@tolgee/core 4.7.3 → 4.8.3-rc.a861236.0

package/dist/Constants/Global.d.ts

@@ -0,0 +1,6 @@
+export declare const RESTRICTED_ASCENDANT_ATTRIBUTE = "data-tolgee-restricted";
+export declare const TOLGEE_ATTRIBUTE_NAME = "_tolgee";
+export declare const TOLGEE_TARGET_ATTRIBUTE = "_tolgee-target";
+export declare const TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE = "data-tolgee-key-only";
+export declare const TOLGEE_HIGHLIGHTER_CLASS = "_tolgee-highlighter";
+export declare const DEVTOOLS_ID = "__tolgee_dev_tools";

package/dist/Constants/ModifierKey.d.ts

@@ -0,0 +1,6 @@
+export declare enum ModifierKey {
+    Alt = 0,
+    Control = 1,
+    Shift = 2,
+    Meta = 3
+}

package/dist/Errors/ApiHttpError.d.ts

@@ -0,0 +1,5 @@
+export declare class ApiHttpError extends Error {
+    response: Response;
+    code?: string;
+    constructor(response: Response, code?: string);
+}

package/dist/Observer.d.ts

@@ -0,0 +1,14 @@
+import { Properties } from './Properties';
+import { ElementRegistrar } from './services/ElementRegistrar';
+import { AbstractWrapper } from './wrappers/AbstractWrapper';
+export declare class Observer {
+    private properties;
+    private textWrapper;
+    private nodeRegistrar;
+    constructor(properties: Properties, textWrapper: AbstractWrapper, nodeRegistrar: ElementRegistrar);
+    private _observer;
+    private _observing;
+    private get observer();
+    observe(): void;
+    stopObserving(): void;
+}

package/dist/Observer.test.d.ts

@@ -0,0 +1,2 @@
+import '@testing-library/jest-dom/extend-expect';
+import 'regenerator-runtime/runtime.js';

package/dist/Properties.d.ts

@@ -0,0 +1,17 @@
+import { TolgeeConfig } from './TolgeeConfig';
+import { Mode, Scope } from './types';
+export declare class Properties {
+    config: TolgeeConfig;
+    scopes?: Scope[];
+    projectId?: number;
+    permittedLanguageIds?: number[];
+    mode?: Mode;
+    _currentLanguage?: string;
+    get currentLanguage(): string;
+    set currentLanguage(language: string);
+    get preferredLanguages(): Set<string>;
+    set preferredLanguages(languages: Set<string>);
+    private getInitialLanguage;
+    private getStoredLanguage;
+    private getLanguageByNavigator;
+}

package/dist/Properties.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/dist/Tolgee.d.ts

