manucap 3.0.0

package/dist/manucap/cues/edit/InlineStyleButton.d.ts

@@ -0,0 +1,11 @@
+import { EditorState } from "draft-js";
+import { ReactElement } from "react";
+interface Props {
+    editorIndex: number;
+    inlineStyle: string;
+    label: ReactElement;
+    editorState: EditorState;
+    setEditorState: Function;
+}
+declare const InlineStyleButton: (props: Props) => ReactElement;
+export default InlineStyleButton;

package/dist/manucap/cues/edit/InlineStyleButton.spec.d.ts

@@ -0,0 +1 @@
+import "../../../testUtils/initBrowserEnvironment";

package/dist/manucap/cues/edit/PositionButton.d.ts

@@ -0,0 +1,8 @@
+import { Position } from "../cueUtils";
+import { ReactElement } from "react";
+interface Props {
+    vttCue: VTTCue;
+    changePosition: (position: Position) => void;
+}
+declare const PositionButton: (props: Props) => ReactElement;
+export default PositionButton;

package/dist/manucap/cues/edit/PositionButton.spec.d.ts

@@ -0,0 +1,2 @@
+import "../../../testUtils/initBrowserEnvironment";
+import "video.js";

package/dist/manucap/cues/edit/SplitCueLineButton.d.ts

@@ -0,0 +1,6 @@
+import { ReactElement } from "react";
+interface Props {
+    cueIndex: number;
+}
+declare const SplitCueLineButton: (props: Props) => ReactElement;
+export default SplitCueLineButton;

package/dist/manucap/cues/edit/SplitCueLineButton.spec.d.ts

@@ -0,0 +1,2 @@
+import "../../../testUtils/initBrowserEnvironment";
+import "video.js";

package/dist/manucap/cues/edit/TimeEditor.d.ts

@@ -0,0 +1,11 @@
+import { ReactElement } from "react";
+interface Props {
+    time?: number;
+    onChange: (time: number) => void;
+    autoFocus?: boolean;
+}
+declare const TimeEditor: {
+    (props: Props): ReactElement;
+    defaultProps: Partial<Props>;
+};
+export default TimeEditor;

package/dist/manucap/cues/edit/TimeEditor.spec.d.ts

@@ -0,0 +1 @@
+import "../../../testUtils/initBrowserEnvironment";

package/dist/manucap/cues/edit/cueEditorSlices.d.ts

@@ -0,0 +1,25 @@
+import { Dispatch } from "react";
+import { PayloadAction } from "@reduxjs/toolkit";
+import { CueChange, CueError, ManuCapAction } from "../../model";
+import { AppThunk } from "../../manuCapReducers";
+export interface CueIndexAction extends ManuCapAction {
+    idx: number;
+}
+export declare const editingCueIndexSlice: import("@reduxjs/toolkit").Slice<number, {
+    updateEditingCueIndex: (_state: number, action: PayloadAction<CueIndexAction>) => number;
+}, "editingCueIndex">;
+declare type FocusedInputType = "EDITOR" | "START_TIME";
+export declare const focusedInputSlice: import("@reduxjs/toolkit").Slice<FocusedInputType, {
+    updateFocusedInput: (_state: FocusedInputType, action: PayloadAction<FocusedInputType>) => FocusedInputType;
+}, "focusedInput">;
+export declare const updateEditingCueIndexNoThunk: (dispatch: Dispatch<ManuCapAction>, idx: number) => void;
+export declare const updateEditingCueIndex: (idx: number, matchedCueIndex?: number) => AppThunk;
+export declare const validationErrorSlice: import("@reduxjs/toolkit").Slice<CueError[], {
+    setValidationErrors: (_state: CueError[], action: PayloadAction<CueError[]>) => CueError[];
+}, "validationError">;
+export declare const setValidationErrors: (errors: CueError[]) => AppThunk;
+export declare const lastCueChangeSlice: import("@reduxjs/toolkit").Slice<CueChange | null, {
+    recordCueChange: (_state: import("immer/dist/internal").WritableDraft<CueChange> | null, action: PayloadAction<CueChange | null>) => CueChange | null;
+}, "lastCueChange">;
+export declare const clearLastCueChange: () => AppThunk;
+export {};

package/dist/manucap/cues/edit/cueEditorSlices.spec.d.ts

@@ -0,0 +1 @@
+import "video.js";

