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

package/dist/blocks/Config/Config.d.ts

@@ -0,0 +1,60 @@
+import { CustomConfig } from '../../abstract/customConfigOptions';
+import { ConfigPlainType, ConfigType } from '../../types';
+import { LitBlock } from '../../lit/LitBlock';
+/**
+ * Config keys that can't be passed as attribute (because they are object or function)
+ */
+export declare const complexConfigKeys: readonly ["metadata", "plugins", "localeDefinitionOverride", "secureUploadsSignatureResolver", "secureDeliveryProxyUrlResolver", "iconHrefResolver", "fileValidators", "collectionValidators", "mediaRecorderOptions"];
+export 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: string, oldVal: string, newVal: string): void;
+    disconnectedCallback(): void;
+    static get observedAttributes(): string[];
+}
+export interface Config extends ConfigType, CustomConfig {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-config': Config;
+    }
+}

package/dist/blocks/Config/assertions.d.ts

@@ -0,0 +1,5 @@
+import { ConfigType } from '../../types/index';
+/** Runs on every config change and warns about potential issues. */
+export declare const runAssertions: ((cfg: ConfigType) => void) & {
+    cancel: () => void;
+};

package/dist/blocks/Config/computed-properties.d.ts

@@ -0,0 +1,24 @@
+import { ConfigType } from '../../types/index';
+type ConfigKey = keyof ConfigType;
+type ConfigValue<TKey extends ConfigKey> = ConfigType[TKey];
+type DepKeys<TKey extends ConfigKey> = ReadonlyArray<Exclude<ConfigKey, TKey>>;
+type ComputedPropertyArgs<TKey extends ConfigKey, TDeps extends DepKeys<TKey>> = {
+    [K in TKey]: () => ConfigValue<K>;
+} & {
+    [K in TDeps[number]]: () => ConfigValue<K>;
+};
+type ComputedPropertyOptions = {
+    signal: AbortSignal;
+};
+type ComputedPropertyFn<TKey extends ConfigKey, TDeps extends DepKeys<TKey>> = (args: ComputedPropertyArgs<TKey, TDeps>, options: ComputedPropertyOptions) => ConfigValue<TKey> | Promise<ConfigValue<TKey>>;
+export type ComputedPropertyControllers = Map<ComputedPropertyFn<any, any>, AbortController>;
+type ConfigSetter = <TSetValue extends ConfigKey>(key: TSetValue, value: ConfigValue<TSetValue>) => void;
+type ConfigGetter = <TGetValue extends ConfigKey>(key: TGetValue) => ConfigValue<TGetValue>;
+type ComputePropertyOptions<TKey extends ConfigKey> = {
+    key: TKey;
+    setValue: ConfigSetter;
+    getValue: ConfigGetter;
+    computationControllers: ComputedPropertyControllers;
+};
+export declare const computeProperty: <TKey extends ConfigKey>({ key, setValue, getValue, computationControllers, }: ComputePropertyOptions<TKey>) => void;
+export {};

package/dist/blocks/Config/computed-properties.test.d.ts

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

package/dist/blocks/Config/initialConfig.d.ts

@@ -0,0 +1,6 @@
+import { ConfigType } from '../../types/exported';
+export declare const DEFAULT_CDN_CNAME = "https://ucarecdn.com";
+export declare const DEFAULT_BASE_URL = "https://upload.uploadcare.com";
+export declare const DEFAULT_SOCIAL_BASE_URL = "https://social.uploadcare.com";
+export declare const DEFAULT_PREFIXED_CDN_BASE_DOMAIN = "https://ucarecd.net";
+export declare const initialConfig: Readonly<ConfigType>;

package/dist/blocks/Config/normalizeConfigValue.d.ts

@@ -0,0 +1,2 @@
+import { ConfigType } from '../../types/index';
+export declare const normalizeConfigValue: <T extends keyof ConfigType>(key: T, value: unknown) => ConfigType[T] | undefined;

