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

package/web/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/web/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/web/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/web/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/web/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/web/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/web/abstract/managers/__tests__/SecureUploadsManager.test.d.ts

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

package/web/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/web/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;
+}

package/web/abstract/managers/plugin/PluginTypes.d.ts

@@ -0,0 +1,146 @@
+import { ConfigType, OutputFileEntry } from '../../../types/exported';
+import { CustomConfig, CustomConfigDefinition } from '../../customConfigOptions';
+import { UploaderPublicApi } from '../../UploaderPublicApi';
+export type PluginIconRegistration = {
+    name: string;
+    svg: string;
+};
+export type PluginI18nRegistration = Record<string, Record<string, string>>;
+export type PluginSourceRegistration = {
+    id: string;
+    label: string;
+    icon?: string;
+    /**
+     * 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;
+};
+export type PluginRenderDispose = () => void;
+export type PluginRender = (el: HTMLElement, activityParams: Record<string, unknown>) => PluginRenderDispose | undefined;
+export type PluginActivityRegistration = {
+    id: string;
+    render: PluginRender;
+};
+export type PluginFileActionRegistration = {
+    id: string;
+    icon: string;
+    shouldRender: (fileEntry: OutputFileEntry) => boolean;
+    onClick: (fileEntry: OutputFileEntry) => void | Promise<void>;
+};
+export type PluginFileHookContext = {
+    /** The file to transform */
+    file: File | Blob;
+    /** MIME type of the file */
+    mimeType: string | null;
+};
+export 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 modified file and mimeType. Return the originals if no transformation is needed.
+     */
+    type: 'beforeUpload' | 'onAdd';
+    handler: (context: PluginFileHookContext) => PluginFileHookContext | Promise<PluginFileHookContext>;
+};
+export type PluginRegistryApi = {
+    registerSource: (source: PluginSourceRegistration) => PluginSourceRegistration;
+    registerActivity: (activity: PluginActivityRegistration) => PluginActivityRegistration;
+    registerFileAction: (fileAction: PluginFileActionRegistration) => PluginFileActionRegistration;
+    registerFileHook: (hook: PluginFileHookRegistration) => PluginFileHookRegistration;
+    registerIcon: (icon: PluginIconRegistration) => PluginIconRegistration;
+    registerI18n: (i18n: PluginI18nRegistration) => PluginI18nRegistration;
+    registerConfig: <T = unknown>(definition: CustomConfigDefinition<T>) => void;
+};
+/**
+ * API for managing plugin config subscriptions
+ */
+export 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
+ */
+export 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;
+};
+export type PluginFileEntryUpdate = {
+    file?: File | Blob;
+    cdnUrl?: string | null;
+    cdnUrlModifiers?: string | null;
+    mimeType?: string | null;
+};
+export 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;
+};
+export type PluginApi = {
+    registry: PluginRegistryApi;
+    config: PluginConfigApi;
+    activity: PluginActivityApi;
+    files: PluginFilesApi;
+};
+export type PluginUploaderApi = UploaderPublicApi;
+export type PluginExports = {
+    dispose?: () => void;
+};
+export type PluginSetupResult = PluginExports | void | Promise<PluginExports | void>;
+export type PluginSetupParams = {
+    pluginApi: PluginApi;
+    uploaderApi: PluginUploaderApi;
+};
+export type UploaderPlugin = {
+    id: string;
+    setup: (params: PluginSetupParams) => PluginSetupResult;
+};
+export type Owned<T> = T & {
+    pluginId: string;
+};
+export type PluginRegistrySnapshot = {
+    sources: Owned<PluginSourceRegistration>[];
+    activities: Owned<PluginActivityRegistration>[];
+    fileActions: Owned<PluginFileActionRegistration>[];
+    fileHooks: Owned<PluginFileHookRegistration>[];
+    icons: Owned<PluginIconRegistration>[];
+    i18n: Owned<PluginI18nRegistration>[];
+};

package/web/abstract/managers/plugin/index.d.ts

@@ -0,0 +1,2 @@
+export * from './PluginManager';
+export * from './PluginTypes';

package/web/abstract/sharedConfigKey.d.ts

@@ -0,0 +1,2 @@
+import { ConfigType } from '../types';
+export declare const sharedConfigKey: <T extends keyof ConfigType>(key: T) => `*cfg/${T}`;

package/web/abstract/uploadEntrySchema.d.ts

@@ -0,0 +1,34 @@
+import { Metadata, UploadcareFile } from '@uploadcare/upload-client';
+import { OutputErrorFile } from '../types/index';
+import { TypedData } from './TypedData';
+export 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;
+}
+export declare const initialUploadEntryData: UploadEntryData;
+export type UploadEntryTypedData = TypedData<UploadEntryData>;
+export type UploadEntryKeys = keyof UploadEntryData;

