@tolgee/core 5.0.0-rc.9be0f0e.0 → 5.0.0

package/lib/Controller/Cache/Cache.d.ts

@@ -1,23 +1,24 @@
-import { CacheDescriptor, CacheDescriptorInternal, CacheDescriptorWithKey, EventEmitterType, FallbackNSTranslation, Options, TranslationsFlat, TranslationValue, TreeTranslationsData, BackendGetRecord, BackendGetDevRecord } from '../../types';
+import { CacheDescriptor, CacheDescriptorInternal, CacheDescriptorWithKey, NsFallback, TranslationsFlat, TranslationValue, TreeTranslationsData, BackendGetRecord, BackendGetDevRecord } from '../../types';
+import { EventEmitterInstance } from '../Events/EventEmitter';
+import { TolgeeStaticData } from '../State/initState';
 import { ValueObserverInstance } from '../ValueObserver';
-export declare const Cache: (onCacheChange: EventEmitterType<CacheDescriptorWithKey>, backendGetRecord: BackendGetRecord, backendGetDevRecord: BackendGetDevRecord, withDefaultNs: (descriptor: CacheDescriptor) => CacheDescriptorInternal, isInitialLoading: () => boolean, fetchingObserver: ValueObserverInstance<boolean>, loadingObserver: ValueObserverInstance<boolean>) => Readonly<{
-    addStaticData: (data: Options['staticData']) => void;
+export declare const Cache: (onCacheChange: EventEmitterInstance<CacheDescriptorWithKey>, backendGetRecord: BackendGetRecord, backendGetDevRecord: BackendGetDevRecord, withDefaultNs: (descriptor: CacheDescriptor) => CacheDescriptorInternal, isInitialLoading: () => boolean, fetchingObserver: ValueObserverInstance<boolean>, loadingObserver: ValueObserverInstance<boolean>) => Readonly<{
+    addStaticData: (data: TolgeeStaticData | undefined) => void;
     invalidate: () => void;
     addRecord: (descriptor: CacheDescriptorInternal, data: TreeTranslationsData) => void;
     exists: (descriptor: CacheDescriptorInternal, strict?: boolean) => boolean;
-    getRecord: (descriptor: CacheDescriptorInternal) => TranslationsFlat | undefined;
+    getRecord: (descriptor: CacheDescriptor) => TranslationsFlat | undefined;
     getTranslation: (descriptor: CacheDescriptorInternal, key: string) => TranslationValue;
-    getTranslationNs: (namespaces: string[], languages: string[], key: string) => string | string[];
+    getTranslationNs: (namespaces: string[], languages: string[], key: string) => string[];
     getTranslationFallback: (namespaces: string[], languages: string[], key: string) => string | undefined;
     changeTranslation: (descriptor: CacheDescriptorInternal, key: string, value: TranslationValue) => void;
-    isFetching: (ns?: FallbackNSTranslation) => boolean;
-    isLoading: (language: string | undefined, ns?: FallbackNSTranslation) => boolean;
+    isFetching: (ns?: NsFallback) => boolean;
+    isLoading: (language: string | undefined, ns?: NsFallback) => boolean;
     loadRecords: (descriptors: CacheDescriptor[], isDev: boolean) => Promise<TranslationsFlat[]>;
-    clear: () => void;
     getAllRecords: () => {
         data: TranslationsFlat;
         language: string;
         namespace: string;
     }[];
 }>;
-export declare type CacheType = ReturnType<typeof Cache>;
+export declare type CacheInstance = ReturnType<typeof Cache>;

package/lib/Controller/Controller.d.ts

@@ -1,93 +1,152 @@
-import type { EventServiceType } from '../Events/Events';
-import { CacheDescriptor, FallbackNSTranslation, Options, TFnType, TranslatePropsInternal } from '../types';
+import { CacheDescriptor, NsFallback, TolgeeOptions, TFnType, KeyAndNamespacesInternal } from '../types';
 declare type StateServiceProps = {
-    events: EventServiceType;
-    options?: Partial<Options>;
+    options?: Partial<TolgeeOptions>;
 };
-export declare const Controller: ({ events, options }: StateServiceProps) => Readonly<{
-    init: (options: Partial<Options>) => void;
+export declare const Controller: ({ options }: StateServiceProps) => Readonly<{
+    init: (options: Partial<TolgeeOptions>) => void;
     changeLanguage: (language: string) => Promise<void>;
-    getTranslation: ({ key, ns, }: Pick<TranslatePropsInternal, 'key' | 'ns'>) => string | undefined;
+    getTranslation: ({ key, ns }: KeyAndNamespacesInternal) => string | undefined;
     changeTranslation: (descriptor: CacheDescriptor, key: string, value: string) => {
         revert: () => void;
     };
-    addActiveNs: (ns: FallbackNSTranslation, forget?: boolean) => Promise<void>;
-    loadRequiredRecords: (lang?: string, ns?: FallbackNSTranslation) => void | Promise<void>;
+    addActiveNs: (ns: NsFallback, forget?: boolean) => Promise<void>;
     loadRecords: (descriptors: CacheDescriptor[]) => Promise<import("../types").TranslationsFlat[]>;
     loadRecord: (descriptor: CacheDescriptor) => Promise<import("../types").TranslationsFlat>;
-    isLoading: (ns?: FallbackNSTranslation) => boolean;
-    isLoaded: (ns?: FallbackNSTranslation) => boolean;
+    isLoading: (ns?: NsFallback) => boolean;
+    isLoaded: (ns?: NsFallback) => boolean;
     t: TFnType<import("../types").DefaultParamType, string>;
     isDev: () => boolean;
     run: () => Promise<void | undefined>;
     stop: () => void;
-    addStaticData: (data: {
-        [key: string]: import("../types").TreeTranslationsData | (() => Promise<import("../types").TreeTranslationsData>);
-    } | undefined) => void;
+    addStaticData: (data: import("./State/initState").TolgeeStaticData | undefined) => void;
     invalidate: () => void;
     addRecord: (descriptor: import("../types").CacheDescriptorInternal, data: import("../types").TreeTranslationsData) => void;
     exists: (descriptor: import("../types").CacheDescriptorInternal, strict?: boolean) => boolean;
-    getRecord: (descriptor: import("../types").CacheDescriptorInternal) => import("../types").TranslationsFlat | undefined;
-    getTranslationNs: (namespaces: string[], languages: string[], key: string) => string | string[];
+    getRecord: (descriptor: CacheDescriptor) => import("../types").TranslationsFlat | undefined;
+    getTranslationNs: (namespaces: string[], languages: string[], key: string) => string[];
     getTranslationFallback: (namespaces: string[], languages: string[], key: string) => string | undefined;
-    isFetching: (ns?: FallbackNSTranslation) => boolean;
-    clear: () => void;
+    isFetching: (ns?: NsFallback) => boolean;
     getAllRecords: () => {
         data: import("../types").TranslationsFlat;
         language: string;
         namespace: string;
     }[];
-    setFinalFormatter: (formatter: import("../types").FinalFormatterInterface | undefined) => void;
-    addFormatter: (formatter: import("../types").FormatterInterface | undefined) => void;
-    formatTranslation: ({ key, translation, defaultValue, noWrap, params, orEmpty, ns, formatEnabled, }: {
+    addPlugin: (tolgeeInstance: Readonly<{
+        on: import("../types").TolgeeOn<keyof import("../types").EventType>;
+        onNsUpdate: (handler: import("../types").Listener<undefined>) => import("../types").SubscriptionSelective;
+        setEmmiterActive: (active: boolean) => void;
+        getLanguage: () => string | undefined;
+        getPendingLanguage: () => string | undefined;
+        changeLanguage: (language: string) => Promise<void>;
+        changeTranslation: (descriptor: CacheDescriptor, key: string, value: string) => {
+            revert: () => void;
+        };
+        addActiveNs: (ns: NsFallback, forget?: boolean) => Promise<void>;
+        removeActiveNs: (ns: NsFallback) => void;
+        loadRecords: (descriptors: CacheDescriptor[]) => Promise<import("../types").TranslationsFlat[]>;
+        loadRecord: (descriptor: CacheDescriptor) => Promise<import("../types").TranslationsFlat>;
+        addStaticData: (data: import("./State/initState").TolgeeStaticData | undefined) => void;
+        getRecord: (descriptor: CacheDescriptor) => import("../types").TranslationsFlat | undefined;
+        getAllRecords: () => {
+            data: import("../types").TranslationsFlat;
+            language: string;
+            namespace: string;
+        }[];
+        isLoaded: (ns?: NsFallback) => boolean;
+        isInitialLoading: () => boolean;
+        isLoading: (ns?: NsFallback) => boolean;
+        isFetching: (ns?: NsFallback) => boolean;
+        isRunning: () => boolean;
+        run: () => Promise<void | undefined>;
+        stop: () => void;
+        t: TFnType<import("../types").DefaultParamType, string>;
+        highlight: import("../types").HighlightInterface;
+        getInitialOptions: () => {
+            apiUrl?: string | undefined;
+            apiKey?: string | undefined;
+            projectId?: string | number | undefined;
+            language?: string | undefined;
+            defaultLanguage?: string | undefined;
+            availableLanguages?: string[] | undefined;
+            fallbackLanguage?: import("../types").FallbackLanguageOption;
+            ns?: string[] | undefined;
+            fallbackNs?: import("../types").FallbackGeneral;
+            defaultNs: string;
+            staticData?: import("./State/initState").TolgeeStaticData | undefined;
+            observerType: "invisible" | "text";
+            observerOptions: import("./State/observerOptions").ObserverOptionsInternal;
+            onFormatError: import("../types").OnFormatError;
+        };
+        isDev: () => boolean;
+        wrap: (params: import("../types").WrapperWrapProps) => string | undefined;
+        unwrap: (text: string) => import("../types").Unwrapped;
+        overrideCredentials(credentials: import("../types").DevCredentials): void;
+        addPlugin(plugin: import("../types").TolgeePlugin | undefined): void;
+        updateOptions(options?: TolgeeOptions | undefined): void;
+    }>, plugin: import("../types").TolgeePlugin) => void;
+    formatTranslation: ({ formatEnabled, ...props }: {
         key: string;
         defaultValue?: string | undefined;
-    } & import("../types").TranslateOptions<import("../types").DefaultParamType> & {
+        params?: import("../types").TranslateParams<import("../types").DefaultParamType> | undefined;
+    } & import("../types").TranslateOptions & {
         translation?: string | undefined;
     } & {
         formatEnabled?: boolean | undefined;
     }) => string;
-    setObserver: (observer: import("../types").ObserverInterface | undefined) => void;
-    getObserver: () => {
-        unwrap: (text: string) => import("../types").Unwrapped;
-        wrap: import("../types").WrapperWrapFunction;
-        retranslate: () => void;
-        stop: () => void;
-        run: (props: import("../types").ObserverRunProps) => void;
-        highlight: import("../types").HighlightInterface;
-        outputNotFormattable: boolean;
-    } | undefined;
-    setUi: (ui: import("../types").UiType | undefined) => void;
-    getUi: () => import("../types").UiConstructor | undefined;
-    addBackend: (backend: import("../types").BackendInterface | undefined) => void;
-    setDevBackend: (backend: import("../types").BackendDevInterface | undefined) => void;
-    getDevBackend: () => import("../types").BackendDevInterface | undefined;
+    getDevBackend: () => import("../types").BackendDevMiddleware | undefined;
     getBackendRecord: import("../types").BackendGetRecord;
     getBackendDevRecord: import("../types").BackendGetRecord;
-    setLanguageDetector: (detector: import("../types").LanguageDetectorInterface | undefined) => void;
-    setLanguageStorage: (storage: import("../types").LanguageStorageInterface | undefined) => void;
+    getLanguageDetector: () => import("../types").LanguageDetectorMiddleware | undefined;
+    getLanguageStorage: () => import("../types").LanguageStorageMiddleware | undefined;
     getInitialLanguage: () => string | Promise<string | undefined> | Promise<string | Promise<string | undefined> | undefined> | undefined;
     setStoredLanguage: (language: string) => void;
     retranslate: () => void;
     highlight: import("../types").HighlightInterface;
-    wrap: (params: import("../types").WrapperWrapProps) => string | undefined;
     unwrap: (text: string) => import("../types").Unwrapped;
+    wrap: (params: import("../types").WrapperWrapProps) => string | undefined;
+    hasDevBackend: () => boolean;
     isRunning: () => boolean;
     setRunning: (value: boolean) => void;
     isInitialLoading: () => boolean;
     setInitialLoading: (value: boolean) => void;
     getLanguage: () => string | undefined;
-    getLanguageOrFail: () => string;
     setLanguage: (language: string) => void;
     getPendingLanguage: () => string | undefined;
     setPendingLanguage: (language: string) => void;
-    getInitialOptions: () => Options;
-    removeActiveNs: (ns: FallbackNSTranslation) => void;
+    getInitialOptions: () => {
+        apiUrl?: string | undefined;
+        apiKey?: string | undefined;
+        projectId?: string | number | undefined;
+        language?: string | undefined;
+        defaultLanguage?: string | undefined;
+        availableLanguages?: string[] | undefined;
+        fallbackLanguage?: import("../types").FallbackLanguageOption;
+        ns?: string[] | undefined;
+        fallbackNs?: import("../types").FallbackGeneral;
+        defaultNs: string;
+        staticData?: import("./State/initState").TolgeeStaticData | undefined;
+        observerType: "invisible" | "text";
+        observerOptions: import("./State/observerOptions").ObserverOptionsInternal;
+        onFormatError: import("../types").OnFormatError;
+    };
+    removeActiveNs: (ns: NsFallback) => void;
     getRequiredNamespaces: () => string[];
     getFallbackLangs: (lang?: string | undefined) => string[];
-    getFallbackNamespaces: () => string[];
+    getFallbackNs: () => string[];
+    getDefaultNs: (ns?: string | undefined) => string;
     getAvailableLanguages: () => string[] | undefined;
     withDefaultNs: (descriptor: CacheDescriptor) => import("../types").CacheDescriptorInternal;
+    overrideCredentials: (credentials: import("../types").DevCredentials) => void;
+    onPendingLanguageChange: import("./Events/EventEmitter").EventEmitterInstance<string>;
+    onLanguageChange: import("./Events/EventEmitter").EventEmitterInstance<string>;
+    onLoadingChange: import("./Events/EventEmitter").EventEmitterInstance<boolean>;
+    onFetchingChange: import("./Events/EventEmitter").EventEmitterInstance<boolean>;
+    onInitialLoaded: import("./Events/EventEmitter").EventEmitterInstance<void>;
+    onRunningChange: import("./Events/EventEmitter").EventEmitterInstance<boolean>;
+    onCacheChange: import("./Events/EventEmitter").EventEmitterInstance<import("../types").CacheDescriptorWithKey>;
+    onUpdate: import("./Events/EventEmitterSelective").EventEmitterSelectiveInstance;
+    setEmmiterActive: (active: boolean) => void;
+    on: import("../types").TolgeeOn<keyof import("../types").EventType>;
 }>;
-export declare type StateServiceType = ReturnType<typeof Controller>;
+export declare type ControllerInstance = ReturnType<typeof Controller>;
 export {};

package/lib/Controller/Events/EventEmitter.d.ts

@@ -0,0 +1,6 @@
+import { Subscription, Listener } from '../../types';
+export declare const EventEmitter: <T>(isActive: () => boolean) => EventEmitterInstance<T>;
+export declare type EventEmitterInstance<T> = {
+    readonly listen: (handler: Listener<T>) => Subscription;
+    readonly emit: (data: T) => void;
+};

package/lib/Controller/Events/EventEmitterSelective.d.ts

@@ -0,0 +1,7 @@
+import { Subscription, Listener, SubscriptionSelective } from '../../types';
+export declare const EventEmitterSelective: (isActive: () => boolean, getFallbackNs: () => string[], getDefaultNs: () => string) => EventEmitterSelectiveInstance;
+export declare type EventEmitterSelectiveInstance = {
+    readonly listenSome: (handler: Listener<undefined>) => SubscriptionSelective;
+    readonly listen: (handler: Listener<undefined>) => Subscription;
+    readonly emit: (ns?: string[], delayed?: boolean) => void;
+};

package/lib/Controller/Events/Events.d.ts

@@ -0,0 +1,14 @@
+import { CacheDescriptorWithKey, TolgeeOn } from '../../types';
+export declare const Events: (getFallbackNs: () => string[], getDefaultNs: () => string) => Readonly<{
+    onPendingLanguageChange: import("./EventEmitter").EventEmitterInstance<string>;
+    onLanguageChange: import("./EventEmitter").EventEmitterInstance<string>;
+    onLoadingChange: import("./EventEmitter").EventEmitterInstance<boolean>;
+    onFetchingChange: import("./EventEmitter").EventEmitterInstance<boolean>;
+    onInitialLoaded: import("./EventEmitter").EventEmitterInstance<void>;
+    onRunningChange: import("./EventEmitter").EventEmitterInstance<boolean>;
+    onCacheChange: import("./EventEmitter").EventEmitterInstance<CacheDescriptorWithKey>;
+    onUpdate: import("./EventEmitterSelective").EventEmitterSelectiveInstance;
+    setEmmiterActive: (active: boolean) => void;
+    on: TolgeeOn<keyof import("../../types").EventType>;
+}>;
+export declare type EventsInstance = ReturnType<typeof Events>;

package/lib/Controller/Plugins/Plugins.d.ts

@@ -1,41 +1,28 @@
-import { BackendDevInterface, BackendGetRecord, BackendInterface, FormatterInterface, ObserverInterface, TranslatePropsInternal, UiType, FinalFormatterInterface, HighlightInterface, UiConstructor, LanguageDetectorInterface, LanguageStorageInterface, Options, ChangeTranslationInterface, WrapperWrapProps, Unwrapped } from '../../types';
-export declare const PluginService: (getLanguage: () => string | undefined, getInitialOptions: () => Options, getAvailableLanguages: () => string[] | undefined, getTranslationNs: (props: TranslatePropsInternal) => string[] | string, getTranslation: (props: TranslatePropsInternal) => string | undefined, changeTranslation: ChangeTranslationInterface) => Readonly<{
-    setFinalFormatter: (formatter: FinalFormatterInterface | undefined) => void;
-    addFormatter: (formatter: FormatterInterface | undefined) => void;
-    formatTranslation: ({ key, translation, defaultValue, noWrap, params, orEmpty, ns, formatEnabled, }: {
+import { BackendDevMiddleware, BackendGetRecord, TranslatePropsInternal, HighlightInterface, LanguageDetectorMiddleware, LanguageStorageMiddleware, ChangeTranslationInterface, WrapperWrapProps, Unwrapped, KeyAndNamespacesInternal, TolgeePlugin, TolgeeInstance, TolgeeOptionsInternal } from '../../types';
+export declare const Plugins: (getLanguage: () => string | undefined, getInitialOptions: () => TolgeeOptionsInternal, getAvailableLanguages: () => string[] | undefined, getTranslationNs: (props: KeyAndNamespacesInternal) => string[], getTranslation: (props: KeyAndNamespacesInternal) => string | undefined, changeTranslation: ChangeTranslationInterface) => Readonly<{
+    addPlugin: (tolgeeInstance: TolgeeInstance, plugin: TolgeePlugin) => void;
+    formatTranslation: ({ formatEnabled, ...props }: {
         key: string;
         defaultValue?: string | undefined;
-    } & import("../../types").TranslateOptions<import("../../types").DefaultParamType> & {
+        params?: import("../../types").TranslateParams<import("../../types").DefaultParamType> | undefined;
+    } & import("../../types").TranslateOptions & {
         translation?: string | undefined;
     } & {
         formatEnabled?: boolean | undefined;
     }) => string;
-    setObserver: (observer: ObserverInterface | undefined) => void;
-    getObserver: () => {
-        unwrap: (text: string) => Unwrapped;
-        wrap: import("../../types").WrapperWrapFunction;
-        retranslate: () => void;
-        stop: () => void;
-        run: (props: import("../../types").ObserverRunProps) => void;
-        highlight: HighlightInterface;
-        outputNotFormattable: boolean;
-    } | undefined;
-    setUi: (ui: UiType | undefined) => void;
-    getUi: () => UiConstructor | undefined;
-    addBackend: (backend: BackendInterface | undefined) => void;
-    setDevBackend: (backend: BackendDevInterface | undefined) => void;
-    getDevBackend: () => BackendDevInterface | undefined;
+    getDevBackend: () => BackendDevMiddleware | undefined;
     getBackendRecord: BackendGetRecord;
     getBackendDevRecord: BackendGetRecord;
-    setLanguageDetector: (detector: LanguageDetectorInterface | undefined) => void;
-    setLanguageStorage: (storage: LanguageStorageInterface | undefined) => void;
+    getLanguageDetector: () => LanguageDetectorMiddleware | undefined;
+    getLanguageStorage: () => LanguageStorageMiddleware | undefined;
     getInitialLanguage: () => string | Promise<string | undefined> | Promise<string | Promise<string | undefined> | undefined> | undefined;
     setStoredLanguage: (language: string) => void;
     run: () => void;
     stop: () => void;
     retranslate: () => void;
     highlight: HighlightInterface;
-    wrap: (params: WrapperWrapProps) => string | undefined;
     unwrap: (text: string) => Unwrapped;
+    wrap: (params: WrapperWrapProps) => string | undefined;
+    hasDevBackend: () => boolean;
 }>;
-export declare type PluginServiceType = ReturnType<typeof PluginService>;
+export declare type PluginsInstance = ReturnType<typeof Plugins>;

package/lib/Controller/State/State.d.ts

@@ -1,22 +1,40 @@
-import { CacheDescriptor, CacheDescriptorInternal, EventEmitterType, FallbackNSTranslation } from '../../types';
-import { Options } from './initState';
-export declare const State: (onLanguageChange: EventEmitterType<string>, onPendingLanguageChange: EventEmitterType<string>, onRunningChange: EventEmitterType<boolean>) => Readonly<{
-    init: (options?: Partial<Options>) => void;
+import { CacheDescriptor, CacheDescriptorInternal, DevCredentials, NsFallback, NsType } from '../../types';
+import { EventEmitterInstance } from '../Events/EventEmitter';
+import { TolgeeOptions } from './initState';
+export declare const State: (onLanguageChange: EventEmitterInstance<string>, onPendingLanguageChange: EventEmitterInstance<string>, onRunningChange: EventEmitterInstance<boolean>) => Readonly<{
+    init: (options?: Partial<TolgeeOptions>) => void;
     isRunning: () => boolean;
     setRunning: (value: boolean) => void;
     isInitialLoading: () => boolean;
     setInitialLoading: (value: boolean) => void;
     getLanguage: () => string | undefined;
-    getLanguageOrFail: () => string;
     setLanguage: (language: string) => void;
     getPendingLanguage: () => string | undefined;
     setPendingLanguage: (language: string) => void;
-    getInitialOptions: () => Options;
-    addActiveNs: (ns: FallbackNSTranslation) => void;
-    removeActiveNs: (ns: FallbackNSTranslation) => void;
+    getInitialOptions: () => {
+        apiUrl?: string | undefined;
+        apiKey?: string | undefined;
+        projectId?: string | number | undefined;
+        language?: string | undefined;
+        defaultLanguage?: string | undefined;
+        availableLanguages?: string[] | undefined;
+        fallbackLanguage?: import("../../types").FallbackLanguageOption;
+        ns?: string[] | undefined;
+        fallbackNs?: import("../../types").FallbackGeneral;
+        defaultNs: string;
+        staticData?: import("./initState").TolgeeStaticData | undefined;
+        observerType: "invisible" | "text";
+        observerOptions: import("./observerOptions").ObserverOptionsInternal;
+        onFormatError: import("../../types").OnFormatError;
+    };
+    addActiveNs: (ns: NsFallback) => void;
+    removeActiveNs: (ns: NsFallback) => void;
     getRequiredNamespaces: () => string[];
     getFallbackLangs: (lang?: string) => string[];
-    getFallbackNamespaces: () => string[];
+    getFallbackNs: () => string[];
+    getDefaultNs: (ns?: NsType) => string;
     getAvailableLanguages: () => string[] | undefined;
     withDefaultNs: (descriptor: CacheDescriptor) => CacheDescriptorInternal;
+    overrideCredentials: (credentials: DevCredentials) => void;
 }>;
+export declare type StateInstance = ReturnType<typeof State>;

package/lib/Controller/State/initState.d.ts

@@ -1,12 +1,26 @@
-import { FallbackLanguageOption, FallbackNS, TreeTranslationsData } from '../../types';
-export declare type Options = {
+import { FallbackGeneral, FallbackLanguageOption, TreeTranslationsData, OnFormatError } from '../../types';
+import { ObserverOptions, ObserverOptionsInternal } from './observerOptions';
+export declare const DEFAULT_FORMAT_ERROR = "invalid";
+export declare type TolgeeStaticData = {
+    [key: string]: TreeTranslationsData | (() => Promise<TreeTranslationsData>);
+};
+export declare type TolgeeOptionsInternal = {
     /**
      * Initial language
      */
     language?: string;
+    /**
+     * Tolgee instance url (e.g. https://app.tolgee.io)
+     */
     apiUrl?: string;
+    /**
+     * Project API key (PAK) or Personal Access Token (PAT)
+     */
     apiKey?: string;
-    projectId?: number;
+    /**
+     * Project id is necessary if you are using PAT
+     */
+    projectId?: number | string;
     /**
      * Used when auto detection is not available or is turned off
      */
@@ -20,10 +34,6 @@ export declare type Options = {
      * Language which is used when no translation is available for current one
      */
     fallbackLanguage?: FallbackLanguageOption;
-    /**
-     * Store user language in localStorage (default: true)
-     */
-    enableLanguageStore?: boolean;
     /**
      * Namespaces which should be always fetched
      */
@@ -31,25 +41,46 @@ export declare type Options = {
     /**
      * Namespaces to be used to find translation when no explicit namespace set.
      */
-    fallbackNs?: FallbackNS;
+    fallbackNs?: FallbackGeneral;
     /**
      * Default namespace when no namespace defined (default: '')
      */
     defaultNs: string;
     /**
-     * Prefix used for fetching languages (default: 'i18n/')
+     * These data go directly to cache or you can specify async
+     * function which will be used to get the data. Use `:` to add namespace:
+     *
+     * ```ts
+     * {
+     *   'locale': <translations | async function>
+     *   'locale:namespace': <translations | async function>
+     * }
+     * ```
+     */
+    staticData?: TolgeeStaticData;
+    /**
+     * Switches between invisible and text observer. (Default: invisible)
+     */
+    observerType: 'invisible' | 'text';
+    /**
+     * Observer options object.
+     */
+    observerOptions: ObserverOptionsInternal;
+    /**
+     * Define what to display in case of formatting error. (Default: 'invalid')
      */
-    filesUrlPrefix: string;
-    staticData?: {
-        [key: string]: TreeTranslationsData | (() => Promise<TreeTranslationsData>);
-    };
+    onFormatError: OnFormatError;
+};
+export declare type TolgeeOptions = Partial<Omit<TolgeeOptionsInternal, 'observerOptions'>> & {
+    observerOptions?: ObserverOptions;
 };
 export declare type State = {
-    initialOptions: Options;
+    initialOptions: TolgeeOptionsInternal;
     activeNamespaces: Map<string, number>;
     language: string | undefined;
     pendingLanguage: string | undefined;
     isInitialLoading: boolean;
     isRunning: boolean;
 };
-export declare const initState: (options?: Partial<Options>, previousState?: State) => State;
+export declare const combineOptions: <T extends TolgeeOptions>(...states: (T | undefined)[]) => T;
+export declare const initState: (options?: Partial<TolgeeOptions>, previousState?: State) => State;

package/lib/Controller/State/observerOptions.d.ts

@@ -0,0 +1,41 @@
+export declare type ObserverOptionsInternal = {
+    /**
+     * Attributes that are observed on html elements
+     */
+    tagAttributes: Record<string, string[]>;
+    /**
+     * Key(s) which trigger in-context translating (default: ['Alt'])
+     */
+    highlightKeys: ModifierKey[];
+    /**
+     * Color used for key highlighting (default: 'rgb(255, 0, 0)')
+     */
+    highlightColor: string;
+    /**
+     * Highliter border width (default: 5)
+     */
+    highlightWidth: number;
+    /**
+     * Root element which will be observed (default: document.body)
+     */
+    targetElement?: HTMLElement;
+    /**
+     * Elements which are not observed (default: ['script', 'style'])
+     */
+    restrictedElements: string[];
+    /**
+     * Text observer prefix (default: '%-%tolgee:')
+     */
+    inputPrefix: string;
+    /**
+     * Text observer suffix (default: '%-%')
+     */
+    inputSuffix: string;
+    /**
+     * Html elements which will pass click listener to their parent (default: ['option', 'optgroup'])
+     */
+    passToParent: (keyof HTMLElementTagNameMap)[] | ((node: Element) => boolean);
+};
+export declare type ObserverOptions = Partial<ObserverOptionsInternal>;
+export declare type ModifierKey = 'Alt' | 'Control' | 'Shift' | 'Meta';
+export declare const defaultObserverOptions: ObserverOptionsInternal;

package/lib/Controller/ValueObserver.d.ts

@@ -1,5 +1,5 @@
-export declare const ValueObserver: <T = any>(initialValue: T, valueGetter: () => T, handler: (value: T) => void) => Readonly<{
-    init: (value: T) => void;
-    notify: () => void;
-}>;
-export declare type ValueObserverInstance<T> = ReturnType<typeof ValueObserver<T>>;
+export declare const ValueObserver: <T = any>(initialValue: T, valueGetter: () => T, handler: (value: T) => void) => ValueObserverInstance<T>;
+export declare type ValueObserverInstance<T> = {
+    readonly init: (value: T) => void;
+    readonly notify: () => void;
+};

package/lib/FormatSimple/FormatError.d.ts

@@ -0,0 +1,7 @@
+export declare const ERROR_PARAM_EMPTY = 0, ERROR_UNEXPECTED_CHAR = 1, ERROR_UNEXPECTED_END = 2;
+export declare type ErrorCode = typeof ERROR_PARAM_EMPTY | typeof ERROR_UNEXPECTED_CHAR | typeof ERROR_UNEXPECTED_END;
+export declare class FormatError extends Error {
+    readonly code: ErrorCode;
+    readonly index: number;
+    constructor(code: ErrorCode, index: number, text: string);
+}

package/lib/FormatSimple/FormatSimple.d.ts

@@ -0,0 +1,2 @@
+import { TolgeePlugin } from '../types';
+export declare const FormatSimple: () => TolgeePlugin;

package/lib/FormatSimple/formatParser.d.ts

@@ -0,0 +1 @@
+export declare function formatParser(translation: string): string[][];

package/lib/FormatSimple/formatter.d.ts

@@ -0,0 +1,2 @@
+import { DefaultParamType, TranslateParams } from '../types';
+export declare function formatter(translation: string, params?: TranslateParams<DefaultParamType>): string;