angular-intlayer 9.4.3 → 9.4.4

package/dist/cjs/UI/IntlayerNode.component.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_decorateMetadata = require('../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorateMetadata.cjs');
-const require_decorate = require('../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorate.cjs');
+const require_decorateMetadata = require('../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.cjs');
+const require_decorate = require('../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.cjs');
 let _angular_core = require("@angular/core");
 
 //#region src/UI/IntlayerNode.component.ts

package/dist/cjs/_virtual/{_@oxc-project_runtime@0.147.0 → _@oxc-project_runtime@0.148.0}/helpers/esm/decorate.cjs

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.147.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/cjs/_virtual/{_@oxc-project_runtime@0.147.0 → _@oxc-project_runtime@0.148.0}/helpers/esm/decorateMetadata.cjs

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.147.0/helpers/esm/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorateMetadata.js
 function __decorateMetadata(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }

package/dist/cjs/editor/ContentSelector.component.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_decorateMetadata = require('../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorateMetadata.cjs');
-const require_decorate = require('../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorate.cjs');
+const require_decorateMetadata = require('../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.cjs');
+const require_decorate = require('../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.cjs');
 let _angular_core = require("@angular/core");
 
 //#region src/editor/ContentSelector.component.ts

package/dist/cjs/editor/EditorProvider.component.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_decorateMetadata = require('../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorateMetadata.cjs');
-const require_decorate = require('../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorate.cjs');
+const require_decorateMetadata = require('../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.cjs');
+const require_decorate = require('../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.cjs');
 const require_editor_useEditor = require('./useEditor.cjs');
 let _angular_core = require("@angular/core");
 

package/dist/cjs/html/installIntlayerHTML.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_decorate = require('../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorate.cjs');
+const require_decorate = require('../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.cjs');
 let _angular_core = require("@angular/core");
 
 //#region src/html/installIntlayerHTML.ts

package/dist/cjs/markdown/installIntlayerMarkdown.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_decorate = require('../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorate.cjs');
+const require_decorate = require('../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.cjs');
 let _intlayer_core_markdown = require("@intlayer/core/markdown");
 let _angular_core = require("@angular/core");
 

package/dist/esm/UI/IntlayerNode.component.mjs

@@ -1,5 +1,5 @@
-import __decorateMetadata from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorateMetadata.mjs";
-import __decorate from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorate.mjs";
+import __decorateMetadata from "../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.mjs";
+import __decorate from "../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.mjs";
 import { ChangeDetectorRef, Component, ElementRef, Input, ViewContainerRef, inject } from "@angular/core";
 
 //#region src/UI/IntlayerNode.component.ts

package/dist/esm/_virtual/{_@oxc-project_runtime@0.147.0 → _@oxc-project_runtime@0.148.0}/helpers/esm/decorate.mjs

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.147.0/helpers/esm/decorate.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorate.js
 function __decorate(decorators, target, key, desc) {
 	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
 	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);

package/dist/esm/_virtual/{_@oxc-project_runtime@0.147.0 → _@oxc-project_runtime@0.148.0}/helpers/esm/decorateMetadata.mjs

@@ -1,4 +1,4 @@
-//#region \0@oxc-project+runtime@0.147.0/helpers/esm/decorateMetadata.js
+//#region \0@oxc-project+runtime@0.148.0/helpers/esm/decorateMetadata.js
 function __decorateMetadata(k, v) {
 	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }

package/dist/esm/editor/ContentSelector.component.mjs

@@ -1,5 +1,5 @@
-import __decorateMetadata from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorateMetadata.mjs";
-import __decorate from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorate.mjs";
+import __decorateMetadata from "../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.mjs";
+import __decorate from "../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.mjs";
 import { CUSTOM_ELEMENTS_SCHEMA, Component, Input } from "@angular/core";
 
 //#region src/editor/ContentSelector.component.ts

package/dist/esm/editor/EditorProvider.component.mjs

@@ -1,5 +1,5 @@
-import __decorateMetadata from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorateMetadata.mjs";
-import __decorate from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorate.mjs";
+import __decorateMetadata from "../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorateMetadata.mjs";
+import __decorate from "../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.mjs";
 import { useEditor } from "./useEditor.mjs";
 import { Component } from "@angular/core";
 

