@tilde-nlp/ngx-translate 1.0.0

package/lib/modules/tld-audio/services/audio-record.service.d.ts

@@ -0,0 +1,35 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class AudioRecordService {
+    private blobType;
+    private readonly defaultBlobType;
+    private chunks;
+    protected recorderEnded: EventEmitter<any>;
+    private recorder;
+    private timerRef;
+    private recordTimeSeconds;
+    private _recordTimeDate;
+    get recordTimeDate(): Date;
+    private _onRecordingStatusChange;
+    get onRecordingStatusChange(): import("rxjs").Observable<boolean>;
+    private _onRecordStart;
+    get onRecordStart(): import("rxjs").Observable<any>;
+    private _onError;
+    get onError(): import("rxjs").Observable<any>;
+    get isRecording(): boolean;
+    private _isRecording;
+    private static guc;
+    private maxFileSizeBytes;
+    private currentFileSizeBytes;
+    getUserContent(): Promise<MediaStream>;
+    startRecording(dataUpdateTimeFrame: number, maxFileSizeInBytes: number, type?: string): void;
+    stopRecording(): Promise<unknown>;
+    private addListeners;
+    private appendToChunks;
+    private recordingStopped;
+    private clear;
+    private toggleRecordingStatus;
+    private throwError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AudioRecordService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AudioRecordService>;
+}

package/lib/modules/tld-audio/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from './tld-voice-input-api.service';
+export * from './tld-voice-input.service';
+export * from './audio-record.service';

package/lib/modules/tld-audio/services/tld-voice-input-api.service.d.ts

@@ -0,0 +1,16 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { IVoiceToTextJob, IVoiceToTextStartJobRequestParams } from '../../tld-common/models';
+import { TldTranslateConfigService } from '../../tld-common/services';
+import * as i0 from "@angular/core";
+export declare class TldVoiceInputApiService {
+    private readonly http;
+    private readonly config;
+    private get audioConfig();
+    constructor(http: HttpClient, config: TldTranslateConfigService);
+    startJob(params: IVoiceToTextStartJobRequestParams): Observable<IVoiceToTextJob>;
+    getJobInfo(jobId: string): Observable<IVoiceToTextJob>;
+    private mapJob;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldVoiceInputApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TldVoiceInputApiService>;
+}

package/lib/modules/tld-audio/services/tld-voice-input.service.d.ts

@@ -0,0 +1,20 @@
+import { IVoiceToTextJob, IVoiceToTextStartJobRequestParams } from '../../tld-common/models';
+import { ITranscriptionUpdateModel } from '../models/transcription-update.model';
+import { TldVoiceInputApiService } from './tld-voice-input-api.service';
+import * as i0 from "@angular/core";
+export declare class TldVoiceInputService {
+    private readonly api;
+    activeJob: IVoiceToTextJob;
+    isProcessing: boolean;
+    private readonly timeoutMs;
+    private lastTranscribtion;
+    private readonly transcribtionTextUpdated;
+    get onTranscribtionTextUpdated(): import("rxjs").Observable<ITranscriptionUpdateModel>;
+    constructor(api: TldVoiceInputApiService);
+    startTranscribtion(params: IVoiceToTextStartJobRequestParams): void;
+    stopProcessing(): void;
+    private checkProgress;
+    private scheduleProgressCheckIfNecessary;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldVoiceInputService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TldVoiceInputService>;
+}

package/lib/modules/tld-audio/tld-audio.module.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tld-record/tld-record.component";
+import * as i2 from "./tld-dictate/tld-dictate.component";
+import * as i3 from "@angular/common";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "@angular/material/tooltip";
+import * as i6 from "@angular/material/icon";
+import * as i7 from "@angular/flex-layout";
+import * as i8 from "@angular/material/button";
+export declare class TldAudioModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldAudioModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TldAudioModule, [typeof i1.TldRecordComponent, typeof i2.TldDictateComponent], [typeof i3.CommonModule, typeof i4.TranslateModule, typeof i5.MatTooltipModule, typeof i6.MatIconModule, typeof i7.FlexLayoutModule, typeof i8.MatButtonModule], [typeof i1.TldRecordComponent, typeof i2.TldDictateComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TldAudioModule>;
+}

