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

package/web/blocks/CloudImageEditor/src/toolbar-constants.d.ts

@@ -0,0 +1,61 @@
+export declare const TabId: Readonly<{
+    readonly CROP: "crop";
+    readonly TUNING: "tuning";
+    readonly FILTERS: "filters";
+}>;
+export type TabIdValue = (typeof TabId)[keyof typeof TabId];
+export declare const ALL_TABS: readonly ["crop", "tuning", "filters"];
+export declare const ALL_COLOR_OPERATIONS: readonly ["brightness", "exposure", "gamma", "contrast", "saturation", "vibrance", "warmth", "enhance"];
+export type ColorOperation = (typeof ALL_COLOR_OPERATIONS)[number];
+export declare const ALL_FILTERS: readonly ["adaris", "briaril", "calarel", "carris", "cynarel", "cyren", "elmet", "elonni", "enzana", "erydark", "fenralan", "ferand", "galen", "gavin", "gethriel", "iorill", "iothari", "iselva", "jadis", "lavra", "misiara", "namala", "nerion", "nethari", "pamaya", "sarnar", "sedis", "sewen", "sorahel", "sorlen", "tarian", "thellassan", "varriel", "varven", "vevera", "virkas", "yedis", "yllara", "zatvel", "zevcen"];
+export type FilterId = (typeof ALL_FILTERS)[number];
+export declare const ALL_CROP_OPERATIONS: readonly ["rotate", "mirror", "flip"];
+export type CropOperation = (typeof ALL_CROP_OPERATIONS)[number];
+/** KeypointsNumber is the number of keypoints loaded from each side of zero, not total number */
+export declare const COLOR_OPERATIONS_CONFIG: Readonly<{
+    brightness: {
+        zero: number;
+        range: readonly [-100, 100];
+        keypointsNumber: number;
+    };
+    exposure: {
+        zero: number;
+        range: readonly [-500, 500];
+        keypointsNumber: number;
+    };
+    gamma: {
+        zero: number;
+        range: readonly [0, 1000];
+        keypointsNumber: number;
+    };
+    contrast: {
+        zero: number;
+        range: readonly [-100, 500];
+        keypointsNumber: number;
+    };
+    saturation: {
+        zero: number;
+        range: readonly [-100, 500];
+        keypointsNumber: number;
+    };
+    vibrance: {
+        zero: number;
+        range: readonly [-100, 500];
+        keypointsNumber: number;
+    };
+    warmth: {
+        zero: number;
+        range: readonly [-100, 100];
+        keypointsNumber: number;
+    };
+    enhance: {
+        zero: number;
+        range: readonly [0, 100];
+        keypointsNumber: number;
+    };
+    filter: {
+        zero: number;
+        range: readonly [0, 100];
+        keypointsNumber: number;
+    };
+}>;

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

@@ -0,0 +1,60 @@
+/**
+ * Mapping of loading resources per operation
+ */
+export type LoadingOperations = Map<string, Map<string, boolean>>;
+/**
+ * Image size
+ */
+export interface ImageSize {
+    width: number;
+    height: number;
+}
+export interface Rectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface Transformations {
+    enhance?: number;
+    brightness?: number;
+    exposure?: number;
+    gamma?: number;
+    contrast?: number;
+    saturation?: number;
+    vibrance?: number;
+    warmth?: number;
+    rotate?: number;
+    mirror?: boolean;
+    flip?: boolean;
+    filter?: {
+        name: string;
+        amount: number;
+    };
+    crop?: {
+        dimensions: [number, number];
+        coords: [number, number];
+    };
+}
+export interface ApplyResult {
+    originalUrl: string;
+    cdnUrlModifiers: string;
+    cdnUrl: string;
+    transformations: Transformations;
+}
+export type ChangeResult = ApplyResult;
+export interface CropAspectRatio {
+    type: 'aspect-ratio';
+    width: number;
+    height: number;
+    id: string;
+    hasFreeform?: boolean;
+}
+export type CropPresetList = CropAspectRatio[];
+export type Direction = '' | 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw';
+export type FrameThumbs = Partial<Record<Direction, {
+    direction: Direction;
+    pathNode: SVGElement;
+    interactionNode: SVGElement;
+    groupNode: SVGElement;
+}>>;

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

@@ -0,0 +1,2 @@
+import { Transformations } from './types';
+export declare function viewerImageSrc(originalUrl: string, width: number, transformations: Transformations): string;

package/web/blocks/CloudImageEditor/src/utils/parseFilterValue.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parses a string like "iothari 100" into an object { filter: "iothari", value: 100 }
+ */
+export declare function parseFilterValue(str: string | null): {
+    filter: string;
+    value: number;
+} | null;

package/web/blocks/CloudImageEditor/src/utils/parseFilterValue.test.d.ts

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

package/web/blocks/CloudImageEditorActivity/CloudImageEditorActivity.d.ts

@@ -0,0 +1,25 @@
+import { nothing } from 'lit';
+import { LitUploaderBlock } from '../../lit/LitUploaderBlock';
+import { ChangeResult } from '../CloudImageEditor/src/types';
+export type ActivityParams = {
+    internalId: string;
+};
+export declare class CloudImageEditorActivity extends LitUploaderBlock {
+    private _entry?;
+    private _editorConfig;
+    get activityParams(): ActivityParams;
+    initCallback(): void;
+    disconnectedCallback(): void;
+    private _handleApply;
+    private _handleCancel;
+    handleChange(event: CustomEvent<ChangeResult>): void;
+    private _mountEditor;
+    private _unmountEditor;
+    render(): import('lit-html').TemplateResult<1> | typeof nothing;
+    private _createEditorConfig;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'uc-cloud-image-editor-activity': CloudImageEditorActivity;
+    }
+}

package/web/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/web/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/web/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/web/blocks/Config/computed-properties.test.d.ts

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

package/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/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/web/blocks/ExternalSource/query-string.d.ts

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

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