@uploadcare/file-uploader 1.25.0-alpha.9 → 1.25.0

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

@@ -1,179 +1,168 @@
-import * as lit_html from 'lit-html';
-import { PropertyValues, LitElement, TemplateResult } from 'lit';
-import * as lit_html_directives_ref_js from 'lit-html/directives/ref.js';
-import { TelemetryRequest } from '@uploadcare/quality-insights';
+import { BaseComponent } from '@symbiotejs/symbiote';
 import * as _uploadcare_upload_client from '@uploadcare/upload-client';
-import { Metadata, UploadcareFile, UploadError, NetworkError, UploadcareGroup, FileFromOptions, Queue } from '@uploadcare/upload-client';
-import { Ref } from 'lit/directives/ref.js';
-
-type Constructor<T = unknown> = new (...args: any[]) => T;
-
-type SymbioteStateBag<T extends Record<string, unknown>> = T;
-/**
- * Interface for components using SymbioteMixin
- */
-declare class SymbioteComponent<TState extends Record<string, unknown> = Record<string, unknown>> {
-    $: SymbioteStateBag<TState>;
-    sub<TKey extends keyof TState>(key: TKey, callback: (value: TState[TKey]) => void, init?: boolean): () => void;
-    pub<TKey extends keyof TState>(key: TKey, value: TState[TKey]): void;
-    set$<T extends {
-        [K in keyof T]: K extends keyof TState ? TState[K] : never;
-    }>(obj: T): void;
-    has<TKey extends keyof TState>(key: TKey): boolean;
-    add<TKey extends keyof TState>(key: TKey, val: TState[TKey], rewrite?: boolean): void;
-    add$<T extends {
-        [K in keyof T]: K extends keyof TState ? TState[K] : never;
-    }>(obj: T, rewrite?: boolean): void;
-    initCallback(): void;
-    ctxName: string;
-    ctxOwner: boolean;
-}
-
-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;
-    /** WARNING: Do not rename/change this, it's used in dashboard */
-    protected dialogEl: lit_html_directives_ref_js.Ref<HTMLDialogElement>;
-    /** WARNING: Do not rename/change this, it's used in dashboard */
-    protected closeDialog: () => void;
-    private _handleDialogClose;
-    private _handleDialogMouseDown;
-    private _handleDialogMouseUp;
-    show(): void;
-    hide(): void;
-    private _handleModalOpen;
-    private _handleModalClose;
-    private _handleModalCloseAll;
-    initCallback(): void;
-    disconnectedCallback(): void;
-    private _handleDialogRef;
-    render(): lit_html.TemplateResult<1>;
-}
-
-type Subscription = {
-    remove: () => void;
-};
-
-type Uid = string & {
-    __uid: true;
-};
-
-declare function defineComponents(blockExports: Record<string, any>): void;
-
-declare const UC_WINDOW_KEY = "UC";
-type IndexModule = Record<string, any>;
-declare global {
-    interface Window {
-        [UC_WINDOW_KEY]?: IndexModule;
-    }
-}
+import { UploadcareFile, Metadata, UploadError, NetworkError, UploadcareGroup, FileFromOptions } from '@uploadcare/upload-client';
+import { TelemetryRequest } from '@uploadcare/quality-insights';
 
 type LocaleDefinition = Record<string, string>;
 
-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>;
-}
+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 TypedSchema = Record<string, {
+    type: unknown;
+    value: unknown;
+    nullable?: boolean;
 }>;
-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'>;
+type Constructor<T = any> = new (...args: any[]) => T;
+type ExtractType<T, V> = T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends NumberConstructor ? number : T extends ArrayConstructor ? V : T extends Constructor ? InstanceType<T> : T;
+type ExtractDataFromSchema<T extends TypedSchema> = {
+    [K in keyof T]: ExtractType<T[K]['type'], T[K]['value']> | (T[K]['nullable'] extends true ? null : never);
 };