package/dist/manucap/cues/edit/cueTextConverter.d.ts

@@ -0,0 +1,4 @@
+import { ContentState } from "draft-js";
+export declare const convertVttToHtml: (vtt: string) => string;
+export declare const convertHtmlToVtt: (html: string) => string;
+export declare const getVttText: (currentContent: ContentState) => string;

package/dist/manucap/cues/edit/cueTextConverter.spec.d.ts

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

package/dist/manucap/cues/edit/editUtils.d.ts

@@ -0,0 +1,3 @@
+import { EditorState } from "draft-js";
+export declare const replaceContent: (editorState: EditorState, replacement: string, start: number, end: number) => EditorState;
+export declare const replaceVttCueContent: (vttCue: VTTCue, replacement: string, start: number, end: number) => VTTCue;

package/dist/manucap/cues/merge/MergeEditor.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from "react";
+declare const MergeEditor: () => ReactElement | null;
+export default MergeEditor;

package/dist/manucap/cues/merge/MergeEditor.spec.d.ts

@@ -0,0 +1 @@
+import "../../../testUtils/initBrowserEnvironment";

package/dist/manucap/cues/merge/mergeSlices.d.ts

@@ -0,0 +1,11 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { AppThunk } from "../../manuCapReducers";
+import { CuesWithRowIndex } from "../../model";
+export declare const mergeVisibleSlice: import("@reduxjs/toolkit").Slice<boolean, {
+    setMergeVisible: (_state: boolean, action: PayloadAction<boolean>) => boolean;
+}, "mergeVisible">;
+export declare const showMerge: (visible: boolean) => AppThunk;
+export declare const rowsToMergeSlice: import("@reduxjs/toolkit").Slice<CuesWithRowIndex[], {
+    addRowCues: (state: import("immer/dist/internal").WritableDraft<CuesWithRowIndex>[], action: PayloadAction<CuesWithRowIndex>) => void;
+    removeRowCues: (state: import("immer/dist/internal").WritableDraft<CuesWithRowIndex>[], action: PayloadAction<CuesWithRowIndex>) => void;
+}, "rowsToMerge">;

package/dist/manucap/cues/merge/mergeSlices.spec.d.ts

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

package/dist/manucap/cues/saveCueDeleteSlices.d.ts

@@ -0,0 +1,12 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { CueDto, SaveTrackCue } from "../model";
+export interface SaveCueDelete {
+    deleteCue: ((trackCue: SaveTrackCue) => void) | null;
+}
+export declare const saveCueDeleteSlice: import("@reduxjs/toolkit").Slice<SaveCueDelete, {
+    setDeleteCueCallback: (state: import("immer/dist/internal").WritableDraft<SaveCueDelete>, action: {
+        payload: (trackCue: SaveTrackCue) => void;
+        type: string;
+    }) => void;
+}, "saveCueDelete">;
+export declare const callSaveCueDelete: (getState: Function, cueToDelete: CueDto) => void;

package/dist/manucap/cues/saveCueDeleteSlices.spec.d.ts

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

package/dist/manucap/cues/saveCueUpdateSlices.d.ts

@@ -0,0 +1,13 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { SaveTrackCue } from "../model";
+import { AppThunk } from "../manuCapReducers";
+export interface SaveCueUpdateCallback {
+    updateCue: ((trackCue: SaveTrackCue) => void) | null;
+}
+export declare const saveCueUpdateSlice: import("@reduxjs/toolkit").Slice<SaveCueUpdateCallback, {
+    setUpdateCueCallback: (state: import("immer/dist/internal").WritableDraft<SaveCueUpdateCallback>, action: {
+        payload: (trackCue: SaveTrackCue) => void;
+        type: string;
+    }) => void;
+}, "saveCueUpdate">;
+export declare const callSaveCueUpdate: (cueIndex: number) => AppThunk;

package/dist/manucap/cues/saveCueUpdateSlices.spec.d.ts

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

package/dist/manucap/cues/saveSlices.d.ts