package/web/blocks/ActivityHeader/ActivityHeader.d.ts

@@ -0,0 +1,8 @@
+import { LitActivityBlock } from '../../lit/LitActivityBlock';
+export declare class ActivityHeader extends LitActivityBlock {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-activity-header': ActivityHeader;
+    }
+}

package/web/blocks/CameraSource/CameraSource.d.ts

@@ -0,0 +1,121 @@
+import { PropertyValues } from 'lit';
+import { LitUploaderBlock } from '../../lit/LitUploaderBlock';
+export type CameraMode = 'photo' | 'video';
+export type CameraStatus = 'shot' | 'retake' | 'accept' | 'play' | 'stop' | 'pause' | 'resume';
+export declare class CameraSource extends LitUploaderBlock {
+    couldBeCtxOwner: boolean;
+    private _unsubPermissions;
+    private _capturing;
+    private _chunks;
+    private _mediaRecorder;
+    private _stream;
+    private _selectedAudioId;
+    private _selectedCameraId;
+    private _activeTab;
+    private _options;
+    private _canvas;
+    private _ctx;
+    private _cameraDevices;
+    private _audioDevices;
+    private _permissionResponses;
+    private _permissionCleanupFns;
+    private _currentVideoSource;
+    private readonly _handlePreviewPlay;
+    private readonly _handlePreviewPause;
+    private _timerRef;
+    private _lineRef;
+    private _videoRef;
+    private _switcherRef;
+    private _startTime;
+    private _elapsedTime;
+    private _videoTransformCss;
+    private _videoHidden;
+    private _messageHidden;
+    private _requestBtnHidden;
+    private _cameraSelectOptions;
+    private _cameraSelectHidden;
+    private _l10nMessage;
+    private _timerHidden;
+    private _cameraHidden;
+    private _cameraActionsHidden;
+    private _audioSelectOptions;
+    private _audioSelectHidden;
+    private _audioSelectDisabled;
+    private _audioToggleMicrophoneHidden;
+    private _tabCameraHidden;
+    private _tabVideoHidden;
+    private _currentIcon;
+    private _currentTimelineIcon;
+    private _toggleMicrophoneIcon;
+    private _mutableClassButton;
+    private _chooseActionWithCamera;
+    private _handleCameraSelectChange;
+    private _handleAudioSelectChange;
+    private _handleRequestPermissions;
+    private _handleStartCamera;
+    private _handleToggleRecording;
+    private _handleToggleAudio;
+    private _handleRetake;
+    private _handleAccept;
+    private _handleClickTab;
+    private _updateTimer;
+    private _startTimer;
+    private _stopTimer;
+    private _startTimeline;
+    private _stopTimeline;
+    private _animationFrameId;
+    private _startRecording;
+    private _stopRecording;
+    /** This method is used to toggle recording pause/resume */
+    private _toggleRecording;
+    private _toggleEnableAudio;
+    /**
+     * Previewing the video that was recorded on the camera
+     */
+    private _previewVideo;
+    private _attachPreviewListeners;
+    private _detachPreviewListeners;
+    private _setVideoSource;
+    /**
+     * Do not bind srcObject directly in the template, because it stops video pausing on shot.
+     * I really don'y know why but that's how it is. Assigning srcObject manually fixes the issue.
+     */
+    private _applyVideoSource;
+    private _retake;
+    private _accept;
+    private _handlePhoto;
+    private _handleVideo;
+    private _setCameraState;
+    private _shot;
+    private _handleActiveTab;
+    private _createFile;
+    private _guessExtensionByMime;
+    /**
+     * The send file to the server
+     */
+    private _toSend;
+    private get _cameraModes();
+    private _setPermissionsState;
+    private _makeStreamInactive;
+    private _stopCapture;
+    private _capture;
+    private _handlePermissionsChange;
+    private _permissionAccess;
+    private _teardownPermissionListeners;
+    private _requestDeviceAccess;
+    private _getDevices;
+    private _onActivate;
+    private _onDeactivate;
+    private _handleCameraModes;
+    initCallback(): void;
+    firstUpdated(changedProperties: PropertyValues<this>): void;
+    updated(changedProperties: PropertyValues<this>): void;
+    private _destroy;
+    disconnectedCallback(): void;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-camera-source': CameraSource;
+    }
+}

package/web/blocks/CameraSource/__tests__/calcCameraModes.test.d.ts

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

package/web/blocks/CameraSource/calcCameraModes.d.ts

@@ -0,0 +1,5 @@
+import { ConfigType } from '../../types/index';
+export declare const calcCameraModes: (cfg: ConfigType) => {
+    isVideoRecordingEnabled: boolean;
+    isPhotoEnabled: boolean;
+};

