@uploadcare/file-uploader 1.24.5 → 1.25.0-alpha.1

package/web/uc-cloud-image-editor.min.d.ts

@@ -1,11 +1,122 @@
-import { BaseComponent } from '@symbiotejs/symbiote';
+import * as lit_html from 'lit-html';
+import { LitElement, PropertyValues, TemplateResult } from 'lit';
+import { PubSub } from '@symbiotejs/symbiote';
+import * as lit_html_directives_ref_js from 'lit-html/directives/ref.js';
+import { TelemetryRequest } from '@uploadcare/quality-insights';
 import * as _uploadcare_upload_client from '@uploadcare/upload-client';
 import { UploadcareFile, Metadata, UploadError, NetworkError, UploadcareGroup, FileFromOptions } from '@uploadcare/upload-client';
-import { TelemetryRequest } from '@uploadcare/quality-insights';
+import { Ref } from 'lit/directives/ref.js';
+
+type Constructor$1<T = {}> = new (...args: any[]) => T;
+
+declare class A11y {
+    private _destroyKeyUX;
+    private readonly _scopedWindow;
+    constructor();
+    registerBlock(scope: LitBlock): void;
+    destroy(): void;
+}
+
+declare class LocaleManager {
+    private _blockInstance;
+    private _localeName;
+    constructor(blockInstance: LitBlock);
+}
+
+declare class Modal extends LitBlock {
+    static styleAttrs: string[];
+    private _mouseDownTarget;
+    protected dialogEl: lit_html_directives_ref_js.Ref<HTMLDialogElement>;
+    handleModalOpen: ModalCb;
+    handleModalClose: ModalCb;
+    handleModalCloseAll: ModalCb;
+    _handleBackdropClick: () => void;
+    _closeDialog: () => void;
+    _handleDialogClose: () => void;
+    _handleDialogMouseDown: (e: MouseEvent) => void;
+    _handleDialogMouseUp: (e: MouseEvent) => void;
+    show(): void;
+    hide(): void;
+    private _handleModalOpen;
+    private _handleModalClose;
+    private _handleModalCloseAll;
+    initCallback(): void;
+    disconnectedCallback(): void;
+    private handleDialogRef;
+    render(): lit_html.TemplateResult<1>;
+}
 
 type LocaleDefinition = Record<string, string>;
 