@@ -0,0 +1,16 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { AppThunk } from "../manuCapReducers";
+import { Dispatch } from "react";
+import { CueDto, ManuCapAction, Track } from "../model";
+interface SaveActionWithPayload extends ManuCapAction {
+    cues: CueDto[];
+    editingTrack: Track | null;
+    shouldCreateNewVersion: boolean;
+}
+export declare const saveTrackSlice: import("@reduxjs/toolkit").Slice<Function | null, {
+    set: (_state: Function | null, action: PayloadAction<Function>) => Function;
+    call: (state: Function | null, action: PayloadAction<SaveActionWithPayload>) => Function | null;
+}, "callSaveTrack">;
+export declare const setSaveTrack: (saveTrack: Function) => AppThunk;
+export declare const callSaveTrack: (dispatch: Dispatch<PayloadAction<ManuCapAction>>, getState: Function) => void;
+export {};

package/dist/manucap/cues/saveSlices.spec.d.ts

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

package/dist/manucap/cues/searchReplace/SearchReplaceEditor.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from "react";
+declare const SearchReplaceEditor: () => ReactElement | null;
+export default SearchReplaceEditor;

package/dist/manucap/cues/searchReplace/SearchReplaceEditor.spec.d.ts

@@ -0,0 +1 @@
+import "../../../testUtils/initBrowserEnvironment";

package/dist/manucap/cues/searchReplace/SearchReplaceMatch.d.ts

@@ -0,0 +1,6 @@
+import { ReactElement } from "react";
+interface Props {
+    children: ReactElement;
+}
+export declare const SearchReplaceMatch: (props: Props) => ReactElement;
+export {};

package/dist/manucap/cues/searchReplace/SearchReplaceMatch.spec.d.ts

@@ -0,0 +1 @@
+import "../../../testUtils/initBrowserEnvironment";

package/dist/manucap/cues/searchReplace/model.d.ts

@@ -0,0 +1,16 @@
+export declare type SearchDirection = "NEXT" | "PREVIOUS";
+export interface SearchReplace {
+    find: string;
+    replacement: string;
+    matchCase: boolean;
+    direction: SearchDirection;
+    indices: SearchReplaceIndices;
+}
+export interface SearchReplaceIndices {
+    matchedCueIndex: number;
+    sourceCueIndex: number;
+    targetCueIndex: number;
+    offset: number;
+    offsetIndex: number;
+    matchLength: number;
+}

package/dist/manucap/cues/searchReplace/searchReplaceSlices.d.ts

@@ -0,0 +1,22 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { AppThunk } from "../../manuCapReducers";
+import { SearchDirection, SearchReplace, SearchReplaceIndices } from "./model";
+export declare const searchReplaceVisibleSlice: import("@reduxjs/toolkit").Slice<boolean, {
+    setSearchReplaceVisible: (_state: boolean, action: PayloadAction<boolean>) => boolean;
+}, "searchReplaceVisible">;
+export declare const searchReplaceSlice: import("@reduxjs/toolkit").Slice<SearchReplace, {
+    setFind: (_state: import("immer/dist/internal").WritableDraft<SearchReplace>, action: PayloadAction<string>) => void;
+    setReplacement: (_state: import("immer/dist/internal").WritableDraft<SearchReplace>, action: PayloadAction<string>) => void;
+    setMatchCase: (_state: import("immer/dist/internal").WritableDraft<SearchReplace>, action: PayloadAction<boolean>) => void;
+    setDirection: (_state: import("immer/dist/internal").WritableDraft<SearchReplace>, action: PayloadAction<SearchDirection>) => void;
+    replaceMatchSignal: (state: import("immer/dist/internal").WritableDraft<SearchReplace>, action: PayloadAction<string>) => void;
+    setIndices: (state: import("immer/dist/internal").WritableDraft<SearchReplace>, action: PayloadAction<SearchReplaceIndices>) => void;
+}, "searchReplace">;
+export declare const setFind: (find: string) => AppThunk;
+export declare const setReplacement: (replacement: string) => AppThunk;
+export declare const setMatchCase: (matchCase: boolean) => AppThunk;
+export declare const showSearchReplace: (visible: boolean) => AppThunk;
+export declare const searchCueText: (text: string, find: string, matchCase: boolean) => Array<number>;
+export declare const searchNextCues: () => AppThunk;
+export declare const searchPreviousCues: () => AppThunk;
+export declare const replaceCurrentMatch: (replacement: string) => AppThunk;

package/dist/manucap/cues/searchReplace/searchReplaceSlices.spec.d.ts

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

package/dist/manucap/cues/spellCheck/SpellCheckIssue.d.ts

