@colijnit/inphoto 262.1.0

package/index.d.ts

@@ -0,0 +1,1093 @@
+import * as i0 from '@angular/core';
+import { EventEmitter, PipeTransform, WritableSignal, OnDestroy, ElementRef, OnInit, ChangeDetectorRef, AfterViewInit } from '@angular/core';
+import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
+import * as i2 from '@colijnit/corecomponents_v12';
+import { LanguageCode } from '@colijnit/ioneconnector/build/enum/language-code.enum';
+import { Subject, BehaviorSubject, Subscription } from 'rxjs';
+import { GetArticlesForCatalogRequest } from '@colijnit/transactionapi/build/model/get-articles-for-catalog';
+import { Vector3, Mesh, Box3, Scene, PerspectiveCamera, WebGLRenderer, Object3D, Vector2, Raycaster } from 'three';
+import { Articles } from '@colijnit/articleapi/build/articles';
+import { MainApi } from '@colijnit/mainapi';
+import { Configurator } from '@colijnit/configuratorapi';
+import { LoginResponse } from '@colijnit/ioneconnector/build/model/login-response';
+import { CatalogDefinition } from '@colijnit/articleapi/build/model/catalog-definition.bo';
+import { ExternalSource } from '@colijnit/articleapi/build/model/external-source.bo';
+import * as i3 from '@colijnit/catalog';
+import { CatalogExternalSourcesService, FilterOrder, CatalogService, ExternalSourceViewmodel } from '@colijnit/catalog';
+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 { ConfigurationResultObject, ConfiguringService } from '@colijnit/configurator';
+import * as i2$1 from '@angular/forms';
+import { Router } from '@angular/router';
+import * as i4 from '@angular/common';
+
+/** AUTO GENERATED FILE. DO NOT CHANGE.. OR YOU WILL SUFFER THE CONSEQUENCES OF YOUR ACTIONS **/
+declare enum Icon {
+    AngleDownSolidFull = "angle_down_solid_full",
+    AngleUpSolidFull = "angle_up_solid_full",
+    ArrowLeftSolidFull = "arrow_left_solid_full",
+    ArrowRightSolidFull = "arrow_right_solid_full",
+    ArrowRotateLeftSolidFull = "arrow_rotate_left_solid_full",
+    ArrowUpFromBracketSolid = "arrow_up_from_bracket_solid",
+    ArrowUpRightAndArrowDownLeftFromCenterSolidFull = "arrow_up_right_and_arrow_down_left_from_center_solid_full",
+    ArrowUpToBracketDuotoneRegular = "arrow_up_to_bracket_duotone_regular",
+    BrushSolidFull = "brush_solid_full",
+    CouchSolidFull = "couch_solid_full",
+    CrossSkinny = "cross_skinny",
+    FillSolidFull = "fill_solid_full",
+    ImagesSharpSolidFull = "images_sharp_solid_full",
+    ImageCircleArrowDownSolidFull = "image_circle_arrow_down_solid_full",
+    ImageCircleXmarkSolidFull = "image_circle_xmark_solid_full",
+    ImageSolidFull = "image_solid_full",
+    LightbulbRegularFull = "lightbulb_regular_full",
+    PenToSquareSolidFull = "pen_to_square_solid_full",
+    SaveSkinny = "save_skinny",
+    SharpRegularObjectGroupPen = "sharp_regular_object_group_pen",
+    UploadSolidFull = "upload_solid_full",
+    WandMagicSparklesSharpRegular = "wand_magic_sparkles_sharp_regular"
+}
+
+declare class IconCacheService {
+    private _sanitizer;
+    /**
+     * All the icons as a large JSON object, from the all-icons.json file.
+     * The object has property keys that are the icon names, and property values with the data string of the actual svg icon.
+     */
+    get iconCache(): {
+        [iconName: string]: SafeHtml;
+    };
+    private _iconCache;
+    constructor(_sanitizer: DomSanitizer);
+    getIcon(iconName: Icon | string): SafeHtml;
+    getIconAsBase64(iconName: Icon): SafeHtml;
+    getRawIcon(iconName: Icon): string;
+    setIconCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconCacheService>;
+}
+
+declare class BackNextButtonsComponent {
+    iconService: IconCacheService;
+    readonly icons: typeof Icon;
+    set showBackButton(value: boolean);
+    get showBackButton(): boolean;
+    set disableBackButton(value: boolean);
+    get disableBackButton(): boolean;
+    set showNextButton(value: boolean);
+    get showNextButton(): boolean;
+    set disableNextButton(value: boolean);
+    get disableNextButton(): boolean;
+    set showGenerateButton(value: boolean);
+    get showGenerateButton(): boolean;
+    set disableGenerateButton(value: boolean);
+    get disableGenerateButton(): boolean;
+    backClicked: EventEmitter<void>;
+    nextClicked: EventEmitter<void>;
+    generateClicked: EventEmitter<void>;
+    showClass(): boolean;
+    private _showBackButton;
+    private _disableBackButton;
+    private _showNextButton;
+    private _disableNextButton;
+    private _showGenerateButton;
+    private _disableGenerateButton;
+    constructor(iconService: IconCacheService);
+    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 {
+    get language(): LanguageCode;
+    set language(value: LanguageCode);
+    private _dictionaryPromise;
+    private _dictionaries;
+    private _language;
+    private readonly _placeholder;
+    setDictionary(language: LanguageCode): Promise<void>;
+    /**
+     * Returns the localized text for the given dictionary key.
+     * @param {string} key
+     * @param {boolean} [upperCaseFirst = true] False for first letter lowercase, true for first letter uppercase for returned dict val
+     * @param {string[]} replacementTexts Rest params for replacement of '|~' in returned dict value
+     * @returns {string} The translated text for given dictionary key
+     */
+    get(key: string, upperCaseFirst?: boolean, ...replacementTexts: string[]): string;
+    private _dictionaryLoaded;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DictionaryService>;
+}
+
+declare class LocalizePipe implements PipeTransform {
+    private _dictionaryService;
+    constructor(_dictionaryService: DictionaryService);
+    transform(value: string, upperCaseFirst?: boolean, replace?: string | string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizePipe, "localize", false>;
+}
+
+declare class PipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PipeModule, [typeof LocalizePipe], never, [typeof LocalizePipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PipeModule>;
+}
+
+declare class BackNextButtonsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackNextButtonsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BackNextButtonsModule, [typeof BackNextButtonsComponent], [typeof i2.ButtonModule, typeof PipeModule], [typeof BackNextButtonsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BackNextButtonsModule>;
+}
+
+declare class SettingOptions {
+    showStockStatus: boolean;
+    show3DWatermark: boolean;
+    showZoomButton: boolean;
+    showTagFilter: boolean;
+    showAsConfigured: boolean;
+    development: boolean;
+    inlineAnswers: boolean;
+}
+
+declare class Settings {
+    url: string;
+    schema: string;
+    version: string;
+    branch: string;
+    currency: number;
+    languageCode: string;
+    currencySymbol: string;
+    username: string;
+    password: string;
+    session: any;
+    useLoginEncryption: boolean;
+    logoutWhenRefresh: boolean;
+    assetPath: string;
+    threeDAssetPath: string;
+    options: SettingOptions;
+    catalogParameters: GetArticlesForCatalogRequest;
+    infoPublicationCode: number;
+}
+
+declare class ImageRoomResponse {
+    floorGeometry: FloorGeometry;
+    cameraData: CameraData;
+    static fromJson(json: any): ImageRoomResponse;
+}
+declare class FloorGeometry {
+    boundaryPoints: Vector3[];
+    normal: Vector3;
+    static fromJson(json: any): FloorGeometry;
+}
+declare class CameraData {
+    imageSize: number[];
+    imageWidth: number;
+    imageHeight: number;
+    intrinsics: Vector3[];
+    static fromJson(json: any): CameraData;
+}
+
+declare class SceneBuildObject {
+    image: string;
+    floorPlaneMap: ImageRoomResponse;
+    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 EnhanceStyle {
+    roomType: string;
+    mode: string;
+    decorationStyle: string;
+    customInstructions: string;
+}
+
+declare class SegmentationPoint {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+}
+
+declare class LoaderService {
+    showLoader: WritableSignal<boolean>;
+    showProgress: WritableSignal<boolean>;
+    loadingText: WritableSignal<string>;
+    showEstimateLoadingTime: WritableSignal<boolean>;
+    estimatedLoadingTime: WritableSignal<string>;
+    clearLoaderProgress: EventEmitter<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoaderService>;
+}
+
+declare class ErrorService implements OnDestroy {
+    private _loaderService;
+    showErrorDialog: WritableSignal<boolean>;
+    get errors(): string[];
+    set errors(value: string[]);
+    private _errors;
+    constructor(_loaderService: LoaderService);
+    ngOnDestroy(): void;
+    addError(error: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ErrorService>;
+}
+
+declare class JobIdResponse {
+    job_id: string;
+}
+
+declare class DecorateResponse {
+    image: string;
+    public: string;
+}
+
+declare class CreatedImageResponse {
+    image: string;
+}
+
+declare class SegmentationResponse {
+    contours: any[];
+}
+
+declare class ExternalConnector {
+    loginResponse: LoginResponse;
+    connector: Connector;
+    cleanUp(): void;
+}
+interface Connector {
+    connector?: Configurator;
+    articleApi?: Articles;
+    mainApi?: MainApi;
+}
+declare class InPhotoConnectorAdapterService implements OnDestroy {
+    private _catalogExternalSourcesService;
+    private _appEventService;
+    private _errorService;
+    private _loaderService;
+    readonly showLoader: Subject<boolean>;
+    readonly connectionReset: Subject<void>;
+    mainUrl: string;
+    mainSchema: string;
+    mainVersion: string;
+    get connector(): Configurator;
+    get articleApi(): Articles;
+    get mainApi(): MainApi;
+    connectors: ExternalConnector;
+    externalSource: string;
+    loginResponse: LoginResponse;
+    private _catalogDefinitions;
+    private _externalSources;
+    private _catalogDefinitionsOriginal;
+    private _externalSourcesOriginal;
+    private _connector?;
+    private _articleApi;
+    private _mainApi;
+    private _boFactory;
+    private _publicationCodeForUserRole;
+    constructor(_catalogExternalSourcesService: CatalogExternalSourcesService, _appEventService: AppEventService, _errorService: ErrorService, _loaderService: LoaderService);
+    ngOnDestroy(): void;
+    initConnector(options: Options, externalSource?: string, forceReload?: boolean, externalSourceId?: number): Promise<boolean>;
+    getExternalSourceFromId(id: number): ExternalSource;
+    prepareExternalSources(): Promise<void>;
+    getCatalogDefinitionsList(): Promise<CatalogDefinition[]>;
+    getExternalSource(externalSourceId: number): Promise<ExternalSource>;
+    getWebViewStartupInfo(request: ExternalCatalogStartupInfoRequest): Promise<ExternalCatalogStartupInfo>;
+    /**
+     *
+     * ALL calls for the AI stuff below here
+     *
+     **/
+    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>;
+    uploadSegmentationImage(image: string): Promise<JobIdResponse>;
+    handleSegmentationClick(jobId: string, point: SegmentationPoint): Promise<SegmentationResponse>;
+    segmentInpaint(jobId: string, image: string): Promise<CreatedImageResponse>;
+    getRoomTypes(showLoader?: boolean): Promise<DataServiceResponseData>;
+    getDecorationModes(showLoader?: boolean): Promise<DataServiceResponseData>;
+    getDecorationStyles(showLoader?: boolean): Promise<DataServiceResponseData>;
+    private _handleRoomData;
+    private _processRoom;
+    private _getJobStatus;
+    private _loadRoom;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InPhotoConnectorAdapterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InPhotoConnectorAdapterService>;
+}
+
+declare class SettingsService {
+    private _dictionary;
+    private _connectorAdapterService;
+    readonly languageCodeToDictionary: Map<string, string>;
+    get languageCode(): LanguageCode;
+    set languageCode(value: LanguageCode);
+    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);
+    createSettingsFromObject(obj: any): void;
+    initialize(options?: Settings): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsService>;
+}
+
+declare class InPhotoConnectorService {
+    private _connectorAdapterService;
+    private _settingsService;
+    readonly connectionReset: Subject<void>;
+    controllerInitialized: BehaviorSubject<boolean>;
+    private readonly _subs;
+    private _initializing;
+    private _initialized;
+    private _connectorOptions;
+    private _shouldShowLoader;
+    constructor(_connectorAdapterService: InPhotoConnectorAdapterService, _settingsService: SettingsService);
+    initConnection(forceReload?: boolean, standAlone?: boolean): Promise<void>;
+    initConnector(options: any, externalSource?: string, forceReload?: boolean, externalSourceId?: number): Promise<boolean>;
+    onShowLoaderChange(showLoader: boolean): void;
+    onConnectionReset(): void;
+    prepareExternalSources(): Promise<void>;
+    getWebViewStartupInfo(request: ExternalCatalogStartupInfoRequest): Promise<ExternalCatalogStartupInfo>;
+    /**
+     *
+     * ALL calls for the AI stuff below here
+     *
+     * */
+    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>;
+    uploadSegmentationImage(image: string): Promise<JobIdResponse>;
+    handleSegmentationClick(jobId: string, point: SegmentationPoint): Promise<SegmentationResponse>;
+    segmentInpaint(jobId: string, image: string): Promise<CreatedImageResponse>;
+    getDecorationModes(showLoader?: boolean): Promise<string[]>;
+    getDecorationStyles(showLoader?: boolean): Promise<string[]>;
+    getRoomTypes(showLoader?: boolean): Promise<string[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InPhotoConnectorService, never>;
+    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 {
+    set selectedObject(value: ArticleConfiguration | undefined);
+    get selectedObject(): ArticleConfiguration | undefined;
+    set floorPlane(plane: Mesh);
+    get floorPlane(): Mesh;
+    get floorItems(): ArticleConfiguration[];
+    set floorBounds(value: Box3);
+    get floorBounds(): Box3;
+    private _selectedObject;
+    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>;
+}
+
+declare class SceneService implements OnDestroy {
+    private _objectsService;
+    set needsRender(render: boolean);
+    get needsRender(): boolean;
+    set sceneHasImage(value: boolean);
+    get sceneHasImage(): boolean;
+    container: ElementRef<HTMLDivElement>;
+    scene: Scene;
+    camera: PerspectiveCamera;
+    renderer: WebGLRenderer;
+    imageWidth: number;
+    imageHeight: number;
+    private _sceneHasImage;
+    private _needsRender;
+    constructor(_objectsService: ObjectsService);
+    ngOnDestroy(): void;
+    init(element: ElementRef<HTMLDivElement>): void;
+    getSceneAsImage(): string;
+    addObjectToScene(result: ArticleConfiguration): void;
+    placeObject(object: Object3D): void;
+    getObjectByUUID(uuid: string): Object3D | undefined;
+    removeObject(object: Object3D): void;
+    addFloorToScene(floorMesh: Mesh): void;
+    private _prepLights;
+    private _animate;
+    private _render;
+    private _onResize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SceneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SceneService>;
+}
+
+declare class InteractionService implements OnDestroy {
+    objectsService: ObjectsService;
+    private _sceneService;
+    mouse: Vector2;
+    raycaster: Raycaster;
+    lastMousePosition: Vector2;
+    isDragging: boolean;
+    dragOffset: Vector3;
+    private _camera;
+    private _scene;
+    private _renderer;
+    constructor(objectsService: ObjectsService, _sceneService: SceneService);
+    ngOnDestroy(): void;
+    init(scene: Scene, camera: PerspectiveCamera, renderer: WebGLRenderer): void;
+    onMouseUp(event: MouseEvent): void;
+    onMouseDown(event: MouseEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    updateMousePosition(event: MouseEvent): void;
+    handleFurnitureHit(furniture: ArticleConfiguration): void;
+    handlePlacement(object: Object3D): Object3D;
+    makeItStick(yRotation: number): void;
+    private _bindObjectToFloorBounds;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InteractionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InteractionService>;
+}
+
+declare class ModelConfigurationService {
+    private _connectorService;
+    private _sceneService;
+    private _settingsService;
+    private _configuringService;
+    private _objectsService;
+    private _interactionService;
+    private _loaderService;
+    /**
+     *
+     * 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);
+    get currentArticleConfiguration(): ArticleConfiguration;
+    private _loadConfigurator;
+    private _currentArticleConfiguration;
+    constructor(_connectorService: InPhotoConnectorService, _sceneService: SceneService, _settingsService: SettingsService, _configuringService: ConfiguringService, _objectsService: ObjectsService, _interactionService: InteractionService, _loaderService: LoaderService);
+    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;
+    connectorService: InPhotoConnectorService;
+    modelConfigurationService: ModelConfigurationService;
+    private _catalogService;
+    private _changeDetection;
+    readonly icons: typeof Icon;
+    showClass(): boolean;
+    showCatalogDialog: boolean;
+    showExternalCatalog: boolean;
+    showOwnCollection: boolean;
+    showBackButton: boolean;
+    hideOwnCatalog: boolean;
+    hideExternalCatalogs: boolean;
+    generalFilterOrders: FilterOrder[];
+    purchaseFilterOrders: FilterOrder[];
+    logisticsFilterOrders: FilterOrder[];
+    subs: Subscription[];
+    externalSource: ExternalSource;
+    catalogDefinition: CatalogDefinition;
+    catalogInfo: ExternalCatalogStartupInfo;
+    externalCatalogName: string;
+    private _source;
+    constructor(iconService: IconCacheService, settingService: SettingsService, appEventService: AppEventService, connectorService: InPhotoConnectorService, modelConfigurationService: ModelConfigurationService, _catalogService: CatalogService, _changeDetection: ChangeDetectorRef);
+    ngOnInit(): Promise<void>;
+    ngOnDestroy(): void;
+    handleToggleShowOwnCollection(): void;
+    handleArticleClick(event: any): void;
+    handleExternalArticleClick(data: ExternalSourceArticleClickInterface, catalogInfo?: ExternalCatalogStartupInfo): void;
+    resetOpenCatalogs(): void;
+    handleShowCatalog(): void;
+    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>;
+}
+
+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 DataService {
+    /**
+     *
+     * 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;
+    private _canvasHasMask;
+    private _generatedImages;
+    private _floorGeometry;
+    private _segmentationJobId;
+    addGeneratedImage(image: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataService>;
+}
+
+declare class EditCanvasComponent implements AfterViewInit {
+    iconService: IconCacheService;
+    dataService: DataService;
+    private _connectorService;
+    readonly icons: typeof Icon;
+    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);
+    onSegmentationPointClick: EventEmitter<SegmentationPoint>;
+    showClass(): boolean;
+    ctx: CanvasRenderingContext2D;
+    drawing: boolean;
+    brushColor: string;
+    brushSize: number;
+    showBrushOption: boolean;
+    setCanvasFullScreen: boolean;
+    private _backgroundImage;
+    private _image;
+    private _showToolbar;
+    private _enableObjectPicker;
+    constructor(iconService: IconCacheService, dataService: DataService, _connectorService: InPhotoConnectorService);
+    ngAfterViewInit(): void;
+    startDrawing(event: MouseEvent): void;
+    draw(event: MouseEvent): void;
+    stopDrawing(): void;
+    changeColor(): void;
+    changeSize(): void;
+    clearCanvas(): void;
+    loadBackground(): void;
+    showBrushSize(): void;
+    openFullScreenCanvas(): void;
+    closeFullScreenCanvas(): void;
+    private _getCanvasCoords;
+    private _drawSegmentation;
+    private _saveCanvas;
+    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>;
+}
+
+declare class EditCanvasModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditCanvasModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EditCanvasModule, [typeof EditCanvasComponent], [typeof i2$1.FormsModule, typeof i2.IconModule, typeof i2.ButtonModule], [typeof EditCanvasComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EditCanvasModule>;
+}
+
+declare class ErrorDialogComponent {
+    errorService: ErrorService;
+    iconService: IconCacheService;
+    readonly icons: typeof Icon;
+    showClass(): boolean;
+    constructor(errorService: ErrorService, iconService: IconCacheService);
+    clearAndClose(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorDialogComponent, "co-error-dialog", never, {}, {}, never, never, false, never>;
+}
+
+declare class ErrorDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ErrorDialogModule, [typeof ErrorDialogComponent], [typeof PipeModule, typeof i2.ButtonModule], [typeof ErrorDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ErrorDialogModule>;
+}
+
+declare class ImageEnhancer {
+    iconService: IconCacheService;
+    dataService: DataService;
+    readonly icons: typeof Icon;
+    selectedStyle: EventEmitter<EnhanceStyle>;
+    selectedProductImage: EventEmitter<string[]>;
+    selectedProductImages: EventEmitter<string[]>;
+    backButtonClicked: EventEmitter<void>;
+    showClass(): boolean;
+    prompt: string;
+    activeTab: number;
+    showMaskInfoDialog: boolean;
+    constructor(iconService: IconCacheService, dataService: DataService);
+    setTab(index: number): void;
+    handleProductImagePrompt(event: string[]): void;
+    handleProductImagesPrompt(event: string[]): void;
+    handleStylePrompt(event: EnhanceStyle): void;
+    handleBackClicked(): 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>;
+}
+
+declare class ImageUpload implements OnDestroy {
+    iconService: IconCacheService;
+    readonly icons: typeof Icon;
+    multiUpload: boolean;
+    showPreview: 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);
+    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;
+    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>;
+}
+
+declare class ImageUploadModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageUploadModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageUploadModule, [typeof ImageUpload], [typeof i2.ButtonModule, typeof i2.CoreComponentsTranslationModule, typeof PipeModule, typeof i2.IconModule], [typeof ImageUpload]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ImageUploadModule>;
+}
+
+declare class DecorationStyle {
+    label: string;
+    description: string;
+    constructor(label: string, description: string);
+}
+
+declare class ImageEnhancerStyleComponent implements OnInit {
+    connectorService: InPhotoConnectorService;
+    prompt: EventEmitter<EnhanceStyle>;
+    backButtonClicked: EventEmitter<void>;
+    get showClass(): boolean;
+    useCustomPrompt: boolean;
+    loaded: boolean;
+    styleEnhancePrompt: EnhanceStyle;
+    selectedRoomStyle: DecorationStyle;
+    roomStyleCollection: DecorationStyle[];
+    selectedMode: DecorationStyle;
+    modeCollection: DecorationStyle[];
+    selectedDecorationStyle: DecorationStyle;
+    decorationStyleCollection: DecorationStyle[];
+    constructor(connectorService: InPhotoConnectorService);
+    ngOnInit(): Promise<void>;
+    handleChangeRoomType(event: DecorationStyle): void;
+    handleChangeMode(event: DecorationStyle): void;
+    handleChangeStyle(event: DecorationStyle): void;
+    handleGenerateClicked(): void;
+    handleBackClicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageEnhancerStyleComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageEnhancerStyleComponent, "co-image-enhancer-style", never, {}, { "prompt": "prompt"; "backButtonClicked": "backButtonClicked"; }, never, never, false, never>;
+}
+
+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 ɵinj: i0.ɵɵInjectorDeclaration<ImageEnhancerStyleModule>;
+}
+
+declare class ImageEnhancerUploadComponent {
+    multiUpload: boolean;
+    prompt: EventEmitter<string[]>;
+    backButtonClicked: EventEmitter<void>;
+    showClass(): boolean;
+    disableGenerateButton: boolean;
+    useCustomPrompt: boolean;
+    uploadedImages: string[];
+    handleImageUpload(event: File[]): void;
+    handleGenerateClicked(): void;
+    handleBackClicked(): 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>;
+}
+
+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 ɵ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 ɵinj: i0.ɵɵInjectorDeclaration<ImageEnhancerModule>;
+}
+
+declare class ImageHistoryComponent {
+    dataService: DataService;
+    iconService: IconCacheService;
+    readonly icons: typeof Icon;
+    setImageAsBackground: EventEmitter<string>;
+    showClass(): boolean;
+    showFullImage: boolean;
+    fullImage: string;
+    constructor(dataService: DataService, iconService: IconCacheService);
+    handleShowFullImage(event: string): void;
+    handleCloseFullImage(): void;
+    handleSetImageAsBackground(event: string): void;
+    handleRemoveImageFromHistory(event: string): void;
+    handleDownloadImage(event: string): void;
+    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;
+    readonly icons: typeof Icon;
+    image: string;
+    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);
+    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>;
+}
+
+declare class ImageHistoryTileModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageHistoryTileModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageHistoryTileModule, [typeof ImageHistoryTileComponent], [typeof i2.ButtonModule, typeof i2.IconModule, typeof PipeModule], [typeof ImageHistoryTileComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<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 ɵ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;
+    private _connectorService;
+    private _loaderService;
+    readonly icons: typeof Icon;
+    set image(value: string);
+    get image(): string;
+    showClass(): boolean;
+    private _image;
+    constructor(iconService: IconCacheService, dataService: DataService, router: Router, navigationService: NavigationService, _connectorService: InPhotoConnectorService, _loaderService: LoaderService);
+    ngOnInit(): void;
+    handleProductImageSelected(event: string[]): void;
+    handleProductImagesSelected(productImages: string[]): void;
+    handleStyleSelection(event: EnhanceStyle): void;
+    handleSetImageFromHistory(event: string): void;
+    handleBackButtonClicked(): void;
+    handleImageUpload(event: File[]): void;
+    private _handleSetLoader;
+    private _handleImageResponse;
+    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 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 ɵinj: i0.ɵɵInjectorDeclaration<PhotoEditorModule>;
+}
+
+declare class PrepareStartingImageComponent implements OnDestroy {
+    dataService: DataService;
+    iconService: IconCacheService;
+    navigationService: NavigationService;
+    private _connectorService;
+    private _loaderService;
+    private _appEventService;
+    readonly icons: typeof Icon;
+    showClass(): boolean;
+    get getCanvasImage(): string;
+    get buttonDisabled(): boolean;
+    disableClearAllObjectsButton: boolean;
+    disableSelectObjectsButton: boolean;
+    showObjectSelectionButtons: boolean;
+    showDefaultToolbar: boolean;
+    enableObjectPicker: boolean;
+    segmentationInPaintingData: any;
+    private _nextButtonDisabled;
+    private _subs;
+    private _previewProcessedImage;
+    constructor(dataService: DataService, iconService: IconCacheService, navigationService: NavigationService, _connectorService: InPhotoConnectorService, _loaderService: LoaderService, _appEventService: AppEventService);
+    ngOnDestroy(): void;
+    handleClearAllObjects(): void;
+    handleSelectToClearObjects(): void;
+    handleSegmentationPointClick(event: SegmentationPoint): void;
+    handleClearSelectedObjects(): void;
+    handleGenerateFloorData(): void;
+    handleNextRoute(): void;
+    handleBackRoute(): 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>;
+}
+
+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 ɵ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;
+    private _interactionService;
+    private _sceneService;
+    private _objectsService;
+    private _settingService;
+    private _appEventService;
+    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>;
+    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>;
+}
+
+declare class ModelListComponent {
+    objectsService: ObjectsService;
+    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;
+    readonly icons: typeof Icon;
+    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;
+    onScaleXChange(event: Event): void;
+    onScaleYChange(event: Event): void;
+    onScaleZChange(event: Event): void;
+    toggleCollapse(): void;
+    openConfiguration(): void;
+    removeFromProject(): 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>;
+}
+
+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 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 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 class UploadStartingImageComponent {
+    iconService: IconCacheService;
+    dataService: DataService;
+    router: Router;
+    navigationService: NavigationService;
+    readonly icons: typeof Icon;
+    readonly RoutesEnum: typeof RoutesEnum;
+    showClass(): boolean;
+    get buttonDisabled(): boolean;
+    constructor(iconService: IconCacheService, dataService: DataService, router: Router, navigationService: NavigationService);
+    handleRoute(): void;
+    handleImageUpload(event: File[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadStartingImageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UploadStartingImageComponent, "co-upload-starting-image", never, {}, {}, never, never, false, never>;
+}
+
+declare class UploadStartingImageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadStartingImageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<UploadStartingImageModule, [typeof UploadStartingImageComponent], [typeof ImageUploadModule, typeof PipeModule, typeof i2.ButtonModule, typeof BackNextButtonsModule, typeof i2.IconModule], [typeof UploadStartingImageComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<UploadStartingImageModule>;
+}
+
+declare class AppInitializerService {
+    private _settingsService;
+    private _connectorService;
+    appInitialized: BehaviorSubject<boolean>;
+    constructor(_settingsService: SettingsService, _connectorService: InPhotoConnectorService);
+    initializeApp(options?: Settings): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppInitializerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppInitializerService>;
+}
+
+declare class InPhotoComponent implements OnDestroy {
+    appInitializerService: AppInitializerService;
+    navigationService: NavigationService;
+    readonly RoutesEnum: typeof RoutesEnum;
+    showClass(): boolean;
+    set settings(input: any);
+    private _subs;
+    constructor(appInitializerService: AppInitializerService, navigationService: NavigationService);
+    ngOnDestroy(): 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 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 ɵ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 };