@uploadcare/file-uploader 1.26.3 → 1.27.0-alpha.1

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';
 
@@ -230,6 +230,81 @@ declare global {
     }
 }
 
+declare class A11y implements ISharedInstance {
+    private _destroyKeyUX;
+    private readonly _scopedWindow;
+    constructor();
+    registerBlock(scope: LitBlock): void;
+    destroy(): void;
+}
+
+declare class LocaleManager extends SharedInstance {
+    private _localeName;
+    constructor(sharedInstancesBag: SharedInstancesBag);
+    private _applyOverrides;
+    private _applyPluginLocales;
+}
+
+/**
+ * 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;
+};
+/**
+ * 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 const InternalEventType: Readonly<{
     readonly INIT_SOLUTION: "init-solution";
     readonly CHANGE_CONFIG: "change-config";
@@ -296,6 +371,80 @@ declare class EventEmitter extends SharedInstance {
     destroy(): void;
 }
 
+declare function buildOutputCollectionState<TCollectionStatus extends OutputCollectionStatus, TGroupFlag extends GroupFlag = 'maybe-has-group'>(bag: SharedInstancesBag): OutputCollectionState<TCollectionStatus, TGroupFlag>;
+
+declare class TypedData<T extends Record<string, unknown>> {
+    private _ctxId;
+    private _data;
+    constructor(initialValue: T);
+    get uid(): Uid;
+    setValue<K extends keyof T>(prop: K, value: T[K]): void;
+    setMultipleValues(updObj: Partial<T>): void;
+    getValue<K extends keyof T>(prop: K): T[K];
+    subscribe<K extends keyof T>(prop: K, handler: (newVal: T[K]) => void): 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;
+
+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;
+}
+
 declare class ActivityHeader extends LitActivityBlock {
 }
 declare global {
@@ -307,11 +456,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 {
@@ -459,25 +611,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"];
-/** 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 {
@@ -485,49 +666,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;
@@ -604,12 +742,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;
@@ -621,6 +759,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;
@@ -799,8 +939,6 @@ declare const CameraSourceTypes: Readonly<{
 }>;
 type ModeCameraType = (typeof CameraSourceTypes)[keyof typeof CameraSourceTypes];
 
-declare function buildOutputCollectionState<TCollectionStatus extends OutputCollectionStatus, TGroupFlag extends GroupFlag = 'maybe-has-group'>(bag: SharedInstancesBag): OutputCollectionState<TCollectionStatus, TGroupFlag>;
-
 type ApiAddFileCommonOptions = {
     silent?: boolean;
     fileName?: string;
@@ -831,7 +969,7 @@ 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;
+    setCurrentActivity: <T extends ActivityType>(activityType: T, ...params: T extends keyof ActivityParamsMap ? [ActivityParamsMap[T]] extends [never] ? [] : [ActivityParamsMap[T]] : []) => void;
     getCurrentActivity: () => ActivityType;
     setModalState: (opened: boolean) => void;
     private get _sourceList();
@@ -1049,6 +1187,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.
      */
@@ -1296,6 +1438,251 @@ type OutputCollectionState<TStatus extends OutputCollectionStatus = OutputCollec
     allEntries: OutputFileEntry[];
 });
 
