@uploadcare/file-uploader 1.25.0-alpha.2 → 1.25.0-alpha.4

package/dist/index.d.ts

@@ -1,24 +1,80 @@
-import { PubSub } from '@symbiotejs/symbiote';
-export { PubSub as Data, PubSub, UID } from '@symbiotejs/symbiote';
+import { LitElement, PropertyValues, nothing, TemplateResult } from 'lit';
 export { loadFileUploaderFrom } from './abstract/loadFileUploaderFrom.js';
 import * as lit_html from 'lit-html';
-import * as lit_html_directives_ref_js from 'lit-html/directives/ref.js';
-import { nothing, LitElement, PropertyValues, TemplateResult } from 'lit';
 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 { UploadcareFile, Metadata, UploadError, NetworkError, UploadcareGroup, FileFromOptions, Queue } from '@uploadcare/upload-client';
 export { Metadata, NetworkError, UploadError, UploadcareError, UploadcareFile, UploadcareGroup } from '@uploadcare/upload-client';
 import { Ref } from 'lit/directives/ref.js';
 export { PACKAGE_NAME, PACKAGE_VERSION } from './env.js';
 
+type Subscription = {
+    remove: () => void;
+};
+declare class PubSub<T extends Record<string, unknown> = Record<string, unknown>> {
+    private static _contexts;
+    private _store;
+    private constructor();
+    pub<K extends keyof T>(key: K, value: T[K]): void;
+    sub<K extends keyof T>(key: K, callback: (value: T[K]) => void, init?: boolean): Subscription;
+    read<K extends keyof T>(key: K): T[K];
+    add<K extends keyof T>(key: K, value: T[K], rewrite?: boolean): void;
+    has(key: keyof T): boolean;
+    get store(): T;
+    static registerCtx<T extends Record<string, unknown>>(initialValue: T, ctxId: string): PubSub<T>;
+    static deleteCtx(ctxId: string): void;
+    static getCtx<T extends Record<string, unknown> = Record<string, unknown>>(ctxId: string): PubSub<T> | null;
+    static hasCtx(ctxId: string): boolean;
+}
+
+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 const BaseComponent_base: typeof LitElement & Constructor<{
+    willYield: boolean;
+    yield(slot: string, defaultContent?: unknown): unknown;
+}> & Constructor<{
+    getCssData(propName: string, silentCheck?: boolean): string | number | boolean | null | undefined;
+}> & Constructor<SymbioteComponent<Record<string, unknown>>> & Constructor<LitElement> & {
+    reg(tagName: string): void;
+};
+declare class BaseComponent extends BaseComponent_base {
+}
+
+type Uid = string & {
+    __uid: true;
+};
+
+declare class UID {
+    static generate(): Uid;
+}
+
 declare function defineComponents(blockExports: Record<string, any>): void;
 
 type LocaleDefinition = Record<string, string>;
 type LocaleDefinitionResolver = () => Promise<LocaleDefinition>;
 declare const defineLocale: (localeName: string, definitionOrResolver: LocaleDefinition | LocaleDefinitionResolver) => void;
 
-type Constructor$1<T = {}> = new (...args: any[]) => T;
-
 declare class A11y {
     private _destroyKeyUX;
     private readonly _scopedWindow;
@@ -39,165 +95,48 @@ type EventMap = {
 
 declare function buildOutputCollectionState<TCollectionStatus extends OutputCollectionStatus, TGroupFlag extends GroupFlag = 'maybe-has-group'>(uploaderBlock: LitUploaderBlock): OutputCollectionState<TCollectionStatus, TGroupFlag>;
 
-type TypedSchema = Record<string, {
-    type: unknown;
-    value: unknown;
-    nullable?: boolean;
-}>;
-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);
-};
-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: (val: unknown) => void;
-    };
+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;
     remove(): 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 UploadEntryData = ExtractDataFromSchema<typeof uploadEntrySchema>;