@@ -0,0 +1,17 @@
+import { ReactElement, RefObject } from "react";
+import { SpellCheck } from "./model";
+interface Props {
+    children: ReactElement;
+    spellCheck: SpellCheck;
+    start: number;
+    end: number;
+    correctSpelling: (replacement: string, start: number, end: number) => void;
+    spellCheckerMatchingOffset: number | null;
+    setSpellCheckerMatchingOffset: (id: number | null) => void;
+    editorRef: RefObject<HTMLInputElement>;
+    bindCueViewModeKeyboardShortcut: () => void;
+    unbindCueViewModeKeyboardShortcut: () => void;
+    trackId: string;
+}
+export declare const SpellCheckIssue: (props: Props) => ReactElement | null;
+export {};

package/dist/manucap/cues/spellCheck/SpellCheckIssue.spec.d.ts

@@ -0,0 +1 @@
+import "../../../testUtils/initBrowserEnvironment";

package/dist/manucap/cues/spellCheck/model.d.ts

@@ -0,0 +1,33 @@
+export interface Replacement {
+    value: string;
+}
+export interface SpellCheckHash {
+    keyword: string;
+    ruleId: string;
+}
+export interface SpellcheckRule {
+    id: string;
+}
+export interface SpellcheckContext {
+    length: number;
+    offset: number;
+    text: string;
+}
+export interface Match {
+    context: SpellcheckContext;
+    message: string;
+    replacements: Replacement[];
+    offset: number;
+    length: number;
+    rule: SpellcheckRule;
+}
+export interface SpellCheck {
+    matches: Match[];
+}
+export interface SpellCheckIgnore {
+    hashes: Array<string>;
+    creationDate: Date;
+}
+export interface SpellCheckIgnoreStorage {
+    trackId: SpellCheckIgnore;
+}

package/dist/manucap/cues/spellCheck/spellCheckFetch.d.ts

@@ -0,0 +1,5 @@
+import { SpellCheck } from "./model";
+import { SpellcheckerSettings, ManuCapAction } from "../../model";
+import { Dispatch } from "react";
+export declare const addSpellCheck: (dispatch: Dispatch<ManuCapAction | void>, index: number, spellCheck: SpellCheck, trackId?: string) => void;
+export declare const fetchSpellCheck: (text: string, spellCheckerSettings: SpellcheckerSettings, language: string) => Promise<SpellCheck>;

package/dist/manucap/cues/spellCheck/spellCheckerUtils.d.ts

@@ -0,0 +1,6 @@
+import { Match } from "./model";
+export declare const getMatchText: (match: Match) => string;
+export declare const generateSpellcheckHash: (keyword: string, ruleId: string) => string;
+export declare const addIgnoredKeyword: (trackId: string, keyword: string, ruleId: string) => void;
+export declare const hasIgnoredKeyword: (match: Match, trackId?: string) => boolean;
+export declare const languageToolLanguageMapping: Map<string, string>;

package/dist/manucap/cues/spellCheck/spellCheckerUtils.spec.d.ts

@@ -0,0 +1 @@
+import "../../../testUtils/initBrowserEnvironment";

package/dist/manucap/cues/spellCheck/spellcheckerSettingsSlice.spec.d.ts

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

package/dist/manucap/cues/view/ClickCueWrapper.d.ts

@@ -0,0 +1,13 @@
+import { ReactElement } from "react";
+export interface CueViewProps {
+    targetCueIndex?: number;
+    targetCuesLength: number;
+    sourceCuesIndexes: number[];
+    nextTargetCueIndex: number;
+    className?: string;
+    children?: ReactElement;
+    editDisabled?: boolean;
+    matchedCueIndex?: number;
+}
+declare const ClickCueWrapper: (props: CueViewProps) => ReactElement;
+export default ClickCueWrapper;

package/dist/manucap/cues/view/ClickCueWrapper.spec.d.ts

@@ -0,0 +1,2 @@
+import "../../../testUtils/initBrowserEnvironment";
+import "video.js";

package/dist/manucap/cues/view/CueView.d.ts

@@ -0,0 +1,21 @@
+import { ReactElement } from "react";
+import { CueDto, LanguageDirection } from "../../model";
+export interface CueViewProps {
+    rowIndex: number;
+    cue: CueDto;
+    isTargetCue: boolean;
+    targetCuesLength: number;
+    showGlossaryTerms: boolean;
+    sourceCuesIndexes: number[];
+    nextTargetCueIndex: number;
+    matchedNestedIndex?: number;
+    targetCueIndex?: number;
+    languageDirection?: LanguageDirection;
+    className?: string;
+    hideText?: boolean;
+    glossaryTerm?: string;
+    setGlossaryTerm?: (glossaryTerm?: string) => void;
+    editDisabled?: boolean;
+}
+declare const CueView: (props: CueViewProps) => ReactElement;
+export default CueView;