@@ -0,0 +1,68 @@
+import { TolgeeConfig } from './TolgeeConfig';
+import { InstantProps, InstantPropsTags, TolgeeModule, TranslateProps, TranslatePropsTags, TranslationTags, TranslationParams, TranslationParamsTags } from './types';
+export declare class Tolgee {
+    private dependencyService;
+    private constructor();
+    get properties(): import("./Properties").Properties;
+    get lang(): string;
+    /**
+     * This sets a new language.
+     *
+     * Using this setter can behave buggy when you change languages
+     * too fast, since it changes the language property before
+     * translations are actually loaded.
+     * @deprecated use asynchronous changeLanguage method.
+     */
+    set lang(newLanguage: string);
+    get defaultLanguage(): string;
+    get onLangChange(): import("./services/EventEmitter").EventEmitter<string>;
+    get onTranslationChange(): import("./services/EventEmitter").EventEmitter<import(".").TranslationData>;
+    /**
+     * Is emitted when language is loaded for the first time
+     */
+    get onLangLoaded(): import("./services/EventEmitter").EventEmitter<string>;
+    /**
+     * True if loading is needed to wait for Tolgee init.
+     * When translation data are provided statically (using import
+     * as staticData config property) then there is no need for translation
+     * fetching so initial loading is not needed at all.
+     */
+    get initialLoading(): boolean;
+    private get coreService();
+    static use(module: TolgeeModule): Tolgee;
+    static init(config: TolgeeConfig): Tolgee;
+    /**
+     * Sets the new language.
+     *
+     * Emits the onLangChange and onLangChangeAndLoad events after
+     * the translations are loaded.
+     *
+     * @return Promise<void> Resolves when translations are loaded
+     */
+    changeLanguage(newLanguage: string): Promise<void>;
+    use(module: TolgeeModule): this;
+    init(config: TolgeeConfig): this;
+    run(): Promise<void>;
+    refresh(): Promise<void>;
+    translate(props: TranslateProps): Promise<string>;
+    translate<T>(props: TranslatePropsTags<T>): Promise<TranslationTags<T>>;
+    translate(key: string, params?: TranslationParams, noWrap?: boolean, defaultValue?: string): Promise<string>;
+    translate<T>(key: string, params?: TranslationParamsTags<T>, noWrap?: boolean, defaultValue?: string): Promise<TranslationTags<T>>;
+    wrap(key: string, params?: TranslationParams, defaultValue?: string | undefined, translation?: string): string;
+    wrap<T>(key: string, params?: TranslationTags<T>, defaultValue?: string | undefined, translation?: TranslationTags<T>): TranslationTags<T>;
+    instant(key: string, params?: TranslationParams, noWrap?: boolean, orEmpty?: boolean, defaultValue?: string): string;
+    instant<T>(key: string, params?: TranslationParamsTags<T>, noWrap?: boolean, orEmpty?: boolean, defaultValue?: string): TranslationTags<T>;
+    instant(props: InstantProps): string;
+    instant<T>(props: InstantPropsTags<T>): TranslationTags<T>;
+    /**
+     * Get currently cached translations for all languages
+     */
+    getCachedTranslations(): Map<string, import("./types").Translations>;
+    /**
+     * Loads translations for given language or returns them from cache
+     * @returns Loaded translations
+     */
+    loadTranslations(lang: string): Promise<import("./types").Translations>;
+    stop: () => void;
+    private emitLangChangeEvent;
+}

package/dist/Tolgee.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/dist/TolgeeConfig.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" />
+import { TreeTranslationsData } from './types';
+import { ModifierKey } from './Constants/ModifierKey';
+import { Mode } from 'fs';
+declare type UiConstructor = new (...args: any[]) => any;
+interface UiLibInterface {
+    UI: UiConstructor;
+}
+declare type UiType = UiConstructor | UiLibInterface | Promise<UiConstructor> | Promise<UiLibInterface>;
+export declare class TolgeeConfig {
+    /**
+     * @deprecated This option won't have any effect,
+     * because mode is now automatically detected when apiKey + apiUrl are set
+     */
+    mode?: Mode;
+    apiUrl?: string;
+    apiKey?: string;
+    inputPrefix?: string;
+    inputSuffix?: string;
+    /**
+     * Overrides all language settings
+     */
+    forceLanguage?: string;
+    /**
+     * Used when auto detection is not available or is turned off
+     */
+    defaultLanguage?: string;
+    /**
+     * Languages which can be used for language detection
+     * and also limits which values can be stored
+     */
+    availableLanguages?: string[];
+    /**
+     * Language which is used when no translation is available for current one
+     */
+    fallbackLanguage?: string;
+    /**
+     * Store user language in localStorage (default: true)
+     */
+    enableLanguageStore?: boolean;
+    /**
+     * Use auto language detection by browser locale (default: true)
+     */
+    enableLanguageDetection?: boolean;
+    filesUrlPrefix?: string;
+    watch?: boolean;
+    ui?: UiType;
+    targetElement?: Element;
+    tagAttributes?: {
+        [key: string]: string[];
+    };
+    highlightKeys?: ModifierKey[];
+    passToParent?: (keyof HTMLElementTagNameMap)[] | ((node: Element) => boolean);
+    restrictedElements?: string[];
+    highlightColor?: string;
+    highlightWidth?: number;
+    /** localization data to use in production mode */
+    staticData?: {
+        [key: string]: TreeTranslationsData | (() => Promise<TreeTranslationsData>);
+    };
+    wrapperMode?: 'text' | 'invisible';
+    /**
+     * When true, fallback language will be preloaded on Tolgee.run
+     */
+    preloadFallback?: boolean;
+    private _targetElement?;
+    constructor(config?: TolgeeConfig);
+}
+export {};