package/lib/modules/tld-audio/tld-dictate/tld-dictate.component.d.ts

@@ -0,0 +1,43 @@
+import { ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { AsrClient } from 'asr-api-client';
+import { AudioErrorCase } from '../models/audio-error-case.model';
+import { IDictateConfiguration } from '../models/dictate-configurationi.model';
+import * as i0 from "@angular/core";
+export declare class TldDictateComponent implements OnInit {
+    onResize(): void;
+    canvasWrapper: ElementRef<any>;
+    recordLength: Date;
+    canvasWidth: number;
+    isProcessing: boolean;
+    hasAnyMicrophone: boolean;
+    asrClient: AsrClient;
+    get maxLength(): number;
+    private _isRecording;
+    get isRecording(): boolean;
+    set isRecording(value: boolean);
+    private _dictatedText;
+    set dictatedText(value: string);
+    get dictatedText(): string;
+    readonly visualizataionId = "dictate-visualization";
+    private interval;
+    /**
+     * Last recognized text
+     */
+    result: EventEmitter<string>;
+    partialResult: EventEmitter<string>;
+    isDictating: EventEmitter<boolean>;
+    onError: EventEmitter<AudioErrorCase>;
+    configuration: IDictateConfiguration;
+    private _language;
+    set language(value: string);
+    constructor();
+    ngOnInit(): void;
+    startRecording(): void;
+    stopRecording(): void;
+    private setCanvasWidth;
+    private findMic;
+    private handleResult;
+    private emitError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldDictateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldDictateComponent, "tld-dictate", never, { "configuration": "configuration"; "language": "language"; }, { "result": "result"; "partialResult": "partialResult"; "isDictating": "isDictating"; "onError": "onError"; }, never, never, false>;
+}

package/lib/modules/tld-audio/tld-record/tld-record.component.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { TldAlertService, TldTranslateConfigService } from '../../tld-common/services';
+import { TldSystemService } from '../../tld-tooltip/services';
+import { AudioRecordService } from '../services/audio-record.service';
+import { TldVoiceInputService } from '../services/tld-voice-input.service';
+import * as i0 from "@angular/core";
+export declare class TldRecordComponent implements OnInit, OnDestroy {
+    private readonly audioRecorderService;
+    private readonly systemService;
+    private readonly configService;
+    private readonly voiceProcessingService;
+    private readonly alert;
+    get isRecording(): boolean;
+    get recordTimeDate(): Date;
+    get isProcessing(): boolean;
+    hasAnyMicrophone: boolean;
+    /**
+     * Successfuly recorded BLOB
+     */
+    record: EventEmitter<Blob>;
+    private recordErrorSubscription;
+    constructor(audioRecorderService: AudioRecordService, systemService: TldSystemService, configService: TldTranslateConfigService, voiceProcessingService: TldVoiceInputService, alert: TldAlertService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    startRecording(): void;
+    stopRecording(): void;
+    cancel(): void;
+    processVoiceRecord(file: Blob): void;
+    private findMic;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldRecordComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldRecordComponent, "tld-record", never, {}, { "record": "record"; }, never, never, false>;
+}

package/lib/modules/tld-common/animations/pulse.animation.d.ts

@@ -0,0 +1 @@
+export declare const pulseAnimation: import("@angular/animations").AnimationTriggerMetadata;

package/lib/modules/tld-common/components/index.d.ts

@@ -0,0 +1,9 @@
+export * from './tld-translate-achievement/tld-translate-achievement.component';
+export * from './tld-loader/tld-loader.component';
+export * from './tld-lang-list/tld-lang-list.component';
+export * from './tld-file-upload/tld-file-upload.component';
+export * from './tld-message/tld-message.component';
+export * from './open-close-button/open-close-button.component';
+export * from './translate-button/translate-button.component';
+export * from './tld-list-menu/tld-list-menu.component';
+export * from './source-and-target-wrapper/source-and-target-wrapper.component';

package/lib/modules/tld-common/components/open-close-button/open-close-button.component.d.ts

@@ -0,0 +1,15 @@
+import { MatButton } from '@angular/material/button';
+import * as i0 from "@angular/core";
+export declare class TldOpenCloseButtonComponent {
+    button: MatButton;
+    private _isOpened;
+    get isOpened(): boolean;
+    disableFocusOnAction: boolean;
+    set isOpened(value: boolean);
+    disabled: boolean;
+    isIcon: boolean;
+    ariaLabelCode: string;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldOpenCloseButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldOpenCloseButtonComponent, "tld-open-close-button", never, { "disableFocusOnAction": "disableFocusOnAction"; "isOpened": "isOpened"; "disabled": "disabled"; "isIcon": "isIcon"; "ariaLabelCode": "ariaLabelCode"; }, {}, never, ["*"], false>;
+}

package/lib/modules/tld-common/components/source-and-target-wrapper/source-and-target-wrapper.component.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { CloseButtonComponent } from '@tilde-nlp/ngx-common';
+import { TextToSpeechSettings } from '../../../../components/shared/text-to-speech/models/text-to-speech-settings.model';
+import * as i0 from "@angular/core";
+export declare class SourceAndTargetWrapperComponent implements OnInit {
+    clearButton: CloseButtonComponent;
+    clearSourceVisible: boolean;
+    clearSourceTooltip: string;
+    clearDisabled: boolean;
+    hideAchievement: boolean;
+    textToSpeechSourceSettings: TextToSpeechSettings;
+    onSourceClear: EventEmitter<any>;
+    constructor();
+    ngOnInit(): void;
+    clearSource(): void;
+    focusClearButton(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SourceAndTargetWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SourceAndTargetWrapperComponent, "tld-source-and-target-wrapper", never, { "clearSourceVisible": "clearSourceVisible"; "clearSourceTooltip": "clearSourceTooltip"; "clearDisabled": "clearDisabled"; "hideAchievement": "hideAchievement"; "textToSpeechSourceSettings": "textToSpeechSourceSettings"; }, { "onSourceClear": "onSourceClear"; }, never, ["[sourceMain]", "[sourceActions]", "[targetMain]", "[targetActions]"], false>;
+}

package/lib/modules/tld-common/components/tld-file-upload/tld-file-upload.component.d.ts

@@ -0,0 +1,28 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import { IFileUploadError } from '../../models';
+import * as i0 from "@angular/core";
+export declare class TldFileUploadComponent {
+    fileInput: ElementRef;
+    inputButton: ElementRef;
+    fileChange: EventEmitter<File[]>;
+    onError: EventEmitter<IFileUploadError>;
+    private _accept;
+    set accept(val: string[]);
+    get accept(): string[];
+    maxSize: number;
+    multiple: boolean;
+    filePreviewProgress: number;
+    allowEmpty: boolean;
+    disabled: boolean;
+    /** same as accept but for registered users. It changes error message if extension is supported for registered users. */
+    extendedAcceptList: string[];
+    allowedExtensions: string;
+    handleFileInput(event: any): void;
+    onFileDrop(files: FileList): void;
+    private emit;
+    private emitError;
+    private validate;
+    private getExtensionErrorCode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldFileUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldFileUploadComponent, "tld-file-upload", never, { "accept": "accept"; "maxSize": "maxSize"; "multiple": "multiple"; "filePreviewProgress": "filePreviewProgress"; "allowEmpty": "allowEmpty"; "disabled": "disabled"; "extendedAcceptList": "extendedAcceptList"; }, { "fileChange": "fileChange"; "onError": "onError"; }, never, ["*"], false>;
+}

package/lib/modules/tld-common/components/tld-lang-list/tld-lang-list.component.d.ts

@@ -0,0 +1,52 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { MatMenu } from '@angular/material/menu';
+import { TranslateService } from '@ngx-translate/core';
+import { ILangListItem, ILanguageWithTranslation, ISelectedLanguage } from '../../models';
+import { TldOpenCloseButtonComponent } from '../open-close-button/open-close-button.component';
+import * as i0 from "@angular/core";
+export declare class TldLangListComponent implements AfterViewInit, OnDestroy {
+    private readonly translate;
+    wrapper: ElementRef;
+    menu: MatMenu;
+    openCloseButton: TldOpenCloseButtonComponent;
+    disabled: boolean;
+    pxPerLanguage: number;
+    set languages(languageList: ILangListItem[]);
+    /** Id for panel class. For testing purposes. */
+    testId: string;
+    private _selected;
+    set selected(val: ISelectedLanguage);
+    get selected(): ISelectedLanguage;
+    private _maxDisplayedLanguages;
+    set maxDisplayedLanguages(val: number);
+    get maxDisplayedLanguages(): number;
+    get firstVisible(): ILanguageWithTranslation;
+    showDomainsWithLanguageName: boolean;
+    onLanguageChange: EventEmitter<string>;
+    onDomainChange: EventEmitter<string>;
+    currentLanguage: string;
+    menuLanguageList: ILanguageWithTranslation[];
+    visibleLanguageList: ILanguageWithTranslation[];
+    readonly menuTriggerAriaCode = "ARIA_LABELS.OTHER_LANGUAGES_TRIGGER";
+    readonly languageLocalizationKey = "LANGUAGES";
+    readonly languageCodePropertyName = "code";
+    private duplicateCodes;
+    private languageList;
+    private readonly destroy$;
+    constructor(translate: TranslateService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onMenuOpen(): void;
+    isActive(language: any | ILanguageWithTranslation): boolean;
+    selectLanguage(language: ILanguageWithTranslation): void;
+    /**
+     * Creates visible language list and menu language list that is used in template.
+     * Uses component variable "languageList" which gets passed as input param.
+     */
+    private recreateLanguageLists;
+    private ensureSelectedIsVisible;
+    private isEqualWithSelected;
+    private toogleDomainVisibility;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldLangListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldLangListComponent, "tld-lang-list", never, { "disabled": "disabled"; "pxPerLanguage": "pxPerLanguage"; "languages": "languages"; "testId": "testId"; "selected": "selected"; "maxDisplayedLanguages": "maxDisplayedLanguages"; "showDomainsWithLanguageName": "showDomainsWithLanguageName"; }, { "onLanguageChange": "onLanguageChange"; "onDomainChange": "onDomainChange"; }, never, ["*"], false>;
+}

package/lib/modules/tld-common/components/tld-list-menu/tld-list-menu.component.d.ts

@@ -0,0 +1,24 @@
+import { EventEmitter } from '@angular/core';
+import { MatMenu } from '@angular/material/menu';
+import * as i0 from "@angular/core";
+export declare class TldListMenuComponent {
+    menu: MatMenu;
+    /** Title key. Should be set if element is not string. */
+    titleKey: string;
+    list: any[];
+    showContent: boolean;
+    selected: any;
+    set selectedValue(value: any);
+    disabled: boolean;
+    /** Open menu button aria label */
+    ariaLabel: string;
+    /** Which property of object should be emitted when element is selected. By default, object is returned. */
+    valueKey: string;
+    /** For testing purposes. Adds this to attributes for wrapper. */
+    testId: string;
+    selectionChange: EventEmitter<any>;
+    select(element: any): void;
+    onMenuOpen(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldListMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldListMenuComponent, "tld-list-menu", never, { "titleKey": "titleKey"; "list": "list"; "showContent": "showContent"; "selectedValue": "selectedValue"; "disabled": "disabled"; "ariaLabel": "ariaLabel"; "valueKey": "valueKey"; "testId": "testId"; }, { "selectionChange": "selectionChange"; }, never, ["*"], false>;
+}

package/lib/modules/tld-common/components/tld-loader/tld-loader.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class TldLoaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldLoaderComponent, "tld-loader", never, {}, {}, never, never, false>;
+}

package/lib/modules/tld-common/components/tld-message/tld-message.component.d.ts

@@ -0,0 +1,18 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { ITldTranslateMessage } from '../../models';
+import * as i0 from "@angular/core";
+export declare class TldMessageComponent implements OnInit {
+    constructor();
+    message: ITldTranslateMessage;
+    contentProjection: boolean;
+    hideClose: boolean;
+    onClose: EventEmitter<any>;
+    get id(): any;
+    get closeButtonId(): any;
+    className: string;
+    readonly ClearLabelCode = "CLEAR_NOTIFICATION";
+    ngOnInit(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldMessageComponent, "tld-message", never, { "message": "message"; "contentProjection": "contentProjection"; "hideClose": "hideClose"; }, { "onClose": "onClose"; }, never, ["*"], false>;
+}

package/lib/modules/tld-common/components/tld-translate-achievement/tld-translate-achievement.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class TldTranslateAchievementComponent {
+    link: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTranslateAchievementComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldTranslateAchievementComponent, "tld-translate-achievement", never, {}, {}, never, never, false>;
+}

package/lib/modules/tld-common/components/translate-button/tld-translate-button.service.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+export declare class TldTranslateButtonService {
+    private onClick;
+    private readonly pulseAnimation;
+    constructor();
+    actionButtonClicked(): void;
+    getActionClick(): import("rxjs").Observable<any>;
+    pulseButton(): void;
+    onPulseAnimation(): import("rxjs").Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTranslateButtonService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TldTranslateButtonService>;
+}

package/lib/modules/tld-common/components/translate-button/translate-button.component.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { TldTranslateButtonService } from './tld-translate-button.service';
+import * as i0 from "@angular/core";
+export declare class TldTranslateButtonComponent implements OnDestroy, OnInit {
+    private service;
+    disabled: boolean;
+    enablePulseAnimation: boolean;
+    clicked: EventEmitter<null>;
+    private pulseCounter;
+    private readonly maxPulseCount;
+    animationState: boolean;
+    private subscription;
+    constructor(service: TldTranslateButtonService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    actionClick(): void;
+    onAnimationEnd(): void;
+    private translateButtonAnimation;
+    private pulse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TldTranslateButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TldTranslateButtonComponent, "tld-translate-button", never, { "disabled": "disabled"; "enablePulseAnimation": "enablePulseAnimation"; }, { "clicked": "clicked"; }, never, never, false>;
+}

package/lib/modules/tld-common/directives/drag-and-drop.directive.d.ts

@@ -0,0 +1,14 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DragAndDropDirective {
+    private readonly element;
+    get disabled(): any;
+    active: boolean;
+    fileDropped: EventEmitter<any>;
+    onDragOver(evt: any): void;
+    onDragLeave(evt: any): void;
+    ondrop(evt: any): void;
+    constructor(element: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragAndDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragAndDropDirective, "[tldDragAndDrop]", never, {}, { "fileDropped": "fileDropped"; }, never, never, false>;
+}

package/lib/modules/tld-common/directives/index.d.ts

@@ -0,0 +1 @@
+export * from './drag-and-drop.directive';

package/lib/modules/tld-common/index.d.ts

@@ -0,0 +1 @@
+export * from './tld-common.module';

package/lib/modules/tld-common/models/auth-options.model.d.ts

@@ -0,0 +1,4 @@
+export interface IAuthOptions {
+    isAuth: boolean;
+    canCreateTermCollection: boolean;
+}

package/lib/modules/tld-common/models/common.d.ts

@@ -0,0 +1,28 @@
+import { TldTranslateConfigService } from '../services/tld-translate-config.service';
+/**
+ * Class for storing some common methods or global app constants.
+ */
+export declare class Common {
+    static getCookie(name: string): string;
+    static getAuthHeaders(config: TldTranslateConfigService): {};
+    static GetApiV2AuthHeaders(config: TldTranslateConfigService): any;
+    static getFileExtension(fileName: string): string;
+    /**
+     * Removes special characters so string is not interpretated as html.
+     * @param text
+     */
+    static escapeHtmlString(text: string): string;
+    static encodeHtmlString(text: string): string;
+    /**
+     * Splits string into paragraphs.
+     * @param text
+     */
+    static splitInParagraphs(text: string): string[];
+    static joinParagraphs(text: string[]): string;
+    static toCamelCase(text: string, symbol?: string): string;
+    static bytesToMb(bytes: number): number;
+    static pascalCaseToEnum(property: string): string;
+    static isTextUrl(text: string): string;
+    static getWordCount(text: string): number;
+    static sortByArray(objectArr: any[], sortByArray: any[], fieldName: string): void;
+}

package/lib/modules/tld-common/models/configs/tld-audio-config.model.d.ts

@@ -0,0 +1,22 @@
+export interface ITldAudioConfig {
+    appSecret: string;
+    appId: string;
+    /** Url for api that returns text from audio input. This was used for EEMT api. */
+    audioApiUrl?: string;
+    /** Maximum size for audio file */
+    audioMaxSizeBytes?: number;
+    /** Allows audio text input. In UI microphone button gets displayed near file upload.  */
+    audioTextInput?: boolean;
+    /** Array of languages for which audio input is supported. */
+    sourceLanguages?: string[];
+    /** How often should file size be checked. Value must be in milliseconds. */
+    dataUpdateTimeFrame?: number;
+    /** Maximum allowed time for recording, in seconds. */
+    maximumRecordTime?: number;
+    /** API url for dictation. */
+    dictateApiUrl?: string;
+    /** Automatically start translation after speech input is stopped. */
+    disableAutomaticTranslation?: boolean;
+    /** Show message to check punctuation after speech input is stopped. */
+    punctuationMessage?: boolean;
+}

package/lib/modules/tld-common/models/configs/tld-term-config.model.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Interface for configurating collection support from MT api and Tilde Term.
+ */
+export interface ITldTermConfig {
+    /** Tilde term portal API url */
+    apiUrl?: string;
+    /** If user has permissions to create/edit new collection. This should be validated outside of the library */
+    canCreateCollection?: boolean;
+    /** Whether collections should be read from both APIs*/
+    isCollectionsActivated?: boolean;
+    /** Determines if Tilde Terminology portal is supported*/
+    isTermPortalSupported?: boolean;
+    /** Min length for collection name input*/
+    collectionNameMinLength?: number;
+    /** Max length for collection name input*/
+    collectionNameMaxLength?: number;
+    /** Timeout in ms after how long shout happen automatic refresh of collection list (From both MT and term api)*/
+    refreshTimeoutMs?: number;
+    /** Overrides refreshTimeoutMs if any of collections is importing.
+    / Use case: normaly refreshing list every 10seconds, but when collection is importend, we might want to refresh list every 5secs, so user gets faster feedback when import finished.
+    */
+    refreshTimeoutMsWhenImporting?: number;
+    /** For "Sign up...." button in terminology promotion component. */
+    freeTrialUrl?: string;
+    /**  For "Learn more about glossaries" button in terminology promotion*/
+    learnMoreUrl?: string;
+}

package/lib/modules/tld-common/models/configs/tld-text-to-speech-config.model.d.ts

@@ -0,0 +1,11 @@
+export interface ITldTextToSpeechConfig {
+    languages?: {
+        [language: string]: {
+            url: string;
+            voice?: string;
+            langBpc47?: string;
+        };
+    };
+    /** Maximum number of characters that can be sent to tts */
+    maxCharsInText?: number;
+}

package/lib/modules/tld-common/models/configs/tld-translate-api-v2-config.model.d.ts

@@ -0,0 +1,11 @@
+export interface ITldTranslateApiV2Config {
+    mtApiUrl?: string;
+    systemListUrl?: string;
+    translationUrl?: string;
+    fileTranslationUrl?: string;
+    grammarCheckUrl?: string;
+    /** If auto domain detection is enabled, system v2 api service creates "fake" system with empty domain and it is used as auto detection domain. */
+    autoDomainDetection?: boolean;
+    /** Authorization key for api v2 for public users. */
+    xApiKey?: string;
+}

package/lib/modules/tld-common/models/configs/tld-translate-config.model.d.ts

@@ -0,0 +1,18 @@
+import { ITldAudioConfig } from "./tld-audio-config.model";
+import { ITldTermConfig } from "./tld-term-config.model";
+import { ITldTranslateFileConfig } from "./tld-translate-file-config.model";
+import { ITldTranslateCoreConfig } from "./tld-translate-core-config.model";
+import { ITldTranslateTextConfig } from "./tld-translate-text-config.model";
+import { ITldTranslateWebsiteConfig } from "./tld-translate-web-config.model";
+import { ITldTranslateApiV2Config } from "./tld-translate-api-v2-config.model";
+import { ITldTextToSpeechConfig } from "./tld-text-to-speech-config.model";
+export interface ITldTranslateConfig {
+    audio?: ITldAudioConfig;
+    core?: ITldTranslateCoreConfig;
+    term?: ITldTermConfig;
+    file?: ITldTranslateFileConfig;
+    text?: ITldTranslateTextConfig;
+    webTranslate?: ITldTranslateWebsiteConfig;
+    apiV2?: ITldTranslateApiV2Config;
+    textToSpeech?: ITldTextToSpeechConfig;
+}

package/lib/modules/tld-common/models/configs/tld-translate-core-config.model.d.ts

@@ -0,0 +1,42 @@
+import { languageMenuVersion } from "../core";
+export interface ITldTranslateCoreConfig {
+    apiIsInTheSameDomain?: boolean;
+    appId: string;
+    appName?: string;
+    clientId: string;
+    defaultVendor?: string;
+    hideAchievement?: boolean;
+    isAuth?: boolean;
+    jwtAuth?: boolean;
+    registerLink?: string;
+    supportEmail?: string;
+    systemListUrl?: string;
+    sourceLanguageOrder?: {
+        [key: string]: string[];
+    };
+    targetLanguageOrder?: {
+        [key: string]: string[];
+    };
+    hideLangMenuLabels?: boolean;
+    showVendors?: boolean;
+    showDomains?: boolean;
+    showDomainTitle?: boolean;
+    swapIconPosition?: "src" | "center";
+    domainSide?: "src" | "trg";
+    unauthorizedRedirectLink?: string[];
+    allowedSystemStatuses?: string[];
+    translateAppName?: boolean;
+    translationServiceUrl?: string;
+    isWebComponent?: boolean;
+    maxDisplayedLanguages?: number;
+    debug?: boolean;
+    showDomainsWithLanguageName?: boolean;
+    defaultSystemId?: string;
+    languageMenuVersion?: languageMenuVersion;
+    /** Maximums number of systems to be stored in localstorage. UI will display one system less than this number. */
+    maxRecentSystemCount?: number;
+    /** For language pair, system service looks for system with domains in this order. */
+    defaultDomains?: string[];
+    /** Wether 'contact support' text should be displayed in notification messages. */
+    contactSupport?: boolean;
+}

package/lib/modules/tld-common/models/configs/tld-translate-file-config.model.d.ts

@@ -0,0 +1,25 @@
+export interface ITldTranslateFileConfig {
+    allowedFileTypes?: string[];
+    extendedFileTypes?: string[];
+    allowTmxAuth?: boolean;
+    allowTmxUnauth?: boolean;
+    fileApiUrl?: string;
+    fileUpload?: boolean;
+    fileDownloadTimeouts?: {
+        [status: string]: number;
+    };
+    maxSize?: number;
+    wordLimit?: number;
+    showTranslationLimits?: boolean;
+    targetDownloadExtensionOrder?: {
+        [extension: string]: string[];
+    };
+    ocrPageLimit?: number;
+    allowPDFSourceDownload?: boolean;
+    allowImageSourceDownload?: boolean;
+    sourceDownloadExtensions?: string[];
+    numberOfFilesAllowed?: number;
+    useMultipleFileUpload?: boolean;
+    /** For which vendors title is visible in file translation progress indicator message.*/
+    progressIndicatorTitleVisibleForVendors?: string[];
+}