package/web/blocks/CameraSource/constants.d.ts

@@ -0,0 +1,15 @@
+export declare const CameraSourceTypes: Readonly<{
+    PHOTO: "photo";
+    VIDEO: "video";
+}>;
+export declare const CameraSourceEvents: Readonly<{
+    IDLE: "idle";
+    SHOT: "shot";
+    PLAY: "play";
+    PAUSE: "pause";
+    RESUME: "resume";
+    STOP: "stop";
+    RETAKE: "retake";
+    ACCEPT: "accept";
+}>;
+export type ModeCameraType = (typeof CameraSourceTypes)[keyof typeof CameraSourceTypes];

package/web/blocks/CloudImageEditor/index.d.ts

@@ -0,0 +1 @@
+export * from './src/index';

package/web/blocks/CloudImageEditor/src/CloudImageEditorBlock.d.ts

@@ -0,0 +1,60 @@
+import { PropertyValues } from 'lit';
+import { LitBlock } from '../../../lit/LitBlock';
+import { initState } from './state.js';
+export declare class CloudImageEditorBlock extends LitBlock {
+    attributesMeta: ({
+        uuid: string;
+    } | {
+        'cdn-url': string;
+    }) & Partial<{
+        tabs: string;
+        'crop-preset': string;
+    }> & {
+        'ctx-name': string;
+    };
+    ctxOwner: boolean;
+    static styleAttrs: string[];
+    private _statusMessage;
+    private _imageSrc;
+    private _fileType;
+    private _showLoader;
+    uuid: string | null;
+    cdnUrl: string | null;
+    cropPreset: string;
+    tabs: string | null;
+    private _hasNetworkProblems;
+    private _isInitialized;
+    private _pendingInitUpdate;
+    private readonly _debouncedShowLoader;
+    private readonly _imgRef;
+    private readonly _cropperRef;
+    private readonly _faderRef;
+    private readonly _imgContainerRef;
+    private readonly _handleImageLoad;
+    private readonly _handleImageError;
+    private readonly _handleRetryNetwork;
+    private _scheduleInitialization;
+    init$: ReturnType<typeof initState>;
+    initCallback(): void;
+    private _assignSharedElements;
+    private _attachImageListeners;
+    private _detachImageListeners;
+    private get _imageClassName();
+    /**
+     * To proper work, we need non-zero size the element. So, we'll wait for it.
+     */
+    private _waitForSize;
+    firstUpdated(changedProperties: PropertyValues<this>): void;
+    disconnectedCallback(): void;
+    render(): import('lit-html').TemplateResult<1>;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    private _syncTabListFromProp;
+    private _syncCropPresetState;
+    updateImage(): Promise<void>;
+    initEditor(): Promise<void>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-cloud-image-editor-block': CloudImageEditorBlock;
+    }
+}

package/web/blocks/CloudImageEditor/src/CropFrame.d.ts

@@ -0,0 +1,56 @@
+import { PropertyValues, TemplateResult } from 'lit';
+import { LitBlock } from '../../../lit/LitBlock';
+export declare class CropFrame extends LitBlock {
+    private _backdropMask?;
+    private _backdropMaskInner?;
+    private readonly _backdropMaskId;
+    private _frameThumbs?;
+    private _frameGuides?;
+    private _draggingThumb?;
+    private _hoverThumb?;
+    private _dragStartPoint?;
+    private _dragStartCrop?;
+    private _frameImage?;
+    private _guidesHidden;
+    private _draggingValue;
+    private readonly _svgRef;
+    private _svgReady;
+    private _pendingMaskHref;
+    private get _svgElement();
+    private get _dragging();
+    private set _dragging(value);
+    private _applyGuidesDragState;
+    private _shouldThumbBeDisabled;
+    private _createBackdrop;
+    /**
+     * @private Super Tricky workaround for the chromium bug See
+     *   https://bugs.chromium.org/p/chromium/issues/detail?id=330815
+     */
+    private _resizeBackdrop;
+    private _updateBackdrop;
+    private _updateFrame;
+    private _createThumb;
+    private _createThumbs;
+    private _createGuides;
+    private _createFrame;
+    private _handlePointerDown;
+    private readonly _handlePointerUp;
+    private readonly _handlePointerMove;
+    private _calcCropBox;
+    private readonly _handleSvgPointerMove;
+    private _updateCursor;
+    private _createMask;
+    private _updateMask;
+    private _render;
+    toggleThumbs(visible: boolean): void;
+    initCallback(): void;
+    protected firstUpdated(changedProperties: PropertyValues<this>): void;
+    private _initializeSvg;
+    disconnectedCallback(): void;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-crop-frame': CropFrame;
+    }
+}