package/dist/TolgeeConfig.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__integration/FormatterIcu.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/dist/__integration/FormatterMissing.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/dist/__integration/Tolgee.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/dist/__integration/TolgeeInvisible.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/dist/__integration/mockTranslations.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    en: {
+        peter_dogs: string;
+        hello_world: string;
+    };
+};
+export default _default;

package/dist/__integration/testConfig.d.ts

@@ -0,0 +1,9 @@
+export declare const testConfig: {
+    id: number;
+    key: string;
+    username: string;
+    userFullName: string;
+    projectId: number;
+    projectName: string;
+    scopes: string[];
+};

package/dist/__testFixtures/classMock.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jest" />
+declare const _default: <T>(implementationFn: () => Partial<T>, baseConstructor?: new (...args: any[]) => any) => jest.Mock<any, any>;
+export default _default;

package/dist/__testFixtures/createElement.d.ts

@@ -0,0 +1,2 @@
+import { ElementWithMeta } from '../types';
+export declare const createElement: (nodesCount: number, keysCount: number, sameKeys?: boolean) => ElementWithMeta;

package/dist/__testFixtures/createTestDom.d.ts

@@ -0,0 +1,9 @@
+export declare const createTestDom: (document: Document) => {
+    keyInRoot: string;
+    keyInRootDiv: string;
+    hereKey: string;
+    hereTooKey: string;
+    appendedKey: string;
+    ariaLabelKey: string;
+    optionKey: string;
+};

package/dist/__testFixtures/mocked.d.ts

@@ -0,0 +1,20 @@
+import { TolgeeConfig } from '../TolgeeConfig';
+import { Properties } from '../Properties';
+import { CoreService } from '../services/CoreService';
+import { Observer } from '../Observer';
+import { TranslationService } from '../services/TranslationService';
+import { TextService } from '../services/TextService';
+import { EventService } from '../services/EventService';
+import { EventEmitterImpl } from '../services/EventEmitter';
+import { ContentHandler } from '../wrappers/text/ContentHandler';
+export declare const configMock: import("jest-mock").MockedObject<typeof TolgeeConfig>;
+export declare const propertiesMock: import("jest-mock").MockedObject<typeof Properties>;
+export declare const coreServiceMock: import("jest-mock").MockedObject<typeof CoreService>;
+export declare const observerMock: import("jest-mock").MockedObject<typeof Observer>;
+export declare const translationServiceMock: import("jest-mock").MockedObject<typeof TranslationService>;
+export declare const textServiceMock: import("jest-mock").MockedObject<typeof TextService>;
+export declare const eventServiceMock: import("jest-mock").MockedObject<typeof EventService>;
+export declare const eventEmitterMock: import("jest-mock").MockedObject<typeof EventEmitterImpl>;
+export declare const tolgeeConfigMock: import("jest-mock").MockedObject<typeof TolgeeConfig>;
+export declare const textHandlerMock: import("jest-mock").MockedObject<typeof ContentHandler>;
+export declare const getMockedInstance: <T>(constructor: new (...args: any[]) => T) => T;

package/dist/__testFixtures/setupAfterEnv.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            toBeFoundIn(contextNode: Node): R;
+        }
+    }
+}
+export {};

package/dist/helpers/NodeHelper.d.ts

@@ -0,0 +1,14 @@
+import { ArgumentTypes } from './commonTypes';
+export declare class NodeHelper {
+    static evaluate<T extends Node>(...args: ArgumentTypes<typeof NodeHelper.evaluateGenerator>): T[];
+    static evaluateToSingle<T extends Node>(...args: ArgumentTypes<typeof NodeHelper.evaluateGenerator>): T;
+    static closestElement(node: Element | Text): Element;
+    static getParentElement(node: Node): Element | undefined;
+    static isElementTargetElement(element: Element): boolean;
+    static markElementAsTargetElement(element: Element): void;
+    static unmarkElementAsTargetElement(element: Element): void;
+    static nodeContains(descendant: Node, node: Node): boolean;
+    private static evaluateGenerator;
+    static getNodeText(node: Node): string;
+    static setNodeText(node: Node, text: string): void;
+}

package/dist/helpers/TextHelper.d.ts

