/// <reference path="../../../../../../../typescript_definitions/declarations/All.d.ts" />
import { FocusAttributesEventListener } from '@zakeke/zakeke-3d-core';
import _ from 'lodash';
import { EventMessage, ExtensionFields, NftForm, NftSettings, OnBeforeSendDataToParent, SceneAnimationsConfig, TryOnMode, TryOnProvidersTypesMapping, VisibleEventMessage } from '.';
import { PlatformAttributeSelection } from './integrations/Integration';
import { BootParameters, Camera, Composition, FontFamily, Group, ImageMacroCategory, Item, Product, ProductQuantityRule, SellerSettings, Settings, Template, TemplateMacroCategory, TryOnGenericFineTuningSettings, TryOnProduct, TryOnSeller, AIPresetCategory, AIPreset, AIProductStagingRule, AIProductStagingOptions, AIProductStagingResult, AIVirtualTryOnOptions, AIVirtualTryOnResult, AIVirtualModelRule } from './models';
import { AxiosResponse } from 'axios';
import { DAMViewerAnalyticsEventType, PrintingMethodsRestrictions, TextSanitationResult, UIConfig, ZakekeImage } from './models';
declare global {
    interface Window {
        token: string;
        isOwin: boolean;
    }
}
interface RestrictionColor {
    colorCode: string;
    isDefault: boolean;
}
interface CustomPreviewSize {
    customCartPreviewWidth: number;
    customCartPreviewHeight: number;
}
interface ThemeCompositions {
    name: string;
    docID: string;
    previewImageUrl: string;
    tags: string[];
}
interface CurrentCompositionInfo {
    compositionId: string | null;
    compositionName: string | null;
    compositionTags: string[] | null;
}
export declare class ZakekeEnvironment {
    private booted;
    private token;
    private platformAttributesSelection;
    private settings;
    private platform;
    private viewer;
    private selection;
    private integration;
    private previewWidth;
    private previewHeight;
    private clientPreviewWidth;
    private clientPreviewHeight;
    private shareUrlPrefix;
    private events;
    private zkProduct;
    private zkScene;
    private zkCurrentTemplate;
    private zkTemplates;
    private internalIsFullscreen;
    private highlightSettings;
    private previousMeshesVisibleStates;
    private lastCameraLocation;
    private enableShareCompositionUrl;
    private sharedCompositionDocId;
    private templateId;
    deepARsceneGLBUrl: string | null;
    loadedComposition: {
        templateName: string;
        attributesOptions: Map<number, number>;
        selectedCategoryID: number | null;
    } | null;
    private savedCompositions;
    private isDraftEditor;
    private isViewerMode;
    private isDAMViewer;
    private isPresetConfigurationEditor;
    shouldLoadDesign: boolean | null;
    private debugMode;
    private draftCompositionDocId;
    private initialSelection;
    private undoStack;
    private redoStack;
    private pricingCalculator;
    currentAttributesSelection: Object | null;
    currentCompositionInfo: CurrentCompositionInfo | null;
    private copyrightMessageLocalStorageKey;
    private isPupillaryDistanceMandatory;
    isAIEnabled: boolean;
    isAIStudioShoppingPreviewEnabled: boolean;
    isAIStudioEditorEnabled: boolean;
    isAIStudioEnabled: boolean;
    isAiProductStagingEnabled: boolean;
    isAiVtoEnabled: boolean;
    private lastProductStagingGenerationTime;
    private lastVirtualTryonGenerationTime;
    /** Session ID (GUID) persisted for the lifetime of this environment instance, sent as ZKK-Session-ID header */
    private readonly aiSessionId;
    sellerSettings: SellerSettings | null;
    get internalProduct(): MPlaza.Model | null;
    get internalScene(): Zakeke.Scene | null;
    get internalCurrentTemplate(): MPlaza.Design | null | undefined;
    themeCompositions: ThemeCompositions[] | null;
    currency: string;
    groups: Group[];
    fonts: FontFamily[];
    defaultFontID: number | null;
    disableTextColors: boolean;
    textColors: RestrictionColor[];
    /**
     * Get the current text default color.
     */
    defaultColor: string;
    quantity: number;
    quantityRule: ProductQuantityRule | null;
    culture: string;
    productCode: string;
    productName: string;
    price: number;
    isOutOfStock: boolean;
    composition: any;
    compositionId: string | null;
    templates: Template[];
    currentTemplate: Template | null;
    product: Product | null;
    templateMacroCategories: TemplateMacroCategory[] | null;
    selectedTemplateCategory: string | null;
    cameras: Camera[];
    isExplodedMode: boolean;
    isAssetsLoading: boolean;
    additionalCustomProperties: ExtensionFields[];
    nftSettings: NftSettings | null;
    eventMessages: EventMessage[] | null;
    personalizedMessages: EventMessage[] | null;
    visibleEventMessages: VisibleEventMessage[];
    tryOnProvidersSettings: TryOnProvidersTypesMapping | null;
    tryOnProductSettings: TryOnProduct | null;
    tryOnSellerSettings: TryOnSeller | null;
    pdSettings: number;
    isInfoPointContentVisible: boolean;
    imagesMacroCategories: ImageMacroCategory[];
    isCompositionSaving: boolean;
    private internalTranslations;
    areTranslationsLoaded: boolean;
    private integrationVersion;
    useLegacyScreenshot: boolean;
    visibleCustomizer: MPlaza.Customizer | null;
    get isFullscreenMode(): boolean;
    get userSettings(): Settings;
    get isViewerReady(): boolean;
    get isShoppingPreview(): boolean;
    uiConfig: UIConfig | null;
    animationsConfig: SceneAnimationsConfig | null;
    backgroundColor: string | null;
    removeBackground: boolean;
    constructor();
    private fetchVisitorToken;
    private parseParameters;
    makeDAMAnalyticsView(type: DAMViewerAnalyticsEventType): Promise<AxiosResponse<any, any, {}>>;
    private getProduct;
    private getScene;
    private getComposerModels;
    private getFonts;
    getFontWeights: (font: FontFamily) => {
        normal: boolean;
        bold: boolean;
        italic: boolean;
        italicBold: boolean;
        normalWeight: number;
        boldWeight: number;
        italicWeight: number;
        italicBoldWeight: number;
    };
    private updateFontWeightForTextItem;
    checkFontSupports: (fontName: string, needsBold: boolean, needsItalic: boolean) => {
        canKeepStyles: boolean;
        supportsBold: boolean;
        supportsItalic: boolean;
    };
    private getSettings;
    private getSellerSetting;
    createQuote: (formData: any) => Promise<any>;
    private getPrice;
    private getTranslations;
    private loadLocalization;
    getTemplateMacroCategories: () => Promise<TemplateMacroCategory[]>;
    private loadScript;
    validationNFTEmail: (email: string) => boolean;
    validationNFTWalletAddress: (address: string) => boolean;
    private saveCustomerWalletInfo;
    setCopyrightMessageAccepted: (copyrightMandatoryCheckbox: boolean) => void;
    getCopyrightMessageAccepted: () => boolean;
    /**
     * @private
     */
    boot: (parameters: BootParameters | null) => Promise<void>;
    private buildDeepARSceneGLBUrl;
    stopAllAnimations: () => void;
    hasAnimations: () => boolean;
    playAnimations: () => void;
    loadSceneFromGlbUrl: (glbUrl: string, sceneConfig: Zakeke.SceneConfig) => Promise<void>;
    appendViewer: (container: HTMLElement) => void;
    /**
     * Forces a resize of the 3D viewer canvas to match its container.
     * Call this from the theme after all UI components have finished rendering
     * to fix canvas buffer/display size mismatches caused by layout reflows.
     */
    forceViewerResize: () => void;
    setHighlightSettings: (settings: {
        color: string;
        size: number;
    }) => void;
    renderDesign: () => Promise<void>;
    debouncedRefresh: _.DebouncedFunc<() => Promise<void>>;
    private updateDesignFast;
    private debouncedChange;
    restoreLastCameraLocation: () => void;
    private buildRecapProps;
    updateRecapAndExtensionField: () => void;
    private getCurrentExtensionFields;
    private handleSceneLoaded;
    private getComposition;
    private getDesign;
    private internalLoadDesign;
    private addHotjarScript;
    private addGoogleTagManagerID;
    loadComposition: (id: string | null) => Promise<void>;
    private internalLoadComposition;
    sync3DAndPlatformSelectionWithCurrentSelection: () => Promise<void>;
    private cloneSelection;
    undo: () => Promise<void>;
    redo: () => Promise<void>;
    /**
     * Reset the platform attributes selection to the current selection
     */
    private resetPlatformAttributesSelection;
    reset: () => Promise<void>;
    private handleAttributeSelectionChanged;
    private handleAttributeEnabled;
    private handleAttributeDisabled;
    private handleAttributeOptionEnabled;
    private handleAttributeOptionDisabled;
    private setAttributeSelectionEnabled;
    private setOptionSelectionEnabled;
    private isOptionEnabled;
    private updateComposition;
    setQuantity(quantity: number): void;
    private _updatePrice;
    private updatePrice;
    private buildStructure;
    private createGroupFromSelection;
    private createStep;
    private createAttributeFromSelection;
    private createOptionFromSelection;
    private createTemplateGroupFromSelection;
    private saveDesignBackbone;
    private saveCompositionBackbone;
    private trigger;
    on: (event: string, callback: any) => void;
    off: (event: string, callback: any) => void;
    setTemplate: (templateId: number) => Promise<void>;
    getTemplateUploadRestrictions: (areaId: number) => {
        isUserImageAllowed: boolean;
        isJpgAllowed: boolean;
        isPngAllowed: boolean;
        isSvgAllowed: boolean;
        isPdfAllowed: boolean;
        isEpsAllowed: boolean;
        isPdfWithRasterAllowed: boolean;
    };
    private getTemplates;
    private saveProduct;
    private getTemplate;
    updateView: () => void;
    selectOption: (optionId: number) => void;
    selectOptionsbyPrompt(prompt: string): Promise<void>;
    focusGroup: (groupId: number) => void;
    focusAttribute: (attributeId: number) => Promise<void>;
    setCamera(cameraLocationId: string, onlyAngleOfView?: boolean, animate?: boolean): void;
    getCameraByName(name: string): Zakeke.SceneCameraLocation | undefined;
    setCameraLocation(name: string, animate?: boolean): void;
    private base64StringToFile;
    saveTemplate: (templateName: string, selectedCategoryID: number | null, attributeOptions: Map<number, number>, save2dDesign?: boolean) => Promise<void>;
    addToCart: (additionalProperties: Record<string, any>, onBeforeSendDataToParent?: ((data: OnBeforeSendDataToParent) => Promise<Record<string, any>>) | undefined, legacyScreenshot?: boolean, nftForm?: NftForm, saveDesignFromTemplateEditor?: boolean) => Promise<void>;
    zoomIn: () => void;
    zoomOut: () => void;
    isFullscreenEnabled: () => boolean;
    getDesignItemsInfo(): Item[];
    switchFullscreen: () => void;
    openSecondScreen: () => void;
    private extendedUpdate;
    exportSceneToUsdz: (hash: string) => Promise<import("@zakeke/zakeke-3d-core").Nullable<string> | undefined>;
    exportSceneToGlb: () => Promise<string | Blob | null>;
    setExplodedMode: (explodedMode: boolean) => Promise<void>;
    hasExplodedMode: () => boolean;
    setBackgroundColor: (color: string, alpha: number) => void;
    getCurrentSelection: () => PlatformAttributeSelection[];
    getScreenshot: (width?: number, height?: number, legacyScreenshot?: boolean, backgroundColor?: string | null, padding?: number, camera?: Zakeke.SceneCameraLocation | null) => Promise<string>;
    private fireItemsChange;
    isAreaVisible(areaId: number): boolean;
    removeItem: (guid: string) => Promise<void>;
    addItemText(settings: {
        text: string;
        fontFamily: string;
    }, areaId: number): Promise<void>;
    setPrintingMethod(printingMethodId: number, areaId: number): Promise<void>;
    getPrintingMethods(): Array<{
        printMethodId: number;
        name: string;
    }>;
    moveItemUp: (guid: string) => void;
    moveItemDown: (guid: string) => void;
    setItemText: (guid: string, text: string) => string;
    setItemItalic: (guid: string, italic: boolean, font?: FontFamily) => void;
    setItemBold: (guid: string, bold: boolean, font?: FontFamily) => void;
    setItemColor: (guid: string, color: string) => void;
    setItemFontFamily: (guid: string, fontFamily: string) => Promise<void>;
    setItemTextOnPath: (guid: string, areaId: number, value: boolean) => void;
    fullyLoadFont(font: string | FontFamily): Promise<FontFamily>;
    sanitizeString: (family: FontFamily, text: string) => string;
    getSanitationText: (family: FontFamily, text: string) => TextSanitationResult;
    createImage: (file: File, progress?: ((percentage: number) => void) | undefined) => Promise<ZakekeImage>;
    createImageFromUrl: (url: string) => Promise<ZakekeImage>;
    addItemImage: (id: number, areaId: number) => Promise<string | null | undefined>;
    setItemImageFromFile: (guid: string, file: File, progress?: ((percentage: number) => void) | undefined) => Promise<void>;
    setItemImageFromBase64: (guid: string, base64: string) => Promise<void>;
    setItemImage: (guid: string, id: number) => Promise<void>;
    setItemSize: (guid: string, width: number, height: number) => Promise<void>;
    setItemConstraints: (guid: string, constraints: {
        canMove?: boolean;
        canResize?: boolean;
        canRotate?: boolean;
        canDelete?: boolean;
    }) => Promise<void>;
    T_static: (str: string) => any;
    T_dynamic: (str: string) => string;
    getMacroCategories: () => Promise<ImageMacroCategory[]>;
    getImages: (categoryId: number) => Promise<ZakekeImage[]>;
    setCameraPivot(meshID: string): void;
    resetCameraPivot(): void;
    setCameraZoomEnabled(enabled: boolean): void;
    setCameraByName(name: string, onlyAngleOfView?: boolean, animate?: boolean): void;
    findObjectByName(name: string): BABYLON.AbstractMesh | null | undefined;
    getPDF: () => Promise<string>;
    private rewriteShareUrl;
    getShareCompositionUrl: () => Promise<string>;
    saveCompositionCopy: (isSharing?: boolean) => Promise<any>;
    getOnlineScreenshot: (width: number, height: number, legacyScreenshot?: boolean, backgroundColor?: string, padding?: number) => Promise<{
        originalUrl: string;
        rewrittenUrl: string;
    }>;
    isSceneArOnTheFly: () => boolean | undefined;
    isArDeviceCompliant: () => boolean;
    isAndroidOrIOS: () => boolean;
    isAndroid: boolean;
    isIOS: boolean;
    private buildModelViewerUrl;
    isSceneArEnabled: () => boolean;
    private getPregeneratedARUrl;
    getQrCodeArUrl: (device: 'iOS' | 'Android') => Promise<string>;
    getMobileArUrl: () => Promise<string | null>;
    getMobileLocalArUrl: () => Promise<string>;
    openArMobile: (url: string) => void;
    private registerView;
    getMeshIDbyName: (name: string) => string | undefined;
    hightlightGroup(groupId: number): void;
    highlightAttribute(attributeId: number): void;
    /**
     * Hide a mesh and its children and save the state
     * @param meshId The mesh and childs to hide
     */
    hideMeshAndSaveState: (meshId: string) => void;
    /**
     * Restore a mesh visibility state from a previous saved one (see hideMeshAndSaveState)
     * @param meshId The mesh and childs to show
     */
    restoreMeshVisibility: (meshId: string) => void;
    /**
     * Change opacity for a specific mesh
     * @param meshId The mesh to change the opacity
     * @param opacity The opacity to set
     */
    setMeshDesignVisibility: (meshId: string, visible: boolean) => void;
    addFocusAttributesListener: (listenerFunction: FocusAttributesEventListener) => void;
    clearListeners: () => void;
    setCameraLocked: (isBlocked?: boolean) => void;
    isSceneTryOnEnabled: () => boolean;
    getTryOnUrl: (tryOnUrl?: string) => Promise<string>;
    saveComposition: (customPreviewSize?: CustomPreviewSize, legacyScreenshot?: boolean, isSharing?: boolean, saveDesignFromTemplateEditor?: boolean) => Promise<void>;
    private bootstrapComposition;
    loadSavedComposition: (docID: string) => Promise<void>;
    private updateSavedCompositions;
    themeCompositionsFromSavedCompositions: (compositions: Composition[]) => {
        name: string;
        docID: string;
        previewImageUrl: string;
        tags: string[];
    }[];
    saveDraftsComposition: (name: string, tags: string[], isCopy?: boolean) => Promise<void>;
    deleteSavedComposition: (docId: string) => Promise<void>;
    applyTemplate: (templateGroupCompositionId: number) => Promise<void>;
    configureByAI: (text: string) => Promise<void>;
    getTryOnProvidersList: () => Promise<TryOnProvidersTypesMapping | null>;
    getTryOnProductInfo: () => Promise<TryOnProduct | null>;
    getTryOnSellerInfo: (typeID: number, providerID: number) => Promise<TryOnSeller | null>;
    private getMessagesByProductCode;
    get hasVTryOnEnabled(): boolean;
    get canUseTryOn(): boolean;
    get canUsePD(): boolean;
    get isVisibleMeshShownForTryOn(): boolean;
    get isMandatoryPD(): boolean;
    get isTryOnMeshVisible(): boolean;
    get tryOnMeshVisibleSettings(): TryOnGenericFineTuningSettings | undefined;
    setPDDistance: (distance: number) => void;
    pdDistance: () => number;
    exportTryOnMeshToGlb: () => Promise<Blob | null>;
    getTryOnSettings: () => Zakeke.TryOnSettings | undefined;
    getDeepARDesktopIframeUrl: () => Promise<string>;
    tryOnCountView: (sellerID: number, providerID: number, modeChosen: TryOnMode) => Promise<void>;
    /**
     * Ottiene le restrizioni sul printing method (che nel caso di un prodotto configuratore 3D c'è sempre ed è 1 solo).
     * @remarks
     * Se non ci sono restrizioni, ritorna quelle di default
     * @returns
     * Le restrizioni sul printing method o quelle di default
     */
    getPrintingMethodsRestrictions: () => PrintingMethodsRestrictions;
    setMouseWheelZoomEnabled: (enabled: boolean) => void;
    setCameraPinchingZoom: (toggle: boolean) => void;
    get isAiEditorEnabled(): boolean;
    startAIStudio: () => Promise<void>;
    private _aiPresetCategoriesPromise;
    private _aiPresetPresetsPromise;
    private fetchAllAIPresetCategories;
    private fetchAllAIPresetPresets;
    getAIPresetCategories: (presetType: string) => Promise<AIPresetCategory[]>;
    getAIPresetPresets: (presetType: string) => Promise<AIPreset[]>;
    getApplicableAIStagingRules: (options: {
        productID?: number;
        printTypeID?: number;
    }) => Promise<AIProductStagingRule | null>;
    getApplicableAIVirtualModelRules: (options: {
        productID?: number;
        printTypeID?: number;
    }) => Promise<AIVirtualModelRule | null>;
    private fetchServicesAvailability;
    private createAIProductStagingTask;
    private pollAIProductStagingTask;
    generateAIProductStaging: (options: AIProductStagingOptions) => Promise<AIProductStagingResult>;
    private createAIVirtualTryonTask;
    private pollAIVirtualTryonTask;
    generateAIVirtualTryon: (options: AIVirtualTryOnOptions) => Promise<AIVirtualTryOnResult>;
}
export {};