package/dist/blocks/Config/validatorsType.d.ts

@@ -0,0 +1,18 @@
+import { PasteScope } from '../../abstract/features/ClipboardLayer';
+import { Metadata, MetadataCallback } from '../../types/index';
+import { ModeCameraType } from '../CameraSource/constants';
+import { FilesViewMode } from '../UploadList/UploadList';
+declare const asString: (value: unknown) => string;
+declare const asNumber: (value: unknown) => number;
+declare const asBoolean: (value: unknown) => boolean;
+declare const asStore: (value: unknown) => boolean | "auto";
+declare const asCameraCapture: (value: unknown) => "" | "user" | "environment";
+declare const asCameraMode: (value: unknown) => ModeCameraType;
+declare const asCameraModes: (value: unknown) => string;
+declare const asPasteScope: (value: unknown) => PasteScope;
+declare const asMetadata: (value: unknown) => Metadata | MetadataCallback;
+declare const asObject: <T>(value: unknown) => T;
+declare const asFunction: <T>(value: unknown) => T;
+declare const asArray: <T>(value: unknown) => T;
+declare const asFilesViewMode: (value: unknown) => FilesViewMode;
+export { asArray, asBoolean, asCameraCapture, asCameraMode, asCameraModes, asFilesViewMode, asFunction, asMetadata, asNumber, asObject, asStore, asString, asPasteScope, };

package/dist/blocks/Copyright/Copyright.d.ts

@@ -0,0 +1,10 @@
+import { LitBlock } from '../../lit/LitBlock';
+export declare class Copyright extends LitBlock {
+    initCallback(): void;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-copyright': Copyright;
+    }
+}

package/dist/blocks/DropArea/DropArea.d.ts

@@ -0,0 +1,47 @@
+import { PropertyValues } from 'lit';
+import { LitUploaderBlock } from '../../lit/LitUploaderBlock';
+export declare class DropArea extends LitUploaderBlock {
+    static styleAttrs: string[];
+    /**
+     * CSS-only attribute
+     */
+    single: boolean;
+    /**
+     * CSS-only attribute
+     */
+    ghost: boolean;
+    disabled: boolean;
+    clickable: boolean;
+    withIcon: boolean;
+    fullscreen: boolean;
+    initflow: boolean;
+    text?: string;
+    private _isEnabled;
+    private _isVisible;
+    private get _localizedText();
+    private _destroyDropzone;
+    private _destroyContentWrapperDropzone;
+    private _contentWrapperRef;
+    private readonly _handleAreaInteraction;
+    private _sourceListAllowsLocal;
+    private _clickableListenersAttached;
+    isActive(): boolean;
+    initCallback(): void;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    /** Ignore drop events if there are other visible drop areas on the page. */
+    private _shouldIgnore;
+    private _couldHandleFiles;
+    private _updateIsEnabled;
+    private _updateVisibility;
+    private _updateDragStateAttribute;
+    private _setupContentWrapperDropzone;
+    private _updateClickableListeners;
+    disconnectedCallback(): void;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-drop-area': DropArea;
+    }
+}

package/dist/blocks/DropArea/addDropzone.d.ts

@@ -0,0 +1,17 @@
+import { getDropItems } from './getDropItems';
+export declare const DropzoneState: Readonly<{
+    readonly ACTIVE: 0;
+    readonly INACTIVE: 1;
+    readonly NEAR: 2;
+    readonly OVER: 3;
+}>;
+export type DropzoneStateValue = (typeof DropzoneState)[keyof typeof DropzoneState];
+type DropItems = Awaited<ReturnType<typeof getDropItems>>;
+type DropzoneDescriptor = {
+    element: HTMLElement;
+    onChange: (state: DropzoneStateValue) => void;
+    onItems: (items: DropItems) => void;
+    shouldIgnore: () => boolean;
+};
+export declare function addDropzone(desc: DropzoneDescriptor): () => void;
+export {};

