@uploadcare/file-uploader 1.27.1 → 1.28.0-alpha.0

package/dist/UrlSource-BxVL9Pve.js

@@ -0,0 +1,9 @@
+/**
+* @license
+* Package: @uploadcare/file-uploader@1.28.0-alpha.0 (MIT)
+* License: https://github.com/uploadcare/blob/main/LICENSE
+* Built: 2026-03-02T14:46:15.080Z
+*/
+import "./Icon-CqTVC82Q.js";
+import { t as UrlSource } from "./UrlSource-DZK5EBwT.js";
+export { UrlSource };

package/dist/UrlSource-DZK5EBwT.js

@@ -0,0 +1,73 @@
+/**
+* @license
+* Package: @uploadcare/file-uploader@1.28.0-alpha.0 (MIT)
+* License: https://github.com/uploadcare/blob/main/LICENSE
+* Built: 2026-03-02T14:46:15.080Z
+*/
+import { F as InternalEventType, ct as __decorate } from "./Icon-CqTVC82Q.js";
+import { c as UploadSource } from "./plugins-DxjsQUa8.js";
+import { n as LitActivityBlock, t as LitUploaderBlock } from "./LitUploaderBlock-BA34rzeU.js";
+import { html } from "lit";
+import { state } from "lit/decorators.js";
+import { createRef, ref } from "lit/directives/ref.js";
+var UrlSource = class extends LitUploaderBlock {
+	constructor(...c) {
+		super(...c), this._formState = { importDisabled: !0 }, this._inputRef = createRef(), this._handleInput = (e) => {
+			this._formState = { importDisabled: !(e.target?.value ?? "") };
+		}, this._handleUpload = (c) => {
+			c.preventDefault(), this.telemetryManager.sendEvent({
+				eventType: InternalEventType.ACTION_EVENT,
+				payload: { metadata: {
+					event: "upload-from-url",
+					node: this.tagName
+				} }
+			});
+			let l = this._inputRef.value?.value?.trim();
+			l && (this.api.addFileFromUrl(l, { source: UploadSource.URL }), this.$["*currentActivity"] = LitActivityBlock.activities.UPLOAD_LIST, this.modalManager?.open(LitActivityBlock.activities.UPLOAD_LIST));
+		};
+	}
+	firstUpdated() {
+		let e = this._inputRef.value;
+		e && (e.value = "", e.focus());
+	}
+	render() {
+		return html`
+      <uc-activity-header>
+        <button type="button" class="uc-mini-btn" @click=${this.historyBack} title=${this.l10n("back")} aria-label=${this.l10n("back")}>
+          <uc-icon name="back"></uc-icon>
+        </button>
+        <div>
+          <uc-icon name="url"></uc-icon>
+          <span>${this.l10n("caption-from-url")}</span>
+        </div>
+        <button
+          type="button"
+          class="uc-mini-btn uc-close-btn"
+          @click=${this.$["*closeModal"]}
+          title=${this.l10n("a11y-activity-header-button-close")}
+          aria-label=${this.l10n("a11y-activity-header-button-close")}
+        >
+          <uc-icon name="close"></uc-icon>
+        </button>
+      </uc-activity-header>
+      <form class="uc-content" @submit=${this._handleUpload}>
+        <label>
+          <input
+            ${ref(this._inputRef)}
+            placeholder="https://"
+            class="uc-url-input"
+            type="text"
+            @input=${this._handleInput}
+          />
+        </label>
+          <button
+            type="submit"
+            class="uc-url-upload-btn uc-primary-btn"
+            ?disabled=${this._formState.importDisabled}
+            >${this.l10n("upload-url")}</button>
+      </form>
+    `;
+	}
+};
+__decorate([state()], UrlSource.prototype, "_formState", void 0);
+export { UrlSource as t };

package/dist/abstract/CTX.d.ts