@@ -0,0 +1,5 @@
+export declare class TextHelper {
+    static splitOnNonEscapedDelimiter(string: string, delimiter: string): string[];
+    static isCharEscaped(position: number, fullString: string): boolean;
+    static removeEscapes(string: string): string;
+}

package/dist/helpers/TextHelper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/commonTypes.d.ts

@@ -0,0 +1,2 @@
+export declare type ArgumentTypes<F extends Function> = F extends (...args: infer A) => any ? A : never;
+export declare type ThenArg<T> = T extends PromiseLike<infer U> ? U : T;

package/dist/helpers/encoderPolyfill.d.ts

@@ -0,0 +1,8 @@
+export declare const Encoder: {
+    new (): TextEncoder;
+    prototype: TextEncoder;
+};
+export declare const Decoder: {
+    new (label?: string, options?: TextDecoderOptions): TextDecoder;
+    prototype: TextDecoder;
+};

package/dist/helpers/secret.d.ts

@@ -0,0 +1,6 @@
+export declare const INVISIBLE_CHARACTERS: string[];
+export declare const INVISIBLE_REGEX: RegExp;
+export declare const encodeMessage: (text: string) => string;
+export declare const decodeFromText: (text: string) => string[];
+export declare const removeSecrets: (text: string) => string;
+export declare const stringToCodePoints: (text: string) => number[];

package/dist/helpers/secret.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/sleep.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (ms: number) => Promise<unknown>;

package/dist/highlighter/HighlightFunctionsInitializer.d.ts

@@ -0,0 +1,10 @@
+import { Properties } from '../Properties';
+import { ElementWithMeta } from '../types';
+export declare class HighlightFunctionsInitializer {
+    private properties;
+    constructor(properties: Properties);
+    initFunctions(element: ElementWithMeta): void;
+    borderElement: HTMLDivElement | null;
+    private initHighlightFunction;
+    private initUnhighlightFunction;
+}

package/dist/highlighter/HighlightFunctionsInitializer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/highlighter/MouseEventHandler.d.ts

@@ -0,0 +1,29 @@
+import { DependencyService } from '../services/DependencyService';
+export declare class MouseEventHandler {
+    private dependencies;
+    private keysDown;
+    private highlighted;
+    private mouseOnChanged;
+    private keysChanged;
+    private cursorPosition;
+    constructor(dependencies: DependencyService);
+    run(): void;
+    stop(): void;
+    private readonly highlight;
+    private readonly unhighlight;
+    private updateHighlight;
+    private updateCursorPosition;
+    private blockEvents;
+    private onMouseMove;
+    private onBlur;
+    private onKeyDown;
+    private onKeyUp;
+    private onScroll;
+    private onClick;
+    private initEventListeners;
+    private removeEventListeners;
+    private isInUiDialog;
+    private getClosestTolgeeElement;
+    private findAncestor;
+    private areKeysDown;
+}

package/dist/highlighter/MouseEventHandler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/highlighter/TranslationHighlighter.d.ts

@@ -0,0 +1,14 @@
+import { ElementWithMeta } from '../types';
+import { PluginManager } from '../toolsManager/PluginManager';
+import { DependencyService } from '../services/DependencyService';
+export declare class TranslationHighlighter {
+    private dependencies;
+    pluginManager: PluginManager;
+    private _renderer;
+    constructor(dependencies: DependencyService);
+    private static getKeyOptions;
+    listen(element: ElementWithMeta & ElementCSSInlineStyle): void;
+    private getRenderer;
+    private getKeyAndDefault;
+    translationEdit: (e: MouseEvent, element: ElementWithMeta) => Promise<void>;
+}

package/dist/highlighter/TranslationHighlighter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { Tolgee } from './Tolgee';
+export { TolgeeConfig } from './TolgeeConfig';
+export { ModifierKey } from './Constants/ModifierKey';
+export { TOLGEE_WRAPPED_ONLY_DATA_ATTRIBUTE } from './Constants/Global';
+export * from './modules';
+export * from './types/DTOs';
+export * from './types';
+export * from './Constants/Global';
+export * from './helpers/NodeHelper';
+export * from './helpers/TextHelper';

package/dist/internal.d.ts

@@ -0,0 +1,2 @@
+export { NodeHelper } from './helpers/NodeHelper';
+export { TextHelper } from './helpers/TextHelper';