-declare function buildOutputCollectionState<TCollectionStatus extends OutputCollectionStatus, TGroupFlag extends GroupFlag = 'maybe-has-group'>(uploaderBlock: UploaderBlock): OutputCollectionState<TCollectionStatus, TGroupFlag>;
+declare const InternalEventType: Readonly<{
+    readonly INIT_SOLUTION: "init-solution";
+    readonly CHANGE_CONFIG: "change-config";
+    readonly ACTION_EVENT: "action-event";
+    readonly ERROR_EVENT: "error-event";
+}>;
+declare const EventType: Readonly<{
+    readonly FILE_ADDED: "file-added";
+    readonly FILE_REMOVED: "file-removed";
+    readonly FILE_UPLOAD_START: "file-upload-start";
+    readonly FILE_UPLOAD_PROGRESS: "file-upload-progress";
+    readonly FILE_UPLOAD_SUCCESS: "file-upload-success";
+    readonly FILE_UPLOAD_FAILED: "file-upload-failed";
+    readonly FILE_URL_CHANGED: "file-url-changed";
+    readonly MODAL_OPEN: "modal-open";
+    readonly MODAL_CLOSE: "modal-close";
+    readonly DONE_CLICK: "done-click";
+    readonly UPLOAD_CLICK: "upload-click";
+    readonly ACTIVITY_CHANGE: "activity-change";
+    readonly COMMON_UPLOAD_START: "common-upload-start";
+    readonly COMMON_UPLOAD_PROGRESS: "common-upload-progress";
+    readonly COMMON_UPLOAD_SUCCESS: "common-upload-success";
+    readonly COMMON_UPLOAD_FAILED: "common-upload-failed";
+    readonly CHANGE: "change";
+    readonly GROUP_CREATED: "group-created";
+}>;
+type EventKey = (typeof EventType)[keyof typeof EventType];
+type InternalEventKey = (typeof InternalEventType)[keyof typeof InternalEventType];
+type EventPayload = {
+    [EventType.FILE_ADDED]: OutputFileEntry<'idle'>;
+    [EventType.FILE_REMOVED]: OutputFileEntry<'removed'>;
+    [EventType.FILE_UPLOAD_START]: OutputFileEntry<'uploading'>;
+    [EventType.FILE_UPLOAD_PROGRESS]: OutputFileEntry<'uploading'>;
+    [EventType.FILE_UPLOAD_SUCCESS]: OutputFileEntry<'success'>;
+    [EventType.FILE_UPLOAD_FAILED]: OutputFileEntry<'failed'>;
+    [EventType.FILE_URL_CHANGED]: OutputFileEntry<'success'>;
+    [EventType.MODAL_OPEN]: {
+        modalId: ModalId;
+    };
+    [EventType.MODAL_CLOSE]: {
+        modalId: ModalId;
+        hasActiveModals: boolean;
+    };
+    [EventType.ACTIVITY_CHANGE]: {
+        activity: ActivityType;
+    };
+    [EventType.UPLOAD_CLICK]: void;
+    [EventType.DONE_CLICK]: OutputCollectionState;
+    [EventType.COMMON_UPLOAD_START]: OutputCollectionState<'uploading'>;
+    [EventType.COMMON_UPLOAD_PROGRESS]: OutputCollectionState<'uploading'>;
+    [EventType.COMMON_UPLOAD_SUCCESS]: OutputCollectionState<'success'>;
+    [EventType.COMMON_UPLOAD_FAILED]: OutputCollectionState<'failed'>;
+    [EventType.CHANGE]: OutputCollectionState;
+    [EventType.GROUP_CREATED]: OutputCollectionState<'success', 'has-group'>;
+};
+declare class EventEmitter {
+    private _timeoutStore;
+    private _targets;
+    private _debugPrint;
+    constructor(debugPrint: (...args: unknown[]) => void);
+    bindTarget(target: LitBlock): void;
+    unbindTarget(target: LitBlock): void;
+    private _dispatch;
+    emit<T extends EventKey, TDebounce extends boolean | number | undefined = undefined>(type: T, payload?: TDebounce extends false | undefined ? EventPayload[T] : () => EventPayload[T], options?: {
+        debounce?: TDebounce;
+    }): void;
+}
+
+declare function buildOutputCollectionState<TCollectionStatus extends OutputCollectionStatus, TGroupFlag extends GroupFlag = 'maybe-has-group'>(uploaderBlock: LitUploaderBlock): OutputCollectionState<TCollectionStatus, TGroupFlag>;
 
 type TypedSchema = Record<string, {
     type: unknown;
@@ -30,7 +141,7 @@ declare class TypedData<T extends TypedSchema> {
     getValue<K extends ExtractKeysFromSchema<T>>(prop: K): ExtractDataFromSchema<T>[K];
     subscribe<K extends ExtractKeysFromSchema<T>>(prop: K, handler: (newVal: ExtractDataFromSchema<T>[K]) => void): {
         remove: () => void;
-        callback: Function;
+        callback: (val: unknown) => void;
     };
     remove(): void;
 }
@@ -181,7 +292,7 @@ declare class ValidationManager {
     private _queue;
     private _runQueueDebounced;
     private _entryValidationState;
-    constructor(blockInstance: UploaderBlock);
+    constructor(blockInstance: LitUploaderBlock);
     runFileValidators(runOn: FileValidatorDescriptor['runOn'], entryIds?: string[]): void;
     runCollectionValidators(): void;
     cleanupValidationForEntry(entry: TypedData<typeof uploadEntrySchema>): void;
@@ -196,9 +307,9 @@ type CameraMode = 'photo' | 'video';
 
 /** Mapping of attribute names to state */
 declare const attrStateMapping: Record<string, string>;
-declare class Config extends Block {
-    requireCtxName: boolean;
-    constructor();
+declare class Config extends LitBlock {
+    init$: LitBlock["init$"] & ConfigType;
+    private computationControllers;
     private _flushValueToAttribute;
     private _flushValueToState;
     private _setValue;
@@ -206,7 +317,7 @@ declare class Config extends Block {
     _assertSameValueDifferentReference(key: string, previousValue: unknown, nextValue: unknown): void;
     initCallback(): void;
     attributeChangedCallback(name: keyof typeof attrStateMapping, oldVal: string, newVal: string): void;
-    get computationControllers(): any;
+    static get observedAttributes(): string[];
 }
 interface Config extends ConfigType {
 }
@@ -261,7 +372,7 @@ type ApiAddFileCommonOptions = {
 };
 declare class UploaderPublicApi {
     private _ctx;
-    constructor(ctx: UploaderBlock);
+    constructor(ctx: LitUploaderBlock);
     private get _uploadCollection();
     get cfg(): ConfigType;
     get l10n(): (str: string, variables?: Record<string, string | number>) => string;
@@ -749,7 +860,7 @@ type OutputCollectionState<TStatus extends OutputCollectionStatus = OutputCollec
 declare class SecureUploadsManager {
     private readonly _block;
     private _secureToken;
-    constructor(block: UploaderBlock);
+    constructor(block: LitUploaderBlock);
     private _debugPrint;
     getSecureToken(): Promise<SecureUploadsSignatureAndExpire | null>;
 }
@@ -795,7 +906,7 @@ declare class TypedCollection<T extends TypedSchema> {
     destroy(): void;
 }
 
-declare class UploaderBlock extends ActivityBlock {
+declare class LitUploaderBlock extends LitActivityBlock {
     static extSrcList: Readonly<typeof ExternalUploadSource>;
     static sourceTypes: Readonly<typeof UploadSource>;
     protected couldBeCtxOwner: boolean;
@@ -826,7 +937,6 @@ declare class UploaderBlock extends ActivityBlock {
     destroyCtxCallback(): void;
     disconnectedCallback(): void;
     connectedCallback(): void;
-    destroyCallback(): void;
     private _initCtxOwner;
     private _observeUploadCollection;
     private _unobserveUploadCollection;
@@ -842,6 +952,10 @@ declare class UploaderBlock extends ActivityBlock {
     getOutputData(): OutputFileEntry[];
 }
 
+/**
+ * Mapping of loading resources per operation
+ */
+type LoadingOperations = Map<string, Map<string, boolean>>;
 /**
  * Image size
  */
@@ -891,7 +1005,7 @@ type ActivityParamsMap = {
     'cloud-image-edit': ActivityParams$1;
     external: ActivityParams;
 };
-declare class ActivityBlock extends Block {
+declare class LitActivityBlock extends LitBlock {
     protected historyTracked: boolean;
     private [ACTIVE_PROP]?;
     init$: {
@@ -927,38 +1041,16 @@ declare class ActivityBlock extends Block {
         onDeactivate?: () => void;
     }): void;
     unregisterActivity(): void;
-    destroyCallback(): void;
+    disconnectedCallback(): void;
     get activityKey(): string;
     get activityParams(): ActivityParamsMap[keyof ActivityParamsMap];
-    get initActivity(): string;
-    get doneActivity(): string;
+    get initActivity(): string | null;
+    get doneActivity(): string | null;
     historyBack(): void;
 }
-type RegisteredActivityType = (typeof ActivityBlock)['activities'][keyof (typeof ActivityBlock)['activities']];
+type RegisteredActivityType = (typeof LitActivityBlock)['activities'][keyof (typeof LitActivityBlock)['activities']];
 type ActivityType = RegisteredActivityType | (string & {}) | null;
 
-declare class Modal extends Block {
-    static styleAttrs: string[];
-    static StateConsumerScope: string;
-    private _mouseDownTarget;
-    handleModalOpen: ModalCb;
-    handleModalClose: ModalCb;
-    handleModalCloseAll: ModalCb;
-    constructor();
-    _handleBackdropClick: () => void;
-    _closeDialog: () => void;
-    _handleDialogClose: () => void;
-    _handleDialogMouseDown: (e: MouseEvent) => void;
-    _handleDialogMouseUp: (e: MouseEvent) => void;
-    show(): void;
-    hide(): void;
-    private _handleModalOpen;
-    private _handleModalClose;
-    private _handleModalCloseAll;
-    initCallback(): void;
-    destroyCallback(): void;
-}
-
 declare const ModalEvents: Readonly<{
     readonly ADD: "modal:add";
     readonly DELETE: "modal:delete";
@@ -978,7 +1070,7 @@ declare class ModalManager {
     private _activeModals;
     private _subscribers;
     private _block;
-    constructor(block: Block);
+    constructor(block: LitBlock);
     private _debugPrint;
     /**
      * Register a modal with the manager
@@ -1013,95 +1105,6 @@ declare class ModalManager {
     destroy(): void;
 }
 
-declare const InternalEventType: Readonly<{
-    readonly INIT_SOLUTION: "init-solution";
-    readonly CHANGE_CONFIG: "change-config";
-    readonly ACTION_EVENT: "action-event";
-    readonly ERROR_EVENT: "error-event";
-}>;
-declare const EventType: Readonly<{
-    readonly FILE_ADDED: "file-added";
-    readonly FILE_REMOVED: "file-removed";
-    readonly FILE_UPLOAD_START: "file-upload-start";
-    readonly FILE_UPLOAD_PROGRESS: "file-upload-progress";
-    readonly FILE_UPLOAD_SUCCESS: "file-upload-success";
-    readonly FILE_UPLOAD_FAILED: "file-upload-failed";
-    readonly FILE_URL_CHANGED: "file-url-changed";
-    readonly MODAL_OPEN: "modal-open";
-    readonly MODAL_CLOSE: "modal-close";
-    readonly DONE_CLICK: "done-click";
-    readonly UPLOAD_CLICK: "upload-click";
-    readonly ACTIVITY_CHANGE: "activity-change";
-    readonly COMMON_UPLOAD_START: "common-upload-start";
-    readonly COMMON_UPLOAD_PROGRESS: "common-upload-progress";
-    readonly COMMON_UPLOAD_SUCCESS: "common-upload-success";
-    readonly COMMON_UPLOAD_FAILED: "common-upload-failed";
-    readonly CHANGE: "change";
-    readonly GROUP_CREATED: "group-created";
-}>;
-type EventKey = (typeof EventType)[keyof typeof EventType];
-type InternalEventKey = (typeof InternalEventType)[keyof typeof InternalEventType];
-type EventPayload = {
-    [EventType.FILE_ADDED]: OutputFileEntry<'idle'>;
-    [EventType.FILE_REMOVED]: OutputFileEntry<'removed'>;
-    [EventType.FILE_UPLOAD_START]: OutputFileEntry<'uploading'>;
-    [EventType.FILE_UPLOAD_PROGRESS]: OutputFileEntry<'uploading'>;
-    [EventType.FILE_UPLOAD_SUCCESS]: OutputFileEntry<'success'>;
-    [EventType.FILE_UPLOAD_FAILED]: OutputFileEntry<'failed'>;
-    [EventType.FILE_URL_CHANGED]: OutputFileEntry<'success'>;
-    [EventType.MODAL_OPEN]: {
-        modalId: ModalId;
-    };
-    [EventType.MODAL_CLOSE]: {
-        modalId: ModalId;
-        hasActiveModals: boolean;
-    };
-    [EventType.ACTIVITY_CHANGE]: {
-        activity: ActivityType;
-    };
-    [EventType.UPLOAD_CLICK]: void;
-    [EventType.DONE_CLICK]: OutputCollectionState;
-    [EventType.COMMON_UPLOAD_START]: OutputCollectionState<'uploading'>;
-    [EventType.COMMON_UPLOAD_PROGRESS]: OutputCollectionState<'uploading'>;
-    [EventType.COMMON_UPLOAD_SUCCESS]: OutputCollectionState<'success'>;
-    [EventType.COMMON_UPLOAD_FAILED]: OutputCollectionState<'failed'>;
-    [EventType.CHANGE]: OutputCollectionState;
-    [EventType.GROUP_CREATED]: OutputCollectionState<'success', 'has-group'>;
-};
-declare class EventEmitter {
-    private _timeoutStore;
-    private _targets;
-    private _debugPrint;
-    constructor(debugPrint: (...args: unknown[]) => void);
-    bindTarget(target: Block): void;
-    unbindTarget(target: Block): void;
-    private _dispatch;
-    emit<T extends EventKey, TDebounce extends boolean | number | undefined = undefined>(type: T, payload?: TDebounce extends false | undefined ? EventPayload[T] : () => EventPayload[T], options?: {
-        debounce?: TDebounce;
-    }): void;
-}
-
-declare class A11y {
-    private _destroyKeyUX;
-    private readonly _scopedWindow;
-    constructor();
-    registerBlock(scope: Block): void;
-    destroy(): void;
-}
-
-type LocaleChangeCallback = () => void;
-declare class LocaleManager {
-    private _blockInstance;
-    private _localeName;
-    private _callbacks;
-    private _boundBlocks;
-    constructor(blockInstance: Block);
-    onLocaleChange(callback: LocaleChangeCallback): () => void;
-    bindL10n(block: Block, key: string, resolver: LocaleChangeCallback): void;
-    destroyL10nBindings(block: Block): void;
-    destroy(): void;
-}
-
 type CommonEventType = InternalEventKey | EventKey;
 type TelemetryState = TelemetryRequest & {
     eventTimestamp: number;
@@ -1119,7 +1122,7 @@ declare class TelemetryManager {
     private _initialized;
     private _lastPayload;
     private readonly _queue;
-    constructor(block: Block);
+    constructor(block: LitBlock);
     private _init;
     private _setConfig;
     private _formattingPayload;
@@ -1140,25 +1143,42 @@ declare class TelemetryManager {
     private get _location();
 }
 
-declare class Block extends BaseComponent<any> {
-    private __cfgProxy?;
-    protected l10nProcessorSubs: Map<string, Set<{
-        remove: () => void;
-    }>>;
-    static StateConsumerScope: string | null;
+declare const LitBlockBase: typeof LitElement & Constructor$1<{
+    yield(slot: string, defaultContent?: unknown): unknown;
+}> & Constructor$1<{
+    getCssData(propName: string, silentCheck?: boolean): string | number | boolean | null | undefined;
+}> & Constructor$1<{
+    $: {
+        [x: string]: any;
+    };
+    sub<T = unknown>(key: string, callback: (value: T) => void, init?: boolean): () => void;
+    pub(key: string, value: unknown): void;
+    set$(obj: {
+        [x: string]: any;
+    }): void;
+    has(key: string): boolean;
+    add(key: string, val: unknown, rewrite?: boolean): void;
+    add$(obj: {
+        [x: string]: any;
+    }, rewrite?: boolean): void;
+    initCallback(): void;
+    sharedCtx: PubSub<Record<string, unknown>>;
+    ctxName: string;
+}> & Constructor$1<LitElement> & {
+    reg(tagName: string): void;
+};
+declare class LitBlock extends LitBlockBase {
+    private __cfgProxy;
     static styleAttrs: string[];
-    protected requireCtxName: boolean;
     activityType: ActivityType;
     init$: {};
+    constructor();
     l10n(str: string, variables?: Record<string, string | number>): string;
     private pluralize;
-    protected bindL10n(key: string, resolver: () => void): void;
-    constructor();
     emit(type: Parameters<EventEmitter['emit']>[0], payload?: Parameters<EventEmitter['emit']>[1], options?: Parameters<EventEmitter['emit']>[2]): void;
-    hasBlockInCtx(callback: (block: Block) => boolean): boolean;
-    setOrAddState(prop: string, newVal: any): void;
+    hasBlockInCtx(callback: (block: LitBlock) => boolean): boolean;
+    setOrAddState(prop: string, newVal: unknown): void;
     connectedCallback(): void;
-    disconnectedCallback(): void;
     initCallback(): void;
     get testId(): string;
     get modalManager(): ModalManager | undefined;
@@ -1169,39 +1189,89 @@ declare class Block extends BaseComponent<any> {
     };
     protected get localeManager(): LocaleManager | null;
     protected get a11y(): A11y | null;
-    protected get blocksRegistry(): Set<Block>;
-    destroyCallback(): void;
+    protected get blocksRegistry(): Set<LitBlock>;
+    disconnectedCallback(): void;
     /**
      * Called when the last block is removed from the context. Note that inheritors must run their callback before that.
      */
     protected destroyCtxCallback(): void;
     protected proxyUrl(url: string): Promise<string>;
     get cfg(): ConfigType;
-    subConfigValue<T extends keyof ConfigType>(key: T, callback: (value: ConfigType[T]) => void): void;
+    subConfigValue<T extends keyof ConfigType>(key: T, callback: (value: ConfigType[T]) => void): () => void;
     debugPrint(...args: unknown[]): void;
-    static reg(name?: string): void;
 }
 
-declare class CloudImageEditorBlock extends Block {
+declare function initState(fnCtx: CloudImageEditorBlock): {
+    '*originalUrl': null;
+    '*loadingOperations': LoadingOperations;
+    '*faderEl': null;
+    '*cropperEl': null;
+    '*imgEl': null;
+    '*imgContainerEl': null;
+    '*networkProblems': boolean;
+    '*imageSize': null;
+    '*editorTransformations': {};
+    '*cropPresetList': never[];
+    '*currentAspectRatio': null;
+    '*tabList': readonly ["crop", "tuning", "filters"];
+    '*tabId': "crop";
+    '*on.retryNetwork': () => void;
+    '*on.apply': (transformations: Transformations) => void;
+    '*on.cancel': () => void;
+};
+
+declare class CloudImageEditorBlock extends LitBlock {
     ctxOwner: boolean;
     static styleAttrs: string[];
-    private _debouncedShowLoader;
-    constructor();
-    private _showLoader;
+    entry: unknown;
+    extension: string | null;
+    editorMode: boolean;
+    modalCaption: string;
+    isImage: boolean;
+    msg: string;
+    src: string;
+    fileType: string;
+    showLoader: boolean;
+    uuid: string | null;
+    cdnUrl: string | null;
+    cropPreset: string;
+    tabs: string | null;
+    presenceNetworkProblems: boolean;
+    presenceModalCaption: boolean;
+    presenceEditorToolbar: boolean;
+    presenceViewerToolbar: boolean;
+    private isInitialized;
+    private pendingInitUpdate;
+    private readonly _debouncedShowLoader;
+    private readonly imgRef;
+    private readonly cropperRef;
+    private readonly faderRef;
+    private readonly imgContainerRef;
+    private readonly handleImageLoad;
+    private readonly handleImageError;
+    private readonly handleRetryNetwork;
+    private scheduleInitialization;
+    init$: ReturnType<typeof initState>;
+    initCallback(): void;
+    private assignSharedElements;
+    private attachImageListeners;
+    private detachImageListeners;
+    private get imageClassName();
     /**
      * To proper work, we need non-zero size the element. So, we'll wait for it.
      */
     private _waitForSize;
-    initCallback(): void;
+    firstUpdated(_changedProperties: Map<PropertyKey, unknown>): void;
+    disconnectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    private syncTabListFromProp;
+    private syncCropPresetState;
     updateImage(): Promise<void>;
     initEditor(): Promise<void>;
 }
 
-declare class CropFrame extends Block {
-    private readonly _handlePointerUp;
-    private readonly _handlePointerMove;
-    private readonly _handleSvgPointerMove;
-    private readonly _backdropMaskId;
+declare class CropFrame extends LitBlock {
     private _backdropMask?;
     private _backdropMaskInner?;
     private _frameThumbs?;
@@ -1212,7 +1282,14 @@ declare class CropFrame extends Block {
     private _dragStartCrop?;
     private _frameImage?;
     private _guidesHidden;
-    constructor();
+    private _dragging;
+    private readonly svgRef;
+    private _svgReady;
+    private _pendingMaskHref;
+    private get _svgElement();
+    private get dragging();
+    private set dragging(value);
+    private _applyGuidesDragState;
     private _shouldThumbBeDisabled;
     private _createBackdrop;
     /**
@@ -1227,41 +1304,57 @@ declare class CropFrame extends Block {
     private _createGuides;
     private _createFrame;
     private _handlePointerDown;
-    private _handlePointerUp_;
-    private _handlePointerMove_;
+    private readonly _handlePointerUp;
+    private readonly _handlePointerMove;
     private _calcCropBox;
-    private _handleSvgPointerMove_;
+    private readonly _handleSvgPointerMove;
     private _updateCursor;
     private _createMask;
     private _updateMask;
     private _render;
     toggleThumbs(visible: boolean): void;
     initCallback(): void;
-    destroyCallback(): void;
+    protected firstUpdated(_changedProperties: PropertyValues<this>): void;
+    private _initializeSvg;
+    disconnectedCallback(): void;
+    render(): TemplateResult;
 }
 
-declare class EditorButtonControl extends Block {
-    private _titleEl?;
-    constructor();
-    initCallback(): void;
+declare class EditorButtonControl extends LitBlock {
+    active: boolean;
+    title: string;
+    icon: string;
+    titleProp: string;
+    protected get buttonClasses(): Record<string, boolean>;
+    private updateHostStateClasses;
+    protected onClick(_event: MouseEvent): void;
+    connectedCallback(): void;
+    protected updated(changedProperties: PropertyValues): void;
+    render(): lit_html.TemplateResult<1>;
 }
 
 declare class EditorFreeformButtonControl extends EditorButtonControl {
     initCallback(): void;
-    handleClick(): void;
+    onClick(): void;
+    private computeTitle;
+    render(): lit_html.TemplateResult<1>;
 }
-interface EditorAspectRatioButtonControl {
+declare class EditorAspectRatioButtonControl extends EditorButtonControl {
+    private _aspectRatio?;
     get aspectRatio(): CropAspectRatio | undefined;
     set aspectRatio(value: CropAspectRatio | undefined);
-}
-declare class EditorAspectRatioButtonControl extends EditorButtonControl {
-    constructor();
     initCallback(): void;
-    handleClick(): void;
-    private _renderRectBasedOnAspectRatio;
-    private _aspectRatio?;
+    onClick(): void;
+    private updateAspectRatioPresentation;
+    private renderIcon;
+    render(): lit_html.TemplateResult<1>;
 }
 
+declare const TabId: Readonly<{
+    readonly CROP: "crop";
+    readonly TUNING: "tuning";
+    readonly FILTERS: "filters";
+}>;
 declare const ALL_COLOR_OPERATIONS: readonly ["brightness", "exposure", "gamma", "contrast", "saturation", "vibrance", "warmth", "enhance"];
 type ColorOperation = (typeof ALL_COLOR_OPERATIONS)[number];
 declare const ALL_FILTERS: readonly ["adaris", "briaril", "calarel", "carris", "cynarel", "cyren", "elmet", "elonni", "enzana", "erydark", "fenralan", "ferand", "galen", "gavin", "gethriel", "iorill", "iothari", "iselva", "jadis", "lavra", "misiara", "namala", "nerion", "nethari", "pamaya", "sarnar", "sedis", "sewen", "sorahel", "sorlen", "tarian", "thellassan", "varriel", "varven", "vevera", "virkas", "yedis", "yllara", "zatvel", "zevcen"];
@@ -1317,13 +1410,10 @@ declare const COLOR_OPERATIONS_CONFIG: Readonly<{
     };
 }>;
 
-interface EditorCropButtonControl {
-    get operation(): CropOperation | undefined;
-    set operation(value: CropOperation | undefined);
-}
 declare class EditorCropButtonControl extends EditorButtonControl {
-    private _operation;
-    initCallback(): void;
+    operation: CropOperation | undefined;
+    protected willUpdate(_changedProperties: PropertyValues): void;
+    onClick(e: MouseEvent): void;
 }
 
 declare class EditorFilterControl extends EditorButtonControl {
@@ -1332,11 +1422,27 @@ declare class EditorFilterControl extends EditorButtonControl {
     private _originalUrl;
     private _observer?;
     private _cancelPreload?;
-    constructor();
+    private _lastPreviewRequestId;
+    private previewVisibilityCheckRaf?;
+    private previewVisibilityCheckTimeout?;
+    private previewImage;
+    private previewLoaded;
+    isOriginal: boolean;
+    iconSize: number;
+    get filter(): string;
+    set filter(value: string);
+    onClick(e: MouseEvent): void;
     private _previewSrc;
     private _observerCallback;
     initCallback(): void;
-    destroyCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    private updateFilterLabels;
+    private loadPreview;
+    private schedulePreviewVisibilityCheck;
+    private clearPreviewVisibilityChecks;
+    private get shouldShowPreview();
+    render(): lit_html.TemplateResult<1>;
 }
 
 type Operations = {
@@ -1344,7 +1450,7 @@ type Operations = {
     mirror: boolean;
     rotate: number;
 };
-declare class EditorImageCropper extends Block {
+declare class EditorImageCropper extends LitBlock {
     ctxOwner: boolean;
     private _commitDebounced;
     private _handleResizeThrottled;
@@ -1353,9 +1459,12 @@ declare class EditorImageCropper extends Block {
     private _ctx;
     private _isActive;
     private _observer?;
+    private _image;
     private _cancelPreload?;
+    private readonly canvasRef;
+    private readonly frameRef;
     constructor();
-    private _handleResize;
+    protected firstUpdated(_changedProperties: PropertyValues): void;
     private _syncTransformations;
     private _initCanvas;
     private _alignImage;
@@ -1380,11 +1489,12 @@ declare class EditorImageCropper extends Block {
     private _waitForImage;
     private _handleImageLoading;
     initCallback(): void;
-    destroyCallback(): void;
+    disconnectedCallback(): void;
+    render(): TemplateResult;
 }
 
 type OperationKey = keyof typeof COLOR_OPERATIONS_CONFIG;
-declare class EditorImageFader extends Block {
+declare class EditorImageFader extends LitBlock {
     private _isActive;
     private _hidden;
     private _operation;
@@ -1392,7 +1502,6 @@ declare class EditorImageFader extends Block {
     private _value?;
     private _transformations;
     private _keypoints;
-    private _container?;
     private _previewImage?;
     private _cancelLastImages?;
     private _cancelBatchPreload?;
@@ -1400,6 +1509,8 @@ declare class EditorImageFader extends Block {
     private _fromViewer?;
     private _raf;
     private _addKeypointDebounced;
+    private readonly _previewHostRef;
+    private readonly _layersHostRef;
     constructor();
     private _handleImageLoading;
     private _flush;
@@ -1409,7 +1520,6 @@ declare class EditorImageFader extends Block {
      * Check if current operation and filter equals passed ones
      */
     private _isSame;
-    private _addKeypoint;
     set(value: string | number): void;
     private _update;
     private _createPreviewImage;
@@ -1432,98 +1542,187 @@ declare class EditorImageFader extends Block {
     deactivate({ hide }?: {
         hide?: boolean;
     }): void;
+    private _ensurePreviewAttached;
+    private _clearLayersHost;
+    render(): TemplateResult;
 }
 
 declare class EditorOperationControl extends EditorButtonControl {
     private _operation;
+    get operation(): ColorOperation | '';
+    set operation(value: ColorOperation | '');
+    private updateOperationMetadata;
     initCallback(): void;
+    onClick(e: MouseEvent): void;
 }
 
-declare class EditorScroller extends Block {
-    initCallback(): void;
+declare class EditorScroller extends LitBlock {
+    private readonly handleWheel;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
 }
 
 type SliderOperation = ColorOperation | 'filter';
 type SliderFilter = FilterId | typeof FAKE_ORIGINAL_FILTER;
 declare const FAKE_ORIGINAL_FILTER = "original";
-declare class EditorSlider extends Block {
-    private _operation;
-    private _filter?;
-    private _originalUrl;
-    constructor();
+declare class EditorSlider extends LitBlock {
+    private state;
+    handleInput: (e: CustomEvent<{
+        value: number;
+    }>) => void;
     setOperation(operation: SliderOperation, filter?: SliderFilter): void;
     private _initializeValues;
     apply(): void;
     cancel(): void;
     initCallback(): void;
+    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
+    render(): lit_html.TemplateResult<1>;
 }
 
-declare class EditorToolbar extends Block {
-    private _debouncedShowLoader;
+type TabIdValue = (typeof TabId)[keyof typeof TabId];
+declare class EditorToolbar extends LitBlock {
+    private showLoader;
+    private showMainToolbar;
+    private showSubToolbar;
+    private showTabToggles;
+    private tabList;
+    private activeTab;
+    private useSliderPanel;
+    private tooltipVisible;
+    private operationTooltip;
+    private tabIndicatorOffset;
+    private tabIndicatorWidth;
+    private readonly sliderRef;
+    private readonly tabIndicatorRef;
+    protected readonly tabToggleRefs: Record<TabIdValue, Ref<HTMLElement>>;
+    private readonly handleWindowResize;
+    private cropPresets;
     private _cancelPreload?;
-    private _updateInfoTooltip;
-    constructor();
+    private readonly _debouncedShowLoader;
+    private readonly _updateInfoTooltip;
+    private readonly subTopToolbarStyles;
+    private readonly subBottomToolbarStyles;
+    private readonly tabContentStyles;
+    private readonly tabToggleStyles;
+    private readonly tabTogglesStyles;
+    init$: Record<string, unknown>;
     private _onSliderClose;
-    private _createOperationControl;
-    private _createFilterControl;
-    private _createToggleControl;
-    private _createAspectRatioControl;
-    private _createFreeformControl;
-    private _clearListAspectRatio;
-    private _renderControlsList;
     private _activateTab;
-    private _unmountTabControls;
+    private applyTabState;
     private _syncTabIndicator;
+    private get hasAspectRatioPicker();
+    private renderControlsByTab;
+    private renderCropTabControls;
+    private renderFilterTabControls;
+    private renderTuningTabControls;
+    private renderControlGroup;
+    private renderFreeformControl;
+    private renderAspectRatioControl;
+    private renderCropOperationControl;
+    private renderFilterControl;
+    private renderOperationControl;
+    private renderAspectRatioList;
     private _preloadEditedImage;
-    private _showLoader;
-    private _updateInfoTooltipHandler;
     initCallback(): void;
-    destroyCallback(): void;
+    connectedCallback(): void;
+    firstUpdated(_changedProperties: PropertyValues): void;
+    protected updated(changedProperties: PropertyValues): void;
+    disconnectedCallback(): void;
+    private assignSharedElements;
+    private handleCancel;
+    private handleApply;
+    private handleApplySlider;
+    private handleCancelSlider;
+    private handleTabClick;
+    private renderTabToggle;
+    private renderTabContent;
+    render(): TemplateResult<1>;
 }
 
-declare class BtnUi extends Block {
-    private _iconReversed;
-    private _iconSingle;
-    private _iconHidden;
-    constructor();
-    private _iconCss;
-    initCallback(): void;
-    set reverse(_value: boolean);
+type Theme = string | null;
+declare class BtnUi extends LitBlock {
+    text: string;
+    icon: string;
+    active: boolean;
+    reverse: boolean;
+    theme: Theme;
+    ariaRole: string;
+    ariaControls: string;
+    titleProp: string;
+    protected firstUpdated(_changed: PropertyValues<this>): void;
+    protected updated(changed: PropertyValues<this>): void;
+    private applyReverse;
+    private applyThemeClass;
+    private get iconClassMap();
+    private get computedIconHidden();
+    private get computedIconSingle();
+    render(): lit_html.TemplateResult<1>;
 }
 
-declare class LineLoaderUi extends Block {
-    private _active;
-    private readonly _handleTransitionEndRight;
-    initCallback(): void;
-    private _start;
-    private _stop;
+declare class LineLoaderUi extends LitBlock {
+    active: boolean;
+    private readonly lineRef;
+    private _isAnimating;
+    private readonly handleTransitionEndRight;
+    protected firstUpdated(_changedProperties: PropertyValues<this>): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    private start;
+    private stop;
+    private resetLine;
+    render(): lit_html.TemplateResult<1>;
 }
 
-declare class PresenceToggle extends Block {
+type PresenceToggleStyle = {
+    transition?: string;
+    visible?: string;
+    hidden?: string;
+};
+declare class PresenceToggle extends LitBlock {
     private _visible;
+    private _styles;
     private _visibleStyle;
     private _hiddenStyle;
     private _externalTransitions;
-    constructor();
+    private initialRenderComplete;
+    set visible(value: boolean);
+    get visible(): boolean;
+    set styles(styles: PresenceToggleStyle);
+    get styles(): PresenceToggleStyle;
     private _handleVisible;
+    private dispatchInitialRenderEvent;
     initCallback(): void;
 }
 
-declare class SliderUi extends Block {
+declare class SliderUi extends LitBlock {
     private _observer?;
     private _thumbSize;
-    private _zero;
     private _zeroDotEl?;
     private _stepsCount?;
+    private readonly inputRef;
+    private readonly thumbRef;
+    private readonly stepsRef;
+    disabled: boolean;
+    min: number;
+    max: number;
+    defaultValue: number;
+    zero: number;
+    private _currentValue;
     constructor();
-    initCallback(): void;
-    private _inputEl;
-    private _thumbEl;
-    private _stepsEl;
+    private emitSliderEvent;
+    private readonly handleSliderInput;
+    private readonly handleSliderChange;
+    private readonly handleInputFocus;
+    private readonly handleInputBlur;
+    protected firstUpdated(changedProperties: Map<PropertyKey, unknown>): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
     private _updateValue;
     private _updateZeroDot;
     private _updateSteps;
-    destroyCallback(): void;
+    disconnectedCallback(): void;
+    private _setCurrentValue;
+    private _syncInputValue;
+    private _extractEventValue;
+    render(): lit_html.TemplateResult<1>;
 }
 
 declare class CloudImageEditor extends CloudImageEditorBlock {
@@ -1534,9 +1733,14 @@ declare class CloudImageEditor extends CloudImageEditorBlock {
 
 declare function defineComponents(blockExports: Record<string, any>): void;
 
-declare class Icon extends Block {
-    constructor();
+declare class Icon extends LitBlock {
+    name: string;
+    private resolvedHref;
+    private iconHrefResolver;
     initCallback(): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    private updateResolvedHref;
+    render(): lit_html.TemplateResult<1>;
 }
 
 export { BtnUi, CloudImageEditor, CloudImageEditorBlock, Config, CropFrame, EditorAspectRatioButtonControl, EditorCropButtonControl, EditorFilterControl, EditorFreeformButtonControl, EditorImageCropper, EditorImageFader, EditorOperationControl, EditorScroller, EditorSlider, EditorToolbar, Icon, LineLoaderUi, PresenceToggle, SliderUi, defineComponents };