@@ -0,0 +1,40 @@
+import { UploadcareGroup, Queue } from '@uploadcare/upload-client';
+import { LitBlock } from '../lit/LitBlock';
+import { OutputCollectionState, OutputErrorCollection } from '../types/index';
+export declare const blockCtx: () => {};
+export declare const activityBlockCtx: (fnCtx: LitBlock) => {
+    '*currentActivity': null;
+    '*currentActivityParams': {};
+    '*history': never[];
+    '*historyBack': null;
+    '*closeModal': () => void;
+};
+export declare const uploaderBlockCtx: (fnCtx: LitBlock) => {
+    '*commonProgress': number;
+    '*uploadList': never[];
+    '*uploadQueue': Queue;
+    '*collectionErrors': OutputErrorCollection[];
+    '*collectionState': OutputCollectionState | null;
+    '*groupInfo': UploadcareGroup | null;
+    '*uploadTrigger': Set<string>;
+    '*currentActivity': null;
+    '*currentActivityParams': {};
+    '*history': never[];
+    '*historyBack': null;
+    '*closeModal': () => void;
+};
+export declare const solutionBlockCtx: (fnCtx: LitBlock) => {
+    '*solution': string | null;
+    '*commonProgress': number;
+    '*uploadList': never[];
+    '*uploadQueue': Queue;
+    '*collectionErrors': OutputErrorCollection[];
+    '*collectionState': OutputCollectionState | null;
+    '*groupInfo': UploadcareGroup | null;
+    '*uploadTrigger': Set<string>;
+    '*currentActivity': null;
+    '*currentActivityParams': {};
+    '*history': never[];
+    '*historyBack': null;
+    '*closeModal': () => void;
+};

package/dist/abstract/TypedCollection.d.ts

@@ -0,0 +1,47 @@
+import { Uid } from '../lit/Uid';
+import { TypedData } from './TypedData';
+type ChangeMap<T extends Record<string, unknown>> = Record<keyof T, Set<Uid>>;
+type TypedCollectionPropertyObserver<T extends Record<string, unknown>> = (changeMap: ChangeMap<T>) => void;
+export type TypedCollectionObserverHandler<T extends Record<string, unknown>> = (list: Uid[], added: Set<TypedData<T>>, removed: Set<TypedData<T>>) => void;
+type TypedCollectionOptions<T extends Record<string, unknown>> = {
+    initialValue: T;
+    watchList?: (keyof T)[];
+    handler?: TypedCollectionObserverHandler<T>;
+};
+export declare class TypedCollection<T extends Record<string, unknown>> {
+    private static readonly _destroyDelayMs;
+    private _ctxId;
+    private _data;
+    private _watchList;
+    private _subsMap;
+    private _propertyObservers;
+    private _collectionObservers;
+    private _items;
+    private _removed;
+    private _added;
+    private _markedToDestroy;
+    private _observeTimeout?;
+    private _notifyTimeout?;
+    private _destroyTimeout?;
+    private _notifyObservers;
+    private _initialValue;
+    constructor(options: TypedCollectionOptions<T>);
+    private _notify;
+    private _scheduleDestroyMarkedItems;
+    observeCollection(handler: TypedCollectionObserverHandler<T>): () => void;
+    unobserveCollection(handler: TypedCollectionObserverHandler<T>): void;
+    add(init: Partial<T>): Uid;
+    hasItem(id: Uid): boolean;
+    read(id: Uid): TypedData<T> | null;
+    readProp<K extends keyof T>(id: Uid, propName: K): T[K];
+    publishProp<K extends keyof T>(id: Uid, propName: K, value: T[K]): void;
+    remove(id: Uid): void;
+    clearAll(): void;
+    observeProperties(handler: TypedCollectionPropertyObserver<T>): () => void;
+    unobserveProperties(handler: TypedCollectionPropertyObserver<T>): void;
+    findItems(checkFn: (item: TypedData<T>) => boolean): Uid[];
+    items(): Uid[];
+    get size(): number;
+    destroy(): void;
+}
+export {};

package/dist/abstract/TypedCollection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/abstract/TypedData.d.ts

@@ -0,0 +1,12 @@
+import { Uid } from '../lit/Uid';
+export 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): import('../lit/PubSubCompat').Unsubscriber;
+    destroy(): void;
+}

package/dist/abstract/TypedData.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/abstract/UploaderPublicApi.d.ts