package/dist/manucap/cues/view/CueView.spec.d.ts

@@ -0,0 +1,2 @@
+import "../../../testUtils/initBrowserEnvironment";
+import "video.js";

package/dist/manucap/cues/view/InsertCueButton.d.ts

@@ -0,0 +1,3 @@
+import { ReactElement } from "react";
+declare const InsertCueButton: () => ReactElement;
+export default InsertCueButton;

package/dist/manucap/cues/view/sourceCueSlices.d.ts

@@ -0,0 +1,11 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { CueDto, ManuCapAction } from "../../model";
+import { AppThunk } from "../../manuCapReducers";
+interface CuesAction extends ManuCapAction {
+    cues: CueDto[];
+}
+export declare const sourceCuesSlice: import("@reduxjs/toolkit").Slice<CueDto[], {
+    updateSourceCues: (_state: import("immer/dist/internal").WritableDraft<CueDto>[], action: PayloadAction<CuesAction>) => CueDto[];
+}, "sourceCues">;
+export declare const updateSourceCues: (cues: CueDto[]) => AppThunk;
+export {};

package/dist/manucap/cues/view/sourceCueSlices.spec.d.ts

@@ -0,0 +1 @@
+import "video.js";

package/dist/manucap/loadingIndicatorSlices.d.ts

@@ -0,0 +1,2 @@
+import { LoadingIndicator } from "./model";
+export declare const loadingIndicatorSlices: import("@reduxjs/toolkit").Slice<LoadingIndicator, {}, "loadingIndicator">;

package/dist/manucap/loadingIndicatorSlices.spec.d.ts

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

package/dist/manucap/manuCapReducers.d.ts

