@rocketshow/designer 1.40.0 → 1.44.0

package/index.d.ts

@@ -1,5 +1,1676 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@rocketshow/designer" />
-export * from './public_api';
+import * as i0 from '@angular/core';
+import { NgZone, OnDestroy, AfterViewInit, OnInit, ElementRef, ChangeDetectorRef, PipeTransform, EventEmitter } from '@angular/core';
+import * as i44 from '@ngx-translate/core';
+import { TranslateService } from '@ngx-translate/core';
+import { BsModalService, BsModalRef } from 'ngx-bootstrap/modal';
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import * as i50 from 'ngx-toastr';
+import { ToastrService } from 'ngx-toastr';
+import { Observable, Subject } from 'rxjs';
+import * as i39 from '@angular/router';
+import { Router, ActivatedRoute } from '@angular/router';
+import * as THREE from 'three';
+import WaveSurfer from 'wavesurfer.js';
+import * as i51 from '@ali-hm/angular-tree-component';
+import { ITreeOptions } from '@ali-hm/angular-tree-component';
+import * as i49 from 'ngx-dropzone-wrapper';
+import { DropzoneConfigInterface } from 'ngx-dropzone-wrapper';
+import * as i40 from '@angular/platform-browser';
+import * as i41 from '@angular/platform-browser/animations';
+import * as i42 from '@angular/forms';
+import * as i43 from 'ngx-bootstrap-slider';
+import * as i45 from 'ngx-bootstrap/accordion';
+import * as i46 from 'ngx-bootstrap/popover';
+import * as i47 from 'ngx-bootstrap/typeahead';
+import * as i48 from 'ngx-sortablejs-plus';
+
+declare class DesignerService {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesignerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DesignerService>;
+}
+
+declare enum FixtureCapabilityType {
+    NoFunction = "NoFunction",
+    ShutterStrobe = "ShutterStrobe",
+    StrobeSpeed = "StrobeSpeed",
+    StrobeDuration = "StrobeDuration",
+    Intensity = "Intensity",
+    ColorIntensity = "ColorIntensity",
+    ColorPreset = "ColorPreset",
+    ColorTemperature = "ColorTemperature",
+    Pan = "Pan",
+    PanContinuous = "PanContinuous",
+    Tilt = "Tilt",
+    TiltContinuous = "TiltContinuous",
+    PanTiltSpeed = "PanTiltSpeed",
+    WheelSlot = "WheelSlot",
+    WheelShake = "WheelShake",
+    WheelSlotRotation = "WheelSlotRotation",
+    WheelRotation = "WheelRotation",
+    EffectSpeed = "EffectSpeed",
+    EffectDuration = "EffectDuration",
+    EffectParameter = "EffectParameter",
+    SoundSensitivity = "SoundSensitivity",
+    Focus = "Focus",
+    Zoom = "Zoom",
+    Iris = "Iris",
+    IrisEffect = "IrisEffect",
+    Frost = "Frost",
+    FrostEffect = "FrostEffect",
+    Prism = "Prism",
+    PrismRotation = "PrismRotation",
+    BladeInsertion = "BladeInsertion",
+    BladeRotation = "BladeRotation",
+    BladeSystemRotation = "BladeSystemRotation",
+    Fog = "Fog",
+    FogOutput = "FogOutput",
+    FogType = "FogType",
+    BeamAngle = "BeamAngle",
+    Rotation = "Rotation",
+    Speed = "Speed",
+    Time = "Time",
+    Maintenance = "Maintenance",
+    Generic = "Generic",
+    Effect = "Effect",
+    BeamPosition = "BeamPosition"
+}
+declare enum FixtureCapabilityColor {
+    Red = "Red",
+    Green = "Green",
+    Blue = "Blue",
+    Cyan = "Cyan",
+    Magenta = "Magenta",
+    Yellow = "Yellow",
+    Amber = "Amber",
+    White = "White",
+    'Warm White' = "Warm White",
+    'Cold White' = "Cold White",
+    UV = "UV",
+    Lime = "Lime",
+    Indigo = "Indigo"
+}
+declare class FixtureCapability {
+    type: FixtureCapabilityType;
+    color: FixtureCapabilityColor;
+    dmxRange: number[];
+    slotNumber: number;
+    comment: string;
+    soundControlled: boolean;
+    shutterEffect: string;
+    randomTiming: boolean;
+    wheel: any;
+    angle: string;
+    angleStart: string;
+    angleEnd: string;
+    speed: string;
+    speedStart: string;
+    speedEnd: string;
+    brightness: string;
+    brightnessStart: string;
+    brightnessEnd: string;
+    duration: string;
+    durationStart: string;
+    durationEnd: string;
+    colorTemperature: string;
+    colorTemperatureStart: string;
+    colorTemperatureEnd: string;
+    soundSensitivity: string;
+    soundSensitivityStart: string;
+    soundSensitivityEnd: string;
+    horizontalAngle: string;
+    horizontalAngleStart: string;
+    horizontalAngleEnd: string;
+    verticalAngle: string;
+    verticalAngleStart: string;
+    verticalAngleEnd: string;
+    distance: string;
+    distanceStart: string;
+    distanceEnd: string;
+    openPercent: string;
+    openPercentStart: string;
+    openPercentEnd: string;
+    frostIntensity: string;
+    frostIntensityStart: string;
+    frostIntensityEnd: string;
+    fogOutput: string;
+    fogOutputStart: string;
+    fogOutputEnd: string;
+    time: string;
+    timeStart: string;
+    timeEnd: string;
+    insertion: string;
+    insertionStart: string;
+    insertionEnd: string;
+    colors: string[];
+    colorsStart: string[];
+    colorsEnd: string[];
+    constructor(data?: any);
+}
+
+declare enum FixtureWheelSlotType {
+    Open = "Open",
+    Closed = "Closed",
+    Color = "Color",
+    Gobo = "Gobo",
+    Prism = "Prism",
+    Iris = "Iris",
+    Frost = "Frost",
+    AnimationGoboStart = "AnimationGoboStart",
+    AnimationGoboEnd = "AnimationGoboEnd"
+}
+declare class FixtureWheelSlot {
+    type: FixtureWheelSlotType;
+    name: string;
+    colors: string[];
+    constructor(data?: any);
+}
+
+declare class FixtureWheel {
+    slots: FixtureWheelSlot[];
+    constructor(data?: any);
+}
+
+declare class CachedFixtureCapability {
+    capability: FixtureCapability;
+    wheelName: string;
+    wheel: FixtureWheel;
+    wheelSlots: FixtureWheelSlot[];
+    wheelIsColor: boolean;
+    centerValue: number;
+}
+
+declare class FixtureChannel {
+    fineChannelAliases: string[];
+    defaultValue: string | number;
+    capability: FixtureCapability;
+    capabilities: FixtureCapability[];
+    dmxValueResolution: string;
+    constructor(data?: any);
+}
+
+declare class CachedFixtureChannel {
+    channel: FixtureChannel;
+    name: string;
+    capabilities: CachedFixtureCapability[];
+    defaultValue: number;
+    maxValue: number;
+    colorWheel: FixtureWheel;
+}
+
+declare enum Positioning {
+    topFront = "topFront",
+    topBack = "topBack",
+    bottomFront = "bottomFront",
+    bottomBack = "bottomBack",
+    manual = "manual"
+}
+declare class Fixture {
+    uuid: string;
+    profileUuid: string;
+    name: string;
+    dmxUniverseUuid: string;
+    dmxFirstChannel: number;
+    modeShortName: string;
+    positioning: Positioning;
+    positionX: number;
+    positionY: number;
+    positionZ: number;
+    rotationX: number;
+    rotationY: number;
+    rotationZ: number;
+    constructor(data?: any);
+}
+
+declare class FixtureModeChannel {
+    name: string;
+    insert: string;
+    repeatFor: string[];
+    channelOrder: string;
+    templateChannels: string[];
+    constructor(data?: any);
+}
+
+declare class FixtureMode {
+    name: string;
+    shortName: string;
+    channels: FixtureModeChannel[];
+    channelCount: number;
+    constructor(data?: any);
+}
+
+declare class FixtureMatrix {
+    pixelKeys: string[][];
+    pixelCount: number[];
+    pixelGroups: any;
+    constructor(data?: any);
+}
+
+declare class FixturePhysical {
+    dimensions: number[];
+    constructor(data?: any);
+}
+
+declare enum FixtureCategory {
+    Blinder = "Blinder",
+    'Color Changer' = "Color Changer",
+    Dimmer = "Dimmer",
+    Effect = "Effect",
+    Fan = "Fan",
+    Flower = "Flower",
+    Hazer = "Hazer",
+    Laser = "Laser",
+    Matrix = "Matrix",
+    'Moving Head' = "Moving Head",
+    'Pixel Bar' = "Pixel Bar",
+    Scanner = "Scanner",
+    Smoke = "Smoke",
+    Stand = "Stand",
+    Strobe = "Strobe",
+    Other = "Other",
+    'Barrel Scanner' = "Barrel Scanner"
+}
+declare class FixtureProfile {
+    uuid: string;
+    name: string;
+    source: string;
+    createdFromFile: boolean;
+    manufacturerShortName: string;
+    manufacturerName: string;
+    categories: FixtureCategory[];
+    physical: FixturePhysical;
+    matrix: FixtureMatrix;
+    availableChannels: any;
+    templateChannels: any;
+    shortName: string;
+    wheels: any;
+    modes: FixtureMode[];
+    constructor(data?: any);
+}
+
+declare class CachedFixture {
+    fixture: Fixture;
+    pixelKey: string;
+    profile: FixtureProfile;
+    mode: FixtureMode;
+    channels: CachedFixtureChannel[];
+}
+
+declare class Color {
+    red: number;
+    green: number;
+    blue: number;
+    constructor(red?: number, green?: number, blue?: number);
+}
+
+declare class ScenePlaybackRegion {
+    sceneUuid: string;
+    startMillis: number;
+    endMillis: number;
+    constructor(data?: any);
+}
+
+declare class Composition {
+    uuid: string;
+    name: string;
+    syncType: string;
+    audioFileName: string;
+    audioFileInLibrary: boolean;
+    beatsPerMinute: number;
+    timeSignatureUpper: number;
+    timeSignatureLower: number;
+    snapToGrid: boolean;
+    tempoGuessed: boolean;
+    gridType: string;
+    gridOffsetMillis: number;
+    gridResolution: number;
+    durationMillis: number;
+    scenePlaybackRegions: ScenePlaybackRegion[];
+    constructor(data?: any);
+}
+
+declare abstract class Effect {
+    type: string;
+    uuid: string;
+    visible: boolean;
+    constructor(type: string, data?: any);
+}
+
+declare class FixtureCapabilityValue {
+    type: FixtureCapabilityType;
+    profileUuid: string;
+    valuePercentage: number;
+    color: FixtureCapabilityColor;
+    wheel: string;
+    slotNumber: number;
+    constructor(data?: any);
+}
+
+declare class FixtureChannelValue {
+    channelName: string;
+    profileUuid: string;
+    value: number;
+    constructor(data?: any);
+}
+
+declare class PresetFixture {
+    fixtureUuid: string;
+    pixelKey: string;
+    constructor(data?: any);
+}
+
+declare class Preset {
+    uuid: string;
+    name: string;
+    fixtureUuids: string[];
+    fixtures: PresetFixture[];
+    fixtureChannelValues: FixtureChannelValue[];
+    fixtureCapabilityValues: FixtureCapabilityValue[];
+    effects: Effect[];
+    startMillis: number;
+    endMillis: number;
+    fadeInMillis: number;
+    fadeOutMillis: number;
+    fadeInPre: boolean;
+    fadeOutPost: boolean;
+    constructor(data?: any);
+}
+
+declare class Scene {
+    uuid: string;
+    name: string;
+    color: string;
+    presetUuids: string[];
+    fadeInMillis: number;
+    fadeOutMillis: number;
+    fadeInPre: boolean;
+    fadeOutPost: boolean;
+    constructor(data?: any);
+}
+
+declare class Project {
+    id: number;
+    version: number;
+    uuid: string;
+    name: string;
+    shareToken: string;
+    stageWidthCm: number;
+    stageHeightCm: number;
+    stageDepthCm: number;
+    stageFloorHeightCm: number;
+    stageCeilingHeightCm: number;
+    stagePillarWidthCm: number;
+    masterDimmerValue: number;
+    selectedPresetUuid: string;
+    selectedSceneUuids: string[];
+    previewPreset: boolean;
+    selectedCompositionUuid: string;
+    compositions: Composition[];
+    fixtureProfiles: FixtureProfile[];
+    fixtures: Fixture[];
+    presetFixtures: PresetFixture[];
+    scenes: Scene[];
+    presets: Preset[];
+    constructor(data?: any);
+}
+
+declare class UserService {
+    private http;
+    token: string;
+    tokenExpiration: Date;
+    username: string;
+    constructor(http: HttpClient);
+    private loadFromLocalStorage;
+    register(email: string, username: string, password: string): Observable<any>;
+    login(email: string, password: string): Observable<any>;
+    logout(): void;
+    isLoggedIn(): boolean;
+    getHeaders(): HttpHeaders;
+    setAutoLoadProject(project: Project): void;
+    getAutoLoadProjectId(): number;
+    getAutoLoadProjectName(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserService>;
+}
+
+declare class ProjectService {
+    private http;
+    private userService;
+    private router;
+    private activatedRoute;
+    private translateService;
+    private toastrService;
+    project: Project;
+    currentProjectVersion: number;
+    constructor(http: HttpClient, userService: UserService, router: Router, activatedRoute: ActivatedRoute, translateService: TranslateService, toastrService: ToastrService);
+    private saveApi;
+    save(project: Project): void;
+    getAllProjects(): Observable<Project[]>;
+    deleteProject(project: Project): Observable<any>;
+    getProject(id: number, name: string, shareToken?: string): Observable<Project>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProjectService>;
+}
+
+declare class UuidService {
+    constructor();
+    getUuid(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UuidService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UuidService>;
+}
+
+declare class FixtureService {
+    private http;
+    private projectService;
+    private translateService;
+    private toastrService;
+    private uuidService;
+    cachedFixtures: CachedFixture[];
+    settingsSelection: boolean;
+    selectedSettingsFixtures: Fixture[];
+    constructor(http: HttpClient, projectService: ProjectService, translateService: TranslateService, toastrService: ToastrService, uuidService: UuidService);
+    getFixtureByUuid(uuid: string): Fixture;
+    private fixtureUuidAndPixelKeyEquals;
+    getCachedFixtureByUuid(uuid: string, pixelKey: string): CachedFixture;
+    getSearchProfiles(): Observable<FixtureProfile[]>;
+    getProfileByUuid(uuid: string): FixtureProfile;
+    loadProfileByUuid(uuid: string): Observable<void>;
+    getRotationAngleDeg(value: string): number;
+    getWheelSlotColors(wheel: FixtureWheel, slotNumber: number): string[];
+    getMixedWheelSlotColor(wheel: FixtureWheel, slotNumber: number): Color;
+    private componentToHex;
+    rgbToHex(r: number, g: number, b: number): string;
+    hexToRgb(hex: string): Color;
+    mixColors(colors: Color[]): Color;
+    wheelHasSlotType(wheel: FixtureWheel, slotType: FixtureWheelSlotType): boolean;
+    getWheelByName(profile: FixtureProfile, wheelName: string): FixtureWheel;
+    private getWheelSlots;
+    getModeByFixture(profile: FixtureProfile, fixture: Fixture): FixtureMode;
+    private getFixtureCapability;
+    private getCapabilitiesByChannel;
+    private getMaxValueByChannel;
+    private getDefaultValueByChannel;
+    private getColorWheelByChannel;
+    getChannelByName(fixture: CachedFixture, channelName: string): CachedFixtureChannel;
+    private getChannelNameWithPixelKey;
+    private addCachedChannel;
+    private alphanumericSort;
+    private getAllPixelKeys;
+    private getAllPixelGroups;
+    private getPixelKeysInOrder;
+    getModeChannelCount(profile: FixtureProfile, mode: FixtureMode): number;
+    getCachedChannels(profile: FixtureProfile, mode: FixtureMode, pixelKey: string): CachedFixtureChannel[];
+    fixtureGetUniquePixelKeys(fixture: Fixture): string[];
+    fixtureHasGeneralChannel(fixture: Fixture): boolean;
+    updateCachedFixtures(): void;
+    capabilitiesMatch(type1: FixtureCapabilityType, type2: FixtureCapabilityType, color1: FixtureCapabilityColor, color2: FixtureCapabilityColor, wheel1: string, wheel2: string, profileUuid1: string, profileUuid2: string): boolean;
+    settingsFixtureIsSelected(fixture: Fixture): boolean;
+    switchSettingsFixtureSelection(fixture: Fixture): void;
+    getFixtureIconClass(profile: FixtureProfile): string;
+    updateProfiles(): Observable<Object>;
+    getNextFreeDmxChannel(fixturePool: Fixture[], neededChannels: number): number;
+    addFixture(profile: FixtureProfile, fixturePool: Fixture[]): Fixture;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FixtureService>;
+}
+
+declare class PreviewMeshService {
+    private loader;
+    private cachedMeshes;
+    private cachedObservables;
+    constructor();
+    private loadScene;
+    private loadMesh;
+    getMesh(name: string): Observable<THREE.Mesh>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewMeshService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PreviewMeshService>;
+}
+
+declare class PresetRegionScene {
+    preset: Preset;
+    region: ScenePlaybackRegion;
+    scene: Scene;
+    constructor(preset: Preset, region: ScenePlaybackRegion, scene: Scene);
+}
+
+declare class AnimationService {
+    timeMillis: number;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnimationService>;
+}
+
+declare class ConfigService {
+    restUrl: string;
+    enableMediaLibrary: boolean;
+    loginAvailable: boolean;
+    shareAvailable: boolean;
+    menuHeightPx: number;
+    languageSwitch: boolean;
+    newProjectTemplate: boolean;
+    livePreview: boolean;
+    localProfiles: boolean;
+    intro: boolean;
+    uniqueProjectNames: boolean;
+    dropzoneChunking: boolean;
+    menuHeightChanged: Subject<void>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
+}
+
+declare class EffectService {
+    selectedEffect: Effect;
+    effectsOpen: boolean;
+    effectsOpenChanged: Subject<void>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<EffectService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EffectService>;
+}
+
+declare class PresetService {
+    private effectService;
+    private uuidService;
+    private projectService;
+    private fixtureService;
+    private configService;
+    private http;
+    private animationService;
+    selectedPreset: Preset;
+    previewSelectionChanged: Subject<void>;
+    fixtureSelectionChanged: Subject<void>;
+    fixtureSelectionSettingsChanged: Subject<void>;
+    fixtureColorChanged: Subject<void>;
+    livePreviewTimer: any;
+    liveChangePending: boolean;
+    constructor(effectService: EffectService, uuidService: UuidService, projectService: ProjectService, fixtureService: FixtureService, configService: ConfigService, http: HttpClient, animationService: AnimationService);
+    getPresetByUuid(uuid: string): Preset;
+    fixtureUuidAndPixelKeyEquals(fixtureUuid1: string, fixtureUuid2: string, pixelKey1: string, pixelKey2: string): boolean;
+    getPresetFixture(preset: Preset, fixtureUuid: string, pixelKey?: string): PresetFixture;
+    fixtureIsSelected(fixture: Fixture, pixelKey: string, preset?: Preset): boolean;
+    switchFixtureSelection(fixture: Fixture, pixelKey: string): void;
+    selectAllFixtures(): void;
+    selectNoFixtures(): void;
+    private presetFixtueEquals;
+    removeDeletedFixtures(): void;
+    updateFixtureSelection(): void;
+    deleteCapabilityValue(preset: Preset, capabilityType: FixtureCapabilityType, color?: FixtureCapabilityColor, wheel?: string, profileUuid?: string): void;
+    setCapabilityValue(preset: Preset, capabilityType: FixtureCapabilityType, valuePercentage: number, slotNumber?: number, color?: FixtureCapabilityColor, wheel?: string, profileUuid?: string): void;
+    getCapabilityValue(preset: Preset, capabilityType: FixtureCapabilityType, color?: FixtureCapabilityColor, wheel?: string, profileUuid?: string): FixtureCapabilityValue;
+    deleteChannelValue(channelName: string, profileUuid: string): void;
+    setChannelValue(channelName: string, profileUuid: string, value: number): void;
+    getChannelValue(channelName: string, profileUuid: string): number;
+    getApproximatedColorWheelCapability(preset: Preset, cachedChannel: CachedFixtureChannel): CachedFixtureCapability;
+    private hasCapabilityType;
+    hasCapabilityDimmer(): boolean;
+    hasCapabilityColor(): boolean;
+    hasCapabilityColorOrColorWheel(): boolean;
+    hasCapabilityPanTilt(): boolean;
+    selectPreset(index: number): void;
+    autoOpenFirstEffect(): void;
+    addPreset(name?: string): void;
+    getSelectedProfiles(): FixtureProfile[];
+    getSelectedProfileChannels(selectedProfiles: FixtureProfile[]): Map<FixtureProfile, CachedFixtureChannel[]>;
+    previewLive(compositionName?: string, positionMillis?: number): void;
+    stopPreviewPlay(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PresetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PresetService>;
+}
+
+declare class SceneService {
+    private uuidService;
+    private effectService;
+    private presetService;
+    private projectService;
+    selectedScenes: Scene[];
+    sceneColors: string[];
+    multipleSelection: boolean;
+    sceneDeleted: Subject<void>;
+    sceneSelected: Subject<void>;
+    constructor(uuidService: UuidService, effectService: EffectService, presetService: PresetService, projectService: ProjectService);
+    sceneIsSelected(scene: Scene): boolean;
+    presetIsSelected(preset: Preset): boolean;
+    switchSceneSelection(scene: Scene): void;
+    selectPresetFromSelectedScene(): void;
+    selectScene(index: number): void;
+    addScene(name?: string): void;
+    removeScene(scene: Scene): void;
+    getSceneByUuid(uuid: string): Scene;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SceneService>;
+}
+
+declare class TimelineService {
+    private sceneService;
+    private presetService;
+    private projectService;
+    private http;
+    private configService;
+    private ngZone;
+    waveSurfer: WaveSurfer;
+    playState: string;
+    zoom: number;
+    private timeUpdateSubscription;
+    currentTime: string;
+    private timelineClicking;
+    selectedPlaybackRegion: ScenePlaybackRegion;
+    private intensity;
+    private intensitySelectedScene;
+    private intensityHighlighted;
+    duration: string;
+    waveSurferReady: Subject<void>;
+    detectChanges: Subject<void>;
+    selectedComposition: Composition;
+    selectedCompositionIndex: number;
+    externalCompositionsAvailable: boolean;
+    loadingAudioFile: boolean;
+    constructor(sceneService: SceneService, presetService: PresetService, projectService: ProjectService, http: HttpClient, configService: ConfigService, ngZone: NgZone);
+    private redrawAllRegions;
+    private pad;
+    private msToTime;
+    private updateCurrentTime;
+    private startTimeUpdater;
+    private stopTimeUpdater;
+    formatTimeCallback(seconds: number, pxPerSec: number): string | number;
+    timeInterval(pxPerSec: number): number;
+    primaryLabelInterval(pxPerSec: number): number;
+    secondaryLabelInterval(pxPerSec: number): 0 | 2 | 5;
+    private seeekWithTimeline;
+    applyZoom(zoom: any): void;
+    private isWaveSurferReady;
+    addRegion(waveSurferRegion?: any): void;
+    private getSnapToGridInterval;
+    private getSnapToGridOffset;
+    deleteSelectedComposition(): void;
+    destroyWaveSurfer(): void;
+    createWaveSurfer(): void;
+    private hexToRgb;
+    private updateRegionSelection;
+    updateSelectedRegion(): void;
+    private setSelectedRegion;
+    private getRegionSnapToGridValue;
+    private connectRegion;
+    private drawRegion;
+    removeRegion(): void;
+    getPresetsInTime(timeMillis: number): PresetRegionScene[];
+    drawAllRegions(): void;
+    updateGrid(): void;
+    getExternalCompositionNames(): Observable<string[]>;
+    selectCompositionIndex(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TimelineService>;
+}
+
+declare class PreviewService implements OnDestroy {
+    private presetService;
+    private fixtureService;
+    private sceneService;
+    private timelineService;
+    private projectService;
+    doUpdateFixtureSetup: Subject<void>;
+    scene: THREE.Scene;
+    private stageMeshes;
+    private stageMaterial;
+    fixtureMaterial: THREE.MeshStandardMaterial;
+    fixtureSelectedMaterial: THREE.MeshLambertMaterial;
+    constructor(presetService: PresetService, fixtureService: FixtureService, sceneService: SceneService, timelineService: TimelineService, projectService: ProjectService);
+    private getAlreadyCalculatedFixture;
+    getPresets(timeMillis: number): PresetRegionScene[];
+    private mixChannelValue;
+    private getFixtureIndex;
+    private getPresetIntensity;
+    private mixCapabilityValues;
+    private mixChannelValues;
+    private mixEffects;
+    getChannelValues(timeMillis: number, presets: PresetRegionScene[]): Map<CachedFixture, FixtureChannelValue[]>;
+    fixtureIsSelected(uuid: string, pixelKey: string, presets: PresetRegionScene[]): boolean;
+    updateFixtureSetup(): void;
+    private prepareStageMesh;
+    updateStage(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PreviewService>;
+}
+
+declare class PreviewComponent implements AfterViewInit {
+    private fixtureService;
+    private previewMeshService;
+    private animationService;
+    private previewService;
+    private timelineService;
+    private projectService;
+    private ngZone;
+    private renderer;
+    private scene;
+    private camera;
+    controls: OrbitControls;
+    private fixtures3d;
+    private canvasRef;
+    constructor(fixtureService: FixtureService, previewMeshService: PreviewMeshService, animationService: AnimationService, previewService: PreviewService, timelineService: TimelineService, projectService: ProjectService, ngZone: NgZone);
+    private syncFixtures;
+    private get canvas();
+    private render;
+    private updateStagePosition;
+    private animate;
+    private getAspectRatio;
+    onResize(): void;
+    private setupRenderer;
+    private setupCamera;
+    private setupControls;
+    private setupScene;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PreviewComponent, "lib-app-preview", never, {}, {}, never, never, false, never>;
+}
+
+declare class ErrorDialogService {
+    private modalService;
+    private translateService;
+    constructor(modalService: BsModalService, translateService: TranslateService);
+    show(message: string, details?: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorDialogService>;
+}
+
+declare class FixturePoolService {
+    private modalService;
+    private fixturePoolOpened;
+    constructor(modalService: BsModalService);
+    open(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixturePoolService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FixturePoolService>;
+}
+
+declare class HotkeyTargetExcludeService {
+    constructor();
+    exclude(event: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HotkeyTargetExcludeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HotkeyTargetExcludeService>;
+}
+
+declare class IntroService {
+    private configService;
+    showIntro: boolean;
+    activeStep: string;
+    positionTopPercentage: number;
+    positionLeftPercentage: number;
+    stylePosition: string;
+    stepChanged: Subject<void>;
+    constructor(configService: ConfigService);
+    refresh(): void;
+    setShowIntro(value: boolean): void;
+    reset(): void;
+    showStep(step: string): boolean;
+    next(): void;
+    back(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntroService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IntroService>;
+}
+
+declare class WarningDialogService {
+    private modalService;
+    private translateService;
+    constructor(modalService: BsModalService, translateService: TranslateService);
+    show(message: string): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WarningDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WarningDialogService>;
+}
+
+declare class ProjectLoadService {
+    private projectService;
+    private previewService;
+    private fixtureService;
+    private presetService;
+    private sceneService;
+    private modalService;
+    private uuidService;
+    private timelineService;
+    private router;
+    private activatedRoute;
+    private warningDialogService;
+    constructor(projectService: ProjectService, previewService: PreviewService, fixtureService: FixtureService, presetService: PresetService, sceneService: SceneService, modalService: BsModalService, uuidService: UuidService, timelineService: TimelineService, router: Router, activatedRoute: ActivatedRoute, warningDialogService: WarningDialogService);
+    private migrateToVersion2;
+    private migrateFromOldProject;
+    private afterLoad;
+    private selectScenesPresetComposition;
+    load(id: number, name: string, shareToken?: string): Observable<void>;
+    new(): void;
+    template(): void;
+    import(data: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectLoadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProjectLoadService>;
+}
+
+declare class UserEnsureLoginService {
+    private userService;
+    private modalService;
+    private configService;
+    constructor(userService: UserService, modalService: BsModalService, configService: ConfigService);
+    login(): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserEnsureLoginService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserEnsureLoginService>;
+}
+
+declare class TimelineComponent implements OnInit, AfterViewInit {
+    timelineService: TimelineService;
+    private changeDetectorRef;
+    private modalService;
+    private uuidService;
+    projectService: ProjectService;
+    private hotkeyTargetExcludeService;
+    private warningDialogService;
+    private http;
+    private configService;
+    private presetService;
+    introService: IntroService;
+    waveWrapper: ElementRef;
+    waveElement: ElementRef;
+    private lastHeight;
+    private lastWidth;
+    constructor(timelineService: TimelineService, changeDetectorRef: ChangeDetectorRef, modalService: BsModalService, uuidService: UuidService, projectService: ProjectService, hotkeyTargetExcludeService: HotkeyTargetExcludeService, warningDialogService: WarningDialogService, http: HttpClient, configService: ConfigService, presetService: PresetService, introService: IntroService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onResize(): void;
+    play(): void;
+    pause(): void;
+    rewind(): void;
+    addRegion(waveSurferRegion?: any): void;
+    removeRegion(): void;
+    openGridSettings(): void;
+    private afterDeleteFile;
+    removeComposition(): void;
+    private openCompositionSettings;
+    compositionSettings(): void;
+    addComposition(): void;
+    selectComposition(index: number): void;
+    handleKeyboardEvent(event: KeyboardEvent): void;
+    setRegionStartMillis(value: any): void;
+    setRegionEndMillis(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineComponent, "lib-app-timeline", never, {}, {}, never, never, false, never>;
+}
+
+declare class DesignerComponent implements OnInit, AfterViewInit {
+    private translateService;
+    projectService: ProjectService;
+    configService: ConfigService;
+    private fixturePoolService;
+    private hotkeyTargetExcludeService;
+    private modalService;
+    userService: UserService;
+    private userEnsureLoginService;
+    private projectLoadService;
+    private warningDialogService;
+    private errorDialogService;
+    private fixtureService;
+    private timelineService;
+    introService: IntroService;
+    private effectService;
+    set menuHeightPx(value: number);
+    set externalCompositionsAvailable(value: boolean);
+    set restUrl(value: string);
+    set enableMediaLibrary(value: boolean);
+    set loginAvailable(value: boolean);
+    set shareAvailable(value: boolean);
+    set languageSwitch(value: boolean);
+    set newProjectTemplate(value: boolean);
+    set livePreview(value: boolean);
+    set localProfiles(value: boolean);
+    set intro(value: boolean);
+    set uniqueProjectNames(value: boolean);
+    set dropzoneChunking(value: boolean);
+    private designerMenuSizePx;
+    private splitGutterSizePx;
+    totalMenuHeightPx: number;
+    currentTab: string;
+    previewComponent: PreviewComponent;
+    timelineComponent: TimelineComponent;
+    constructor(translateService: TranslateService, projectService: ProjectService, configService: ConfigService, fixturePoolService: FixturePoolService, hotkeyTargetExcludeService: HotkeyTargetExcludeService, modalService: BsModalService, userService: UserService, userEnsureLoginService: UserEnsureLoginService, projectLoadService: ProjectLoadService, warningDialogService: WarningDialogService, errorDialogService: ErrorDialogService, fixtureService: FixtureService, timelineService: TimelineService, introService: IntroService, effectService: EffectService);
+    private loadError;
+    ngOnInit(): void;
+    private calcTotalMenuHeight;
+    private onResize;
+    ngAfterViewInit(): void;
+    openTab(tab: string): void;
+    openFixturePool(): void;
+    projectNew(): void;
+    projectOpen(): void;
+    projectSave(): void;
+    projectSaveAs(): void;
+    userRegister(): void;
+    projectImport(): void;
+    projectExport(): void;
+    projectShare(): void;
+    handleKeyboardEvent(event: any): void;
+    switchLanguage(language: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesignerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DesignerComponent, "lib-designer", never, { "menuHeightPx": { "alias": "menuHeightPx"; "required": false; }; "externalCompositionsAvailable": { "alias": "externalCompositionsAvailable"; "required": false; }; "restUrl": { "alias": "restUrl"; "required": false; }; "enableMediaLibrary": { "alias": "enableMediaLibrary"; "required": false; }; "loginAvailable": { "alias": "loginAvailable"; "required": false; }; "shareAvailable": { "alias": "shareAvailable"; "required": false; }; "languageSwitch": { "alias": "languageSwitch"; "required": false; }; "newProjectTemplate": { "alias": "newProjectTemplate"; "required": false; }; "livePreview": { "alias": "livePreview"; "required": false; }; "localProfiles": { "alias": "localProfiles"; "required": false; }; "intro": { "alias": "intro"; "required": false; }; "uniqueProjectNames": { "alias": "uniqueProjectNames"; "required": false; }; "dropzoneChunking": { "alias": "dropzoneChunking"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class WarningDialogComponent implements OnInit {
+    private bsModalRef;
+    onClose: Subject<number>;
+    message: string;
+    constructor(bsModalRef: BsModalRef);
+    ngOnInit(): void;
+    ok(): void;
+    cancel(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WarningDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WarningDialogComponent, "lib-app-warning-dialog", never, {}, {}, never, never, false, never>;
+}
+
+declare class EffectCurveProfileChannels {
+    profileUuid: string;
+    channels: string[];
+    constructor(data?: any);
+}
+
+declare class EffectCurve extends Effect {
+    curveType: string;
+    capabilities: FixtureCapability[];
+    channels: EffectCurveProfileChannels[];
+    lengthMillis: number;
+    phaseMillis: number;
+    amplitude: number;
+    position: number;
+    phasingMillis: number;
+    constructor(data?: any);
+    getValueAtMillis(timeMillis: number, fixtureIndex?: number): number;
+}
+
+declare class EffectCurveComponent implements OnInit, OnDestroy {
+    presetService: PresetService;
+    private animationService;
+    private fixtureService;
+    private translate;
+    private effectService;
+    private ngZone;
+    private gridUpdateSubscription;
+    private ctx;
+    private maxWidth;
+    private maxHeight;
+    lengthMillisMin: number;
+    lengthMillisMax: number;
+    amplitudeMin: number;
+    amplitudeMax: number;
+    percentageMin: number;
+    percentageMax: number;
+    phaseMillisMin: number;
+    phaseMillisMax: number;
+    phasingMillisMin: number;
+    phasingMillisMax: number;
+    availableCapabilities: FixtureCapability[];
+    availableChannels: Map<FixtureProfile, CachedFixtureChannel[]>;
+    availableProfiles: FixtureProfile[];
+    selectedProfiles: FixtureProfile[];
+    private effectsOpenChangedSubscription;
+    curve: EffectCurve;
+    set isSelected(value: boolean);
+    curveGrid: ElementRef;
+    constructor(presetService: PresetService, animationService: AnimationService, fixtureService: FixtureService, translate: TranslateService, effectService: EffectService, ngZone: NgZone);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private startUpdateTimer;
+    private stopUpdateTimer;
+    private drawCurrentValue;
+    private getPhasingCount;
+    redraw(): void;
+    private calculateChannelCapabilities;
+    changeProfileSelection($event: any, profile: FixtureProfile): void;
+    private updateCapabilitiesAndChannels;
+    getCapabilityName(capability: FixtureCapability): Observable<string>;
+    capabilityChecked(capability: FixtureCapability): boolean;
+    toggleCapability(event: any, capability: FixtureCapability): void;
+    getChannelName(profileName: string, channelName: string): string;
+    channelChecked(profile: FixtureProfile, channel: CachedFixtureChannel): boolean;
+    toggleChannel(event: any, profile: FixtureProfile, channel: CachedFixtureChannel): void;
+    setLengthMillis(value: any): void;
+    setAmplitude(value: any): void;
+    setPosition(value: any): void;
+    setPhaseMillis(value: any): void;
+    setPhasingMillis(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EffectCurveComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EffectCurveComponent, "lib-app-effect-curve", never, { "curve": { "alias": "curve"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class EffectPanTiltComponent implements OnInit {
+    panTiltGrid: ElementRef;
+    private svg;
+    private path;
+    private points;
+    private dragged;
+    private selected;
+    constructor();
+    private redraw;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EffectPanTiltComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EffectPanTiltComponent, "lib-app-effect-pan-tilt", never, {}, {}, never, never, false, never>;
+}
+
+declare class SceneComponent implements OnInit {
+    sceneService: SceneService;
+    presetService: PresetService;
+    projectService: ProjectService;
+    private modalService;
+    introService: IntroService;
+    constructor(sceneService: SceneService, presetService: PresetService, projectService: ProjectService, modalService: BsModalService, introService: IntroService);
+    ngOnInit(): void;
+    selectScene(event: any, index: number): void;
+    removeScene(): void;
+    openSettings(scene: Scene): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SceneComponent, "lib-app-scene", never, {}, {}, never, never, false, never>;
+}
+
+declare class FixtureCapabilityColorComponent implements OnInit, OnDestroy {
+    private presetService;
+    private fixtureService;
+    private changeDetectorRef;
+    color: string;
+    colorPicker: any;
+    active: boolean;
+    private colorPickerMounted;
+    private updatingColor;
+    private updateSubscription;
+    constructor(presetService: PresetService, fixtureService: FixtureService, changeDetectorRef: ChangeDetectorRef);
+    private update;
+    private setPickerColor;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    mount(): void;
+    private updateFixtureColor;
+    changeActive(active: boolean): void;
+    changeColor(color: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureCapabilityColorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixtureCapabilityColorComponent, "lib-app-fixture-capability-color", never, {}, {}, never, never, false, never>;
+}
+
+declare class FixtureComponent implements OnInit {
+    projectService: ProjectService;
+    presetService: PresetService;
+    private fixturePoolService;
+    fixtureService: FixtureService;
+    introService: IntroService;
+    constructor(projectService: ProjectService, presetService: PresetService, fixturePoolService: FixturePoolService, fixtureService: FixtureService, introService: IntroService);
+    ngOnInit(): void;
+    fixtureName(presetFixture: PresetFixture): string;
+    fixtureIsSelected(presetFixture: PresetFixture): boolean;
+    selectFixture(event: any, presetFixture: PresetFixture): void;
+    selectAll(): void;
+    selectNone(): void;
+    openFixturePool(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixtureComponent, "lib-app-fixture", never, {}, {}, never, never, false, never>;
+}
+
+declare class FixtureSettingsPositionComponent implements OnInit {
+    fixtureService: FixtureService;
+    private presetService;
+    selectUndefinedOptionValue: any;
+    selectedPositioning: string;
+    positionX: number;
+    positionY: number;
+    positionZ: number;
+    positionXMin: number;
+    positionXMax: number;
+    positionYMin: number;
+    positionYMax: number;
+    positionZMin: number;
+    positionZMax: number;
+    rotationX: number;
+    rotationY: number;
+    rotationZ: number;
+    rotationMin: number;
+    rotationMax: number;
+    constructor(fixtureService: FixtureService, presetService: PresetService);
+    ngOnInit(): void;
+    private updateSelection;
+    changePosition(positioningStr: string): void;
+    changePositionManual(position: string, value: any): void;
+    changeRotationManual(rotation: string, value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureSettingsPositionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixtureSettingsPositionComponent, "lib-app-fixture-settings-position", never, {}, {}, never, never, false, never>;
+}
+
+declare class FixtureCapabilityComponent implements OnInit, OnDestroy {
+    presetService: PresetService;
+    private fixtureService;
+    private changeDetectorRef;
+    projectService: ProjectService;
+    introService: IntroService;
+    private fixtureSelectionChangedSubscription;
+    private previewSelectionChangedSubscription;
+    colorWheelChannels: Map<FixtureProfile, CachedFixtureChannel>;
+    hasCapabilityDimmer: boolean;
+    hasCapabilityColorOrColorWheel: boolean;
+    hasCapabilityPanTilt: boolean;
+    constructor(presetService: PresetService, fixtureService: FixtureService, changeDetectorRef: ChangeDetectorRef, projectService: ProjectService, introService: IntroService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private wheelInList;
+    private updateColorWheels;
+    private updateCapabilities;
+    private update;
+    isChrome(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureCapabilityComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixtureCapabilityComponent, "lib-app-fixture-capability", never, {}, {}, never, never, false, never>;
+}
+
+declare class FixtureSettingsComponent implements OnInit {
+    private fixtureService;
+    presetService: PresetService;
+    dmxChannels: number[];
+    constructor(fixtureService: FixtureService, presetService: PresetService);
+    ngOnInit(): void;
+    isChrome(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureSettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixtureSettingsComponent, "lib-app-fixture-settings", never, {}, {}, never, never, false, never>;
+}
+
+declare class EffectComponent implements OnInit {
+    private uuidService;
+    presetService: PresetService;
+    effectService: EffectService;
+    private warningDialogService;
+    constructor(uuidService: UuidService, presetService: PresetService, effectService: EffectService, warningDialogService: WarningDialogService);
+    ngOnInit(): void;
+    private addEffect;
+    addCurveEffect(): void;
+    addPanTiltEffect(): void;
+    openEffect(effect: Effect, event: any): void;
+    deleteEffect(effect: Effect): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EffectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EffectComponent, "lib-app-effect", never, {}, {}, never, never, false, never>;
+}
+
+declare class FixturePoolComponent implements OnInit {
+    bsModalRef: BsModalRef;
+    fixtureService: FixtureService;
+    private uuidService;
+    projectService: ProjectService;
+    private previewService;
+    private translateService;
+    private toastrService;
+    private presetService;
+    configService: ConfigService;
+    private modalService;
+    private profiles;
+    filteredProfiles: FixtureProfile[];
+    loadingProfiles: boolean;
+    fixturePool: Fixture[];
+    dmxChannels: number[];
+    selectedFixture: Fixture;
+    selectedFixtureProfile: FixtureProfile;
+    showChannelNumbers: boolean;
+    channelDragFixture: Fixture;
+    channelDragOffset: number;
+    onClose: Subject<number>;
+    searchExpression: string;
+    updatingProfiles: boolean;
+    constructor(bsModalRef: BsModalRef, fixtureService: FixtureService, uuidService: UuidService, projectService: ProjectService, previewService: PreviewService, translateService: TranslateService, toastrService: ToastrService, presetService: PresetService, configService: ConfigService, modalService: BsModalService);
+    ngOnInit(): void;
+    private loadProfiles;
+    selectFixture(fixture: Fixture): void;
+    filterProfiles(): void;
+    addFixture(searchProfile: FixtureProfile): void;
+    addCopy(originalFixture: Fixture): void;
+    removeFixture(fixture: Fixture): void;
+    channelOccupied(index: number): boolean;
+    channelOccupiedStart(index: number): boolean;
+    channelOccupiedEnd(index: number): boolean;
+    channelOverlapped(index: number): boolean;
+    channelMouseDown(event: any): void;
+    channelSelected(index: number): boolean;
+    mouseUp(event: any): void;
+    channelMouseOver(event: any): void;
+    ok(): void;
+    cancel(): void;
+    updateProfiles(): void;
+    createFixtureFromProfileFile(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixturePoolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixturePoolComponent, "lib-app-fixture-pool", never, {}, {}, never, never, false, never>;
+}
+
+declare class PresetComponent implements OnInit {
+    presetService: PresetService;
+    sceneService: SceneService;
+    projectService: ProjectService;
+    introService: IntroService;
+    private modalService;
+    treeOptions: ITreeOptions;
+    treeNodes: any;
+    tree: ElementRef;
+    constructor(presetService: PresetService, sceneService: SceneService, projectService: ProjectService, introService: IntroService, modalService: BsModalService);
+    ngOnInit(): void;
+    onActivate(event: any): void;
+    selectPreset(index: number): void;
+    enableCheckbox(): boolean;
+    activatePreset(active: boolean, index: number): void;
+    addPreset(): void;
+    removePreset(): void;
+    openSettings(preset: Preset): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PresetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PresetComponent, "lib-app-preset", never, {}, {}, never, never, false, never>;
+}
+
+declare class MasterDimmerComponent implements OnInit {
+    projectService: ProjectService;
+    private changeDetectorRef;
+    private presetService;
+    constructor(projectService: ProjectService, changeDetectorRef: ChangeDetectorRef, presetService: PresetService);
+    ngOnInit(): void;
+    setValue(value: any): void;
+    getValue(): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MasterDimmerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MasterDimmerComponent, "lib-app-master-dimmer", never, {}, {}, never, never, false, never>;
+}
+
+declare class FixtureCapabilityDimmerComponent implements OnInit {
+    private presetService;
+    private changeDetectorRef;
+    constructor(presetService: PresetService, changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    getValue(): number;
+    getValueText(): number;
+    setValue(value: any): void;
+    changeActive(active: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureCapabilityDimmerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixtureCapabilityDimmerComponent, "lib-app-fixture-capability-dimmer", never, {}, {}, never, never, false, never>;
+}
+
+declare class TimelineGridComponent implements OnInit {
+    bsModalRef: BsModalRef;
+    timelineService: TimelineService;
+    gridType: string;
+    beatsPerMinute: number;
+    timeSignatureUpper: number;
+    timeSignatureLower: number;
+    snapToGrid: boolean;
+    gridOffsetMillis: number;
+    gridResolution: number;
+    constructor(bsModalRef: BsModalRef, timelineService: TimelineService);
+    ngOnInit(): void;
+    ok(): void;
+    cancel(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimelineGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimelineGridComponent, "lib-app-timeline-grid", never, {}, {}, never, never, false, never>;
+}
+
+declare class CompositionSettingsComponent implements OnInit {
+    bsModalRef: BsModalRef;
+    private timelineService;
+    configService: ConfigService;
+    private translateService;
+    private http;
+    private warningDialogService;
+    private toastrService;
+    projectService: ProjectService;
+    composition: Composition;
+    existingCompositionNames: string[];
+    onClose: Subject<number>;
+    dropzoneConfig: DropzoneConfigInterface;
+    uploadMessage: string;
+    existingFiles: string[];
+    filteredExistingFiles: string[];
+    uploading: boolean;
+    constructor(bsModalRef: BsModalRef, timelineService: TimelineService, configService: ConfigService, translateService: TranslateService, http: HttpClient, warningDialogService: WarningDialogService, toastrService: ToastrService, projectService: ProjectService);
+    ngOnInit(): void;
+    getDropzoneUrl(): string;
+    ok(): void;
+    cancel(): void;
+    handleKeyboardEvent(event: any): void;
+    private getNameFromFile;
+    private loadFiles;
+    onUploadError(args: any): void;
+    onUploadSuccess(args: any): void;
+    onQueueComplete(args: any): void;
+    onAddedFile(args: any): void;
+    filterExistingFiles(searchValue?: string): void;
+    selectExistingFile(existingFile: string): void;
+    deleteFile(existingFile: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CompositionSettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CompositionSettingsComponent, "lib-app-composition-settings", never, {}, {}, never, never, false, never>;
+}
+
+declare class ArraySortPipe implements PipeTransform {
+    transform(array: any, field: string): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<ArraySortPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<ArraySortPipe, "sort", false>;
+}
+
+declare class FixtureCapabilityPanTiltComponent implements OnInit {
+    private presetService;
+    private changeDetectorRef;
+    constructor(presetService: PresetService, changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    getValuePan(): number;
+    getValueTextPan(): number;
+    setValuePan(value: any): void;
+    getValueTilt(): number;
+    getValueTextTilt(): number;
+    setValueTilt(value: any): void;
+    changeActive(active: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureCapabilityPanTiltComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixtureCapabilityPanTiltComponent, "lib-app-fixture-capability-pan-tilt", never, {}, {}, never, never, false, never>;
+}
+
+declare class FixtureCapabilityChannelComponent implements OnInit {
+    private presetService;
+    sliderValue: ElementRef;
+    selectedCapability: CachedFixtureCapability;
+    _channel: CachedFixtureChannel;
+    defaultValue: number;
+    value: number;
+    templateValue: number;
+    description: string;
+    hasRange: boolean;
+    rangeMin: number;
+    rangeMax: number;
+    descriptionStart: string;
+    descriptionEnd: string;
+    valueSetTimer: any;
+    profile: FixtureProfile;
+    set channel(value: CachedFixtureChannel);
+    capabilityIndex: number;
+    constructor(presetService: PresetService);
+    private updateChannel;
+    capabilityHasRange(): boolean;
+    getDescriptionStart(capability: CachedFixtureCapability): string;
+    getDescriptionEnd(capability: CachedFixtureCapability): string;
+    getDescription(capability: CachedFixtureCapability): string;
+    private getRangeMin;
+    private getRangeMax;
+    ngOnInit(): void;
+    setValue(value: any, ignoreCapabilityRange?: boolean): void;
+    private calculateTemplateValue;
+    private getDefaultValue;
+    changeActive(active: boolean): void;
+    capabilitySelected(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureCapabilityChannelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixtureCapabilityChannelComponent, "lib-app-fixture-capability-channel", never, { "profile": { "alias": "profile"; "required": false; }; "channel": { "alias": "channel"; "required": false; }; "capabilityIndex": { "alias": "capabilityIndex"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class FixtureChannelComponent implements OnInit, OnDestroy {
+    presetService: PresetService;
+    private changeDetectorRef;
+    projectService: ProjectService;
+    channelCapabilities: Map<FixtureProfile, CachedFixtureChannel[]>;
+    profiles: FixtureProfile[];
+    selectedProfiles: FixtureProfile[];
+    private fixtureSelectionChangedSubscription;
+    private previewSelectionChangedSubscription;
+    constructor(presetService: PresetService, changeDetectorRef: ChangeDetectorRef, projectService: ProjectService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private calculateChannelCapabilities;
+    private calculateProfiles;
+    changeProfileSelection($event: any, profile: FixtureProfile): void;
+    isChrome(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureChannelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixtureChannelComponent, "lib-app-fixture-channel", never, {}, {}, never, never, false, never>;
+}
+
+declare class FixtureCapabilityColorWheelComponent implements OnInit, OnDestroy {
+    presetService: PresetService;
+    private changeDetectorRef;
+    private fixtureService;
+    _fixtureProfile: FixtureProfile;
+    _channel: CachedFixtureChannel;
+    wheelName: string;
+    wheel: FixtureWheel;
+    slotCapabilities: CachedFixtureCapability[];
+    private colorChangeSubscription;
+    set profile(value: FixtureProfile);
+    set channel(value: CachedFixtureChannel);
+    wheelIndex: number;
+    showContainer: boolean;
+    constructor(presetService: PresetService, changeDetectorRef: ChangeDetectorRef, fixtureService: FixtureService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private update;
+    getCapabilityColorStyle(capability: CachedFixtureCapability): any;
+    getCurrentSlotNumber(): number;
+    slotCapabilityIsSelected(slotNumber: number): boolean;
+    changeActive(active: boolean): void;
+    selectSlotNumber(slotNumber: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureCapabilityColorWheelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixtureCapabilityColorWheelComponent, "lib-app-fixture-capability-color-wheel", never, { "profile": { "alias": "profile"; "required": false; }; "channel": { "alias": "channel"; "required": false; }; "wheelIndex": { "alias": "wheelIndex"; "required": false; }; "showContainer": { "alias": "showContainer"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class UserLoginComponent implements OnInit {
+    private bsModalRef;
+    private userService;
+    error: string;
+    loggingIn: boolean;
+    email: string;
+    password: string;
+    subject: Subject<void>;
+    constructor(bsModalRef: BsModalRef, userService: UserService);
+    ngOnInit(): void;
+    cancel(): void;
+    login(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserLoginComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserLoginComponent, "lib-user-login", never, {}, {}, never, never, false, never>;
+}
+
+declare class UserRegisterComponent implements OnInit {
+    private bsModalRef;
+    private modalService;
+    private userService;
+    error: string;
+    registering: boolean;
+    username: string;
+    email: string;
+    password: string;
+    passwordRepeat: string;
+    subject: Subject<void>;
+    constructor(bsModalRef: BsModalRef, modalService: BsModalService, userService: UserService);
+    ngOnInit(): void;
+    cancel(): void;
+    login(): void;
+    private emailIsValid;
+    register(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserRegisterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserRegisterComponent, "lib-user-register", never, {}, {}, never, never, false, never>;
+}
+
+declare class ProjectBrowserComponent implements OnInit {
+    private bsModalRef;
+    private projectService;
+    private projectLoadService;
+    private userService;
+    private warningDialogService;
+    private configService;
+    projects: Project[];
+    loading: boolean;
+    constructor(bsModalRef: BsModalRef, projectService: ProjectService, projectLoadService: ProjectLoadService, userService: UserService, warningDialogService: WarningDialogService, configService: ConfigService);
+    private loadProjects;
+    ngOnInit(): void;
+    cancel(): void;
+    openProject(project: Project): void;
+    deleteProject(project: Project): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectBrowserComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProjectBrowserComponent, "lib-project-browser", never, {}, {}, never, never, false, never>;
+}
+
+declare class WaitDialogComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WaitDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WaitDialogComponent, "lib-wait-dialog", never, {}, {}, never, never, false, never>;
+}
+
+declare class ProjectImportComponent implements OnInit {
+    bsModalRef: BsModalRef;
+    private translateService;
+    private toastrService;
+    private projectLoadService;
+    dropzoneConfig: DropzoneConfigInterface;
+    uploadMessage: string;
+    constructor(bsModalRef: BsModalRef, translateService: TranslateService, toastrService: ToastrService, projectLoadService: ProjectLoadService);
+    ngOnInit(): void;
+    onUploadError(args: any): void;
+    ok(): void;
+    cancel(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectImportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProjectImportComponent, "lib-project-import", never, {}, {}, never, never, false, never>;
+}
+
+declare class ProjectShareComponent implements OnInit {
+    bsModalRef: BsModalRef;
+    private projectService;
+    shareLink: string;
+    constructor(bsModalRef: BsModalRef, projectService: ProjectService);
+    ngOnInit(): void;
+    ok(): void;
+    cancel(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectShareComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProjectShareComponent, "lib-project-share", never, {}, {}, never, never, false, never>;
+}
+
+declare class ErrorDialogComponent implements OnInit {
+    private bsModalRef;
+    onClose: Subject<number>;
+    message: string;
+    details: string;
+    constructor(bsModalRef: BsModalRef);
+    ngOnInit(): void;
+    ok(): void;
+    cancel(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorDialogComponent, "lib-error-dialog", never, {}, {}, never, never, false, never>;
+}
+
+declare class FixtureSettingsStageComponent implements OnInit {
+    projectService: ProjectService;
+    previewService: PreviewService;
+    private changeDetectorRef;
+    constructor(projectService: ProjectService, previewService: PreviewService, changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    update(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureSettingsStageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixtureSettingsStageComponent, "lib-app-fixture-settings-stage", never, {}, {}, never, never, false, never>;
+}
+
+declare class IntroComponent implements OnInit {
+    introService: IntroService;
+    constructor(introService: IntroService);
+    ngOnInit(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IntroComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IntroComponent, "lib-app-intro", never, {}, {}, never, never, false, never>;
+}
+
+declare class PresetSettingsComponent implements OnInit {
+    bsModalRef: BsModalRef;
+    preset: Preset;
+    name: string;
+    startMillis: number;
+    endMillis: number;
+    fadeInMillis: number;
+    fadeOutMillis: number;
+    fadeInPre: boolean;
+    fadeOutPost: boolean;
+    constructor(bsModalRef: BsModalRef);
+    ngOnInit(): void;
+    ok(): void;
+    cancel(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PresetSettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PresetSettingsComponent, "lib-preset-settings", never, {}, {}, never, never, false, never>;
+}
+
+declare class SceneSettingsComponent implements OnInit {
+    bsModalRef: BsModalRef;
+    scene: Scene;
+    name: string;
+    fadeInMillis: number;
+    fadeOutMillis: number;
+    fadeInPre: boolean;
+    fadeOutPost: boolean;
+    constructor(bsModalRef: BsModalRef);
+    ngOnInit(): void;
+    ok(): void;
+    cancel(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneSettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SceneSettingsComponent, "lib-scene-settings", never, {}, {}, never, never, false, never>;
+}
+
+declare class ProjectSaveComponent implements OnInit {
+    private bsModalRef;
+    private projectService;
+    private warningDialogService;
+    private configService;
+    projects: Project[];
+    loading: boolean;
+    projectName: string;
+    constructor(bsModalRef: BsModalRef, projectService: ProjectService, warningDialogService: WarningDialogService, configService: ConfigService);
+    ngOnInit(): void;
+    private loadProjects;
+    cancel(): void;
+    selectProject(project: Project): void;
+    private existingProject;
+    private doSave;
+    saveProject(): void;
+    deleteProject(project: Project): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProjectSaveComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProjectSaveComponent, "lib-project-save", never, {}, {}, never, never, false, never>;
+}
+
+declare class FixturePoolCreateFromFileComponent implements OnInit {
+    bsModalRef: BsModalRef;
+    private translateService;
+    private toastrService;
+    private fixtureService;
+    private projectService;
+    dropzoneConfig: DropzoneConfigInterface;
+    uploadMessage: string;
+    onClose: Subject<FixtureProfile>;
+    constructor(bsModalRef: BsModalRef, translateService: TranslateService, toastrService: ToastrService, fixtureService: FixtureService, projectService: ProjectService);
+    ngOnInit(): void;
+    onUploadError(args: any): void;
+    ok(): void;
+    cancel(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixturePoolCreateFromFileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FixturePoolCreateFromFileComponent, "lib-fixture-pool-create-from-file", never, {}, {}, never, never, false, never>;
+}
+
+declare class DropzoneComponent {
+    private translateService;
+    private configService;
+    error: EventEmitter<any>;
+    success: EventEmitter<any>;
+    addedFile: EventEmitter<any>;
+    private _url;
+    private _acceptedFiles;
+    private _maxFiles;
+    set url(value: string);
+    set acceptedFiles(value: string);
+    set maxFiles(value: number);
+    dropzoneConfig: DropzoneConfigInterface;
+    uploadMessage: string;
+    constructor(translateService: TranslateService, configService: ConfigService);
+    updateConfig(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DropzoneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DropzoneComponent, "app-dropzone", never, { "url": { "alias": "url"; "required": false; }; "acceptedFiles": { "alias": "acceptedFiles"; "required": false; }; "maxFiles": { "alias": "maxFiles"; "required": false; }; }, { "error": "error"; "success": "success"; "addedFile": "addedFile"; }, never, never, false, never>;
+}
+
+declare class DesignerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DesignerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DesignerModule, [typeof DesignerComponent, typeof WarningDialogComponent, typeof PreviewComponent, typeof EffectCurveComponent, typeof EffectPanTiltComponent, typeof SceneComponent, typeof TimelineComponent, typeof FixtureCapabilityColorComponent, typeof FixtureComponent, typeof FixtureSettingsPositionComponent, typeof FixtureCapabilityComponent, typeof FixtureSettingsComponent, typeof EffectComponent, typeof FixturePoolComponent, typeof PresetComponent, typeof MasterDimmerComponent, typeof FixtureCapabilityDimmerComponent, typeof TimelineGridComponent, typeof CompositionSettingsComponent, typeof ArraySortPipe, typeof FixtureCapabilityPanTiltComponent, typeof FixtureCapabilityChannelComponent, typeof FixtureChannelComponent, typeof FixtureCapabilityColorWheelComponent, typeof UserLoginComponent, typeof UserRegisterComponent, typeof ProjectBrowserComponent, typeof WaitDialogComponent, typeof ProjectImportComponent, typeof ProjectShareComponent, typeof ErrorDialogComponent, typeof FixtureSettingsStageComponent, typeof IntroComponent, typeof PresetSettingsComponent, typeof SceneSettingsComponent, typeof ProjectSaveComponent, typeof FixturePoolCreateFromFileComponent, typeof DropzoneComponent], [typeof i39.RouterModule, typeof i40.BrowserModule, typeof i41.BrowserAnimationsModule, typeof i42.FormsModule, typeof i43.NgxBootstrapSliderModule, typeof i44.TranslateModule, typeof i45.AccordionModule, typeof i46.PopoverModule, typeof i47.TypeaheadModule, typeof i48.SortablejsModule, typeof i49.DropzoneModule, typeof i50.ToastrModule, typeof i51.TreeModule], [typeof DesignerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DesignerModule>;
+}
+
+export { DesignerComponent, DesignerModule, DesignerService };