@@ -0,0 +1,41 @@
+import { ModeCameraType } from '../blocks/CameraSource/constants';
+import { ActivityParamsMap, ActivityType } from '../lit/LitActivityBlock';
+import { SharedInstance } from '../lit/shared-instances';
+import { OutputCollectionStatus, OutputFileEntry, OutputFileStatus } from '../types/index';
+import { buildOutputCollectionState } from './buildOutputCollectionState';
+import { UploadEntryData } from './uploadEntrySchema';
+export type ApiAddFileCommonOptions = {
+    silent?: boolean;
+    fileName?: string;
+    source?: string;
+};
+export declare class UploaderPublicApi extends SharedInstance {
+    private _l10n;
+    get _uploadCollection(): import('./TypedCollection').TypedCollection<UploadEntryData>;
+    get cfg(): Readonly<import('..').ConfigType>;
+    get l10n(): (str: string, variables?: Record<string, string | number>) => string;
+    /**
+     * TODO: Probably we should not allow user to override `source` property
+     */
+    addFileFromUrl: (url: string, { silent, fileName, source }?: ApiAddFileCommonOptions) => OutputFileEntry<"idle">;
+    addFileFromUuid: (uuid: string, { silent, fileName, source }?: ApiAddFileCommonOptions) => OutputFileEntry<"idle">;
+    addFileFromCdnUrl: (cdnUrl: string, { silent, fileName, source }?: ApiAddFileCommonOptions) => OutputFileEntry<"idle">;
+    addFileFromObject: (file: File, { silent, fileName, source, fullPath, }?: ApiAddFileCommonOptions & {
+        fullPath?: string;
+    }) => OutputFileEntry<"idle">;
+    removeFileByInternalId: (internalId: string) => void;
+    removeAllFiles(): void;
+    uploadAll: () => void;
+    openSystemDialog: (options?: {
+        captureCamera?: boolean;
+        modeCamera?: ModeCameraType;
+    }) => void;
+    getOutputItem<TStatus extends OutputFileStatus>(entryId: string): OutputFileEntry<TStatus>;
+    getOutputCollectionState<TStatus extends OutputCollectionStatus>(): ReturnType<typeof buildOutputCollectionState<TStatus>>;
+    initFlow: (force?: boolean) => void;
+    doneFlow: () => void;
+    setCurrentActivity: <T extends ActivityType>(activityType: T, ...params: T extends keyof ActivityParamsMap ? [ActivityParamsMap[T]] extends [never] ? [] : [ActivityParamsMap[T]] : []) => void;
+    getCurrentActivity: () => ActivityType;
+    setModalState: (opened: boolean) => void;
+    private get _sourceList();
+}

package/dist/abstract/buildOutputCollectionState.d.ts

@@ -0,0 +1,3 @@
+import { SharedInstancesBag } from '../lit/shared-instances';
+import { GroupFlag, OutputCollectionState, OutputCollectionStatus } from '../types/index';
+export declare function buildOutputCollectionState<TCollectionStatus extends OutputCollectionStatus, TGroupFlag extends GroupFlag = 'maybe-has-group'>(bag: SharedInstancesBag): OutputCollectionState<TCollectionStatus, TGroupFlag>;

