@colijnit/inphoto 300.1.0 → 300.1.2

package/index.d.ts

@@ -18,12 +18,14 @@ import { Options } from '@colijnit/ioneconnector/build/model/options';
 import { DataServiceResponseData } from '@colijnit/ioneconnector/build/model/data-service-response-data';
 import { ExternalCatalogStartupInfoRequest } from '@colijnit/articleapi/build/model/external-catalog-startup-info-request';
 import { ExternalCatalogStartupInfo } from '@colijnit/articleapi/build/model/external-catalog-startup-info';
-import { ExternalSourceArticleClickInterface } from '@colijnit/articleapi/build/interface/external-source-article-click.interface';
-import * as i7 from '@colijnit/configurator';
+import * as i7$1 from '@colijnit/configurator';
 import { ConfigurationResultObject, ConfiguringService, ConfiguratorEventService } from '@colijnit/configurator';
+import { ExternalSourceArticleClickInterface } from '@colijnit/articleapi/build/interface/external-source-article-click.interface';
+import { Font } from 'three/examples/jsm/loaders/FontLoader.js';
 import * as i2$1 from '@angular/forms';
-import { Router } from '@angular/router';
+import * as i7 from '@angular/cdk/drag-drop';
 import * as i4 from '@angular/common';
+import * as i5 from '@colijnit/utilities';
 
 /** AUTO GENERATED FILE. DO NOT CHANGE.. OR YOU WILL SUFFER THE CONSEQUENCES OF YOUR ACTIONS **/
 declare enum Icon {
@@ -36,22 +38,46 @@ declare enum Icon {
     ArrowUpRightAndArrowDownLeftFromCenterSolidFull = "arrow_up_right_and_arrow_down_left_from_center_solid_full",
     ArrowUpToBracketDuotoneRegular = "arrow_up_to_bracket_duotone_regular",
     BrushSolidFull = "brush_solid_full",
+    CaretDownSolidFull = "caret_down_solid_full",
+    CaretUpSolidFull = "caret_up_solid_full",
+    CheckSolidFull = "check_solid_full",
+    CircleInfoRegularFull = "circle_info_regular_full",
+    CloudArrowUpRegular = "cloud_arrow_up_regular",
+    CopyLight = "copy_light",
     CouchSolidFull = "couch_solid_full",
     CrossSkinny = "cross_skinny",
+    CubeRegularFull = "cube_regular_full",
+    DrawSquareRegular = "draw_square_regular",
+    EraserRegular = "eraser_regular",
+    EraserSolidFull = "eraser_solid_full",
+    FileVectorLight = "file_vector_light",
     FillSolidFull = "fill_solid_full",
+    GripDotsVerticalSolid = "grip_dots_vertical_solid",
+    GripVerticalSharpSolid = "grip_vertical_sharp_solid",
     ImagesSharpSolidFull = "images_sharp_solid_full",
     ImageCircleArrowDownSolidFull = "image_circle_arrow_down_solid_full",
     ImageCircleXmarkSolidFull = "image_circle_xmark_solid_full",
     ImageSolidFull = "image_solid_full",
+    InfoSolidFull = "info_solid_full",
     LightbulbRegularFull = "lightbulb_regular_full",
+    LockSolidFull = "lock_solid_full",
+    PaintbrushRegular = "paintbrush_regular",
     PenToSquareSolidFull = "pen_to_square_solid_full",
+    RotateLeftSharpSolidFull = "rotate_left_sharp_solid_full",
+    RotateSolidFull = "rotate_solid_full",
     SaveSkinny = "save_skinny",
+    Scale = "scale",
     SharpRegularObjectGroupPen = "sharp_regular_object_group_pen",
+    SparklesRegularFull = "sparkles_regular_full",
+    TrashCanLight = "trash_can_light",
     UploadSolidFull = "upload_solid_full",
-    WandMagicSparklesSharpRegular = "wand_magic_sparkles_sharp_regular"
+    UpDownLeftRightSolidFull = "up_down_left_right_solid_full",
+    WandMagicSparkles = "wand_magic_sparkles",
+    WandMagicSparklesSharpRegular = "wand_magic_sparkles_sharp_regular",
+    XmarkSolidFull = "xmark_solid_full"
 }
 
-declare class IconCacheService {
+declare class InphotoIconCacheService {
     private _sanitizer;
     /**
      * All the icons as a large JSON object, from the all-icons.json file.
@@ -66,12 +92,12 @@ declare class IconCacheService {
     getIconAsBase64(iconName: Icon): SafeHtml;
     getRawIcon(iconName: Icon): string;
     setIconCache(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<IconCacheService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<IconCacheService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoIconCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InphotoIconCacheService>;
 }
 
 declare class BackNextButtonsComponent {
-    iconService: IconCacheService;
+    iconService: InphotoIconCacheService;
     readonly icons: typeof Icon;
     set showBackButton(value: boolean);
     get showBackButton(): boolean;
@@ -95,12 +121,12 @@ declare class BackNextButtonsComponent {
     private _disableNextButton;
     private _showGenerateButton;
     private _disableGenerateButton;
-    constructor(iconService: IconCacheService);
+    constructor(iconService: InphotoIconCacheService);
     static ɵfac: i0.ɵɵFactoryDeclaration<BackNextButtonsComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<BackNextButtonsComponent, "co-back-next-buttons", never, { "showBackButton": { "alias": "showBackButton"; "required": false; }; "disableBackButton": { "alias": "disableBackButton"; "required": false; }; "showNextButton": { "alias": "showNextButton"; "required": false; }; "disableNextButton": { "alias": "disableNextButton"; "required": false; }; "showGenerateButton": { "alias": "showGenerateButton"; "required": false; }; "disableGenerateButton": { "alias": "disableGenerateButton"; "required": false; }; }, { "backClicked": "backClicked"; "nextClicked": "nextClicked"; "generateClicked": "generateClicked"; }, never, never, false, never>;
 }
 
-declare class DictionaryService {
+declare class InphotoDictionaryService {
     get language(): LanguageCode;
     set language(value: LanguageCode);
     private _dictionaryPromise;
@@ -117,13 +143,13 @@ declare class DictionaryService {
      */
     get(key: string, upperCaseFirst?: boolean, ...replacementTexts: string[]): string;
     private _dictionaryLoaded;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DictionaryService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DictionaryService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoDictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InphotoDictionaryService>;
 }
 
 declare class LocalizePipe implements PipeTransform {
     private _dictionaryService;
-    constructor(_dictionaryService: DictionaryService);
+    constructor(_dictionaryService: InphotoDictionaryService);
     transform(value: string, upperCaseFirst?: boolean, replace?: string | string[]): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<LocalizePipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<LocalizePipe, "localize", false>;
@@ -195,21 +221,45 @@ declare class SceneBuildObject {
     constructor(image?: string, floorPlaneMap?: ImageRoomResponse);
 }
 
-declare class AppEventService {
-    onOpenCatalog: EventEmitter<void>;
-    onOpenEditor: EventEmitter<void>;
-    onProcessRoomReceived: EventEmitter<SceneBuildObject>;
-    onUpdateRoomReceived: EventEmitter<void>;
-    onRoomFinished: EventEmitter<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AppEventService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AppEventService>;
+declare class ArticleConfiguration {
+    sku: string;
+    instanceId: string;
+    externalSourceId: number;
+    externalSourceUserName: string;
+    externalSourcePassword: string;
+    externalSourceSchema: string;
+    externalSourceUrl: string;
+    configurationResult: ConfigurationResultObject;
+}
+
+declare class InphotoEventService {
+    onProcessRoomReceived: Subject<SceneBuildObject>;
+    openCatalog: Subject<boolean>;
+    addArticleToScene: Subject<ArticleConfiguration>;
+    onObjectSelect: Subject<ArticleConfiguration>;
+    unSelectObject: Subject<void>;
+    updateProcessingImageData: Subject<boolean>;
+    updateCanvasMaskColor: Subject<boolean>;
+    clearMarkedCanvas: Subject<void>;
+    onGeneratedImageReceived: Subject<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InphotoEventService>;
+}
+
+declare enum PromptStyle {
+    append = "append",
+    replace = "replace"
+}
+
+declare class Prompt {
+    prompt: string;
+    promptStyle: PromptStyle;
 }
 
-declare class EnhanceStyle {
+declare class EnhanceStyle extends Prompt {
     roomType: string;
     mode: string;
     decorationStyle: string;
-    customInstructions: string;
 }
 
 declare class SegmentationPoint {
@@ -220,7 +270,6 @@ declare class SegmentationPoint {
 
 declare class LoaderService {
     showLoader: WritableSignal<boolean>;
-    showProgress: WritableSignal<boolean>;
     loadingText: WritableSignal<string>;
     showEstimateLoadingTime: WritableSignal<boolean>;
     estimatedLoadingTime: WritableSignal<string>;
@@ -294,7 +343,7 @@ declare class InPhotoConnectorAdapterService implements OnDestroy {
     private _mainApi;
     private _boFactory;
     private _publicationCodeForUserRole;
-    constructor(_catalogExternalSourcesService: CatalogExternalSourcesService, _appEventService: AppEventService, _errorService: ErrorService, _loaderService: LoaderService);
+    constructor(_catalogExternalSourcesService: CatalogExternalSourcesService, _appEventService: InphotoEventService, _errorService: ErrorService, _loaderService: LoaderService);
     ngOnDestroy(): void;
     initConnector(options: Options, externalSource?: string, forceReload?: boolean, externalSourceId?: number): Promise<boolean>;
     getExternalSourceFromId(id: number): ExternalSource;
@@ -309,8 +358,8 @@ declare class InPhotoConnectorAdapterService implements OnDestroy {
      **/
     uploadRoomImage(image: string, skipInpainting: boolean): Promise<SceneBuildObject>;
     processDecorateImage(canvasImage: string, style: EnhanceStyle): Promise<DecorateResponse>;
-    processProductPlacement(canvasImage: string, productImage: string): Promise<CreatedImageResponse>;
-    processMultiProductPlacement(canvasImage: string, productImages: string[]): Promise<CreatedImageResponse>;
+    processEmptyRoom(canvasImage: string): Promise<CreatedImageResponse>;
+    processMultiProductPlacement(canvasImage: string, productImages: string[], colorProducts: any[], customPrompt: string, customPromptMode: PromptStyle): Promise<CreatedImageResponse>;
     uploadSegmentationImage(image: string): Promise<JobIdResponse>;
     handleSegmentationClick(jobId: string, point: SegmentationPoint): Promise<SegmentationResponse>;
     segmentInpaint(jobId: string, image: string): Promise<CreatedImageResponse>;
@@ -325,7 +374,7 @@ declare class InPhotoConnectorAdapterService implements OnDestroy {
     static ɵprov: i0.ɵɵInjectableDeclaration<InPhotoConnectorAdapterService>;
 }
 
-declare class SettingsService {
+declare class InphotoSettingsService {
     private _dictionary;
     private _connectorAdapterService;
     readonly languageCodeToDictionary: Map<string, string>;
@@ -334,15 +383,14 @@ declare class SettingsService {
     set settings(value: Settings);
     get settings(): Settings;
     settingsInitialized: BehaviorSubject<boolean>;
-    get dictionaryKey(): string;
     settingsLoaded: BehaviorSubject<boolean>;
     private _languageCode;
     private _settings;
-    constructor(_dictionary: DictionaryService, _connectorAdapterService: InPhotoConnectorAdapterService);
+    constructor(_dictionary: InphotoDictionaryService, _connectorAdapterService: InPhotoConnectorAdapterService);
     createSettingsFromObject(obj: any): void;
     initialize(options?: Settings): Promise<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InphotoSettingsService>;
 }
 
 declare class InPhotoConnectorService {
@@ -355,7 +403,7 @@ declare class InPhotoConnectorService {
     private _initialized;
     private _connectorOptions;
     private _shouldShowLoader;
-    constructor(_connectorAdapterService: InPhotoConnectorAdapterService, _settingsService: SettingsService);
+    constructor(_connectorAdapterService: InPhotoConnectorAdapterService, _settingsService: InphotoSettingsService);
     initConnection(forceReload?: boolean, standAlone?: boolean): Promise<void>;
     initConnector(options: any, externalSource?: string, forceReload?: boolean, externalSourceId?: number): Promise<boolean>;
     onShowLoaderChange(showLoader: boolean): void;
@@ -369,8 +417,8 @@ declare class InPhotoConnectorService {
      * */
     uploadRoomImage(image: string, skipInpainting?: boolean): Promise<SceneBuildObject>;
     processDecorateImage(canvasImage: string, style: EnhanceStyle): Promise<DecorateResponse>;
-    processProductPlacement(canvasImage: string, productImage: string): Promise<CreatedImageResponse>;
-    processMultiProductPlacement(canvasImage: string, productImages: string[]): Promise<CreatedImageResponse>;
+    processEmptyRoom(canvasImage: string): Promise<CreatedImageResponse>;
+    processMultiProductPlacement(canvasImage: string, productImages: string[], colorProducts: any[], customPrompt: string, customPromptMode: PromptStyle): Promise<CreatedImageResponse>;
     uploadSegmentationImage(image: string): Promise<JobIdResponse>;
     handleSegmentationClick(jobId: string, point: SegmentationPoint): Promise<SegmentationResponse>;
     segmentInpaint(jobId: string, image: string): Promise<CreatedImageResponse>;
@@ -381,18 +429,7 @@ declare class InPhotoConnectorService {
     static ɵprov: i0.ɵɵInjectableDeclaration<InPhotoConnectorService>;
 }
 
-declare class ArticleConfiguration {
-    sku: string;
-    instanceId: string;
-    externalSourceId: number;
-    externalSourceUserName: string;
-    externalSourcePassword: string;
-    externalSourceSchema: string;
-    externalSourceUrl: string;
-    configurationResult: ConfigurationResultObject;
-}
-
-declare class ObjectsService implements OnDestroy {
+declare class InphotoItemService implements OnDestroy {
     set selectedObject(value: ArticleConfiguration | undefined);
     get selectedObject(): ArticleConfiguration | undefined;
     set floorPlane(plane: Mesh);
@@ -405,16 +442,15 @@ declare class ObjectsService implements OnDestroy {
     private _floorItems;
     private _floorPlane;
     private _floorBounds;
-    constructor();
     ngOnDestroy(): void;
     addFloorItem(item: ArticleConfiguration): void;
     removeFloorItem(item: ArticleConfiguration): void;
     getFloorCenter(): Vector3;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectsService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ObjectsService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoItemService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InphotoItemService>;
 }
 
-declare class SceneService implements OnDestroy {
+declare class InphotoSceneService implements OnDestroy {
     private _objectsService;
     set needsRender(render: boolean);
     get needsRender(): boolean;
@@ -427,8 +463,9 @@ declare class SceneService implements OnDestroy {
     imageWidth: number;
     imageHeight: number;
     private _sceneHasImage;
+    private _placementMarker;
     private _needsRender;
-    constructor(_objectsService: ObjectsService);
+    constructor(_objectsService: InphotoItemService);
     ngOnDestroy(): void;
     init(element: ElementRef<HTMLDivElement>): void;
     getSceneAsImage(): string;
@@ -437,38 +474,102 @@ declare class SceneService implements OnDestroy {
     getObjectByUUID(uuid: string): Object3D | undefined;
     removeObject(object: Object3D): void;
     addFloorToScene(floorMesh: Mesh): void;
+    setPlacementMarker(marker: Object3D | null): void;
     private _prepLights;
     private _animate;
     private _render;
+    private _animateMarker;
     private _onResize;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SceneService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SceneService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoSceneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InphotoSceneService>;
+}
+
+declare class InphotoFontService {
+    hudFont: Font;
+    monospaceFont: Font;
+    constructor();
+    private _loadFont;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoFontService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InphotoFontService>;
 }
 
-declare class InteractionService implements OnDestroy {
-    objectsService: ObjectsService;
+declare class InphotoHudService implements OnDestroy {
+    private _appEventService;
     private _sceneService;
+    private _fontService;
+    private _selectedItem;
+    private _rotationHelper;
+    private _subs;
+    private _mouseover;
+    private _rotating;
+    constructor(_appEventService: InphotoEventService, _sceneService: InphotoSceneService, _fontService: InphotoFontService);
+    ngOnDestroy(): void;
+    update(force?: boolean): void;
+    getRotationSnapperArea(): Object3D | null;
+    getSelectedCenter(): Vector3 | null;
+    setMouseOver(on: boolean): void;
+    setRotating(on: boolean): void;
+    private _applySceneUpdates;
+    private _unselectItem;
+    private _selectItem;
+    private _resetSelectedItem;
+    private _createRotationHelper;
+    private _setColor;
+    private _addToScene;
+    private _removeRotationHelper;
+    private _removeFromScene;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoHudService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InphotoHudService>;
+}
+
+declare enum InteractionMode {
+    Move = "move",
+    Rotate = "rotate"
+}
+declare class InphotoInteractionService implements OnDestroy {
+    objectsService: InphotoItemService;
+    private _sceneService;
+    private _appEventService;
+    private _hudService;
     mouse: Vector2;
     raycaster: Raycaster;
     lastMousePosition: Vector2;
     isDragging: boolean;
     dragOffset: Vector3;
+    mode: InteractionMode;
+    rotationSensitivity: number;
+    isPlacing: boolean;
+    placementLocked: boolean;
     private _camera;
     private _scene;
     private _renderer;
-    constructor(objectsService: ObjectsService, _sceneService: SceneService);
+    private _placementMarker;
+    private _placementPosition;
+    private _placementNormal;
+    constructor(objectsService: InphotoItemService, _sceneService: InphotoSceneService, _appEventService: InphotoEventService, _hudService: InphotoHudService);
     ngOnDestroy(): void;
     init(scene: Scene, camera: PerspectiveCamera, renderer: WebGLRenderer): void;
+    setMode(mode: InteractionMode): void;
     onMouseUp(event: MouseEvent): void;
     onMouseDown(event: MouseEvent): void;
     onMouseMove(event: MouseEvent): void;
+    startPlacement(): void;
+    endPlacement(): {
+        position: Vector3;
+        normal: Vector3;
+    };
+    private _clearPlacementMarker;
+    private _floorHitFromEvent;
+    private _moveMarkerTo;
+    private _rotateByDrag;
+    private _applyYRotation;
     updateMousePosition(event: MouseEvent): void;
     handleFurnitureHit(furniture: ArticleConfiguration): void;
-    handlePlacement(object: Object3D): Object3D;
+    handlePlacement(object: Object3D, targetPosition?: Vector3, targetNormal?: Vector3): Object3D;
     makeItStick(yRotation: number): void;
     private _bindObjectToFloorBounds;
-    static ɵfac: i0.ɵɵFactoryDeclaration<InteractionService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<InteractionService>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoInteractionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InphotoInteractionService>;
 }
 
 declare class ModelConfigurationService implements OnDestroy {
@@ -480,12 +581,6 @@ declare class ModelConfigurationService implements OnDestroy {
     private _interactionService;
     private _loaderService;
     private _configuratorEventService;
-    /**
-     *
-     * Service that get the article/ external source data, starts the configurator, and waits for the build the finish.
-     * After that it will add it to the scene
-     *
-     * */
     set loadConfigurator(value: boolean);
     get loadConfigurator(): boolean;
     set currentArticleConfiguration(value: ArticleConfiguration);
@@ -497,24 +592,17 @@ declare class ModelConfigurationService implements OnDestroy {
     private _loadConfigurator;
     private _currentArticleConfiguration;
     private _subs;
-    constructor(_connectorService: InPhotoConnectorService, _sceneService: SceneService, _settingsService: SettingsService, _configuringService: ConfiguringService, _objectsService: ObjectsService, _interactionService: InteractionService, _loaderService: LoaderService, _configuratorEventService: ConfiguratorEventService);
+    constructor(_connectorService: InPhotoConnectorService, _sceneService: InphotoSceneService, _settingsService: InphotoSettingsService, _configuringService: ConfiguringService, _objectsService: InphotoItemService, _interactionService: InphotoInteractionService, _loaderService: LoaderService, _configuratorEventService: ConfiguratorEventService);
     ngOnDestroy(): void;
-    startConfigurator(articleConfiguration: ArticleConfiguration): Promise<void>;
-    handleFirstBuild(buildResult: ConfigurationResultObject): void;
-    handleBuildResult(buildResult: ConfigurationResultObject): void;
-    continueConfiguration(articleConfiguration: ArticleConfiguration): Promise<void>;
     rotateObject(rotationDegrees: number): void;
-    scaleObject(object: ArticleConfiguration, scaleX: number, scaleY: number, scaleZ: number): void;
-    removeModelFromProject(item: ArticleConfiguration): void;
-    private _prepareSettings;
     static ɵfac: i0.ɵɵFactoryDeclaration<ModelConfigurationService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ModelConfigurationService>;
 }
 
-declare class CatalogComponent implements OnInit, OnDestroy {
-    iconService: IconCacheService;
-    settingService: SettingsService;
-    appEventService: AppEventService;
+declare class InphotoCatalogComponent implements OnInit, OnDestroy {
+    iconService: InphotoIconCacheService;
+    settingService: InphotoSettingsService;
+    appEventService: InphotoEventService;
     connectorService: InPhotoConnectorService;
     modelConfigurationService: ModelConfigurationService;
     private _catalogService;
@@ -536,7 +624,7 @@ declare class CatalogComponent implements OnInit, OnDestroy {
     catalogInfo: ExternalCatalogStartupInfo;
     externalCatalogName: string;
     private _source;
-    constructor(iconService: IconCacheService, settingService: SettingsService, appEventService: AppEventService, connectorService: InPhotoConnectorService, modelConfigurationService: ModelConfigurationService, _catalogService: CatalogService, _changeDetection: ChangeDetectorRef);
+    constructor(iconService: InphotoIconCacheService, settingService: InphotoSettingsService, appEventService: InphotoEventService, connectorService: InPhotoConnectorService, modelConfigurationService: ModelConfigurationService, _catalogService: CatalogService, _changeDetection: ChangeDetectorRef);
     ngOnInit(): Promise<void>;
     ngOnDestroy(): void;
     handleToggleShowOwnCollection(): void;
@@ -547,93 +635,127 @@ declare class CatalogComponent implements OnInit, OnDestroy {
     handleCloseDialog(): void;
     handleExternalSourceClick(source?: ExternalSourceViewmodel): Promise<void>;
     private _buildExternalCatalogRequest;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogComponent, "co-catalog", never, {}, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoCatalogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InphotoCatalogComponent, "co-inphoto-catalog", never, {}, {}, never, never, false, never>;
 }
 
-declare class CatalogModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogModule, [typeof CatalogComponent], [typeof i2.ButtonModule, typeof i3.CatalogSearchModule, typeof PipeModule, typeof i2.IconModule, typeof i3.CatalogExternalSourcesModule, typeof i3.CatalogExternalSourceModule, typeof i2.AppendPipeModule], [typeof CatalogComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogModule>;
+declare class InphotoCatalogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoCatalogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InphotoCatalogModule, [typeof InphotoCatalogComponent], [typeof i2.ButtonModule, typeof i3.CatalogSearchModule, typeof PipeModule, typeof i2.IconModule, typeof i3.CatalogExternalSourcesModule, typeof i3.CatalogExternalSourceModule, typeof i2.AppendPipeModule], [typeof InphotoCatalogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InphotoCatalogModule>;
+}
+
+declare enum ColorPalette {
+    RED = "FF0000",
+    GREEN = "00FF00",
+    BLUE = "0000FF",
+    YELLOW = "FFD700",
+    PURPLE = "800080",
+    TEAL = "008080"
+}
+
+interface MaskStroke {
+    brushSize: number;
+    points: SegmentationPoint[];
+    erase?: boolean;
+}
+
+declare class ImageData {
+    image: string;
+    maskColor: ColorPalette;
+    maskData: MaskStroke[];
 }
 
-declare class DataService {
+declare class InphotoDataService {
+    private _appEventService;
     /**
      *
      * Since the frontend is responsible for the data, we need to keep a list of images that where processed by AI
      * But also what image is in the drawing canvas and are uploaded to be used with AI to create images.
-     * We might also need to save the threejs scene here aswel
-     *
-     * We might also need to create some more data object to save states.
      *
      * */
-    get startingPointImage(): string;
-    set startingPointImage(value: string);
-    get canvasBackground(): string;
-    set canvasBackground(value: string);
-    get generatedImages(): string[];
-    get threeJSBackground(): string;
-    set threeJSBackground(value: string);
-    get floorGeometry(): ImageRoomResponse;
-    set floorGeometry(value: ImageRoomResponse);
     set canvasHasMask(value: boolean);
     get canvasHasMask(): boolean;
-    get segmentationJobId(): string;
-    set segmentationJobId(value: string);
-    private _startingPointImage;
-    private _threeJSBackground;
-    private _canvasBackground;
+    get generatedImages(): string[];
+    set progressingData(data: ImageData[]);
+    get progressingData(): ImageData[];
+    set activeCanvasColor(value: ColorPalette);
+    get activeCanvasColor(): ColorPalette;
     private _canvasHasMask;
     private _generatedImages;
-    private _floorGeometry;
-    private _segmentationJobId;
+    private _processingData;
+    private _activeCanvasColor;
+    constructor(_appEventService: InphotoEventService);
     addGeneratedImage(image: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DataService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DataService>;
+    addImageData(data: ImageData): void;
+    removeProcessingImage(data: ImageData): void;
+    uploadProcessingObject(updateData: ImageData, currentData: ImageData): void;
+    getOrCreateImageDataForColor(color: ColorPalette): ImageData;
+    getStrokes(color: ColorPalette): MaskStroke[];
+    addStroke(color: ColorPalette, stroke: MaskStroke): void;
+    undoLastStroke(color: ColorPalette): MaskStroke | undefined;
+    clearColor(color: ColorPalette): void;
+    /** Clear the color's mask. */
+    removeMask(color: ColorPalette): void;
+    hasAnyMask(): boolean;
+    clearAllMasks(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InphotoDataService>;
 }
 
 declare class EditCanvasComponent implements AfterViewInit {
-    iconService: IconCacheService;
-    dataService: DataService;
-    private _connectorService;
+    iconService: InphotoIconCacheService;
+    dataService: InphotoDataService;
+    private _appEventService;
     readonly icons: typeof Icon;
+    showClass(): boolean;
     canvas: ElementRef<HTMLCanvasElement>;
     set image(value: string);
     get image(): string;
-    set showToolbar(value: boolean);
-    get showToolbar(): boolean;
-    set enableObjectPicker(value: boolean);
-    get enableObjectPicker(): boolean;
     set segmentationInPainting(value: SegmentationResponse);
+    set inpaintMode(value: boolean);
+    set eraserMode(value: boolean);
     onSegmentationPointClick: EventEmitter<SegmentationPoint>;
-    showClass(): boolean;
+    imageState: EventEmitter<string>;
+    set maskColor(color: ColorPalette);
+    get maskColor(): ColorPalette;
     ctx: CanvasRenderingContext2D;
     drawing: boolean;
-    brushColor: string;
     brushSize: number;
-    showBrushOption: boolean;
-    setCanvasFullScreen: boolean;
+    maskOpacity: number;
     private _backgroundImage;
+    private _maskLayers;
+    private _currentStroke;
+    private _segCanvas;
+    private _segCtx;
     private _image;
-    private _showToolbar;
-    private _enableObjectPicker;
-    constructor(iconService: IconCacheService, dataService: DataService, _connectorService: InPhotoConnectorService);
+    private _inpaintMode;
+    private _eraserMode;
+    private _maskColor;
+    private _subs;
+    private _canvasLoaded;
+    constructor(iconService: InphotoIconCacheService, dataService: InphotoDataService, _appEventService: InphotoEventService);
     ngAfterViewInit(): void;
+    changeCanvasCursor(icon: Icon): void;
     startDrawing(event: MouseEvent): void;
     draw(event: MouseEvent): void;
     stopDrawing(): void;
-    changeColor(): void;
-    changeSize(): void;
+    undoLastStroke(color?: ColorPalette): void;
+    clearColor(color: ColorPalette): void;
+    private _syncLayersFromData;
     clearCanvas(): void;
     loadBackground(): void;
-    showBrushSize(): void;
-    openFullScreenCanvas(): void;
-    closeFullScreenCanvas(): void;
+    private _getLayer;
+    private _resizeAndReplayLayers;
+    private _render;
+    private _replayColor;
     private _getCanvasCoords;
     private _drawSegmentation;
+    private _ensureSegCanvas;
     private _saveCanvas;
+    private _colorToString;
     static ɵfac: i0.ɵɵFactoryDeclaration<EditCanvasComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<EditCanvasComponent, "co-edit-canvas", never, { "image": { "alias": "image"; "required": false; }; "showToolbar": { "alias": "showToolbar"; "required": false; }; "enableObjectPicker": { "alias": "enableObjectPicker"; "required": false; }; "segmentationInPainting": { "alias": "segmentationInPainting"; "required": false; }; }, { "onSegmentationPointClick": "onSegmentationPointClick"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EditCanvasComponent, "co-edit-canvas", never, { "image": { "alias": "image"; "required": false; }; "segmentationInPainting": { "alias": "segmentationInPainting"; "required": false; }; "inpaintMode": { "alias": "inpaintMode"; "required": false; }; "eraserMode": { "alias": "eraserMode"; "required": false; }; }, { "onSegmentationPointClick": "onSegmentationPointClick"; "imageState": "imageState"; }, never, never, false, never>;
 }
 
 declare class EditCanvasModule {
@@ -644,10 +766,10 @@ declare class EditCanvasModule {
 
 declare class ErrorDialogComponent {
     errorService: ErrorService;
-    iconService: IconCacheService;
+    iconService: InphotoIconCacheService;
     readonly icons: typeof Icon;
     showClass(): boolean;
-    constructor(errorService: ErrorService, iconService: IconCacheService);
+    constructor(errorService: ErrorService, iconService: InphotoIconCacheService);
     clearAndClose(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ErrorDialogComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ErrorDialogComponent, "co-error-dialog", never, {}, {}, never, never, false, never>;
@@ -659,54 +781,77 @@ declare class ErrorDialogModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<ErrorDialogModule>;
 }
 
+interface MaskImageColorInterface {
+    image: string;
+    color: ColorPalette;
+}
+
+declare class PromptWithImages extends Prompt {
+    imageData: ImageData[];
+}
+
 declare class ImageEnhancer {
-    iconService: IconCacheService;
-    dataService: DataService;
+    iconService: InphotoIconCacheService;
+    dataService: InphotoDataService;
+    private _appEventService;
     readonly icons: typeof Icon;
+    showClass(): boolean;
+    dragBoundary: string;
     selectedStyle: EventEmitter<EnhanceStyle>;
-    selectedProductImage: EventEmitter<string[]>;
-    selectedProductImages: EventEmitter<string[]>;
+    createPromptWithImages: EventEmitter<PromptWithImages>;
     backButtonClicked: EventEmitter<void>;
-    showClass(): boolean;
+    changeMarkerColor: EventEmitter<MaskImageColorInterface>;
     prompt: string;
     activeTab: number;
     showMaskInfoDialog: boolean;
-    constructor(iconService: IconCacheService, dataService: DataService);
+    collapsed: boolean;
+    constructor(iconService: InphotoIconCacheService, dataService: InphotoDataService, _appEventService: InphotoEventService);
     setTab(index: number): void;
-    handleProductImagePrompt(event: string[]): void;
-    handleProductImagesPrompt(event: string[]): void;
+    handlePromptWithImages(event: PromptWithImages): void;
     handleStylePrompt(event: EnhanceStyle): void;
     handleBackClicked(): void;
+    handleChangeMarkerColor(data: MaskImageColorInterface): void;
+    closeDialog(): void;
+    openDialog(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ImageEnhancer, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ImageEnhancer, "co-image-enhancer", never, {}, { "selectedStyle": "selectedStyle"; "selectedProductImage": "selectedProductImage"; "selectedProductImages": "selectedProductImages"; "backButtonClicked": "backButtonClicked"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageEnhancer, "co-image-enhancer", never, { "dragBoundary": { "alias": "dragBoundary"; "required": false; }; }, { "selectedStyle": "selectedStyle"; "createPromptWithImages": "createPromptWithImages"; "backButtonClicked": "backButtonClicked"; "changeMarkerColor": "changeMarkerColor"; }, never, never, false, never>;
+}
+
+declare enum FileTypes {
+    JPG = "JPG",
+    JPEG = "JPEG",
+    PNG = "PNG"
 }
 
 declare class ImageUpload implements OnDestroy {
-    iconService: IconCacheService;
+    iconService: InphotoIconCacheService;
     readonly icons: typeof Icon;
+    showClass(): boolean;
     multiUpload: boolean;
-    showPreview: boolean;
+    set supportedFiles(value: FileTypes[]);
+    get supportedFiles(): FileTypes[];
+    set compactMode(value: boolean);
+    get compactMode(): boolean;
     uploadedFiles: EventEmitter<File[]>;
-    showClass(): boolean;
-    get fileEntries(): [number, [File, string]][];
     selectedFiles: File[];
     files: Map<number, [File, string]>;
     fileId: number;
     isDragging: boolean;
-    compactMode: boolean;
-    constructor(iconService: IconCacheService);
+    accepted: string;
+    private _compactMode;
+    private _supportedFiles;
+    constructor(iconService: InphotoIconCacheService);
     ngOnDestroy(): void;
     onFileSelected(event: any): void;
     handleFile(fileList: FileList): void;
     onDrop(event: DragEvent): void;
     onDragOver(event: DragEvent): void;
     onDragLeave(): void;
-    removeUploadedImage(id: number): void;
-    deleteFile(id: number): boolean;
-    getFile(id: number): [File, string];
     private _addFile;
+    private _handleSetSupportedFiles;
+    private _setAcceptAttr;
     static ɵfac: i0.ɵɵFactoryDeclaration<ImageUpload, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ImageUpload, "co-image-upload", never, { "multiUpload": { "alias": "multiUpload"; "required": false; }; "showPreview": { "alias": "showPreview"; "required": false; }; }, { "uploadedFiles": "uploadedFiles"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageUpload, "co-image-upload", never, { "multiUpload": { "alias": "multiUpload"; "required": false; }; "supportedFiles": { "alias": "supportedFiles"; "required": false; }; "compactMode": { "alias": "compactMode"; "required": false; }; }, { "uploadedFiles": "uploadedFiles"; }, never, never, false, never>;
 }
 
 declare class ImageUploadModule {
@@ -723,10 +868,15 @@ declare class DecorationStyle {
 
 declare class ImageEnhancerStyleComponent implements OnInit {
     connectorService: InPhotoConnectorService;
+    iconCacheService: InphotoIconCacheService;
+    private _changeDetection;
+    readonly icons: typeof Icon;
+    get showClass(): boolean;
     prompt: EventEmitter<EnhanceStyle>;
     backButtonClicked: EventEmitter<void>;
-    get showClass(): boolean;
-    useCustomPrompt: boolean;
+    customPrompt: string;
+    customPromptMode: PromptStyle;
+    showInputError: boolean;
     loaded: boolean;
     styleEnhancePrompt: EnhanceStyle;
     selectedRoomStyle: DecorationStyle;
@@ -735,7 +885,7 @@ declare class ImageEnhancerStyleComponent implements OnInit {
     modeCollection: DecorationStyle[];
     selectedDecorationStyle: DecorationStyle;
     decorationStyleCollection: DecorationStyle[];
-    constructor(connectorService: InPhotoConnectorService);
+    constructor(connectorService: InPhotoConnectorService, iconCacheService: InphotoIconCacheService, _changeDetection: ChangeDetectorRef);
     ngOnInit(): Promise<void>;
     handleChangeRoomType(event: DecorationStyle): void;
     handleChangeMode(event: DecorationStyle): void;
@@ -746,80 +896,182 @@ declare class ImageEnhancerStyleComponent implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<ImageEnhancerStyleComponent, "co-image-enhancer-style", never, {}, { "prompt": "prompt"; "backButtonClicked": "backButtonClicked"; }, never, never, false, never>;
 }
 
+declare class AiPromptComponent {
+    private _changeDetection;
+    get showClass(): boolean;
+    customPrompt: string;
+    set promptMode(value: PromptStyle);
+    get promptMode(): PromptStyle;
+    set showEmptyInputError(value: boolean);
+    get showEmptyInputError(): boolean;
+    promptModeChange: EventEmitter<PromptStyle>;
+    customPromptChange: EventEmitter<string>;
+    toggleModel: boolean;
+    private _promptMode;
+    private _emptyInputError;
+    constructor(_changeDetection: ChangeDetectorRef);
+    handleUpdateModel(): void;
+    handlePromptChange(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiPromptComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AiPromptComponent, "co-ai-prompt", never, { "customPrompt": { "alias": "customPrompt"; "required": false; }; "promptMode": { "alias": "promptMode"; "required": false; }; "showEmptyInputError": { "alias": "showEmptyInputError"; "required": false; }; }, { "promptModeChange": "promptModeChange"; "customPromptChange": "customPromptChange"; }, never, never, false, never>;
+}
+
+declare class AiPromptModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<AiPromptModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<AiPromptModule, [typeof AiPromptComponent], [typeof i2.InputTextareaModule, typeof PipeModule, typeof i2$1.FormsModule], [typeof AiPromptComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<AiPromptModule>;
+}
+
 declare class ImageEnhancerStyleModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ImageEnhancerStyleModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageEnhancerStyleModule, [typeof ImageEnhancerStyleComponent], [typeof i2.ListOfValuesModule, typeof PipeModule, typeof i2.InputCheckboxModule, typeof i2.InputTextareaModule, typeof BackNextButtonsModule], [typeof ImageEnhancerStyleComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageEnhancerStyleModule, [typeof ImageEnhancerStyleComponent], [typeof i2.ListOfValuesModule, typeof PipeModule, typeof i2.InputCheckboxModule, typeof i2.InputTextareaModule, typeof BackNextButtonsModule, typeof i2.IconModule, typeof AiPromptModule], [typeof ImageEnhancerStyleComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ImageEnhancerStyleModule>;
 }
 
 declare class ImageEnhancerUploadComponent {
+    dataService: InphotoDataService;
+    iconCacheService: InphotoIconCacheService;
+    readonly FileTypes: typeof FileTypes;
+    readonly icons: typeof Icon;
     multiUpload: boolean;
-    prompt: EventEmitter<string[]>;
+    prompt: EventEmitter<PromptWithImages>;
     backButtonClicked: EventEmitter<void>;
+    changeMarkerColor: EventEmitter<MaskImageColorInterface>;
     showClass(): boolean;
+    compactMode: boolean;
     disableGenerateButton: boolean;
-    useCustomPrompt: boolean;
     uploadedImages: string[];
+    customPrompt: string;
+    customPromptMode: PromptStyle;
+    showInputError: boolean;
+    constructor(dataService: InphotoDataService, iconCacheService: InphotoIconCacheService);
     handleImageUpload(event: File[]): void;
     handleGenerateClicked(): void;
     handleBackClicked(): void;
+    handleDeleteImage(image: ImageData): void;
+    handleDeleteMask(data: ImageData): void;
+    handleChangeMarkerColor(color: ColorPalette, data: ImageData): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ImageEnhancerUploadComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ImageEnhancerUploadComponent, "co-image-enhancer-upload", never, { "multiUpload": { "alias": "multiUpload"; "required": false; }; }, { "prompt": "prompt"; "backButtonClicked": "backButtonClicked"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageEnhancerUploadComponent, "co-image-enhancer-upload", never, { "multiUpload": { "alias": "multiUpload"; "required": false; }; }, { "prompt": "prompt"; "backButtonClicked": "backButtonClicked"; "changeMarkerColor": "changeMarkerColor"; }, never, never, false, never>;
+}
+
+declare class ImageTileComponent {
+    iconCacheService: InphotoIconCacheService;
+    private _dataService;
+    readonly icons: typeof Icon;
+    readonly color: typeof ColorPalette;
+    showClass(): boolean;
+    index: number;
+    set activeItem(value: boolean);
+    get activeItem(): boolean;
+    set data(value: ImageData);
+    get data(): ImageData;
+    changeMarkerColor: EventEmitter<ColorPalette>;
+    deleteImage: EventEmitter<ImageData>;
+    deleteMask: EventEmitter<ImageData>;
+    hideColors: boolean;
+    hasSelectedColor: boolean;
+    private _activeItem;
+    private _selectedColor;
+    private _data;
+    constructor(iconCacheService: InphotoIconCacheService, _dataService: InphotoDataService);
+    setMarkerColor(color: ColorPalette): void;
+    handleContinueCurrentMask(): void;
+    showColorPalette(): void;
+    removeImage(): void;
+    removeMask(): void;
+    private _handleSetData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageTileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageTileComponent, "co-image-title", never, { "index": { "alias": "index"; "required": false; }; "activeItem": { "alias": "activeItem"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, { "changeMarkerColor": "changeMarkerColor"; "deleteImage": "deleteImage"; "deleteMask": "deleteMask"; }, never, never, false, never>;
+}
+
+declare class ColorPaletteOptionComponent {
+    iconCacheService: InphotoIconCacheService;
+    readonly icons: typeof Icon;
+    readonly color: typeof ColorPalette;
+    showClass(): boolean;
+    colorOption: ColorPalette;
+    set selected(value: boolean);
+    get selected(): boolean;
+    changeMarkerColor: EventEmitter<ColorPalette>;
+    private _selected;
+    constructor(iconCacheService: InphotoIconCacheService);
+    setMarkerColor(color: ColorPalette): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorPaletteOptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColorPaletteOptionComponent, "co-color-palette-option", never, { "colorOption": { "alias": "colorOption"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "changeMarkerColor": "changeMarkerColor"; }, never, never, false, never>;
+}
+
+declare class ImageTileModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageTileModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageTileModule, [typeof ImageTileComponent, typeof ColorPaletteOptionComponent], [typeof i2.IconModule, typeof i2.ButtonModule, typeof PipeModule], [typeof ImageTileComponent, typeof ColorPaletteOptionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ImageTileModule>;
 }
 
 declare class ImageEnhancerUploadModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ImageEnhancerUploadModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageEnhancerUploadModule, [typeof ImageEnhancerUploadComponent], [typeof ImageUploadModule, typeof BackNextButtonsModule, typeof i2.InputCheckboxModule, typeof i2.InputTextareaModule, typeof PipeModule], [typeof ImageEnhancerUploadComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageEnhancerUploadModule, [typeof ImageEnhancerUploadComponent], [typeof ImageUploadModule, typeof BackNextButtonsModule, typeof i2.InputCheckboxModule, typeof i2.InputTextareaModule, typeof PipeModule, typeof ImageTileModule, typeof i2.IconModule, typeof AiPromptModule], [typeof ImageEnhancerUploadComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ImageEnhancerUploadModule>;
 }
 
 declare class ImageEnhancerModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ImageEnhancerModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageEnhancerModule, [typeof ImageEnhancer], [typeof i2.ListOfValuesModule, typeof PipeModule, typeof i2.IconModule, typeof ImageUploadModule, typeof i2.ButtonModule, typeof i2.InputTextareaModule, typeof ImageEnhancerStyleModule, typeof ImageEnhancerUploadModule], [typeof ImageEnhancer]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageEnhancerModule, [typeof ImageEnhancer], [typeof i2.ListOfValuesModule, typeof PipeModule, typeof i2.IconModule, typeof ImageUploadModule, typeof i2.ButtonModule, typeof i2.InputTextareaModule, typeof ImageEnhancerStyleModule, typeof ImageEnhancerUploadModule, typeof i7.CdkDragHandle, typeof i7.CdkDrag], [typeof ImageEnhancer]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ImageEnhancerModule>;
 }
 
-declare class ImageHistoryComponent {
-    dataService: DataService;
-    iconService: IconCacheService;
+declare class ImageHistoryComponent implements AfterViewInit, OnDestroy {
+    dataService: InphotoDataService;
+    iconService: InphotoIconCacheService;
+    private _eventService;
     readonly icons: typeof Icon;
-    setImageAsBackground: EventEmitter<string>;
+    private tilesRow?;
     showClass(): boolean;
+    onResize(): void;
+    onEscape(): void;
+    onArrowLeft(event: KeyboardEvent): void;
+    onArrowRight(event: KeyboardEvent): void;
+    setImageAsBackground: EventEmitter<string>;
+    displayedImages: string[];
+    selectedImage: string;
     showFullImage: boolean;
     fullImage: string;
-    constructor(dataService: DataService, iconService: IconCacheService);
+    canScrollLeft: boolean;
+    canScrollRight: boolean;
+    private _subs;
+    constructor(dataService: InphotoDataService, iconService: InphotoIconCacheService, _eventService: InphotoEventService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    setDataCollection(): void;
+    handleSetImageAsBackground(event: string): void;
     handleShowFullImage(event: string): void;
     handleCloseFullImage(): void;
-    handleSetImageAsBackground(event: string): void;
     handleRemoveImageFromHistory(event: string): void;
     handleDownloadImage(event: string): void;
+    handleDownloadFullImage(): void;
+    handleDeleteFullImage(): void;
+    scroll(direction: number): void;
+    onWheel(event: WheelEvent): void;
+    updateScrollState(): void;
+    showNextPrevImage(): void;
+    showNextLargeImage(): void;
+    private _getCurrentIndex;
     static ɵfac: i0.ɵɵFactoryDeclaration<ImageHistoryComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<ImageHistoryComponent, "co-image-history", never, {}, { "setImageAsBackground": "setImageAsBackground"; }, never, never, false, never>;
 }
 
 declare class ImageHistoryTileComponent {
-    iconService: IconCacheService;
-    private _dataService;
+    iconService: InphotoIconCacheService;
     readonly icons: typeof Icon;
     image: string;
+    selected: boolean;
     showFullImage: EventEmitter<string>;
     setImageAsBackground: EventEmitter<string>;
     removeImageFromHistory: EventEmitter<string>;
     downloadImage: EventEmitter<string>;
     showClass(): boolean;
-    /**
-     *
-     * Functionality
-     * - Show thumbnail of image
-     * - Show image in full size when clicked
-     * - Button to remove image from history
-     * - Button to use the image as background in the canvas
-     * - Button to use the image as background in the 3D scene?
-     *
-     * */
-    constructor(iconService: IconCacheService, _dataService: DataService);
+    constructor(iconService: InphotoIconCacheService);
     static ɵfac: i0.ɵɵFactoryDeclaration<ImageHistoryTileComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ImageHistoryTileComponent, "co-image-history-tile", never, { "image": { "alias": "image"; "required": false; }; }, { "showFullImage": "showFullImage"; "setImageAsBackground": "setImageAsBackground"; "removeImageFromHistory": "removeImageFromHistory"; "downloadImage": "downloadImage"; }, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageHistoryTileComponent, "co-image-history-tile", never, { "image": { "alias": "image"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "showFullImage": "showFullImage"; "setImageAsBackground": "setImageAsBackground"; "removeImageFromHistory": "removeImageFromHistory"; "downloadImage": "downloadImage"; }, never, never, false, never>;
 }
 
 declare class ImageHistoryTileModule {
@@ -830,238 +1082,323 @@ declare class ImageHistoryTileModule {
 
 declare class ImageHistoryModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<ImageHistoryModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageHistoryModule, [typeof ImageHistoryComponent], [typeof ImageHistoryTileModule, typeof PipeModule, typeof i2.ButtonModule], [typeof ImageHistoryComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageHistoryModule, [typeof ImageHistoryComponent], [typeof ImageHistoryTileModule, typeof PipeModule, typeof i2.ButtonModule, typeof i2.IconModule], [typeof ImageHistoryComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<ImageHistoryModule>;
 }
 
-declare enum RoutesEnum {
-    Upload = "1",
-    AdjustImage = "2",
-    SelectProducts = "3",
-    EnhanceImage = "4"
-}
-
-declare class NavigationService {
-    readonly menuItemChange: EventEmitter<RoutesEnum>;
-    activeStep: RoutesEnum;
-    menuItems: {
-        label: string;
-        icon: Icon;
-        menuIndex: RoutesEnum;
-        disabled: boolean;
-    }[];
-    navigateToStep(step: RoutesEnum, updateDisabledItems?: boolean): void;
-    updateMenu(step: RoutesEnum): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
-}
-
 declare class PhotoEditorComponent implements OnInit {
-    iconService: IconCacheService;
-    dataService: DataService;
-    router: Router;
-    navigationService: NavigationService;
+    iconService: InphotoIconCacheService;
+    dataService: InphotoDataService;
     private _connectorService;
-    private _loaderService;
+    private _changeDetection;
+    private _eventService;
     readonly icons: typeof Icon;
+    readonly FileTypes: typeof FileTypes;
+    showClass(): boolean;
     set image(value: string);
     get image(): string;
-    showClass(): boolean;
+    showLoader: boolean;
+    loadingTexts: string[];
+    canvasErase: boolean;
+    maskingList: MaskImageColorInterface[];
+    canvasMaskColor: ColorPalette;
     private _image;
-    constructor(iconService: IconCacheService, dataService: DataService, router: Router, navigationService: NavigationService, _connectorService: InPhotoConnectorService, _loaderService: LoaderService);
+    private _canvasImage;
+    constructor(iconService: InphotoIconCacheService, dataService: InphotoDataService, _connectorService: InPhotoConnectorService, _changeDetection: ChangeDetectorRef, _eventService: InphotoEventService);
     ngOnInit(): void;
-    handleProductImageSelected(event: string[]): void;
-    handleProductImagesSelected(productImages: string[]): void;
+    toggleEraseMode(state: boolean): void;
+    handleCreatePromptWithImages(event: PromptWithImages): void;
     handleStyleSelection(event: EnhanceStyle): void;
     handleSetImageFromHistory(event: string): void;
     handleBackButtonClicked(): void;
     handleImageUpload(event: File[]): void;
+    handleChangeMarkerColor(data: MaskImageColorInterface): void;
+    handleUpdateCanvasImage(image: string): void;
     private _handleSetLoader;
     private _handleImageResponse;
+    private _addToHistory;
     static ɵfac: i0.ɵɵFactoryDeclaration<PhotoEditorComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<PhotoEditorComponent, "co-photo-editor", never, { "image": { "alias": "image"; "required": false; }; }, {}, never, never, false, never>;
 }
 
+declare class ProcessLoaderComponent implements OnDestroy {
+    iconCacheService: InphotoIconCacheService;
+    readonly icons: typeof Icon;
+    showClass(): boolean;
+    set showLoader(value: boolean);
+    get showLoader(): boolean;
+    set loadingTexts(values: string[]);
+    get loadingTexts(): string[];
+    activeIndex: number;
+    suppressTransition: boolean;
+    private _showLoader;
+    private _loadingTexts;
+    private _intervalId;
+    private _snapTimeoutId?;
+    private _rafId;
+    private _holdDuration;
+    private _slideDuration;
+    constructor(iconCacheService: InphotoIconCacheService);
+    ngOnDestroy(): void;
+    start(): void;
+    advance(): void;
+    reset(): void;
+    stop(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProcessLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProcessLoaderComponent, "co-process-loader", never, { "showLoader": { "alias": "showLoader"; "required": false; }; "loadingTexts": { "alias": "loadingTexts"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProcessLoaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProcessLoaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProcessLoaderModule, [typeof ProcessLoaderComponent], [typeof i2.LoaderModule, typeof PipeModule, typeof i4.DecimalPipe, typeof i5.UtilitiesPipesModule, typeof i2.IconModule], [typeof ProcessLoaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProcessLoaderModule>;
+}
+
+declare class CanvasToolBarComponent {
+    iconService: InphotoIconCacheService;
+    readonly icons: typeof Icon;
+    showClass(): boolean;
+    set canvasInpaintMode(value: boolean);
+    get canvasInpaintMode(): boolean;
+    set canvasEraseMode(value: boolean);
+    get canvasEraseMode(): boolean;
+    showActionButtons: boolean;
+    showInfoIcon: boolean;
+    title: string;
+    dragBoundary: string;
+    changeEraseMode: EventEmitter<boolean>;
+    cancelClick: EventEmitter<void>;
+    processSegmentation: EventEmitter<void>;
+    openInfoContainer: EventEmitter<any>;
+    private _canvasInpaintMode;
+    private _canvasEraseMode;
+    constructor(iconService: InphotoIconCacheService);
+    toggleEraseMode(mode: boolean): void;
+    openInfoDialog(): void;
+    handleCancelClick(): void;
+    processInpainted(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanvasToolBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CanvasToolBarComponent, "co-canvas-tool-bar", never, { "canvasInpaintMode": { "alias": "canvasInpaintMode"; "required": false; }; "canvasEraseMode": { "alias": "canvasEraseMode"; "required": false; }; "showActionButtons": { "alias": "showActionButtons"; "required": false; }; "showInfoIcon": { "alias": "showInfoIcon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "dragBoundary": { "alias": "dragBoundary"; "required": false; }; }, { "changeEraseMode": "changeEraseMode"; "cancelClick": "cancelClick"; "processSegmentation": "processSegmentation"; "openInfoContainer": "openInfoContainer"; }, never, never, false, never>;
+}
+
+declare class CanvasToolBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CanvasToolBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CanvasToolBarModule, [typeof CanvasToolBarComponent], [typeof i2.ButtonModule, typeof i2.IconModule, typeof PipeModule, typeof i7.CdkDrag, typeof i7.CdkDragHandle], [typeof CanvasToolBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CanvasToolBarModule>;
+}
+
 declare class PhotoEditorModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<PhotoEditorModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<PhotoEditorModule, [typeof PhotoEditorComponent], [typeof EditCanvasModule, typeof PipeModule, typeof ImageUploadModule, typeof i2.ButtonModule, typeof ImageEnhancerModule, typeof ImageHistoryModule], [typeof PhotoEditorComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PhotoEditorModule, [typeof PhotoEditorComponent], [typeof EditCanvasModule, typeof PipeModule, typeof ImageUploadModule, typeof i2.ButtonModule, typeof ImageEnhancerModule, typeof ImageHistoryModule, typeof ProcessLoaderModule, typeof i2.IconModule, typeof CanvasToolBarModule, typeof i7.DragDropModule], [typeof PhotoEditorComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<PhotoEditorModule>;
 }
 
-declare class PrepareStartingImageComponent implements OnDestroy {
-    dataService: DataService;
-    iconService: IconCacheService;
-    navigationService: NavigationService;
+declare class PrepareStartingImageComponent {
+    iconService: InphotoIconCacheService;
     private _connectorService;
-    private _loaderService;
     private _appEventService;
     readonly icons: typeof Icon;
     showClass(): boolean;
-    get getCanvasImage(): string;
-    get buttonDisabled(): boolean;
-    disableClearAllObjectsButton: boolean;
+    image: string;
+    cancelClick: EventEmitter<void>;
+    processedRoom: EventEmitter<SceneBuildObject>;
+    segmentationJobId: EventEmitter<string>;
+    imageReady: EventEmitter<string>;
+    continueToAI: EventEmitter<string>;
     disableSelectObjectsButton: boolean;
-    showObjectSelectionButtons: boolean;
-    showDefaultToolbar: boolean;
-    enableObjectPicker: boolean;
-    segmentationInPaintingData: any;
-    private _nextButtonDisabled;
-    private _subs;
-    private _previewProcessedImage;
-    private _usedSegmentation;
-    constructor(dataService: DataService, iconService: IconCacheService, navigationService: NavigationService, _connectorService: InPhotoConnectorService, _loaderService: LoaderService, _appEventService: AppEventService);
-    ngOnDestroy(): void;
+    showLoader: boolean;
+    loadingTexts: string[];
+    constructor(iconService: InphotoIconCacheService, _connectorService: InPhotoConnectorService, _appEventService: InphotoEventService);
+    handleCancelClick(): void;
     handleClearAllObjects(): void;
     handleSelectToClearObjects(): void;
-    handleSegmentationPointClick(event: SegmentationPoint): void;
-    handleClearSelectedObjects(): void;
-    handleGenerateFloorData(): Promise<SceneBuildObject>;
-    handleNextRoute(): void;
-    handleBackRoute(): void;
+    handleContinueToAI(): void;
     private _handleRoomReceived;
-    private _handleLoader;
     static ɵfac: i0.ɵɵFactoryDeclaration<PrepareStartingImageComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<PrepareStartingImageComponent, "co-prepare-starting-image", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PrepareStartingImageComponent, "co-prepare-starting-image", never, { "image": { "alias": "image"; "required": false; }; }, { "cancelClick": "cancelClick"; "processedRoom": "processedRoom"; "segmentationJobId": "segmentationJobId"; "imageReady": "imageReady"; "continueToAI": "continueToAI"; }, never, never, false, never>;
 }
 
 declare class PrepareStartingImageModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<PrepareStartingImageModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<PrepareStartingImageModule, [typeof PrepareStartingImageComponent], [typeof EditCanvasModule, typeof i2.ButtonModule, typeof PipeModule, typeof BackNextButtonsModule, typeof i2.IconModule], [typeof PrepareStartingImageComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PrepareStartingImageModule, [typeof PrepareStartingImageComponent], [typeof EditCanvasModule, typeof i2.ButtonModule, typeof PipeModule, typeof BackNextButtonsModule, typeof i2.IconModule, typeof ProcessLoaderModule], [typeof PrepareStartingImageComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<PrepareStartingImageModule>;
 }
 
-declare class ProcessLoaderComponent {
-    loaderService: LoaderService;
-    appEventService: AppEventService;
-    private _changeDetectorRef;
-    showClass(): boolean;
-    get loaderProgress(): number;
-    set loaderProgress(value: number);
-    private _loaderProgress;
-    subs: Subscription[];
-    constructor(loaderService: LoaderService, appEventService: AppEventService, _changeDetectorRef: ChangeDetectorRef);
-    updateProgress(): void;
-    setLoaderDone(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ProcessLoaderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ProcessLoaderComponent, "co-process-loader", never, {}, {}, never, never, false, never>;
-}
-
-declare class ProcessLoaderModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ProcessLoaderModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ProcessLoaderModule, [typeof ProcessLoaderComponent], [typeof i2.LoaderModule, typeof PipeModule, typeof i4.DecimalPipe], [typeof ProcessLoaderComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ProcessLoaderModule>;
-}
-
-declare class StepMenuComponent {
-    navigationService: NavigationService;
-    iconService: IconCacheService;
-    readonly icons: typeof Icon;
-    showClass(): boolean;
-    constructor(navigationService: NavigationService, iconService: IconCacheService);
-    navigate(menuIndex: RoutesEnum): void;
-    isActive(menuIndex: RoutesEnum): boolean;
-    isFinished(item: any): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<StepMenuComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<StepMenuComponent, "co-step-menu", never, {}, {}, never, never, false, never>;
-}
-
-declare class StepMenuModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<StepMenuModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<StepMenuModule, [typeof StepMenuComponent], [typeof PipeModule, typeof i2.IconModule], [typeof StepMenuComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<StepMenuModule>;
-}
-
-declare class ThreedSceneComponent implements AfterViewInit {
-    dataService: DataService;
-    router: Router;
-    navigationService: NavigationService;
-    iconService: IconCacheService;
-    modelConfigurationService: ModelConfigurationService;
+declare class InphotoThreedSceneComponent implements AfterViewInit {
+    iconService: InphotoIconCacheService;
     private _interactionService;
     private _sceneService;
     private _objectsService;
-    private _settingService;
     private _appEventService;
+    private _settingsService;
+    private _configuringService;
+    private _configuratorEventService;
+    private _inphotoHudService;
     readonly icons: typeof Icon;
-    constructor(dataService: DataService, router: Router, navigationService: NavigationService, iconService: IconCacheService, modelConfigurationService: ModelConfigurationService, _interactionService: InteractionService, _sceneService: SceneService, _objectsService: ObjectsService, _settingService: SettingsService, _appEventService: AppEventService);
     showClass(): boolean;
     container: ElementRef<HTMLDivElement>;
+    set room(value: SceneBuildObject);
+    get room(): SceneBuildObject;
+    set currentArticleConfiguration(value: ArticleConfiguration);
+    get currentArticleConfiguration(): ArticleConfiguration;
+    startAiDecoration: EventEmitter<string>;
+    configuratorSettings: any;
+    configuratorSku: string;
+    configuratorInstanceId: string;
+    firstBuild: boolean;
+    loadConfigurator: boolean;
+    showConfiguratorSideBar: boolean;
+    private _room;
+    private _sceneReady;
+    private _currentArticleConfiguration;
+    private _userActionNeeded;
+    private _subs;
+    constructor(iconService: InphotoIconCacheService, _interactionService: InphotoInteractionService, _sceneService: InphotoSceneService, _objectsService: InphotoItemService, _appEventService: InphotoEventService, _settingsService: InphotoSettingsService, _configuringService: ConfiguringService, _configuratorEventService: ConfiguratorEventService, _inphotoHudService: InphotoHudService);
     ngAfterViewInit(): void;
     init(): void;
-    openCatalog(): void;
-    handleNextRoute(): void;
-    handleBackRoute(): void;
     setBackgroundImage(url: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ThreedSceneComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ThreedSceneComponent, "co-threedscene", never, {}, {}, never, never, false, never>;
+    handleConfigureObjectClick(articleConfiguration: ArticleConfiguration): void;
+    handleObjectScaleClick(articleConfiguration: ArticleConfiguration): void;
+    handleDeleteObject(articleConfiguration: ArticleConfiguration): void;
+    showConfiguratorChange(show: boolean): void;
+    handleChangeObjectScale(scale: Vector3): void;
+    handleCloseConfiguratorSideBar(): void;
+    handleThreedToAi(): void;
+    private _addArticleToScene;
+    private _prepareSettings;
+    private _handleFirstBuild;
+    private _handleBuildResult;
+    private _continueConfiguration;
+    private _resetConfigurator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoThreedSceneComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InphotoThreedSceneComponent, "co-inphoto-threed-scene", never, { "room": { "alias": "room"; "required": false; }; }, { "startAiDecoration": "startAiDecoration"; }, never, never, false, never>;
 }
 
-declare class ModelListComponent {
-    objectsService: ObjectsService;
+declare class SceneContextMenuComponent implements OnDestroy {
+    iconService: InphotoIconCacheService;
+    private _appEventService;
+    private _interactionService;
+    readonly icons: typeof Icon;
     showClass(): boolean;
-    constructor(objectsService: ObjectsService);
-    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListComponent, "co-model-list", never, {}, {}, never, never, false, never>;
-}
-
-declare class ModelListItemComponent {
-    iconService: IconCacheService;
-    private _modelConfigurationService;
+    configureObject: EventEmitter<ArticleConfiguration>;
+    copyObject: EventEmitter<ArticleConfiguration>;
+    scaleObject: EventEmitter<ArticleConfiguration>;
+    deleteObject: EventEmitter<ArticleConfiguration>;
+    activeItem: 'move' | 'rotate' | null;
+    articleName: string;
+    showContextMenu: boolean;
+    private _subs;
+    private _articleConfiguration;
+    constructor(iconService: InphotoIconCacheService, _appEventService: InphotoEventService, _interactionService: InphotoInteractionService);
+    ngOnDestroy(): void;
+    handleMovementClick(): void;
+    handleRotateClick(): void;
+    handleConfigureClick(): void;
+    handleScaleClick(): void;
+    handleCopyClick(): void;
+    handleDeleteClick(): void;
+    setArticleConfiguration(article: ArticleConfiguration): void;
+    closeMenu(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneContextMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SceneContextMenuComponent, "co-scene-context-menu", never, {}, { "configureObject": "configureObject"; "copyObject": "copyObject"; "scaleObject": "scaleObject"; "deleteObject": "deleteObject"; }, never, never, false, never>;
+}
+
+declare class SceneContextMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneContextMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SceneContextMenuModule, [typeof SceneContextMenuComponent], [typeof i2.IconModule, typeof PipeModule, typeof i2.ButtonModule], [typeof SceneContextMenuComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SceneContextMenuModule>;
+}
+
+declare class ConfigurationSideBarMenuComponent implements OnDestroy {
+    iconService: InphotoIconCacheService;
+    private _eventService;
     readonly icons: typeof Icon;
+    showClass(): boolean;
+    set item(value: ArticleConfiguration);
+    get item(): ArticleConfiguration;
+    updateObjectScale: EventEmitter<Vector3>;
+    closeClick: EventEmitter<void>;
     scaleAll: number;
     scaleX: number;
     scaleY: number;
     scaleZ: number;
-    rotationDegrees: number;
-    set item(value: ArticleConfiguration);
-    get item(): ArticleConfiguration;
-    showClass(): boolean;
-    collapsed: boolean;
     private _item;
-    constructor(iconService: IconCacheService, _modelConfigurationService: ModelConfigurationService);
-    onRotationChange(event: Event): void;
+    private _subs;
+    constructor(iconService: InphotoIconCacheService, _eventService: InphotoEventService);
+    ngOnDestroy(): void;
     onScaleAllChange(event: Event): void;
-    onScaleXChange(event: Event): void;
-    onScaleYChange(event: Event): void;
-    onScaleZChange(event: Event): void;
-    toggleCollapse(): void;
-    openConfiguration(): void;
-    removeFromProject(): void;
+    onScaleSingleAxis(event: Event): void;
+    handleCloseClick(): void;
     private _setProperties;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListItemComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ModelListItemComponent, "co-model-list-item", never, { "item": { "alias": "item"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationSideBarMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfigurationSideBarMenuComponent, "co-configuration-side-bar-menu", never, { "item": { "alias": "item"; "required": false; }; }, { "updateObjectScale": "updateObjectScale"; "closeClick": "closeClick"; }, never, never, false, never>;
+}
+
+declare class ConfigurationSideBarMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationSideBarMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ConfigurationSideBarMenuModule, [typeof ConfigurationSideBarMenuComponent], [typeof i2$1.FormsModule, typeof PipeModule, typeof i2.IconModule, typeof i2.ButtonModule, typeof i4.NgClass], [typeof ConfigurationSideBarMenuComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ConfigurationSideBarMenuModule>;
+}
+
+declare class ThreedToAiComponent {
+    iconService: InphotoIconCacheService;
+    readonly icons: typeof Icon;
+    showClass(): boolean;
+    threedToAiClick: EventEmitter<void>;
+    constructor(iconService: InphotoIconCacheService);
+    handleClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThreedToAiComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ThreedToAiComponent, "co-threed-to-ai", never, {}, { "threedToAiClick": "threedToAiClick"; }, never, never, false, never>;
 }
 
-declare class ModelListItemModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListItemModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ModelListItemModule, [typeof ModelListItemComponent], [typeof i2$1.FormsModule, typeof PipeModule, typeof i2.IconModule, typeof i2.ButtonModule, typeof i4.NgClass], [typeof ModelListItemComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ModelListItemModule>;
+declare class ThreedToAiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThreedToAiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ThreedToAiModule, [typeof ThreedToAiComponent], [typeof i2.IconModule, typeof PipeModule], [typeof ThreedToAiComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ThreedToAiModule>;
 }
 
-declare class ModelListModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ModelListModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ModelListModule, [typeof ModelListComponent], [typeof ModelListItemModule], [typeof ModelListComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ModelListModule>;
+declare class InphotoThreedsceneModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InphotoThreedsceneModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InphotoThreedsceneModule, [typeof InphotoThreedSceneComponent], [typeof ImageUploadModule, typeof BackNextButtonsModule, typeof i2.ButtonModule, typeof PipeModule, typeof InphotoCatalogModule, typeof i2.IconModule, typeof i7$1.ConfiguratorModule, typeof SceneContextMenuModule, typeof ConfigurationSideBarMenuModule, typeof ThreedToAiModule], [typeof InphotoThreedSceneComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<InphotoThreedsceneModule>;
 }
 
-declare class ThreedsceneModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<ThreedsceneModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<ThreedsceneModule, [typeof ThreedSceneComponent], [typeof ImageUploadModule, typeof BackNextButtonsModule, typeof i2.ButtonModule, typeof PipeModule, typeof CatalogModule, typeof i2.IconModule, typeof i7.ConfiguratorModule, typeof ModelListModule], [typeof ThreedSceneComponent]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<ThreedsceneModule>;
+declare enum RoutesEnum {
+    Upload = "1",
+    AdjustImage = "2",
+    SelectProducts = "3",
+    EnhanceImage = "4"
+}
+
+declare class NavigationService {
+    readonly menuItemChange: EventEmitter<RoutesEnum>;
+    activeStep: RoutesEnum;
+    menuItems: {
+        label: string;
+        icon: Icon;
+        menuIndex: RoutesEnum;
+        disabled: boolean;
+    }[];
+    navigateToStep(step: RoutesEnum, updateDisabledItems?: boolean): void;
+    updateMenu(step: RoutesEnum): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
 }
 
 declare class UploadStartingImageComponent {
-    iconService: IconCacheService;
-    dataService: DataService;
+    iconService: InphotoIconCacheService;
+    dataService: InphotoDataService;
     navigationService: NavigationService;
     readonly icons: typeof Icon;
+    readonly FileTypes: typeof FileTypes;
     showClass(): boolean;
-    get buttonDisabled(): boolean;
-    constructor(iconService: IconCacheService, dataService: DataService, navigationService: NavigationService);
-    handleRoute(): void;
+    cancelClick: EventEmitter<void>;
+    uploadedImage: EventEmitter<string>;
+    constructor(iconService: InphotoIconCacheService, dataService: InphotoDataService, navigationService: NavigationService);
     handleImageUpload(event: File[]): void;
+    handleCancelClick(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<UploadStartingImageComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<UploadStartingImageComponent, "co-upload-starting-image", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UploadStartingImageComponent, "co-upload-starting-image", never, {}, { "cancelClick": "cancelClick"; "uploadedImage": "uploadedImage"; }, never, never, false, never>;
 }
 
 declare class UploadStartingImageModule {
@@ -1074,29 +1411,190 @@ declare class AppInitializerService {
     private _settingsService;
     private _connectorService;
     appInitialized: BehaviorSubject<boolean>;
-    constructor(_settingsService: SettingsService, _connectorService: InPhotoConnectorService);
+    constructor(_settingsService: InphotoSettingsService, _connectorService: InPhotoConnectorService);
     initializeApp(options?: Settings): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<AppInitializerService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<AppInitializerService>;
 }
 
-declare class InPhotoComponent implements OnDestroy {
+declare class InPhotoComponent {
     appInitializerService: AppInitializerService;
-    navigationService: NavigationService;
-    readonly RoutesEnum: typeof RoutesEnum;
+    appEventService: InphotoEventService;
+    private _cdk;
     showClass(): boolean;
     set settings(input: any);
-    private _subs;
-    constructor(appInitializerService: AppInitializerService, navigationService: NavigationService);
-    ngOnDestroy(): void;
+    showImageUpload: boolean;
+    showImagePrepare: boolean;
+    showImageNextStep: boolean;
+    showImageInpaint: boolean;
+    showImageAiDecoration: boolean;
+    show3D: boolean;
+    showReadyToAddDialog: boolean;
+    uploadedImage: string;
+    preparedImage: string;
+    aiDecorationImage: string;
+    roomData: SceneBuildObject;
+    segmentJobId: string;
+    constructor(appInitializerService: AppInitializerService, appEventService: InphotoEventService, _cdk: ChangeDetectorRef);
+    handleCancelClick(): void;
+    startPoint(): void;
+    handleImageUpload(image: string): void;
+    handleProcessedRoom(roomData: SceneBuildObject): void;
+    handleStart3D(data: SceneBuildObject): void;
+    handleSegmentationJobId(segmentJobId: string): void;
+    handleSegmentOutput(image: string): void;
+    handleCancelSegmentClick(): void;
+    handleMenuChange(event: any): void;
+    handleAiDecoration(image?: string): void;
+    handleCancelCompleteClick(): void;
+    closeReadyToOpen(): void;
+    handleOpenCatalog(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<InPhotoComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<InPhotoComponent, "co-inphoto", never, { "settings": { "alias": "settings"; "required": false; }; }, {}, never, never, false, never>;
 }
 
+declare class SegmentInpaintComponent {
+    iconService: InphotoIconCacheService;
+    private _connectorService;
+    private _loaderService;
+    readonly icons: typeof Icon;
+    showClass(): boolean;
+    set image(value: string);
+    get image(): string;
+    set segmentJobId(value: string);
+    get segmentJobId(): string;
+    cancelClick: EventEmitter<void>;
+    preparedImage: EventEmitter<string>;
+    segmentationInPaintingData: any;
+    showInfoDialog: boolean;
+    canvasInPaint: boolean;
+    canvasErase: boolean;
+    showLoader: boolean;
+    loadingTexts: string[];
+    private _image;
+    private _segmentJobiId;
+    private _inpaintImageState;
+    constructor(iconService: InphotoIconCacheService, _connectorService: InPhotoConnectorService, _loaderService: LoaderService);
+    handleCancelClick(): void;
+    openInfoDialog(): void;
+    handleCloseInfoDialogClick(): void;
+    toggleEraseMode(erase: boolean): void;
+    handleSegmentationPointClick(event: SegmentationPoint): void;
+    processInpainted(): void;
+    handleImageStateChange(image: string): void;
+    private _handleLoader;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentInpaintComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SegmentInpaintComponent, "co-segment-inpaint", never, { "image": { "alias": "image"; "required": false; }; "segmentJobId": { "alias": "segmentJobId"; "required": false; }; }, { "cancelClick": "cancelClick"; "preparedImage": "preparedImage"; }, never, never, false, never>;
+}
+
+declare class InpaintInfoCardComponent {
+    showClass(): boolean;
+    icon: SafeHtml;
+    title: string;
+    description: string;
+    number: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InpaintInfoCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InpaintInfoCardComponent, "co-inpaint-info-card", never, { "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "number": { "alias": "number"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class SegmentInpaintModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SegmentInpaintModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SegmentInpaintModule, [typeof SegmentInpaintComponent, typeof InpaintInfoCardComponent], [typeof EditCanvasModule, typeof i2.IconModule, typeof PipeModule, typeof i2.ButtonModule, typeof ProcessLoaderModule, typeof CanvasToolBarModule], [typeof SegmentInpaintComponent, typeof InpaintInfoCardComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SegmentInpaintModule>;
+}
+
+declare class ImageProcessCompleteComponent {
+    iconService: InphotoIconCacheService;
+    private _connectorService;
+    private _appEventService;
+    readonly icons: typeof Icon;
+    showClass(): boolean;
+    set image(value: string);
+    get image(): string;
+    handleStart3D: EventEmitter<SceneBuildObject>;
+    handleAiDecorationClicked: EventEmitter<string>;
+    cancelClick: EventEmitter<void>;
+    showLoader: boolean;
+    loadingTexts: string[];
+    private _image;
+    private _subs;
+    constructor(iconService: InphotoIconCacheService, _connectorService: InPhotoConnectorService, _appEventService: InphotoEventService);
+    handle3DClick(): void;
+    handleAiClick(): void;
+    cancel(): void;
+    private _handleRoomReceived;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageProcessCompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageProcessCompleteComponent, "co-image-process-complete", never, { "image": { "alias": "image"; "required": false; }; }, { "handleStart3D": "handleStart3D"; "handleAiDecorationClicked": "handleAiDecorationClicked"; "cancelClick": "cancelClick"; }, never, never, false, never>;
+}
+
+declare class ImageProcessCompleteNextComponent {
+    iconService: InphotoIconCacheService;
+    readonly icons: typeof Icon;
+    showClass(): boolean;
+    icon: Icon;
+    header: string;
+    body: string;
+    onClick: EventEmitter<void>;
+    constructor(iconService: InphotoIconCacheService);
+    handleClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageProcessCompleteNextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageProcessCompleteNextComponent, "co-image-process-complete-next", never, { "icon": { "alias": "icon"; "required": false; }; "header": { "alias": "header"; "required": false; }; "body": { "alias": "body"; "required": false; }; }, { "onClick": "onClick"; }, never, never, false, never>;
+}
+
+declare class ImageProcessCompleteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageProcessCompleteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageProcessCompleteModule, [typeof ImageProcessCompleteComponent, typeof ImageProcessCompleteNextComponent], [typeof i2.IconModule, typeof PipeModule, typeof i2.ButtonModule, typeof ProcessLoaderModule], [typeof ImageProcessCompleteComponent, typeof ImageProcessCompleteNextComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ImageProcessCompleteModule>;
+}
+
+interface SideBarMenuOption {
+    id: number;
+    labelKey: string;
+    icon: Icon;
+    disabled: boolean;
+}
+declare class SideBarMenuComponent {
+    iconService: InphotoIconCacheService;
+    readonly icons: typeof Icon;
+    showClass(): boolean;
+    optionClicked: EventEmitter<SideBarMenuOption>;
+    options: SideBarMenuOption[];
+    activeId: number;
+    constructor(iconService: InphotoIconCacheService);
+    select(option: SideBarMenuOption): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideBarMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SideBarMenuComponent, "co-side-bar-menu", never, {}, { "optionClicked": "optionClicked"; }, never, never, false, never>;
+}
+
+declare class SideBarMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideBarMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SideBarMenuModule, [typeof SideBarMenuComponent], [typeof i2.IconModule, typeof PipeModule], [typeof SideBarMenuComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SideBarMenuModule>;
+}
+
+declare class ReadyToAddArticlesComponent {
+    iconCacheService: InphotoIconCacheService;
+    readonly icons: typeof Icon;
+    showClass(): boolean;
+    closeClick: EventEmitter<void>;
+    openCatalog: EventEmitter<void>;
+    constructor(iconCacheService: InphotoIconCacheService);
+    close(): void;
+    open(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReadyToAddArticlesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReadyToAddArticlesComponent, "co-ready-to-add-articles", never, {}, { "closeClick": "closeClick"; "openCatalog": "openCatalog"; }, never, never, false, never>;
+}
+
+declare class ReadyToAddArticlesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReadyToAddArticlesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ReadyToAddArticlesModule, [typeof ReadyToAddArticlesComponent], [typeof i2.IconModule, typeof PipeModule, typeof i2.ButtonModule], [typeof ReadyToAddArticlesComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ReadyToAddArticlesModule>;
+}
+
 declare class InPhotoModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<InPhotoModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<InPhotoModule, [typeof InPhotoComponent], [typeof UploadStartingImageModule, typeof StepMenuModule, typeof ErrorDialogModule, typeof ProcessLoaderModule, typeof PrepareStartingImageModule, typeof ThreedsceneModule, typeof PhotoEditorModule], [typeof InPhotoComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<InPhotoModule, [typeof InPhotoComponent], [typeof UploadStartingImageModule, typeof ErrorDialogModule, typeof ProcessLoaderModule, typeof PrepareStartingImageModule, typeof InphotoThreedsceneModule, typeof PhotoEditorModule, typeof EditCanvasModule, typeof SegmentInpaintModule, typeof ImageProcessCompleteModule, typeof SideBarMenuModule, typeof InphotoCatalogModule, typeof ReadyToAddArticlesModule], [typeof InPhotoComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<InPhotoModule>;
 }
 
-export { BackNextButtonsComponent, BackNextButtonsModule, CatalogComponent, CatalogModule, EditCanvasComponent, EditCanvasModule, ErrorDialogComponent, ErrorDialogModule, ImageEnhancer, ImageEnhancerModule, ImageEnhancerStyleComponent, ImageEnhancerStyleModule, ImageEnhancerUploadComponent, ImageEnhancerUploadModule, ImageHistoryComponent, ImageHistoryModule, ImageHistoryTileComponent, ImageHistoryTileModule, ImageUpload, ImageUploadModule, InPhotoComponent, InPhotoModule, PhotoEditorComponent, PhotoEditorModule, PrepareStartingImageComponent, PrepareStartingImageModule, ProcessLoaderComponent, ProcessLoaderModule, StepMenuComponent, StepMenuModule, ThreedSceneComponent, ThreedsceneModule, UploadStartingImageComponent, UploadStartingImageModule };
+export { BackNextButtonsComponent, BackNextButtonsModule, EditCanvasComponent, EditCanvasModule, ErrorDialogComponent, ErrorDialogModule, ImageEnhancer, ImageEnhancerModule, ImageEnhancerStyleComponent, ImageEnhancerStyleModule, ImageEnhancerUploadComponent, ImageEnhancerUploadModule, ImageHistoryComponent, ImageHistoryModule, ImageHistoryTileComponent, ImageHistoryTileModule, ImageUpload, ImageUploadModule, InPhotoComponent, InPhotoModule, InphotoCatalogComponent, InphotoCatalogModule, InphotoThreedSceneComponent, InphotoThreedsceneModule, PhotoEditorComponent, PhotoEditorModule, PrepareStartingImageComponent, PrepareStartingImageModule, ProcessLoaderComponent, ProcessLoaderModule, UploadStartingImageComponent, UploadStartingImageModule };