+type PluginVersion = string;
+type PluginIconRegistration = {
+    name: string;
+    svg: string;
+};
+type PluginI18nRegistration = Record<string, Record<string, string>>;
+type PluginSourceRegistration = {
+    id: string;
+    label: string;
+    icon?: 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 = {
+    id: string;
+    icon: string;
+    shouldRender: (fileEntry: OutputFileEntry) => boolean;
+    onClick: (fileEntry: OutputFileEntry) => void | Promise<void>;
+};
+type PluginRegistryApi = {
+    registerSource: (source: PluginSourceRegistration) => PluginSourceRegistration;
+    registerActivity: (activity: PluginActivityRegistration) => PluginActivityRegistration;
+    registerFileAction: (fileAction: PluginFileActionRegistration) => PluginFileActionRegistration;
+    registerIcon: (icon: PluginIconRegistration) => PluginIconRegistration;
+    registerI18n: (i18n: PluginI18nRegistration) => PluginI18nRegistration;
+    registerConfig: <T = unknown>(definition: CustomConfigDefinition<T>) => void;
+};
+/**
+ * API for managing plugin config subscriptions
+ */
+type PluginConfigApi = {
+    /**
+     * Get the current value of a config option.
+     *
+     * @param configName - The name of the config to get
+     * @returns The current config value
+     *
+     * @example
+     * ```typescript
+     * const theme = pluginApi.config.get('my-theme');
+     * console.log('Current theme:', theme);
+     * ```
+     */
+    get: <T = unknown>(configName: keyof (ConfigType & CustomConfig)) => T;
+    /**
+     * Subscribe to changes in a custom config value.
+     * The callback will be called immediately with the current value,
+     * and then whenever the value changes.
+     *
+     * Subscriptions are automatically cleaned up when the plugin is disposed.
+     *
+     * @param configName - The name of the custom config to subscribe to
+     * @param callback - Function to call with the new value
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * pluginApi.config.subscribe('my-option', (value) => {
+     *   console.log('Config changed:', value);
+     * });
+     * // Cleanup happens automatically on plugin disposal
+     * ```
+     */
+    subscribe: <T = unknown>(configName: keyof (ConfigType & CustomConfig), callback: (value: T) => 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 PluginApi = {
+    registry: PluginRegistryApi;
+    config: PluginConfigApi;
+    activity: PluginActivityApi;
+};
+type PluginUploaderApi = UploaderPublicApi;
+type PluginExports = {
+    dispose?: () => void;
+};
+type PluginSetupResult = PluginExports | void | Promise<PluginExports | void>;
+type PluginSetupParams = {
+    pluginApi: PluginApi;
+    uploaderApi: PluginUploaderApi;
+};
+type UploaderPlugin = {
+    id: string;
+    version: PluginVersion;
+    setup: (params: PluginSetupParams) => PluginSetupResult;
+};
+type Owned<T> = T & {
+    pluginId: string;
+};
+type PluginRegistrySnapshot = {
+    sources: Owned<PluginSourceRegistration>[];
+    activities: Owned<PluginActivityRegistration>[];
+    fileActions: Owned<PluginFileActionRegistration>[];
+    icons: Owned<PluginIconRegistration>[];
+    i18n: Owned<PluginI18nRegistration>[];
+};
+
+declare class PluginManager extends SharedInstance {
+    private _plugins;
+    private _sources;
+    private _activities;
+    private _fileActions;
+    private _icons;
+    private _i18n;
+    private _subscribers;
+    private _pluginsUpdate;
+    readonly configRegistry: CustomConfigRegistry;
+    constructor(sharedInstancesBag: SharedInstancesBag);
+    onPluginsChange(callback: () => void): () => void;
+    private _syncPlugins;
+    private _registerPlugin;
+    private _unregisterPlugin;
+    snapshot(): PluginRegistrySnapshot;
+    destroy(): void;
+    private _register;
+    private _purgeRegistrations;
+    private _notifySubscribers;
+}
+
+type CommonEventType = InternalEventKey | EventKey;
+type TelemetryState = TelemetryRequest & {
+    eventTimestamp: number;
+    location: string;
+};
+type TelemetryEventBody = Partial<Pick<TelemetryState, 'payload' | 'config'>> & {
+    modalId?: string;
+    eventType?: CommonEventType;
+};
+declare class TelemetryManager extends SharedInstance {
+    private readonly _sessionId;
+    private readonly _telemetryInstance;
+    private _config;
+    private _initialized;
+    private _lastPayload;
+    private readonly _queue;
+    private _isEnabled;
+    constructor(sharedInstancesBag: SharedInstancesBag);
+    private _init;
+    private _setConfig;
+    private _formattingPayload;
+    private _excludedEvents;
+    sendEvent(body: TelemetryEventBody): void;
+    sendEventError(error: unknown, context?: string): void;
+    /**
+     * Method to send telemetry event for Cloud Image Editor.
+     */
+    sendEventCloudImageEditor(e: MouseEvent, tabId: string, options?: Record<string, unknown>): void;
+    /**
+     * Deeply compares two objects and returns true if they are equal, false otherwise.
+     */
+    private _checkObj;
+    private get _timestamp();
+    private get _solution();
+    private get _activity();
+    private get _location();
+}
+
+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";
+    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 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;
+};
+
 declare class SecureUploadsManager extends SharedInstance {
     private _secureToken;
     getSecureToken(): Promise<SecureUploadsSignatureAndExpire | null>;
@@ -1410,12 +1797,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;
@@ -1494,13 +1880,17 @@ declare const ACTIVITY_TYPES: Readonly<{
     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;
@@ -1517,7 +1907,7 @@ 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';
@@ -1538,8 +1928,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;
 }
 
@@ -1729,18 +2119,20 @@ declare global {
     }
 }
 
+type SourceButtonConfig = {
+    id: string;
+    label: string;
+    icon?: string;
+    onClick: () => void | Promise<void>;
+};
 declare class SourceBtn extends LitUploaderBlock {
     couldBeCtxOwner: boolean;
-    private _registeredTypes;
-    type?: string;
+    source?: SourceButtonConfig;
     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 {
@@ -1749,9 +2141,11 @@ declare global {
     }
 }
 
-declare class SourceList extends LitBlock {
+declare class SourceList extends LitUploaderBlock {
     private _rawSourceList;
     private _cameraModes;
+    private _unsubscribePlugins?;
+    private _sources;
     /**
      * CSS-only attribute
      */
@@ -1759,8 +2153,12 @@ declare class SourceList extends LitBlock {
     initCallback(): void;
     protected updated(changedProperties: PropertyValues<this>): void;
     private _updateSources;
-    private _sources;
+    private _expandSource;
+    private _makeBuiltInSourceConfig;
+    private _makePluginSourceConfig;
+    private _openActivity;
     render(): lit_html.TemplateResult<1>;
+    disconnectedCallback(): void;
 }
 declare global {
     interface HTMLElementTagNameMap {
@@ -1823,13 +2221,11 @@ declare global {
 }
 
 declare class UrlSource extends LitUploaderBlock {
-    couldBeCtxOwner: boolean;
-    activityType: ActivityType;
     private _formState;
-    initCallback(): void;
     private _inputRef;
     private _handleInput;
     private _handleUpload;
+    firstUpdated(): void;
     render(): lit_html.TemplateResult<1>;
 }
 declare global {
@@ -1853,6 +2249,35 @@ declare global {
     }
 }
 
+declare class PluginActivityHost extends LitActivityBlock {
+    registration: Owned<PluginActivityRegistration>;
+    activityType: ActivityType;
+    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-plugin-activity-host': PluginActivityHost;
+        'uc-plugin-activity-renderer': PluginActivityRenderer;
+    }
+}
+
 declare class FileUploaderRegular extends LitSolutionBlock {
     attributesMeta: {
         headless?: boolean;
@@ -1913,57 +2338,6 @@ declare global {
     }
 }
 
-declare class A11y implements ISharedInstance {
-    private _destroyKeyUX;
-    private readonly _scopedWindow;
-    constructor();
-    registerBlock(scope: LitBlock): void;
-    destroy(): void;
-}
-
-declare class LocaleManager extends SharedInstance {
-    private _localeName;
-    constructor(sharedInstancesBag: SharedInstancesBag);
-}
-
-type CommonEventType = InternalEventKey | EventKey;
-type TelemetryState = TelemetryRequest & {
-    eventTimestamp: number;
-    location: string;
-};
-type TelemetryEventBody = Partial<Pick<TelemetryState, 'payload' | 'config'>> & {
-    modalId?: string;
-    eventType?: CommonEventType;
-};
-declare class TelemetryManager extends SharedInstance {
-    private readonly _sessionId;
-    private readonly _telemetryInstance;
-    private _config;
-    private _initialized;
-    private _lastPayload;
-    private readonly _queue;
-    private _isEnabled;
-    constructor(sharedInstancesBag: SharedInstancesBag);
-    private _init;
-    private _setConfig;
-    private _formattingPayload;
-    private _excludedEvents;
-    sendEvent(body: TelemetryEventBody): void;
-    sendEventError(error: unknown, context?: string): void;
-    /**
-     * Method to send telemetry event for Cloud Image Editor.
-     */
-    sendEventCloudImageEditor(e: MouseEvent, tabId: string, options?: Record<string, unknown>): void;
-    /**
-     * Deeply compares two objects and returns true if they are equal, false otherwise.
-     */
-    private _checkObj;
-    private get _timestamp();
-    private get _solution();
-    private get _activity();
-    private get _location();
-}
-
 declare const TabId: Readonly<{
     readonly CROP: "crop";
     readonly TUNING: "tuning";
@@ -2030,9 +2404,9 @@ type SharedConfigState = {
 };
 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;
 };
@@ -2099,13 +2473,16 @@ type EditorToolbarState = {
     '*currentOperation': string | null;
     '*operationTooltip': string | null;
 };
+type SharedContextInstances = Map<string, ISharedInstance>;
 type DynamicBlockState = {
+    '*sharedContextInstances': SharedContextInstances;
     '*blocksRegistry': BlocksRegistry;
     '*eventEmitter': EventEmitter;
     '*localeManager': LocaleManager;
     '*telemetryManager': TelemetryManager;
     '*a11y': A11y;
     '*modalManager': ModalManager | null;
+    '*pluginManager': PluginManager;
 };
 type DynamicUploaderBlockState = {
     '*uploadCollection': TypedCollection<UploadEntryData>;
@@ -2118,65 +2495,6 @@ type LocaleState = {
 };
 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' | '*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;
-}
-
 declare const LitBlockBase: typeof LitElement & Constructor<{
     willYield: boolean;
     yield(slot: string, defaultContent?: unknown): unknown;
@@ -2187,7 +2505,6 @@ 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$: {};
@@ -2197,6 +2514,7 @@ 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;
@@ -2206,6 +2524,19 @@ declare class LitBlock extends LitBlockBase {
         readonly secureUploadsManager: SecureUploadsManager;
         readonly api: UploaderPublicApi;
         readonly validationManager: ValidationManager;
+        when<TName extends "modalManager" | "pluginManager" | "telemetryManager" | "localeManager" | "a11y" | "blocksRegistry" | "eventEmitter" | "uploadCollection" | "secureUploadsManager" | "api" | "validationManager">(name: TName, callback: (instance: NonNullable<{
+            modalManager: ModalManager | null;
+            pluginManager: PluginManager;
+            telemetryManager: TelemetryManager;
+            localeManager: LocaleManager;
+            a11y: A11y;
+            blocksRegistry: BlocksRegistry;
+            eventEmitter: EventEmitter;
+            uploadCollection: TypedCollection<UploadEntryData>;
+            secureUploadsManager: SecureUploadsManager;
+            api: UploaderPublicApi;
+            validationManager: ValidationManager;
+        }[TName]>) => void): () => void;
     };
     emit(type: Parameters<EventEmitter['emit']>[0], payload?: Parameters<EventEmitter['emit']>[1], options?: Parameters<EventEmitter['emit']>[2]): void;
     hasBlockInCtx(callback: (block: LitBlock) => boolean): boolean;
@@ -2223,11 +2554,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];