package/dist/blocks/DropArea/getDropItems.d.ts

@@ -0,0 +1,12 @@
+export type DropItem = {
+    type: 'file';
+    file: File;
+    fullPath?: string;
+} | {
+    type: 'url';
+    url: string;
+};
+/**
+ * Note: dataTransfer will be destroyed outside of the call stack. So, do not try to process it asynchronous.
+ */
+export declare function getDropItems(dataTransfer: DataTransfer): Promise<DropItem[]>;

package/dist/blocks/ExternalSource/ExternalSource.d.ts

@@ -0,0 +1,45 @@
+import { LitUploaderBlock } from '../../lit/LitUploaderBlock';
+export type ActivityParams = {
+    externalSourceType: string;
+};
+export declare class ExternalSource extends LitUploaderBlock {
+    couldBeCtxOwner: boolean;
+    private _messageBridge?;
+    private _iframeRef;
+    private _latestSelectionSummary;
+    private _selectedList;
+    private _isSelectionReady;
+    private _isDoneBtnEnabled;
+    private _couldSelectAll;
+    private _couldDeselectAll;
+    private _showSelectionStatus;
+    private _showDoneBtn;
+    private _doneBtnTextClass;
+    private _toolbarVisible;
+    private get _counterText();
+    get activityParams(): ActivityParams;
+    initCallback(): void;
+    private _extractUrlFromSelectedFile;
+    private _handleToolbarStateChange;
+    private _handleSelectedFilesChange;
+    private _handleIframeLoad;
+    private _applyTheme;
+    private _applyEmbedCss;
+    private _setupL10n;
+    private _remoteUrl;
+    private _handleDone;
+    private _handleCancel;
+    private _handleSelectAll;
+    private _handleDeselectAll;
+    private _setSelectionSummary;
+    private _mountIframe;
+    private _unmountIframe;
+    private _resetSelectionStatus;
+    disconnectedCallback(): void;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-external-source': ExternalSource;
+    }
+}

package/dist/blocks/ExternalSource/MessageBridge.d.ts

@@ -0,0 +1,11 @@
+import { InputMessageHandler, InputMessageType, OutputMessage } from './types';
+export declare class MessageBridge {
+    private _handlerMap;
+    private _context;
+    private _getTargetOrigin;
+    constructor(context: Window, getTargetOrigin: () => string);
+    private _handleMessage;
+    on<T extends InputMessageType>(type: T, handler: InputMessageHandler<T>): void;
+    send(message: OutputMessage): void;
+    destroy(): void;
+}

package/dist/blocks/ExternalSource/buildThemeDefinition.d.ts

@@ -0,0 +1,4 @@
+import { ThemeDefinition } from './types';
+type ThemeCustomProperty = keyof ThemeDefinition;
+export declare const buildThemeDefinition: (element: HTMLElement) => Record<ThemeCustomProperty, string>;
+export {};

package/dist/blocks/ExternalSource/query-string.d.ts

@@ -0,0 +1 @@
+export declare function queryString(params: Record<string, string | number | boolean | null | undefined>): string;

package/dist/blocks/ExternalSource/types.d.ts

