@uploadcare/file-uploader 1.30.0-alpha.3 → 1.30.0-alpha.6

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

@@ -1,8 +1,8 @@
 import * as lit_html from 'lit-html';
 import { PropertyValues, nothing, LitElement, TemplateResult } from 'lit';
-import * as lit_html_directives_ref_js from 'lit-html/directives/ref.js';
 import * as _uploadcare_upload_client from '@uploadcare/upload-client';
 import { UploadcareFile, Metadata, UploadError, NetworkError, UploadcareGroup, FileFromOptions, Queue } from '@uploadcare/upload-client';
+import * as lit_html_directives_ref_js from 'lit-html/directives/ref.js';
 import { Ref } from 'lit/directives/ref.js';
 import { TelemetryRequest } from '@uploadcare/quality-insights';
 
@@ -113,7 +113,6 @@ declare const _default: {
     'src-type-camera': string;
     'src-type-mobile-video-camera': string;
     'src-type-mobile-photo-camera': string;
-    'src-type-draw': string;
     'src-type-facebook': string;
     'src-type-dropbox': string;
     'src-type-gdrive': string;
@@ -128,7 +127,6 @@ declare const _default: {
     'src-type-other': string;
     'caption-from-url': string;
     'caption-camera': string;
-    'caption-draw': string;
     'caption-edit-file': string;
     'file-no-name': string;
     'toggle-fullscreen': string;
@@ -193,6 +191,13 @@ declare const _default: {
     'crop-to-shape': string;
     custom: string;
     'freeform-crop': string;
+    'upload-from': string;
+    'get-from': string;
+    'capture-with': string;
+    take: string;
+    record: string;
+    retake: string;
+    accept: string;
 };
 
 type LocaleDefinition = typeof _default;
@@ -215,7 +220,7 @@ declare class Modal extends LitBlock {
     private _handleDialogClose;
     private _handleDialogMouseDown;
     private _handleDialogMouseUp;
-    show(): void;
+    show(): Promise<void>;
     hide(): void;
     private _handleModalOpen;
     private _handleModalClose;
@@ -231,81 +236,176 @@ declare global {
     }
 }
 
-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]: undefined;
-    [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'>;
+/**
+ * Custom configuration options registration system for plugins
+ */
+type CustomConfigDefinition<T = unknown> = {
+    /**
+     * Config option name (will be used as property and optionally as attribute)
+     */
+    name: string;
+    /**
+     * Default value for the config option
+     */
+    defaultValue: T;
+    /**
+     * Whether this config can be set via HTML attribute
+     * @default true
+     */
+    attribute?: boolean;
+    /**
+     * Convert attribute string to config value
+     * Only used if attribute is true
+     */
+    fromAttribute?: (value: string | null) => T;
+    /**
+     * Convert config value to attribute string
+     * Only used if attribute is true
+     */
+    toAttribute?: (value: T) => string | null;
+    /**
+     * Normalize/validate the config value
+     */
+    normalize?: (value: unknown) => T;
 };
-declare class EventEmitter extends SharedInstance {
-    private _timeoutStore;
-    private _targets;
-    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;
+/**
+ * Registry for custom config options defined by plugins
+ * This is managed by the PluginManager as a shared instance property
+ */
+declare class CustomConfigRegistry {
+    private _definitions;
+    register<T = unknown>(pluginId: string, definition: CustomConfigDefinition<T>): void;
+    unregister(name: string): void;
+    unregisterByPlugin(pluginId: string): void;
+    get(name: string): CustomConfigDefinition<any> | undefined;
+    getAll(): Map<string, CustomConfigDefinition<any>>;
+}
+/**
+ * Interface for TypeScript module augmentation
+ * Plugins should extend this interface to add their custom config types
+ *
+ * @example
+ * ```typescript
+ * declare module '@uploadcare/file-uploader' {
+ *   interface CustomConfig {
+ *     'my-custom-option': string;
+ *   }
+ * }
+ * ```
+ */
+interface CustomConfig {
+}
+
+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): Unsubscriber;
     destroy(): void;
 }
 
-type PasteScope = 'local' | 'global' | false;
-declare class ClipboardLayer extends SharedInstance {
-    private scopes;
-    private listener;
+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;
+
+declare class PluginRegistry {
+    private _sources;
+    private _activities;
+    private _fileActions;
+    private _fileHooks;
+    private _icons;
+    private _l10n;
+    readonly config: CustomConfigRegistry;
+    private _own;
+    addSource(pluginId: string, item: PluginSourceRegistration): void;
+    addActivity(pluginId: string, item: PluginActivityRegistration): void;
+    addFileAction(pluginId: string, item: PluginFileActionRegistration): void;
+    addFileHook(pluginId: string, item: PluginFileHookRegistration): void;
+    addIcon(pluginId: string, item: PluginIconRegistration): void;
+    addL10n(pluginId: string, item: PluginL10nRegistration): void;
+    addConfig<T>(pluginId: string, definition: CustomConfigDefinition<T>): void;
+    purge(pluginId: string): void;
+    snapshot(): PluginRegistrySnapshot;
+}
+
+declare class PluginManager extends SharedInstance {
+    private _plugins;
+    private _subscribers;
+    private _pluginsUpdate;
+    private _lazyPluginLoader;
+    readonly registry: PluginRegistry;
+    get configRegistry(): CustomConfigRegistry;
     constructor(sharedInstancesBag: SharedInstancesBag);
-    private openUploadList;
-    private _listener;
-    private handlePaste;
-    registerBlock(scope: Node): () => void;
+    pluginsReady(): Promise<void>;
+    onPluginsChange(callback: Unsubscriber): Unsubscriber;
+    private _syncPlugins;
+    private _registerPlugin;
+    private _unregisterPlugin;
+    snapshot(): PluginRegistrySnapshot;
+    runOnAddHooks(entry: UploadEntryTypedData): Promise<void>;
+    destroy(): void;
+    private _notifySubscribers;
+}
+
+declare function buildOutputCollectionState<TCollectionStatus extends OutputCollectionStatus, TGroupFlag extends GroupFlag = 'maybe-has-group'>(bag: SharedInstancesBag): OutputCollectionState<TCollectionStatus, TGroupFlag>;
+
+type FuncFileValidator = (outputEntry: OutputFileEntry, api: UploaderPublicApi, options?: {
+    signal?: AbortSignal;
+}) => undefined | OutputErrorFile | Promise<undefined | OutputErrorFile>;
+type FileValidatorDescriptor = {
+    runOn: 'add' | 'upload' | 'change';
+    validator: FuncFileValidator;
+};
+type FileValidator = FileValidatorDescriptor | FuncFileValidator;
+type FuncCollectionValidator = (collection: ReturnType<typeof buildOutputCollectionState<OutputCollectionStatus>>, api: UploaderPublicApi) => undefined | OutputErrorCollection;
+declare class ValidationManager extends SharedInstance {
+    private get _uploadCollection();
+    private _commonFileValidators;
+    private _commonCollectionValidators;
+    private _queue;
+    private _runQueueDebounced;
+    private _isDestroyed;
+    private _entryValidationState;
+    constructor(sharedInstancesBag: SharedInstancesBag);
+    runFileValidators(runOn: FileValidatorDescriptor['runOn'], entryIds?: Uid[]): void;
+    runCollectionValidators(): void;
+    cleanupValidationForEntry(entry: TypedData<UploadEntryData>): void;
+    private _runFileValidatorsForEntry;
+    private _addCustomTypeToValidationError;
+    private _getEntryValidationState;
+    private _getValidatorDescriptors;
+    private _getValidatorDescriptorsForEntry;
     destroy(): void;
 }
 
@@ -320,11 +420,14 @@ declare global {
 declare class Icon extends LitBlock {
     name: string;
     private _resolvedHref;
+    private _pluginSvg;
     private _iconHrefResolver;
+    private _unsubscribePlugins?;
     initCallback(): void;
     protected willUpdate(changedProperties: PropertyValues<this>): void;
     private _updateResolvedHref;
     render(): lit_html.TemplateResult<1>;
+    disconnectedCallback(): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
@@ -352,7 +455,6 @@ declare global {
 type CameraMode = 'photo' | 'video';
 declare class CameraSource extends LitUploaderBlock {
     couldBeCtxOwner: boolean;
-    activityType: "camera";
     private _unsubPermissions;
     private _capturing;
     private _chunks;
@@ -374,7 +476,6 @@ declare class CameraSource extends LitUploaderBlock {
     private _timerRef;
     private _lineRef;
     private _videoRef;
-    private _switcherRef;
     private _startTime;
     private _elapsedTime;
     private _videoTransformCss;
@@ -472,25 +573,54 @@ declare global {
 /**
  * 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", "smartBtn"];
-/** Mapping of attribute names to state */
-declare const attrStateMapping: Record<string, string>;
+declare const complexConfigKeys: readonly ["metadata", "plugins", "localeDefinitionOverride", "secureUploadsSignatureResolver", "secureDeliveryProxyUrlResolver", "iconHrefResolver", "fileValidators", "collectionValidators", "mediaRecorderOptions"];
 declare class Config extends LitBlock {
     attributesMeta: Partial<ConfigPlainType> & {
         'ctx-name': string;
     };
     init$: LitBlock["init$"] & ConfigType;
     private _computationControllers;
+    private _pluginChangeUnsubscribe?;
+    private _mutationObserver?;
+    /**
+     * Mapping of attribute names to custom config keys for plugin-registered configs.
+     * Updated dynamically when plugins are registered or changed.
+     * Similar to builtinAttrKeyMapping but for custom configs.
+     */
+    private _customAttrKeyMapping;
+    /** Set of all custom config names registered by plugins */
+    private _customConfigKeys;
+    /**
+     * Map of custom config subscriptions (config name -> unsubscribe function)
+     * Used to track and clean up subscriptions when plugins change
+     */
+    private _customConfigSubscriptions;
+    /**
+     * Check if a key is a custom config (registered by plugins)
+     */
+    private _isCustomConfig;
+    /**
+     * Get the custom config definition for a key
+     */
+    private _getCustomConfigDefinition;
+    /**
+     * Get attribute names for a config key (kebab-case and lowercase)
+     */
+    private _getAttributeNames;
     private _flushValueToAttribute;
     private _flushValueToState;
     private _setValue;
     private _getValue;
     private _assertSameValueDifferentReference;
+    private _processCustomConfigs;
+    private _setupCustomConfigs;
+    private _setupMutationObserver;
     initCallback(): void;
-    attributeChangedCallback(name: keyof typeof attrStateMapping, oldVal: string, newVal: string): void;
+    attributeChangedCallback(name: string, oldVal: string, newVal: string): void;
+    disconnectedCallback(): void;
     static get observedAttributes(): string[];
 }
-interface Config extends ConfigType {
+interface Config extends ConfigType, CustomConfig {
 }
 declare global {
     interface HTMLElementTagNameMap {
@@ -498,49 +628,6 @@ declare global {
     }
 }
 
-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): Unsubscriber;
-    destroy(): void;
-}
-
-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;
-
 declare class FileItemConfig extends LitUploaderBlock {
     private _entrySubs;
     protected entry: UploadEntryTypedData | null;
@@ -603,6 +690,21 @@ declare global {
     }
 }
 
+declare class FileActionButton extends LitUploaderBlock {
+    static styleAttrs: string[];
+    uploading: boolean;
+    failed: boolean;
+    success: boolean;
+    idle: boolean;
+    private _handleRemove;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-file-action-button': FileActionButton;
+    }
+}
+
 declare class FileItem extends FileItemConfig {
     protected couldBeCtxOwner: boolean;
     private _pauseRender;
@@ -617,12 +719,12 @@ declare class FileItem extends FileItemConfig {
     private _isFailed;
     private _isUploading;
     private _isFocused;
-    private _isEditable;
     private _showFileNames;
     private _ariaLabelStatusFile;
+    private _pluginFileActions;
     private _renderedOnce;
     private _observer?;
-    private _handleEdit;
+    private _unsubscribePlugins?;
     private _handleRemove;
     private _handleUploadClick;
     private _calculateState;
@@ -634,6 +736,8 @@ declare class FileItem extends FileItemConfig {
     private _handleEntryId;
     private _updateShowFileNames;
     protected willUpdate(changedProperties: PropertyValues<this>): void;
+    private _updatePluginFileActions;
+    private _handlePluginFileAction;
     initCallback(): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
@@ -733,6 +837,7 @@ declare global {
 declare const ExternalUploadSource: Readonly<{
     readonly FACEBOOK: "facebook";
     readonly DROPBOX: "dropbox";
+    readonly DROPBOX_CHOOSER: "dropboxchooser";
     readonly GDRIVE: "gdrive";
     readonly GPHOTOS: "gphotos";
     readonly FLICKR: "flickr";
@@ -745,6 +850,7 @@ declare const ExternalUploadSource: Readonly<{
 declare const UploadSource: Readonly<{
     readonly FACEBOOK: "facebook";
     readonly DROPBOX: "dropbox";
+    readonly DROPBOX_CHOOSER: "dropboxchooser";
     readonly GDRIVE: "gdrive";
     readonly GPHOTOS: "gphotos";
     readonly FLICKR: "flickr";
@@ -761,7 +867,6 @@ declare const UploadSource: Readonly<{
     readonly EXTERNAL: "external";
     readonly API: "js-api";
     readonly URL: "url";
-    readonly DRAW: "draw";
 }>;
 type SourceTypes = (typeof UploadSource)[keyof typeof UploadSource];
 
@@ -801,6 +906,8 @@ declare class TypedCollection<T extends Record<string, unknown>> {
     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;
+    abort(id: Uid): void;
+    abortAll(): void;
     clearAll(): void;
     observeProperties(handler: TypedCollectionPropertyObserver<T>): () => void;
     unobserveProperties(handler: TypedCollectionPropertyObserver<T>): void;
@@ -810,14 +917,80 @@ declare class TypedCollection<T extends Record<string, unknown>> {
     destroy(): void;
 }
 
-declare const CameraSourceTypes: Readonly<{
-    PHOTO: "photo";
-    VIDEO: "video";
-}>;
-type ModeCameraType = (typeof CameraSourceTypes)[keyof typeof CameraSourceTypes];
-
-declare function buildOutputCollectionState<TCollectionStatus extends OutputCollectionStatus, TGroupFlag extends GroupFlag = 'maybe-has-group'>(bag: SharedInstancesBag): OutputCollectionState<TCollectionStatus, TGroupFlag>;
-
+declare const CameraSourceTypes: Readonly<{
+    PHOTO: "photo";
+    VIDEO: "video";
+}>;
+type ModeCameraType = (typeof CameraSourceTypes)[keyof typeof CameraSourceTypes];
+
+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]: undefined;
+    [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 extends SharedInstance {
+    private _timeoutStore;
+    private _targets;
+    private _listeners;
+    bindTarget(target: LitBlock): () => void;
+    on<T extends EventKey>(type: T, handler: (payload: EventPayload[T]) => void): () => 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;
+    destroy(): void;
+}
+
 type ApiAddFileCommonOptions = {
     silent?: boolean;
     fileName?: string;
@@ -848,25 +1021,31 @@ declare class UploaderPublicApi extends SharedInstance {
     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;
+    private _pluginsReady;
+    setCurrentActivity: <T extends ActivityType>(activityType: T, ...params: T extends keyof ActivityParamsMap ? [ActivityParamsMap[T]] extends [never] ? [] : [ActivityParamsMap[T]] : []) => void;
+    on: <T extends EventKey>(type: T, handler: (payload: EventPayload[T]) => void) => (() => void);
     getCurrentActivity: () => ActivityType;
+    historyBack: () => void;
     setModalState: (opened: boolean) => void;
     private get _sourceList();
 }
 
+type SourceButtonConfig = {
+    id: string;
+    label: string;
+    icon?: string;
+    onClick: () => void | Promise<void>;
+};
 declare class SourceBtn extends LitUploaderBlock {
     couldBeCtxOwner: boolean;
-    private _registeredTypes;
-    type?: string;
-    onlyIcon: boolean;
+    source?: SourceButtonConfig;
+    textOnly: boolean;
+    iconOnly: boolean;
     private _iconName;
     private _srcTypeKey;
-    private _initTypes;
-    initCallback(): void;
-    private _registerType;
-    activate(): void;
-    private _applyType;
     protected willUpdate(changedProperties: PropertyValues<this>): void;
+    private _applySource;
+    activate(): void;
     render(): lit_html.TemplateResult<1>;
 }
 declare global {
@@ -875,46 +1054,92 @@ declare global {
     }
 }
 
-declare class Dropdown extends LitBlock {
+declare class PrimaryAction extends LitUploaderBlock {
+    static styleAttrs: string[];
+    private static readonly SOURCE_TEXT_CONFIG;
+    source: SourceButtonConfig | null;
+    entries: OutputCollectionState<OutputCollectionStatus, 'maybe-has-group'>;
+    private showIcon;
+    private _isMultiple;
+    initCallback(): void;
+    private get hasEntries();
+    private get hasSingleSuccessImage();
+    private get hasMultipleEntries();
+    private get localizedSourceLabel();
+    private _translate;
+    private get textBasedOnLocale();
+    private _headerTextDependentOnEntries;
+    private _getSourceLabelText;
+    private _handleClick;
+    private _renderThumbnail;
+    protected render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-primary-action': PrimaryAction;
+    }
+}
+
+declare class DropDown extends LitBlock {
+    static styleAttrs: string[];
     private _id;
     private readonly _handleContentClick;
-    protected render(): unknown;
+    render(): lit_html.TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'uc-dropdown': Dropdown;
+        'uc-drop-down': DropDown;
     }
 }
 
-type SmartButtonMode = 'auto' | 'allwrap' | 'nowrap';
-type AdvancedSmartBtnConfig = {
-    sourceList: string;
-    mode: SmartButtonMode;
-};
+declare class NoWrapModeSmartBtn extends LitUploaderBlock {
+    static styleAttrs: string[];
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-no-wrap-mode-smart-btn': NoWrapModeSmartBtn;
+    }
+}
+
+type SmartButtonMode = 'auto' | 'allwrap' | 'nowrap' | 'collapse';
 declare class SmartBtn extends LitUploaderBlock {
     static styleAttrs: string[];
     couldBeCtxOwner: boolean;
+    private _controller?;
+    private _unregisterAfterFileAddHook?;
     dropzone: boolean;
-    private _sourceList;
+    private _mode;
+    private _sources;
     private _status;
-    private _multiple;
-    private _entry;
-    private _lastDigest;
-    private _progressPercent;
-    private _progressFading;
-    private _progressFadeTimer;
-    private _showDropdown;
+    private _mainAndRemainSources;
+    private _collection;
+    private _progress;
     private get isIdle();
-    private get buttonText();
+    private get isSuccess();
+    private get isFailed();
+    private get isUploading();
+    private get isCollapsedMode();
+    private get shouldShowPrimaryAction();
+    private get shouldShowInline();
+    private get shouldShowDropdown();
+    private get hasCollectionEntries();
+    private get shouldShowAbortAction();
     private _throttledHandleCollectionUpdate;
     private _updateButtonBasedOnCollectionState;
-    private _cancelProgressFade;
-    private _startProgressFade;
-    disconnectedCallback(): void;
-    private _removeEntries;
+    private _updateSourceSplit;
     initCallback(): void;
-    private readonly _handleClickAbort;
-    private readonly _handleClick;
+    disconnectedCallback(): void;
+    private _renderInline;
+    private _getDropdownIconName;
+    private _clearAllEntries;
+    private _clearAllFailedEntries;
+    private _abortAllEntries;
+    private _handleRemove;
+    private _renderDropdown;
+    private _renderPrimaryAction;
+    private _renderAbortAction;
+    private _getInnerClassMap;
+    private _renderVisualDropArea;
     render(): lit_html.TemplateResult<1>;
 }
 declare global {
@@ -1135,6 +1360,10 @@ type ConfigType = {
      * Expiry threshold for secure uploads.
      */
     secureUploadsExpireThreshold: number;
+    /**
+     * Array of plugins to register with the uploader instance.
+     */
+    plugins: UploaderPlugin[];
     /**
      * Metadata for the file.
      */
@@ -1220,7 +1449,8 @@ type ConfigType = {
      * Define the clipboard paste scope.
      */
     pasteScope: PasteScope;
-    smartBtn: AdvancedSmartBtnConfig | null;
+    smartButtonViewMode: SmartButtonMode;
+    smartButtonShowFirstIcon: boolean;
 };
 type ConfigComplexType = Pick<ConfigType, (typeof complexConfigKeys)[number]>;
 type ConfigPlainType = Omit<ConfigType, keyof ConfigComplexType>;
@@ -1387,6 +1617,165 @@ type OutputCollectionState<TStatus extends OutputCollectionStatus = OutputCollec
     allEntries: OutputFileEntry[];
 });
 
+type PluginIconRegistration = {
+    name: string;
+    svg: string;
+};
+type PluginL10nRegistration = Record<string, Record<string, string>>;
+type PluginSourceRegistration = {
+    id: string;
+    label: string;
+    icon?: string;
+    /**
+     * @internal
+     *
+     * Optional expansion function. When present, SourceList calls this to determine
+     * which source IDs should actually be rendered in place of this source.
+     * Useful for sources that map to multiple device-specific variants (e.g. camera
+     * expanding to separate photo/video buttons on mobile).
+     * Return `[id]` (the source's own id) to render it as-is.
+     */
+    expand?: () => string[];
+    onSelect: () => Promise<void> | void;
+};
+type PluginRenderDispose = () => void;
+type PluginRender = (el: HTMLElement, activityParams: Record<string, unknown>) => PluginRenderDispose | undefined;
+type PluginActivityRegistration = {
+    id: string;
+    render: PluginRender;
+};
+type PluginFileActionRegistration = {
+    /** Unique action identifier. */
+    id: string;
+    /** Icon name to display in the action button. */
+    icon: string;
+    /** Label shown next to the icon in the action button. Accepts a plain string or an l10n key registered via `registerL10n`. */
+    label: string;
+    /** Return `true` to show the action button for the given file entry. */
+    shouldRender: (fileEntry: OutputFileEntry) => boolean;
+    onClick: (fileEntry: OutputFileEntry) => void | Promise<void>;
+};
+type PluginFileHookResult = {
+    /** The (optionally transformed) file */
+    file: File | Blob;
+};
+type PluginFileHookContext = PluginFileHookResult & {
+    /**
+     * An AbortSignal that fires when the operation is cancelled (e.g. upload aborted or file removed).
+     * Hooks should respect this signal to avoid doing unnecessary work.
+     */
+    signal: AbortSignal;
+};
+type PluginFileHookRegistration = {
+    /**
+     * When the hook is called:
+     * - `'beforeUpload'`: called right before the file is uploaded.
+     * - `'onAdd'`: called after the file is added to the upload list.
+     *
+     * Return the (optionally transformed) file. After the hook runs, `mimeType`,
+     * `isImage`, `fileSize`, and `fileName` are all re-derived from the returned file.
+     */
+    type: 'beforeUpload' | 'onAdd';
+    handler: (context: PluginFileHookContext) => PluginFileHookResult | Promise<PluginFileHookResult>;
+    /**
+     * Maximum time in milliseconds to wait for the hook to complete before skipping it.
+     * @default 30000
+     */
+    timeout?: number;
+};
+type PluginRegistryApi = {
+    registerSource: (source: PluginSourceRegistration) => void;
+    registerActivity: (activity: PluginActivityRegistration) => void;
+    registerFileAction: (fileAction: PluginFileActionRegistration) => void;
+    registerFileHook: (hook: PluginFileHookRegistration) => void;
+    registerIcon: (icon: PluginIconRegistration) => void;
+    registerL10n: (l10n: PluginL10nRegistration) => void;
+    registerConfig: <T = unknown>(definition: CustomConfigDefinition<T>) => void;
+};
+/**
+ * API for managing plugin config subscriptions
+ */
+type PluginConfigApi = {
+    get: <TKey extends keyof (ConfigType & CustomConfig)>(configName: TKey) => (ConfigType & CustomConfig)[TKey];
+    subscribe: <TKey extends keyof (ConfigType & CustomConfig)>(configName: TKey, callback: (value: (ConfigType & CustomConfig)[TKey]) => void) => () => void;
+};
+/**
+ * API for managing plugin activity interactions
+ */
+type PluginActivityApi = {
+    /**
+     * Get the current activity parameters.
+     *
+     * @returns The current activity parameters object
+     *
+     * @example
+     * ```typescript
+     * const params = pluginApi.activity.getParams();
+     * console.log('Current params:', params);
+     * ```
+     */
+    getParams: () => Record<string, unknown>;
+    /**
+     * Subscribe to changes in activity parameters.
+     * The callback will be called immediately with the current params,
+     * and then whenever the params change.
+     *
+     * Subscriptions are automatically cleaned up when the plugin is disposed.
+     *
+     * @param callback - Function to call with the new params
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * pluginApi.activity.subscribeToParams((params) => {
+     *   console.log('Activity params changed:', params);
+     * });
+     * // Cleanup happens automatically on plugin disposal
+     * ```
+     */
+    subscribeToParams: (callback: (params: Record<string, unknown>) => void) => () => void;
+};
+type PluginFileEntryUpdate = {
+    file?: File | Blob;
+    cdnUrl?: string | null;
+    cdnUrlModifiers?: string | null;
+    mimeType?: string | null;
+};
+type PluginFilesApi = {
+    /**
+     * Update mutable properties of a file entry by its internalId.
+     * `fileSize` is recalculated automatically when `file` is provided.
+     */
+    update: (internalId: string, changes: PluginFileEntryUpdate) => void;
+};
+type PluginApi = {
+    registry: PluginRegistryApi;
+    config: PluginConfigApi;
+    activity: PluginActivityApi;
+    files: PluginFilesApi;
+};
+type PluginUploaderApi = UploaderPublicApi;
+type PluginSetupResult = (() => void) | void | Promise<(() => void) | void>;
+type PluginSetupParams = {
+    pluginApi: PluginApi;
+    uploaderApi: PluginUploaderApi;
+};
+type UploaderPlugin = {
+    id: string;
+    setup: (params: PluginSetupParams) => PluginSetupResult;
+};
+type Owned<T> = T & {
+    pluginId: string;
+};
+type PluginRegistrySnapshot = {
+    sources: Owned<PluginSourceRegistration>[];
+    activities: Owned<PluginActivityRegistration>[];
+    fileActions: Owned<PluginFileActionRegistration>[];
+    fileHooks: Owned<PluginFileHookRegistration>[];
+    icons: Owned<PluginIconRegistration>[];
+    l10n: Owned<PluginL10nRegistration>[];
+};
+
 declare class SecureUploadsManager extends SharedInstance {
     private _secureToken;
     getSecureToken(): Promise<SecureUploadsSignatureAndExpire | null>;
@@ -1431,7 +1820,6 @@ declare class LitUploaderBlock extends LitActivityBlock {
     private _handleCollectionUpdate;
     private _handleCollectionPropertiesUpdate;
     private _flushCommonUploadProgress;
-    private _openCloudImageEditor;
     private _setInitialCrop;
     protected getMetadataFor(entryId: string): Promise<_uploadcare_upload_client.Metadata | undefined>;
     protected getUploadClientOptions(): Promise<FileFromOptions>;
@@ -1501,12 +1889,11 @@ type ActivityParams$1 = {
     internalId: string;
 };
 declare class CloudImageEditorActivity extends LitUploaderBlock {
-    couldBeCtxOwner: boolean;
-    activityType: "cloud-image-edit";
     private _entry?;
     private _editorConfig;
     get activityParams(): ActivityParams$1;
     initCallback(): void;
+    disconnectedCallback(): void;
     private _handleApply;
     private _handleCancel;
     handleChange(event: CustomEvent<ChangeResult>): void;
@@ -1535,7 +1922,6 @@ type ActivityParams = {
 };
 declare class ExternalSource extends LitUploaderBlock {
     couldBeCtxOwner: boolean;
-    activityType: "external";
     private _messageBridge?;
     private _iframeRef;
     private _latestSelectionSummary;
@@ -1579,22 +1965,26 @@ declare global {
 declare const ACTIVITY_TYPES: Readonly<{
     START_FROM: "start-from";
     CAMERA: "camera";
-    DRAW: "draw";
     UPLOAD_LIST: "upload-list";
     URL: "url";
     CLOUD_IMG_EDIT: "cloud-image-edit";
     EXTERNAL: "external";
 }>;
-type RegisteredActivityType = (typeof ACTIVITY_TYPES)[keyof typeof ACTIVITY_TYPES];
-type ActivityType = RegisteredActivityType | (string & {}) | null;
+type RegisteredActivityType = (typeof ACTIVITY_TYPES)[keyof typeof ACTIVITY_TYPES] | keyof CustomActivities;
+type ActivityType = RegisteredActivityType | null;
 
 declare const ACTIVE_PROP = "___ACTIVITY_IS_ACTIVE___";
+interface CustomActivities {
+}
 type ActivityParamsMap = {
     'cloud-image-edit': ActivityParams$1;
     external: ActivityParams;
+} & {
+    [Key in keyof CustomActivities]: CustomActivities[Key]['params'];
 };
 declare class LitActivityBlock extends LitBlock {
     protected historyTracked: boolean;
+    activityType: ActivityType;
     private [ACTIVE_PROP]?;
     init$: {
         '*currentActivity': null;
@@ -1608,12 +1998,11 @@ declare class LitActivityBlock extends LitBlock {
     private _activate;
     initCallback(): void;
     private _historyFlush;
-    private _isActivityRegistered;
+    protected _isActivityRegistered(): boolean;
     private static _activityCallbacks;
     static activities: Readonly<{
         START_FROM: 'start-from';
         CAMERA: 'camera';
-        DRAW: 'draw';
         UPLOAD_LIST: 'upload-list';
         URL: 'url';
         CLOUD_IMG_EDIT: 'cloud-image-edit';
@@ -1629,8 +2018,8 @@ declare class LitActivityBlock extends LitBlock {
     private _unregisterActivity;
     disconnectedCallback(): void;
     get activityParams(): ActivityParamsMap[keyof ActivityParamsMap];
-    get initActivity(): string | null;
-    get doneActivity(): string | null;
+    get initActivity(): RegisteredActivityType | null;
+    get doneActivity(): RegisteredActivityType | null;
     historyBack(): void;
 }
 
@@ -1685,10 +2074,19 @@ declare class ModalManager extends SharedInstance {
     destroy(): void;
 }
 
+type ConfigGetter = <K extends keyof ConfigType>(key: K) => ConfigType[K];
+type LazyPluginEntry = {
+    configDeps: readonly (keyof ConfigType)[];
+    isEnabled: (get: ConfigGetter) => boolean;
+    load: () => UploaderPlugin | undefined | Promise<UploaderPlugin | undefined>;
+};
+
 declare class LitSolutionBlock extends LitBlock {
     static styleAttrs: string[];
+    static lazyPlugins: LazyPluginEntry[] | null;
     init$: {
         '*solution': string | null;
+        '*lazyPlugins': LazyPluginEntry[] | null;
         '*commonProgress': number;
         '*uploadList': never[];
         '*uploadQueue': _uploadcare_upload_client.Queue;
@@ -1820,17 +2218,15 @@ declare global {
     }
 }
 
-declare class SourceList extends LitBlock {
-    private _rawSourceList;
-    private _cameraModes;
+declare class SourceList extends LitUploaderBlock {
+    private _controller?;
+    private _sources;
     /**
      * CSS-only attribute
      */
     wrap: boolean;
     initCallback(): void;
     protected updated(changedProperties: PropertyValues<this>): void;
-    private _updateSources;
-    private _sources;
     render(): lit_html.TemplateResult<1>;
 }
 declare global {
@@ -1885,7 +2281,9 @@ declare class UploadCtxProvider extends LitUploaderBlock {
 }
 interface UploadCtxProvider extends LitUploaderBlock {
     addEventListener<T extends keyof EventListenerMap>(type: T, listener: EventListenerMap[T], options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<T extends keyof EventListenerMap>(type: T, listener: EventListenerMap[T], options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
@@ -1893,47 +2291,80 @@ declare global {
     }
 }
 
-declare class UrlSource extends LitUploaderBlock {
+declare class SimpleBtn extends LitUploaderBlock {
+    static styleAttrs: string[];
     couldBeCtxOwner: boolean;
-    activityType: ActivityType;
-    private _formState;
+    dropzone: boolean;
+    private _buttonTextKey;
+    private readonly _handleClick;
     initCallback(): void;
-    private _inputRef;
-    private _handleInput;
-    private _handleUpload;
     render(): lit_html.TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'uc-url-source': UrlSource;
+        'uc-simple-btn': SimpleBtn;
     }
 }
 
-declare class SimpleBtn extends LitUploaderBlock {
-    static styleAttrs: string[];
-    couldBeCtxOwner: boolean;
-    dropzone: boolean;
-    private _buttonTextKey;
-    private readonly _handleClick;
+declare class PluginActivityHost extends LitActivityBlock {
+    registration: Owned<PluginActivityRegistration>;
+    private _dispose?;
+    private _containerRef;
     initCallback(): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    private _ensureRegistered;
+    private _renderActivity;
+    private _disposeActivity;
+    disconnectedCallback(): void;
+    render(): lit_html.TemplateResult<1>;
+}
+declare class PluginActivityRenderer extends LitBlock {
+    mode: 'modal' | 'inline';
+    private _activities;
+    private _unsubscribePlugins?;
+    initCallback(): void;
+    private _syncActivities;
+    disconnectedCallback(): void;
     render(): lit_html.TemplateResult<1>;
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'uc-simple-btn': SimpleBtn;
+        'uc-plugin-activity-host': PluginActivityHost;
+        'uc-plugin-activity-renderer': PluginActivityRenderer;
+    }
+}
+
+declare class UrlSource extends LitUploaderBlock {
+    private _url;
+    private _handleInput;
+    private _handleUpload;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-url-source': UrlSource;
     }
 }
 
 declare class FileUploaderRegular extends LitSolutionBlock {
+    static lazyPlugins: LazyPluginEntry[];
     attributesMeta: {
         headless?: boolean;
+        'smart-button'?: boolean;
         'ctx-name': string;
     };
     static styleAttrs: string[];
     headless: boolean;
-    smart: boolean;
+    smartButton: boolean;
     constructor();
     initCallback(): void;
+    /**
+     * Exposes whether SmartBtn is active for non-Lit classes that can't use context
+     */
+    get isSmartBtnActive(): boolean;
+    private _renderSmartButton;
+    private _renderStaticButton;
+    private _renderButton;
     render(): lit_html.TemplateResult<1>;
 }
 declare global {
@@ -1943,6 +2374,7 @@ declare global {
 }
 
 declare class FileUploaderInline extends LitSolutionBlock {
+    static lazyPlugins: LazyPluginEntry[];
     attributesMeta: {
         'ctx-name': string;
     };
@@ -1963,6 +2395,7 @@ declare global {
 }
 
 declare class FileUploaderMinimal extends LitSolutionBlock {
+    static lazyPlugins: LazyPluginEntry[];
     attributesMeta: {
         'ctx-name': string;
     };
@@ -1986,6 +2419,16 @@ declare global {
     }
 }
 
+type AfterFileAddContext = {
+    historyLength: number;
+};
+type AfterFileAddHook = (ctx: AfterFileAddContext) => boolean;
+declare class RouterHooksLayer extends SharedInstance {
+    private _afterFileAddHooks;
+    registerAfterFileAddHook(hook: AfterFileAddHook): () => void;
+    navigateAfterFileAdd(): void;
+}
+
 declare class A11y implements ISharedInstance {
     private _destroyKeyUX;
     private readonly _scopedWindow;
@@ -1997,6 +2440,8 @@ declare class A11y implements ISharedInstance {
 declare class LocaleManager extends SharedInstance {
     private _localeName;
     constructor(sharedInstancesBag: SharedInstancesBag);
+    private _applyOverrides;
+    private _applyPluginLocales;
 }
 
 type CommonEventType = InternalEventKey | EventKey;
@@ -2037,6 +2482,72 @@ declare class TelemetryManager extends SharedInstance {
     private get _location();
 }
 
+interface ISharedInstance {
+    destroy?(): void;
+}
+declare class SharedInstance {
+    protected _ctx: PubSub<SharedState>;
+    protected _sharedInstancesBag: SharedInstancesBag;
+    private _subscriptions;
+    private _cfgProxy;
+    protected _debugPrint: (...args: unknown[]) => void;
+    constructor(sharedInstancesBag: SharedInstancesBag);
+    protected addSub(unsub: () => void): void;
+    protected get _cfg(): Readonly<ConfigType>;
+    destroy(): void;
+}
+declare const instanceKeyMap: {
+    modalManager: "*modalManager";
+    pluginManager: "*pluginManager";
+    telemetryManager: "*telemetryManager";
+    localeManager: "*localeManager";
+    a11y: "*a11y";
+    clipboard: "*clipboard";
+    routerLayer: "*routerLayer";
+    blocksRegistry: "*blocksRegistry";
+    eventEmitter: "*eventEmitter";
+    uploadCollection: "*uploadCollection";
+    secureUploadsManager: "*secureUploadsManager";
+    api: "*publicApi";
+    validationManager: "*validationManager";
+};
+type InstanceTypeMap = {
+    [key in keyof typeof instanceKeyMap]: SharedState[(typeof instanceKeyMap)[key]];
+};
+type InstanceName = keyof typeof instanceKeyMap;
+type SharedInstancesState = Pick<SharedState, (typeof instanceKeyMap)[keyof typeof instanceKeyMap]>;
+type SharedInstancesBag = ReturnType<typeof createSharedInstancesBag>;
+declare const createSharedInstancesBag: (getCtx: () => PubSub<SharedState>) => {
+    readonly ctx: PubSub<SharedState>;
+    readonly modalManager: ModalManager | null;
+    readonly pluginManager: PluginManager;
+    readonly telemetryManager: TelemetryManager;
+    readonly localeManager: LocaleManager;
+    readonly a11y: A11y;
+    readonly routerLayer: RouterHooksLayer;
+    readonly blocksRegistry: Set<LitBlock>;
+    readonly eventEmitter: EventEmitter;
+    readonly uploadCollection: TypedCollection<UploadEntryData>;
+    readonly secureUploadsManager: SecureUploadsManager;
+    readonly api: UploaderPublicApi;
+    readonly validationManager: ValidationManager;
+    when<TName extends InstanceName>(name: TName, callback: (instance: NonNullable<InstanceTypeMap[TName]>) => void): () => void;
+    wait<TName extends InstanceName>(name: TName): Promise<NonNullable<InstanceTypeMap[TName]>>;
+};
+
+type PasteScope = 'local' | 'global' | false;
+declare class ClipboardLayer extends SharedInstance {
+    private scopes;
+    private listener;
+    constructor(sharedInstancesBag: SharedInstancesBag);
+    private _excludingNodes;
+    private openUploadList;
+    private _listener;
+    private handlePaste;
+    registerBlock(scope: Node): () => void;
+    destroy(): void;
+}
+
 declare const TabId: Readonly<{
     readonly CROP: "crop";
     readonly TUNING: "tuning";
@@ -2101,11 +2612,14 @@ declare const COLOR_OPERATIONS_CONFIG: Readonly<{
 type SharedConfigState = {
     [K in keyof ConfigType as `*cfg/${K}`]: ConfigType[K];
 };
+type SharedCustomConfigState = {
+    [K in keyof CustomConfig as `*cfg/${K}`]: CustomConfig[K];
+};
 type BlocksRegistry = Set<LitBlock>;
 type ActivityBlockCtxState = {
-    '*currentActivity': string | null;
+    '*currentActivity': RegisteredActivityType | null;
     '*currentActivityParams': Record<string, unknown>;
-    '*history': (string | null)[];
+    '*history': (RegisteredActivityType | null)[];
     '*historyBack': (() => void) | null;
     '*closeModal': () => void;
 };
@@ -2122,6 +2636,7 @@ type UploaderBlockCtxState = ActivityBlockCtxState & {
 };
 type SolutionBlockCtxState = UploaderBlockCtxState & {
     '*solution': string | null;
+    '*lazyPlugins': LazyPluginEntry[] | null;
 };
 type CloudImageEditorState = {
     '*originalUrl': string | null;
@@ -2172,7 +2687,9 @@ type EditorToolbarState = {
     '*currentOperation': string | null;
     '*operationTooltip': string | null;
 };
+type SharedContextInstances = Map<string, ISharedInstance>;
 type DynamicBlockState = {
+    '*sharedContextInstances': SharedContextInstances;
     '*blocksRegistry': BlocksRegistry;
     '*eventEmitter': EventEmitter;
     '*localeManager': LocaleManager;
@@ -2180,6 +2697,8 @@ type DynamicBlockState = {
     '*a11y': A11y;
     '*modalManager': ModalManager | null;
     '*clipboard': ClipboardLayer;
+    '*routerLayer': RouterHooksLayer;
+    '*pluginManager': PluginManager;
 };
 type DynamicUploaderBlockState = {
     '*uploadCollection': TypedCollection<UploadEntryData>;
@@ -2190,66 +2709,7 @@ type DynamicUploaderBlockState = {
 type LocaleState = {
     [K in keyof LocaleDefinition as `*l10n/${K}`]: string;
 };
-type SharedState = SolutionBlockCtxState & SharedConfigState & CloudImageEditorState & EditorImageCropperState & EditorToolbarState & DynamicBlockState & DynamicUploaderBlockState & LocaleState;
-
-interface ISharedInstance {
-    destroy?(): void;
-}
-declare class SharedInstance {
-    protected _ctx: PubSub<SharedState>;
-    protected _sharedInstancesBag: SharedInstancesBag;
-    private _subscriptions;
-    private _cfgProxy;
-    protected _debugPrint: (...args: unknown[]) => void;
-    constructor(sharedInstancesBag: SharedInstancesBag);
-    protected addSub(unsub: () => void): void;
-    protected get _cfg(): Readonly<ConfigType>;
-    destroy(): void;
-}
-type SharedInstancesState = Pick<SharedState, '*blocksRegistry' | '*eventEmitter' | '*localeManager' | '*telemetryManager' | '*a11y' | '*clipboard' | '*modalManager' | '*uploadCollection' | '*publicApi' | '*validationManager' | '*secureUploadsManager'>;
-type SharedInstancesBag = ReturnType<typeof createSharedInstancesBag>;
-declare const createSharedInstancesBag: (getCtx: () => PubSub<SharedState>) => {
-    readonly ctx: PubSub<SharedState>;
-    readonly modalManager: ModalManager | null;
-    readonly telemetryManager: TelemetryManager;
-    readonly localeManager: LocaleManager;
-    readonly a11y: A11y;
-    readonly blocksRegistry: Set<LitBlock>;
-    readonly eventEmitter: EventEmitter;
-    readonly uploadCollection: TypedCollection<UploadEntryData>;
-    readonly secureUploadsManager: SecureUploadsManager;
-    readonly api: UploaderPublicApi;
-    readonly validationManager: ValidationManager;
-};
-
-type FuncFileValidator = (outputEntry: OutputFileEntry, api: UploaderPublicApi, options?: {
-    signal?: AbortSignal;
-}) => undefined | OutputErrorFile | Promise<undefined | OutputErrorFile>;
-type FileValidatorDescriptor = {
-    runOn: 'add' | 'upload' | 'change';
-    validator: FuncFileValidator;
-};
-type FileValidator = FileValidatorDescriptor | FuncFileValidator;
-type FuncCollectionValidator = (collection: ReturnType<typeof buildOutputCollectionState<OutputCollectionStatus>>, api: UploaderPublicApi) => undefined | OutputErrorCollection;
-declare class ValidationManager extends SharedInstance {
-    private get _uploadCollection();
-    private _commonFileValidators;
-    private _commonCollectionValidators;
-    private _queue;
-    private _runQueueDebounced;
-    private _isDestroyed;
-    private _entryValidationState;
-    constructor(sharedInstancesBag: SharedInstancesBag);
-    runFileValidators(runOn: FileValidatorDescriptor['runOn'], entryIds?: Uid[]): void;
-    runCollectionValidators(): void;
-    cleanupValidationForEntry(entry: TypedData<UploadEntryData>): void;
-    private _runFileValidatorsForEntry;
-    private _addCustomTypeToValidationError;
-    private _getEntryValidationState;
-    private _getValidatorDescriptors;
-    private _getValidatorDescriptorsForEntry;
-    destroy(): void;
-}
+type SharedState = SolutionBlockCtxState & SharedConfigState & SharedCustomConfigState & CloudImageEditorState & EditorImageCropperState & EditorToolbarState & DynamicBlockState & DynamicUploaderBlockState & LocaleState;
 
 declare const LitBlockBase: typeof LitElement & Constructor<{
     willYield: boolean;
@@ -2261,9 +2721,7 @@ declare const LitBlockBase: typeof LitElement & Constructor<{
 };
 declare class LitBlock extends LitBlockBase {
     private _cfgProxy;
-    protected _sharedContextInstances: Map<keyof SharedInstancesState, ISharedInstance>;
     static styleAttrs: string[];
-    activityType: ActivityType;
     init$: {};
     constructor();
     l10n: (str: string, variables?: Record<string, string | number>) => string;
@@ -2271,15 +2729,47 @@ declare class LitBlock extends LitBlockBase {
     protected _sharedInstancesBag: {
         readonly ctx: PubSub<SharedState>;
         readonly modalManager: ModalManager | null;
+        readonly pluginManager: PluginManager;
         readonly telemetryManager: TelemetryManager;
         readonly localeManager: LocaleManager;
         readonly a11y: A11y;
+        readonly routerLayer: RouterHooksLayer;
         readonly blocksRegistry: Set<LitBlock>;
         readonly eventEmitter: EventEmitter;
         readonly uploadCollection: TypedCollection<UploadEntryData>;
         readonly secureUploadsManager: SecureUploadsManager;
         readonly api: UploaderPublicApi;
         readonly validationManager: ValidationManager;
+        when<TName extends "modalManager" | "pluginManager" | "telemetryManager" | "localeManager" | "a11y" | "clipboard" | "routerLayer" | "blocksRegistry" | "eventEmitter" | "uploadCollection" | "secureUploadsManager" | "api" | "validationManager">(name: TName, callback: (instance: NonNullable<{
+            modalManager: ModalManager | null;
+            pluginManager: PluginManager;
+            telemetryManager: TelemetryManager;
+            localeManager: LocaleManager;
+            a11y: A11y;
+            clipboard: ClipboardLayer;
+            routerLayer: RouterHooksLayer;
+            blocksRegistry: BlocksRegistry;
+            eventEmitter: EventEmitter;
+            uploadCollection: TypedCollection<UploadEntryData>;
+            secureUploadsManager: SecureUploadsManager;
+            api: UploaderPublicApi;
+            validationManager: ValidationManager;
+        }[TName]>) => void): () => void;
+        wait<TName extends "modalManager" | "pluginManager" | "telemetryManager" | "localeManager" | "a11y" | "clipboard" | "routerLayer" | "blocksRegistry" | "eventEmitter" | "uploadCollection" | "secureUploadsManager" | "api" | "validationManager">(name: TName): Promise<NonNullable<{
+            modalManager: ModalManager | null;
+            pluginManager: PluginManager;
+            telemetryManager: TelemetryManager;
+            localeManager: LocaleManager;
+            a11y: A11y;
+            clipboard: ClipboardLayer;
+            routerLayer: RouterHooksLayer;
+            blocksRegistry: BlocksRegistry;
+            eventEmitter: EventEmitter;
+            uploadCollection: TypedCollection<UploadEntryData>;
+            secureUploadsManager: SecureUploadsManager;
+            api: UploaderPublicApi;
+            validationManager: ValidationManager;
+        }[TName]>>;
     };
     emit(type: Parameters<EventEmitter['emit']>[0], payload?: Parameters<EventEmitter['emit']>[1], options?: Parameters<EventEmitter['emit']>[2]): void;
     hasBlockInCtx(callback: (block: LitBlock) => boolean): boolean;
@@ -2291,6 +2781,7 @@ declare class LitBlock extends LitBlockBase {
     get localeManager(): LocaleManager;
     get a11y(): A11y;
     get clipboardLayer(): ClipboardLayer;
+    get routerLayer(): RouterHooksLayer;
     get blocksRegistry(): Set<LitBlock>;
     get eventEmitter(): EventEmitter;
     disconnectedCallback(): void;
@@ -2298,11 +2789,7 @@ declare class LitBlock extends LitBlockBase {
      * Called when the last block is removed from the context. Note that inheritors must run their callback before that.
      */
     private destroyCtxCallback;
-    /**
-     * 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.
-     */
+    private _getSharedContextInstances;
     protected _addSharedContextInstance<TKey extends keyof SharedInstancesState>(key: TKey, resolver: (sharedInstancesBag: SharedInstancesBag) => NonNullable<SharedInstancesState[TKey]>): 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];
@@ -2836,6 +3323,7 @@ declare class CloudImageEditorBlock extends LitBlock {
     private _hasNetworkProblems;
     private _isInitialized;
     private _pendingInitUpdate;
+    private _pendingSizeWait;
     private readonly _debouncedShowLoader;
     private readonly _imgRef;
     private readonly _cropperRef;