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 };