@@ -0,0 +1,105 @@
+export type DoneSuccessResponse = {
+    error?: undefined;
+    alternatives?: Record<string, string>;
+    is_image?: boolean | null;
+    filename?: string;
+    obj_type: 'selected_file';
+    url: string;
+};
+export type InputMessageMap = {
+    'selected-files-change': {
+        type: 'selected-files-change';
+        total: number;
+        selectedCount: number;
+    } & ({
+        isReady: false;
+        isMultipleMode: boolean;
+        selectedFiles: undefined;
+    } | {
+        isReady: true;
+        isMultipleMode: true;
+        selectedFiles: DoneSuccessResponse[];
+    } | {
+        isReady: true;
+        isMultipleMode: false;
+        selectedFiles: [DoneSuccessResponse] | [];
+    });
+    'toolbar-state-change': {
+        type: 'toolbar-state-change';
+        isVisible: boolean;
+    };
+};
+export type InputMessageType = keyof InputMessageMap;
+export type InputMessage = InputMessageMap[InputMessageType];
+export type InputMessageHandler<T extends InputMessageType> = (message: InputMessageMap[T]) => void;
+export type ThemeDefinition = {
+    '--uc-font-family': string;
+    '--uc-font-size': string;
+    '--uc-line-height': string;
+    '--uc-button-size': string;
+    '--uc-preview-size': string;
+    '--uc-input-size': string;
+    '--uc-padding': string;
+    '--uc-radius': string;
+    '--uc-transition': string;
+    '--uc-background': string;
+    '--uc-foreground': string;
+    '--uc-primary': string;
+    '--uc-primary-hover': string;
+    '--uc-primary-transparent': string;
+    '--uc-primary-foreground': string;
+    '--uc-secondary': string;
+    '--uc-secondary-hover': string;
+    '--uc-secondary-foreground': string;
+    '--uc-muted': string;
+    '--uc-muted-foreground': string;
+    '--uc-destructive': string;
+    '--uc-destructive-foreground': string;
+    '--uc-border': string;
+    '--uc-primary-rgb-light': string;
+    '--uc-primary-light': string;
+    '--uc-primary-hover-light': string;
+    '--uc-primary-transparent-light': string;
+    '--uc-background-light': string;
+    '--uc-foreground-light': string;
+    '--uc-primary-foreground-light': string;
+    '--uc-secondary-light': string;
+    '--uc-secondary-hover-light': string;
+    '--uc-secondary-foreground-light': string;
+    '--uc-muted-light': string;
+    '--uc-muted-foreground-light': string;
+    '--uc-destructive-light': string;
+    '--uc-destructive-foreground-light': string;
+    '--uc-border-light': string;
+    '--uc-primary-rgb-dark': string;
+    '--uc-primary-dark': string;
+    '--uc-primary-hover-dark': string;
+    '--uc-primary-transparent-dark': string;
+    '--uc-background-dark': string;
+    '--uc-foreground-dark': string;
+    '--uc-primary-foreground-dark': string;
+    '--uc-secondary-dark': string;
+    '--uc-secondary-hover-dark': string;
+    '--uc-secondary-foreground-dark': string;
+    '--uc-muted-dark': string;
+    '--uc-muted-foreground-dark': string;
+    '--uc-destructive-dark': string;
+    '--uc-destructive-foreground-dark': string;
+    '--uc-border-dark': string;
+    '--uc-primary-oklch-light': string;
+    '--uc-primary-oklch-dark': string;
+};
+export type OutputMessage = {
+    type: 'select-all';
+} | {
+    type: 'deselect-all';
+} | {
+    type: 'set-theme-definition';
+    theme: Record<string, string>;
+} | {
+    type: 'set-locale-definition';
+    localeDefinition: string;
+} | {
+    type: 'set-embed-css';
+    css: string;
+};

package/dist/blocks/FileItem/FileItem.d.ts

@@ -0,0 +1,50 @@
+import { PropertyValues } from 'lit';
+import { Uid } from '../../lit/Uid';
+import { FileItemConfig } from './FileItemConfig';
+export declare class FileItem extends FileItemConfig {
+    protected couldBeCtxOwner: boolean;
+    private _pauseRender;
+    uid: Uid;
+    private _itemName;
+    private _errorText;
+    private _hint;
+    private _progressValue;
+    private _progressVisible;
+    private _badgeIcon;
+    private _isFinished;
+    private _isFailed;
+    private _isUploading;
+    private _isFocused;
+    private _showFileNames;
+    private _ariaLabelStatusFile;
+    private _pluginFileActions;
+    private _renderedOnce;
+    private _observer?;
+    private _unsubscribePlugins?;
+    private _handleRemove;
+    private _handleUploadClick;
+    private _calculateState;
+    private _debouncedCalculateState;
+    private _updateHintAndProgress;
+    private _handleState;
+    protected reset(): void;
+    private _observerCallback;
+    private _handleEntryId;
+    private _applyOnAddHooks;
+    private _updateShowFileNames;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    private _updatePluginFileActions;
+    private _handlePluginFileAction;
+    initCallback(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private _upload;
+    static activeInstances: Set<FileItem>;
+    protected shouldUpdate(changedProperties: PropertyValues<this>): boolean;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-file-item': FileItem;
+    }
+}