-declare class EventEmitter {
-    private _timeoutStore;
-    private _targets;
-    private _debugPrint;
-    constructor(debugPrint: (...args: unknown[]) => void);
-    bindTarget(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;
+type ExtractKeysFromSchema<T extends TypedSchema> = Extract<keyof T, string>;
+declare class TypedData<T extends TypedSchema> {
+    private __typedSchema;
+    private __ctxId;
+    private __schema;
+    private __data;
+    constructor(typedSchema: T, ctxName?: string);
+    get uid(): string;
+    setValue<K extends ExtractKeysFromSchema<T>>(prop: K, value: ExtractDataFromSchema<T>[K]): void;
+    setMultipleValues(updObj: Partial<ExtractDataFromSchema<T>>): void;
+    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;
+    };
+    remove(): void;
 }
 
-declare function buildOutputCollectionState<TCollectionStatus extends OutputCollectionStatus, TGroupFlag extends GroupFlag = 'maybe-has-group'>(uploaderBlock: LitUploaderBlock): OutputCollectionState<TCollectionStatus, TGroupFlag>;
-
-declare class TypedData<T extends Record<string, unknown>> {
-    private _ctxId;
-    private _data;
-    constructor(initialValue: T);
-    get uid(): Uid;
-    setValue<K extends keyof T>(prop: K, value: T[K]): void;
-    setMultipleValues(updObj: Partial<T>): void;
-    getValue<K extends keyof T>(prop: K): T[K];
-    subscribe<K extends keyof T>(prop: K, handler: (newVal: T[K]) => void): Subscription;
-    destroy(): void;
-}
+declare const uploadEntrySchema: Readonly<{
+    file: Readonly<{
+        type: {
+            new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+            prototype: File;
+        };
+        value: null;
+        nullable: true;
+    }>;
+    externalUrl: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    fileName: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    fileSize: Readonly<{
+        type: NumberConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    lastModified: Readonly<{
+        type: NumberConstructor;
+        value: number;
+    }>;
+    uploadProgress: Readonly<{
+        type: NumberConstructor;
+        value: 0;
+    }>;
+    uuid: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    isImage: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    mimeType: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    ctxName: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    cdnUrl: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    cdnUrlModifiers: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    fileInfo: Readonly<{
+        type: typeof UploadcareFile;
+        value: null;
+        nullable: true;
+    }>;
+    isUploading: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    abortController: Readonly<{
+        type: {
+            new (): AbortController;
+            prototype: AbortController;
+        };
+        value: null;
+        nullable: true;
+    }>;
+    thumbUrl: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    silent: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    source: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    fullPath: Readonly<{
+        type: StringConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    metadata: Readonly<{
+        type: ObjectConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    errors: Readonly<{
+        type: ArrayConstructor;
+        value: OutputErrorFile[];
+    }>;
+    uploadError: Readonly<{
+        type: ErrorConstructor;
+        value: null;
+        nullable: true;
+    }>;
+    isRemoved: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    isQueuedForUploading: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    isValidationPending: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+    isQueuedForValidation: Readonly<{
+        type: BooleanConstructor;
+        value: false;
+    }>;
+}>;
 
 type FuncFileValidator = (outputEntry: OutputFileEntry, api: UploaderPublicApi, options?: {
     signal?: AbortSignal;
@@ -192,10 +181,10 @@ declare class ValidationManager {
     private _queue;
     private _runQueueDebounced;
     private _entryValidationState;
-    constructor(blockInstance: LitUploaderBlock);
-    runFileValidators(runOn: FileValidatorDescriptor['runOn'], entryIds?: Uid[]): void;
+    constructor(blockInstance: UploaderBlock);
+    runFileValidators(runOn: FileValidatorDescriptor['runOn'], entryIds?: string[]): void;
     runCollectionValidators(): void;
-    cleanupValidationForEntry(entry: TypedData<UploadEntryData>): void;
+    cleanupValidationForEntry(entry: TypedData<typeof uploadEntrySchema>): void;
     private _runFileValidatorsForEntry;
     private _addCustomTypeToValidationError;
     private _getEntryValidationState;
@@ -205,26 +194,19 @@ declare class ValidationManager {
 
 type CameraMode = 'photo' | 'video';
 
-/**
- * Config keys that can't be passed as attribute (because they are object or function)
- */
-declare const complexConfigKeys: readonly ["metadata", "localeDefinitionOverride", "secureUploadsSignatureResolver", "secureDeliveryProxyUrlResolver", "iconHrefResolver", "fileValidators", "collectionValidators", "mediaRecorderOptions"];
 /** Mapping of attribute names to state */
 declare const attrStateMapping: Record<string, string>;
-declare class Config extends LitBlock {
-    attributesMeta: Partial<ConfigPlainType> & {
-        'ctx-name': string;
-    };
-    init$: LitBlock["init$"] & ConfigType;
-    private _computationControllers;
+declare class Config extends Block {
+    requireCtxName: boolean;
+    constructor();
     private _flushValueToAttribute;
     private _flushValueToState;
     private _setValue;
     private _getValue;
-    private _assertSameValueDifferentReference;
+    _assertSameValueDifferentReference(key: string, previousValue: unknown, nextValue: unknown): void;
     initCallback(): void;
     attributeChangedCallback(name: keyof typeof attrStateMapping, oldVal: string, newVal: string): void;
-    static get observedAttributes(): string[];
+    get computationControllers(): any;
 }
 interface Config extends ConfigType {
 }
@@ -266,51 +248,6 @@ declare const UploadSource: Readonly<{
 }>;
 type SourceTypes = (typeof UploadSource)[keyof typeof UploadSource];
 
-type ChangeMap<T extends Record<string, unknown>> = Record<keyof T, Set<Uid>>;
-type TypedCollectionPropertyObserver<T extends Record<string, unknown>> = (changeMap: ChangeMap<T>) => void;
-type TypedCollectionObserverHandler<T extends Record<string, unknown>> = (list: Uid[], added: Set<TypedData<T>>, removed: Set<TypedData<T>>) => void;
-type TypedCollectionOptions<T extends Record<string, unknown>> = {
-    initialValue: T;
-    watchList?: (keyof T)[];
-    handler?: TypedCollectionObserverHandler<T>;
-};
-declare class TypedCollection<T extends Record<string, unknown>> {
-    private static readonly _destroyDelayMs;
-    private _ctxId;
-    private _data;
-    private _watchList;
-    private _subsMap;
-    private _propertyObservers;
-    private _collectionObservers;
-    private _items;
-    private _removed;
-    private _added;
-    private _markedToDestroy;
-    private _observeTimeout?;
-    private _notifyTimeout?;
-    private _destroyTimeout?;
-    private _notifyObservers;
-    private _initialValue;
-    constructor(options: TypedCollectionOptions<T>);
-    private _notify;
-    private _scheduleDestroyMarkedItems;
-    observeCollection(handler: TypedCollectionObserverHandler<T>): () => void;
-    unobserveCollection(handler: TypedCollectionObserverHandler<T>): void;
-    add(init: Partial<T>): Uid;
-    hasItem(id: Uid): boolean;
-    read(id: Uid): TypedData<T> | null;
-    readProp<K extends keyof T>(id: Uid, propName: K): T[K];
-    publishProp<K extends keyof T>(id: Uid, propName: K, value: T[K]): void;
-    remove(id: Uid): void;
-    clearAll(): void;
-    observeProperties(handler: TypedCollectionPropertyObserver<T>): () => void;
-    unobserveProperties(handler: TypedCollectionPropertyObserver<T>): void;
-    findItems(checkFn: (item: TypedData<T>) => boolean): Uid[];
-    items(): Uid[];
-    get size(): number;
-    destroy(): void;
-}
-
 declare const CameraSourceTypes: Readonly<{
     PHOTO: "photo";
     VIDEO: "video";
@@ -324,8 +261,8 @@ type ApiAddFileCommonOptions = {
 };
 declare class UploaderPublicApi {
     private _ctx;
-    constructor(ctx: LitUploaderBlock);
-    get _uploadCollection(): TypedCollection<UploadEntryData>;
+    constructor(ctx: UploaderBlock);
+    private get _uploadCollection();
     get cfg(): ConfigType;
     get l10n(): (str: string, variables?: Record<string, string | number>) => string;
     /**
@@ -348,7 +285,7 @@ declare class UploaderPublicApi {
     getOutputCollectionState<TStatus extends OutputCollectionStatus>(): ReturnType<typeof buildOutputCollectionState<TStatus>>;
     initFlow: (force?: boolean) => void;
     doneFlow: () => void;
-    setCurrentActivity: <T extends RegisteredActivityType>(activityType: T, ...params: T extends keyof ActivityParamsMap ? [ActivityParamsMap[T]] : T extends RegisteredActivityType ? [undefined?] : [never]) => void;
+    setCurrentActivity: <T extends ActivityType>(activityType: T, ...[params]: T extends keyof ActivityParamsMap ? [ActivityParamsMap[T]] : T extends RegisteredActivityType ? [undefined?] : [unknown?]) => void;
     getCurrentActivity: () => ActivityType;
     setModalState: (opened: boolean) => void;
     private get _sourceList();
@@ -648,8 +585,6 @@ type ConfigType = {
      */
     testMode: boolean;
 };
-type ConfigComplexType = Pick<ConfigType, (typeof complexConfigKeys)[number]>;
-type ConfigPlainType = Omit<ConfigType, keyof ConfigComplexType>;
 type OutputFileStatus = 'idle' | 'uploading' | 'success' | 'failed' | 'removed';
 type OutputCustomErrorType = 'CUSTOM_ERROR';
 type OutputFileErrorType = OutputCustomErrorType | 'NOT_AN_IMAGE' | 'FORBIDDEN_FILE_TYPE' | 'FILE_SIZE_EXCEEDED' | 'UPLOAD_ERROR' | 'NETWORK_ERROR' | 'UNKNOWN_ERROR';
@@ -661,9 +596,7 @@ type OutputErrorTypePayload = {
     NOT_AN_IMAGE: OutputFileErrorPayload;
     FORBIDDEN_FILE_TYPE: OutputFileErrorPayload;
     FILE_SIZE_EXCEEDED: OutputFileErrorPayload;
-    SOME_FILES_HAS_ERRORS: {
-        [k: string]: never;
-    };
+    SOME_FILES_HAS_ERRORS: {};
     TOO_MANY_FILES: {
         min: number;
         max: number;
@@ -813,58 +746,60 @@ type OutputCollectionState<TStatus extends OutputCollectionStatus = OutputCollec
     allEntries: OutputFileEntry[];
 });
 
-interface UploadEntryData extends Record<string, unknown> {
-    file: File | null;
-    externalUrl: string | null;
-    fileName: string | null;
-    fileSize: number | null;
-    lastModified: number;
-    uploadProgress: number;
-    uuid: string | null;
-    isImage: boolean;
-    mimeType: string | null;
-    ctxName: string | null;
-    cdnUrl: string | null;
-    cdnUrlModifiers: string | null;
-    fileInfo: UploadcareFile | null;
-    isUploading: boolean;
-    abortController: AbortController | null;
-    thumbUrl: string | null;
-    silent: boolean;
-    source: string | null;
-    fullPath: string | null;
-    metadata: Metadata | null;
-    errors: OutputErrorFile[];
-    uploadError: Error | null;
-    isRemoved: boolean;
-    isQueuedForUploading: boolean;
-    isValidationPending: boolean;
-    isQueuedForValidation: boolean;
-}
-
-type ActivityParams$1 = {
-    externalSourceType: string;
-};
-
-declare class CloudImageEditor extends CloudImageEditorBlock {
-    static styleAttrs: string[];
-    constructor();
-    initCallback(): void;
-}
-
 declare class SecureUploadsManager {
     private readonly _block;
     private _secureToken;
-    constructor(block: LitUploaderBlock);
+    constructor(block: UploaderBlock);
     private _debugPrint;
     getSecureToken(): Promise<SecureUploadsSignatureAndExpire | null>;
 }
 
-declare class LitUploaderBlock extends LitActivityBlock {
+type ChangeMap<T extends TypedSchema> = Record<keyof T, Set<string>>;
+type TypedCollectionPropertyObserver<T extends TypedSchema> = (changeMap: ChangeMap<T>) => void;
+type TypedCollectionObserverHandler<T extends TypedSchema> = (list: string[], added: Set<TypedData<T>>, removed: Set<TypedData<T>>) => void;
+type TypedCollectionOptions<T extends TypedSchema> = {
+    typedSchema: T;
+    watchList?: ExtractKeysFromSchema<T>[];
+    handler?: TypedCollectionObserverHandler<T>;
+    ctxName?: string;
+};
+declare class TypedCollection<T extends TypedSchema> {
+    private __typedSchema;
+    private __ctxId;
+    private __data;
+    private __watchList;
+    private __subsMap;
+    private __propertyObservers;
+    private __collectionObservers;
+    private __items;
+    private __removed;
+    private __added;
+    private __observeTimeout?;
+    private __notifyTimeout?;
+    private __notifyObservers;
+    constructor(options: TypedCollectionOptions<T>);
+    notify(): void;
+    observeCollection(handler: TypedCollectionObserverHandler<T>): () => void;
+    unobserveCollection(handler: TypedCollectionObserverHandler<T>): void;
+    add(init: Partial<ExtractDataFromSchema<T>>): string;
+    read(id: string): TypedData<T> | null;
+    readProp<K extends ExtractKeysFromSchema<T>>(id: string, propName: K): ExtractDataFromSchema<T>[K] | null;
+    publishProp<K extends ExtractKeysFromSchema<T>>(id: string, propName: K, value: ExtractDataFromSchema<T>[K]): void;
+    remove(id: string): void;
+    clearAll(): void;
+    observeProperties(handler: TypedCollectionPropertyObserver<T>): () => void;
+    unobserveProperties(handler: TypedCollectionPropertyObserver<T>): void;
+    findItems(checkFn: (item: TypedData<T>) => boolean): string[];
+    items(): string[];
+    get size(): number;
+    destroy(): void;
+}
+
+declare class UploaderBlock extends ActivityBlock {
     static extSrcList: Readonly<typeof ExternalUploadSource>;
     static sourceTypes: Readonly<typeof UploadSource>;
     protected couldBeCtxOwner: boolean;
-    private _isCtxOwner;
+    private isCtxOwner;
     private _unobserveCollection?;
     private _unobserveCollectionProperties?;
     init$: {
@@ -875,21 +810,23 @@ declare class LitUploaderBlock extends LitActivityBlock {
         '*collectionState': OutputCollectionState | null;
         '*groupInfo': _uploadcare_upload_client.UploadcareGroup | null;
         '*uploadTrigger': Set<string>;
+        '*secureUploadsManager': SecureUploadsManager | null;
         '*currentActivity': null;
         '*currentActivityParams': {};
         '*history': never[];
         '*historyBack': null;
         '*closeModal': () => void;
     };
-    private get _hasCtxOwner();
+    private get hasCtxOwner();
     initCallback(): void;
     protected get validationManager(): ValidationManager;
     get api(): UploaderPublicApi;
     getAPI(): UploaderPublicApi;
-    get uploadCollection(): TypedCollection<UploadEntryData>;
-    get secureUploadsManager(): SecureUploadsManager;
+    get uploadCollection(): TypedCollection<typeof uploadEntrySchema>;
+    destroyCtxCallback(): void;
     disconnectedCallback(): void;
     connectedCallback(): void;
+    destroyCallback(): void;
     private _initCtxOwner;
     private _observeUploadCollection;
     private _unobserveUploadCollection;
@@ -898,17 +835,13 @@ declare class LitUploaderBlock extends LitActivityBlock {
     private _handleCollectionUpdate;
     private _handleCollectionPropertiesUpdate;
     private _flushCommonUploadProgress;
-    private _openCloudImageEditor;
-    private _setInitialCrop;
+    openCloudImageEditor(): void;
+    private setInitialCrop;
     protected getMetadataFor(entryId: string): Promise<_uploadcare_upload_client.Metadata | undefined>;
     protected getUploadClientOptions(): Promise<FileFromOptions>;
     getOutputData(): OutputFileEntry[];
 }
 
-/**
- * Mapping of loading resources per operation
- */
-type LoadingOperations = Map<string, Map<string, boolean>>;
 /**
  * Image size
  */
@@ -944,18 +877,21 @@ interface CropAspectRatio {
     id: string;
     hasFreeform?: boolean;
 }
-type CropPresetList = CropAspectRatio[];
 
-type ActivityParams = {
+type ActivityParams$1 = {
     internalId: string;
 };
 
+type ActivityParams = {
+    externalSourceType: string;
+};
+
 declare const ACTIVE_PROP = "___ACTIVITY_IS_ACTIVE___";
 type ActivityParamsMap = {
-    'cloud-image-edit': ActivityParams;
-    external: ActivityParams$1;
+    'cloud-image-edit': ActivityParams$1;
+    external: ActivityParams;
 };
-declare class LitActivityBlock extends LitBlock {
+declare class ActivityBlock extends Block {
     protected historyTracked: boolean;
     private [ACTIVE_PROP]?;
     init$: {
@@ -965,7 +901,9 @@ declare class LitActivityBlock extends LitBlock {
         '*historyBack': null;
         '*closeModal': () => void;
     };
-    private _debouncedHistoryFlush;
+    _debouncedHistoryFlush: (() => void) & {
+        cancel: () => void;
+    };
     private _deactivate;
     private _activate;
     initCallback(): void;
@@ -981,23 +919,46 @@ declare class LitActivityBlock extends LitBlock {
         CLOUD_IMG_EDIT: 'cloud-image-edit';
         EXTERNAL: 'external';
     }>;
-    protected get isActivityActive(): boolean;
+    get isActivityActive(): boolean;
     get couldOpenActivity(): boolean;
     /** TODO: remove name argument */
-    protected registerActivity(_name: string, options?: {
+    registerActivity(_name: string, options?: {
         onActivate?: () => void;
         onDeactivate?: () => void;
     }): void;
-    private _unregisterActivity;
-    disconnectedCallback(): void;
+    unregisterActivity(): void;
+    destroyCallback(): void;
+    get activityKey(): string;
     get activityParams(): ActivityParamsMap[keyof ActivityParamsMap];
-    get initActivity(): string | null;
-    get doneActivity(): string | null;
+    get initActivity(): string;
+    get doneActivity(): string;
     historyBack(): void;
 }
-type RegisteredActivityType = (typeof LitActivityBlock)['activities'][keyof (typeof LitActivityBlock)['activities']];
+type RegisteredActivityType = (typeof ActivityBlock)['activities'][keyof (typeof ActivityBlock)['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";
@@ -1017,7 +978,7 @@ declare class ModalManager {
     private _activeModals;
     private _subscribers;
     private _block;
-    constructor(block: LitBlock);
+    constructor(block: Block);
     private _debugPrint;
     /**
      * Register a modal with the manager
@@ -1052,6 +1013,95 @@ 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;
@@ -1061,292 +1111,99 @@ type TelemetryEventBody = Partial<Pick<TelemetryState, 'payload' | 'config'>> &
     modalId?: string;
     eventType?: CommonEventType;
 };
-interface ITelemetryManager {
+declare class TelemetryManager {
+    private readonly _sessionId;
+    private readonly _telemetryInstance;
+    private readonly _block;
+    private _config;
+    private _initialized;
+    private _lastPayload;
+    private readonly _queue;
+    constructor(block: Block);
+    private _init;
+    private _setConfig;
+    private _formattingPayload;
+    private _excludedEvents;
     sendEvent(body: TelemetryEventBody): void;
     sendEventError(error: unknown, context?: string): void;
+    /**
+     * Method to send telemetry event for Cloud Image Editor.
+     */
     sendEventCloudImageEditor(e: MouseEvent, tabId: string, options?: Record<string, unknown>): void;
+    /**
+     * Deeply compares two objects and returns true if they are equal, false otherwise.
+     */
+    private _checkObj;
+    private get _timestamp();
+    private get _solution();
+    private get _activity();
+    private get _location();
 }
 
-declare const TabId: Readonly<{
-    readonly CROP: "crop";
-    readonly TUNING: "tuning";
-    readonly FILTERS: "filters";
-}>;
-type TabIdValue$1 = (typeof TabId)[keyof typeof TabId];
-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"];
-type FilterId = (typeof ALL_FILTERS)[number];
-declare const ALL_CROP_OPERATIONS: readonly ["rotate", "mirror", "flip"];
-type CropOperation = (typeof ALL_CROP_OPERATIONS)[number];
-/** KeypointsNumber is the number of keypoints loaded from each side of zero, not total number */
-declare const COLOR_OPERATIONS_CONFIG: Readonly<{
-    brightness: {
-        zero: number;
-        range: readonly [-100, 100];
-        keypointsNumber: number;
-    };
-    exposure: {
-        zero: number;
-        range: readonly [-500, 500];
-        keypointsNumber: number;
-    };
-    gamma: {
-        zero: number;
-        range: readonly [0, 1000];
-        keypointsNumber: number;
-    };
-    contrast: {
-        zero: number;
-        range: readonly [-100, 500];
-        keypointsNumber: number;
-    };
-    saturation: {
-        zero: number;
-        range: readonly [-100, 500];
-        keypointsNumber: number;
-    };
-    vibrance: {
-        zero: number;
-        range: readonly [-100, 500];
-        keypointsNumber: number;
-    };
-    warmth: {
-        zero: number;
-        range: readonly [-100, 100];
-        keypointsNumber: number;
-    };
-    enhance: {
-        zero: number;
-        range: readonly [0, 100];
-        keypointsNumber: number;
-    };
-    filter: {
-        zero: number;
-        range: readonly [0, 100];
-        keypointsNumber: number;
-    };
-}>;
-
-type SharedConfigState = {
-    [K in keyof ConfigType as `*cfg/${K}`]: ConfigType[K];
-};
-type BlocksRegistry = Set<LitBlock>;
-type ActivityBlockCtxState = {
-    '*currentActivity': string | null;
-    '*currentActivityParams': Record<string, unknown>;
-    '*history': (string | null)[];
-    '*historyBack': (() => void) | null;
-    '*closeModal': () => void;
-};
-type UploaderBlockCtxState = ActivityBlockCtxState & {
-    '*commonProgress': number;
-    '*uploadList': {
-        uid: Uid;
-    }[];
-    '*uploadQueue': Queue;
-    '*collectionErrors': OutputErrorCollection[];
-    '*collectionState': OutputCollectionState | null;
-    '*groupInfo': UploadcareGroup | null;
-    '*uploadTrigger': Set<Uid>;
-};
-type SolutionBlockCtxState = UploaderBlockCtxState & {
-    '*solution': string | null;
-};
-type CloudImageEditorState = {
-    '*originalUrl': string | null;
-    '*loadingOperations': LoadingOperations;
-    '*faderEl': EditorImageFader | null;
-    '*cropperEl': EditorImageCropper | null;
-    '*imgEl': HTMLImageElement | null;
-    '*imgContainerEl': HTMLElement | null;
-    '*networkProblems': boolean;
-    '*imageSize': {
-        width: number;
-        height: number;
-    } | null;
-    '*editorTransformations': Transformations;
-    '*cropPresetList': CropPresetList;
-    '*currentAspectRatio': CropAspectRatio | null;
-    '*tabList': readonly TabIdValue$1[];
-    '*tabId': TabIdValue$1;
-    '*on.retryNetwork': () => void;
-    '*on.apply': (transformations: Transformations) => void;
-    '*on.cancel': () => void;
-};
-type EditorImageCropperState = {
-    '*padding': number;
-    '*operations': {
-        rotate: number;
-        mirror: boolean;
-        flip: boolean;
-    };
-    '*imageBox': {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    '*cropBox': {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-};
-type EditorToolbarState = {
-    '*showListAspectRatio': boolean;
-    '*sliderEl': EditorSlider | null;
-    '*showSlider': boolean;
-    '*currentFilter': string;
-    '*currentOperation': string | null;
-    '*operationTooltip': string | null;
-};
-type DynamicBlockState = {
-    '*blocksRegistry': BlocksRegistry;
-    '*eventEmitter': EventEmitter;
-    '*localeManager': LocaleManager;
-    '*telemetryManager': ITelemetryManager;
-    '*a11y': A11y;
-    '*modalManager': ModalManager | null;
-};
-type DynamicUploaderBlockState = {
-    '*uploadCollection': TypedCollection<UploadEntryData>;
-    '*publicApi': UploaderPublicApi;
-    '*validationManager': ValidationManager;
-    '*secureUploadsManager': SecureUploadsManager;
-};
-type LocaleState = {
-    [K in keyof LocaleDefinition as `*l10n/${K}`]: string;
-};
-type SharedState = SolutionBlockCtxState & SharedConfigState & CloudImageEditorState & EditorImageCropperState & EditorToolbarState & DynamicBlockState & DynamicUploaderBlockState & LocaleState;
-
-declare const LitBlockBase: typeof LitElement & Constructor<{
-    willYield: boolean;
-    yield(slot: string, defaultContent?: unknown): unknown;
-}> & Constructor<{
-    getCssData(propName: string, silentCheck?: boolean): string | number | boolean | null | undefined;
-}> & Constructor<SymbioteComponent<SharedState>> & Constructor<LitElement> & {
-    reg(tagName: string): void;
-};
-declare class LitBlock extends LitBlockBase {
-    private _cfgProxy;
-    private _sharedContextInstances;
+declare class Block extends BaseComponent<any> {
+    private __cfgProxy?;
+    protected l10nProcessorSubs: Map<string, Set<{
+        remove: () => void;
+    }>>;
+    static StateConsumerScope: string | null;
     static styleAttrs: string[];
+    protected requireCtxName: boolean;
     activityType: ActivityType;
     init$: {};
-    constructor();
     l10n(str: string, variables?: Record<string, string | number>): string;
-    private _pluralize;
+    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: LitBlock) => boolean): boolean;
+    hasBlockInCtx(callback: (block: Block) => boolean): boolean;
+    setOrAddState(prop: string, newVal: any): void;
     connectedCallback(): void;
+    disconnectedCallback(): void;
     initCallback(): void;
     get testId(): string;
-    get modalManager(): ModalManager | null;
-    get telemetryManager(): ITelemetryManager;
-    get localeManager(): LocaleManager;
-    get a11y(): A11y;
-    get blocksRegistry(): Set<LitBlock>;
-    get eventEmitter(): EventEmitter;
-    disconnectedCallback(): void;
+    get modalManager(): ModalManager | undefined;
+    get telemetryManager(): TelemetryManager | {
+        sendEvent: () => void;
+        sendEventCloudImageEditor: () => void;
+        sendEventError: () => void;
+    };
+    protected get localeManager(): LocaleManager | null;
+    protected get a11y(): A11y | null;
+    protected get blocksRegistry(): Set<Block>;
+    destroyCallback(): void;
     /**
      * Called when the last block is removed from the context. Note that inheritors must run their callback before that.
      */
     protected destroyCtxCallback(): void;
-    /**
-     * Adds a shared context instance if it does not exist yet.
-     * @param key The shared state key.
-     * @param resolver The resolver function that creates the instance.
-     * @param persist Whether to persist the instance in the context if the creator block is removed. It's usually needed for those instances that depends on the current block. Defaults to false.
-     */
-    protected addSharedContextInstance<TKey extends keyof SharedState>(key: TKey, resolver: () => SharedState[TKey], { persist }?: {
-        persist?: boolean | undefined;
-    }): void;
-    private _destroySharedContextInstances;
-    protected getSharedContextInstance<TKey extends keyof SharedState, TRequired extends boolean = true>(key: TKey, isRequired?: TRequired): TRequired extends true ? NonNullable<SharedState[TKey]> : SharedState[TKey];
     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 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 {
-    attributesMeta: ({
-        uuid: string;
-    } | {
-        'cdn-url': string;
-    }) & Partial<{
-        tabs: string;
-        'crop-preset': string;
-    }> & {
-        'ctx-name': string;
-    };
+declare class CloudImageEditorBlock extends Block {
     ctxOwner: boolean;
     static styleAttrs: string[];
-    private _statusMessage;
-    private _imageSrc;
-    private _fileType;
+    private _debouncedShowLoader;
+    constructor();
     private _showLoader;
-    uuid: string | null;
-    cdnUrl: string | null;
-    cropPreset: string;
-    tabs: string | null;
-    private _hasNetworkProblems;
-    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;
-    firstUpdated(changedProperties: PropertyValues<this>): void;
-    disconnectedCallback(): void;
-    render(): lit_html.TemplateResult<1>;
-    protected updated(changedProperties: PropertyValues<this>): void;
-    private _syncTabListFromProp;
-    private _syncCropPresetState;
+    initCallback(): void;
     updateImage(): Promise<void>;
     initEditor(): Promise<void>;
 }
 
-declare class CropFrame extends LitBlock {
+declare class CropFrame extends Block {
+    private readonly _handlePointerUp;
+    private readonly _handlePointerMove;
+    private readonly _handleSvgPointerMove;
+    private readonly _backdropMaskId;
     private _backdropMask?;
     private _backdropMaskInner?;
-    private readonly _backdropMaskId;
     private _frameThumbs?;
     private _frameGuides?;
     private _draggingThumb?;
@@ -1355,14 +1212,7 @@ declare class CropFrame extends LitBlock {
     private _dragStartCrop?;
     private _frameImage?;
     private _guidesHidden;
-    private _draggingValue;
-    private readonly _svgRef;
-    private _svgReady;
-    private _pendingMaskHref;
-    private get _svgElement();
-    private get _dragging();
-    private set _dragging(value);
-    private _applyGuidesDragState;
+    constructor();
     private _shouldThumbBeDisabled;
     private _createBackdrop;
     /**
@@ -1377,56 +1227,103 @@ declare class CropFrame extends LitBlock {
     private _createGuides;
     private _createFrame;
     private _handlePointerDown;
-    private readonly _handlePointerUp;
-    private readonly _handlePointerMove;
+    private _handlePointerUp_;
+    private _handlePointerMove_;
     private _calcCropBox;
-    private readonly _handleSvgPointerMove;
+    private _handleSvgPointerMove_;
     private _updateCursor;
     private _createMask;
     private _updateMask;
     private _render;
     toggleThumbs(visible: boolean): void;
     initCallback(): void;
-    protected firstUpdated(changedProperties: PropertyValues<this>): void;
-    private _initializeSvg;
-    disconnectedCallback(): void;
-    render(): TemplateResult;
+    destroyCallback(): void;
 }
 
-declare class EditorButtonControl extends LitBlock {
-    active: boolean;
-    title: string;
-    protected icon: string;
-    protected titleProp: string;
-    protected get buttonClasses(): Record<string, boolean>;
-    private _updateHostStateClasses;
-    protected onClick(_event: MouseEvent): void;
-    connectedCallback(): void;
-    protected updated(changedProperties: PropertyValues<this>): void;
-    render(): lit_html.TemplateResult<1>;
+declare class EditorButtonControl extends Block {
+    private _titleEl?;
+    constructor();
+    initCallback(): void;
 }
 
 declare class EditorFreeformButtonControl extends EditorButtonControl {
     initCallback(): void;
-    onClick(): void;
-    private _computeTitle;
-    render(): lit_html.TemplateResult<1>;
+    handleClick(): void;
+}
+interface EditorAspectRatioButtonControl {
+    get aspectRatio(): CropAspectRatio | undefined;
+    set aspectRatio(value: CropAspectRatio | undefined);
 }
 declare class EditorAspectRatioButtonControl extends EditorButtonControl {
-    private _aspectRatio;
-    get aspectRatio(): CropAspectRatio | null;
-    set aspectRatio(value: CropAspectRatio | null);
+    constructor();
     initCallback(): void;
-    protected onClick(): void;
-    private _updateAspectRatioPresentation;
-    private _renderIcon;
-    render(): lit_html.TemplateResult<1>;
+    handleClick(): void;
+    private _renderRectBasedOnAspectRatio;
+    private _aspectRatio?;
 }
 
+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"];
+type FilterId = (typeof ALL_FILTERS)[number];
+declare const ALL_CROP_OPERATIONS: readonly ["rotate", "mirror", "flip"];
+type CropOperation = (typeof ALL_CROP_OPERATIONS)[number];
+/** KeypointsNumber is the number of keypoints loaded from each side of zero, not total number */
+declare const COLOR_OPERATIONS_CONFIG: Readonly<{
+    brightness: {
+        zero: number;
+        range: readonly [-100, 100];
+        keypointsNumber: number;
+    };
+    exposure: {
+        zero: number;
+        range: readonly [-500, 500];
+        keypointsNumber: number;
+    };
+    gamma: {
+        zero: number;
+        range: readonly [0, 1000];
+        keypointsNumber: number;
+    };
+    contrast: {
+        zero: number;
+        range: readonly [-100, 500];
+        keypointsNumber: number;
+    };
+    saturation: {
+        zero: number;
+        range: readonly [-100, 500];
+        keypointsNumber: number;
+    };
+    vibrance: {
+        zero: number;
+        range: readonly [-100, 500];
+        keypointsNumber: number;
+    };
+    warmth: {
+        zero: number;
+        range: readonly [-100, 100];
+        keypointsNumber: number;
+    };
+    enhance: {
+        zero: number;
+        range: readonly [0, 100];
+        keypointsNumber: number;
+    };
+    filter: {
+        zero: number;
+        range: readonly [0, 100];
+        keypointsNumber: number;
+    };
+}>;
+
+interface EditorCropButtonControl {
+    get operation(): CropOperation | undefined;
+    set operation(value: CropOperation | undefined);
+}
 declare class EditorCropButtonControl extends EditorButtonControl {
-    operation: CropOperation | undefined;
-    protected willUpdate(changedProperties: PropertyValues<this>): void;
-    protected onClick(e: MouseEvent): void;
+    private _operation;
+    initCallback(): void;
 }
 
 declare class EditorFilterControl extends EditorButtonControl {
@@ -1435,27 +1332,11 @@ declare class EditorFilterControl extends EditorButtonControl {
     private _originalUrl;
     private _observer?;
     private _cancelPreload?;
-    private _lastPreviewRequestId;
-    private _previewVisibilityCheckRaf?;
-    private _previewVisibilityCheckTimeout?;
-    private _previewImage;
-    private _previewLoaded;
-    isOriginal: boolean;
-    private _iconSize;
-    get filter(): string;
-    set filter(value: string);
-    onClick(e: MouseEvent): void;
+    constructor();
     private _previewSrc;
     private _observerCallback;
     initCallback(): 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>;
+    destroyCallback(): void;
 }
 
 type Operations = {
@@ -1463,7 +1344,7 @@ type Operations = {
     mirror: boolean;
     rotate: number;
 };
-declare class EditorImageCropper extends LitBlock {
+declare class EditorImageCropper extends Block {
     ctxOwner: boolean;
     private _commitDebounced;
     private _handleResizeThrottled;
@@ -1472,12 +1353,9 @@ declare class EditorImageCropper extends LitBlock {
     private _ctx;
     private _isActive;
     private _observer?;
-    private _image;
     private _cancelPreload?;
-    private readonly _canvasRef;
-    private readonly _frameRef;
     constructor();
-    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    private _handleResize;
     private _syncTransformations;
     private _initCanvas;
     private _alignImage;
@@ -1502,12 +1380,11 @@ declare class EditorImageCropper extends LitBlock {
     private _waitForImage;
     private _handleImageLoading;
     initCallback(): void;
-    disconnectedCallback(): void;
-    render(): TemplateResult;
+    destroyCallback(): void;
 }
 
 type OperationKey = keyof typeof COLOR_OPERATIONS_CONFIG;
-declare class EditorImageFader extends LitBlock {
+declare class EditorImageFader extends Block {
     private _isActive;
     private _hidden;
     private _operation;
@@ -1515,6 +1392,7 @@ declare class EditorImageFader extends LitBlock {
     private _value?;
     private _transformations;
     private _keypoints;
+    private _container?;
     private _previewImage?;
     private _cancelLastImages?;
     private _cancelBatchPreload?;
@@ -1522,8 +1400,6 @@ declare class EditorImageFader extends LitBlock {
     private _fromViewer?;
     private _raf;
     private _addKeypointDebounced;
-    private readonly _previewHostRef;
-    private readonly _layersHostRef;
     constructor();
     private _handleImageLoading;
     private _flush;
@@ -1533,6 +1409,7 @@ declare class EditorImageFader extends LitBlock {
      * Check if current operation and filter equals passed ones
      */
     private _isSame;
+    private _addKeypoint;
     set(value: string | number): void;
     private _update;
     private _createPreviewImage;
@@ -1555,194 +1432,111 @@ declare class EditorImageFader extends LitBlock {
     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;
-    protected onClick(e: MouseEvent): void;
 }
 
-declare class EditorScroller extends LitBlock {
-    private readonly _handleWheel;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
+declare class EditorScroller extends Block {
+    initCallback(): void;
 }
 
 type SliderOperation = ColorOperation | 'filter';
 type SliderFilter = FilterId | typeof FAKE_ORIGINAL_FILTER;
 declare const FAKE_ORIGINAL_FILTER = "original";
-declare class EditorSlider extends LitBlock {
-    state: {
-        operation: SliderOperation;
-        filter: SliderFilter | undefined;
-        originalUrl: string;
-        disabled: boolean;
-        min: number;
-        max: number;
-        value: number;
-        defaultValue: number;
-        zero: number;
-    };
-    private _handleInput;
+declare class EditorSlider extends Block {
+    private _operation;
+    private _filter?;
+    private _originalUrl;
+    constructor();
     setOperation(operation: SliderOperation, filter?: SliderFilter): void;
     private _initializeValues;
     apply(): void;
     cancel(): void;
     initCallback(): void;
-    protected updated(changedProperties: PropertyValues<this>): void;
-    render(): lit_html.TemplateResult<1>;
 }
 
-type TabIdValue = (typeof TabId)[keyof typeof TabId];
-declare class EditorToolbar extends LitBlock {
-    private _showLoader;
-    showMainToolbar: boolean;
-    showSubToolbar: boolean;
-    private _showTabToggles;
-    tabList: readonly TabIdValue[];
-    activeTab: TabIdValue;
-    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;
+declare class EditorToolbar extends Block {
+    private _debouncedShowLoader;
     private _cancelPreload?;
-    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 _updateInfoTooltip;
+    constructor();
     private _onSliderClose;
+    private _createOperationControl;
+    private _createFilterControl;
+    private _createToggleControl;
+    private _createAspectRatioControl;
+    private _createFreeformControl;
+    private _clearListAspectRatio;
+    private _renderControlsList;
     private _activateTab;
-    private _applyTabState;
+    private _unmountTabControls;
     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;
-    connectedCallback(): void;
-    firstUpdated(changedProperties: PropertyValues<this>): void;
-    protected updated(changedProperties: PropertyValues<this>): void;
-    disconnectedCallback(): void;
-    private _assignSharedElements;
-    private readonly _handleCancel;
-    private readonly _handleApply;
-    private readonly _handleApplySlider;
-    private readonly _handleCancelSlider;
-    private readonly _handleTabClick;
-    private _renderTabToggle;
-    private _renderTabContent;
-    render(): TemplateResult<1>;
+    destroyCallback(): void;
 }
 
-type Theme = string | null;
-declare class BtnUi extends LitBlock {
-    text: string;
-    icon: string;
-    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 BtnUi extends Block {
+    private _iconReversed;
+    private _iconSingle;
+    private _iconHidden;
+    constructor();
+    private _iconCss;
+    initCallback(): void;
+    set reverse(_value: boolean);
 }
 
-declare class LineLoaderUi extends LitBlock {
-    active: boolean;
-    private readonly _lineRef;
-    private _isAnimating;
+declare class LineLoaderUi extends Block {
+    private _active;
     private readonly _handleTransitionEndRight;
-    protected firstUpdated(changedProperties: PropertyValues<this>): void;
-    protected updated(changedProperties: PropertyValues<this>): void;
+    initCallback(): void;
     private _start;
     private _stop;
-    private _resetLine;
-    render(): lit_html.TemplateResult<1>;
 }
 
-type PresenceToggleStyle = {
-    transition?: string;
-    visible?: string;
-    hidden?: string;
-};
-declare class PresenceToggle extends LitBlock {
+declare class PresenceToggle extends Block {
     private _visible;
-    private _styles;
     private _visibleStyle;
     private _hiddenStyle;
     private _externalTransitions;
-    private _initialRenderComplete;
-    set visible(value: boolean);
-    get visible(): boolean;
-    set styles(styles: PresenceToggleStyle);
-    get styles(): PresenceToggleStyle;
+    constructor();
     private _handleVisible;
-    private _dispatchInitialRenderEvent;
     initCallback(): void;
 }
 
-declare class SliderUi extends LitBlock {
+declare class SliderUi extends Block {
     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();
-    private _emitSliderEvent;
-    private readonly _handleSliderInput;
-    private readonly _handleSliderChange;
-    private readonly _handleInputFocus;
-    private readonly _handleInputBlur;
-    protected firstUpdated(changedProperties: PropertyValues<this>): void;
-    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    initCallback(): void;
+    private _inputEl;
+    private _thumbEl;
+    private _stepsEl;
     private _updateValue;
     private _updateZeroDot;
     private _updateSteps;
-    disconnectedCallback(): void;
-    private _setCurrentValue;
-    private _syncInputValue;
-    private _extractEventValue;
-    render(): lit_html.TemplateResult<1>;
+    destroyCallback(): void;
+}
+
+declare class CloudImageEditor extends CloudImageEditorBlock {
+    static styleAttrs: string[];
+    constructor();
+    initCallback(): void;
+}
+
+declare function defineComponents(blockExports: Record<string, any>): void;
+
+declare class Icon extends Block {
+    constructor();
+    initCallback(): void;
 }
 
 export { BtnUi, CloudImageEditor, CloudImageEditorBlock, Config, CropFrame, EditorAspectRatioButtonControl, EditorCropButtonControl, EditorFilterControl, EditorFreeformButtonControl, EditorImageCropper, EditorImageFader, EditorOperationControl, EditorScroller, EditorSlider, EditorToolbar, Icon, LineLoaderUi, PresenceToggle, SliderUi, defineComponents };