package/dist/modules/IcuFormatter.d.ts

@@ -0,0 +1,2 @@
+import { TolgeeModule } from '../types';
+export declare const IcuFormatter: TolgeeModule;

package/dist/modules/index.d.ts

@@ -0,0 +1 @@
+export { IcuFormatter } from './IcuFormatter';

package/dist/services/ApiHttpService.d.ts

@@ -0,0 +1,15 @@
+import { Properties } from '../Properties';
+import { ArgumentTypes } from '../helpers/commonTypes';
+declare type FetchArgumentTypes = ArgumentTypes<typeof fetch>;
+declare type Tail<T extends any[]> = ((...args: T) => any) extends (_: infer First, ...rest: infer Rest) => any ? T extends any[] ? Rest : ReadonlyArray<Rest[number]> : [];
+export declare class ApiHttpService {
+    private properties;
+    constructor(properties: Properties);
+    private static handleErrors;
+    fetch(...args: ArgumentTypes<typeof fetch>): Promise<Response>;
+    fetchJson(...args: ArgumentTypes<typeof fetch>): Promise<any>;
+    post(url: any, body: any, init?: FetchArgumentTypes[1], ...rest: Tail<Tail<FetchArgumentTypes>>): Promise<Response>;
+    postJson(url: any, body: any, init?: FetchArgumentTypes[1], ...rest: Tail<Tail<FetchArgumentTypes>>): Promise<any>;
+    private getUrl;
+}
+export {};

package/dist/services/CoreService.d.ts

@@ -0,0 +1,18 @@
+import { Properties } from '../Properties';
+import { ApiHttpService } from './ApiHttpService';
+import { Scope } from '../types';
+import { LanguageModel } from '../types/DTOs';
+import { components } from '../types/apiSchema.generated';
+export declare type ApiKeyWithLanguagesModel = components['schemas']['ApiKeyWithLanguagesModel'];
+export declare class CoreService {
+    private properties;
+    private apiHttpService;
+    private languagePromise;
+    constructor(properties: Properties, apiHttpService: ApiHttpService);
+    getLanguages(): Promise<Set<string>>;
+    getLanguagesFull(): Promise<LanguageModel[]>;
+    getApiKeyDetails(): Promise<ApiKeyWithLanguagesModel>;
+    isAuthorizedTo(scope: Scope): boolean;
+    checkScope(scope: Scope): void;
+    loadApiKeyDetails(): Promise<void>;
+}

package/dist/services/CoreService.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/dist/services/DependencyService.d.ts

@@ -0,0 +1,39 @@
+import { Properties } from '../Properties';
+import { EventService } from './EventService';
+import { ApiHttpService } from './ApiHttpService';
+import { TranslationService } from './TranslationService';
+import { TextService } from './TextService';
+import { MouseEventHandler } from '../highlighter/MouseEventHandler';
+import { TranslationHighlighter } from '../highlighter/TranslationHighlighter';
+import { ElementRegistrar } from './ElementRegistrar';
+import { Observer } from '../Observer';
+import { CoreService } from './CoreService';
+import { TolgeeConfig } from '../TolgeeConfig';
+import { PluginManager } from '../toolsManager/PluginManager';
+import { Messages } from '../toolsManager/Messages';
+import { HighlightFunctionsInitializer } from '../highlighter/HighlightFunctionsInitializer';
+import { ScreenshotService } from './ScreenshotService';
+import { ModuleService } from './ModuleService';
+import { AbstractWrapper } from '../wrappers/AbstractWrapper';
+export declare class DependencyService {
+    properties: Properties;
+    eventService: EventService;
+    apiHttpService: ApiHttpService;
+    mouseEventHandler: MouseEventHandler;
+    moduleService: ModuleService;
+    coreService: CoreService;
+    screenshotService: ScreenshotService;
+    translationService: TranslationService;
+    textService: TextService;
+    highlightFunctionInitializer: HighlightFunctionsInitializer;
+    translationHighlighter: TranslationHighlighter;
+    elementRegistrar: ElementRegistrar;
+    messages: Messages;
+    pluginManager: PluginManager;
+    constructor();
+    wrapper: AbstractWrapper;
+    observer: Observer;
+    init(config: TolgeeConfig): void;
+    run: () => void;
+    stop: () => void;
+}