package/dist/esm/html/installIntlayerHTML.mjs

@@ -1,4 +1,4 @@
-import __decorate from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorate.mjs";
+import __decorate from "../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.mjs";
 import { Injectable, InjectionToken, inject } from "@angular/core";
 
 //#region src/html/installIntlayerHTML.ts

package/dist/esm/markdown/installIntlayerMarkdown.mjs

@@ -1,4 +1,4 @@
-import __decorate from "../_virtual/_@oxc-project_runtime@0.147.0/helpers/esm/decorate.mjs";
+import __decorate from "../_virtual/_@oxc-project_runtime@0.148.0/helpers/esm/decorate.mjs";
 import { compile, parseMarkdown as parseMarkdown$1, renderMarkdownAst } from "@intlayer/core/markdown";
 import { Injectable, InjectionToken, inject } from "@angular/core";
 

package/dist/types/UI/IntlayerNode.component.d.ts

@@ -13,7 +13,7 @@ import { OnChanges, SimpleChanges } from "@angular/core";
  * <h1><intlayer-node [node]="content().title"></intlayer-node></h1>
  * ```
  */
-declare class IntlayerNodeComponent implements OnChanges {
+export declare class IntlayerNodeComponent implements OnChanges {
   node: any;
   private vcr;
   private elRef;
@@ -22,5 +22,4 @@ declare class IntlayerNodeComponent implements OnChanges {
   private render;
 }
 //#endregion
-export { IntlayerNodeComponent };
 //# sourceMappingURL=IntlayerNode.component.d.ts.map

package/dist/types/UI/IntlayerNode.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IntlayerNode.component.d.ts","names":[],"sources":["../../../src/UI/IntlayerNode.component.ts"],"mappings":";;;;;;;;;;;;;;;cAkCa,iCAAiC;EACnC;UAED;UACA;UACA;EAER,YAAY,SAAS;UAMb"}
+{"version":3,"file":"IntlayerNode.component.d.ts","names":[],"sources":["../../../src/UI/IntlayerNode.component.ts"],"mappings":";;;;;;;;;;;;;;;qBAkCa,iCAAiC;EACnC;UAED;UACA;UACA;EAER,YAAY,SAAS;UAMb"}

package/dist/types/analytics/exposureSink.d.ts

@@ -5,28 +5,27 @@ import { KeyPath } from "@intlayer/types/keyPath";
  * only) so the interpreter hot path in `plugins.ts` never statically imports
  * `@intlayer/analytics` — the package stays optional and tree-shakeable.
  */
-type ExposureInput = {
+export type ExposureInput = {
   dictionaryKey: string;
   keyPath: KeyPath[];
   locale?: string;
   nodeType?: string;
 };
 /** Consumer of exposure reports, installed by `useAnalytics` after init. */
-type ExposureSink = (input: ExposureInput) => void;
+export type ExposureSink = (input: ExposureInput) => void;
 /**
  * Installs (or clears) the exposure sink. `useAnalytics` sets this once the
  * analytics client has loaded, and clears it on unmount.
  *
  * @param next - The sink to install, or `null` to clear.
  */
-declare const setExposureSink: (next: ExposureSink | null) => void;
+export declare const setExposureSink: (next: ExposureSink | null) => void;
 /**
  * Forwards a content exposure to the installed sink. A cheap null-check when
  * analytics is not running, so it is safe to call from every node resolution.
  *
  * @param input - The node metadata to report.
  */
-declare const reportExposure: (input: ExposureInput) => void;
+export declare const reportExposure: (input: ExposureInput) => void;
 //#endregion
-export { ExposureInput, ExposureSink, reportExposure, setExposureSink };
 //# sourceMappingURL=exposureSink.d.ts.map

package/dist/types/analytics/exposureSink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exposureSink.d.ts","names":[],"sources":["../../../src/analytics/exposureSink.ts"],"mappings":";;;;;;;KAOY;EACV;EACA,SAAS;EACT;EACA;;;KAIU,gBAAgB,OAAO;;;;;;;cAUtB,kBAAe,MAAU;;;;;;;cAUzB,iBAAc,OAAW"}
+{"version":3,"file":"exposureSink.d.ts","names":[],"sources":["../../../src/analytics/exposureSink.ts"],"mappings":";;;;;;;YAOY;EACV;EACA,SAAS;EACT;EACA;;;YAIU,gBAAgB,OAAO;;;;;;;qBAUtB,kBAAe,MAAU;;;;;;;qBAUzB,iBAAc,OAAW"}

package/dist/types/analytics/useAnalytics.d.ts

@@ -12,7 +12,7 @@ import { IntlayerProvider } from "../client/intlayerToken.js";
  *   When omitted the function injects `INTLAYER_TOKEN` from the DI tree,
  *   so it still works when called directly from a component.
  */
-declare const useAnalytics: (client?: IntlayerProvider | null) => void;
+export declare const useAnalytics: (client?: IntlayerProvider | null) => void;
 /**
  * Angular provider that wires `useAnalytics` into the application
  * initialisation phase via `provideAppInitializer`.
@@ -30,7 +30,6 @@ declare const useAnalytics: (client?: IntlayerProvider | null) => void;
  * };
  * ```
  */