@@ -0,0 +1,65 @@
+import { Action } from "@reduxjs/toolkit";
+import { ThunkAction } from "redux-thunk";
+export declare const Reducers: {
+    cues: import("redux").Reducer<import("./model").CueDto[], import("redux").AnyAction>;
+    editingTrack: import("redux").Reducer<import("./model").Track | null, import("redux").AnyAction>;
+    captionSpecifications: import("redux").Reducer<import("./toolbox/model").CaptionSpecification | null, import("redux").AnyAction>;
+    sourceCues: import("redux").Reducer<import("./model").CueDto[], import("redux").AnyAction>;
+    videoSectionToPlay: import("redux").Reducer<import("./player/playbackSlices").PlayVideoAction, import("redux").AnyAction>;
+    loadingIndicator: import("redux").Reducer<import("./model").LoadingIndicator, import("redux").AnyAction>;
+    saveTrack: import("redux").Reducer<Function | null, import("redux").AnyAction>;
+    saveCueUpdate: import("redux").Reducer<import("./cues/saveCueUpdateSlices").SaveCueUpdateCallback, import("redux").AnyAction>;
+    saveCueDelete: import("redux").Reducer<import("./cues/saveCueDeleteSlices").SaveCueDelete, import("redux").AnyAction>;
+    spellCheckerSettings: import("redux").Reducer<any, import("redux").AnyAction>;
+    searchReplace: import("redux").Reducer<import("./cues/searchReplace/model").SearchReplace, import("redux").AnyAction>;
+    searchReplaceVisible: import("redux").Reducer<boolean, import("redux").AnyAction>;
+    mergeVisible: import("redux").Reducer<boolean, import("redux").AnyAction>;
+    rowsToMerge: import("redux").Reducer<import("./model").CuesWithRowIndex[], import("redux").AnyAction>;
+    captionUser: import("redux").Reducer<import("./model").User | null, import("redux").AnyAction>;
+    editingCueIndex: import("redux").Reducer<number, import("redux").AnyAction>;
+    lastCueChange: import("redux").Reducer<import("./model").CueChange | null, import("redux").AnyAction>;
+    validationErrors: import("redux").Reducer<import("./model").CueError[], import("redux").AnyAction>;
+    focusedCueIndex: import("redux").Reducer<number | null, import("redux").AnyAction>;
+    matchedCues: import("redux").Reducer<import("./cues/cuesList/cuesListTimeMatching").MatchedCuesWithEditingFocus, import("redux").AnyAction>;
+    currentPlayerTime: import("redux").Reducer<number, import("redux").AnyAction>;
+    commentsVisible: import("redux").Reducer<boolean, import("redux").AnyAction>;
+    waveformVisible: import("redux").Reducer<boolean, import("redux").AnyAction>;
+    currentCueErrorIndex: import("redux").Reducer<number, import("redux").AnyAction>;
+    focusedInput: import("redux").Reducer<"EDITOR" | "START_TIME", import("redux").AnyAction>;
+};
+declare const manuCapReducers: import("redux").Reducer<import("redux").CombinedState<{
+    cues: import("./model").CueDto[];
+    editingTrack: import("./model").Track | null;
+    captionSpecifications: import("./toolbox/model").CaptionSpecification | null;
+    sourceCues: import("./model").CueDto[];
+    videoSectionToPlay: import("./player/playbackSlices").PlayVideoAction;
+    loadingIndicator: import("./model").LoadingIndicator;
+    saveTrack: Function | null;
+    saveCueUpdate: import("./cues/saveCueUpdateSlices").SaveCueUpdateCallback;
+    saveCueDelete: import("./cues/saveCueDeleteSlices").SaveCueDelete;
+    spellCheckerSettings: any;
+    searchReplace: import("./cues/searchReplace/model").SearchReplace;
+    searchReplaceVisible: boolean;
+    mergeVisible: boolean;
+    rowsToMerge: import("./model").CuesWithRowIndex[];
+    captionUser: import("./model").User | null;
+    editingCueIndex: number;
+    lastCueChange: import("./model").CueChange | null;
+    validationErrors: import("./model").CueError[];
+    focusedCueIndex: number | null;
+    matchedCues: import("./cues/cuesList/cuesListTimeMatching").MatchedCuesWithEditingFocus;
+    currentPlayerTime: number;
+    commentsVisible: boolean;
+    waveformVisible: boolean;
+    currentCueErrorIndex: number;
+    focusedInput: "EDITOR" | "START_TIME";
+}>, import("redux").AnyAction>;
+export default manuCapReducers;
+export declare type ManuCapState = ReturnType<typeof manuCapReducers>;
+/**
+ * We are forced to use `as {} as AnyAction` casting then we are executing actions with `testingStore.dispatch`.
+ * This seems to be related problem: https://github.com/reduxjs/redux-toolkit/issues/321.
+ * But no suggestions from that issue work nor mentioned fix didn't work. I couldn't figure out any other fix than
+ * applying ugly cast workaround.
+ */
+export declare type AppThunk = ThunkAction<void, ManuCapState, unknown, Action<string>>;

package/dist/manucap/model.d.ts