package/dist/blocks/FileItem/FileItemConfig.d.ts

@@ -0,0 +1,10 @@
+import { UploadEntryData, UploadEntryKeys, UploadEntryTypedData } from '../../abstract/uploadEntrySchema';
+import { LitUploaderBlock } from '../../lit/LitUploaderBlock';
+export declare class FileItemConfig extends LitUploaderBlock {
+    private _entrySubs;
+    protected entry: UploadEntryTypedData | null;
+    protected withEntry<A extends unknown[], R>(fn: (entry: UploadEntryTypedData, ...args: A) => R): (...args: A) => R | undefined;
+    protected subEntry<K extends UploadEntryKeys>(prop: K, handler: (value: UploadEntryData[K]) => void): void;
+    protected reset(): void;
+    disconnectedCallback(): void;
+}

package/dist/blocks/FormInput/FormInput.d.ts

@@ -0,0 +1,18 @@
+import { LitUploaderBlock } from '../../lit/LitUploaderBlock';
+export declare class FormInput extends LitUploaderBlock {
+    attributesMeta: {
+        'ctx-name': string;
+        name?: string;
+    };
+    private _validationInputElement;
+    private _dynamicInputsContainer;
+    nameAttrValue?: string;
+    private get _inputName();
+    private _createValidationInput;
+    initCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-form-input': FormInput;
+    }
+}

package/dist/blocks/Icon/Icon.d.ts

@@ -0,0 +1,19 @@
+import { PropertyValues } from 'lit';
+import { LitBlock } from '../../lit/LitBlock';
+export 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(): import('lit-html').TemplateResult<1>;
+    disconnectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-icon': Icon;
+    }
+}

package/dist/blocks/Img/Img.d.ts

@@ -0,0 +1,14 @@
+import { ImgBase } from './ImgBase.js';
+export declare class Img extends ImgBase {
+    attributesMeta: {
+        src: string;
+    } | {
+        uuid: string;
+    };
+    connectedCallback(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-img': Img;
+    }
+}

package/dist/blocks/Img/ImgBase.d.ts

@@ -0,0 +1,29 @@
+import { ImgConfig } from './ImgConfig';
+export declare class ImgBase extends ImgConfig {
+    private _img;
+    private _imgPreview;
+    private _fmtAbs;
+    private _validateSize;
+    private _getCdnModifiers;
+    private _getTypedCssValue;
+    private _getUrlBase;
+    private _proxyUrl;
+    protected _getElSize(el: HTMLElement, k?: number, wOnly?: boolean): string | null;
+    private _setupEventProxy;
+    protected get img(): HTMLImageElement;
+    private get _currentImg();
+    private get _hasPreviewImage();
+    private get _bgSelector();
+    private get _breakpoints();
+    private get _hasFormatJPG();
+    private _renderBg;
+    private _getSrcset;
+    private _getSrc;
+    private get _srcUrlPreview();
+    private _renderBackground;
+    private _appendURL;
+    private _setupConfigForImage;
+    private _loaderImage;
+    private _renderImage;
+    protected init(): void;
+}

package/dist/blocks/Img/ImgConfig.d.ts