package/dist/services/DependencyService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/ElementRegistrar.d.ts

@@ -0,0 +1,19 @@
+import { ElementWithMeta } from '../types';
+import { Properties } from '../Properties';
+import { TranslationHighlighter } from '../highlighter/TranslationHighlighter';
+import { EventService } from './EventService';
+export declare class ElementRegistrar {
+    private properties;
+    private translationHighlighter;
+    private eventService;
+    private registeredElements;
+    constructor(properties: Properties, translationHighlighter: TranslationHighlighter, eventService: EventService);
+    register(element: ElementWithMeta): void;
+    refreshAll(): void;
+    cleanAll(): void;
+    findAllByKey(key: string): ElementWithMeta[];
+    private cleanElementInactiveNodes;
+    private cleanElement;
+    private getActiveNodes;
+    private isElementActive;
+}

package/dist/services/ElementRegistrar.test.d.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom/extend-expect';

package/dist/services/EventEmitter.d.ts

@@ -0,0 +1,13 @@
+import { Subscription } from './Subscription';
+export declare type CallbackType<T> = (data: T) => Promise<void> | void;
+export interface EventEmitter<T> {
+    subscribe(callback: CallbackType<T>): Subscription;
+}
+export declare class EventEmitterImpl<T> {
+    private idCounter;
+    private _subscriptions;
+    private get subscriptions();
+    emit(data?: T): Promise<void> | void;
+    subscribe(callback: CallbackType<T>): Subscription;
+    private unsubscribe;
+}

package/dist/services/EventService.d.ts

@@ -0,0 +1,9 @@
+import { EventEmitter } from './EventEmitter';
+import { TranslationData } from '../types/DTOs';
+import { ElementWithMeta } from '../types';
+export declare class EventService {
+    readonly TRANSLATION_CHANGED: EventEmitter<TranslationData>;
+    readonly LANGUAGE_CHANGED: EventEmitter<string>;
+    readonly LANGUAGE_LOADED: EventEmitter<string>;
+    readonly ELEMENT_REGISTERED: EventEmitter<ElementWithMeta>;
+}

package/dist/services/ModuleService.d.ts

@@ -0,0 +1,5 @@
+import { Formatter, TolgeeModule } from '../types';
+export declare class ModuleService {
+    formatter: Formatter | null;
+    addModule: (module: TolgeeModule) => void;
+}

package/dist/services/ScreenshotService.d.ts

@@ -0,0 +1,15 @@
+import { ApiHttpService } from './ApiHttpService';
+import { CoreService } from './CoreService';
+export declare class ScreenshotService {
+    private coreService;
+    private apiHttpService;
+    constructor(coreService: CoreService, apiHttpService: ApiHttpService);
+    uploadImage(blob: Blob): Promise<{
+        id: number;
+        filename: string;
+        fileUrl: string;
+        requestFilename: string;
+        createdAt: string;
+    }>;
+    deleteImages(ids: number[]): Promise<Response>;
+}

package/dist/services/Subscription.d.ts

@@ -0,0 +1,5 @@
+export declare class Subscription {
+    private onUnsubscribe;
+    constructor(onUnsubscribe: () => void);
+    unsubscribe(): void;
+}

package/dist/services/TextService.d.ts

@@ -0,0 +1,14 @@
+import { TranslationTags, TranslationParamsTags } from '../types';
+import { TranslationService } from './TranslationService';
+import { Properties } from '../Properties';
+import { ModuleService } from './ModuleService';
+export declare class TextService {
+    private properties;
+    private translationService;
+    private moduleService;
+    constructor(properties: Properties, translationService: TranslationService, moduleService: ModuleService);
+    translate(key: string, params: TranslationParamsTags<any>, lang?: string, orEmpty?: boolean, defaultValue?: string): Promise<TranslationTags<any>>;
+    instant(key: string, params: TranslationParamsTags<any>, lang?: string, orEmpty?: boolean, defaultValue?: string): TranslationTags<any>;
+    private formatTranslation;
+    private readonly format;
+}

package/dist/services/TextService.test.d.ts

@@ -0,0 +1 @@
+export {};