@@ -0,0 +1,174 @@
+import { SpellCheck } from "./cues/spellCheck/model";
+export declare type TrackType = "CAPTION" | "TRANSLATION";
+export declare type LanguageDirection = "RTL" | "LTR";
+export interface Language {
+    readonly id: string;
+    readonly name: string;
+    readonly direction?: LanguageDirection;
+    countryCode?: string;
+    alpha1Code?: string;
+    alpha2TCode?: string;
+    alpha2BCode?: string;
+    code?: string | null;
+    localizedName?: string;
+}
+export declare type CueCategory = "DIALOGUE" | "ONSCREEN_TEXT" | "AUDIO_DESCRIPTION" | "LYRICS";
+export interface GlossaryMatchDto {
+    source: string;
+    replacements: string[];
+}
+export declare enum CueLineState {
+    NONE = 0,
+    GOOD = 1,
+    ERROR = 2
+}
+export declare const CUE_LINE_STATE_CLASSES: Map<CueLineState, {
+    dividerClass: string;
+    flapClass: string;
+}>;
+export interface CueDto {
+    id?: string;
+    readonly vttCue: VTTCue;
+    readonly cueCategory: CueCategory;
+    editUuid?: string;
+    editDisabled?: boolean;
+    spellCheck?: SpellCheck;
+    glossaryMatches?: GlossaryMatchDto[];
+    errors?: CueError[] | null;
+    comments?: CueComment[];
+    trackVersionId?: string;
+    trackVersionLockingVersion?: number;
+    addId?: string;
+}
+export interface CueDtoWithIndex {
+    index: number;
+    cue: CueDto;
+}
+export interface CueLineDto {
+    sourceCues?: CueDtoWithIndex[];
+    targetCues?: CueDtoWithIndex[];
+}
+export interface CuesWithRowIndex {
+    index: number;
+    cues?: CueDtoWithIndex[];
+}
+export interface LanguageCues {
+    readonly languageId: string;
+    readonly cues: CueDto[];
+}
+export interface TrackVersionDto extends Track {
+    trackVersionId: string;
+    completion: number;
+}
+export interface Track {
+    readonly type: TrackType;
+    readonly language: Language;
+    readonly default: boolean;
+    readonly mediaTitle: string;
+    readonly mediaLength: number;
+    readonly mediaChunkStart?: number;
+    readonly mediaChunkEnd?: number;
+    readonly sourceLanguage?: Language;
+    trackSource?: boolean;
+    readonly progress: number;
+    overlapEnabled?: boolean;
+    timecodesUnlocked?: boolean;
+    id?: string;
+    createdBy: User;
+    currentVersion: TrackVersionDto;
+    createdAt: string;
+    title: string;
+    trackId: string;
+    name: string;
+}
+export interface SpellcheckerSettings {
+    enabled: boolean;
+    domain: string | null | undefined;
+}
+export interface User {
+    userId: string;
+    firstname: string;
+    lastname: string;
+    email: string;
+    systemAdmin: string;
+    displayName: string;
+}
+/**
+ * This is marker interface for all the actions that can be dispatched
+ */
+export interface ManuCapAction {
+}
+export interface TimeGapLimit {
+    minGap: number;
+    maxGap: number;
+}
+export interface LoadingIndicator {
+    cuesLoaded: boolean;
+    sourceCuesLoaded: boolean;
+}
+export interface CueChange {
+    changeType: "ADD" | "EDIT" | "REMOVE" | "SPLIT" | "MERGE" | "UPDATE_ALL";
+    index: number;
+    vttCue?: VTTCue;
+}
+/**
+ * Declare video cue scroll position
+ * @author Mario Dennis
+ * @param FIRST - scrolls to first cue item
+ * @param LAST - scrolls to last cue item
+ * @param CURRENT - scroll to cue item currently being edited
+ * @param PLAYBACK - scroll to currently playing media track cue item
+ * @param LAST_TRANSLATED - scroll to last translated cue
+ */
+export declare enum ScrollPosition {
+    NONE = 0,
+    FIRST = 1,
+    LAST = 2,
+    CURRENT = 3,
+    PLAYBACK = 4,
+    LAST_TRANSLATED = 5,
+    NEXT_PAGE = 6,
+    PREVIOUS_PAGE = 7,
+    ERROR = 8
+}
+export declare enum CueError {
+    LINE_CHAR_LIMIT_EXCEEDED = "Max Characters Per Line Exceeded",
+    LINE_COUNT_EXCEEDED = "Max Lines Per Caption Exceeded",
+    TIME_GAP_LIMIT_EXCEEDED = "Min/Max Caption Duration In Seconds Exceeded",
+    TIME_GAP_OVERLAP = "Cue Overlap",
+    SPELLCHECK_ERROR = "Spelling Error(s)",
+    INVALID_RANGE_START = "Invalid Start Time",
+    INVALID_RANGE_END = "Invalid End Time",
+    OUT_OF_CHUNK_RAGE = "Out of Chunk Range",
+    MERGE_ERROR = "Merged caption is too long/Not enough captions selected",
+    SPLIT_ERROR = "Caption is too short to split",
+    CHARS_PER_SECOND_EXCEEDED = "Max Characters Per Second Exceeded"
+}
+export interface CueComment {
+    id?: string;
+    userId?: string;
+    userName?: string;
+    author?: string;
+    comment: string;
+    date: string;
+}
+export interface WaveformRegion {
+    id: number;
+    start: number;
+    end: number;
+}
+export interface TrackCues {
+    editingTrack: Track | null;
+    cues: CueDto[];
+}
+export interface SaveTrackCue {
+    editingTrack: Track;
+    cue: CueDto;
+    onAddCueSaveSuccess: (cueDto: CueDto) => void;
+}
+export interface SaveActionParameters {
+    cues: CueDto[];
+    editingTrack: Track;
+    shouldCreateNewVersion: boolean;
+}
+export declare type SaveState = "NONE" | "TRIGGERED" | "SAVED" | "ERROR";