@@ -0,0 +1,28 @@
+import { LitElement } from 'lit';
+type CssPropValue = string | number | undefined | null;
+declare const ImgConfig_base: typeof LitElement & import('../../lit/Constructor.js').Constructor<LitElement> & {
+    reg(tagName: string): void;
+} & import('../../lit/Constructor.js').Constructor<{
+    getCssData(propName: string, silentCheck?: boolean): string | number | boolean | null | undefined;
+}>;
+export declare class ImgConfig extends ImgConfig_base {
+    private _state;
+    private _subscribers;
+    private _isnObserver;
+    private _observed;
+    createRenderRoot(): HTMLElement | ShadowRoot;
+    constructor();
+    protected $$(key: string): unknown;
+    protected set$$(kvObj: Record<string, CssPropValue>): void;
+    protected sub$$<T = unknown>(key: string, kbFn: (val: T) => void): void;
+    private _notify;
+    protected analyticsParams(): string;
+    protected initAttributes(el: HTMLElement): void;
+    protected initIntersection(el: HTMLElement, cbkFn: () => void): void;
+    connectedCallback(): void;
+    private _initCssProperties;
+    disconnectedCallback(): void;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _oldVal: string | null, newVal: string | null): void;
+}
+export {};

package/dist/blocks/Img/configurations.d.ts

@@ -0,0 +1,11 @@
+export declare const CSS_PREF = "--uc-img-";
+export declare const UNRESOLVED_ATTR = "unresolved";
+export declare const HI_RES_K = 2;
+export declare const ULTRA_RES_K = 3;
+export declare const DEV_MODE: boolean;
+export declare const MAX_WIDTH = 3000;
+export declare const MAX_WIDTH_JPG = 5000;
+export declare const ImgTypeEnum: Readonly<{
+    PREVIEW: "PREVIEW";
+    MAIN: "MAIN";
+}>;

package/dist/blocks/Img/props-map.d.ts

@@ -0,0 +1,28 @@
+export declare const PROPS_MAP: Readonly<{
+    'dev-mode': {};
+    pubkey: {};
+    uuid: {};
+    src: {};
+    lazy: {
+        default: number;
+    };
+    intersection: {};
+    breakpoints: {};
+    'cdn-cname': {
+        default: string;
+    };
+    'proxy-cname': {};
+    'secure-delivery-proxy': {};
+    'hi-res-support': {
+        default: number;
+    };
+    'ultra-res-support': {};
+    format: {};
+    'cdn-operations': {};
+    progressive: {};
+    quality: {};
+    'is-background-for': {};
+    'is-preview-blur': {
+        default: number;
+    };
+}>;

package/dist/blocks/Img/utils/parseObjectToString.d.ts

@@ -0,0 +1,2 @@
+export type ParseableParams = Record<string, string | number | boolean | null | undefined>;
+export declare const parseObjectToString: (params: ParseableParams) => (string | number | boolean | null | undefined)[];

package/dist/blocks/Modal/Modal.d.ts

@@ -0,0 +1,34 @@
+import { LitBlock } from '../../lit/LitBlock';
+export declare class Modal extends LitBlock {
+    static styleAttrs: string[];
+    private _mouseDownTarget;
+    /** WARNING: Do not rename/change this, it's used in dashboard */
+    protected dialogEl: import('lit-html/directives/ref.js').Ref<HTMLDialogElement>;
+    /**
+     * CSS-only attribute
+     */
+    strokes: boolean;
+    /**
+     * CSS-only attribute
+     */
+    blockBodyScrolling: boolean;
+    /** WARNING: Do not rename/change this, it's used in dashboard */
+    protected closeDialog: () => void;
+    private _handleDialogClose;
+    private _handleDialogMouseDown;
+    private _handleDialogMouseUp;
+    show(): void;
+    hide(): void;
+    private _handleModalOpen;
+    private _handleModalClose;
+    private _handleModalCloseAll;
+    initCallback(): void;
+    disconnectedCallback(): void;
+    private _handleDialogRef;
+    render(): import('lit-html').TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-modal': Modal;
+    }
+}