@rocketshow/designer 1.67.0 → 1.69.0

package/index.d.ts

@@ -1,27 +1,27 @@
 import * as i0 from '@angular/core';
 import { NgZone, OnDestroy, AfterViewInit, OnInit, ElementRef, ChangeDetectorRef, OnChanges, EventEmitter, TemplateRef, SimpleChanges, PipeTransform } from '@angular/core';
-import * as i47 from '@ngx-translate/core';
+import * as i56 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 i52 from 'ngx-toastr';
+import * as i61 from 'ngx-toastr';
 import { ToastrService } from 'ngx-toastr';
 import { Observable, Subject } from 'rxjs';
-import * as i42 from '@angular/router';
+import * as i51 from '@angular/router';
 import { Router, ActivatedRoute } from '@angular/router';
 import * as THREE from 'three';
 import WaveSurfer from 'wavesurfer.js';
-import { Options } from 'sortablejs';
-import * as i51 from 'ngx-dropzone-wrapper';
+import * as i60 from 'ngx-dropzone-wrapper';
 import { DropzoneConfigInterface } from 'ngx-dropzone-wrapper';
-import * as i43 from '@angular/platform-browser';
-import * as i44 from '@angular/platform-browser/animations';
-import * as i45 from '@angular/forms';
-import * as i46 from 'ngx-bootstrap-slider';
-import * as i48 from 'ngx-bootstrap/accordion';
-import * as i49 from 'ngx-bootstrap/popover';
-import * as i50 from 'ngx-bootstrap/typeahead';
+import { Options } from 'sortablejs';
+import * as i52 from '@angular/platform-browser';
+import * as i53 from '@angular/platform-browser/animations';
+import * as i54 from '@angular/forms';
+import * as i55 from 'ngx-bootstrap-slider';
+import * as i57 from 'ngx-bootstrap/accordion';
+import * as i58 from 'ngx-bootstrap/popover';
+import * as i59 from 'ngx-bootstrap/typeahead';
 
 declare class DesignerService {
     constructor();
@@ -338,6 +338,23 @@ declare class Composition {
     constructor(data?: any);
 }
 
+/**
+ * A folder inside one of the trees (presets, scenes, fixtures). Folders only group
+ * what is already there: the items keep living in their flat list of the project and
+ * carry the uuid of the folder they are in.
+ *
+ * Folders and items are ordered together by their sortIndex, which counts through the
+ * children of one folder, so an item can sit above a folder and the other way round.
+ */
+declare class Folder {
+    uuid: string;
+    name: string;
+    parentUuid: string;
+    sortIndex: number;
+    expanded: boolean;
+    constructor(data?: any);
+}
+
 declare abstract class Effect {
     type: string;
     uuid: string;
@@ -362,41 +379,115 @@ declare class FixtureChannelValue {
     constructor(data?: any);
 }
 
+/**
+ * Where a preset which brings its own fixture order puts one of the project's fixture
+ * folders. The folders themselves stay the project's — their name, what is inside them
+ * and how they are nested is the rig, shared by every preset. Only the position among
+ * their siblings can differ, so one preset can chase from the front truss to the back
+ * one while another does it the other way round.
+ */
+declare class FolderPosition {
+    folderUuid: string;
+    sortIndex: number;
+    constructor(data?: any);
+}
+
 declare class PresetFixture {
     fixtureUuid: string;
     pixelKey: string;
+    folderUuid: string;
+    sortIndex: number;
+    constructor(data?: any);
+}
+
+declare class PresetStepEffectAmount {
+    effectUuid: string;
+    amount: number;
+    constructor(data?: any);
+}
+
+type TransitionCurveType = 'linear' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'snap';
+
+declare class PresetStep {
+    uuid: string;
+    startMillis: number;
+    transitionMillis: number;
+    transitionCurve: TransitionCurveType;
+    fixtureChannelValues: FixtureChannelValue[];
+    fixtureCapabilityValues: FixtureCapabilityValue[];
+    effectAmounts: PresetStepEffectAmount[];
     constructor(data?: any);
+    getEffectAmount(effectUuid: string): number;
 }
 
 declare class Preset {
     uuid: string;
     name: string;
+    folderUuid: string;
+    sortIndex: number;
+    color: string;
+    colorAuto: boolean;
+    icon: string;
     fixtureUuids: string[];
     fixtures: PresetFixture[];
+    fixtureFolders: FolderPosition[];
+    useGlobalFixtureOrder: boolean;
     fixtureChannelValues: FixtureChannelValue[];
     fixtureCapabilityValues: FixtureCapabilityValue[];
+    steps: PresetStep[];
+    stepsLoop: boolean;
+    stepsLoopMillis: number;
+    stepsPhasingMode: string;
+    stepsPhasingMillis: number;
+    stepsPhasingCycles: number;
+    stepsPhasingGroupSize: number;
     effects: Effect[];
+    mirrorPan: boolean;
+    mirrorTilt: boolean;
     startMillis: number;
     endMillis: number;
     fadeInMillis: number;
     fadeOutMillis: number;
+    fadeInCurve: TransitionCurveType;
+    fadeOutCurve: TransitionCurveType;
     fadeInPre: boolean;
     fadeOutPost: boolean;
     constructor(data?: any);
+    mirrorsCapability(type: FixtureCapabilityType): boolean;
+    getMirroredValuePercentage(type: FixtureCapabilityType, valuePercentage: number): number;
 }
 
 declare class Scene {
     uuid: string;
     name: string;
+    folderUuid: string;
+    sortIndex: number;
     color: string;
+    colorAuto: boolean;
+    icon: string;
+    expanded: boolean;
     presetUuids: string[];
+    dimmer: number;
     fadeInMillis: number;
     fadeOutMillis: number;
+    fadeInCurve: TransitionCurveType;
+    fadeOutCurve: TransitionCurveType;
     fadeInPre: boolean;
     fadeOutPost: boolean;
     constructor(data?: any);
 }
 
+/**
+ * Lightweight configuration entry describing a universe that can
+ * be selected by the user inside the fixture pool. The actual
+ * runtime universe (with channel values, etc.) is represented by
+ * the `Universe` model.
+ */
+interface UniverseConfig {
+    uuid: string;
+    name: string;
+}
+
 declare class Project {
     id: number;
     version: number;
@@ -412,14 +503,21 @@ declare class Project {
     masterDimmerValue: number;
     selectedPresetUuid: string;
     selectedSceneUuids: string[];
+    selectedStepUuid: string;
+    stepPreviewRunning: boolean;
+    stepPreviewStartMillis: number;
     previewPreset: boolean;
     selectedCompositionUuid: string;
     compositions: Composition[];
     fixtureProfiles: FixtureProfile[];
     fixtures: Fixture[];
     presetFixtures: PresetFixture[];
+    universes: UniverseConfig[];
     scenes: Scene[];
     presets: Preset[];
+    sceneFolders: Folder[];
+    presetFolders: Folder[];
+    fixtureFolders: Folder[];
     constructor(data?: any);
 }
 
@@ -430,7 +528,7 @@ declare class UserService {
     username: string;
     constructor(http: HttpClient);
     private loadFromLocalStorage;
-    register(email: string, username: string, password: string): Observable<any>;
+    register(email: string, username: string, password: string, newsletter: boolean): Observable<any>;
     login(email: string, password: string): Observable<any>;
     logout(): void;
     isLoggedIn(): boolean;
@@ -442,6 +540,27 @@ declare class UserService {
     static ɵprov: i0.ɵɵInjectableDeclaration<UserService>;
 }
 
+declare class ConfigService {
+    restUrl: string;
+    enableMediaLibrary: boolean;
+    loginAvailable: boolean;
+    shareAvailable: boolean;
+    menuHeightPx: number;
+    languageSwitch: boolean;
+    livePreview: boolean;
+    localProfiles: boolean;
+    intro: boolean;
+    uniqueProjectNames: boolean;
+    dropzoneChunking: boolean;
+    universes: UniverseConfig[];
+    freeUniverseEdit: boolean;
+    hardwarePromo: boolean;
+    menuHeightChanged: Subject<void>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
+}
+
 declare class ProjectService {
     private http;
     private userService;
@@ -449,10 +568,13 @@ declare class ProjectService {
     private activatedRoute;
     private translateService;
     private toastrService;
+    private configService;
     project: Project;
     currentProjectVersion: number;
-    constructor(http: HttpClient, userService: UserService, router: Router, activatedRoute: ActivatedRoute, translateService: TranslateService, toastrService: ToastrService);
+    projectChanged: Subject<void>;
+    constructor(http: HttpClient, userService: UserService, router: Router, activatedRoute: ActivatedRoute, translateService: TranslateService, toastrService: ToastrService, configService: ConfigService);
     private saveApi;
+    writeCompatibilityValues(project: Project): void;
     save(project: Project): void;
     getAllProjects(): Observable<Project[]>;
     deleteProject(project: Project): Observable<any>;
@@ -489,12 +611,16 @@ declare class FixtureService {
     private uuidService;
     private fixturePixelGroupResolveService;
     cachedFixtures: CachedFixture[];
+    private fixtureIndex;
+    private profileIndex;
+    private cachedFixtureIndex;
     settingsSelection: boolean;
     selectedSettingsFixtures: Fixture[];
     constructor(http: HttpClient, projectService: ProjectService, translateService: TranslateService, toastrService: ToastrService, uuidService: UuidService, fixturePixelGroupResolveService: FixturePixelGroupResolveService);
     getFixtureByUuid(uuid: string): Fixture;
     private fixtureUuidAndPixelKeyEquals;
     getCachedFixtureByUuid(uuid: string, pixelKey: string): CachedFixture;
+    private getCachedFixturesByUuid;
     getSearchProfiles(): Observable<FixtureProfile[]>;
     getProfileByUuid(uuid: string): FixtureProfile;
     loadProfileByUuid(uuid: string): Observable<void>;
@@ -551,58 +677,100 @@ declare class PreviewMeshService {
     static ɵprov: i0.ɵɵInjectableDeclaration<PreviewMeshService>;
 }
 
-declare class PresetRegionScene {
-    preset: Preset;
-    region: ScenePlaybackRegion;
-    scene: Scene;
-    constructor(preset: Preset, region: ScenePlaybackRegion, scene: Scene);
+declare class HardwarePromoService {
+    private configService;
+    private barDismissed;
+    private sessionCount;
+    constructor(configService: ConfigService);
+    get enabled(): boolean;
+    countSession(): void;
+    get showBar(): boolean;
+    dismissBar(): void;
+    link(placement: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HardwarePromoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HardwarePromoService>;
 }
 
 declare class EffectService {
+    private uuidService;
     selectedEffect: Effect;
     effectsOpen: boolean;
     effectsOpenChanged: Subject<void>;
-    constructor();
+    effectsChanged: Subject<void>;
+    constructor(uuidService: UuidService);
+    duplicateEffect(preset: Preset, effect: Effect): Effect;
+    private copyOf;
     static ɵfac: i0.ɵɵFactoryDeclaration<EffectService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<EffectService>;
 }
 
-declare class AnimationService {
-    timeMillis: number;
-    constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<AnimationService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AnimationService>;
+declare class PresetStepState {
+    currentStep: PresetStep;
+    currentStepProgress: number;
+    fixtureChannelValues: FixtureChannelValue[];
+    fixtureCapabilityValues: FixtureCapabilityValue[];
+    effectAmounts: Map<string, number>;
+    getEffectAmount(effectUuid: string): number;
 }
 
+declare class PresetStepService {
+    private uuidService;
+    constructor(uuidService: UuidService);
+    ensureStep(preset: Preset): PresetStep;
+    sortSteps(preset: Preset): void;
+    addStep(preset: Preset, copyOf?: PresetStep): PresetStep;
+    deleteStep(preset: Preset, step: PresetStep): void;
+    getStepsLoopMillis(preset: Preset): number;
+    getStepEndMillis(preset: Preset, index: number): number;
+    getStepTransitionMillis(preset: Preset, step: PresetStep): number;
+    stepsArePhased(preset: Preset): boolean;
+    getStepsPhasingMillis(preset: Preset, fixtureIndex?: number, fixtureCount?: number): number;
+    getStepState(step: PresetStep): PresetStepState;
+    getStateAtMillis(preset: Preset, presetTimeMillis: number): PresetStepState;
+    private capabilityValuesMatch;
+    private getMatchingCapabilityValue;
+    private getMatchingChannelValue;
+    private interpolate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PresetStepService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PresetStepService>;
+}
+
+interface FolderItem {
+    folderUuid?: string;
+    sortIndex?: number;
+}
+interface FolderChild {
+    folder?: Folder;
+    item?: FolderItem;
+    sortIndex: number;
+}
 /**
- * Lightweight configuration entry describing a universe that can
- * be selected by the user inside the fixture pool. The actual
- * runtime universe (with channel values, etc.) is represented by
- * the `Universe` model.
+ * The order inside a tree with folders: folders and items of the same parent are
+ * ordered together by their sortIndex, so they can be interleaved freely.
+ *
+ * The flat item list of the project is kept in the order the tree shows it, so
+ * everything reading that list plainly still sees the same order as the user.
  */
-interface UniverseConfig {
-    uuid: string;
-    name: string;
+declare class FolderService {
+    private uuidService;
+    constructor(uuidService: UuidService);
+    createFolder(folders: Folder[], items: FolderItem[], name: string, parentUuid?: string): Folder;
+    placeLast(folders: Folder[], items: FolderItem[], item: FolderItem, parentUuid?: string): void;
+    getChildren(folders: Folder[], items: FolderItem[], parentUuid?: string): FolderChild[];
+    getFolderWithDescendants(folders: Folder[], folder: Folder): Folder[];
+    removeFolder(folders: Folder[], items: FolderItem[], folder: Folder): void;
+    renumber(folders: Folder[], items: FolderItem[], parentUuid?: string): void;
+    sortItems(folders: Folder[], items: FolderItem[]): void;
+    private sameFolder;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FolderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FolderService>;
 }
 
-declare class ConfigService {
-    restUrl: string;
-    enableMediaLibrary: boolean;
-    loginAvailable: boolean;
-    shareAvailable: boolean;
-    menuHeightPx: number;
-    languageSwitch: boolean;
-    livePreview: boolean;
-    localProfiles: boolean;
-    intro: boolean;
-    uniqueProjectNames: boolean;
-    dropzoneChunking: boolean;
-    universes: UniverseConfig[];
-    freeUniverseEdit: boolean;
-    menuHeightChanged: Subject<void>;
+declare class AnimationService {
+    timeMillis: number;
     constructor();
-    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AnimationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AnimationService>;
 }
 
 declare class TimelineStateService {
@@ -620,11 +788,13 @@ declare class LivePreviewService {
     private projectService;
     private animationService;
     private timelineStateService;
+    private static readonly throttleMillis;
     private livePreviewTimer;
-    private liveChangePending;
-    private livePreviewPendingPositionMillis;
+    private pendingPositionMillis;
     constructor(configService: ConfigService, http: HttpClient, projectService: ProjectService, animationService: AnimationService, timelineStateService: TimelineStateService);
     previewLive(compositionName?: string, positionMillis?: number): void;
+    private startThrottleTimer;
+    private postPreview;
     stopPreviewPlay(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<LivePreviewService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LivePreviewService>;
@@ -632,19 +802,33 @@ declare class LivePreviewService {
 
 declare class PresetService {
     private effectService;
+    private presetStepService;
     private uuidService;
     private projectService;
     private fixtureService;
     private livePreviewService;
+    private animationService;
+    private folderService;
     selectedPreset: Preset;
+    static readonly defaultIcon = "fa-lightbulb-o";
+    selectedStep: PresetStep;
+    private presetFixtureIndex;
     previewSelectionChanged: Subject<void>;
+    presetsChanged: Subject<void>;
+    stepsChanged: Subject<void>;
     fixtureSelectionChanged: Subject<void>;
     fixtureSelectionSettingsChanged: Subject<void>;
     fixtureColorChanged: Subject<void>;
-    constructor(effectService: EffectService, uuidService: UuidService, projectService: ProjectService, fixtureService: FixtureService, livePreviewService: LivePreviewService);
+    capabilityValuesChanged: Subject<void>;
+    constructor(effectService: EffectService, presetStepService: PresetStepService, uuidService: UuidService, projectService: ProjectService, fixtureService: FixtureService, livePreviewService: LivePreviewService, animationService: AnimationService, folderService: FolderService);
+    getPresetIcon(preset: Preset): string;
     getPresetByUuid(uuid: string): Preset;
     fixtureUuidAndPixelKeyEquals(fixtureUuid1: string, fixtureUuid2: string, pixelKey1: string, pixelKey2: string): boolean;
     getPresetFixture(preset: Preset, fixtureUuid: string, pixelKey?: string): PresetFixture;
+    private getPresetFixturesByUuid;
+    getOrderedPresetFixtures(preset: Preset): PresetFixture[];
+    getPresetFixtureCount(preset: Preset): number;
+    setUseGlobalFixtureOrder(preset: Preset, useGlobalFixtureOrder: boolean): void;
     fixtureIsSelected(fixture: Fixture, pixelKey: string, preset?: Preset): boolean;
     switchFixtureSelection(fixture: Fixture, pixelKey: string): void;
     selectAllFixtures(): void;
@@ -652,45 +836,114 @@ declare class PresetService {
     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;
+    deleteCapabilityValue(step: PresetStep, capabilityType: FixtureCapabilityType, color?: FixtureCapabilityColor, wheel?: string, profileUuid?: string): void;
+    private removeCapabilityValue;
+    setCapabilityValue(step: PresetStep, capabilityType: FixtureCapabilityType, valuePercentage: number, slotNumber?: number, color?: FixtureCapabilityColor, wheel?: string, profileUuid?: string): void;
+    getCapabilityValue(step: PresetStep, capabilityType: FixtureCapabilityType, color?: FixtureCapabilityColor, wheel?: string, profileUuid?: string): FixtureCapabilityValue;
+    getCapabilityValueOf(capabilityValues: FixtureCapabilityValue[], 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;
+    getApproximatedColorWheelCapability(capabilityValues: FixtureCapabilityValue[], cachedChannel: CachedFixtureChannel): CachedFixtureCapability;
+    getCapabilityChannelValue(capabilityValue: FixtureCapabilityValue, channel: CachedFixtureChannel, channelCapability: CachedFixtureCapability, preset?: Preset): number;
+    getChannelValueFromCapabilities(capabilityValues: FixtureCapabilityValue[], channel: CachedFixtureChannel, profileUuid: string, preset?: Preset): number;
+    channelIsDrivenByEffect(preset: Preset, channel: CachedFixtureChannel, profileUuid: string): boolean;
     private hasCapabilityType;
     hasCapabilityDimmer(): boolean;
     hasCapabilityColor(): boolean;
     hasCapabilityColorOrColorWheel(): boolean;
     hasCapabilityPanTilt(): boolean;
+    setPreviewPreset(previewPreset: boolean): void;
     selectPreset(index: number): void;
+    getEditStep(preset: Preset): PresetStep;
+    selectStep(step: PresetStep): void;
+    selectStepFromProject(): void;
+    addStep(): PresetStep;
+    deleteStep(step: PresetStep): void;
+    stepChanged(): void;
+    activeStep: PresetStep;
+    activeStepProgress: number;
+    private stepsVisibleOverride;
+    get stepsVisible(): boolean;
+    switchStepsVisible(): void;
+    get stepPreviewRunning(): boolean;
+    setStepPreviewRunning(running: boolean): void;
+    stepPreviewFinished(): boolean;
+    get stepPreviewStartMillis(): number;
     autoOpenFirstEffect(): void;
     addPreset(name?: string): void;
+    duplicatePreset(preset: Preset, name?: string): Preset;
+    removePreset(preset: Preset): void;
     getSelectedProfiles(): FixtureProfile[];
     getSelectedProfileChannels(selectedProfiles: FixtureProfile[]): Map<FixtureProfile, CachedFixtureChannel[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<PresetService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<PresetService>;
 }
 
+declare class PresetRegionScene {
+    preset: Preset;
+    region: ScenePlaybackRegion;
+    scene: Scene;
+    constructor(preset: Preset, region: ScenePlaybackRegion, scene: Scene);
+}
+
+/**
+ * The colors the scenes and the presets are marked with in the lists and on the
+ * timeline.
+ *
+ * A color is either picked by hand or derived from what the item does: a preset takes
+ * the color it puts on its fixtures, a scene the mixed color of the presets it plays.
+ * An item which sets no color at all falls back to the color stored with it (the one
+ * picked last, or the palette color a new scene starts with).
+ */
+declare class ColorService {
+    private fixtureService;
+    private presetService;
+    readonly palette: string[];
+    readonly pickerColors: string[];
+    private static readonly MIN_BRIGHTNESS;
+    constructor(fixtureService: FixtureService, presetService: PresetService);
+    getPresetColor(preset: Preset): string;
+    getDerivedPresetColor(preset: Preset): string;
+    getSceneColor(scene: Scene): string;
+    getDerivedSceneColor(scene: Scene): string;
+    getNewSceneColor(sceneCount: number): string;
+    toRgba(hex: string, alpha: number): string;
+    private getPresetCapabilityValues;
+    private getColorIntensityColor;
+    private getColorIntensity;
+    private getWheelSlotColor;
+    private toDisplayColor;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColorService>;
+}
+
 declare class SceneService {
     private uuidService;
+    private colorService;
     private effectService;
+    private folderService;
     private presetService;
     private projectService;
     private livePreviewService;
     selectedScenes: Scene[];
-    sceneColors: string[];
-    multipleSelection: boolean;
+    static readonly defaultIcon = "fa-picture-o";
     sceneDeleted: Subject<void>;
     sceneSelected: Subject<void>;
-    constructor(uuidService: UuidService, effectService: EffectService, presetService: PresetService, projectService: ProjectService, livePreviewService: LivePreviewService);
+    scenesChanged: Subject<void>;
+    constructor(uuidService: UuidService, colorService: ColorService, effectService: EffectService, folderService: FolderService, presetService: PresetService, projectService: ProjectService, livePreviewService: LivePreviewService);
+    getSceneIcon(scene: Scene): string;
     sceneIsSelected(scene: Scene): boolean;
+    getScenePresets(scene: Scene): Preset[];
+    addPresetToScene(scene: Scene, preset: Preset, index?: number): void;
+    removePresetFromScene(scene: Scene, preset: Preset): void;
+    removePresetFromAllScenes(preset: Preset): void;
     presetIsSelected(preset: Preset): boolean;
-    switchSceneSelection(scene: Scene): void;
     selectPresetFromSelectedScene(): void;
     selectScene(index: number): void;
-    addScene(name?: string): void;
+    selectScenes(scenes: Scene[], preset?: Preset): void;
+    addScene(name?: string, folderUuid?: string, above?: Scene): Scene;
+    duplicateScene(scene: Scene, name?: string): Scene;
     removeScene(scene: Scene): void;
     getSceneByUuid(uuid: string): Scene;
     static ɵfac: i0.ɵɵFactoryDeclaration<SceneService, never>;
@@ -700,6 +953,7 @@ declare class SceneService {
 declare class TimelineService {
     private sceneService;
     private presetService;
+    private colorService;
     private projectService;
     private http;
     private configService;
@@ -720,14 +974,14 @@ declare class TimelineService {
     detectChanges: Subject<void>;
     externalCompositionsAvailable: boolean;
     loadingAudioFile: boolean;
-    constructor(sceneService: SceneService, presetService: PresetService, projectService: ProjectService, http: HttpClient, configService: ConfigService, ngZone: NgZone, timelineStateService: TimelineStateService, livePreviewService: LivePreviewService);
+    constructor(sceneService: SceneService, presetService: PresetService, colorService: ColorService, projectService: ProjectService, http: HttpClient, configService: ConfigService, ngZone: NgZone, timelineStateService: TimelineStateService, livePreviewService: LivePreviewService);
     get playState(): string;
     set playState(playState: string);
     get selectedComposition(): Composition;
     set selectedComposition(selectedComposition: Composition);
     get selectedCompositionIndex(): number;
     set selectedCompositionIndex(selectedCompositionIndex: number);
-    private redrawAllRegions;
+    redrawAllRegions(): void;
     private pad;
     private msToTime;
     private updateCurrentTime;
@@ -746,12 +1000,15 @@ declare class TimelineService {
     deleteSelectedComposition(): void;
     destroyWaveSurfer(): void;
     createWaveSurfer(): void;
-    private hexToRgb;
+    private regionColor;
     private updateRegionSelection;
     updateSelectedRegion(): void;
     private setSelectedRegion;
     private getRegionSnapToGridValue;
     private connectRegion;
+    updateStepMarkers(): void;
+    private drawStepMarkers;
+    private createStepMarker;
     private drawRegion;
     removeRegion(): void;
     getPresetsInTime(timeMillis: number): PresetRegionScene[];
@@ -765,6 +1022,7 @@ declare class TimelineService {
 
 declare class PreviewService implements OnDestroy {
     private presetService;
+    private presetStepService;
     private fixtureService;
     private sceneService;
     private timelineService;
@@ -778,14 +1036,18 @@ declare class PreviewService implements OnDestroy {
     private stageMaterial;
     fixtureMaterial: THREE.MeshStandardMaterial;
     fixtureSelectedMaterial: THREE.MeshLambertMaterial;
-    constructor(presetService: PresetService, fixtureService: FixtureService, sceneService: SceneService, timelineService: TimelineService, projectService: ProjectService);
+    constructor(presetService: PresetService, presetStepService: PresetStepService, fixtureService: FixtureService, sceneService: SceneService, timelineService: TimelineService, projectService: ProjectService);
     private getAlreadyCalculatedFixture;
     getPresets(timeMillis: number): PresetRegionScene[];
     private mixChannelValue;
     private getFixtureIndex;
+    private getPresetStartMillis;
+    private getPresetStepState;
     private getPresetIntensity;
     private mixCapabilityValues;
     private mixChannelValues;
+    private getBeatsPerMinute;
+    private getCurveTimeMillis;
     private mixEffects;
     getChannelValues(timeMillis: number, presets: PresetRegionScene[]): Map<CachedFixture, FixtureChannelValue[]>;
     fixtureIsSelected(uuid: string, pixelKey: string, presets: PresetRegionScene[]): boolean;
@@ -803,8 +1065,11 @@ declare class PreviewComponent implements AfterViewInit {
     private animationService;
     private previewService;
     private timelineService;
-    private projectService;
+    projectService: ProjectService;
+    private presetService;
+    private sceneService;
     private ngZone;
+    hardwarePromoService: HardwarePromoService;
     private renderer;
     private scene;
     private camera;
@@ -812,11 +1077,14 @@ declare class PreviewComponent implements AfterViewInit {
     private fixtures3d;
     private fixtureGroups;
     private canvasRef;
-    constructor(fixtureService: FixtureService, previewMeshService: PreviewMeshService, animationService: AnimationService, previewService: PreviewService, timelineService: TimelineService, projectService: ProjectService, ngZone: NgZone);
+    previewHidden: boolean;
+    promoLink: string;
+    constructor(fixtureService: FixtureService, previewMeshService: PreviewMeshService, animationService: AnimationService, previewService: PreviewService, timelineService: TimelineService, projectService: ProjectService, presetService: PresetService, sceneService: SceneService, ngZone: NgZone, hardwarePromoService: HardwarePromoService);
     private syncFixtures;
     private get canvas();
     private render;
     private updateStagePosition;
+    private updateFixtures;
     private animate;
     private getAspectRatio;
     onResize(): void;
@@ -824,6 +1092,9 @@ declare class PreviewComponent implements AfterViewInit {
     private setupCamera;
     private setupControls;
     private setupScene;
+    soloPreset(): boolean;
+    switchPreviewHidden(): void;
+    previewName(): string;
     ngAfterViewInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PreviewComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<PreviewComponent, "lib-app-preview", never, {}, {}, never, never, false, never>;
@@ -848,8 +1119,10 @@ declare class FixturePoolService {
 }
 
 declare class HotkeyTargetExcludeService {
+    private static readonly textInputTypes;
     constructor();
     exclude(event: any): boolean;
+    excludeTyping(event: any): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<HotkeyTargetExcludeService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<HotkeyTargetExcludeService>;
 }
@@ -887,6 +1160,7 @@ declare class ProjectLoadService {
     private previewService;
     private fixtureService;
     private presetService;
+    private presetStepService;
     private sceneService;
     private modalService;
     private uuidService;
@@ -895,15 +1169,27 @@ declare class ProjectLoadService {
     private activatedRoute;
     private warningDialogService;
     private livePreviewService;
-    constructor(projectService: ProjectService, previewService: PreviewService, fixtureService: FixtureService, presetService: PresetService, sceneService: SceneService, modalService: BsModalService, uuidService: UuidService, timelineService: TimelineService, router: Router, activatedRoute: ActivatedRoute, warningDialogService: WarningDialogService, livePreviewService: LivePreviewService);
+    private configService;
+    private effectService;
+    constructor(projectService: ProjectService, previewService: PreviewService, fixtureService: FixtureService, presetService: PresetService, presetStepService: PresetStepService, sceneService: SceneService, modalService: BsModalService, uuidService: UuidService, timelineService: TimelineService, router: Router, activatedRoute: ActivatedRoute, warningDialogService: WarningDialogService, livePreviewService: LivePreviewService, configService: ConfigService, effectService: EffectService);
     private migrateToVersion2;
+    private migrateToVersion3;
+    private migrateToVersion4;
+    private migrateToVersion5;
+    private migrateToVersion6;
+    private migrateToVersion7;
+    private globalFixtureIndex;
     private migrateFromOldProject;
+    private setupUniverses;
     private afterLoad;
+    private announceChanges;
     private selectScenesPresetComposition;
     load(id: number, name: string, shareToken?: string): Observable<void>;
     new(): void;
     template(): void;
     import(data: string): void;
+    private restoreSelectedComposition;
+    restoreProject(project: Project): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ProjectLoadService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ProjectLoadService>;
 }
@@ -957,6 +1243,46 @@ declare class TimelineComponent implements OnInit, AfterViewInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<TimelineComponent, "lib-app-timeline", never, {}, {}, never, never, false, never>;
 }
 
+declare class UndoService implements OnDestroy {
+    private projectService;
+    private projectLoadService;
+    private ngZone;
+    private static readonly maxSteps;
+    private static readonly maxCharacters;
+    private static readonly settleMillis;
+    private static readonly typingMillis;
+    private static readonly untrackedKeys;
+    private static readonly gestureStartEvents;
+    private static readonly gestureEndEvents;
+    private static readonly typingEvents;
+    private undoSteps;
+    private redoSteps;
+    private currentState;
+    private restoring;
+    private pointerDown;
+    private captureTimer;
+    private gestureStartListener;
+    private gestureEndListener;
+    private typingListener;
+    constructor(projectService: ProjectService, projectLoadService: ProjectLoadService, ngZone: NgZone);
+    ngOnDestroy(): void;
+    private eachInteractionEvent;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    private serialize;
+    private trimHistory;
+    private scheduleCapture;
+    private capturePending;
+    captureChanges(): void;
+    private capture;
+    reset(): void;
+    private apply;
+    undo(): void;
+    redo(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UndoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UndoService>;
+}
+
 declare class DesignerComponent implements OnInit, AfterViewInit {
     private translateService;
     projectService: ProjectService;
@@ -972,7 +1298,11 @@ declare class DesignerComponent implements OnInit, AfterViewInit {
     private fixtureService;
     private timelineService;
     introService: IntroService;
+    presetService: PresetService;
+    colorService: ColorService;
     private effectService;
+    private hardwarePromoService;
+    undoService: UndoService;
     set menuHeightPx(value: number);
     set externalCompositionsAvailable(value: boolean);
     set restUrl(value: string);
@@ -987,13 +1317,14 @@ declare class DesignerComponent implements OnInit, AfterViewInit {
     set dropzoneChunking(value: boolean);
     set universes(value: UniverseConfig[]);
     set freeUniverseEdit(value: boolean);
+    set hardwarePromo(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);
+    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, presetService: PresetService, colorService: ColorService, effectService: EffectService, hardwarePromoService: HardwarePromoService, undoService: UndoService);
     private loadError;
     ngOnInit(): void;
     private calcTotalMenuHeight;
@@ -1001,6 +1332,9 @@ declare class DesignerComponent implements OnInit, AfterViewInit {
     ngAfterViewInit(): void;
     openTab(tab: string): void;
     openFixturePool(): void;
+    undo(): void;
+    redo(): void;
+    setProjectName(name: string): void;
     projectNew(): void;
     projectOpen(): void;
     projectSave(): void;
@@ -1010,9 +1344,10 @@ declare class DesignerComponent implements OnInit, AfterViewInit {
     projectExport(): void;
     projectShare(): void;
     handleKeyboardEvent(event: any): void;
+    private handleUndoRedo;
     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; }; "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; }; "universes": { "alias": "universes"; "required": false; }; "freeUniverseEdit": { "alias": "freeUniverseEdit"; "required": false; }; }, {}, never, never, false, 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; }; "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; }; "universes": { "alias": "universes"; "required": false; }; "freeUniverseEdit": { "alias": "freeUniverseEdit"; "required": false; }; "hardwarePromo": { "alias": "hardwarePromo"; "required": false; }; }, {}, never, never, false, never>;
 }
 
 declare class WarningDialogComponent implements OnInit {
@@ -1035,18 +1370,61 @@ declare class EffectCurveProfileChannels {
 }
 
 declare class EffectCurve extends Effect {
+    private static readonly dutyCycleTypes;
+    private static readonly cycleEpsilon;
+    static readonly defaultBeatsPerMinute = 120;
     curveType: string;
     capabilities: FixtureCapability[];
     channels: EffectCurveProfileChannels[];
+    lengthMode: string;
     lengthMillis: number;
+    lengthBeats: number;
     phaseMillis: number;
+    phaseBeats: number;
     amplitude: number;
     position: number;
+    dutyCycle: number;
+    runMode: string;
+    runCycles: number;
+    runDurationMillis: number;
+    endMode: string;
+    phasingMode: string;
     phasingMillis: number;
+    phasingBeats: number;
+    phasingCycles: number;
+    phasingGroupSize: number;
     constructor(data?: any);
-    getValueAtMillis(timeMillis: number, fixtureIndex?: number): number;
+    static getBeatMillis(beatsPerMinute?: number): number;
+    isBeatSynced(): boolean;
+    getLengthMillis(beatsPerMinute?: number): number;
+    getPhaseMillis(beatsPerMinute?: number): number;
+    hasDutyCycle(): boolean;
+    private getPhasingGroupSize;
+    getPhasingStepCount(fixtureCount?: number): number;
+    getPhasingStepMillis(step: number, fixtureCount?: number, beatsPerMinute?: number): number;
+    getPhasingMillis(fixtureIndex?: number, fixtureCount?: number, beatsPerMinute?: number): number;
+    getRunEndMillis(beatsPerMinute?: number): number | undefined;
+    getRunLoopMillis(fixtureCount?: number, beatsPerMinute?: number): number | undefined;
+    getValueAtMillis(timeMillis: number, fixtureIndex?: number, fixtureCount?: number, beatsPerMinute?: number): number | undefined;
+    private getCyclePosition;
+    private getClampedDutyCycle;
+    private warpCyclePosition;
+    private getCurveValue;
+}
+
+interface CurveCapabilityOption {
+    id: string;
+    name: string;
+    checked: boolean;
+    capability: FixtureCapability;
+}
+interface CurveChannelOption {
+    id: string;
+    name: string;
+    checked: boolean;
+    profile: FixtureProfile;
+    channel: CachedFixtureChannel;
 }
-
 declare class EffectCurveComponent implements OnInit, OnDestroy {
     presetService: PresetService;
     private animationService;
@@ -1055,54 +1433,113 @@ declare class EffectCurveComponent implements OnInit, OnDestroy {
     private effectService;
     private ngZone;
     livePreviewService: LivePreviewService;
-    private gridUpdateSubscription;
+    private modalService;
+    private timelineService;
+    private animationFrameId;
     private ctx;
     private maxWidth;
     private maxHeight;
     lengthMillisMin: number;
     lengthMillisMax: number;
+    lengthBeatsMin: number;
+    lengthBeatsMax: number;
     amplitudeMin: number;
     amplitudeMax: number;
     percentageMin: number;
     percentageMax: number;
-    phaseMillisMin: number;
-    phaseMillisMax: number;
     phasingMillisMin: number;
     phasingMillisMax: number;
-    availableCapabilities: FixtureCapability[];
-    availableChannels: Map<FixtureProfile, CachedFixtureChannel[]>;
+    phasingCyclesMin: number;
+    phasingCyclesMax: number;
+    phasingBeatsMin: number;
+    phasingBeatsMax: number;
+    phaseCyclesMin: number;
+    phaseCyclesMax: number;
+    capabilityOptions: CurveCapabilityOption[];
+    channelOptions: CurveChannelOption[];
+    private availableChannels;
     availableProfiles: FixtureProfile[];
     selectedProfiles: FixtureProfile[];
     private effectsOpenChangedSubscription;
+    private fixtureSelectionChangedSubscription;
+    private langChangeSubscription;
+    private effectSelected;
+    private phasingCount;
+    private phasingCountMillis;
     curve: EffectCurve;
     set isSelected(value: boolean);
     curveGrid: ElementRef;
-    constructor(presetService: PresetService, animationService: AnimationService, fixtureService: FixtureService, translate: TranslateService, effectService: EffectService, ngZone: NgZone, livePreviewService: LivePreviewService);
+    constructor(presetService: PresetService, animationService: AnimationService, fixtureService: FixtureService, translate: TranslateService, effectService: EffectService, ngZone: NgZone, livePreviewService: LivePreviewService, modalService: BsModalService, timelineService: TimelineService);
     ngOnInit(): void;
     ngOnDestroy(): void;
-    private startUpdateTimer;
-    private stopUpdateTimer;
+    private startAnimation;
+    private stopAnimation;
+    get beatsPerMinute(): number;
     private drawCurrentValue;
     private getPhasingCount;
+    private getGridDurationMillis;
     redraw(): void;
     private calculateChannelCapabilities;
     changeProfileSelection($event: any, profile: FixtureProfile): void;
+    profileChecked(profile: FixtureProfile): boolean;
     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;
+    private updateChannelOptions;
+    private updateOptionNames;
+    private updateCapabilityNames;
+    private capabilityChecked;
+    toggleCapability(event: any, option: CurveCapabilityOption): void;
+    private getChannelName;
+    private channelChecked;
+    toggleChannel(event: any, option: CurveChannelOption): void;
     setLengthMillis(value: any): void;
+    setLengthMillisFromSlider(value: any): void;
+    setLengthBeats(value: any): void;
+    setLengthBeatsFromSlider(value: any): void;
+    setLengthMode(lengthMode: string): void;
+    private clamp;
+    private lengthChanged;
+    private wrapPhase;
+    get phaseCycles(): number;
+    setPhaseCycles(value: any): void;
     setAmplitude(value: any): void;
     setPosition(value: any): void;
     setPhaseMillis(value: any): void;
+    setPhaseBeats(value: any): void;
     setPhasingMillis(value: any): void;
+    setPhasingBeats(value: any): void;
+    setPhasingCycles(value: any): void;
+    setPhasingMode(phasingMode: string): void;
+    advancedActive(): boolean;
+    openAdvanced(): 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 EffectCurveAdvancedComponent {
+    bsModalRef: BsModalRef;
+    livePreviewService: LivePreviewService;
+    curve: EffectCurve;
+    runCyclesMin: number;
+    runCyclesMax: number;
+    runDurationMillisMin: number;
+    runDurationMillisMax: number;
+    dutyCyclePercentMin: number;
+    dutyCyclePercentMax: number;
+    phasingGroupSizeMin: number;
+    phasingGroupSizeMax: number;
+    constructor(bsModalRef: BsModalRef, livePreviewService: LivePreviewService);
+    get dutyCyclePercent(): number;
+    setDutyCyclePercent(value: any): void;
+    setRunMode(runMode: string): void;
+    setRunCycles(value: any): void;
+    setRunDurationMillis(value: any): void;
+    setEndMode(endMode: string): void;
+    setPhasingGroupSize(value: any): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EffectCurveAdvancedComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EffectCurveAdvancedComponent, "lib-app-effect-curve-advanced", never, {}, {}, never, never, false, never>;
+}
+
 declare class EffectPanTiltComponent implements OnInit {
     panTiltGrid: ElementRef;
     private svg;
@@ -1117,16 +1554,171 @@ declare class EffectPanTiltComponent implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<EffectPanTiltComponent, "lib-app-effect-pan-tilt", never, {}, {}, never, never, false, never>;
 }
 
-declare class SceneComponent implements OnInit {
+/**
+ * Carries nodes which are dragged into a tree from the outside (e.g. from a list
+ * next to it). The payload cannot be read from the DragEvent itself, because the
+ * browser only hands out the transferred data on drop, not while dragging over.
+ *
+ * External nodes are inserted as they are, the source list keeps its own items.
+ */
+declare class TreeDragService {
+    nodes: TreeNode[];
+    ended: Subject<void>;
+    start(nodes: TreeNode[]): void;
+    end(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TreeDragService>;
+}
+
+interface TreeNode {
+    id?: string | number;
+    name?: string;
+    isFolder?: boolean;
+    expanded?: boolean;
+    icon?: string;
+    iconOpen?: string;
+    iconClass?: string;
+    iconColor?: string;
+    toggleOnClick?: boolean;
+    children?: TreeNode[];
+    [key: string]: any;
+}
+type TreeDropZone = 'before' | 'after' | 'inside';
+interface FlatNode {
+    node: TreeNode;
+    key: any;
+    level: number;
+    parent: TreeNode | null;
+}
+interface DropTarget {
+    row: TreeNode;
+    zone: TreeDropZone;
+    indent: number;
+    ref: TreeNode;
+}
+/**
+ * A lightweight, dependency-free tree:
+ *  - collapsible folders (click the folder icon to open/close them)
+ *  - multi selection (ctrl/cmd to toggle, shift to select a range)
+ *  - native HTML5 drag & drop, dropping before/after a node or into a folder,
+ *    moving the whole current selection at once
+ *  - accepting nodes dragged in from the outside (see TreeDragService), which are
+ *    inserted instead of moved
+ */
+declare class TreeComponent implements OnChanges, OnInit, OnDestroy {
+    private treeDragService;
+    nodes: TreeNode[];
+    selectedNodes: TreeNode[];
+    focusedNode: TreeNode | undefined;
+    publishDrag: boolean;
+    plainClickSelects: boolean;
+    nodeClass: (node: TreeNode) => string;
+    allowDrag: (node: TreeNode) => boolean;
+    allowDrop: (dragged: TreeNode[], target: TreeNode, zone: TreeDropZone) => boolean;
+    selectedNodesChange: EventEmitter<TreeNode[]>;
+    activate: EventEmitter<TreeNode>;
+    nodeDoubleClick: EventEmitter<TreeNode>;
+    nodesChange: EventEmitter<TreeNode[]>;
+    nodeExpandedChange: EventEmitter<TreeNode>;
+    nodeTemplate?: TemplateRef<any>;
+    flatNodes: FlatNode[];
+    draggingNodes: TreeNode[];
+    drop: DropTarget | null;
+    dropTail: boolean;
+    private static readonly INDENT_STEP;
+    private static readonly INDENT_BASE;
+    private selection;
+    private lastClickedIndex;
+    private flatByNode;
+    private externalDragEnded;
+    constructor(treeDragService: TreeDragService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private get activeNodes();
+    private get externalDrag();
+    indentPx(level: number): string;
+    private indent;
+    ngOnChanges(changes: SimpleChanges): void;
+    nodeIcon(node: TreeNode): string;
+    showCaret(node: TreeNode): boolean;
+    isSelected(node: TreeNode): boolean;
+    isDragging(node: TreeNode): boolean;
+    toggleExpand(node: TreeNode, event?: MouseEvent): void;
+    onRowClick(flat: FlatNode, event: MouseEvent): void;
+    onRowDoubleClick(node: TreeNode, event: MouseEvent): void;
+    private selectRange;
+    onDragStart(flat: FlatNode, event: DragEvent): void;
+    onDragOver(flat: FlatNode, event: DragEvent): void;
+    onDrop(flat: FlatNode, event: DragEvent): void;
+    onTailDragOver(event: DragEvent): void;
+    onTailDrop(event: DragEvent): void;
+    onDragEnd(): void;
+    private endDrag;
+    private clearIndicator;
+    private resolveDrop;
+    private insideOf;
+    private afterRow;
+    private canDrop;
+    private canDropAtRoot;
+    private moveNodes;
+    private detachAll;
+    private rebuild;
+    private flatten;
+    private key;
+    private remapSelection;
+    private eachNode;
+    private removeNested;
+    private contains;
+    private locate;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TreeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TreeComponent, "lib-tree", never, { "nodes": { "alias": "nodes"; "required": false; }; "selectedNodes": { "alias": "selectedNodes"; "required": false; }; "focusedNode": { "alias": "focusedNode"; "required": false; }; "publishDrag": { "alias": "publishDrag"; "required": false; }; "plainClickSelects": { "alias": "plainClickSelects"; "required": false; }; "nodeClass": { "alias": "nodeClass"; "required": false; }; "allowDrag": { "alias": "allowDrag"; "required": false; }; "allowDrop": { "alias": "allowDrop"; "required": false; }; }, { "selectedNodesChange": "selectedNodesChange"; "activate": "activate"; "nodeDoubleClick": "nodeDoubleClick"; "nodesChange": "nodesChange"; "nodeExpandedChange": "nodeExpandedChange"; }, ["nodeTemplate"], never, false, never>;
+}
+
+declare class SceneComponent implements OnInit, OnDestroy {
     sceneService: SceneService;
     presetService: PresetService;
     projectService: ProjectService;
+    private colorService;
+    private folderService;
+    private translateService;
     private modalService;
+    private livePreviewService;
     introService: IntroService;
-    constructor(sceneService: SceneService, presetService: PresetService, projectService: ProjectService, modalService: BsModalService, introService: IntroService);
+    treeNodes: TreeNode[];
+    selectedNodes: TreeNode[];
+    focusedNode: TreeNode;
+    private subscriptions;
+    private targetFolder;
+    private targetScene;
+    private targetPreset;
+    constructor(sceneService: SceneService, presetService: PresetService, projectService: ProjectService, colorService: ColorService, folderService: FolderService, translateService: TranslateService, modalService: BsModalService, livePreviewService: LivePreviewService, introService: IntroService);
     ngOnInit(): void;
-    selectScene(event: any, index: number): void;
-    removeScene(): void;
+    ngOnDestroy(): void;
+    private buildTree;
+    private buildNodes;
+    private updateSelection;
+    private updateColors;
+    private eachNode;
+    private findNode;
+    private draggedPresets;
+    allowDrop: (dragged: TreeNode[], target: TreeNode, zone: TreeDropZone) => boolean;
+    onNodesChange(nodes: TreeNode[]): void;
+    private applyNodes;
+    onActivate(node: TreeNode): void;
+    private updateFocusedNode;
+    onSelectedNodesChange(nodes: TreeNode[]): void;
+    onNodeExpandedChange(node: TreeNode): void;
+    allScenesCollapsed(): boolean;
+    switchAllScenesCollapsed(): void;
+    addScene(): void;
+    duplicateLabel(): string;
+    duplicate(): void;
+    private copyName;
+    addFolder(): void;
+    removeLabel(): string;
+    remove(): void;
+    onNodeDoubleClick(node: TreeNode): void;
+    dimmerPercentage(scene: Scene): number;
     openSettings(scene: Scene): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<SceneComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<SceneComponent, "lib-app-scene", never, {}, {}, never, never, false, never>;
@@ -1156,19 +1748,75 @@ declare class FixtureCapabilityColorComponent implements OnInit, OnDestroy {
     static ɵcmp: i0.ɵɵComponentDeclaration<FixtureCapabilityColorComponent, "lib-app-fixture-capability-color", never, {}, {}, never, never, false, never>;
 }
 
-declare class FixtureComponent implements OnInit {
+/**
+ * The fixture order of the project: its fixtures grouped in folders, plus the presets
+ * which bring an order of their own inside those same folders.
+ *
+ * The fixture panel and the fixture pool both show and edit these folders, so both keep
+ * everything which follows from them in step from here.
+ */
+declare class FixtureOrderService {
+    private projectService;
+    private folderService;
+    constructor(projectService: ProjectService, folderService: FolderService);
+    fixtureKey(presetFixture: PresetFixture): string;
+    getProjectFixtures(): Map<string, PresetFixture>;
+    getFolders(preset?: Preset): Folder[];
+    sortProjectFixtures(): void;
+    syncPresetOrders(): void;
+    syncPresetOrder(preset: Preset, projectFixtures?: Map<string, PresetFixture>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FixtureOrderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FixtureOrderService>;
+}
+
+declare class FixtureComponent implements OnInit, OnDestroy {
     projectService: ProjectService;
     presetService: PresetService;
     private fixturePoolService;
     fixtureService: FixtureService;
     introService: IntroService;
+    private folderService;
+    private fixtureOrderService;
+    private translateService;
     private livePreviewService;
-    fixtureSortableOptions: Options;
-    constructor(projectService: ProjectService, presetService: PresetService, fixturePoolService: FixturePoolService, fixtureService: FixtureService, introService: IntroService, livePreviewService: LivePreviewService);
+    otherFixtures: PresetFixture[];
+    treeNodes: TreeNode[];
+    selectedNodes: TreeNode[];
+    focusedNode: TreeNode;
+    private subscriptions;
+    private targetFolder;
+    private targetFixture;
+    private parentOf;
+    constructor(projectService: ProjectService, presetService: PresetService, fixturePoolService: FixturePoolService, fixtureService: FixtureService, introService: IntroService, folderService: FolderService, fixtureOrderService: FixtureOrderService, translateService: TranslateService, livePreviewService: LivePreviewService);
     ngOnInit(): void;
+    ngOnDestroy(): void;
+    usePresetOrder(): boolean;
+    switchCustomFixtureOrder(customFixtureOrder: boolean): void;
+    private orderedPreset;
+    private buildTree;
+    private updateOtherFixtures;
+    private orderItems;
+    private buildNodes;
+    private updateFocusedNode;
+    private findNode;
+    nodeClass: (node: TreeNode) => string;
+    allowDrag: (node: TreeNode) => boolean;
+    allowDrop: (dragged: TreeNode[], target: TreeNode, zone: TreeDropZone) => boolean;
+    private containsFolder;
+    onNodesChange(nodes: TreeNode[]): void;
+    private applyNodes;
+    private setFolderPosition;
+    onNodeExpandedChange(node: TreeNode): void;
+    onActivate(node: TreeNode): void;
+    onSelectedNodesChange(nodes: TreeNode[]): void;
+    allFoldersCollapsed(): boolean;
+    switchAllFoldersCollapsed(): void;
+    addFolder(): void;
+    removeFolder(): void;
+    fixtureIconClass(presetFixture: PresetFixture): string;
     fixtureName(presetFixture: PresetFixture): string;
     fixtureIsSelected(presetFixture: PresetFixture): boolean;
-    selectFixture(event: any, presetFixture: PresetFixture): void;
+    selectFixture(presetFixture: PresetFixture): void;
     selectAll(): void;
     selectNone(): void;
     fixtureListReordered(): void;
@@ -1216,6 +1864,7 @@ declare class FixtureCapabilityComponent implements OnInit, OnDestroy {
     introService: IntroService;
     private fixtureSelectionChangedSubscription;
     private previewSelectionChangedSubscription;
+    private stepsChangedSubscription;
     colorWheelChannels: Map<FixtureProfile, CachedFixtureChannel>;
     hasCapabilityDimmer: boolean;
     hasCapabilityColorOrColorWheel: boolean;
@@ -1252,15 +1901,24 @@ declare class EffectComponent implements OnInit {
     constructor(uuidService: UuidService, presetService: PresetService, effectService: EffectService, warningDialogService: WarningDialogService, livePreviewService: LivePreviewService);
     ngOnInit(): void;
     private addEffect;
+    toggleVisible(effect: Effect): void;
     addCurveEffect(): void;
     addPanTiltEffect(): void;
     openEffect(effect: Effect, event: any): void;
+    duplicateEffect(effect: Effect): 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 {
+interface DmxChannel {
+    occupied: boolean;
+    start: boolean;
+    end: boolean;
+    selected: boolean;
+    overlapped: boolean;
+}
+declare class FixturePoolComponent implements OnInit, AfterViewInit, OnDestroy {
     bsModalRef: BsModalRef;
     fixtureService: FixtureService;
     private uuidService;
@@ -1271,15 +1929,26 @@ declare class FixturePoolComponent implements OnInit {
     private presetService;
     configService: ConfigService;
     private modalService;
+    private folderService;
+    private fixtureOrderService;
+    private ngZone;
+    private hotkeyTargetExcludeService;
     private livePreviewService;
-    private profiles;
+    hardwarePromoService: HardwarePromoService;
     filteredProfiles: FixtureProfile[];
+    hiddenProfileCount: number;
     loadingProfiles: boolean;
     fixturePool: Fixture[];
-    dmxChannels: number[];
+    fixtureFolders: Folder[];
+    treeNodes: TreeNode[];
+    selectedNodes: TreeNode[];
+    focusedNode: TreeNode;
+    dmxChannels: DmxChannel[];
+    dmxMap: ElementRef<HTMLElement>;
+    dmxCanvas: ElementRef<HTMLCanvasElement>;
+    channelLabel: ElementRef<HTMLElement>;
     selectedFixture: Fixture;
     selectedFixtureProfile: FixtureProfile;
-    showChannelNumbers: boolean;
     channelDragFixture: Fixture;
     channelDragOffset: number;
     onClose: Subject<number>;
@@ -1287,7 +1956,18 @@ declare class FixturePoolComponent implements OnInit {
     updatingProfiles: boolean;
     universes: UniverseConfig[];
     selectedUniverse: UniverseConfig;
-    constructor(bsModalRef: BsModalRef, fixtureService: FixtureService, uuidService: UuidService, projectService: ProjectService, previewService: PreviewService, translateService: TranslateService, toastrService: ToastrService, presetService: PresetService, configService: ConfigService, modalService: BsModalService, livePreviewService: LivePreviewService);
+    promoLink: string;
+    private static readonly maxShownProfiles;
+    private static readonly channelWidth;
+    private static readonly channelHeight;
+    private channelsPerRow;
+    private labelledChannel;
+    private mapResized;
+    private fixtureItems;
+    private searchIndex;
+    private targetFolder;
+    private fixtureOrderChanged;
+    constructor(bsModalRef: BsModalRef, fixtureService: FixtureService, uuidService: UuidService, projectService: ProjectService, previewService: PreviewService, translateService: TranslateService, toastrService: ToastrService, presetService: PresetService, configService: ConfigService, modalService: BsModalService, folderService: FolderService, fixtureOrderService: FixtureOrderService, ngZone: NgZone, hotkeyTargetExcludeService: HotkeyTargetExcludeService, livePreviewService: LivePreviewService, hardwarePromoService: HardwarePromoService);
     get freeUniverseEdit(): boolean;
     /** Fixtures belonging to the currently selected universe. */
     get currentUniverseFixtures(): Fixture[];
@@ -1295,22 +1975,54 @@ declare class FixturePoolComponent implements OnInit {
     private get channelFixtures();
     selectUniverse(universe: UniverseConfig): void;
     ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private channelHovered;
+    private channelLeft;
+    private channelAt;
+    private labelChannel;
+    private drawChannelMap;
+    private channelRuns;
+    private channelBar;
     private loadProfiles;
     selectFixture(fixture: Fixture): void;
+    private buildFixtureItems;
+    private buildTree;
+    private buildNodes;
+    private updateSelection;
+    private updateFocusedNode;
+    private findNode;
+    nodeClass: (node: TreeNode) => string;
+    allowDrop: (dragged: TreeNode[], target: TreeNode, zone: TreeDropZone) => boolean;
+    private containsFolder;
+    onNodesChange(nodes: TreeNode[]): void;
+    private applyNodes;
+    onNodeExpandedChange(node: TreeNode): void;
+    onActivate(node: TreeNode): void;
+    onSelectedNodesChange(nodes: TreeNode[]): void;
+    allFoldersCollapsed(): boolean;
+    switchAllFoldersCollapsed(): void;
+    addFolder(): void;
+    removeFolder(): void;
+    private targetFolderUuid;
+    private selectedItem;
+    private nextSortIndex;
+    private addFixtureItem;
     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;
-    private channelOverlappedInFixtures;
-    channelMouseDown(event: any): void;
-    channelSelected(index: number): boolean;
+    updateChannelMap(): void;
+    private lampKey;
+    private fixtureChannelCount;
+    private fixturesOverlap;
+    channelMouseDown(event: MouseEvent): void;
     mouseUp(event: any): void;
-    channelMouseOver(event: any): void;
+    private dragChannelTo;
+    setFirstChannel(channel: number): void;
     ok(): void;
+    private addPresetFixture;
+    private applyFixtureOrder;
     cancel(): void;
     updateProfiles(): void;
     openEditUniverses(): void;
@@ -1320,97 +2032,53 @@ declare class FixturePoolComponent implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<FixturePoolComponent, "lib-app-fixture-pool", never, {}, {}, never, never, false, never>;
 }
 
-interface TreeNode {
-    id?: string | number;
-    name?: string;
-    isFolder?: boolean;
-    expanded?: boolean;
-    children?: TreeNode[];
-    [key: string]: any;
-}
-type TreeDropZone = 'before' | 'after' | 'inside';
-interface FlatNode {
-    node: TreeNode;
-    level: number;
-    parent: TreeNode | null;
-}
-interface DropTarget {
-    row: TreeNode;
-    zone: TreeDropZone;
-    indent: number;
-    ref: TreeNode;
-}
-/**
- * A lightweight, dependency-free tree:
- *  - collapsible folders (closed/open folder icon)
- *  - multi selection (ctrl/cmd to toggle, shift to select a range)
- *  - native HTML5 drag & drop, dropping before/after a node or into a folder,
- *    moving the whole current selection at once
- */
-declare class TreeComponent implements OnChanges {
-    nodes: TreeNode[];
-    selectedNodes: TreeNode[];
-    allowDrag: (node: TreeNode) => boolean;
-    allowDrop: (dragged: TreeNode[], target: TreeNode, zone: TreeDropZone) => boolean;
-    selectedNodesChange: EventEmitter<TreeNode[]>;
-    activate: EventEmitter<TreeNode>;
-    nodesChange: EventEmitter<TreeNode[]>;
-    nodeTemplate?: TemplateRef<any>;
-    flatNodes: FlatNode[];
-    draggingNodes: TreeNode[];
-    drop: DropTarget | null;
-    dropTail: boolean;
-    private static readonly INDENT_STEP;
-    private static readonly INDENT_BASE;
-    private selection;
-    private lastClickedIndex;
-    private flatByNode;
-    indentPx(level: number): string;
-    private indent;
-    ngOnChanges(changes: SimpleChanges): void;
-    isSelected(node: TreeNode): boolean;
-    isDragging(node: TreeNode): boolean;
-    toggleExpand(node: TreeNode): void;
-    onRowClick(flat: FlatNode, event: MouseEvent): void;
-    private selectRange;
-    onDragStart(flat: FlatNode, event: DragEvent): void;
-    onDragOver(flat: FlatNode, event: DragEvent): void;
-    onDrop(flat: FlatNode, event: DragEvent): void;
-    onTailDragOver(event: DragEvent): void;
-    onTailDrop(event: DragEvent): void;
-    onDragEnd(): void;
-    private endDrag;
-    private clearIndicator;
-    private resolveDrop;
-    private afterRow;
-    private canDrop;
-    private moveNodes;
-    private detachAll;
-    private rebuild;
-    private flatten;
-    private removeNested;
-    private contains;
-    private locate;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TreeComponent, "lib-tree", never, { "nodes": { "alias": "nodes"; "required": false; }; "selectedNodes": { "alias": "selectedNodes"; "required": false; }; "allowDrag": { "alias": "allowDrag"; "required": false; }; "allowDrop": { "alias": "allowDrop"; "required": false; }; }, { "selectedNodesChange": "selectedNodesChange"; "activate": "activate"; "nodesChange": "nodesChange"; }, ["nodeTemplate"], never, false, never>;
-}
-
-declare class PresetComponent implements OnInit {
+declare class PresetComponent implements OnInit, OnDestroy {
     presetService: PresetService;
     sceneService: SceneService;
     projectService: ProjectService;
     introService: IntroService;
+    private colorService;
+    private folderService;
+    private translateService;
     private modalService;
     treeNodes: TreeNode[];
-    constructor(presetService: PresetService, sceneService: SceneService, projectService: ProjectService, introService: IntroService, modalService: BsModalService);
+    selectedNodes: TreeNode[];
+    focusedNode: TreeNode;
+    private subscriptions;
+    private targetFolder;
+    constructor(presetService: PresetService, sceneService: SceneService, projectService: ProjectService, introService: IntroService, colorService: ColorService, folderService: FolderService, translateService: TranslateService, modalService: BsModalService);
     ngOnInit(): void;
+    ngOnDestroy(): void;
+    private buildTree;
+    private buildNodes;
+    private updateSelection;
+    private updateColors;
+    private eachNode;
+    private updateFocusedNode;
+    private findPresetNode;
+    private findFolderNode;
+    allowDrop: (dragged: TreeNode[], target: TreeNode, zone: TreeDropZone) => boolean;
+    private containsFolder;
+    onNodesChange(nodes: TreeNode[]): void;
+    private applyNodes;
+    onNodeExpandedChange(node: TreeNode): void;
     onActivate(node: TreeNode): void;
-    selectPreset(index: number): void;
+    onSelectedNodesChange(nodes: TreeNode[]): void;
+    allFoldersCollapsed(): boolean;
+    switchAllFoldersCollapsed(): void;
+    private singleSelectedScene;
     enableCheckbox(): boolean;
-    activatePreset(active: boolean, index: number): void;
+    activatePreset(active: boolean, preset: Preset): void;
+    soloPreset(): boolean;
+    switchSoloPreset(): void;
     addPreset(): void;
-    removePreset(): void;
-    openSettings(preset: Preset): void;
+    duplicatePreset(): void;
+    private copyName;
+    addFolder(): void;
+    removeLabel(): string;
+    remove(): void;
+    onNodeDoubleClick(node: TreeNode): void;
+    openSettings(node: TreeNode): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<PresetComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<PresetComponent, "lib-app-preset", never, {}, {}, never, never, false, never>;
 }
@@ -1469,6 +2137,7 @@ declare class CompositionSettingsComponent implements OnInit {
     private warningDialogService;
     private toastrService;
     projectService: ProjectService;
+    hardwarePromoService: HardwarePromoService;
     composition: Composition;
     existingCompositionNames: string[];
     onClose: Subject<number>;
@@ -1477,7 +2146,8 @@ declare class CompositionSettingsComponent implements OnInit {
     existingFiles: string[];
     filteredExistingFiles: string[];
     uploading: boolean;
-    constructor(bsModalRef: BsModalRef, timelineService: TimelineService, configService: ConfigService, translateService: TranslateService, http: HttpClient, warningDialogService: WarningDialogService, toastrService: ToastrService, projectService: ProjectService);
+    promoLink: string;
+    constructor(bsModalRef: BsModalRef, timelineService: TimelineService, configService: ConfigService, translateService: TranslateService, http: HttpClient, warningDialogService: WarningDialogService, toastrService: ToastrService, projectService: ProjectService, hardwarePromoService: HardwarePromoService);
     ngOnInit(): void;
     getDropzoneUrl(): string;
     ok(): void;
@@ -1508,6 +2178,11 @@ declare class FixtureCapabilityPanTiltComponent implements OnInit {
     private livePreviewService;
     constructor(presetService: PresetService, changeDetectorRef: ChangeDetectorRef, livePreviewService: LivePreviewService);
     ngOnInit(): void;
+    getMirrorPan(): boolean;
+    setMirrorPan(mirror: boolean): void;
+    getMirrorTilt(): boolean;
+    setMirrorTilt(mirror: boolean): void;
+    private mirrorChanged;
     getValuePan(): number;
     getValueTextPan(): number;
     setValuePan(value: any): void;
@@ -1519,14 +2194,18 @@ declare class FixtureCapabilityPanTiltComponent implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<FixtureCapabilityPanTiltComponent, "lib-app-fixture-capability-pan-tilt", never, {}, {}, never, never, false, never>;
 }
 
-declare class FixtureCapabilityChannelComponent implements OnInit {
+declare class FixtureCapabilityChannelComponent implements OnInit, OnDestroy {
     private presetService;
+    private effectService;
     private livePreviewService;
+    private changeDetectorRef;
     sliderValue: ElementRef;
     selectedCapability: CachedFixtureCapability;
     _channel: CachedFixtureChannel;
     defaultValue: number;
     value: number;
+    capabilityValue: number;
+    drivenByEffect: boolean;
     templateValue: number;
     description: string;
     hasRange: boolean;
@@ -1535,10 +2214,15 @@ declare class FixtureCapabilityChannelComponent implements OnInit {
     descriptionStart: string;
     descriptionEnd: string;
     valueSetTimer: any;
+    private updateTimer;
+    private capabilityValuesChangedSubscription;
+    private effectsChangedSubscription;
+    private stepsChangedSubscription;
     profile: FixtureProfile;
     set channel(value: CachedFixtureChannel);
     capabilityIndex: number;
-    constructor(presetService: PresetService, livePreviewService: LivePreviewService);
+    constructor(presetService: PresetService, effectService: EffectService, livePreviewService: LivePreviewService, changeDetectorRef: ChangeDetectorRef);
+    private scheduleUpdate;
     private updateChannel;
     capabilityHasRange(): boolean;
     getDescriptionStart(capability: CachedFixtureCapability): string;
@@ -1547,6 +2231,7 @@ declare class FixtureCapabilityChannelComponent implements OnInit {
     private getRangeMin;
     private getRangeMax;
     ngOnInit(): void;
+    ngOnDestroy(): void;
     setValue(value: any, ignoreCapabilityRange?: boolean): void;
     private calculateTemplateValue;
     private getDefaultValue;
@@ -1631,6 +2316,7 @@ declare class UserRegisterComponent implements OnInit {
     email: string;
     password: string;
     passwordRepeat: string;
+    newsletter: boolean;
     subject: Subject<void>;
     constructor(bsModalRef: BsModalRef, modalService: BsModalService, userService: UserService);
     ngOnInit(): void;
@@ -1689,8 +2375,10 @@ declare class ProjectImportComponent implements OnInit {
 declare class ProjectShareComponent implements OnInit {
     bsModalRef: BsModalRef;
     private projectService;
+    hardwarePromoService: HardwarePromoService;
     shareLink: string;
-    constructor(bsModalRef: BsModalRef, projectService: ProjectService);
+    promoLink: string;
+    constructor(bsModalRef: BsModalRef, projectService: ProjectService, hardwarePromoService: HardwarePromoService);
     ngOnInit(): void;
     ok(): void;
     cancel(): void;
@@ -1726,7 +2414,9 @@ declare class FixtureSettingsStageComponent implements OnInit {
 
 declare class IntroComponent implements OnInit {
     introService: IntroService;
-    constructor(introService: IntroService);
+    hardwarePromoService: HardwarePromoService;
+    promoLink: string;
+    constructor(introService: IntroService, hardwarePromoService: HardwarePromoService);
     ngOnInit(): void;
     close(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<IntroComponent, never>;
@@ -1735,16 +2425,28 @@ declare class IntroComponent implements OnInit {
 
 declare class PresetSettingsComponent implements OnInit {
     bsModalRef: BsModalRef;
+    private colorService;
+    private presetService;
     preset: Preset;
     name: string;
+    color: string;
+    colorAuto: boolean;
+    icon: string;
     startMillis: number;
     endMillis: number;
     fadeInMillis: number;
     fadeOutMillis: number;
     fadeInPre: boolean;
     fadeOutPost: boolean;
-    constructor(bsModalRef: BsModalRef);
+    fadeInCurve: TransitionCurveType;
+    fadeOutCurve: TransitionCurveType;
+    transitionCurveTypes: TransitionCurveType[];
+    derivedColor: string;
+    readonly defaultIcon = "fa-lightbulb-o";
+    palette: string[];
+    constructor(bsModalRef: BsModalRef, colorService: ColorService, presetService: PresetService);
     ngOnInit(): void;
+    shownColor(): string;
     ok(): void;
     cancel(): void;
     handleKeyboardEvent(event: any): void;
@@ -1752,16 +2454,100 @@ declare class PresetSettingsComponent implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<PresetSettingsComponent, "lib-preset-settings", never, {}, {}, never, never, false, never>;
 }
 
+declare class PresetStepComponent implements OnInit, OnDestroy {
+    presetService: PresetService;
+    private presetStepService;
+    private modalService;
+    private translateService;
+    private changeDetectorRef;
+    private ngZone;
+    activeStep: PresetStep;
+    activeStepPercentage: number;
+    private activeStepTimer;
+    constructor(presetService: PresetService, presetStepService: PresetStepService, modalService: BsModalService, translateService: TranslateService, changeDetectorRef: ChangeDetectorRef, ngZone: NgZone);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    stepDescription(step: PresetStep, index: number): string;
+    selectStep(step: PresetStep): void;
+    addStep(): void;
+    deleteStep(): void;
+    switchStepPreview(): void;
+    openStepsSettings(): void;
+    openSettings(step: PresetStep): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PresetStepComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PresetStepComponent, "lib-app-preset-step", never, {}, {}, never, never, false, never>;
+}
+
+declare class PresetStepSettingsComponent implements OnInit {
+    bsModalRef: BsModalRef;
+    private presetService;
+    private presetStepService;
+    preset: Preset;
+    step: PresetStep;
+    startMillis: number;
+    transitionMillis: number;
+    transitionCurve: TransitionCurveType;
+    stepNumber: number;
+    wholeStepMillis: number;
+    effectAmounts: number[];
+    transitionCurveTypes: TransitionCurveType[];
+    constructor(bsModalRef: BsModalRef, presetService: PresetService, presetStepService: PresetStepService);
+    ngOnInit(): void;
+    ok(): void;
+    cancel(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PresetStepSettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PresetStepSettingsComponent, "lib-preset-step-settings", never, {}, {}, never, never, false, never>;
+}
+
+declare class PresetStepsSettingsComponent implements OnInit {
+    bsModalRef: BsModalRef;
+    private presetStepService;
+    private livePreviewService;
+    preset: Preset;
+    stepsLoop: boolean;
+    stepsLoopMillis: number;
+    stepsPhasingMode: string;
+    stepsPhasingMillis: number;
+    stepsPhasingCycles: number;
+    stepsPhasingGroupSize: number;
+    automaticLoopMillis: number;
+    constructor(bsModalRef: BsModalRef, presetStepService: PresetStepService, livePreviewService: LivePreviewService);
+    ngOnInit(): void;
+    setPhasingAmount(amount: number): void;
+    ok(): void;
+    cancel(): void;
+    handleKeyboardEvent(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PresetStepsSettingsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PresetStepsSettingsComponent, "lib-preset-steps-settings", never, {}, {}, never, never, false, never>;
+}
+
 declare class SceneSettingsComponent implements OnInit {
     bsModalRef: BsModalRef;
+    private colorService;
+    private sceneService;
+    private livePreviewService;
     scene: Scene;
     name: string;
+    color: string;
+    colorAuto: boolean;
+    icon: string;
+    dimmer: number;
     fadeInMillis: number;
     fadeOutMillis: number;
     fadeInPre: boolean;
     fadeOutPost: boolean;
-    constructor(bsModalRef: BsModalRef);
+    fadeInCurve: TransitionCurveType;
+    fadeOutCurve: TransitionCurveType;
+    transitionCurveTypes: TransitionCurveType[];
+    derivedColor: string;
+    readonly defaultIcon = "fa-picture-o";
+    palette: string[];
+    constructor(bsModalRef: BsModalRef, colorService: ColorService, sceneService: SceneService, livePreviewService: LivePreviewService);
     ngOnInit(): void;
+    dimmerPercentage(): number;
+    setDimmer(value: any): void;
+    shownColor(): string;
     ok(): void;
     cancel(): void;
     handleKeyboardEvent(event: any): void;
@@ -1813,10 +2599,12 @@ declare class FixturePoolCreateFromFileComponent implements OnInit {
 declare class FixturePoolEditUniversesComponent {
     bsModalRef: BsModalRef;
     private uuidService;
+    hardwarePromoService: HardwarePromoService;
     universes: UniverseConfig[];
     newUniverseName: string;
     onClose: Subject<UniverseConfig[] | undefined>;
-    constructor(bsModalRef: BsModalRef, uuidService: UuidService);
+    promoLink: string;
+    constructor(bsModalRef: BsModalRef, uuidService: UuidService, hardwarePromoService: HardwarePromoService);
     addUniverse(): void;
     removeUniverse(universe: UniverseConfig): void;
     ok(): void;
@@ -1865,9 +2653,106 @@ declare class SortablejsDirective implements AfterViewInit, OnDestroy {
     static ɵdir: i0.ɵɵDirectiveDeclaration<SortablejsDirective, "[sortablejs]", never, { "sortablejs": { "alias": "sortablejs"; "required": false; }; "sortablejsContainer": { "alias": "sortablejsContainer"; "required": false; }; "sortablejsOptions": { "alias": "sortablejsOptions"; "required": false; }; }, { "sortablejsInit": "sortablejsInit"; }, never, never, false, never>;
 }
 
+declare class InlineEditComponent {
+    value: string;
+    valueChange: EventEmitter<string>;
+    placeholder: string;
+    editing: boolean;
+    editValue: string;
+    editInput: ElementRef<HTMLInputElement>;
+    get inputSize(): number;
+    startEdit(): void;
+    save(): void;
+    cancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineEditComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InlineEditComponent, "lib-app-inline-edit", never, { "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, false, never>;
+}
+
+/**
+ * Picks the color an item (a scene, a preset) is marked with: a wheel for a free
+ * choice, a palette for a quick one and the hex value for an exact one.
+ *
+ * The color can also be left to the item itself, which is what the "automatic" switch
+ * is for: the picker then shows what the item derives (autoColor), and picking anything
+ * puts it back to the color chosen here.
+ */
+declare class ColorPickerComponent implements AfterViewInit, OnChanges, OnDestroy {
+    color: string;
+    colorChange: EventEmitter<string>;
+    auto: boolean;
+    autoChange: EventEmitter<boolean>;
+    autoColor: string;
+    autoLabel: string;
+    palette: string[];
+    wheelContainer: ElementRef<HTMLElement>;
+    hexValue: string;
+    readonly autoId: string;
+    private static instances;
+    private picker;
+    private updating;
+    private mounted;
+    get shownColor(): string;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    private static readonly noColor;
+    pick(color: string): void;
+    pickHex(value: string): void;
+    resetHex(): void;
+    setAuto(auto: boolean): void;
+    private onWheelChange;
+    private apply;
+    private update;
+    private static parseHex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorPickerComponent, "lib-app-color-picker", never, { "color": { "alias": "color"; "required": false; }; "auto": { "alias": "auto"; "required": false; }; "autoColor": { "alias": "autoColor"; "required": false; }; "autoLabel": { "alias": "autoLabel"; "required": false; }; "palette": { "alias": "palette"; "required": false; }; }, { "colorChange": "colorChange"; "autoChange": "autoChange"; }, never, never, false, never>;
+}
+
+/**
+ * Picks the icon an item (a scene, a preset) is shown with in the trees, from a small
+ * set of font awesome glyphs which say something about lighting: what a look is, what
+ * it does and where in the show it belongs.
+ *
+ * The icon can also be left alone, which is what the first entry is for: the item then
+ * keeps the default icon of its kind.
+ */
+declare class IconPickerComponent implements OnChanges {
+    icon: string;
+    iconChange: EventEmitter<string>;
+    defaultIcon: string;
+    color: string;
+    pickableIcons: string[];
+    ngOnChanges(): void;
+    get defaultPicked(): boolean;
+    pick(icon: string): void;
+    private static readonly icons;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconPickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IconPickerComponent, "lib-app-icon-picker", never, { "icon": { "alias": "icon"; "required": false; }; "defaultIcon": { "alias": "defaultIcon"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, { "iconChange": "iconChange"; }, never, never, false, never>;
+}
+
+declare class HardwarePromoBarComponent {
+    hardwarePromoService: HardwarePromoService;
+    introService: IntroService;
+    link: string;
+    constructor(hardwarePromoService: HardwarePromoService, introService: IntroService);
+    get show(): boolean;
+    dismiss(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HardwarePromoBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HardwarePromoBarComponent, "lib-app-hardware-promo-bar", never, {}, {}, never, never, false, never>;
+}
+
+declare class HardwarePromoDialogComponent {
+    private bsModalRef;
+    link: string;
+    constructor(bsModalRef: BsModalRef, hardwarePromoService: HardwarePromoService);
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HardwarePromoDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HardwarePromoDialogComponent, "lib-app-hardware-promo-dialog", never, {}, {}, 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 FixturePoolEditUniversesComponent, typeof DropzoneComponent, typeof SortablejsDirective, typeof TreeComponent], [typeof i42.RouterModule, typeof i43.BrowserModule, typeof i44.BrowserAnimationsModule, typeof i45.FormsModule, typeof i46.NgxBootstrapSliderModule, typeof i47.TranslateModule, typeof i48.AccordionModule, typeof i49.PopoverModule, typeof i50.TypeaheadModule, typeof i51.DropzoneModule, typeof i52.ToastrModule], [typeof DesignerComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DesignerModule, [typeof DesignerComponent, typeof WarningDialogComponent, typeof PreviewComponent, typeof EffectCurveComponent, typeof EffectCurveAdvancedComponent, 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 PresetStepComponent, typeof PresetStepSettingsComponent, typeof PresetStepsSettingsComponent, typeof SceneSettingsComponent, typeof ProjectSaveComponent, typeof FixturePoolCreateFromFileComponent, typeof FixturePoolEditUniversesComponent, typeof DropzoneComponent, typeof SortablejsDirective, typeof TreeComponent, typeof InlineEditComponent, typeof ColorPickerComponent, typeof IconPickerComponent, typeof HardwarePromoBarComponent, typeof HardwarePromoDialogComponent], [typeof i51.RouterModule, typeof i52.BrowserModule, typeof i53.BrowserAnimationsModule, typeof i54.FormsModule, typeof i55.NgxBootstrapSliderModule, typeof i56.TranslateModule, typeof i57.AccordionModule, typeof i58.PopoverModule, typeof i59.TypeaheadModule, typeof i60.DropzoneModule, typeof i61.ToastrModule], [typeof DesignerComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DesignerModule>;
 }