package/dist/abstract/customConfigOptions.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Custom configuration options registration system for plugins
+ */
+export 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;
+};
+/**
+ * Custom config definition with plugin ownership tracking
+ */
+export type OwnedCustomConfigDefinition<T = unknown> = CustomConfigDefinition<T> & {
+    pluginId: string;
+};
+/**
+ * Registry for custom config options defined by plugins
+ * This is managed by the PluginManager as a shared instance property
+ */
+export 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;
+ *   }
+ * }
+ * ```
+ */
+export interface CustomConfig {
+}

package/dist/abstract/defineComponents.d.ts

@@ -0,0 +1 @@
+export declare function defineComponents(blockExports: Record<string, any>): void;

package/dist/abstract/features/ClipboardLayer.d.ts

@@ -0,0 +1,12 @@
+import { SharedInstance, SharedInstancesBag } from '../../lit/shared-instances';
+export type PasteScope = 'local' | 'global' | false;
+export declare class ClipboardLayer extends SharedInstance {
+    private scopes;
+    private listener;
+    constructor(sharedInstancesBag: SharedInstancesBag);
+    private openUploadList;
+    private _listener;
+    private handlePaste;
+    registerBlock(scope: Node): () => void;
+    destroy(): void;
+}

package/dist/abstract/loadFileUploaderFrom.d.ts

@@ -1,4 +1,4 @@
-declare const UC_WINDOW_KEY = "UC";
+export declare const UC_WINDOW_KEY = "UC";
 type IndexModule = Record<string, any>;
 declare global {
     interface Window {
@@ -9,6 +9,5 @@ declare global {
  * @param url File Uploader pack url
  * @param [register] Register connected package, if it not registered yet
  */
-declare function loadFileUploaderFrom(url: string, register?: boolean): Promise<IndexModule | null>;
-
-export { UC_WINDOW_KEY, loadFileUploaderFrom };
+export declare function loadFileUploaderFrom(url: string, register?: boolean): Promise<IndexModule | null>;
+export {};

package/dist/abstract/loadFileUploaderFrom.js

@@ -1,7 +1,8 @@
 /**
- * @license
- * Package: @uploadcare/file-uploader@1.27.1 (MIT)
- * License: https://github.com/uploadcare/blob/main/LICENSE
- * Built: 2026-02-16T22:57:30.783Z
- */
-var l=["UploaderBlock","ActivityBlock","Block","SolutionBlock"];function c(t){for(let n in t){if(l.includes(n))continue;let e=[...n].reduce((i,o)=>(o.toUpperCase()===o&&(o=`-${o.toLowerCase()}`),i+=o,i),"");e.startsWith("-")&&(e=e.replace("-","")),e.startsWith("uc-")||(e=`uc-${e}`),t[n].reg&&t[n].reg(e);}}var r="UC";function a(t,n=false){return new Promise((e,i)=>{if(typeof document!="object"){e(null);return}if(typeof window=="object"&&window[r]){e(window[r]);return}let o=document.createElement("script");o.async=true,o.src=t,o.onerror=()=>{i();},o.onload=()=>{let d=window[r];n&&c(d),e(d);},document.head.appendChild(o);})}export{r as UC_WINDOW_KEY,a as loadFileUploaderFrom};
+* @license
+* Package: @uploadcare/file-uploader@1.28.0-alpha.0 (MIT)
+* License: https://github.com/uploadcare/blob/main/LICENSE
+* Built: 2026-03-02T14:46:15.080Z
+*/
+import { n as loadFileUploaderFrom, t as UC_WINDOW_KEY } from "../loadFileUploaderFrom-BWJM43Yq.js";
+export { UC_WINDOW_KEY, loadFileUploaderFrom };

package/dist/abstract/localeRegistry.d.ts

@@ -0,0 +1,5 @@
+import { default as en } from '../locales/file-uploader/en';
+export type LocaleDefinition = typeof en;
+export type LocaleDefinitionResolver = () => Promise<LocaleDefinition>;
+export declare const defineLocale: (localeName: string, definitionOrResolver: LocaleDefinition | LocaleDefinitionResolver) => void;
+export declare const resolveLocaleDefinition: (localeName: string) => Promise<LocaleDefinition>;

package/dist/abstract/managers/LocaleManager.d.ts

@@ -0,0 +1,10 @@
+import { SharedInstance, SharedInstancesBag } from '../../lit/shared-instances';
+import { LocaleDefinition } from '../localeRegistry';
+export declare const localeStateKey: <T extends keyof LocaleDefinition>(key: T) => `*l10n/${T}`;
+export declare const DEFAULT_LOCALE = "en";
+export declare class LocaleManager extends SharedInstance {
+    private _localeName;
+    constructor(sharedInstancesBag: SharedInstancesBag);
+    private _applyOverrides;
+    private _applyPluginLocales;
+}

package/dist/abstract/managers/ModalManager.d.ts

@@ -0,0 +1,53 @@
+import { Modal as ModalNode } from '../../blocks/Modal/Modal';
+import { ActivityType } from '../../lit/LitActivityBlock';
+import { SharedInstance } from '../../lit/shared-instances';
+export declare const ModalEvents: Readonly<{
+    readonly ADD: "modal:add";
+    readonly DELETE: "modal:delete";
+    readonly OPEN: "modal:open";
+    readonly CLOSE: "modal:close";
+    readonly CLOSE_ALL: "modal:closeAll";
+    readonly DESTROY: "modal:destroy";
+}>;
+export type ModalId = ActivityType;
+export type ModalCb = (data: {
+    id: ModalId;
+    modal: ModalNode;
+}) => void;
+export type ModalEventType = (typeof ModalEvents)[keyof typeof ModalEvents];
+export declare class ModalManager extends SharedInstance {
+    private _modals;
+    private _activeModals;
+    private _subscribers;
+    /**
+     * Register a modal with the manager
+     * @param id Unique identifier for the modal
+     * @param modal Modal component instance
+     */
+    registerModal(id: ModalId, modal: ModalNode): void;
+    /** Remove a modal by ID. */
+    deleteModal(id: ModalId): boolean;
+    /** Open a modal by its ID. */
+    open(id: ModalId): boolean;
+    /** Close a specific modal by ID. */
+    close(id: ModalId): boolean;
+    /** Toggle a modal - open if closed, close if open. */
+    toggle(id: ModalId): boolean;
+    /** True if there are any active modals. */
+    get hasActiveModals(): boolean;
+    /** Close the most recently opened modal and return to the previous one. */
+    back(): boolean;
+    /** Close all open modals. */
+    closeAll(): number;
+    /**
+     * Subscribe to modal events
+     * @returns Unsubscribe function
+     */
+    subscribe(event: ModalEventType, callback: ModalCb): () => void;
+    /** Unsubscribe from modal events */
+    unsubscribe(event: ModalEventType, callback: ModalCb | undefined): void;
+    /** Notify all subscribers of a modal event. */
+    private _notify;
+    /** Destroy the modal manager, clean up resources */
+    destroy(): void;
+}

package/dist/abstract/managers/SecureUploadsManager.d.ts

@@ -0,0 +1,7 @@
+import { SharedInstance } from '../../lit/shared-instances';
+import { SecureUploadsSignatureAndExpire } from '../../types/index';
+export declare class SecureUploadsManager extends SharedInstance {
+    private _secureToken;
+    getSecureToken(): Promise<SecureUploadsSignatureAndExpire | null>;
+    destroy(): void;
+}

package/dist/abstract/managers/TelemetryManager.d.ts

@@ -0,0 +1,41 @@
+import { TelemetryRequest } from '@uploadcare/quality-insights';
+import { EventKey, InternalEventKey } from '../../blocks/UploadCtxProvider/EventEmitter';
+import { SharedInstance, SharedInstancesBag } from '../../lit/shared-instances';
+type CommonEventType = InternalEventKey | EventKey;
+type TelemetryState = TelemetryRequest & {
+    eventTimestamp: number;
+    location: string;
+};
+type TelemetryEventBody = Partial<Pick<TelemetryState, 'payload' | 'config'>> & {
+    modalId?: string;
+    eventType?: CommonEventType;
+};
+export 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();
+}
+export {};

package/dist/abstract/managers/ValidationManager.d.ts

@@ -0,0 +1,34 @@
+import { SharedInstance, SharedInstancesBag } from '../../lit/shared-instances';
+import { Uid } from '../../lit/Uid';
+import { OutputCollectionStatus, OutputErrorCollection, OutputErrorFile, OutputFileEntry, UploaderPublicApi } from '../../types';
+import { buildOutputCollectionState } from '../buildOutputCollectionState';
+import { TypedData } from '../TypedData';
+import { UploadEntryData } from '../uploadEntrySchema';
+export type FuncFileValidator = (outputEntry: OutputFileEntry, api: UploaderPublicApi, options?: {
+    signal?: AbortSignal;
+}) => undefined | OutputErrorFile | Promise<undefined | OutputErrorFile>;
+export type FileValidatorDescriptor = {
+    runOn: 'add' | 'upload' | 'change';
+    validator: FuncFileValidator;
+};
+export type FileValidator = FileValidatorDescriptor | FuncFileValidator;
+export type FuncCollectionValidator = (collection: ReturnType<typeof buildOutputCollectionState<OutputCollectionStatus>>, api: UploaderPublicApi) => undefined | OutputErrorCollection;
+export 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;
+}

package/dist/abstract/managers/__tests__/ModalManager.test.d.ts

@@ -0,0 +1,13 @@
+declare module '../../../lit/LitActivityBlock' {
+    interface CustomActivities {
+        'test-modal': {
+            params: never;
+        };
+        'modal-1': {
+            params: never;
+        };
+        'modal-2': {
+            params: never;
+        };
+    }
+}

package/dist/abstract/managers/__tests__/SecureUploadsManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/abstract/managers/a11y.d.ts

@@ -0,0 +1,9 @@
+import { LitBlock } from '../../lit/LitBlock';
+import { ISharedInstance } from '../../lit/shared-instances';
+export declare class A11y implements ISharedInstance {
+    private _destroyKeyUX;
+    private readonly _scopedWindow;
+    constructor();
+    registerBlock(scope: LitBlock): void;
+    destroy(): void;
+}

package/dist/abstract/managers/plugin/PluginManager.d.ts

@@ -0,0 +1,25 @@
+import { SharedInstance, SharedInstancesBag } from '../../../lit/shared-instances';
+import { CustomConfigRegistry } from '../../customConfigOptions';
+import { PluginRegistrySnapshot } from './PluginTypes';
+export declare class PluginManager extends SharedInstance {
+    private _plugins;
+    private _sources;
+    private _activities;
+    private _fileActions;
+    private _fileHooks;
+    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;
+}