speechrecorderng 3.11.28 → 3.12.1

package/types/speechrecorderng.d.ts

@@ -0,0 +1,2835 @@
+import * as i0 from "@angular/core";
+import { AfterContentChecked, AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, InjectionToken, ModuleWithProviders, OnDestroy, OnInit, Renderer2 } from "@angular/core";
+import * as i28 from "@angular/router";
+import { ActivatedRoute, Router } from "@angular/router";
+import { Observable, Subscription } from "rxjs";
+import * as i36 from "@angular/material/checkbox";
+import { MatCheckboxChange } from "@angular/material/checkbox";
+import * as i32 from "@angular/material/dialog";
+import { MatDialog, MatDialogRef } from "@angular/material/dialog";
+import * as i34 from "@angular/material/progress-spinner";
+import { ProgressSpinnerMode } from "@angular/material/progress-spinner";
+import { BreakpointObserver } from "@angular/cdk/layout";
+import { ThemePalette } from "@angular/material/core";
+import { HttpClient, HttpResponse } from "@angular/common/http";
+import * as i29 from "@angular/common";
+import { PlatformLocation } from "@angular/common";
+import * as i40 from "@angular/material/table";
+import { MatTableDataSource } from "@angular/material/table";
+import * as i43 from "@angular/material/snack-bar";
+import { MatSnackBar } from "@angular/material/snack-bar";
+import * as i30 from "@angular/material/icon";
+import * as i31 from "@angular/material/button";
+import * as i33 from "@angular/material/progress-bar";
+import * as i35 from "@angular/material/tooltip";
+import * as i37 from "@angular/material/card";
+import * as i38 from "@angular/material/divider";
+import * as i39 from "@angular/material/grid-list";
+import * as i41 from "@angular/material/input";
+import * as i42 from "@angular/material/select";
+import * as i44 from "@angular/material/menu";
+export declare const SPEECHRECORDER_CONFIG: InjectionToken<SpeechRecorderConfig>;
+export declare enum ApiType {
+  NORMAL = 0,
+  FILES = 1
+}
+export declare class SpeechRecorderConfig {
+  apiEndPoint?: string | null;
+  apiType?: ApiType | null;
+  apiVersion: number;
+  withCredentials?: boolean;
+  enableDownloadRecordings?: boolean;
+  enableUploadRecordings?: boolean;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<SpeechRecorderConfig, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class Position {
+  left: number;
+  top: number;
+  constructor(left: number, top: number);
+  toString(): string;
+}
+declare class Dimension {
+  width: number;
+  height: number;
+  constructor(width: number, height: number);
+  toString(): string;
+}
+declare class Rectangle {
+  position: Position;
+  dimension: Dimension;
+  constructor(position: Position, dimension: Dimension);
+  toString(): string;
+}
+declare abstract class CanvasLayerComponent {
+  protected bounds: Rectangle | null;
+  protected virtualDimension: Dimension;
+  protected canvasLayers: Array<HTMLCanvasElement>;
+  constructor();
+  toXViewPortPixelPosition(virtualX: number): number;
+  toXVirtualPixelPosition(viewPortX: number): number;
+  toViewPortPosition(virtualPos: Position): Position;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CanvasLayerComponent, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<CanvasLayerComponent, never, never, {}, {}, never, never, true, never>;
+}
+interface Float32ArrayInputStream {
+  read(buffers: Array<Float32Array>): number;
+  skipFrames(n: number): void;
+  close(): void;
+}
+interface AsyncFloat32ArrayInputStream {
+  readObs(buffers: Array<Float32Array>): Observable<number>;
+  skipFrames(n: number): void;
+  close(): void;
+}
+interface Float32ArrayOutStream {
+  write(buffers: Array<Float32Array>): number;
+  flush(): void;
+  close(): void;
+}
+interface AudioFloat32OutStream extends Float32ArrayOutStream {
+  setFormat(channels: number, sampleRate: number): void;
+}
+interface SequenceAudioFloat32OutStream extends AudioFloat32OutStream {
+  nextStream(): void;
+}
+interface AudioSource {
+  get duration(): number;
+  get sampleRate(): number;
+  get numberOfChannels(): number;
+  get frameLen(): number;
+  sampleCounts(): number;
+  audioInputStream(): Float32ArrayInputStream | null;
+  asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+  randomAccessAudioStream(): RandomAccessAudioStream;
+  releaseAudioData(): Observable<void>;
+  addOnReadyListener(onReady: (() => void) | null): void;
+  removeOnReadyListener(onReady: (() => void) | null): void;
+  ready(): void;
+}
+declare abstract class BasicAudioSource implements AudioSource {
+  protected _ready: boolean;
+  protected onReadyListeners: Array<(() => void)>;
+  addOnReadyListener(onReady: (() => void)): void;
+  removeOnReadyListener(onReady: (() => void)): void;
+  ready(): void;
+  abstract asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+  abstract audioInputStream(): Float32ArrayInputStream | null;
+  abstract get duration(): number;
+  abstract get frameLen(): number;
+  abstract get numberOfChannels(): number;
+  abstract randomAccessAudioStream(): RandomAccessAudioStream;
+  abstract releaseAudioData(): Observable<void>;
+  abstract sampleCounts(): number;
+  abstract get sampleRate(): number;
+}
+interface RandomAccessAudioStream {
+  framesObs(framePos: number, frameLen: number, bufs: Float32Array[]): Observable<number>;
+  close(): void;
+}
+declare class AudioDataHolder {
+  private _audioSource;
+  get audioSource(): AudioSource | null;
+  get duration(): number;
+  private readonly _numberOfChannels;
+  private readonly _sampleRate;
+  private readonly _frameLen;
+  private readonly _duration;
+  constructor(_audioSource: AudioSource | null);
+  addOnReadyListener(onReady: (() => void) | null): void;
+  get sampleRate(): number;
+  get numberOfChannels(): number;
+  get frameLen(): number;
+  sampleCounts(): number;
+  randomAccessAudioStream(): RandomAccessAudioStream;
+  audioInputStream(): Float32ArrayInputStream | null;
+  asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+  releaseAudioData(): Observable<void>;
+}
+declare class LevelInfo {
+  readonly channelCount: number;
+  startFrame: number;
+  frameLength: number;
+  private readonly _minLinLevels;
+  private readonly _maxLinLevels;
+  constructor(channelCount: number, startFrame?: number, frameLength?: number, minLinLevels?: Array<number>, maxLinLevels?: Array<number>);
+  get minLinLevels(): number[];
+  get maxLinLevels(): number[];
+  private checkOrInitArray;
+  merge(levelInfo: LevelInfo): void;
+  levelsLin(): Array<number>;
+  powerLevelsDB(): Array<number>;
+  powerLevelDB(): number;
+  clone(): LevelInfo;
+}
+declare class LevelInfos {
+  readonly bufferLevelInfos: Array<LevelInfo>;
+  readonly peakLevelInfo: LevelInfo;
+  constructor(bufferLevelInfos: Array<LevelInfo>, peakLevelInfo: LevelInfo);
+  framesPerBuffer(): number;
+}
+interface LevelListener {
+  channelCount: number;
+  update(levelInfo: LevelInfo, peakLevelInfo: LevelInfo): void;
+  streamFinished(): void;
+  reset(): void;
+}
+declare class LevelMeasure {
+  private readonly workerURL;
+  constructor();
+  calcBufferLevelInfos(audioDataHolder: AudioDataHolder, bufferTimeLength: number): Observable<LevelInfos>;
+  workerFunction(): void;
+}
+declare class StreamLevelMeasure implements SequenceAudioFloat32OutStream {
+  currentLevelInfos: LevelInfo | null;
+  peakLevelInfo: LevelInfo | null;
+  private readonly workerURL;
+  private worker;
+  private channelCount;
+  private bufferIndex;
+  private frameCount;
+  levelListener: LevelListener | null;
+  peakLevelListener: ((peakLvlInDb: number) => void) | null;
+  private peakLevelInDb;
+  constructor();
+  setFormat(channels: number, sampleRate: number): void;
+  nextStream(): void;
+  private reset;
+  write(bufferData: Array<Float32Array>): number;
+  flush(): void;
+  close(): void;
+  workerFunction(): void;
+  updateLevels(bufferLevelInfo: LevelInfo): void;
+  stop(): void;
+}
+export declare class AudioClip {
+  private _audioDataHolder;
+  private _selection;
+  private _levelInfos;
+  private selectionObservers;
+  constructor(_audioDataHolder: AudioDataHolder);
+  get audioDataHolder(): AudioDataHolder;
+  get selection(): Selection | null;
+  set selection(value: Selection | null);
+  get levelInfos(): LevelInfos | null;
+  set levelInfos(value: LevelInfos | null);
+  addSelectionObserver(selectionObserver: (audioClip: AudioClip) => void, init?: boolean): void;
+  removeSelectionObserver(selectionObserver: (audioClip: AudioClip) => void): void;
+}
+export declare class Selection {
+  private readonly _sampleRate;
+  private readonly _startFrame;
+  private readonly _endFrame;
+  constructor(sampleRate: number, startFrame: number, endFrame: number);
+  get sampleRate(): number;
+  get endFrame(): number;
+  get startFrame(): number;
+  get leftFrame(): number;
+  get rightFrame(): number;
+  equals(otherSelection: Selection | null | undefined): boolean;
+  toString(): string;
+}
+declare class Marker {
+  name: string | null;
+  framePosition: number | null;
+}
+declare class ViewSelection {
+  private _startX;
+  private _endX;
+  get startX(): number;
+  get endX(): number;
+  width(): number;
+  constructor(_startX: number, _endX: number);
+}
+declare abstract class BasicAudioCanvasLayerComponent extends CanvasLayerComponent {
+  protected _audioDataHolder: AudioDataHolder | null;
+  protected _bgColor: string | null;
+  protected _selectColor: string;
+  /**
+   * Returns pixel position depending on current zoom setting.
+   * @param framePos audio frame (sample) position
+   */
+  frameToXPixelPosition(framePos: number): number | null;
+  /**
+   * Returns pixel position in view port (visible window of scroll pane).
+   * @param framePos audio frame (sample) position
+   */
+  frameToViewPortXPixelPosition(framePos: number): number | null;
+  viewPortXPixelToFramePosition(xViewPortPixelPos: number): number | null;
+  layoutBounds(bounds: Rectangle, virtualDimension: Dimension, redraw: boolean): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<BasicAudioCanvasLayerComponent, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<BasicAudioCanvasLayerComponent, never, never, {}, {}, never, never, true, never>;
+}
+declare abstract class AudioCanvasLayerComponent extends BasicAudioCanvasLayerComponent {
+  protected static readonly ENABLE_STREAMING_NUMBER_OF_SAMPLES_THRESHOLD: number;
+  _pointerPosition: Marker | null;
+  protected selectStartX: number | null;
+  bgCanvasRef: ElementRef;
+  bgCanvas: HTMLCanvasElement;
+  cursorCanvasRef: ElementRef;
+  cursorCanvas: HTMLCanvasElement;
+  onMouseup(me: MouseEvent): void;
+  layoutBounds(bounds: Rectangle, virtualDimension: Dimension, redraw: boolean, clear?: boolean): void;
+  set pointerPosition(pointerPosition: Marker | null);
+  _selecting: Selection | null;
+  set selecting(selecting: Selection | null);
+  get selecting(): Selection | null;
+  _selection: Selection | null;
+  set selection(selection: Selection | null);
+  get selection(): Selection | null;
+  selectionStart(me: MouseEvent): void;
+  selectionCommit(me: MouseEvent): void;
+  abstract startDraw(clear: boolean): void;
+  updateCursorCanvas(me: MouseEvent, showCursorPosition?: boolean): void;
+  pointerPositionEventEmitter: EventEmitter<Marker>;
+  selectingEventEmitter: EventEmitter<Selection>;
+  selectedEventEmitter: EventEmitter<Selection>;
+  pointerPositionChanged(xPosition: number | null): void;
+  private _selectingChange;
+  selectingChange(viewSel: ViewSelection | null): void;
+  select(viewSel: ViewSelection | null): void;
+  viewSelection(): ViewSelection | null;
+  drawBg(): void;
+  drawCursorLayer(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AudioCanvasLayerComponent, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<AudioCanvasLayerComponent, never, never, {
+    "pointerPosition": {
+      "alias": "pointerPosition";
+      "required": false;
+    };
+    "selecting": {
+      "alias": "selecting";
+      "required": false;
+    };
+    "selection": {
+      "alias": "selection";
+      "required": false;
+    };
+  }, {
+    "pointerPositionEventEmitter": "pointerPositionEventEmitter";
+    "selectingEventEmitter": "selectingEventEmitter";
+    "selectedEventEmitter": "selectedEventEmitter";
+  }, never, never, true, never>;
+}
+declare class AudioSignal extends AudioCanvasLayerComponent {
+  private ref;
+  n: any;
+  ce: HTMLDivElement;
+  audioSignalCanvasRef: ElementRef;
+  playPosCanvasRef: ElementRef;
+  signalCanvas: HTMLCanvasElement;
+  markerCanvas: HTMLCanvasElement;
+  private _playFramePosition;
+  private worker;
+  private readonly workerURL;
+  private raAsSubsc;
+  constructor(ref: ElementRef);
+  ngAfterViewInit(): void;
+  get playFramePosition(): number | null;
+  set playFramePosition(playFramePosition: number | null);
+  drawPlayPosition(): void;
+  workerFunction(): void;
+  startDraw(clear?: boolean): void;
+  private startRender;
+  drawStateText(stateText: string): void;
+  drawRendered(left: number, w: number, h: number, chs: number, psMinMax: Float32Array): void;
+  setData(audioData: AudioDataHolder | null): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AudioSignal, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AudioSignal, "audio-signal", never, {}, {}, never, never, false, never>;
+}
+declare class Complex {
+  real: number;
+  img: number;
+  static fromPolarForm(magnitude: number, argument: number): Complex;
+  constructor(real: number, img: number);
+  magnitude(): number;
+  argument(): number;
+  add(addC: Complex): Complex;
+  sub(subC: Complex): Complex;
+  mult(multC: Complex): Complex;
+  multReal(multF: number): Complex;
+  div(divisor: Complex): Complex;
+  divReal(divisor: number): Complex;
+  conjugate(): Complex;
+  equals(c: Complex): boolean;
+  toString(): string;
+}
+declare class DFTFloat32 {
+  private n;
+  private m;
+  private cosLookup;
+  private sinLookup;
+  constructor(n: number);
+  processReal(srcBuf: Float32Array): Array<Complex>;
+  processRealMagnitude(srcBuf: Float32Array): Float32Array;
+  fftCooleyTukey(real: Float32Array, img: Float32Array): void;
+  process(t: Array<Complex>): Array<Complex>;
+}
+declare class Sonagram extends AudioCanvasLayerComponent {
+  private ref;
+  dft: DFTFloat32;
+  n: any;
+  ce: HTMLDivElement;
+  sonagramCanvas: HTMLCanvasElement;
+  markerCanvas: HTMLCanvasElement;
+  sonagramCanvasRef: ElementRef;
+  markerCanvasRef: ElementRef;
+  markers: Array<Marker>;
+  private _playFramePosition;
+  private worker;
+  private readonly workerURL;
+  private raAsSubsc;
+  private dftSize;
+  constructor(ref: ElementRef);
+  ngAfterViewInit(): void;
+  get playFramePosition(): number | null;
+  set playFramePosition(playFramePosition: number | null);
+  private canvasMousePos;
+  drawStateText(stateText: string): void;
+  drawCursorPosition(e: MouseEvent, show: boolean): void;
+  drawPlayPosition(): void;
+  workerFunction(): void;
+  startDraw(clear?: boolean): void;
+  private startRender;
+  drawRendered(w: number, h: number, imgData: Uint8ClampedArray): void;
+  setData(audioData: AudioDataHolder | null): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<Sonagram, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<Sonagram, "audio-sonagram", never, {}, {}, never, never, false, never>;
+}
+export declare class ScrollPaneHorizontal {
+  static ɵfac: i0.ɵɵFactoryDeclaration<ScrollPaneHorizontal, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ScrollPaneHorizontal, "scroll-pane-horizontal", never, {}, {}, never, never, false, never>;
+}
+export declare class AudioClipUIContainer extends BasicAudioCanvasLayerComponent implements OnInit, AfterViewInit {
+  private ref;
+  private static DIVIDER_PIXEL_SIZE;
+  parentE: HTMLElement;
+  canvasRef: ElementRef;
+  dc: HTMLCanvasElement;
+  ceRef: ElementRef;
+  ce: HTMLDivElement;
+  as: AudioSignal;
+  so: Sonagram;
+  private _audioClip;
+  pointer: Marker | null;
+  selecting: Selection | null;
+  selection: Selection | null;
+  selectionEventEmitter: EventEmitter<Selection>;
+  private _playFramePosition;
+  private dragStartMouseY;
+  private dragStartY;
+  private dividerPosition;
+  userAction: boolean;
+  private _xZoom;
+  get xZoom(): number | null;
+  set xZoom(value: number | null);
+  private _fixFitToPanel;
+  set fixFitToPanel(value: boolean);
+  constructor(ref: ElementRef);
+  ngOnInit(): void;
+  ngAfterViewInit(): void;
+  onResize(event: Event): void;
+  mouseover(me: MouseEvent): void;
+  mouseleave(me: MouseEvent): void;
+  mousedown(me: MouseEvent): void;
+  onMouseup(me: MouseEvent): void;
+  onMousemove(me: MouseEvent): void;
+  pointerPositionChanged(pp: Marker): void;
+  selectingChanged(s: Selection | null): void;
+  selectionChanged(s: Selection): void;
+  private canvasMousePos;
+  dividerCursorPosition(e: MouseEvent, show: boolean): void;
+  dividerDrag(e: MouseEvent): void;
+  drawDivider(): void;
+  clipBounds(clipBounds: Rectangle): void;
+  currentXZoom(): number | null;
+  private _layout;
+  layoutScaled(): void;
+  layout(clear?: boolean): void;
+  set audioData(audioDataHolder: AudioDataHolder | null);
+  get audioData(): AudioDataHolder | null;
+  set audioClip(audioClip: AudioClip | null);
+  get playFramePosition(): number | null;
+  set playFramePosition(playFramePosition: number | null);
+  static ɵfac: i0.ɵɵFactoryDeclaration<AudioClipUIContainer, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AudioClipUIContainer, "app-audio", never, {
+    "audioData": {
+      "alias": "audioData";
+      "required": false;
+    };
+    "audioClip": {
+      "alias": "audioClip";
+      "required": false;
+    };
+  }, {
+    "selectionEventEmitter": "selectionEventEmitter";
+  }, never, never, false, never>;
+}
+declare class ActionEvent<T> {
+  private _value;
+  get value(): T | null;
+  constructor(_value?: T | null);
+}
+interface ActionEventListener<T> {
+  (ae: ActionEvent<T>): void;
+}
+export declare class Action<T> {
+  get value(): T | null;
+  private readonly _name;
+  private _value;
+  _disabled: boolean;
+  private _onAction;
+  listeners: Array<ActionEventListener<T>>;
+  private controls;
+  constructor(name: string, value?: T | null);
+  get name(): string;
+  get onAction(): ActionEventListener<T> | null;
+  set onAction(value: ActionEventListener<T> | null);
+  protected createActionEvent(value?: T | null): ActionEvent<T>;
+  perform(value?: T | null): void;
+  set disabled(disabled: boolean);
+  get disabled(): boolean;
+  addControl(ctrl: HTMLInputElement, actionEventName?: string): void;
+  removeControl(ctrl: HTMLInputElement): void;
+}
+export declare class AudioDisplayScrollPane {
+  private ref;
+  private spEl;
+  zoomInAction: Action<void>;
+  zoomOutAction: Action<void>;
+  zoomSelectedAction: Action<void>;
+  zoomFitToPanelAction: Action<void>;
+  zoomFixFitToPanelAction: Action<void>;
+  private ac;
+  constructor(ref: ElementRef);
+  updateClipBounds(): void;
+  onScroll(se: Event): void;
+  onResize(event: Event): void;
+  layout(): void;
+  selectionChanged(s: Selection | null): void;
+  set audioData(audioData: AudioDataHolder | null);
+  set audioClip(audioClip: AudioClip | null);
+  set playFramePosition(framePos: number | null);
+  static ɵfac: i0.ɵɵFactoryDeclaration<AudioDisplayScrollPane, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AudioDisplayScrollPane, "audio-display-scroll-pane", never, {
+    "audioClip": {
+      "alias": "audioClip";
+      "required": false;
+    };
+  }, {
+    "zoomInAction": "zoomInAction";
+    "zoomOutAction": "zoomOutAction";
+    "zoomSelectedAction": "zoomSelectedAction";
+    "zoomFitToPanelAction": "zoomFitToPanelAction";
+  }, never, never, false, never>;
+}
+export declare class AudioDisplay implements OnInit, AfterViewInit {
+  private ref;
+  private eRef;
+  parentE: HTMLElement;
+  private _audioClip;
+  playStartAction: Action<void> | undefined;
+  playStopAction: Action<void> | undefined;
+  playSelectionAction: Action<void> | undefined;
+  autoPlayOnSelectToggleAction: Action<boolean> | undefined;
+  zoomFitToPanelAction: Action<void>;
+  zoomSelectedAction: Action<void>;
+  zoomInAction: Action<void>;
+  zoomOutAction: Action<void>;
+  clearSelectionAction: Action<void>;
+  status: string;
+  audio: any;
+  audioDisplayScrollPane: AudioDisplayScrollPane;
+  constructor(ref: ChangeDetectorRef, eRef: ElementRef);
+  ngOnInit(): void;
+  ngAfterViewInit(): void;
+  layout(): void;
+  started(): void;
+  set audioData(audioData: AudioDataHolder);
+  set audioClip(audioClip: AudioClip | null);
+  get audioClip(): AudioClip | null;
+  set playFramePosition(playFramePosition: number);
+  error(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AudioDisplay, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AudioDisplay, "app-audiodisplay", never, {
+    "playStartAction": {
+      "alias": "playStartAction";
+      "required": false;
+    };
+    "playStopAction": {
+      "alias": "playStopAction";
+      "required": false;
+    };
+    "playSelectionAction": {
+      "alias": "playSelectionAction";
+      "required": false;
+    };
+    "autoPlayOnSelectToggleAction": {
+      "alias": "autoPlayOnSelectToggleAction";
+      "required": false;
+    };
+    "audioData": {
+      "alias": "audioData";
+      "required": false;
+    };
+    "audioClip": {
+      "alias": "audioClip";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare abstract class AudioSourceNode extends AudioWorkletNode {
+  static readonly DEFAULT_BUFFER_FILL_SECONDS = 10;
+  static readonly DEFAULT_STREAM_READ_FRAME_LEN = 1024;
+  static readonly QUANTUM_FRAME_LEN = 128;
+  protected _playStartTime: number | null;
+  abstract start(when?: number | undefined, offset?: number | undefined, duration?: number | undefined): void;
+  abstract stop(): void;
+  resetPlayPositionTime(): void;
+  get playPositionTime(): number | null;
+  onended: (() => void) | null;
+}
+export declare enum EventType {
+  CLOSED = 0,
+  READY = 1,
+  STARTED = 2,
+  POS_UPDATE = 3,
+  STOPPED = 4,
+  ENDED = 5,
+  ERROR = 6
+}
+export declare class AudioPlayerEvent {
+  private readonly _type;
+  private readonly _timePosition;
+  constructor(type: EventType, timePosition?: number);
+  get type(): EventType;
+  get timePosition(): number | undefined;
+}
+export interface AudioPlayerListener {
+  audioPlayerUpdate(e: AudioPlayerEvent): void;
+}
+export declare class AudioPlayer {
+  get autoPlayOnSelectToggleAction(): Action<boolean>;
+  static DEFAULT_BUFSIZE: number;
+  private running;
+  private readonly _startAction;
+  private readonly _startSelectionAction;
+  private readonly _autoPlayOnSelectToggleAction;
+  private readonly _stopAction;
+  bufSize: number;
+  context: AudioContext | null;
+  ready: boolean;
+  listener: AudioPlayerListener;
+  _audioClip: AudioClip | null;
+  private _audioSource;
+  sourceBufferNode: AudioBufferSourceNode | null;
+  sourceAudioWorkletNode: AudioSourceNode | null;
+  buffPos: number;
+  private zeroBufCnt;
+  n: any;
+  zb: Float32Array;
+  private playStartTime;
+  private timerVar;
+  constructor(listener: AudioPlayerListener);
+  private _audioContext;
+  private _resetPlayPosition;
+  get startAction(): Action<void>;
+  get startSelectionAction(): Action<void>;
+  get stopAction(): Action<void>;
+  set audioClip(audioClip: AudioClip | null);
+  get audioSource(): AudioSource | null;
+  set audioSource(value: AudioSource | null);
+  private _loadSourceWorkletAndInitStart;
+  private _startAudioSourceWorkletNode;
+  start(): void;
+  updateStartActions(): void;
+  startSelectionDisabled(): boolean;
+  private _start;
+  startSelected(): void;
+  stop(): void;
+  onended(): void;
+  get playPositionTime(): number | null;
+  get playPositionFrames(): number | null;
+}
+export declare class AudioDisplayPlayer implements AudioPlayerListener, OnInit, AfterViewInit {
+  protected route: ActivatedRoute;
+  protected ref: ChangeDetectorRef;
+  protected eRef: ElementRef;
+  private _audioUrl;
+  parentE: HTMLElement;
+  playStartAction: Action<void>;
+  playStopAction: Action<void>;
+  playSelectionAction: Action<void>;
+  autoPlayOnSelectToggleAction: Action<boolean>;
+  zoomFitToPanelAction: Action<void>;
+  zoomSelectedAction: Action<void>;
+  zoomInAction: Action<void>;
+  zoomOutAction: Action<void>;
+  private _audioClip;
+  ap: AudioPlayer | undefined;
+  status: string;
+  currentLoader: XMLHttpRequest | null;
+  audio: any;
+  updateTimerId: any;
+  private audioDisplayScrollPane;
+  constructor(route: ActivatedRoute, ref: ChangeDetectorRef, eRef: ElementRef);
+  ngOnInit(): void;
+  ngAfterViewInit(): void;
+  layout(): void;
+  get audioUrl(): string | null;
+  set audioUrl(value: string | null);
+  started(): void;
+  private load;
+  private loaded;
+  set audioData(audioData: AudioDataHolder);
+  startSelectionDisabled(): boolean;
+  set audioClip(audioClip: AudioClip | null);
+  get audioClip(): AudioClip | null;
+  updatePlayPosition(): void;
+  audioPlayerUpdate(e: AudioPlayerEvent): void;
+  error(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AudioDisplayPlayer, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AudioDisplayPlayer, "app-audiodisplayplayer", never, {
+    "playStartAction": {
+      "alias": "playStartAction";
+      "required": false;
+    };
+    "playStopAction": {
+      "alias": "playStopAction";
+      "required": false;
+    };
+    "playSelectionAction": {
+      "alias": "playSelectionAction";
+      "required": false;
+    };
+    "autoPlayOnSelectToggleAction": {
+      "alias": "autoPlayOnSelectToggleAction";
+      "required": false;
+    };
+    "audioData": {
+      "alias": "audioData";
+      "required": false;
+    };
+    "audioClip": {
+      "alias": "audioClip";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+export declare class AudioDisplayControl {
+  audioClip: AudioClip | null;
+  private autoplaySelectedCheckbox;
+  playStartAction: Action<void> | undefined;
+  playSelectionAction: Action<void> | undefined;
+  playStopAction: Action<void> | undefined;
+  zoomInAction: Action<void> | null;
+  zoomOutAction: Action<void> | null;
+  zoomFitToPanelAction: Action<void> | undefined;
+  zoomSelectedAction: Action<void> | undefined;
+  autoPlayOnSelectToggleAction: Action<boolean> | undefined;
+  status: string | null;
+  audio: any;
+  constructor();
+  clearSelection(): void;
+  hasSelection(): boolean;
+  autoPlaySelectionChange(ch: MatCheckboxChange): void;
+  error(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AudioDisplayControl, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AudioDisplayControl, "audio-display-control", never, {
+    "audioClip": {
+      "alias": "audioClip";
+      "required": false;
+    };
+    "playStartAction": {
+      "alias": "playStartAction";
+      "required": false;
+    };
+    "playSelectionAction": {
+      "alias": "playSelectionAction";
+      "required": false;
+    };
+    "playStopAction": {
+      "alias": "playStopAction";
+      "required": false;
+    };
+    "zoomInAction": {
+      "alias": "zoomInAction";
+      "required": false;
+    };
+    "zoomOutAction": {
+      "alias": "zoomOutAction";
+      "required": false;
+    };
+    "zoomFitToPanelAction": {
+      "alias": "zoomFitToPanelAction";
+      "required": false;
+    };
+    "zoomSelectedAction": {
+      "alias": "zoomSelectedAction";
+      "required": false;
+    };
+    "autoPlayOnSelectToggleAction": {
+      "alias": "autoPlayOnSelectToggleAction";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare enum State$1 {
+  LOADING = 0,
+  RENDERING = 1,
+  READY = 2
+}
+export declare class LevelBar implements LevelListener, AfterViewInit {
+  private ref;
+  private changeDetectorRef;
+  virtualCanvasRef: ElementRef;
+  virtualCanvas: HTMLDivElement;
+  liveLevelCanvasRef: ElementRef;
+  liveLevelCanvas: HTMLCanvasElement;
+  markerCanvasRef: ElementRef;
+  markerCanvas: HTMLCanvasElement;
+  ce: HTMLDivElement;
+  dbValues: Array<Array<number>>;
+  private pixelsPerValue;
+  peakDbLvl: number;
+  private _streamingMode;
+  private _streamingFrameLength;
+  private _staticLevelInfos;
+  private _playFramePosition;
+  private _state;
+  warnDBLevel: number;
+  constructor(ref: ElementRef, changeDetectorRef: ChangeDetectorRef);
+  ngAfterViewInit(): void;
+  onScroll(se: Event): void;
+  private updateViewportPosition;
+  set streamingMode(streamingMode: boolean);
+  set displayLevelInfos(levelInfos: LevelInfos | null | undefined);
+  set state(state: State$1);
+  set channelCount(channelCount: number);
+  set playFramePosition(playFramePosition: number | null);
+  onResize(event: Event): void;
+  layout(): void;
+  update(levelInfos: LevelInfo): void;
+  streamFinished(): void;
+  private layoutStatic;
+  private checkWidth;
+  reset(stat?: boolean): void;
+  private drawLevelBackground;
+  private drawLevelLines;
+  private drawPushValue;
+  private drawAll;
+  private framesPerPixel;
+  private drawPlayPosition;
+  static ɵfac: i0.ɵɵFactoryDeclaration<LevelBar, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<LevelBar, "audio-levelbar", never, {
+    "streamingMode": {
+      "alias": "streamingMode";
+      "required": false;
+    };
+    "displayLevelInfos": {
+      "alias": "displayLevelInfos";
+      "required": false;
+    };
+    "state": {
+      "alias": "state";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+export type Mode = "MANUAL" | "AUTOPROGRESS" | "AUTORECORDING";
+export type PromptPhase = "IDLE" | "PRERECORDING" | "PRERECORDINGONLY" | "RECORDING";
+type Order = 'SEQUENTIAL' | 'RANDOM' | 'RANDOMIZED';
+type Decoration = 'underline';
+type Style = 'italic' | 'normal';
+type FontWeight = 'normal' | 'bold';
+type BlockType = 'p';
+type TextType = 'text' | 'font';
+interface Recinstructions$1 {
+  recinstructions: string;
+}
+interface Text {
+  type: TextType;
+  color?: string;
+  decoration?: Decoration;
+  size?: string;
+  weight?: FontWeight;
+  style?: Style;
+  text: string | Text;
+}
+interface Block {
+  type: BlockType;
+  texts: Array<Text>;
+}
+interface Body {
+  blocks?: Array<Block>;
+}
+interface PromptDoc {
+  body?: Body;
+}
+export interface Mediaitem {
+  text?: string;
+  src?: string;
+  promptDoc?: PromptDoc;
+  mimetype?: string;
+  defaultVirtualViewBox?: VirtualViewBox;
+  alt?: string;
+}
+export interface PromptItem {
+  type?: string;
+  itemcode?: string;
+  prerecdelay?: number;
+  prerecording?: number;
+  recduration?: number;
+  duration?: number;
+  postrecording?: number;
+  postrecdelay?: number;
+  recinstructions?: Recinstructions$1;
+  mediaitems: Array<Mediaitem>;
+}
+export interface Group {
+  order?: Order;
+  promptItems: Array<PromptItem>;
+  _shuffledPromptItems: Array<PromptItem>;
+}
+export interface Section {
+  mode: Mode;
+  promptphase: PromptPhase;
+  order?: Order;
+  training: boolean;
+  groups: Array<Group>;
+  _shuffledGroups: Array<Group>;
+}
+interface VirtualViewBox {
+  height: number;
+}
+export interface Script {
+  virtualViewBox?: VirtualViewBox;
+  sections: Array<Section>;
+}
+interface RecordingFileDescriptor {
+  recording: PromptItem;
+  version: number;
+}
+declare class RecordingFileDescriptorImpl {
+  recording: PromptItem;
+  version: number;
+  frames?: number;
+  samplerate?: number;
+  channels?: number;
+  constructor();
+}
+declare class RecordingFile {
+  recordingFileId: string | number | null;
+  uuid: string | null;
+  serverPersisted: boolean;
+  date: string | null;
+  _dateAsDateObj: Date | null;
+  startedDate: string | null;
+  _startedAsDateObj?: Date | null;
+  audioDataHolder: AudioDataHolder | null;
+  session: string | number | null;
+  channels: number | null;
+  frames: number | null;
+  samplerate: number | null;
+  timeLength: number | null;
+  editSampleRate: number | null;
+  editStartFrame: number | null;
+  editEndFrame: number | null;
+  constructor(uuid: string, sessionId: string | number, audioDataHolder: AudioDataHolder | null);
+  filenameString(): string;
+  equals(otherRecordingFile: RecordingFile | null): boolean;
+  toString(): string;
+}
+export declare class SprRecordingFile extends RecordingFile implements RecordingFileDescriptor {
+  itemCode: string;
+  recording: PromptItem;
+  version: number;
+  constructor(sessionId: string | number, itemcode: string, version: number, audioDataHolder: AudioDataHolder | null);
+  recordingFileDone(): boolean;
+  filenameString(): string;
+  toString(): string;
+}
+declare class Item {
+  private _promptAsString;
+  private _training;
+  private _recording;
+  recs: Array<SprRecordingFile> | null;
+  constructor(_promptAsString: string, _training: boolean, _recording: boolean);
+  itemDone(): boolean;
+  get promptAsString(): string;
+  get training(): boolean;
+  get recording(): boolean;
+}
+declare class Progress {
+  private elRef;
+  isObs: IntersectionObserver;
+  constructor(elRef: ElementRef);
+  items: Array<Item> | undefined;
+  selectedItemIdx: number;
+  enableDownload: boolean;
+  onRowSelect: EventEmitter<number>;
+  set rowSelect(rowIdx: number);
+  onShowDoneAction: EventEmitter<number>;
+  set clickDone(rowIdx: number);
+  onDownloadDoneAction: EventEmitter<number>;
+  set clickDownloadDone(rowIdx: number);
+  latestRecordingAvail(item: Item): boolean | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<Progress, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<Progress, "app-sprprogress", never, {
+    "items": {
+      "alias": "items";
+      "required": false;
+    };
+    "selectedItemIdx": {
+      "alias": "selectedItemIdx";
+      "required": false;
+    };
+    "enableDownload": {
+      "alias": "enableDownload";
+      "required": false;
+    };
+  }, {
+    "onRowSelect": "onRowSelect";
+    "rowSelect": "rowSelect";
+    "onShowDoneAction": "onShowDoneAction";
+    "clickDone": "clickDone";
+    "onDownloadDoneAction": "onDownloadDoneAction";
+    "clickDownloadDone": "clickDownloadDone";
+  }, never, never, false, never>;
+}
+declare const enum State {
+  IDLE = 0,
+  PRERECORDING = 1,
+  POSTRECORDING = 2,
+  RECORDING = 3,
+  OFF = 4
+}
+interface StartStopSignal {
+  status: State;
+}
+declare class SimpleTrafficLight implements StartStopSignal {
+  lighttop: string;
+  lightmid: string;
+  lightbottom: string;
+  constructor();
+  set status(status: State);
+  static ɵfac: i0.ɵɵFactoryDeclaration<SimpleTrafficLight, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SimpleTrafficLight, "app-simpletrafficlight", never, {
+    "status": {
+      "alias": "status";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+export declare class ResponsiveComponent {
+  protected breakpointObserver: BreakpointObserver;
+  screenXs: boolean;
+  constructor(breakpointObserver: BreakpointObserver);
+  static ɵfac: i0.ɵɵFactoryDeclaration<ResponsiveComponent, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ResponsiveComponent, never, never, {}, {}, never, never, true, never>;
+}
+declare class StatusDisplay {
+  statusAlertType: string;
+  statusMsg: string;
+  statusWaiting: boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<StatusDisplay, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<StatusDisplay, "app-sprstatusdisplay", never, {
+    "statusAlertType": {
+      "alias": "statusAlertType";
+      "required": false;
+    };
+    "statusMsg": {
+      "alias": "statusMsg";
+      "required": false;
+    };
+    "statusWaiting": {
+      "alias": "statusWaiting";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class UploadStatus$1 {
+  private _awaitNewUpload;
+  spinnerMode: ProgressSpinnerMode;
+  _status: string;
+  colorStatus: ThemePalette;
+  _value: number;
+  displayValue: string | null;
+  toolTipText: string;
+  private _updateSpinner;
+  set value(value: number);
+  set awaitNewUpload(awaitNewUpload: boolean);
+  set status(status: string);
+  get status(): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<UploadStatus$1, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<UploadStatus$1, "app-uploadstatus", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+    };
+    "awaitNewUpload": {
+      "alias": "awaitNewUpload";
+      "required": false;
+    };
+    "status": {
+      "alias": "status";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class ProgressDisplay {
+  progressMsg: string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ProgressDisplay, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ProgressDisplay, "app-sprprogressdisplay", never, {}, {}, never, never, false, never>;
+}
+declare class TransportActions {
+  startAction: Action<void>;
+  stopAction: Action<void>;
+  nextAction: Action<void>;
+  fwdNextAction: Action<void>;
+  pauseAction: Action<void>;
+  fwdAction: Action<void>;
+  bwdAction: Action<void>;
+  stopNonrecordingAction: Action<void>;
+  constructor();
+}
+declare class TransportPanel extends ResponsiveComponent {
+  readonly: boolean;
+  actions: TransportActions;
+  navigationEnabled: boolean;
+  pausingEnabled: boolean;
+  startStopNextButtonName: string;
+  startStopNextButtonIconName: string;
+  constructor(breakpointObserver: BreakpointObserver);
+  startDisabled(): boolean;
+  stopDisabled(): boolean;
+  nextDisabled(): boolean;
+  stopNonrecordingDisabled(): boolean;
+  pauseDisabled(): boolean;
+  fwdDisabled(): boolean;
+  fwdNextDisabled(): boolean;
+  bwdDisabled(): boolean;
+  startStopNextName(): string;
+  startStopNextIconName(): string;
+  startStopNextIconColor(): string;
+  startStopNextPerform(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TransportPanel, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<TransportPanel, "app-sprtransport", never, {
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+    };
+    "actions": {
+      "alias": "actions";
+      "required": false;
+    };
+    "navigationEnabled": {
+      "alias": "navigationEnabled";
+      "required": false;
+    };
+    "pausingEnabled": {
+      "alias": "pausingEnabled";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class WakeLockIndicator {
+  _screenLocked: boolean;
+  constructor();
+  set screenLocked(screenLock: boolean);
+  static ɵfac: i0.ɵɵFactoryDeclaration<WakeLockIndicator, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WakeLockIndicator, "app-wakelockindicator", never, {
+    "screenLocked": {
+      "alias": "screenLocked";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class ReadyStateIndicator {
+  _ready: boolean;
+  hourGlassIconName: string;
+  readyStateToolTip: string;
+  constructor();
+  set ready(ready: boolean);
+  get ready(): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ReadyStateIndicator, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ReadyStateIndicator, "app-readystateindicator", never, {
+    "ready": {
+      "alias": "ready";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class ControlPanel extends ResponsiveComponent {
+  protected bpo: BreakpointObserver;
+  dialog: MatDialog;
+  statusDisplay: StatusDisplay;
+  transportPanel: TransportPanel;
+  readonly: boolean;
+  transportActions: TransportActions;
+  processing: boolean;
+  statusMsg: string;
+  statusAlertType: string;
+  statusWaiting: boolean;
+  uploadStatus: string;
+  uploadProgress: number;
+  currentRecording: AudioBuffer | null | undefined;
+  enableUploadRecordings: boolean;
+  navigationEnabled: boolean;
+  _ready: boolean;
+  constructor(bpo: BreakpointObserver, dialog: MatDialog);
+  set ready(ready: boolean);
+  get ready(): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ControlPanel, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<ControlPanel, "app-sprcontrolpanel", never, {
+    "readonly": {
+      "alias": "readonly";
+      "required": false;
+    };
+    "transportActions": {
+      "alias": "transportActions";
+      "required": false;
+    };
+    "processing": {
+      "alias": "processing";
+      "required": false;
+    };
+    "statusMsg": {
+      "alias": "statusMsg";
+      "required": false;
+    };
+    "statusAlertType": {
+      "alias": "statusAlertType";
+      "required": false;
+    };
+    "statusWaiting": {
+      "alias": "statusWaiting";
+      "required": false;
+    };
+    "uploadStatus": {
+      "alias": "uploadStatus";
+      "required": false;
+    };
+    "uploadProgress": {
+      "alias": "uploadProgress";
+      "required": false;
+    };
+    "currentRecording": {
+      "alias": "currentRecording";
+      "required": false;
+    };
+    "enableUploadRecordings": {
+      "alias": "enableUploadRecordings";
+      "required": false;
+    };
+    "navigationEnabled": {
+      "alias": "navigationEnabled";
+      "required": false;
+    };
+    "ready": {
+      "alias": "ready";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare enum SampleSize {
+  INT16 = 16,
+  INT32 = 32
+}
+export declare class WavWriter {
+  static readonly DEFAULT_SAMPLE_SIZE: SampleSize;
+  private readonly sampleSizeInBytes;
+  private encodingFloat;
+  private sampleSize;
+  private sampleSizeInBits;
+  private bw;
+  private workerURL;
+  constructor(encodingFloat?: boolean, sampleSize?: SampleSize);
+  workerFunction(): void;
+  writeFmtChunk(audioBuffer: AudioBuffer): void;
+  writeFactChunk(audioBuffer: AudioBuffer): void;
+  writeDataChunk(audioBuffer: AudioBuffer): void;
+  writeChunkHeader(name: string, chkLen: number): void;
+  writeAsync(audioBuffer: AudioBuffer, callback: (wavFileData: ArrayBuffer) => any): void;
+  write(audioBuffer: AudioBuffer): Uint8Array;
+  writeHeader(audioBuffer: AudioBuffer): number;
+}
+interface AudioFormat$1 {
+  channels: number;
+}
+interface MediaCaptureFormat {
+  audioChannelCount: number;
+}
+interface AudioDevice {
+  name: string;
+  playback: boolean;
+  regex: boolean;
+}
+declare enum Platform$1 {
+  Linux = "LINUX",
+  macOS = "MACOS",
+  Windows = "WINDOWS",
+  Android = "ANDROID"
+}
+declare enum AudioStorageType {
+  MEM_ENTIRE = "MEM_ENTIRE",
+  MEM_CHUNKED = "MEM_CHUNKED",
+  DB_CHUNKED = "DB_CHUNKED",
+  NET_CHUNKED = "NET_CHUNKED",
+  MEM_ENTIRE_AUTO_NET_CHUNKED = "MEM_ENTIRE_AUTO_NET_CHUNKED",
+  MEM_CHUNKED_AUTO_NET_CHUNKED = "MEM_CHUNKED_AUTO_NET_CHUNKED"
+}
+declare enum AudioStorageFormatEncoding {
+  PCM_SIGNED = "PCM_SIGNED",
+  PCM_FLOAT = "PCM_FLOAT"
+}
+interface MediaStorageFormat {
+  audioEncoding?: AudioStorageFormatEncoding;
+  audioPCMsampleSizeInBits?: SampleSize;
+}
+interface AutoGainControlConfig {
+  value: boolean;
+  platform: Platform$1;
+}
+interface Project {
+  name: string;
+  recordingDeviceWakeLock?: boolean;
+  audioFormat?: AudioFormat$1;
+  mediaCaptureFormat?: MediaCaptureFormat;
+  autoGainControlConfigs?: Array<AutoGainControlConfig>;
+  allowEchoCancellation?: boolean;
+  audioDevices?: Array<AudioDevice>;
+  chunkedRecording?: boolean;
+  clientAudioStorageType?: AudioStorageType;
+  mediaStorageFormat?: MediaStorageFormat;
+  showSessionCompleteMessage?: boolean;
+}
+export declare class ProjectService {
+  private http;
+  private platformLocation;
+  private config?;
+  static readonly PROJECT_API_CTX = "project";
+  private readonly projectCtxUrl;
+  private readonly withCredentials;
+  constructor(http: HttpClient, platformLocation: PlatformLocation, config?: SpeechRecorderConfig | undefined);
+  private appendRequestUUIDForDevelopmentServer;
+  projectUrl(id: string): string;
+  projectResourceUrl(projectId: string, relResourcePath: string): string;
+  projectObservable(id: string): Observable<Project>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ProjectService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class Recinstructions {
+  recinstructions: string | null | undefined;
+  selectedItemIdx: number | null | undefined;
+  itemCount: number | undefined;
+  displayText(): string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<Recinstructions, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<Recinstructions, "spr-recinstructions", never, {
+    "recinstructions": {
+      "alias": "recinstructions";
+      "required": false;
+    };
+    "selectedItemIdx": {
+      "alias": "selectedItemIdx";
+      "required": false;
+    };
+    "itemCount": {
+      "alias": "itemCount";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class Prompter {
+  private elRef;
+  private renderer;
+  private projectService;
+  projectName: string | undefined;
+  private _promptMediaItems;
+  prompterHeight: number;
+  private _text;
+  private _src;
+  private _blocks;
+  mimetype: string;
+  private currPromptChild;
+  prompterStyleFill: boolean;
+  constructor(elRef: ElementRef, renderer: Renderer2, projectService: ProjectService);
+  get text(): string | null | undefined;
+  get src(): string | null | undefined;
+  srcUrl(): string | null;
+  width(): number | null;
+  height(): number | null;
+  private appendTextElement;
+  set promptMediaItems(pMis: Array<Mediaitem> | null);
+  static ɵfac: i0.ɵɵFactoryDeclaration<Prompter, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<Prompter, "app-sprprompter", never, {
+    "projectName": {
+      "alias": "projectName";
+      "required": false;
+    };
+    "prompterHeight": {
+      "alias": "prompterHeight";
+      "required": false;
+    };
+    "promptMediaItems": {
+      "alias": "promptMediaItems";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class PromptContainer implements OnInit, AfterContentChecked {
+  private elRef;
+  projectName: string | undefined;
+  private _mediaitems;
+  prompterHeight: number;
+  fontSize: number;
+  fontSizeChange: boolean;
+  contentChecked: boolean;
+  prDisplay: string;
+  defaultStyle: CSSStyleDeclaration;
+  defaultFontSizePx: number;
+  autoFontSize: boolean;
+  prompter: Prompter;
+  constructor(elRef: ElementRef);
+  ngOnInit(): void;
+  ngAfterContentChecked(): void;
+  set mediaitems(mediaitems: Array<Mediaitem> | null);
+  get mediaitems(): Array<Mediaitem> | null;
+  onResize(event: Event): void;
+  private layout;
+  private fontSizeToFit;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PromptContainer, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PromptContainer, "app-sprpromptcontainer", never, {
+    "projectName": {
+      "alias": "projectName";
+      "required": false;
+    };
+    "mediaitems": {
+      "alias": "mediaitems";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class PromptingContainer {
+  private ref;
+  projectName: string | undefined;
+  promptItem: PromptItem | null;
+  showPrompt: boolean;
+  selectedItemIdx: number;
+  itemCount: number | undefined;
+  transportActions: TransportActions;
+  private e;
+  private startX;
+  private touchStartTimeStamp;
+  constructor(ref: ElementRef);
+  ngOnInit(): void;
+  onTouchstart(ev: TouchEvent | any): void;
+  onTouchEnd(ev: TouchEvent | any): void;
+  onTouchMove(ev: TouchEvent | any): void;
+  onTouchCancel(ev: TouchEvent | any): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<PromptingContainer, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<PromptingContainer, "app-sprpromptingcontainer", never, {
+    "projectName": {
+      "alias": "projectName";
+      "required": false;
+    };
+    "promptItem": {
+      "alias": "promptItem";
+      "required": false;
+    };
+    "showPrompt": {
+      "alias": "showPrompt";
+      "required": false;
+    };
+    "selectedItemIdx": {
+      "alias": "selectedItemIdx";
+      "required": false;
+    };
+    "itemCount": {
+      "alias": "itemCount";
+      "required": false;
+    };
+    "transportActions": {
+      "alias": "transportActions";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class Prompting extends ResponsiveComponent {
+  protected bpo: BreakpointObserver;
+  constructor(bpo: BreakpointObserver);
+  simpleTrafficLight: SimpleTrafficLight;
+  audioDisplay: AudioDisplay;
+  projectName: string | undefined;
+  startStopSignalState: State;
+  promptItem: PromptItem | null;
+  showPrompt: boolean;
+  items: Array<Item> | undefined;
+  selectedItemIdx: number;
+  transportActions: TransportActions;
+  enableDownload: boolean;
+  audioSignalCollapsed: boolean;
+  displayAudioClip: AudioClip | null;
+  playStartAction: Action<void> | undefined;
+  playSelectionAction: Action<void> | undefined;
+  autoPlayOnSelectToggleAction: Action<boolean> | undefined;
+  playStopAction: Action<void> | undefined;
+  onItemSelect: EventEmitter<number>;
+  onNextItem: EventEmitter<any>;
+  onPrevItem: EventEmitter<any>;
+  itemSelect(rowIdx: number): void;
+  nextItem(): void;
+  prevItem(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<Prompting, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<Prompting, "app-sprprompting", never, {
+    "projectName": {
+      "alias": "projectName";
+      "required": false;
+    };
+    "startStopSignalState": {
+      "alias": "startStopSignalState";
+      "required": false;
+    };
+    "promptItem": {
+      "alias": "promptItem";
+      "required": false;
+    };
+    "showPrompt": {
+      "alias": "showPrompt";
+      "required": false;
+    };
+    "items": {
+      "alias": "items";
+      "required": false;
+    };
+    "selectedItemIdx": {
+      "alias": "selectedItemIdx";
+      "required": false;
+    };
+    "transportActions": {
+      "alias": "transportActions";
+      "required": false;
+    };
+    "enableDownload": {
+      "alias": "enableDownload";
+      "required": false;
+    };
+    "audioSignalCollapsed": {
+      "alias": "audioSignalCollapsed";
+      "required": false;
+    };
+    "displayAudioClip": {
+      "alias": "displayAudioClip";
+      "required": false;
+    };
+    "playStartAction": {
+      "alias": "playStartAction";
+      "required": false;
+    };
+    "playSelectionAction": {
+      "alias": "playSelectionAction";
+      "required": false;
+    };
+    "autoPlayOnSelectToggleAction": {
+      "alias": "autoPlayOnSelectToggleAction";
+      "required": false;
+    };
+    "playStopAction": {
+      "alias": "playStopAction";
+      "required": false;
+    };
+  }, {
+    "onItemSelect": "onItemSelect";
+    "onNextItem": "onNextItem";
+    "onPrevItem": "onPrevItem";
+  }, never, never, false, never>;
+}
+declare class RecordingItemControls extends ResponsiveComponent implements OnDestroy {
+  protected bpo: BreakpointObserver;
+  private ref;
+  private changeDetectorRef;
+  ce: HTMLDivElement | null;
+  audioSignalCollapsed: boolean;
+  private _displayAudioBuffer;
+  enableDownload: boolean;
+  peakDbLvl: number;
+  _displayLevelInfos: LevelInfos | null;
+  _agc: boolean | null | undefined;
+  agcString: string;
+  set agc(agc: boolean | null | undefined);
+  onShowRecordingDetails: EventEmitter<void>;
+  onDownloadRecording: EventEmitter<void>;
+  disableAudioDetails: boolean;
+  audioLoaded: boolean;
+  playStartAction: Action<void> | undefined;
+  playStopAction: Action<void> | undefined;
+  playStartEnabled: boolean;
+  playStopEnabled: boolean;
+  private updateTimerId;
+  private destroyed;
+  warnDbLevel: number;
+  constructor(bpo: BreakpointObserver, ref: ElementRef, changeDetectorRef: ChangeDetectorRef);
+  ngOnDestroy(): void;
+  showRecordingDetails(): void;
+  downloadRecording(): void;
+  ngAfterViewInit(): void;
+  set displayLevelInfos(levelInfos: LevelInfos | null);
+  error(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RecordingItemControls, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RecordingItemControls, "spr-recordingitemcontrols", never, {
+    "audioSignalCollapsed": {
+      "alias": "audioSignalCollapsed";
+      "required": false;
+    };
+    "enableDownload": {
+      "alias": "enableDownload";
+      "required": false;
+    };
+    "peakDbLvl": {
+      "alias": "peakDbLvl";
+      "required": false;
+    };
+    "agc": {
+      "alias": "agc";
+      "required": false;
+    };
+    "disableAudioDetails": {
+      "alias": "disableAudioDetails";
+      "required": false;
+    };
+    "audioLoaded": {
+      "alias": "audioLoaded";
+      "required": false;
+    };
+    "playStartAction": {
+      "alias": "playStartAction";
+      "required": false;
+    };
+    "playStopAction": {
+      "alias": "playStopAction";
+      "required": false;
+    };
+    "displayLevelInfos": {
+      "alias": "displayLevelInfos";
+      "required": false;
+    };
+  }, {
+    "onShowRecordingDetails": "onShowRecordingDetails";
+    "onDownloadRecording": "onDownloadRecording";
+  }, never, never, false, never>;
+}
+declare class RecordingItemDisplay extends ResponsiveComponent implements LevelListener, OnDestroy {
+  protected bpo: BreakpointObserver;
+  private ref;
+  private changeDetectorRef;
+  ce: HTMLDivElement | null;
+  liveLevel: LevelBar;
+  streamingMode: boolean;
+  audioSignalCollapsed: boolean;
+  private _displayAudioBuffer;
+  enableDownload: boolean;
+  peakDbLvl: number;
+  _displayLevelInfos: LevelInfos | null;
+  _agc: boolean | null | undefined;
+  agcString: string;
+  set agc(agc: boolean | null | undefined);
+  onShowRecordingDetails: EventEmitter<void>;
+  onDownloadRecording: EventEmitter<void>;
+  playStartAction: Action<void> | undefined;
+  playStopAction: Action<void> | undefined;
+  playStartEnabled: boolean;
+  playStopEnabled: boolean;
+  private updateTimerId;
+  private destroyed;
+  warnDbLevel: number;
+  constructor(bpo: BreakpointObserver, ref: ElementRef, changeDetectorRef: ChangeDetectorRef);
+  ngOnDestroy(): void;
+  set displayAudioBuffer(displayAudioBuffer: AudioBuffer | null | undefined);
+  get displayAudioBuffer(): AudioBuffer | null | undefined;
+  showRecordingDetails(): void;
+  downloadRecording(): void;
+  ngAfterViewInit(): void;
+  set displayLevelInfos(levelInfos: LevelInfos | null);
+  set channelCount(channelCount: number);
+  set playFramePosition(playFramePosition: number);
+  update(levelInfo: LevelInfo, peakLevelInfo: LevelInfo): void;
+  error(): void;
+  streamFinished(): void;
+  reset(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RecordingItemDisplay, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RecordingItemDisplay, "spr-recordingitemdisplay", never, {
+    "streamingMode": {
+      "alias": "streamingMode";
+      "required": false;
+    };
+    "audioSignalCollapsed": {
+      "alias": "audioSignalCollapsed";
+      "required": false;
+    };
+    "enableDownload": {
+      "alias": "enableDownload";
+      "required": false;
+    };
+    "agc": {
+      "alias": "agc";
+      "required": false;
+    };
+    "playStartAction": {
+      "alias": "playStartAction";
+      "required": false;
+    };
+    "playStopAction": {
+      "alias": "playStopAction";
+      "required": false;
+    };
+    "displayAudioBuffer": {
+      "alias": "displayAudioBuffer";
+      "required": false;
+    };
+    "displayLevelInfos": {
+      "alias": "displayLevelInfos";
+      "required": false;
+    };
+  }, {
+    "onShowRecordingDetails": "onShowRecordingDetails";
+    "onDownloadRecording": "onDownloadRecording";
+  }, never, never, false, never>;
+}
+declare class WarningBar {
+  warningText: string;
+  set show(show: boolean);
+  displayClass: string;
+  static ɵfac: i0.ɵɵFactoryDeclaration<WarningBar, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<WarningBar, "app-warningbar", never, {
+    "warningText": {
+      "alias": "warningText";
+      "required": false;
+    };
+    "show": {
+      "alias": "show";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class ArrayAudioBuffer extends BasicAudioSource {
+  private _channelCount;
+  private _sampleRate;
+  private _data;
+  private _chunkCount;
+  private _frameLen;
+  private _duration;
+  private _sealed;
+  constructor(_channelCount: number, _sampleRate: number, _data: Array<Array<Float32Array>>);
+  private updateFrameLen;
+  seal(): void;
+  sealed(): boolean;
+  static fromAudioBuffer(audioBuffer: AudioBuffer, chunkFrameSize?: number): ArrayAudioBuffer;
+  appendAudioBuffer(audioBuffer: AudioBuffer): void;
+  get channelCount(): number;
+  frames(framePos: number, frameLen: number, bufs: Float32Array[]): number;
+  get sampleRate(): number;
+  get frameLen(): number;
+  get chunkCount(): number;
+  get data(): Array<Array<Float32Array>>;
+  asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+  audioInputStream(): Float32ArrayInputStream | null;
+  get duration(): number;
+  get numberOfChannels(): number;
+  releaseAudioData(): Observable<void>;
+  sampleCounts(): number;
+  randomAccessAudioStream(): RandomAccessAudioStream;
+}
+declare class PersistentAudioStorageTarget {
+  private _indexedDb;
+  private _storeName;
+  get indexedDb(): IDBDatabase;
+  get storeName(): string;
+  constructor(_indexedDb: IDBDatabase, _storeName: string);
+  transaction(mode?: IDBTransactionMode): IDBTransaction;
+  objectStore(mode?: IDBTransactionMode): IDBObjectStore;
+  deleteAll(): Observable<void>;
+}
+declare class IndexedDbAudioBuffer extends BasicAudioSource implements AudioSource {
+  private _persistentAudioStorageTarget;
+  private _channelCount;
+  private _sampleRate;
+  private _chunkFrameLen;
+  private _frameLen;
+  private _uuid;
+  get chunkFrameLen(): number;
+  get persistentAudioStorageTarget(): PersistentAudioStorageTarget;
+  get uuid(): string;
+  private _chunkCount;
+  private indDbChkIdx;
+  private _sealed;
+  private _storeError;
+  constructor(_persistentAudioStorageTarget: PersistentAudioStorageTarget, _channelCount: number, _sampleRate: number, _chunkFrameLen: number, _frameLen: number, _uuid: string);
+  get channelCount(): number;
+  sealed(): boolean;
+  seal(): void;
+  private deleteChunk;
+  private deleteAllBufs;
+  get sampleRate(): number;
+  get frameLen(): number;
+  get chunkCount(): number;
+  appendRawAudioData(data: Array<Array<Float32Array>>): Observable<void>;
+  static fromChunkAudioBuffer(persistentAudioStorageTarget: PersistentAudioStorageTarget, audioBuffer: AudioBuffer): Observable<IndexedDbAudioBuffer>;
+  appendChunkAudioBuffer(audioBuffer: AudioBuffer): Observable<void>;
+  releaseAudioData(): Observable<void>;
+  toString(): string;
+  asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+  audioInputStream(): Float32ArrayInputStream | null;
+  get duration(): number;
+  get numberOfChannels(): number;
+  sampleCounts(): number;
+  randomAccessAudioStream(): RandomAccessAudioStream;
+}
+interface AudioCaptureListener {
+  opened(): void;
+  started(): void;
+  stopped(): void;
+  closed(): void;
+  error(msg?: string, advice?: string): void;
+}
+declare class AudioCapture {
+  get maxAutoNetMemStoreSamples(): number;
+  set maxAutoNetMemStoreSamples(value: number);
+  set recUUID(value: string | null);
+  get recUUID(): string | null;
+  get audioStorageType(): AudioStorageType;
+  set audioStorageType(value: AudioStorageType);
+  get persistentAudioStorageTarget(): PersistentAudioStorageTarget | null;
+  set persistentAudioStorageTarget(value: PersistentAudioStorageTarget | null);
+  get opened(): boolean;
+  static BUFFER_SIZE: number;
+  private static readonly DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES;
+  private _maxAutoNetMemStoreSamples;
+  private static captureInterceptorModuleRegistered;
+  context: AudioContext | null;
+  stream: MediaStream;
+  channelCount: number;
+  private _recUUID;
+  mediaStream: any;
+  agcStatus: boolean | null;
+  bufferingNode: AudioNode | null;
+  listener: AudioCaptureListener;
+  data: Array<Array<Float32Array>> | null;
+  currentSampleRate: number;
+  n: Navigator;
+  audioOutStream: SequenceAudioFloat32OutStream | null;
+  private disconnectStreams;
+  private _opened;
+  private capturing;
+  framesRecorded: number;
+  private _audioStorageType;
+  private _persistentAudioStorageTarget;
+  private persisted;
+  private persistError;
+  private inddbAudioBuffer;
+  constructor();
+  private _audioContext;
+  private initData;
+  listDevices(): void;
+  private dummySession;
+  private stopAllSessionTracks;
+  deviceInfos(cb: (deviceInfos: MediaDeviceInfo[] | null) => any, retry?: boolean, dummyStream?: MediaStream): void;
+  printDevices(l: MediaDeviceInfo[]): void;
+  addCaptureInterceptor(): void;
+  open(channelCount: number, selDeviceId?: ConstrainDOMString | undefined, autoGainControlConfigs?: Array<AutoGainControlConfig> | null | undefined, allowEchoCancellation?: boolean): void;
+  _open(channelCount: number, selDeviceId?: ConstrainDOMString | undefined, autoGainControlConfigs?: Array<AutoGainControlConfig> | null | undefined, allowEchoCancellation?: boolean): void;
+  private _start;
+  start(): void;
+  stop(): void;
+  store(): void;
+  close(): void;
+  audioBuffer(): AudioBuffer | null;
+  audioBufferArray(): ArrayAudioBuffer | null;
+  inddbAudioBufferArray(): IndexedDbAudioBuffer | null;
+}
+type Status$2 = "CREATED" | "LOADED" | "STARTED_TRAINING" | "STARTED" | "COMPLETED";
+type Type = 'NORM' | 'TEST' | 'TEST_DEF_A' | 'SINUS_TEST';
+export interface Session {
+  sessionId: string | number;
+  status: Status$2;
+  sealed?: boolean;
+  type: Type;
+  loadedDate?: Date;
+  startedTrainingDate?: Date;
+  startedDate?: Date;
+  completedDate?: Date;
+  restartedDate?: Date;
+  project: string;
+  script: string | number;
+}
+export declare class SessionService {
+  private http;
+  private config?;
+  get uploadCount(): number;
+  static readonly SESSION_API_CTX = "session";
+  private apiEndPoint;
+  private readonly sessionsUrl;
+  private readonly withCredentials;
+  private _uploadCount;
+  constructor(http: HttpClient, config?: SpeechRecorderConfig | undefined);
+  sessionObserver(id: string): Observable<Session>;
+  patchSessionObserver(session: Session, body: any): Observable<Session>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SessionService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare enum UploadStatus {
+  IDLE = 1,
+  UPLOADING = 2,
+  ABORT = 3,
+  DONE = 0,
+  ERR = -1
+}
+declare enum UploaderStatus {
+  DONE = 0,
+  UPLOADING = 1,
+  TRY_UPLOADING = 2,
+  NEXT = 3,
+  ERR = -1
+}
+declare class UploaderStatusChangeEvent {
+  private readonly _sizeQueued;
+  private readonly _sizeDone;
+  private readonly _status;
+  constructor(sizeQueued: number, sizeDone: number, status: UploaderStatus);
+  get sizeQueued(): number;
+  get sizeDone(): number;
+  sizeInQueue(): number;
+  get status(): UploaderStatus;
+  uploadDone(): boolean;
+  percentDone(): number;
+}
+declare class Upload {
+  private _serverPersistable;
+  get serverPersistable(): ServerPersistable | null;
+  private readonly _data;
+  private readonly _url;
+  status: UploadStatus;
+  onDone: ((upload: Upload) => void) | null;
+  constructor(blob: Blob | FormData, url: string, _serverPersistable?: ServerPersistable | null);
+  get url(): string;
+  get data(): Blob | FormData;
+  done(): void;
+  toString: () => string;
+}
+declare class UploadHolder {
+  onUploadSet: ((upload: Upload) => void) | null;
+  get upload(): Upload | null;
+  set upload(value: Upload | null);
+  private _upload;
+}
+declare class UploadSet {
+  private uploads;
+  private _complete;
+  private _onDone;
+  add(upload: Upload | UploadHolder): void;
+  complete(): void;
+  set onDone(value: ((uploadSet: UploadSet) => void) | null);
+  private checkUploadStates;
+}
+interface ServerPersistable {
+  serverPersisted: boolean;
+}
+declare class Uploader {
+  private http;
+  private withCredentials;
+  POST_MIN_TIMEOUT: number;
+  POST_TIMEOUT_PER_KB: number;
+  RETRY_DELAY: number;
+  DEBUG_DELAY: number;
+  private status;
+  private readonly que;
+  listener: ((ue: UploaderStatusChangeEvent) => void) | null;
+  private _sizeQueued;
+  private _sizeDone;
+  private retryTimerRunning;
+  private retryTimerId;
+  private te;
+  constructor(http: HttpClient, withCredentials?: boolean);
+  private dataSize;
+  private uploadDone;
+  private startUpload;
+  private processError;
+  private process;
+  queueUpload(ul: Upload): void;
+}
+declare class SpeechRecorderUploader extends Uploader {
+  private httpClient;
+  private config?;
+  constructor(httpClient: HttpClient, config?: SpeechRecorderConfig | undefined);
+  static ɵfac: i0.ɵɵFactoryDeclaration<SpeechRecorderUploader, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class AudioFormat {
+  sampleRate: number;
+  channelCount: number;
+  constructor(sampleRate: number, channelCount: number);
+}
+declare class PCMAudioFormat extends AudioFormat {
+  encodingFloat: boolean;
+  sampleSize: number;
+  sampleSizeInBits: number;
+  constructor(sampleRate: number, channelCount: number, sampleSize: number, sampleSizeInBits: number, encodingFloat?: boolean);
+  toString(): string;
+}
+declare class ChunkDownload {
+  private _orgPCMAudioFormat;
+  private _orgFrameLength;
+  private _decodedAudioBuffer;
+  get orgPCMAudioFormat(): PCMAudioFormat;
+  get orgFrameLength(): number;
+  get decodedAudioBuffer(): AudioBuffer;
+  constructor(_orgPCMAudioFormat: PCMAudioFormat, _orgFrameLength: number, _decodedAudioBuffer: AudioBuffer);
+}
+declare class BasicRecordingService {
+  protected http: HttpClient;
+  protected config?: SpeechRecorderConfig | undefined;
+  static readonly DEFAULT_CHUNKED_DOWNLOAD_SECONDS: number;
+  static readonly DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES: number;
+  protected _maxAutoNetMemStoreSamples: number;
+  protected apiEndPoint: string;
+  protected withCredentials: boolean;
+  constructor(http: HttpClient, config?: SpeechRecorderConfig | undefined);
+  protected audioRequestByURL(audioBaseUrl: string, audioURLSearchParams: URLSearchParams): Observable<HttpResponse<ArrayBuffer>>;
+  chunkAudioRequest(baseAudioUrl: string, startFrame: number | undefined, frameLength: number): Observable<ChunkDownload | null>;
+  protected chunkAudioRequestToNetAudioBuffer(baseAudioUrl: string, startFrame: number | undefined, orgSampleRate: number, seconds: number, frames: number | null): Observable<NetAudioBuffer | null>;
+}
+declare class NetAudioBuffer extends BasicAudioSource implements AudioSource {
+  private _recFileService;
+  private _baseUrl;
+  private _channelCount;
+  private _sampleRate;
+  private _chunkFrameLen;
+  private _frameLen;
+  private _uuid;
+  private _orgFetchChunkFrameLen;
+  get orgFetchChunkFrameLen(): number;
+  get recFileService(): BasicRecordingService;
+  get baseUrl(): string;
+  get chunkFrameLen(): number;
+  get uuid(): string | null;
+  private _chunkCount;
+  private _sealed;
+  constructor(_recFileService: BasicRecordingService, _baseUrl: string, _channelCount: number, _sampleRate: number, _chunkFrameLen: number, _frameLen: number, _uuid?: string | null, _orgFetchChunkFrameLen?: number);
+  get channelCount(): number;
+  sealed(): boolean;
+  seal(): void;
+  get sampleRate(): number;
+  get frameLen(): number;
+  get chunkCount(): number;
+  releaseAudioData(): Observable<void>;
+  toString(): string;
+  static fromChunkAudioBuffer(recordingsService: BasicRecordingService, baseUrl: string, ab: AudioBuffer, frameLen: number, orgFetchChunkFrameLen?: number): NetAudioBuffer;
+  asyncAudioInputStream(): AsyncFloat32ArrayInputStream | null;
+  audioInputStream(): Float32ArrayInputStream | null;
+  get duration(): number;
+  get numberOfChannels(): number;
+  sampleCounts(): number;
+  randomAccessAudioStream(): RandomAccessAudioStream;
+}
+export declare class RecordingService extends BasicRecordingService {
+  protected http: HttpClient;
+  protected config?: SpeechRecorderConfig | undefined;
+  static readonly REC_API_CTX = "recfile";
+  static readonly RECORDING_API_CTX = "recordingfile";
+  private debugDelay;
+  constructor(http: HttpClient, config?: SpeechRecorderConfig | undefined);
+  private recordingFilesUrl;
+  private sessionRecordingFilesUrl;
+  private sessionRecFilesUrl;
+  private sessionRecFilesReqUrl;
+  recordingFileDescrList(projectName: string, sessId: string | number): Observable<Array<RecordingFileDescriptorImpl>>;
+  recordingFileList(projectName: string, sessId: string | number): Observable<Array<RecordingFile>>;
+  sprRecordingFileList(projectName: string, sessId: string | number): Observable<Array<SprRecordingFile>>;
+  private audioRequest;
+  private chunkAudioRequestToIndDb;
+  private chunkedAudioRequestToArrayBuffer;
+  private chunkedInddbAudioRequest;
+  audioFileUrlById(projectName: string, sessId: string | number, recFileId: string | number): string;
+  private fetchAudiofile;
+  audioFileUrl(projectName: string, recordingFile: RecordingFile): string | null;
+  audioFileUrlByUUID(projectName: string, session: string | number, uuid: string): string | null;
+  private fetchSprAudiofile;
+  sprAudioFileUrlByItemcode(projectName: string, sessId: string | number, itemcode: string, version: number): string;
+  sprAudioFileUrl(projectName: string, recordingFile: SprRecordingFile): string | null;
+  fetchRecordingFileAudioBuffer(projectName: string, recordingFile: RecordingFile): Observable<AudioBuffer | null>;
+  fetchAndApplyRecordingFile(aCtx: AudioContext, projectName: string, recordingFile: RecordingFile): Observable<RecordingFile | null>;
+  fetchSprRecordingFileAudioBuffer(projectName: string, recordingFile: SprRecordingFile): Observable<AudioBuffer | null>;
+  fetchSprRecordingFileArrayAudioBuffer(projectName: string, recordingFile: SprRecordingFile): Observable<ArrayAudioBuffer | null>;
+  fetchRecordingFileArrayAudioBuffer(projectName: string, recordingFile: RecordingFile): Observable<ArrayAudioBuffer | null>;
+  fetchSprRecordingFileIndDbAudioBuffer(persistentAudioStorageTarget: PersistentAudioStorageTarget, projectName: string, recordingFile: SprRecordingFile): Observable<IndexedDbAudioBuffer | null>;
+  fetchRecordingFileIndDbAudioBuffer(persistentAudioStorageTarget: PersistentAudioStorageTarget, projectName: string, recordingFile: RecordingFile): Observable<IndexedDbAudioBuffer | null>;
+  fetchSprRecordingFileNetAudioBuffer(projectName: string, recordingFile: SprRecordingFile): Observable<NetAudioBuffer | null>;
+  fetchRecordingFileNetAudioBuffer(projectName: string, recordingFile: RecordingFile): Observable<NetAudioBuffer | null>;
+  fetchAndApplySprRecordingFile(aCtx: AudioContext, projectName: string, recordingFile: SprRecordingFile): Observable<SprRecordingFile | null>;
+  fetchRecordingFile(aCtx: AudioContext, projectName: string, sessId: string | number, itemcode: string, version: number): Observable<SprRecordingFile | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RecordingService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare class RecordingList implements AfterViewInit {
+  private recordingList;
+  recordingListDataSource: MatTableDataSource<RecordingFile>;
+  cols: string[];
+  selectDisabled: boolean;
+  selectedRecordingFileChanged: EventEmitter<RecordingFile>;
+  selectedRecordingFile: RecordingFile | null;
+  constructor();
+  ngAfterViewInit(): void;
+  private buildDataSource;
+  addRecFile(rf: RecordingFile): void;
+  setRecFileAudioData(recFile: RecordingFile, adh: AudioDataHolder | null): void;
+  selectRecordingFile(rf: RecordingFile): void;
+  selectTop(): void;
+  lengthTimeFormatted(rf: RecordingFile): string;
+  recordingFileCached(rf: RecordingFile): boolean | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RecordingList, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RecordingList, "app-recordinglist", never, {
+    "selectDisabled": {
+      "alias": "selectDisabled";
+      "required": false;
+    };
+    "selectedRecordingFile": {
+      "alias": "selectedRecordingFile";
+      "required": false;
+    };
+  }, {
+    "selectedRecordingFileChanged": "selectedRecordingFileChanged";
+  }, never, never, false, never>;
+}
+declare class RecorderCombiPane extends ResponsiveComponent implements AfterViewInit {
+  protected bpo: BreakpointObserver;
+  recordingListComp: RecordingList;
+  selectDisabled: boolean;
+  selectedRecordingFileChanged: EventEmitter<RecordingFile>;
+  selectedRecordingFile: RecordingFile | null;
+  audioDisplay: AudioDisplay;
+  audioSignalCollapsed: boolean;
+  displayAudioClip: AudioClip | null;
+  playStartAction: Action<void> | undefined;
+  playSelectionAction: Action<void> | undefined;
+  autoPlayOnSelectToggleAction: Action<boolean> | undefined;
+  playStopAction: Action<void> | undefined;
+  constructor(bpo: BreakpointObserver);
+  ngAfterViewInit(): void;
+  addRecFile(rf: RecordingFile): void;
+  setRecFileAudioData(recFile: RecordingFile, adh: AudioDataHolder | null): void;
+  selectRecordingFile(rf: RecordingFile): void;
+  selectTop(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RecorderCombiPane, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RecorderCombiPane, "app-recordercombipane", never, {
+    "selectDisabled": {
+      "alias": "selectDisabled";
+      "required": false;
+    };
+    "selectedRecordingFile": {
+      "alias": "selectedRecordingFile";
+      "required": false;
+    };
+    "audioSignalCollapsed": {
+      "alias": "audioSignalCollapsed";
+      "required": false;
+    };
+    "displayAudioClip": {
+      "alias": "displayAudioClip";
+      "required": false;
+    };
+    "playStartAction": {
+      "alias": "playStartAction";
+      "required": false;
+    };
+    "playSelectionAction": {
+      "alias": "playSelectionAction";
+      "required": false;
+    };
+    "autoPlayOnSelectToggleAction": {
+      "alias": "autoPlayOnSelectToggleAction";
+      "required": false;
+    };
+    "playStopAction": {
+      "alias": "playStopAction";
+      "required": false;
+    };
+  }, {
+    "selectedRecordingFileChanged": "selectedRecordingFileChanged";
+  }, never, never, false, never>;
+}
+declare enum Browser {
+  Firefox = "Firefox",
+  Chrome = "Chrome",
+  Safari = "Safari",
+  Edge = "Edge"
+}
+declare enum Platform {
+  Windows = "Windows",
+  Android = "Android",
+  macOS = "MAC OS X"
+}
+declare class UserAgent {
+  private _detectedPlatform;
+  private _detectedBrowser;
+  private _detectedBrowserVersion;
+  constructor(_detectedPlatform: Platform | null, _detectedBrowser: Browser | null, _detectedBrowserVersion?: string | null);
+  get detectedBrowser(): Browser | null;
+  get detectedBrowserVersion(): string | null;
+  get detectedPlatform(): Platform | null;
+}
+interface ChunkAudioBufferReceiver {
+  postAudioStreamStart(): void;
+  postChunkAudioBuffer(audioBuffer: AudioBuffer, chunkIdx: number, sampleSize?: SampleSize): void;
+  postAudioStreamEnd(chunkCount: number): void;
+}
+declare abstract class BasicRecorder extends ResponsiveComponent {
+  protected bpo: BreakpointObserver;
+  protected changeDetectorRef: ChangeDetectorRef;
+  dialog: MatDialog;
+  protected sessionService: SessionService;
+  protected uploader: SpeechRecorderUploader;
+  config?: SpeechRecorderConfig | undefined;
+  get allowEchoCancellation(): boolean;
+  set allowEchoCancellation(value: boolean);
+  protected updateTimerId: any;
+  protected maxRecTimerId: number | null;
+  protected maxRecTimerRunning: boolean;
+  get maxAutoNetMemStoreSamples(): number;
+  set maxAutoNetMemStoreSamples(value: number);
+  static readonly DEFAULT_MAX_NET_AUTO_MEM_STORE_SAMPLES: number;
+  protected _maxAutoNetMemStoreSamples: number;
+  static readonly DEFAULT_CHUNK_SIZE_SECONDS: number;
+  get clientAudioStorageType(): AudioStorageType;
+  set clientAudioStorageType(value: AudioStorageType);
+  get clientMediaStorageFormat(): MediaStorageFormat | undefined;
+  set clientMediaStorageFormat(value: MediaStorageFormat | undefined);
+  get persistentAudioStorageTarget(): PersistentAudioStorageTarget | null;
+  set persistentAudioStorageTarget(value: PersistentAudioStorageTarget | null);
+  static readonly FORCE_ARRRAY_AUDIO_BUFFER = false;
+  get uploadChunkSizeSeconds(): number | null;
+  set uploadChunkSizeSeconds(value: number | null);
+  protected userAgent: UserAgent;
+  statusMsg: string;
+  statusAlertType: string;
+  statusWaiting: boolean;
+  readonly: boolean;
+  protected rfUuid: string | null;
+  processingRecording: boolean;
+  ac: AudioCapture | null;
+  protected _wakeLock: boolean;
+  protected _audioDevices: Array<AudioDevice> | null | undefined;
+  protected _selectedDeviceId: string | undefined;
+  protected selCaptureDeviceId: ConstrainDOMString | null;
+  protected _channelCount: number;
+  protected _autoGainControlConfigs: Array<AutoGainControlConfig> | null | undefined;
+  protected _allowEchoCancellation: boolean;
+  _session: Session | null;
+  protected _recordingFile: RecordingFile | null;
+  transportActions: TransportActions;
+  playStartAction: Action<void>;
+  protected startedDate: Date | null;
+  uploadProgress: number;
+  uploadStatus: string;
+  protected uploadSet: UploadSet | null;
+  audioSignalCollapsed: boolean;
+  protected streamLevelMeasure: StreamLevelMeasure;
+  protected levelMeasure: LevelMeasure;
+  peakLevelInDb: number;
+  audioLoaded: boolean;
+  disableAudioDetails: boolean;
+  protected _controlAudioPlayer: AudioPlayer | null;
+  displayAudioClip: AudioClip | null;
+  protected audioFetchSubscription: Subscription | null;
+  liveLevelDisplayState: State$1;
+  keepLiveLevel: boolean;
+  private calcBufferInfosSubscr;
+  protected destroyed: boolean;
+  protected navigationDisabled: boolean;
+  protected _uploadChunkSizeSeconds: number | null;
+  protected _clientAudioStorageType: AudioStorageType;
+  protected _clientMediaStorageFormat: MediaStorageFormat | undefined;
+  protected _persistentAudioStorageTarget: PersistentAudioStorageTarget | null;
+  protected _screenLocked: boolean;
+  private wakeLockManager?;
+  protected constructor(bpo: BreakpointObserver, changeDetectorRef: ChangeDetectorRef, dialog: MatDialog, sessionService: SessionService, uploader: SpeechRecorderUploader, config?: SpeechRecorderConfig | undefined);
+  get wakeLock(): boolean;
+  set wakeLock(value: boolean);
+  enableWakeLockCond(): void;
+  disableWakeLockCond(): void;
+  get screenLocked(): boolean;
+  set audioDevices(audioDevices: Array<AudioDevice> | null | undefined);
+  set autoGainControlConfigs(autoGainControlConfigs: Array<AutoGainControlConfig> | null | undefined);
+  set channelCount(channelCount: number);
+  set session(session: Session | null);
+  get session(): Session | null;
+  enableStartUserGesture(): void;
+  configureStreamCaptureStream(): void;
+  showRecording(): void;
+  start(): void;
+  startItem(): void;
+  protected startCapture(): void;
+  opened(): void;
+  started(): void;
+  postRecording(wavFile: ArrayBuffer, recUrl: string, rf: RecordingFile | null, uploadHolder?: UploadHolder): void;
+  postAudioStreamStart(): void;
+  protected sessionsBaseUrl(): string;
+  abstract postChunkAudioBuffer(audioBuffer: AudioBuffer, chunkIdx: number): void;
+  postAudioStreamEnd(chunkCount: number): void;
+  closed(): void;
+  error(msg?: string, advice?: string): void;
+}
+export interface ReadyStateProvider {
+  ready(): boolean;
+}
+export declare abstract class RecorderComponent implements ReadyStateProvider {
+  protected uploader: SpeechRecorderUploader;
+  dataSaved: boolean;
+  protected _persistentAudioStorageTarget: PersistentAudioStorageTarget | null;
+  constructor(uploader: SpeechRecorderUploader);
+  printStorageInfos(): void;
+  prepare(persistentAudioStorage?: boolean): Observable<void>;
+  abstract ready(): boolean;
+  abstract get screenLocked(): boolean;
+}
+declare abstract class BasicRecFilesCache {
+  static readonly DEBUG = false;
+  static readonly DEFAULT_MAX_SAMPLES: number;
+  protected _sampleCount: number;
+  maxSampleCount: number;
+  private _currentRecordingFile;
+  protected abstract expire(): void;
+  get currentRecordingFile(): RecordingFile | null;
+  set currentRecordingFile(value: RecordingFile | null);
+}
+declare class SprItemsCache extends BasicRecFilesCache {
+  private _items;
+  get items(): Array<Item>;
+  addItem(item: Item): void;
+  getItem(index: number): Item;
+  length(): number;
+  private tryExpire;
+  protected expire(): void;
+  addSprRecFile(item: Item, sprRecFile: SprRecordingFile): void;
+  setSprRecFileAudioData(sprRecFile: SprRecordingFile, adh: AudioDataHolder | null): void;
+}
+declare const enum Status$1 {
+  BLOCKED = 0,
+  IDLE = 1,
+  STARTING = 2,
+  PRE_RECORDING = 3,
+  RECORDING = 4,
+  POST_REC_STOP = 5,
+  POST_REC_PAUSE = 6,
+  STOPPING_STOP = 7,
+  STOPPING_PAUSE = 8,
+  NON_RECORDING_WAIT = 9,
+  ERROR = 10
+}
+declare class SessionManager extends BasicRecorder implements AfterViewInit, OnDestroy, AudioCaptureListener, ChunkAudioBufferReceiver {
+  protected bpo: BreakpointObserver;
+  private renderer;
+  private recFileService;
+  private offlineAudioContext;
+  get persistentAudioStorageTarget(): PersistentAudioStorageTarget | null;
+  set persistentAudioStorageTarget(value: PersistentAudioStorageTarget | null);
+  projectName: string | undefined;
+  enableUploadRecordings: boolean;
+  enableDownloadRecordings: boolean;
+  status: Status$1;
+  prompting: Prompting;
+  liveLevelDisplay: LevelBar;
+  dataSaved: boolean;
+  startStopSignalState: State;
+  private preRecTimerId;
+  private preRecTimerRunning;
+  private postDelay;
+  private postRecTimerId;
+  private postRecTimerRunning;
+  private nonRecordingDurationTimerId;
+  private nonRecordingDurationTimerRunning;
+  audio: any;
+  _script: Script;
+  private _promptIndex;
+  private section;
+  group: Group;
+  promptItem: PromptItem;
+  showPrompt: boolean;
+  sectIdx: number;
+  groupIdxInSection: number;
+  promptItemIdxInGroup: number;
+  private autorecording;
+  items: SprItemsCache | null;
+  private _displayRecFile;
+  private displayRecFileVersion;
+  promptItemCount: number;
+  showSessionCompleteMessage: boolean;
+  constructor(bpo: BreakpointObserver, changeDetectorRef: ChangeDetectorRef, renderer: Renderer2, dialog: MatDialog, sessionService: SessionService, recFileService: RecordingService, uploader: SpeechRecorderUploader, config?: SpeechRecorderConfig);
+  ngAfterViewInit(): void;
+  ngOnDestroy(): void;
+  private init;
+  onKeyPress(ke: KeyboardEvent): void;
+  onKeyDown(ke: KeyboardEvent): void;
+  updateWakeLock(dataSaved?: boolean): void;
+  progressPercentValue(): number;
+  isTestSession(): boolean;
+  isDefaultAudioTestSession(): boolean;
+  isDefaultAudioTestSessionOverwritingProjectRequirements(): boolean;
+  set controlAudioPlayer(controlAudioPlayer: AudioPlayer | null);
+  get controlAudioPlayer(): AudioPlayer | null;
+  set script(script: any);
+  update(e: AudioPlayerEvent): void;
+  get promptIndex(): number;
+  set promptIndex(promptIndex: number);
+  itemSelect(itemIdx: number): void;
+  private clearPreRecTimer;
+  private clearPostRecTimer;
+  private clearMaxRecTimer;
+  private clearNonRecordingDurationTimer;
+  startItem(): void;
+  private loadScript;
+  promptIndexByItemcode(itemcode: string): number | null;
+  clearPrompt(): void;
+  applyPrompt(): void;
+  downloadRecording(): void;
+  set displayRecFile(displayRecFile: SprRecordingFile | null);
+  protected updateDisplayRecFile(displayRecFile: SprRecordingFile | null, fetchAndApplyRecordingFile?: boolean): void;
+  get displayRecFile(): SprRecordingFile | null;
+  isRecordingItem(): boolean;
+  updateStartActionDisableState(): void;
+  applyItem(temporary?: boolean): void;
+  start(): void;
+  isRecording(): boolean;
+  isActive(): boolean;
+  prevItem(): void;
+  nextItem(): void;
+  private updateNavigationActions;
+  nextUnrecordedItem(): void;
+  enableStartUserGesture(): void;
+  enableNavigation(): void;
+  started(): void;
+  stopItem(): void;
+  stopNonrecording(): void;
+  pauseItem(): void;
+  stopRecording(): void;
+  stopRecordingMaxRec(): void;
+  addRecordingFileByDescriptor(rfd: RecordingFileDescriptorImpl): void;
+  stopped(): void;
+  continueSession(): void;
+  error(msg?: string, advice?: string): void;
+  postChunkAudioBuffer(audioBuffer: AudioBuffer, chunkIdx: number): void;
+  stop(): void;
+  private updateControlPlaybackPosition;
+  audioPlayerUpdate(e: AudioPlayerEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SessionManager, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SessionManager, "app-sprrecordingsession", never, {
+    "projectName": {
+      "alias": "projectName";
+      "required": false;
+    };
+    "dataSaved": {
+      "alias": "dataSaved";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+export declare class ScriptService {
+  private http;
+  private config?;
+  private readonly scriptCtxUrl;
+  private readonly withCredentials;
+  constructor(http: HttpClient, config?: SpeechRecorderConfig | undefined);
+  scriptObservable(id: string | number): Observable<Script>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<ScriptService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+declare enum Mode$1 {
+  SINGLE_SESSION = 0,
+  DEMO = 1
+}
+export declare class SpeechrecorderngComponent extends RecorderComponent implements OnInit, AfterViewInit, AudioPlayerListener {
+  private route;
+  private router;
+  private changeDetectorRef;
+  private sessionsService;
+  private projectService;
+  private scriptService;
+  private recFilesService;
+  protected uploader: SpeechRecorderUploader;
+  mode: Mode$1;
+  controlAudioPlayer: AudioPlayer | null;
+  audio: any;
+  _project: Project | null;
+  sessionId: string;
+  session: Session;
+  script: Script;
+  sm: SessionManager;
+  constructor(route: ActivatedRoute, router: Router, changeDetectorRef: ChangeDetectorRef, sessionsService: SessionService, projectService: ProjectService, scriptService: ScriptService, recFilesService: RecordingService, uploader: SpeechRecorderUploader);
+  handleError(err: any): void;
+  ngOnInit(): void;
+  ngAfterViewInit(): void;
+  fetchSession(sessionId: string): void;
+  fetchScript(sess: Session): void;
+  fetchRecordings(sess: Session, script: Script): void;
+  get screenLocked(): boolean;
+  private startSession;
+  setSession(session: any): void;
+  ready(): boolean;
+  init(): boolean;
+  uploadUpdate(ue: UploaderStatusChangeEvent): void;
+  configure(): void;
+  private randomize;
+  setScript(script: Script): void;
+  set project(project: Project | null);
+  get project(): Project | null;
+  loadProjectCfg(callback: () => any): void;
+  start(): void;
+  audioPlayerUpdate(e: AudioPlayerEvent): void;
+  error(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SpeechrecorderngComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SpeechrecorderngComponent, "app-speechrecorder", never, {}, {}, never, never, false, never>;
+}
+declare const enum Status {
+  BLOCKED = 0,
+  IDLE = 1,
+  STARTING = 2,
+  RECORDING = 3,
+  STOPPING_STOP = 4,
+  ERROR = 5
+}
+export declare class AudioRecorder extends BasicRecorder implements OnInit, AfterViewInit, OnDestroy, AudioCaptureListener, ReadyStateProvider, ChunkAudioBufferReceiver {
+  protected bpo: BreakpointObserver;
+  private renderer;
+  private recFileService;
+  protected uploader: SpeechRecorderUploader;
+  _project: Project | undefined | null;
+  projectName: string | undefined | null;
+  enableUploadRecordings: boolean;
+  enableDownloadRecordings: boolean;
+  status: Status;
+  recorderCombiPane: RecorderCombiPane;
+  liveLevelDisplay: LevelBar;
+  dataSaved: boolean;
+  startStopNextButtonName: string;
+  startStopNextButtonIconName: string;
+  audio: any;
+  private _displayRecFile;
+  private displayRecFileVersion;
+  constructor(bpo: BreakpointObserver, changeDetectorRef: ChangeDetectorRef, renderer: Renderer2, dialog: MatDialog, sessionService: SessionService, recFileService: RecordingService, uploader: SpeechRecorderUploader, config?: SpeechRecorderConfig);
+  ngAfterViewInit(): void;
+  ready(): boolean;
+  ngOnDestroy(): void;
+  ngOnInit(): void;
+  onKeyPress(ke: KeyboardEvent): void;
+  onKeyDown(ke: KeyboardEvent): void;
+  isTestSession(): boolean;
+  isDefaultAudioTestSession(): boolean;
+  isDefaultAudioTestSessionOverwriteingProjectRequirements(): boolean;
+  fetchRecordings(sess: Session): void;
+  set project(project: Project | undefined | null);
+  get project(): Project | undefined | null;
+  selectRecordingFile(rf: RecordingFile): void;
+  uploadUpdate(ue: UploaderStatusChangeEvent): void;
+  set controlAudioPlayer(controlAudioPlayer: AudioPlayer | null);
+  get controlAudioPlayer(): AudioPlayer | null;
+  update(e: AudioPlayerEvent): void;
+  startDisabled(): boolean;
+  stopDisabled(): boolean;
+  startStopNextName(): string;
+  startStopNextIconName(): string;
+  startStopNextIconColor(): string;
+  startStopPerform(): void;
+  startItem(): void;
+  downloadRecording(): void;
+  set displayRecFile(displayRecFile: RecordingFile | null);
+  get displayRecFile(): RecordingFile | null;
+  updateStartActionDisableState(): void;
+  start(): void;
+  isRecording(): boolean;
+  isActive(): boolean;
+  updateWakeLock(dataSaved?: boolean): void;
+  private updateNavigationActions;
+  enableStartUserGesture(): void;
+  enableNavigation(): void;
+  started(): void;
+  stopItem(): void;
+  stopRecording(): void;
+  stopRecordingMaxRec(): void;
+  stopped(): void;
+  error(msg?: string, advice?: string): void;
+  postRecordingMultipart(wavFile: ArrayBuffer, recUrl: string, rf: RecordingFile): void;
+  postChunkAudioBuffer(audioBuffer: AudioBuffer, chunkIdx: number): void;
+  stop(): void;
+  private updateControlPlaybackPosition;
+  audioPlayerUpdate(e: AudioPlayerEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AudioRecorder, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AudioRecorder, "app-audiorecorder", never, {
+    "projectName": {
+      "alias": "projectName";
+      "required": false;
+    };
+    "dataSaved": {
+      "alias": "dataSaved";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+export declare class AudioRecorderComponent extends RecorderComponent implements OnInit, OnDestroy, AfterViewInit, ReadyStateProvider {
+  private route;
+  private router;
+  private changeDetectorRef;
+  private sessionService;
+  private projectService;
+  protected uploader: SpeechRecorderUploader;
+  mode: Mode$1;
+  controlAudioPlayer: AudioPlayer;
+  audio: any;
+  _project: Project | undefined;
+  sessionId: string;
+  session: Session;
+  ar: AudioRecorder;
+  constructor(route: ActivatedRoute, router: Router, changeDetectorRef: ChangeDetectorRef, sessionService: SessionService, projectService: ProjectService, uploader: SpeechRecorderUploader);
+  ngOnInit(): void;
+  ngAfterViewInit(): void;
+  ngOnDestroy(): void;
+  get screenLocked(): boolean;
+  fetchSession(sessionId: string): void;
+  uploadUpdate(ue: UploaderStatusChangeEvent): void;
+  ready(): boolean;
+  static ɵfac: i0.ɵɵFactoryDeclaration<AudioRecorderComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<AudioRecorderComponent, "app-audiorecorder-comp", never, {}, {}, never, never, false, never>;
+}
+export declare class MessageDialog {
+  dialogRef: MatDialogRef<MessageDialog>;
+  data: any;
+  constructor(dialogRef: MatDialogRef<MessageDialog>, data: any);
+  closeDialog(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<MessageDialog, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<MessageDialog, "msg-dialog", never, {}, {}, never, never, false, never>;
+}
+declare class SessionFinishedDialog {
+  dialogRef: MatDialogRef<SessionFinishedDialog>;
+  data: any;
+  constructor(dialogRef: MatDialogRef<SessionFinishedDialog>, data: any);
+  closeDialog(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SessionFinishedDialog, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SessionFinishedDialog, "spr-session-finished-dialog", never, {}, {}, never, never, false, never>;
+}
+export declare class RecordingFileService extends BasicRecordingService {
+  protected http: HttpClient;
+  protected config?: SpeechRecorderConfig | undefined;
+  static readonly RECOFILE_API_CTX = "recordingfile";
+  private debugDelay;
+  constructor(http: HttpClient, config?: SpeechRecorderConfig | undefined);
+  private recoFileUrl;
+  private fetchAudiofile;
+  private recordingFileDescrObserver;
+  private sprRecordingFileDescrObserver;
+  private fetchSessionAudiofileById;
+  fetchAndApplyRecordingFile(recordingFile: SprRecordingFile): Observable<SprRecordingFile | null>;
+  fetchRecordingFile(aCtx: AudioContext, recordingFileId: string | number): Observable<RecordingFile | null>;
+  fetchSprRecordingFile(recordingFileId: string | number): Observable<SprRecordingFile | null>;
+  saveEditSelection(recordingFileId: string | number, editSampleRate: number | null, editStartFrame: number | null, editEndFrame: number | null): Observable<SprRecordingFile | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RecordingFileService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class RecordingFileViewComponent extends AudioDisplayPlayer implements OnInit, AfterViewInit {
+  protected recordingFileService: RecordingFileService;
+  protected recordingService: RecordingService;
+  protected sessionService: SessionService;
+  protected router: Router;
+  protected route: ActivatedRoute;
+  protected ref: ChangeDetectorRef;
+  protected eRef: ElementRef;
+  protected dialog: MatDialog;
+  sessionId: string | number | null;
+  sessionIdFromRoute: string | null;
+  availRecFiles: Array<Array<SprRecordingFile>> | null;
+  versions: Array<number> | null;
+  recordingFile: SprRecordingFile | null;
+  recordingFileVersion: number | null;
+  private routedByQueryParam;
+  posInList: number | null;
+  private ac;
+  firstAction: Action<void>;
+  prevAction: Action<void>;
+  nextAction: Action<void>;
+  lastAction: Action<void>;
+  toVersionAction: Action<number>;
+  audioFetching: boolean;
+  naviInfoLoading: boolean;
+  constructor(recordingFileService: RecordingFileService, recordingService: RecordingService, sessionService: SessionService, router: Router, route: ActivatedRoute, ref: ChangeDetectorRef, eRef: ElementRef, dialog: MatDialog);
+  ngOnInit(): void;
+  ngAfterViewInit(): void;
+  private navigateToId;
+  private navigateToRecordingFile;
+  toVersion(ae: ActionEvent<number>): void;
+  prevFile(): void;
+  nextFile(): void;
+  private positionInList;
+  private updatePos;
+  protected loadRecFile(rfId: number | string): void;
+  protected loadedRecfile(): void;
+  private updateActions;
+  private loadSession;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RecordingFileViewComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RecordingFileViewComponent, "app-audiodisplayplayer", never, {}, {}, never, never, false, never>;
+}
+export declare class RecordingFileUI extends RecordingFileViewComponent implements AfterViewInit {
+  protected recordingFileService: RecordingFileService;
+  protected recordingService: RecordingService;
+  protected sessionService: SessionService;
+  protected router: Router;
+  protected route: ActivatedRoute;
+  protected ref: ChangeDetectorRef;
+  protected eRef: ElementRef;
+  protected dialog: MatDialog;
+  private snackBar;
+  savedEditSelection: Selection | null;
+  editSaved: boolean;
+  constructor(recordingFileService: RecordingFileService, recordingService: RecordingService, sessionService: SessionService, router: Router, route: ActivatedRoute, ref: ChangeDetectorRef, eRef: ElementRef, dialog: MatDialog, snackBar: MatSnackBar);
+  ngAfterViewInit(): void;
+  applyButtonText(): string;
+  protected loadRecFile(rfId: number | string): void;
+  protected loadedRecfile(): void;
+  applySelection(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RecordingFileUI, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RecordingFileUI, "app-audiodisplayplayer", never, {}, {}, never, never, false, never>;
+}
+declare class ScrollIntoViewDirective {
+  private elRef;
+  constructor(elRef: ElementRef);
+  set scrollIntoViewToBottom(siv: boolean);
+  static ɵfac: i0.ɵɵFactoryDeclaration<ScrollIntoViewDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollIntoViewDirective, "[scrollIntoViewToBottom]", never, {
+    "scrollIntoViewToBottom": {
+      "alias": "scrollIntoViewToBottom";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class RecordingFileNaviComponent implements OnInit {
+  firstAction: Action<void> | undefined;
+  prevAction: Action<void> | undefined;
+  nextAction: Action<void> | undefined;
+  lastAction: Action<void> | undefined;
+  items: number | null | undefined;
+  itemPos: number | null | undefined;
+  selectVersion: Action<number> | undefined;
+  versions: Array<number> | null;
+  version: number | null;
+  naviInfoLoading: boolean;
+  constructor();
+  ngOnInit(): void;
+  selectVersionChange(ev: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RecordingFileNaviComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RecordingFileNaviComponent, "app-recording-file-navi", never, {
+    "firstAction": {
+      "alias": "firstAction";
+      "required": false;
+    };
+    "prevAction": {
+      "alias": "prevAction";
+      "required": false;
+    };
+    "nextAction": {
+      "alias": "nextAction";
+      "required": false;
+    };
+    "lastAction": {
+      "alias": "lastAction";
+      "required": false;
+    };
+    "items": {
+      "alias": "items";
+      "required": false;
+    };
+    "itemPos": {
+      "alias": "itemPos";
+      "required": false;
+    };
+    "selectVersion": {
+      "alias": "selectVersion";
+      "required": false;
+    };
+    "versions": {
+      "alias": "versions";
+      "required": false;
+    };
+    "version": {
+      "alias": "version";
+      "required": false;
+    };
+    "naviInfoLoading": {
+      "alias": "naviInfoLoading";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+declare class RecordingFileMetaComponent {
+  sessionId: string | number | null;
+  private _recordingFile;
+  stateLoading: boolean;
+  constructor();
+  get recordingFile(): SprRecordingFile | null;
+  set recordingFile(recordingFile: SprRecordingFile | null);
+  itemCode: string | null;
+  uuid: string | null | undefined;
+  recordingAsPlainText(): string | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RecordingFileMetaComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RecordingFileMetaComponent, "app-recording-file-meta", never, {
+    "sessionId": {
+      "alias": "sessionId";
+      "required": false;
+    };
+    "stateLoading": {
+      "alias": "stateLoading";
+      "required": false;
+    };
+    "recordingFile": {
+      "alias": "recordingFile";
+      "required": false;
+    };
+  }, {}, never, never, false, never>;
+}
+interface ElementIntersection {
+  observer: IntersectionObserver;
+  observe: boolean;
+}
+declare class IntersectionObserverDirective {
+  private elRef;
+  constructor(elRef: ElementRef);
+  set updateObservation(elIntersection: ElementIntersection);
+  static ɵfac: i0.ɵɵFactoryDeclaration<IntersectionObserverDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<IntersectionObserverDirective, "[updateObservation]", never, {
+    "updateObservation": {
+      "alias": "updateObservation";
+      "required": false;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare class SpeechrecorderngModule {
+  static forRoot(config: SpeechRecorderConfig): ModuleWithProviders<SpeechrecorderngModule>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SpeechrecorderngModule, never>;
+  static ɵmod: i0.ɵɵNgModuleDeclaration<SpeechrecorderngModule, [typeof AudioSignal, typeof Sonagram, typeof ScrollPaneHorizontal, typeof AudioClipUIContainer, typeof AudioDisplayScrollPane, typeof AudioDisplay, typeof AudioDisplayPlayer, typeof AudioDisplayControl, typeof LevelBar, typeof Progress, typeof SimpleTrafficLight, typeof Recinstructions, typeof Prompter, typeof PromptContainer, typeof PromptingContainer, typeof Prompting, typeof StatusDisplay, typeof ProgressDisplay, typeof RecordingItemDisplay, typeof RecordingItemControls, typeof UploadStatus$1, typeof TransportPanel, typeof WakeLockIndicator, typeof ReadyStateIndicator, typeof ControlPanel, typeof WarningBar, typeof AudioRecorder, typeof SessionManager, typeof MessageDialog, typeof SessionFinishedDialog, typeof SpeechrecorderngComponent, typeof AudioRecorderComponent, typeof RecordingFileViewComponent, typeof RecordingFileUI, typeof ScrollIntoViewDirective, typeof RecordingFileNaviComponent, typeof RecordingFileMetaComponent, typeof RecordingList, typeof RecorderCombiPane, typeof AudioRecorder], [typeof i28.RouterModule, typeof i29.CommonModule, typeof i30.MatIconModule, typeof i31.MatButtonModule, typeof i32.MatDialogModule, typeof i33.MatProgressBarModule, typeof i34.MatProgressSpinnerModule, typeof i35.MatTooltipModule, typeof i36.MatCheckboxModule, typeof i37.MatCardModule, typeof i38.MatDividerModule, typeof i39.MatGridListModule, typeof i40.MatTableModule, typeof i41.MatInputModule, typeof i42.MatSelectModule, typeof i43.MatSnackBarModule, typeof i44.MatMenuModule, typeof IntersectionObserverDirective], [typeof MessageDialog, typeof SpeechrecorderngComponent, typeof ScrollPaneHorizontal, typeof AudioClipUIContainer, typeof AudioDisplayScrollPane, typeof AudioDisplay, typeof AudioDisplayPlayer, typeof AudioDisplayControl, typeof LevelBar, typeof AudioRecorder]>;
+  static ɵinj: i0.ɵɵInjectorDeclaration<SpeechrecorderngModule>;
+}
+export declare const VERSION = "3.12.1";
+export declare const SPEECHRECORDER_ENVIRONMENT_DEFAULTS: {
+  production: boolean;
+  apiType: string;
+  apiEndPoint: string;
+  apiVersion: number;
+  enableDownloadRecordings: boolean;
+  enableUploadRecordings: boolean;
+};
+export declare class UUID {
+  static generate(): string;
+  private static s4;
+}
+export declare class AudioContextProvider {
+  private static _audioContext;
+  private static _offlineAudioContext;
+  static audioContextInstance(): AudioContext | null;
+  static decodeAudioData(data: ArrayBuffer): Promise<AudioBuffer>;
+}
+export {};