-declare const provideIntlayerAnalytics: (client?: IntlayerProvider | null) => import("@angular/core").EnvironmentProviders;
+export declare const provideIntlayerAnalytics: (client?: IntlayerProvider | null) => import("@angular/core").EnvironmentProviders;
 //#endregion
-export { provideIntlayerAnalytics, useAnalytics };
 //# sourceMappingURL=useAnalytics.d.ts.map

package/dist/types/analytics/useAnalytics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAnalytics.d.ts","names":[],"sources":["../../../src/analytics/useAnalytics.ts"],"mappings":";;;;;;;;;;;;;;cA4Ba,eAAY,SAAa;;;;;;;;;;;;;;;;;;cAkGzB,2BAAwB,SAAa,oDAAuB"}
+{"version":3,"file":"useAnalytics.d.ts","names":[],"sources":["../../../src/analytics/useAnalytics.ts"],"mappings":";;;;;;;;;;;;;;qBA4Ba,eAAY,SAAa;;;;;;;;;;;;;;;;;;qBAkGzB,2BAAwB,SAAa,oDAAuB"}

package/dist/types/analytics/useConversion.d.ts

@@ -2,7 +2,7 @@
 /**
  * Parameters describing a conversion to record.
  */
-type ConversionParams = {
+export type ConversionParams = {
   /** The experiment this conversion is attributed to. */
   experimentKey: string;
   /** The variant the session was assigned. */
@@ -32,7 +32,6 @@ type ConversionParams = {
  * }
  * ```
  */
-declare const useConversion: () => (params: ConversionParams) => void;
+export declare const useConversion: () => (params: ConversionParams) => void;
 //#endregion
-export { ConversionParams, useConversion };
 //# sourceMappingURL=useConversion.d.ts.map

package/dist/types/analytics/useConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useConversion.d.ts","names":[],"sources":["../../../src/analytics/useConversion.ts"],"mappings":";;;;KAKY;;EAEV;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;cAuBW,sBAAa,QACR"}
+{"version":3,"file":"useConversion.d.ts","names":[],"sources":["../../../src/analytics/useConversion.ts"],"mappings":";;;;YAKY;;EAEV;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;;;;;;;;qBAuBW,sBAAa,QACR"}

package/dist/types/analytics/useExperiment.d.ts

@@ -3,7 +3,7 @@ import { Signal } from "@angular/core";
 /**
  * The state of an A/B experiment for the current session.
  */
-type ExperimentState = {
+export type ExperimentState = {
   /**
    * The variant assigned to this session. Until assignment resolves (and on
    * the server, or when analytics is disabled), this is the first variant —
@@ -41,7 +41,6 @@ type ExperimentState = {
  * }
  * ```
  */
-declare const useExperiment: (experimentKey: string, variants: string[], weights?: number[]) => ExperimentState;
+export declare const useExperiment: (experimentKey: string, variants: string[], weights?: number[]) => ExperimentState;
 //#endregion
-export { ExperimentState, useExperiment };
 //# sourceMappingURL=useExperiment.d.ts.map

package/dist/types/analytics/useExperiment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useExperiment.d.ts","names":[],"sources":["../../../src/analytics/useExperiment.ts"],"mappings":";;;;;KAMY;;;;;;EAMV,SAAS;;;;;;EAMT,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BD,gBAAa,uBACH,oBACH,uBAEjB"}
+{"version":3,"file":"useExperiment.d.ts","names":[],"sources":["../../../src/analytics/useExperiment.ts"],"mappings":";;;;;YAMY;;;;;;EAMV,SAAS;;;;;;EAMT,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2BD,gBAAa,uBACH,oBACH,uBAEjB"}

package/dist/types/client/installIntlayer.d.ts

@@ -31,14 +31,14 @@ import { LocalesValues, ProviderVariant } from "@intlayer/types/module_augmentat
  * };
  * ```
  */
-declare const provideIntlayer: (locale?: LocalesValues, isCookieEnabled?: boolean, variant?: ProviderVariant) => (import("@angular/core").EnvironmentProviders | {
+export declare const provideIntlayer: (locale?: LocalesValues, isCookieEnabled?: boolean, variant?: ProviderVariant) => (import("@angular/core").EnvironmentProviders | {
   provide: import("@angular/core").InjectionToken<IntlayerProvider>;
   useValue: IntlayerProvider;
 })[];
 /**
  * Helper to install the Intlayer provider.
  */
-declare const installIntlayer: (locale?: LocalesValues, isCookieEnabled?: boolean, variant?: ProviderVariant) => IntlayerProvider;
+export declare const installIntlayer: (locale?: LocalesValues, isCookieEnabled?: boolean, variant?: ProviderVariant) => IntlayerProvider;
 //#endregion
-export { INTLAYER_TOKEN, IntlayerProvider, createIntlayerClient, installIntlayer, provideIntlayer };
+export { INTLAYER_TOKEN, IntlayerProvider, createIntlayerClient };
 //# sourceMappingURL=installIntlayer.d.ts.map

package/dist/types/client/installIntlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"installIntlayer.d.ts","names":[],"sources":["../../../src/client/installIntlayer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4Ca,kBAAe,SACjB,eAAa,2BAAA,UAEZ,6CAAe;;;;;;;cAcd,kBAAe,SACjB,eAAa,2BAAA,UAEZ,oBAAe"}
+{"version":3,"file":"installIntlayer.d.ts","names":[],"sources":["../../../src/client/installIntlayer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4Ca,kBAAe,SACjB,eAAa,2BAAA,UAEZ,6CAAe;;;;;;;qBAcd,kBAAe,SACjB,eAAa,2BAAA,UAEZ,oBAAe"}

package/dist/types/client/intlayerToken.d.ts

@@ -1,7 +1,7 @@
 import { InjectionToken, Signal } from "@angular/core";
 import { LocalesValues, ProviderVariant } from "@intlayer/types/module_augmentation";
 //#region src/client/intlayerToken.d.ts
-declare class IntlayerProvider {
+export declare class IntlayerProvider {
   isCookieEnabled: import("@angular/core").WritableSignal<boolean>;
   private _locale;
   private _variant;
@@ -15,11 +15,10 @@ declare class IntlayerProvider {
   setLocale: (locale: LocalesValues) => void;
   setVariant: (variant: ProviderVariant | undefined) => void;
 }
-declare const INTLAYER_TOKEN: InjectionToken<IntlayerProvider>;
+export declare const INTLAYER_TOKEN: InjectionToken<IntlayerProvider>;
 /**
  * Create and return a single IntlayerProvider instance
  */
-declare const createIntlayerClient: (locale?: LocalesValues, isCookieEnabled?: boolean, variant?: ProviderVariant) => IntlayerProvider;
+export declare const createIntlayerClient: (locale?: LocalesValues, isCookieEnabled?: boolean, variant?: ProviderVariant) => IntlayerProvider;
 //#endregion
-export { INTLAYER_TOKEN, IntlayerProvider, createIntlayerClient };
 //# sourceMappingURL=intlayerToken.d.ts.map

package/dist/types/client/intlayerToken.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerToken.d.ts","names":[],"sources":["../../../src/client/intlayerToken.ts"],"mappings":";;;cAQa;EACX,yCAAe;UACP;UAIA;WAEC,QAAQ,OAAO;;;;;WAMf,SAAS,OAAO;EAGzB;EAIA,YAAS,QAAY;EAIrB,aAAU,SAAa;;cAKZ,gBAAc,eAAA;;;;cAUd,uBAAoB,SACtB,eAAa,2BAAA,UAEZ,oBACT"}
+{"version":3,"file":"intlayerToken.d.ts","names":[],"sources":["../../../src/client/intlayerToken.ts"],"mappings":";;;qBAQa;EACX,yCAAe;UACP;UAIA;WAEC,QAAQ,OAAO;;;;;WAMf,SAAS,OAAO;EAGzB;EAIA,YAAS,QAAY;EAIrB,aAAU,SAAa;;qBAKZ,gBAAc,eAAA;;;;qBAUd,uBAAoB,SACtB,eAAa,2BAAA,UAEZ,oBACT"}

package/dist/types/client/useDictionary.d.ts

@@ -7,7 +7,6 @@ import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup, Resol
  * Angular hook that transforms a dictionary (or qualified dictionary group)
  * and returns its reactive content for the given locale or selector.
  */
-declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => Signal<DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>>;
+export declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => Signal<DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>>;
 //#endregion
-export { useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/client/useDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;;;;;;cAqBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,OACD,qBACE,kCAAkC,GAAG,IACrC,sBAAsB"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;;;;;;qBAqBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,OACD,qBACE,kCAAkC,GAAG,IACrC,sBAAsB"}

package/dist/types/client/useDictionaryAsync.d.ts

@@ -6,7 +6,6 @@ import { Dictionary } from "@intlayer/types/dictionary";
  *
  * If the locale is not provided, it will use the locale from the client context
  */
-declare const useDictionaryAsync: <const T extends Dictionary>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: LocalesValues) => Promise<import("@angular/core").Signal<unknown>>;
+export declare const useDictionaryAsync: <const T extends Dictionary>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: LocalesValues) => Promise<import("@angular/core").Signal<unknown>>;
 //#endregion
-export { useDictionaryAsync };
 //# sourceMappingURL=useDictionaryAsync.d.ts.map

package/dist/types/client/useDictionaryAsync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/client/useDictionaryAsync.ts"],"mappings":";;;;;;;;cAiBa,2BAAkC,UAAU,YAAU,mBAC9C,0BAA0B,QAAQ,KAAG,SAC/C,kBAAa,gCAAA"}
+{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/client/useDictionaryAsync.ts"],"mappings":";;;;;;;;qBAiBa,2BAAkC,UAAU,YAAU,mBAC9C,0BAA0B,QAAQ,KAAG,SAC/C,kBAAa,gCAAA"}

package/dist/types/client/useDictionaryDynamic.d.ts

@@ -13,7 +13,6 @@ import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator"
  * If the locale is not provided (directly or through the selector), it will use
  * the locale from the client context.
  */
-declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: K, localeOrSelector?: A) => import("@angular/core").Signal<any>;
+export declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: K, localeOrSelector?: A) => import("@angular/core").Signal<any>;
 //#endregion
-export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

package/dist/types/client/useDictionaryDynamic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;cAoCa,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa,8BAAC"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;qBAoCa,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa,8BAAC"}

package/dist/types/client/useIntlayer.d.ts

@@ -3,7 +3,7 @@ import { Signal } from "@angular/core";
 import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, DictionarySelectorForKey, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/client/useIntlayer.d.ts
 /** guard utility - true only for objects generated by `renderIntlayerNode()` */
-declare const isUpdatableNode: (val: unknown) => val is {
+export declare const isUpdatableNode: (val: unknown) => val is {
   __update: (n: unknown) => void;
 };
 /**
@@ -31,7 +31,6 @@ declare const isUpdatableNode: (val: unknown) => val is {
  * }
  * ```
  */
-declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => Signal<DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>>;
+export declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => Signal<DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>>;
 //#endregion
-export { isUpdatableNode, useIntlayer };
 //# sourceMappingURL=useIntlayer.d.ts.map

package/dist/types/client/useIntlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;cAea,kBAAe,iBAEzB;EAAS,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BV,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,OACD,qBAAqB,yBAAyB,GAAG,IAAI,sBAAsB"}
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;qBAea,kBAAe,iBAEzB;EAAS,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8BV,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,OACD,qBAAqB,yBAAyB,GAAG,IAAI,sBAAsB"}

package/dist/types/client/useLoadDynamic.d.ts

@@ -5,7 +5,6 @@
  * - Immediately returns a reactive signal so that Angular can properly track changes.
  * - When the Promise resolves, it replaces the signal's value with the real data.
  */
-declare const useLoadDynamic: <T extends Record<string, any>>(key: string, promise: Promise<T>) => T;
+export declare const useLoadDynamic: <T extends Record<string, any>>(key: string, promise: Promise<T>) => T;
 //#endregion
-export { useLoadDynamic };
 //# sourceMappingURL=useLoadDynamic.d.ts.map

package/dist/types/client/useLoadDynamic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"mappings":";;;;;;;cAQa,iBAAkB,UAAU,qBAAmB,aAC/C,SACF,QAAQ,OAChB"}
+{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"mappings":";;;;;;;qBAQa,iBAAkB,UAAU,qBAAmB,aAC/C,SACF,QAAQ,OAChB"}