-type UploadEntryTypedData = TypedData<typeof uploadEntrySchema>;
-type UploadEntryKeys = ExtractKeysFromSchema<typeof uploadEntrySchema>;
+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 UploadEntryTypedData = TypedData<UploadEntryData>;
+type UploadEntryKeys = keyof UploadEntryData;
 
 type FuncFileValidator = (outputEntry: OutputFileEntry, api: UploaderPublicApi, options?: {
     signal?: AbortSignal;
@@ -217,9 +156,9 @@ declare class ValidationManager {
     private _runQueueDebounced;
     private _entryValidationState;
     constructor(blockInstance: LitUploaderBlock);
-    runFileValidators(runOn: FileValidatorDescriptor['runOn'], entryIds?: string[]): void;
+    runFileValidators(runOn: FileValidatorDescriptor['runOn'], entryIds?: Uid[]): void;
     runCollectionValidators(): void;
-    cleanupValidationForEntry(entry: TypedData<typeof uploadEntrySchema>): void;
+    cleanupValidationForEntry(entry: TypedData<UploadEntryData>): void;
     private _runFileValidatorsForEntry;
     private _addCustomTypeToValidationError;
     private _getEntryValidationState;
@@ -227,16 +166,7 @@ declare class ValidationManager {
     private _getValidatorDescriptorsForEntry;
 }
 
-type CameraDeviceOption = {
-    text: string;
-    value: string;
-};
-type AudioDeviceOption = {
-    text: string;
-    value: string;
-};
 type CameraMode = 'photo' | 'video';
-type CameraStatus = 'shot' | 'retake' | 'accept' | 'play' | 'stop' | 'pause' | 'resume';
 declare class CameraSource extends LitUploaderBlock {
     couldBeCtxOwner: boolean;
     activityType: "camera";
@@ -254,34 +184,37 @@ declare class CameraSource extends LitUploaderBlock {
     private _cameraDevices;
     private _audioDevices;
     private _permissionResponses;
-    private timerRef;
-    private lineRef;
-    private videoRef;
-    private switcherRef;
+    private _permissionCleanupFns;
+    private _currentVideoSource;
+    private readonly _handlePreviewPlay;
+    private readonly _handlePreviewPause;
+    private _timerRef;
+    private _lineRef;
+    private _videoRef;
+    private _switcherRef;
     private _startTime;
     private _elapsedTime;
-    protected video: MediaStream | null;
-    protected videoTransformCss: string | null;
-    protected videoHidden: boolean;
-    protected messageHidden: boolean;
-    protected requestBtnHidden: boolean;
-    protected cameraSelectOptions: CameraDeviceOption[];
-    protected cameraSelectHidden: boolean;
-    protected l10nMessage: string;
-    protected timerHidden: boolean;
-    protected cameraHidden: boolean;
-    protected cameraActionsHidden: boolean;
-    protected audioSelectOptions: AudioDeviceOption[];
-    protected audioSelectHidden: boolean;
-    protected audioSelectDisabled: boolean;
-    protected audioToggleMicrophoneHidden: boolean;
-    protected tabCameraHidden: boolean;
-    protected tabVideoHidden: boolean;
-    protected currentIcon: string;
-    protected currentTimelineIcon: string;
-    protected toggleMicrophoneIcon: string;
-    protected mutableClassButton: string;
-    _chooseActionWithCamera: () => void;
+    private _videoTransformCss;
+    private _videoHidden;
+    private _messageHidden;
+    private _requestBtnHidden;
+    private _cameraSelectOptions;
+    private _cameraSelectHidden;
+    private _l10nMessage;
+    private _timerHidden;
+    private _cameraHidden;
+    private _cameraActionsHidden;
+    private _audioSelectOptions;
+    private _audioSelectHidden;
+    private _audioSelectDisabled;
+    private _audioToggleMicrophoneHidden;
+    private _tabCameraHidden;
+    private _tabVideoHidden;
+    private _currentIcon;
+    private _currentTimelineIcon;
+    private _toggleMicrophoneIcon;
+    private _mutableClassButton;
+    private _chooseActionWithCamera;
     private _handleCameraSelectChange;
     private _handleAudioSelectChange;
     private _handleRequestPermissions;
@@ -291,49 +224,59 @@ declare class CameraSource extends LitUploaderBlock {
     private _handleRetake;
     private _handleAccept;
     private _handleClickTab;
-    _updateTimer: () => void;
-    _startTimer: () => void;
-    _stopTimer: () => void;
-    _startTimeline: () => void;
-    _stopTimeline: () => void;
-    _animationFrameId: number | null;
-    _startRecording: () => void;
+    private _updateTimer;
+    private _startTimer;
+    private _stopTimer;
+    private _startTimeline;
+    private _stopTimeline;
+    private _animationFrameId;
+    private _startRecording;
     private _stopRecording;
     /** This method is used to toggle recording pause/resume */
-    _toggleRecording: () => void;
-    _toggleEnableAudio: () => void;
+    private _toggleRecording;
+    private _toggleEnableAudio;
     /**
      * Previewing the video that was recorded on the camera
      */
     private _previewVideo;
-    _retake: () => void;
-    _accept: () => void;
-    _handlePhoto: (status: CameraStatus) => void;
-    _handleVideo: (status: CameraStatus) => void;
+    private _attachPreviewListeners;
+    private _detachPreviewListeners;
+    private _setVideoSource;
+    /**
+     * Do not bind srcObject directly in the template, because it stops video pausing on shot.
+     * I really don'y know why but that's how it is. Assigning srcObject manually fixes the issue.
+     */
+    private _applyVideoSource;
+    private _retake;
+    private _accept;
+    private _handlePhoto;
+    private _handleVideo;
     private _setCameraState;
     private _shot;
     private _handleActiveTab;
     private _createFile;
-    _guessExtensionByMime(mime: string | undefined): string;
+    private _guessExtensionByMime;
     /**
      * The send file to the server
      */
-    _toSend: (file: File) => void;
+    private _toSend;
     private get _cameraModes();
     private _setPermissionsState;
-    _makeStreamInactive: () => boolean;
-    _stopCapture: () => void;
-    _capture: () => Promise<void>;
-    _handlePermissionsChange: () => void;
-    _permissionAccess: () => Promise<void>;
-    _getPermission: () => void;
-    _requestDeviceAccess: () => Promise<void>;
-    _getDevices: () => Promise<void>;
-    _onActivate: () => Promise<void>;
-    _onDeactivate: () => Promise<void>;
-    _handleCameraModes: (cameraModes: CameraMode[]) => void;
+    private _makeStreamInactive;
+    private _stopCapture;
+    private _capture;
+    private _handlePermissionsChange;
+    private _permissionAccess;
+    private _teardownPermissionListeners;
+    private _requestDeviceAccess;
+    private _getDevices;
+    private _onActivate;
+    private _onDeactivate;
+    private _handleCameraModes;
     initCallback(): void;
-    _destroy(): void;
+    firstUpdated(changedProperties: PropertyValues<this>): void;
+    updated(changedProperties: PropertyValues<this>): void;
+    private _destroy;
     disconnectedCallback(): void;
     render(): lit_html.TemplateResult<1>;
 }
@@ -345,13 +288,16 @@ declare const complexConfigKeys: readonly ["metadata", "localeDefinitionOverride
 /** 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;
+    private _computationControllers;
     private _flushValueToAttribute;
     private _flushValueToState;
     private _setValue;
     private _getValue;
-    _assertSameValueDifferentReference(key: string, previousValue: unknown, nextValue: unknown): void;
+    private _assertSameValueDifferentReference;
     initCallback(): void;
     attributeChangedCallback(name: keyof typeof attrStateMapping, oldVal: string, newVal: string): void;
     static get observedAttributes(): string[];
@@ -362,23 +308,23 @@ interface Config extends ConfigType {
 type FilesViewMode = 'grid' | 'list';
 declare class UploadList extends LitUploaderBlock {
     couldBeCtxOwner: boolean;
-    historyTracked: boolean;
+    protected historyTracked: boolean;
     activityType: "upload-list";
-    private doneBtnVisible;
-    private doneBtnEnabled;
-    private uploadBtnVisible;
-    private addMoreBtnVisible;
-    private addMoreBtnEnabled;
-    private commonErrorMessage;
-    private hasFiles;
+    private _doneBtnVisible;
+    private _doneBtnEnabled;
+    private _uploadBtnVisible;
+    private _addMoreBtnVisible;
+    private _addMoreBtnEnabled;
+    private _commonErrorMessage;
+    private _hasFiles;
     private _latestSummary;
-    protected get headerText(): string;
+    private get _headerText();
     private _handleAdd;
     private _handleUpload;
     private _handleDone;
     private _handleCancel;
     private _throttledHandleCollectionUpdate;
-    protected _updateUploadsState(): void;
+    private _updateUploadsState;
     private _getHeaderText;
     get couldOpenActivity(): boolean;
     initCallback(): void;
@@ -458,7 +404,7 @@ declare class UploaderPublicApi {
     getOutputCollectionState<TStatus extends OutputCollectionStatus>(): ReturnType<typeof buildOutputCollectionState<TStatus>>;
     initFlow: (force?: boolean) => void;
     doneFlow: () => void;
-    setCurrentActivity: <T extends ActivityType>(activityType: T, ...params: T extends keyof ActivityParamsMap ? [ActivityParamsMap[T]] : T extends RegisteredActivityType ? [undefined?] : [any?]) => void;
+    setCurrentActivity: <T extends RegisteredActivityType>(activityType: T, ...params: T extends keyof ActivityParamsMap ? [ActivityParamsMap[T]] : T extends RegisteredActivityType ? [undefined?] : [never]) => void;
     getCurrentActivity: () => ActivityType;
     setModalState: (opened: boolean) => void;
     private get _sourceList();
@@ -780,7 +726,9 @@ type OutputErrorTypePayload = {
     NOT_AN_IMAGE: OutputFileErrorPayload;
     FORBIDDEN_FILE_TYPE: OutputFileErrorPayload;
     FILE_SIZE_EXCEEDED: OutputFileErrorPayload;
-    SOME_FILES_HAS_ERRORS: {};
+    SOME_FILES_HAS_ERRORS: {
+        [k: string]: never;
+    };
     TOO_MANY_FILES: {
         min: number;
         max: number;
@@ -938,43 +886,42 @@ declare class SecureUploadsManager {
     getSecureToken(): Promise<SecureUploadsSignatureAndExpire | null>;
 }
 
-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>[];
+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>;
-    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;
+declare class TypedCollection<T extends Record<string, unknown>> {
+    private _ctxId;
+    private _data;
+    private _watchList;
+    private _subsMap;
+    private _propertyObservers;
+    private _collectionObservers;
+    private _items;
+    private _removed;
+    private _added;
+    private _observeTimeout?;
+    private _notifyTimeout?;
+    private _notifyObservers;
+    private _initialValue;
     constructor(options: TypedCollectionOptions<T>);
-    notify(): void;
+    private _notify;
     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;
+    add(init: Partial<T>): string;
+    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): string[];
-    items(): string[];
+    findItems(checkFn: (item: TypedData<T>) => boolean): Uid[];
+    items(): Uid[];
     get size(): number;
     destroy(): void;
 }
@@ -983,7 +930,7 @@ declare class LitUploaderBlock extends LitActivityBlock {
     static extSrcList: Readonly<typeof ExternalUploadSource>;
     static sourceTypes: Readonly<typeof UploadSource>;
     protected couldBeCtxOwner: boolean;
-    private isCtxOwner;
+    private _isCtxOwner;
     private _unobserveCollection?;
     private _unobserveCollectionProperties?;
     init$: {
@@ -1001,13 +948,13 @@ declare class LitUploaderBlock extends LitActivityBlock {
         '*historyBack': null;
         '*closeModal': () => void;
     };
-    private get hasCtxOwner();
+    private get _hasCtxOwner();
     initCallback(): void;
     protected get validationManager(): ValidationManager;
     get api(): UploaderPublicApi;
     getAPI(): UploaderPublicApi;
-    get uploadCollection(): TypedCollection<typeof uploadEntrySchema>;
-    destroyCtxCallback(): void;
+    get uploadCollection(): TypedCollection<UploadEntryData>;
+    get secureUploadsManager(): SecureUploadsManager;
     disconnectedCallback(): void;
     connectedCallback(): void;
     private _initCtxOwner;
@@ -1018,8 +965,8 @@ declare class LitUploaderBlock extends LitActivityBlock {
     private _handleCollectionUpdate;
     private _handleCollectionPropertiesUpdate;
     private _flushCommonUploadProgress;
-    openCloudImageEditor(): void;
-    private setInitialCrop;
+    private _openCloudImageEditor;
+    private _setInitialCrop;
     protected getMetadataFor(entryId: string): Promise<_uploadcare_upload_client.Metadata | undefined>;
     protected getUploadClientOptions(): Promise<FileFromOptions>;
     getOutputData(): OutputFileEntry[];
@@ -1071,6 +1018,7 @@ interface CropAspectRatio {
     id: string;
     hasFreeform?: boolean;
 }
+type CropPresetList = CropAspectRatio[];
 
 type ActivityParams$1 = {
     internalId: string;
@@ -1079,14 +1027,14 @@ declare class CloudImageEditorActivity extends LitUploaderBlock {
     couldBeCtxOwner: boolean;
     activityType: "cloud-image-edit";
     private _entry?;
-    private editorConfig;
+    private _editorConfig;
     get activityParams(): ActivityParams$1;
     initCallback(): void;
-    handleApply(e: CustomEvent<ApplyResult>): void;
-    handleCancel(event?: Event): void;
+    private _handleApply;
+    private _handleCancel;
     handleChange(event: CustomEvent<ChangeResult>): void;
-    mountEditor(): void;
-    unmountEditor(): void;
+    private _mountEditor;
+    private _unmountEditor;
     render(): lit_html.TemplateResult<1> | typeof nothing;
     private _createEditorConfig;
 }
@@ -1098,36 +1046,37 @@ declare class ExternalSource extends LitUploaderBlock {
     couldBeCtxOwner: boolean;
     activityType: "external";
     private _messageBridge?;
-    private iframeRef;
+    private _iframeRef;
     private _latestSelectionSummary;
-    private selectedList;
-    private isSelectionReady;
-    private isDoneBtnEnabled;
-    private couldSelectAll;
-    private couldDeselectAll;
-    private showSelectionStatus;
-    private showDoneBtn;
-    private doneBtnTextClass;
-    private toolbarVisible;
-    private get counterText();
+    private _selectedList;
+    private _isSelectionReady;
+    private _isDoneBtnEnabled;
+    private _couldSelectAll;
+    private _couldDeselectAll;
+    private _showSelectionStatus;
+    private _showDoneBtn;
+    private _doneBtnTextClass;
+    private _toolbarVisible;
+    private get _counterText();
     get activityParams(): ActivityParams;
     initCallback(): void;
-    private extractUrlFromSelectedFile;
-    private handleToolbarStateChange;
-    private handleSelectedFilesChange;
-    private handleIframeLoad;
-    private applyTheme;
-    private applyEmbedCss;
-    private setupL10n;
-    private remoteUrl;
+    private _extractUrlFromSelectedFile;
+    private _handleToolbarStateChange;
+    private _handleSelectedFilesChange;
+    private _handleIframeLoad;
+    private _applyTheme;
+    private _applyEmbedCss;
+    private _setupL10n;
+    private _remoteUrl;
     private _handleDone;
     private _handleCancel;
     private _handleSelectAll;
     private _handleDeselectAll;
     private _setSelectionSummary;
-    private mountIframe;
-    private unmountIframe;
-    private resetSelectionStatus;
+    private _mountIframe;
+    private _unmountIframe;
+    private _resetSelectionStatus;
+    disconnectedCallback(): void;
     render(): lit_html.TemplateResult<1>;
 }
 
@@ -1146,9 +1095,7 @@ declare class LitActivityBlock extends LitBlock {
         '*historyBack': null;
         '*closeModal': () => void;
     };
-    _debouncedHistoryFlush: (() => void) & {
-        cancel: () => void;
-    };
+    private _debouncedHistoryFlush;
     private _deactivate;
     private _activate;
     initCallback(): void;
@@ -1164,16 +1111,15 @@ declare class LitActivityBlock extends LitBlock {
         CLOUD_IMG_EDIT: 'cloud-image-edit';
         EXTERNAL: 'external';
     }>;
-    get isActivityActive(): boolean;
+    protected get isActivityActive(): boolean;
     get couldOpenActivity(): boolean;
     /** TODO: remove name argument */
-    registerActivity(_name: string, options?: {
+    protected registerActivity(_name: string, options?: {
         onActivate?: () => void;
         onDeactivate?: () => void;
     }): void;
-    unregisterActivity(): void;
+    private _unregisterActivity;
     disconnectedCallback(): void;
-    get activityKey(): string;
     get activityParams(): ActivityParamsMap[keyof ActivityParamsMap];
     get initActivity(): string | null;
     get doneActivity(): string | null;
@@ -1242,8 +1188,7 @@ declare class EventEmitter {
     private _targets;
     private _debugPrint;
     constructor(debugPrint: (...args: unknown[]) => void);
-    bindTarget(target: LitBlock): void;
-    unbindTarget(target: LitBlock): 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;
@@ -1259,87 +1204,210 @@ type TelemetryEventBody = Partial<Pick<TelemetryState, 'payload' | 'config'>> &
     modalId?: string;
     eventType?: CommonEventType;
 };
-declare class TelemetryManager {
-    private readonly _sessionId;
-    private readonly _telemetryInstance;
-    private readonly _block;
-    private _config;
-    private _initialized;
-    private _lastPayload;
-    private readonly _queue;
-    constructor(block: LitBlock);
-    private _init;
-    private _setConfig;
-    private _formattingPayload;
-    private _excludedEvents;
+interface ITelemetryManager {
     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 LitBlockBase: typeof LitElement & Constructor$1<{
+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 BlockCtxState = Record<string, never>;
+type ActivityBlockCtxState = BlockCtxState & {
+    '*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>;
+    '*secureUploadsManager': SecureUploadsManager;
+};
+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': Set<LitBlock>;
+    '*eventEmitter': EventEmitter;
+    '*localeManager': LocaleManager;
+    '*telemetryManager': ITelemetryManager;
+    '*a11y': A11y;
+    '*modalManager': ModalManager | null;
+};
+type DynamicUploaderBlockState = {
+    '*uploadCollection': TypedCollection<UploadEntryData> | null;
+    '*publicApi': UploaderPublicApi;
+    '*validationManager': ValidationManager;
+};
+type LocaleState = {
+    [key: `*l10n/${string}`]: 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$1<{
+}> & Constructor<{
     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> & {
+}> & Constructor<SymbioteComponent<SharedState>> & Constructor<LitElement> & {
     reg(tagName: string): void;
 };
 declare class LitBlock extends LitBlockBase {
-    private __cfgProxy;
+    private _cfgProxy;
+    private _sharedContextInstances;
     static styleAttrs: string[];
     activityType: ActivityType;
     init$: {};
     constructor();
     l10n(str: string, variables?: Record<string, string | number>): string;
-    private pluralize;
+    private _pluralize;
     emit(type: Parameters<EventEmitter['emit']>[0], payload?: Parameters<EventEmitter['emit']>[1], options?: Parameters<EventEmitter['emit']>[2]): void;
     hasBlockInCtx(callback: (block: LitBlock) => boolean): boolean;
-    setOrAddState(prop: string, newVal: unknown): void;
     connectedCallback(): void;
     initCallback(): void;
     get testId(): string;
-    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<LitBlock>;
+    get modalManager(): ModalManager | null;
+    get telemetryManager(): ITelemetryManager;
+    get localeManager(): LocaleManager;
+    get a11y(): A11y;
+    get blocksRegistry(): Set<LitBlock>;
+    get eventEmitter(): EventEmitter;
     disconnectedCallback(): 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;
@@ -1349,15 +1417,11 @@ declare class LitBlock extends LitBlockBase {
 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;
+    private _dialogEl;
+    private _closeDialog;
+    private _handleDialogClose;
+    private _handleDialogMouseDown;
+    private _handleDialogMouseUp;
     show(): void;
     hide(): void;
     private _handleModalOpen;
@@ -1365,7 +1429,7 @@ declare class Modal extends LitBlock {
     private _handleModalCloseAll;
     initCallback(): void;
     disconnectedCallback(): void;
-    private handleDialogRef;
+    private _handleDialogRef;
     render(): lit_html.TemplateResult<1>;
 }
 
@@ -1423,81 +1487,334 @@ declare class ModalManager {
     destroy(): void;
 }
 
-declare class ActivityHeader extends LitActivityBlock {
+type KebabCase<T extends string> = T extends `${infer Head} ${infer Tail}` ? `${Lowercase<Head>}-${KebabCase<Tail>}` : Lowercase<T>;
+declare const toKebabCase: <T extends string>(str: T) => KebabCase<T>;
+
+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 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;
-};
+type CssPropValue = string | number | undefined | null;
+declare const ImgConfig_base: typeof LitElement & Constructor<LitElement> & {
+    reg(tagName: string): void;
+} & Constructor<{
+    getCssData(propName: string, silentCheck?: boolean): string | number | boolean | null | undefined;
+}>;
+declare class ImgConfig extends ImgConfig_base {
+    private _state;
+    private _subscribers;
+    private _isnObserver;
+    private _observed;
+    createRenderRoot(): HTMLElement | ShadowRoot;
+    constructor();
+    protected $$(key: string): unknown;
+    protected set$$(kvObj: Record<string, CssPropValue>): void;
+    protected sub$$<T = unknown>(key: string, kbFn: (val: T) => void): void;
+    private _notify;
+    protected analyticsParams(): string;
+    protected initAttributes(el: HTMLElement): void;
+    protected initIntersection(el: HTMLElement, cbkFn: () => void): void;
+    connectedCallback(): void;
+    private _initCssProperties;
+    disconnectedCallback(): void;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _oldVal: string | null, newVal: string | null): void;
+}
 
-declare class CloudImageEditorBlock extends LitBlock {
-    ctxOwner: boolean;
-    static styleAttrs: string[];
-    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>;
+declare class ImgBase extends ImgConfig {
+    private _img;
+    private _imgPreview;
+    private _fmtAbs;
+    private _validateSize;
+    private _getCdnModifiers;
+    private _getTypedCssValue;
+    private _getUrlBase;
+    private _proxyUrl;
+    protected _getElSize(el: HTMLElement, k?: number, wOnly?: boolean): string | null;
+    private _setupEventProxy;
+    protected get img(): HTMLImageElement;
+    private get _currentImg();
+    private get _hasPreviewImage();
+    private get _bgSelector();
+    private get _breakpoints();
+    private get _hasFormatJPG();
+    private _renderBg;
+    private _getSrcset;
+    private _getSrc;
+    private get _srcUrlPreview();
+    private _renderBackground;
+    private _appendURL;
+    private _setupConfigForImage;
+    private _loaderImage;
+    private _renderImage;
+    protected init(): void;
+}
+
+declare class Img extends ImgBase {
+    attributesMeta: {
+        src: string;
+    } | {
+        uuid: string;
+    };
+    connectedCallback(): void;
+}
+
+declare class FormInput extends LitUploaderBlock {
+    propertiesMeta: {
+        'ctx-name': string;
+    };
+    private _validationInputElement;
+    private _dynamicInputsContainer;
+    private _createValidationInput;
+    initCallback(): void;
+}
+
+declare class Copyright extends LitBlock {
     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: 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 LitBlock {
-    private _backdropMask?;
+declare class ProgressBar extends LitBlock {
+    value: number;
+    visible: boolean;
+    private _progressValue;
+    private readonly _fakeProgressLineRef;
+    private readonly _handleFakeProgressAnimation;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    disconnectedCallback(): void;
+    private _normalizeProgressValue;
+    private _updateProgressValueStyle;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class ProgressBarCommon extends LitUploaderBlock {
+    private _unobserveCollectionCb?;
+    private _visible;
+    private _value;
+    constructor();
+    initCallback(): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    disconnectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
+type SelectOption = {
+    text: string;
+    value: string;
+};
+declare class Select extends LitBlock {
+    value: string;
+    disabled: boolean;
+    options: SelectOption[];
+    render(): lit_html.TemplateResult<1>;
+    private _handleChange;
+}
+
+declare class SourceBtn extends LitUploaderBlock {
+    couldBeCtxOwner: boolean;
+    private _registeredTypes;
+    type?: string;
+    private _iconName;
+    private _srcTypeKey;
+    private _initTypes;
+    initCallback(): void;
+    private _registerType;
+    activate(): void;
+    private _applyType;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class SourceList extends LitBlock {
+    private _rawSourceList;
+    private _cameraModes;
+    initCallback(): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    private _updateSources;
+    private _sources;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class Spinner extends LitBlock {
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class FileItemConfig extends LitUploaderBlock {
+    private _entrySubs;
+    protected entry: UploadEntryTypedData | null;
+    protected withEntry<A extends unknown[], R>(fn: (entry: UploadEntryTypedData, ...args: A) => R): (...args: A) => R | undefined;
+    protected subEntry<K extends UploadEntryKeys>(prop: K, handler: (value: UploadEntryData[K]) => void): void;
+    protected reset(): void;
+    disconnectedCallback(): void;
+}
+
+declare class Thumb extends FileItemConfig {
+    badgeIcon: string;
+    uid: Uid;
+    private _thumbUrl;
+    private _renderedGridOnce;
+    private _thumbRect;
+    private _isIntersecting;
+    private _firstViewMode;
+    private _observer?;
+    private _pendingThumbUpdate?;
+    private _calculateThumbSize;
+    private _generateThumbnail;
+    private _debouncedGenerateThumb;
+    private _decodeImage;
+    private _cancelPendingThumbUpdate;
+    private _scheduleThumbUpdate;
+    private _requestThumbGeneration;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    private _observerCallback;
+    protected reset(): void;
+    private _bindToEntry;
+    initCallback(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
+declare class ActivityHeader extends LitActivityBlock {
+}
+
+declare class StartFrom extends LitActivityBlock {
+    protected historyTracked: boolean;
+    activityType: ActivityType;
+    initCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
+type EventListenerMap = {
+    [K in (typeof EventType)[keyof typeof EventType]]: (e: CustomEvent<EventPayload[K]>) => void;
+};
+declare class UploadCtxProvider extends LitUploaderBlock {
+    propertiesMeta: {
+        'ctx-name': string;
+    };
+    static styleAttrs: string[];
+    static 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";
+    }>;
+    private _unbindEventEmitter;
+    initCallback(): void;
+    disconnectedCallback(): void;
+}
+interface UploadCtxProvider extends LitUploaderBlock {
+    addEventListener<T extends keyof EventListenerMap>(type: T, listener: EventListenerMap[T], options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<T extends keyof EventListenerMap>(type: T, listener: EventListenerMap[T], options?: boolean | EventListenerOptions): void;
+}
+
+declare class UrlSource extends LitUploaderBlock {
+    couldBeCtxOwner: boolean;
+    activityType: ActivityType;
+    private _formState;
+    initCallback(): void;
+    private _inputRef;
+    private _handleInput;
+    private _handleUpload;
+    render(): lit_html.TemplateResult<1>;
+}
+
+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;
+    };
+    ctxOwner: boolean;
+    static styleAttrs: string[];
+    private _statusMessage;
+    private _imageSrc;
+    private _fileType;
+    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;
+    updateImage(): Promise<void>;
+    initEditor(): Promise<void>;
+}
+
+declare class CropFrame extends LitBlock {
+    private _backdropMask?;
     private _backdropMaskInner?;
     private _frameThumbs?;
     private _frameGuides?;
@@ -1507,13 +1824,13 @@ declare class CropFrame extends LitBlock {
     private _dragStartCrop?;
     private _frameImage?;
     private _guidesHidden;
-    private _dragging;
-    private readonly svgRef;
+    private _draggingValue;
+    private readonly _svgRef;
     private _svgReady;
     private _pendingMaskHref;
     private get _svgElement();
-    private get dragging();
-    private set dragging(value);
+    private get _dragging();
+    private set _dragging(value);
     private _applyGuidesDragState;
     private _shouldThumbBeDisabled;
     private _createBackdrop;
@@ -1539,7 +1856,7 @@ declare class CropFrame extends LitBlock {
     private _render;
     toggleThumbs(visible: boolean): void;
     initCallback(): void;
-    protected firstUpdated(_changedProperties: PropertyValues<this>): void;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
     private _initializeSvg;
     disconnectedCallback(): void;
     render(): TemplateResult;
@@ -1548,97 +1865,37 @@ declare class CropFrame extends LitBlock {
 declare class EditorButtonControl extends LitBlock {
     active: boolean;
     title: string;
-    icon: string;
-    titleProp: string;
+    protected icon: string;
+    protected titleProp: string;
     protected get buttonClasses(): Record<string, boolean>;
-    private updateHostStateClasses;
+    private _updateHostStateClasses;
     protected onClick(_event: MouseEvent): void;
     connectedCallback(): void;
-    protected updated(changedProperties: PropertyValues): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
     render(): lit_html.TemplateResult<1>;
 }
 
 declare class EditorFreeformButtonControl extends EditorButtonControl {
     initCallback(): void;
     onClick(): void;
-    private computeTitle;
+    private _computeTitle;
     render(): lit_html.TemplateResult<1>;
 }
 declare class EditorAspectRatioButtonControl extends EditorButtonControl {
-    private _aspectRatio?;
-    get aspectRatio(): CropAspectRatio | undefined;
-    set aspectRatio(value: CropAspectRatio | undefined);
+    private _aspectRatio;
+    get aspectRatio(): CropAspectRatio | null;
+    set aspectRatio(value: CropAspectRatio | null);
     initCallback(): void;
-    onClick(): void;
-    private updateAspectRatioPresentation;
-    private renderIcon;
+    protected 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"];
-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;
-    };
-}>;
-
 declare class EditorCropButtonControl extends EditorButtonControl {
     operation: CropOperation | undefined;
-    protected willUpdate(_changedProperties: PropertyValues): void;
-    onClick(e: MouseEvent): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    protected onClick(e: MouseEvent): void;
 }
 
 declare class EditorFilterControl extends EditorButtonControl {
@@ -1648,12 +1905,12 @@ declare class EditorFilterControl extends EditorButtonControl {
     private _observer?;
     private _cancelPreload?;
     private _lastPreviewRequestId;
-    private previewVisibilityCheckRaf?;
-    private previewVisibilityCheckTimeout?;
-    private previewImage;
-    private previewLoaded;
+    private _previewVisibilityCheckRaf?;
+    private _previewVisibilityCheckTimeout?;
+    private _previewImage;
+    private _previewLoaded;
     isOriginal: boolean;
-    iconSize: number;
+    private _iconSize;
     get filter(): string;
     set filter(value: string);
     onClick(e: MouseEvent): void;
@@ -1662,11 +1919,11 @@ declare class EditorFilterControl extends EditorButtonControl {
     initCallback(): void;
     disconnectedCallback(): void;
     protected updated(changedProperties: PropertyValues<this>): void;
-    private updateFilterLabels;
-    private loadPreview;
-    private schedulePreviewVisibilityCheck;
-    private clearPreviewVisibilityChecks;
-    private get shouldShowPreview();
+    private _updateFilterLabels;
+    private _loadPreview;
+    private _schedulePreviewVisibilityCheck;
+    private _clearPreviewVisibilityChecks;
+    private get _shouldShowPreview();
     render(): lit_html.TemplateResult<1>;
 }
 
@@ -1686,10 +1943,10 @@ declare class EditorImageCropper extends LitBlock {
     private _observer?;
     private _image;
     private _cancelPreload?;
-    private readonly canvasRef;
-    private readonly frameRef;
+    private readonly _canvasRef;
+    private readonly _frameRef;
     constructor();
-    protected firstUpdated(_changedProperties: PropertyValues): void;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
     private _syncTransformations;
     private _initCanvas;
     private _alignImage;
@@ -1776,13 +2033,13 @@ declare class EditorOperationControl extends EditorButtonControl {
     private _operation;
     get operation(): ColorOperation | '';
     set operation(value: ColorOperation | '');
-    private updateOperationMetadata;
+    private _updateOperationMetadata;
     initCallback(): void;
-    onClick(e: MouseEvent): void;
+    protected onClick(e: MouseEvent): void;
 }
 
 declare class EditorScroller extends LitBlock {
-    private readonly handleWheel;
+    private readonly _handleWheel;
     connectedCallback(): void;
     disconnectedCallback(): void;
 }
@@ -1791,76 +2048,84 @@ type SliderOperation = ColorOperation | 'filter';
 type SliderFilter = FilterId | typeof FAKE_ORIGINAL_FILTER;
 declare const FAKE_ORIGINAL_FILTER = "original";
 declare class EditorSlider extends LitBlock {
-    private state;
-    handleInput: (e: CustomEvent<{
+    state: {
+        operation: SliderOperation;
+        filter: SliderFilter | undefined;
+        originalUrl: string;
+        disabled: boolean;
+        min: number;
+        max: number;
         value: number;
-    }>) => void;
+        defaultValue: number;
+        zero: number;
+    };
+    private _handleInput;
     setOperation(operation: SliderOperation, filter?: SliderFilter): void;
     private _initializeValues;
     apply(): void;
     cancel(): void;
     initCallback(): void;
-    protected updated(changedProperties: Map<PropertyKey, unknown>): 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;
-    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;
+    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;
+    private readonly _handleWindowResize;
+    private _cropPresets;
     private _cancelPreload?;
     private readonly _debouncedShowLoader;
     private readonly _updateInfoTooltip;
-    private readonly subTopToolbarStyles;
-    private readonly subBottomToolbarStyles;
-    private readonly tabContentStyles;
-    private readonly tabToggleStyles;
-    private readonly tabTogglesStyles;
+    private readonly _subTopToolbarStyles;
+    private readonly _subBottomToolbarStyles;
+    private readonly _tabContentStyles;
+    private readonly _tabToggleStyles;
+    private readonly _tabTogglesStyles;
     init$: Record<string, unknown>;
     private _onSliderClose;
     private _activateTab;
-    private applyTabState;
+    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 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;
     initCallback(): void;
     connectedCallback(): void;
-    firstUpdated(_changedProperties: PropertyValues): void;
-    protected updated(changedProperties: PropertyValues): void;
+    firstUpdated(changedProperties: PropertyValues<this>): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
     disconnectedCallback(): void;
-    private assignSharedElements;
-    private handleCancel;
-    private handleApply;
-    private handleApplySlider;
-    private handleCancelSlider;
-    private handleTabClick;
-    private renderTabToggle;
-    private renderTabContent;
+    private _assignSharedElements;
+    private readonly _handleCancel;
+    private readonly _handleApply;
+    private readonly _handleApplySlider;
+    private readonly _handleCancelSlider;
+    private readonly _handleTabClick;
+    private _renderTabToggle;
+    private _renderTabContent;
     render(): TemplateResult<1>;
 }
 
@@ -1874,26 +2139,26 @@ declare class BtnUi extends LitBlock {
     ariaRole: string;
     ariaControls: string;
     titleProp: string;
-    protected firstUpdated(_changed: PropertyValues<this>): void;
+    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();
+    private _applyReverse;
+    private _applyThemeClass;
+    private get _iconClassMap();
+    private get _computedIconHidden();
+    private get _computedIconSingle();
     render(): lit_html.TemplateResult<1>;
 }
 
 declare class LineLoaderUi extends LitBlock {
     active: boolean;
-    private readonly lineRef;
+    private readonly _lineRef;
     private _isAnimating;
-    private readonly handleTransitionEndRight;
-    protected firstUpdated(_changedProperties: PropertyValues<this>): void;
+    private readonly _handleTransitionEndRight;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
     protected updated(changedProperties: PropertyValues<this>): void;
-    private start;
-    private stop;
-    private resetLine;
+    private _start;
+    private _stop;
+    private _resetLine;
     render(): lit_html.TemplateResult<1>;
 }
 
@@ -1908,13 +2173,13 @@ declare class PresenceToggle extends LitBlock {
     private _visibleStyle;
     private _hiddenStyle;
     private _externalTransitions;
-    private initialRenderComplete;
+    private _initialRenderComplete;
     set visible(value: boolean);
     get visible(): boolean;
     set styles(styles: PresenceToggleStyle);
     get styles(): PresenceToggleStyle;
     private _handleVisible;
-    private dispatchInitialRenderEvent;
+    private _dispatchInitialRenderEvent;
     initCallback(): void;
 }
 
@@ -1923,9 +2188,9 @@ declare class SliderUi extends LitBlock {
     private _thumbSize;
     private _zeroDotEl?;
     private _stepsCount?;
-    private readonly inputRef;
-    private readonly thumbRef;
-    private readonly stepsRef;
+    private readonly _inputRef;
+    private readonly _thumbRef;
+    private readonly _stepsRef;
     disabled: boolean;
     min: number;
     max: number;
@@ -1933,12 +2198,12 @@ declare class SliderUi extends LitBlock {
     zero: number;
     private _currentValue;
     constructor();
-    private emitSliderEvent;
-    private readonly handleSliderInput;
-    private readonly handleSliderChange;
-    private readonly handleInputFocus;
-    private readonly handleInputBlur;
-    protected firstUpdated(changedProperties: Map<PropertyKey, unknown>): void;
+    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;
     private _updateValue;
     private _updateZeroDot;
@@ -1950,11 +2215,6 @@ declare class SliderUi extends LitBlock {
     render(): lit_html.TemplateResult<1>;
 }
 
-declare class Copyright extends LitBlock {
-    initCallback(): void;
-    render(): lit_html.TemplateResult<1>;
-}
-
 declare class DropArea extends LitUploaderBlock {
     static styleAttrs: string[];
     disabled: boolean;
@@ -1963,15 +2223,15 @@ declare class DropArea extends LitUploaderBlock {
     fullscreen: boolean;
     initflow: boolean;
     text?: string;
-    private isEnabled;
-    private isVisible;
-    private get localizedText();
+    private _isEnabled;
+    private _isVisible;
+    private get _localizedText();
     private _destroyDropzone;
     private _destroyContentWrapperDropzone;
-    private contentWrapperRef;
-    private readonly handleAreaInteraction;
-    private sourceListAllowsLocal;
-    private clickableListenersAttached;
+    private _contentWrapperRef;
+    private readonly _handleAreaInteraction;
+    private _sourceListAllowsLocal;
+    private _clickableListenersAttached;
     isActive(): boolean;
     initCallback(): void;
     protected willUpdate(changedProperties: PropertyValues<this>): void;
@@ -1979,45 +2239,33 @@ declare class DropArea extends LitUploaderBlock {
     /** Ignore drop events if there are other visible drop areas on the page. */
     private _shouldIgnore;
     private _couldHandleFiles;
-    private updateIsEnabled;
-    private updateVisibility;
-    private updateDragStateAttribute;
-    private updateClickableListeners;
+    private _updateIsEnabled;
+    private _updateVisibility;
+    private _updateDragStateAttribute;
+    private _updateClickableListeners;
     disconnectedCallback(): void;
     render(): lit_html.TemplateResult<1>;
 }
 
-type EntrySubscription = ReturnType<UploadEntryTypedData['subscribe']>;
-declare class FileItemConfig extends LitUploaderBlock {
-    protected _entrySubs: Set<EntrySubscription>;
-    protected _entry: UploadEntryTypedData | null;
-    protected _withEntry<A extends unknown[], R>(fn: (entry: UploadEntryTypedData, ...args: A) => R): (...args: A) => R | undefined;
-    protected _subEntry<K extends UploadEntryKeys>(prop: K, handler: (value: UploadEntryData[K]) => void): void;
-    protected _reset(): void;
-    disconnectedCallback(): void;
-}
-
 declare class FileItem extends FileItemConfig {
-    couldBeCtxOwner: boolean;
-    pauseRender: boolean;
-    uid: string;
-    protected itemName: string;
-    protected errorText: string;
-    protected hint: string;
-    protected progressValue: number;
-    protected progressVisible: boolean;
-    protected badgeIcon: string;
-    protected isFinished: boolean;
-    protected isFailed: boolean;
-    protected isUploading: boolean;
-    protected isFocused: boolean;
-    protected isEditable: boolean;
-    protected showFileNames: boolean;
-    protected ariaLabelStatusFile: string;
+    protected couldBeCtxOwner: boolean;
+    private _pauseRender;
+    uid: Uid;
+    private _itemName;
+    private _errorText;
+    private _hint;
+    private _progressValue;
+    private _progressVisible;
+    private _badgeIcon;
+    private _isFinished;
+    private _isFailed;
+    private _isUploading;
+    private _isFocused;
+    private _isEditable;
+    private _showFileNames;
+    private _ariaLabelStatusFile;
     private _renderedOnce;
     private _observer?;
-    protected _isIntersecting: boolean;
-    protected _thumbRect?: DOMRectReadOnly;
     private _handleEdit;
     private _handleRemove;
     private _handleUploadClick;
@@ -2025,7 +2273,7 @@ declare class FileItem extends FileItemConfig {
     private _debouncedCalculateState;
     private _updateHintAndProgress;
     private _handleState;
-    _reset(): void;
+    protected reset(): void;
     private _observerCallback;
     private _handleEntryId;
     private _updateShowFileNames;
@@ -2033,266 +2281,19 @@ declare class FileItem extends FileItemConfig {
     initCallback(): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
-    upload: () => Promise<void> | undefined;
+    private _upload;
     static activeInstances: Set<FileItem>;
-    protected shouldUpdate(_changedProperties: PropertyValues): boolean;
-    render(): lit_html.TemplateResult<1>;
-}
-
-declare class FormInput extends LitUploaderBlock {
-    _validationInputElement: HTMLInputElement | null;
-    _dynamicInputsContainer: HTMLDivElement | null;
-    _createValidationInput(): HTMLInputElement;
-    initCallback(): void;
-}
-
-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 const ImgTypeEnum: Readonly<{
-    PREVIEW: "PREVIEW";
-    MAIN: "MAIN";
-}>;
-
-type CssPropValue = string | number | undefined | null;
-declare const ImgConfig_base: typeof LitElement & Constructor$1<LitElement> & {
-    reg(tagName: string): void;
-} & Constructor$1<{
-    getCssData(propName: string, silentCheck?: boolean): string | number | boolean | null | undefined;
-}>;
-declare class ImgConfig extends ImgConfig_base {
-    private _state;
-    private _subscribers;
-    private _isnObserver;
-    private _observed;
-    createRenderRoot(): HTMLElement | ShadowRoot;
-    constructor();
-    $$(key: string): unknown;
-    set$$(kvObj: Record<string, CssPropValue>): void;
-    sub$$<T = unknown>(key: string, kbFn: (val: T) => void): void;
-    private _notify;
-    analyticsParams(): string;
-    initAttributes(el: HTMLElement): void;
-    initIntersection(el: HTMLElement, cbkFn: () => void): void;
-    connectedCallback(): void;
-    private _initCssProperties;
-    disconnectedCallback(): void;
-    static get observedAttributes(): string[];
-    attributeChangedCallback(name: string, _oldVal: string | null, newVal: string | null): void;
-}
-
-type ImgType = (typeof ImgTypeEnum)[keyof typeof ImgTypeEnum];
-type LoaderParams = {
-    src?: string;
-    srcset?: string;
-    elNode: HTMLImageElement;
-};
-type CurrentImg = {
-    type: ImgType;
-    img: HTMLImageElement;
-};
-declare class ImgBase extends ImgConfig {
-    protected _img: HTMLImageElement;
-    protected _imgPreview: HTMLImageElement;
-    private _fmtAbs;
-    private _validateSize;
-    private _getCdnModifiers;
-    private _getTypedCssValue;
-    private _getUrlBase;
-    private _proxyUrl;
-    protected _getElSize(el: HTMLElement, k?: number, wOnly?: boolean): string | null;
-    private _setupEventProxy;
-    get img(): HTMLImageElement;
-    get currentImg(): CurrentImg;
-    get hasPreviewImage(): string | number | boolean | undefined;
-    get bgSelector(): string | undefined;
-    get breakpoints(): number[] | null;
-    get hasFormatJPG(): boolean;
-    renderBg(el: HTMLElement): void;
-    getSrcset(): string;
-    getSrc(): string | undefined;
-    get srcUrlPreview(): string | undefined;
-    renderBackground(): void;
-    private _appendURL;
-    private _setupConfigForImage;
-    loaderImage({ src, srcset, elNode }: LoaderParams): Promise<HTMLImageElement>;
-    renderImage(): Promise<void>;
-    init(): void;
-}
-
-declare class Img extends ImgBase {
-    connectedCallback(): void;
-}
-
-declare class ProgressBar extends LitBlock {
-    value: number;
-    visible: boolean;
-    private _progressValue;
-    private readonly fakeProgressLineRef;
-    private readonly handleFakeProgressAnimation;
-    protected firstUpdated(changedProperties: PropertyValues<this>): void;
-    protected updated(changedProperties: PropertyValues<this>): void;
-    disconnectedCallback(): void;
-    private normalizeProgressValue;
-    private updateProgressValueStyle;
-    render(): lit_html.TemplateResult<1>;
-}
-
-declare class ProgressBarCommon extends LitUploaderBlock {
-    private _unobserveCollectionCb?;
-    protected visible: boolean;
-    protected value: number;
-    constructor();
-    initCallback(): void;
-    protected updated(changedProperties: PropertyValues<this>): void;
-    disconnectedCallback(): void;
-    render(): lit_html.TemplateResult<1>;
-}
-
-type SelectOption = {
-    text: string;
-    value: string;
-};
-declare class Select extends LitBlock {
-    value: string;
-    disabled: boolean;
-    options: SelectOption[];
+    protected shouldUpdate(changedProperties: PropertyValues<this>): boolean;
     render(): lit_html.TemplateResult<1>;
-    private _handleChange;
 }
 
 declare class SimpleBtn extends LitUploaderBlock {
     static styleAttrs: string[];
     couldBeCtxOwner: boolean;
     dropzone: boolean;
-    private buttonTextKey;
-    private readonly handleClick;
-    initCallback(): void;
-    render(): lit_html.TemplateResult<1>;
-}
-
-type SourceTypeConfig = {
-    type: string;
-    activity?: ActivityType | null;
-    textKey?: string;
-    icon?: string;
-    activate?: () => boolean;
-    activityParams?: Record<string, unknown>;
-};
-declare class SourceBtn extends LitUploaderBlock {
-    couldBeCtxOwner: boolean;
-    private _registeredTypes;
-    type?: string;
-    private iconName;
-    private srcTypeKey;
-    initTypes(): void;
-    initCallback(): void;
-    registerType(typeConfig: SourceTypeConfig): void;
-    getType(type: string): SourceTypeConfig | undefined;
-    activate(): void;
-    applyType(type: string): void;
-    protected willUpdate(changedProperties: PropertyValues<this>): void;
-    render(): lit_html.TemplateResult<1>;
-}
-
-declare class SourceList extends LitBlock {
-    private _rawSourceList;
-    private _cameraModes;
-    private _resolvedSources;
-    initCallback(): void;
-    protected updated(changedProperties: PropertyValues): void;
-    private _updateSources;
-    sources: string[];
-    render(): lit_html.TemplateResult<1>;
-}
-
-declare class Spinner extends LitBlock {
-    render(): lit_html.TemplateResult<1>;
-}
-
-declare class StartFrom extends LitActivityBlock {
-    historyTracked: boolean;
-    activityType: ActivityType;
-    initCallback(): void;
-    render(): lit_html.TemplateResult<1>;
-}
-
-declare class Thumb extends FileItemConfig {
-    badgeIcon: string;
-    uid: string;
-    private thumbUrl;
-    private renderedGridOnce;
-    private thumbRect;
-    private isIntersecting;
-    private firstViewMode;
-    private observer?;
-    private pendingThumbUpdate?;
-    private calculateThumbSize;
-    private generateThumbnail;
-    private debouncedGenerateThumb;
-    private decodeImage;
-    private cancelPendingThumbUpdate;
-    private scheduleThumbUpdate;
-    private requestThumbGeneration;
-    protected firstUpdated(changedProperties: PropertyValues<this>): void;
-    protected updated(changedProperties: PropertyValues<this>): void;
-    private _observerCallback;
-    protected _reset(): void;
-    private bindToEntry;
-    initCallback(): void;
-    connectedCallback(): void;
-    disconnectedCallback(): void;
-    render(): lit_html.TemplateResult<1>;
-}
-
-type EventListenerMap = {
-    [K in (typeof EventType)[keyof typeof EventType]]: (e: CustomEvent<EventPayload[K]>) => void;
-};
-declare class UploadCtxProvider extends LitUploaderBlock {
-    static styleAttrs: string[];
-    static 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";
-    }>;
+    private _buttonTextKey;
+    private readonly _handleClick;
     initCallback(): void;
-    disconnectedCallback(): void;
-}
-interface UploadCtxProvider extends LitUploaderBlock {
-    addEventListener<T extends keyof EventListenerMap>(type: T, listener: EventListenerMap[T], options?: boolean | AddEventListenerOptions): void;
-    removeEventListener<T extends keyof EventListenerMap>(type: T, listener: EventListenerMap[T], options?: boolean | EventListenerOptions): void;
-}
-
-declare class UrlSource extends LitUploaderBlock {
-    couldBeCtxOwner: boolean;
-    activityType: ActivityType;
-    private formState;
-    initCallback(): void;
-    private inputRef;
-    private handleInput;
-    private handleUpload;
     render(): lit_html.TemplateResult<1>;
 }
 
@@ -2318,6 +2319,18 @@ declare class LitSolutionBlock extends LitBlock {
     render(): lit_html.TemplateResult<1>;
 }
 
+declare class FileUploaderRegular extends LitSolutionBlock {
+    attributesMeta: {
+        headless?: boolean;
+        'ctx-name': string;
+    };
+    static styleAttrs: string[];
+    headless: boolean;
+    constructor();
+    initCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+
 declare class CloudImageEditor extends CloudImageEditorBlock {
     static styleAttrs: string[];
     constructor();
@@ -2325,25 +2338,29 @@ declare class CloudImageEditor extends CloudImageEditorBlock {
 }
 
 declare class FileUploaderInline extends LitSolutionBlock {
+    propertiesMeta: {
+        'ctx-name': string;
+    };
     static styleAttrs: string[];
-    private couldCancel;
+    private _couldCancel;
     constructor();
     private _handleCancel;
-    get couldHistoryBack(): boolean;
-    get couldShowList(): boolean;
+    private get _couldHistoryBack();
+    private get _couldShowList();
     private _getInitActivity;
     initCallback(): void;
     render(): lit_html.TemplateResult<1>;
 }
 
 declare class FileUploaderMinimal extends LitSolutionBlock {
+    propertiesMeta: {
+        'ctx-name': string;
+    };
     static styleAttrs: string[];
-    protected singleUpload: boolean;
-    protected isHiddenStartFrom: boolean;
-    protected classUploadList: string;
-    protected classStartFrom: string;
-    private handleModalOpen?;
-    private handleModalClose?;
+    private _singleUpload;
+    private _isHiddenStartFrom;
+    private _classUploadList;
+    private _classStartFrom;
     private _getInitActivity;
     constructor();
     private _handleModalOpen;
@@ -2353,15 +2370,4 @@ declare class FileUploaderMinimal extends LitSolutionBlock {
     render(): lit_html.TemplateResult<1>;
 }
 
-declare class FileUploaderRegular extends LitSolutionBlock {
-    static styleAttrs: string[];
-    headless: boolean;
-    constructor();
-    initCallback(): void;
-    render(): lit_html.TemplateResult<1>;
-}
-
-type KebabCase<T extends string> = T extends `${infer Head} ${infer Tail}` ? `${Lowercase<Head>}-${KebabCase<Tail>}` : Lowercase<T>;
-declare const toKebabCase: <T extends string>(str: T) => KebabCase<T>;
-
-export { LitActivityBlock as ActivityBlock, ActivityHeader, type ApiAddFileCommonOptions, LitBlock as Block, BtnUi, CameraSource, CloudImageEditor, CloudImageEditorActivity, CloudImageEditorBlock, type CollectionValidators, Config, type ConfigAttributesType, type ConfigComplexType, type ConfigPlainType, type ConfigType, Copyright, CropFrame, DropArea, EditorAspectRatioButtonControl, EditorCropButtonControl, EditorFilterControl, EditorFreeformButtonControl, EditorImageCropper, EditorImageFader, EditorOperationControl, EditorScroller, EditorSlider, EditorToolbar, type EventMap, type EventPayload, EventType, ExternalSource, ExternalUploadSource, FileItem, FileUploaderInline, FileUploaderMinimal, FileUploaderRegular, type FileValidator, type FileValidatorDescriptor, type FileValidators, FormInput, type FuncCollectionValidator, type FuncFileValidator, type GroupFlag, Icon, type IconHrefResolver, Img, type KebabCase$1 as KebabCase, type KebabCaseKeys, LineLoaderUi, type LocaleDefinitionOverride, type LowerCase, type LowerCaseKeys, type MetadataCallback, Modal, ModalEvents, type ModalId, type OutputCollectionErrorType, type OutputCollectionState, type OutputCollectionStatus, type OutputCustomErrorType, type OutputError, type OutputErrorCollection, type OutputErrorFile, type OutputErrorTypePayload, type OutputFileEntry, type OutputFileErrorPayload, type OutputFileErrorType, type OutputFileStatus, PresenceToggle, ProgressBar, ProgressBarCommon, type SecureDeliveryProxyUrlResolver, type SecureUploadsSignatureAndExpire, type SecureUploadsSignatureResolver, Select, SimpleBtn, SliderUi, LitSolutionBlock as SolutionBlock, SourceBtn, SourceList, type SourceTypes, Spinner, StartFrom, Thumb, UploadCtxProvider, UploadList, UploadSource, LitUploaderBlock as UploaderBlock, UploaderPublicApi, UrlSource, defineComponents, defineLocale, toKebabCase };
+export { LitActivityBlock as ActivityBlock, ActivityHeader, type ApiAddFileCommonOptions, BaseComponent, LitBlock as Block, BtnUi, CameraSource, CloudImageEditor, CloudImageEditorActivity, CloudImageEditorBlock, type CollectionValidators, Config, type ConfigAttributesType, type ConfigComplexType, type ConfigPlainType, type ConfigType, Copyright, CropFrame, PubSub as Data, DropArea, EditorAspectRatioButtonControl, EditorCropButtonControl, EditorFilterControl, EditorFreeformButtonControl, EditorImageCropper, EditorImageFader, EditorOperationControl, EditorScroller, EditorSlider, EditorToolbar, type EventMap, type EventPayload, EventType, ExternalSource, ExternalUploadSource, FileItem, FileUploaderInline, FileUploaderMinimal, FileUploaderRegular, type FileValidator, type FileValidatorDescriptor, type FileValidators, FormInput, type FuncCollectionValidator, type FuncFileValidator, type GroupFlag, Icon, type IconHrefResolver, Img, type KebabCase$1 as KebabCase, type KebabCaseKeys, LineLoaderUi, type LocaleDefinitionOverride, type LowerCase, type LowerCaseKeys, type MetadataCallback, Modal, ModalEvents, type ModalId, type OutputCollectionErrorType, type OutputCollectionState, type OutputCollectionStatus, type OutputCustomErrorType, type OutputError, type OutputErrorCollection, type OutputErrorFile, type OutputErrorTypePayload, type OutputFileEntry, type OutputFileErrorPayload, type OutputFileErrorType, type OutputFileStatus, PresenceToggle, ProgressBar, ProgressBarCommon, type SecureDeliveryProxyUrlResolver, type SecureUploadsSignatureAndExpire, type SecureUploadsSignatureResolver, Select, SimpleBtn, SliderUi, LitSolutionBlock as SolutionBlock, SourceBtn, SourceList, type SourceTypes, Spinner, StartFrom, Thumb, UID, UploadCtxProvider, UploadList, UploadSource, LitUploaderBlock as UploaderBlock, UploaderPublicApi, UrlSource, defineComponents, defineLocale, toKebabCase };