package/dist/types/client/useLocale.d.ts

@@ -1,11 +1,11 @@
 import { Signal } from "@angular/core";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/client/useLocale.d.ts
-type UseLocaleProps = {
+export type UseLocaleProps = {
   isCookieEnabled?: boolean;
   onLocaleChange?: (locale: DeclaredLocales) => void;
 };
-type UseLocaleResult = {
+export type UseLocaleResult = {
   locale: Signal<DeclaredLocales>;
   defaultLocale: DeclaredLocales;
   availableLocales: DeclaredLocales[];
@@ -38,7 +38,6 @@ type UseLocaleResult = {
  * }
  * ```
  */
-declare const useLocale: ({ isCookieEnabled, onLocaleChange }?: UseLocaleProps) => UseLocaleResult;
+export declare const useLocale: ({ isCookieEnabled, onLocaleChange }?: UseLocaleProps) => UseLocaleResult;
 //#endregion
-export { UseLocaleProps, UseLocaleResult, useLocale };
 //# sourceMappingURL=useLocale.d.ts.map

package/dist/types/client/useLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;;KASY;EACV;EACA,kBAAkB,QAAQ;;KAGhB;EACV,QAAQ,OAAO;EACf,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BT,cAAS,iBAAA,mBAGnB,mBAAsB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;;YASY;EACV;EACA,kBAAkB,QAAQ;;YAGhB;EACV,QAAQ,OAAO;EACf,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8BT,cAAS,iBAAA,mBAGnB,mBAAsB"}

package/dist/types/client/useLocaleStorage.d.ts

@@ -1,4 +1,3 @@
-import { Locale } from "../intlayer/dist/types/index.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/client/useLocaleStorage.d.ts
 /**
@@ -7,28 +6,28 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 /**
  * Get the locale cookie
  */
-declare const localeInStorage: Locale;
+export declare const localeInStorage: import("@intlayer/types").Locale;
 /**
  * @deprecated Use localeInStorage instead
  *
  * Get the locale cookie
  */
-declare const localeCookie: Locale;
+export declare const localeCookie: import("@intlayer/types").Locale;
 /**
  * Set the locale cookie
  */
-declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled: boolean) => void;
+export declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled: boolean) => void;
 /**
  * @deprecated Use setLocaleInStorage instead
  *
  * Set the locale cookie
  */
-declare const setLocaleCookie: typeof setLocaleInStorage;
+export declare const setLocaleCookie: typeof setLocaleInStorage;
 /**
  * Hook that provides the locale storage and a function to set it
  */
-declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
-  getLocale: () => Locale;
+export declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
+  getLocale: () => import("@intlayer/types").Locale;
   setLocale: (locale: LocalesValues) => void;
 };
 /**
@@ -38,10 +37,9 @@ declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
  *
  * Hook that provides the locale cookie and a function to set it
  */
-declare const useLocaleCookie: (isCookieEnabled?: boolean) => {
-  localeCookie: Locale;
+export declare const useLocaleCookie: (isCookieEnabled?: boolean) => {
+  localeCookie: import("@intlayer/types").Locale;
   setLocaleCookie: (locale: LocalesValues) => void;
 };
 //#endregion
-export { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage };
 //# sourceMappingURL=useLocaleStorage.d.ts.map

package/dist/types/client/useLocaleStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;;;cAca,iBAAA;;;;;;cAMA,cAAA;;;;cAKA,qBAAkB,QACrB,eAAa;;;;;;cAaV,wBAAe;;;;cAKf,mBAAgB;mBAAhB;sBAAA;;;;;;;;;cAaA,kBAAe;EAIxB,cAJS;EAKT,kBAAe,QAAA"}
+{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;;qBAca,2CAAe;;;;;;qBAMf,wCAAY;;;;qBAKZ,qBAAkB,QACrB,eAAa;;;;;;qBAaV,wBAAe;;;;qBAKf,mBAAgB;;sBAAhB;;;;;;;;;qBAaA,kBAAe;EAIxB,wCAAY;EACZ,kBAAe,QAAA"}

package/dist/types/client/usePathname.d.ts

@@ -29,7 +29,6 @@ import { Signal } from "@angular/core";
  * }
  * ```
  */
-declare const usePathname: () => Signal<string>;
+export declare const usePathname: () => Signal<string>;
 //#endregion
-export { usePathname };
 //# sourceMappingURL=usePathname.d.ts.map

package/dist/types/client/usePathname.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePathname.d.ts","names":[],"sources":["../../../src/client/usePathname.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCa,mBAAkB"}
+{"version":3,"file":"usePathname.d.ts","names":[],"sources":["../../../src/client/usePathname.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsCa,mBAAkB"}

package/dist/types/editor/ContentSelector.component.d.ts

@@ -1,9 +1,8 @@
 //#region src/editor/ContentSelector.component.d.ts
-declare class ContentSelectorWrapperComponent {
+export declare class ContentSelectorWrapperComponent {
   dictionaryKey: string;
   keyPath: any[];
   get keyPathJson(): string;
 }
 //#endregion
-export { ContentSelectorWrapperComponent };
 //# sourceMappingURL=ContentSelector.component.d.ts.map

package/dist/types/editor/ContentSelector.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContentSelector.component.d.ts","names":[],"sources":["../../../src/editor/ContentSelector.component.ts"],"mappings":";cAea;EACF;EACA;MAEL"}
+{"version":3,"file":"ContentSelector.component.d.ts","names":[],"sources":["../../../src/editor/ContentSelector.component.ts"],"mappings":";qBAea;EACF;EACA;MAEL"}

package/dist/types/editor/EditorProvider.component.d.ts

@@ -25,9 +25,8 @@
  * export class AppComponent {}
  * ```
  */
-declare class EditorProviderComponent {
+export declare class EditorProviderComponent {
   constructor();
 }
 //#endregion
-export { EditorProviderComponent };
 //# sourceMappingURL=EditorProvider.component.d.ts.map

package/dist/types/editor/EditorProvider.component.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EditorProvider.component.d.ts","names":[],"sources":["../../../src/editor/EditorProvider.component.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCa;EACX"}
+{"version":3,"file":"EditorProvider.component.d.ts","names":[],"sources":["../../../src/editor/EditorProvider.component.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkCa;EACX"}

package/dist/types/editor/useEditor.d.ts

@@ -12,7 +12,7 @@ import { IntlayerProvider } from "../client/intlayerToken.js";
  *   When omitted the function injects `INTLAYER_TOKEN` from the DI tree,
  *   so it still works when called directly from a component.
  */
-declare const useEditor: (client?: IntlayerProvider | null) => void;
+export declare const useEditor: (client?: IntlayerProvider | null) => void;
 /**
  * Angular provider that wires `useEditor` into the application initialisation
  * phase via `provideAppInitializer`.
@@ -30,7 +30,6 @@ declare const useEditor: (client?: IntlayerProvider | null) => void;
  * };
  * ```
  */
-declare const provideIntlayerEditor: (client?: IntlayerProvider | null) => import("@angular/core").EnvironmentProviders;
+export declare const provideIntlayerEditor: (client?: IntlayerProvider | null) => import("@angular/core").EnvironmentProviders;
 //#endregion
-export { provideIntlayerEditor, useEditor };
 //# sourceMappingURL=useEditor.d.ts.map

package/dist/types/editor/useEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useEditor.d.ts","names":[],"sources":["../../../src/editor/useEditor.ts"],"mappings":";;;;;;;;;;;;;;cA4Ba,YAAS,SAAa;;;;;;;;;;;;;;;;;;cAiEtB,wBAAqB,SAAa,oDAAuB"}
+{"version":3,"file":"useEditor.d.ts","names":[],"sources":["../../../src/editor/useEditor.ts"],"mappings":";;;;;;;;;;;;;;qBA4Ba,YAAS,SAAa;;;;;;;;;;;;;;;;;;qBAiEtB,wBAAqB,SAAa,oDAAuB"}

package/dist/types/esbuild/plugin.d.ts

@@ -1,6 +1,6 @@
 import { GetConfigurationOptions } from "@intlayer/config/node";
 //#region src/esbuild/plugin.d.ts
-interface EsbuildPluginBuild {
+export interface EsbuildPluginBuild {
   initialOptions: {
     alias?: Record<string, string>;
     define?: Record<string, string>;
@@ -38,11 +38,11 @@ interface EsbuildPluginBuild {
     loader?: string;
   } | null | undefined>): void;
 }
-interface EsbuildPlugin {
+export interface EsbuildPlugin {
   name: string;
   setup(build: EsbuildPluginBuild): void | Promise<void>;
 }
-type IntlayerEsbuildPluginOptions = {
+export type IntlayerEsbuildPluginOptions = {
   configOptions?: GetConfigurationOptions;
   /**
    * Whether to start the Intlayer file watcher for dictionary regeneration.
@@ -75,7 +75,6 @@ type IntlayerEsbuildPluginOptions = {
  * export default [intlayerEsbuildPlugin()];
  * ```
  */
-declare const intlayerEsbuildPlugin: (options?: IntlayerEsbuildPluginOptions) => EsbuildPlugin;
+export declare const intlayerEsbuildPlugin: (options?: IntlayerEsbuildPluginOptions) => EsbuildPlugin;
 //#endregion
-export { EsbuildPlugin, EsbuildPluginBuild, IntlayerEsbuildPluginOptions, intlayerEsbuildPlugin };
 //# sourceMappingURL=plugin.d.ts.map

package/dist/types/esbuild/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","names":[],"sources":["../../../src/esbuild/plugin.ts"],"mappings":";;UAiDiB;EACf;IACE,QAAQ;IACR,SAAS;IACT;IACA;;IAEA;;EAEF,QAAQ,uBAAuB;;EAE/B,UACE;IAAW,QAAQ;IAAQ;KAC3B,WAAW;IACT;IACA;IACA;IACA;;IACM;IAAc;;;EAGxB,OACE;IAAW,QAAQ;IAAQ;KAC3B,WAAW;IACT;IACA;;IAEI;IAAkB;yBAGpB;IAAU;IAAkB;;;UAInB;EACf;EACA,MAAM,OAAO,4BAA4B;;KAG/B;EACV,gBAAgB;;;;;;;;EAQhB;;;;;;;;;;;;;;;;;;;;;;;;cAyBW,wBAAqB,UACtB,iCACT"}
+{"version":3,"file":"plugin.d.ts","names":[],"sources":["../../../src/esbuild/plugin.ts"],"mappings":";;iBAiDiB;EACf;IACE,QAAQ;IACR,SAAS;IACT;IACA;;IAEA;;EAEF,QAAQ,uBAAuB;;EAE/B,UACE;IAAW,QAAQ;IAAQ;KAC3B,WAAW;IACT;IACA;IACA;IACA;;IACM;IAAc;;;EAGxB,OACE;IAAW,QAAQ;IAAQ;KAC3B,WAAW;IACT;IACA;;IAEI;IAAkB;yBAGpB;IAAU;IAAkB;;;iBAInB;EACf;EACA,MAAM,OAAO,4BAA4B;;YAG/B;EACV,gBAAgB;;;;;;;;EAQhB;;;;;;;;;;;;;;;;;;;;;;;;qBAyBW,wBAAqB,UACtB,iCACT"}

package/dist/types/format/useCompact.d.ts

@@ -1,8 +1,6 @@
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/format/useCompact.d.ts
-declare const useCompact: () => import("@angular/core").Signal<(value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: LocalesValues;
+export declare const useCompact: () => import("@angular/core").Signal<(value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string>;
 //#endregion
-export { useCompact };
 //# sourceMappingURL=useCompact.d.ts.map