themelia-react-ui 0.0.0-stage → 1.0.0

package/dist/components/features/map/map.d.ts

@@ -0,0 +1,166 @@
+import { type StringsProp } from "../../../lib/strings";
+import { DropdownMenuCheckboxItem } from "../../base/navigation/dropdown-menu";
+import { type PlaceAutocompleteProps } from "./place-autocomplete";
+import type { Circle, CircleMarker, DivIconOptions, DrawOptions, EditToolbar, ErrorEvent, FeatureGroup, LatLngExpression, LayerGroup, Map as LeafletMap, LocateOptions, LocationEvent, Marker, Polygon, Polyline, Popup, Rectangle, TileLayer, Tooltip } from "leaflet";
+import type * as LeafletDrawNamespace from "leaflet-draw";
+import type * as LeafletNamespace from "leaflet";
+import React, { type ReactNode, type Ref } from "react";
+import type { CircleMarkerProps, CircleProps, LayerGroupProps, MapContainerProps, MarkerProps, PolygonProps, PolylineProps, PopupProps, RectangleProps, TileLayerProps, TooltipProps, MarkerClusterGroupProps } from "./public-leaflet.types";
+export interface MapStrings {
+    /** Id of the tile layer shown first. */
+    defaultTileLayer: string;
+    mapType: string;
+    layers: string;
+    selectLayers: string;
+    marker: string;
+    zoomControls: string;
+    zoomIn: string;
+    zoomOut: string;
+    enterFullscreen: string;
+    exitFullscreen: string;
+    locating: string;
+    stopTracking: string;
+    trackLocation: string;
+    stopLocationTracking: string;
+    startLocationTracking: string;
+    currentLocation: string;
+    drawMarker: string;
+    drawPolyline: string;
+    drawCircle: string;
+    drawRectangle: string;
+    drawPolygon: string;
+    editShapes: string;
+    removeShapes: string;
+    undoEdit: string;
+    undoRemove: string;
+    editInstructions: string;
+    removeInstructions: string;
+}
+export declare const defaultMapStrings: MapStrings;
+declare function Map({ zoom, maxZoom, className, children, strings: stringsProp, ref, ...props }: Omit<MapContainerProps, "zoomControl"> & {
+    center: LatLngExpression;
+    ref?: Ref<LeafletMap>;
+    /** Overrides the map's own copy. */
+    strings?: StringsProp<MapStrings>;
+}): React.JSX.Element | null;
+interface MapTileLayerOption {
+    /** Form field name, forwarded for native submits. */
+    name: string;
+    /** Tile URL template. */
+    url: string;
+    /** Attribution shown for the tile layer. */
+    attribution?: string;
+}
+interface MapLayerGroupOption extends Pick<React.ComponentProps<typeof DropdownMenuCheckboxItem>, "disabled"> {
+    /** Form field name, forwarded for native submits. */
+    name: string;
+}
+interface MapLayersContextType {
+    registerTileLayer: (layer: MapTileLayerOption) => void;
+    tileLayers: MapTileLayerOption[];
+    selectedTileLayer: string;
+    setSelectedTileLayer: (name: string) => void;
+    registerLayerGroup: (layer: MapLayerGroupOption) => void;
+    layerGroups: MapLayerGroupOption[];
+    activeLayerGroups: string[];
+    setActiveLayerGroups: (names: string[]) => void;
+}
+declare const MapLayersContext: React.Context<MapLayersContextType | null>;
+declare function MapTileLayer({ name: nameProp, url, attribution, darkUrl, darkAttribution, ...props }: Partial<TileLayerProps> & {
+    /** Display name for the layer in the layer control. */
+    name?: string;
+    /** Tile URL used when the dark theme is active. */
+    darkUrl?: string;
+    /** Attribution shown for the dark tile layer. */
+    darkAttribution?: string;
+    ref?: Ref<TileLayer>;
+}): React.JSX.Element | null;
+declare function MapLayerGroup({ name, disabled, ...props }: LayerGroupProps & MapLayerGroupOption & {
+    ref?: Ref<LayerGroup>;
+}): React.JSX.Element | null;
+declare function MapFeatureGroup({ name, disabled, ...props }: LayerGroupProps & MapLayerGroupOption & {
+    ref?: Ref<FeatureGroup>;
+}): React.JSX.Element | null;
+declare function MapLayers({ defaultTileLayer, defaultLayerGroups, ...props }: Omit<React.ComponentProps<typeof MapLayersContext.Provider>, "value"> & {
+    /** Name of the tile layer shown first. */
+    defaultTileLayer?: string;
+    /** Names of the overlay groups shown first. */
+    defaultLayerGroups?: string[];
+}): React.JSX.Element;
+declare function MapLayersControl({ tileLayersLabel, layerGroupsLabel, position, className, ...props }: React.ComponentProps<"button"> & {
+    /** Heading for the tile-layer group in the layer control. */
+    tileLayersLabel?: string;
+    /** Heading for the overlay group in the layer control. */
+    layerGroupsLabel?: string;
+    /** Corner the control is anchored to. */
+    position?: string;
+}): React.JSX.Element | null;
+declare function MapMarker({ icon, iconAnchor, bgPos, popupAnchor, tooltipAnchor, ariaLabel, ref, ...props }: Omit<MarkerProps, "icon"> & Pick<DivIconOptions, "iconAnchor" | "bgPos" | "popupAnchor" | "tooltipAnchor"> & {
+    icon?: ReactNode;
+    ariaLabel?: string;
+    ref?: Ref<Marker>;
+}): React.JSX.Element | null;
+declare function MapMarkerClusterGroup({ polygonOptions, spiderLegPolylineOptions, icon, ...props }: Omit<MarkerClusterGroupProps, "iconCreateFunction"> & {
+    children: ReactNode;
+    /** Marker glyph. */
+    icon?: (markerCount: number) => ReactNode;
+}): React.JSX.Element | null;
+declare function MapCircle({ className, ...props }: CircleProps & {
+    ref?: Ref<Circle>;
+}): React.JSX.Element;
+declare function MapCircleMarker({ className, ...props }: CircleMarkerProps & {
+    ref?: Ref<CircleMarker>;
+}): React.JSX.Element;
+declare function MapPolyline({ className, ...props }: PolylineProps & {
+    ref?: Ref<Polyline>;
+}): React.JSX.Element;
+declare function MapPolygon({ className, ...props }: PolygonProps & {
+    ref?: Ref<Polygon>;
+}): React.JSX.Element;
+declare function MapRectangle({ className, ...props }: RectangleProps & {
+    ref?: Ref<Rectangle>;
+}): React.JSX.Element;
+declare function MapPopup({ className, ...props }: Omit<PopupProps, "content"> & {
+    ref?: Ref<Popup>;
+}): React.JSX.Element;
+declare function MapTooltip({ className, children, side, sideOffset, ...props }: Omit<TooltipProps, "offset"> & {
+    /** Which side of the trigger the surface opens on. */
+    side?: "top" | "right" | "bottom" | "left";
+    /** Distance from the trigger, in pixels. */
+    sideOffset?: number;
+    ref?: Ref<Tooltip>;
+}): React.JSX.Element;
+declare function MapZoomControl({ position, className, ...props }: React.ComponentProps<"div"> & {
+    position?: string;
+}): React.JSX.Element;
+declare function MapFullscreenControl({ position, className, ...props }: React.ComponentProps<"button"> & {
+    position?: string;
+}): React.JSX.Element;
+declare function MapLocateControl({ watch, onLocationFound, onLocationError, position, className, ...props }: React.ComponentProps<"button"> & Pick<LocateOptions, "watch"> & {
+    onLocationFound?: (location: LocationEvent) => void;
+    onLocationError?: (error: ErrorEvent) => void;
+} & {
+    position?: string;
+}): React.JSX.Element;
+declare function MapSearchControl({ position, className, ...props }: PlaceAutocompleteProps & {
+    position?: string;
+}): React.JSX.Element;
+declare function MapDrawControl({ onLayersChange, position, className, ...props }: React.ComponentProps<"div"> & {
+    onLayersChange?: (layers: L.FeatureGroup) => void;
+    /** Corner the control is anchored to. */
+    position?: string;
+}): React.JSX.Element;
+declare function MapDrawMarker({ ...props }: DrawOptions.MarkerOptions): React.JSX.Element;
+declare function MapDrawPolyline({ showLength, drawError, shapeOptions, ...props }: DrawOptions.PolylineOptions): React.JSX.Element;
+declare function MapDrawCircle({ showRadius, shapeOptions, ...props }: DrawOptions.CircleOptions): React.JSX.Element;
+declare function MapDrawRectangle({ showArea, shapeOptions, ...props }: DrawOptions.RectangleOptions): React.JSX.Element;
+declare function MapDrawPolygon({ drawError, shapeOptions, ...props }: DrawOptions.PolygonOptions): React.JSX.Element;
+declare function MapDrawEdit({ selectedPathOptions, ...props }: Omit<EditToolbar.EditHandlerOptions, "featureGroup">): React.JSX.Element;
+declare function MapDrawDelete(): React.JSX.Element;
+declare function MapDrawUndo({ className, ...props }: React.ComponentProps<"button">): React.JSX.Element;
+declare function MapControlContainer({ className, ...props }: React.ComponentPropsWithoutRef<"div">): React.JSX.Element;
+declare function useLeaflet(): {
+    L: typeof LeafletNamespace | null;
+    LeafletDraw: typeof LeafletDrawNamespace | null;
+};
+export { Map, MapCircle, MapCircleMarker, MapControlContainer, MapDrawCircle, MapDrawControl, MapDrawDelete, MapDrawEdit, MapDrawMarker, MapDrawPolygon, MapDrawPolyline, MapDrawRectangle, MapDrawUndo, MapFeatureGroup, MapFullscreenControl, MapLayerGroup, MapLayers, MapLayersControl, MapLocateControl, MapMarker, MapMarkerClusterGroup, MapPolygon, MapPolyline, MapPopup, MapRectangle, MapSearchControl, MapTileLayer, MapTooltip, MapZoomControl, useLeaflet, };

package/dist/components/features/map/place-autocomplete.d.ts

@@ -0,0 +1,97 @@
+import { type StringsProp } from "../../../lib/strings";
+import * as React from "react";
+type BBox = [number, number, number, number];
+type Point = {
+    type: "Point";
+    coordinates: [number, number];
+};
+type Feature<TGeometry, TProperties> = {
+    type: "Feature";
+    geometry: TGeometry;
+    properties: TProperties;
+    bbox?: BBox;
+};
+interface PlaceFeatureProperties {
+    osm_id: number;
+    osm_type: "N" | "W" | "R";
+    osm_key: string;
+    osm_value: string;
+    type: string;
+    /** Form field name, forwarded for native submits. */
+    name?: string;
+    housenumber?: string;
+    street?: string;
+    locality?: string;
+    district?: string;
+    postcode?: string;
+    city?: string;
+    county?: string;
+    state?: string;
+    country?: string;
+    countrycode?: string;
+    extent?: [number, number, number, number];
+    extra?: Record<string, string>;
+}
+type PlaceFeature = Feature<Point, PlaceFeatureProperties>;
+interface PlaceAutocompleteStrings {
+    searchPlaceholder: string;
+    /** Announced while a place lookup is in flight. */
+    loading: string;
+    error: string;
+    /** Action shown after a failed lookup. */
+    retry?: string;
+    noResults: string;
+    unknownPlace: string;
+}
+declare const defaultPlaceAutocompleteStrings: PlaceAutocompleteStrings;
+/**
+ * Query parameters for Photon geocoding API
+ * @see https://github.com/komoot/photon#photon-api
+ */
+interface PlaceSearchOptions {
+    /** Search text (address, place name, or POI) */
+    query: string;
+    /** Preferred language for results (e.g., "en", "de", "fr") */
+    lang?: string;
+    /** Maximum number of results to return */
+    limit?: number;
+    /**
+     * Bounding box used to restrict results.
+     * Format: [minLongitude, minLatitude, maxLongitude, maxLatitude]
+     */
+    bbox?: BBox;
+    /** Latitude used to bias results toward a specific location */
+    lat?: number;
+    /** Longitude used to bias results toward a specific location */
+    lon?: number;
+    /**
+     * Zoom level used for location biasing.
+     * Higher values increase locality.
+     */
+    zoom?: number;
+    /**
+     * Strength of the location bias.
+     */
+    locationBiasScale?: number;
+}
+/** Consumer-owned geocoding integration. Keep callback identity stable until its provider changes. */
+type PlaceSearchCallback = (options: PlaceSearchOptions, signal: AbortSignal) => Promise<PlaceFeature[]>;
+interface PlaceAutocompleteProps extends Omit<PlaceSearchOptions, "query">, Omit<React.ComponentProps<"input">, "value" | "onChange"> {
+    debounceMs?: number;
+    /** Current value. Controlled. */
+    value?: string;
+    /** Initial value for uncontrolled use. */
+    defaultValue?: string;
+    /** Fired with the next text value. */
+    onValueChange?: (value: string) => void;
+    onPlaceSelect?: (feature: PlaceFeature) => void;
+    onResultsChange?: (results: PlaceFeature[]) => void;
+    /** Overrides Photon. Memoize when its implementation captures consumer state. */
+    searchPlaces?: PlaceSearchCallback;
+    /** Reports a current lookup failure; cancelled or superseded failures are ignored. */
+    onSearchError?: (error: Error) => void;
+    /** Overrides this surface's own copy. */
+    strings?: StringsProp<PlaceAutocompleteStrings>;
+}
+declare function PlaceAutocomplete({ debounceMs, lang, limit, bbox, lat, lon, zoom, locationBiasScale, className, value: controlledValue, defaultValue, onValueChange: controlledOnValueChange, onPlaceSelect, onResultsChange, searchPlaces, onSearchError, strings: stringsProp, onFocus: inputOnFocus, ...props }: PlaceAutocompleteProps): React.JSX.Element;
+export { PlaceAutocomplete, defaultPlaceAutocompleteStrings, type PlaceAutocompleteProps, type PlaceAutocompleteStrings, type PlaceFeature, type PlaceSearchOptions, type PlaceSearchCallback, };

package/dist/components/features/map/public-leaflet.types.d.ts

@@ -0,0 +1,71 @@
+/// <reference types="leaflet-draw" preserve="true" />
+/// <reference types="leaflet.markercluster" preserve="true" />
+import type { CircleMarkerOptions, CircleOptions, FitBoundsOptions, InteractiveLayerOptions, LatLngBoundsExpression, LatLngExpression, LayerOptions, LeafletEventHandlerFnMap, MapOptions, MarkerClusterGroupOptions, MarkerOptions, PathOptions, PolylineOptions, PopupOptions, TileLayerOptions, TooltipOptions } from 'leaflet';
+import type { CSSProperties, ReactNode } from 'react';
+/**
+ * Structural equivalents of react-leaflet 5's public props. Keep declaration
+ * consumers independent of wrapper declaration internals; the runtime still
+ * loads the official React Leaflet components lazily.
+ */
+interface EventedProps {
+    eventHandlers?: LeafletEventHandlerFnMap;
+}
+interface LayerProps extends LayerOptions, EventedProps {
+}
+interface PathProps extends LayerProps, InteractiveLayerOptions {
+    pathOptions?: PathOptions;
+}
+export interface MapContainerProps extends MapOptions {
+    bounds?: LatLngBoundsExpression;
+    boundsOptions?: FitBoundsOptions;
+    children?: ReactNode;
+    className?: string;
+    id?: string;
+    placeholder?: ReactNode;
+    style?: CSSProperties;
+    whenReady?: () => void;
+}
+export interface TileLayerProps extends TileLayerOptions, LayerProps {
+    url: string;
+}
+export interface MarkerProps extends MarkerOptions, EventedProps {
+    children?: ReactNode;
+    position: LatLngExpression;
+}
+export interface PopupProps extends PopupOptions, EventedProps {
+    children?: ReactNode;
+    position?: LatLngExpression;
+}
+export interface TooltipProps extends TooltipOptions, EventedProps {
+    children?: ReactNode;
+    position?: LatLngExpression;
+}
+export interface PolylineProps extends PolylineOptions, PathProps {
+    children?: ReactNode;
+    positions: LatLngExpression[] | LatLngExpression[][];
+}
+export interface PolygonProps extends PolylineOptions, PathProps {
+    children?: ReactNode;
+    positions: LatLngExpression[] | LatLngExpression[][] | LatLngExpression[][][];
+}
+export interface RectangleProps extends PathOptions, PathProps {
+    bounds: LatLngBoundsExpression;
+    children?: ReactNode;
+}
+export interface CircleProps extends CircleOptions, PathProps {
+    center: LatLngExpression;
+    children?: ReactNode;
+}
+export interface CircleMarkerProps extends CircleMarkerOptions, PathProps {
+    center: LatLngExpression;
+    children?: ReactNode;
+}
+export interface LayerGroupProps extends LayerOptions, EventedProps {
+    children?: ReactNode;
+}
+/** Exact option surface advertised by react-leaflet-markercluster 5. */
+export interface MarkerClusterGroupProps extends Pick<MarkerClusterGroupOptions, 'showCoverageOnHover' | 'zoomToBoundsOnClick' | 'spiderfyOnMaxZoom' | 'removeOutsideVisibleBounds' | 'animate' | 'animateAddingMarkers' | 'disableClusteringAtZoom' | 'maxClusterRadius' | 'polygonOptions' | 'singleMarkerMode' | 'spiderLegPolylineOptions' | 'spiderfyDistanceMultiplier' | 'iconCreateFunction' | 'spiderfyShapePositions' | 'clusterPane' | 'chunkedLoading' | 'chunkInterval' | 'chunkDelay'> {
+    chunkProgress?: ((processed: number, total: number, elapsed: number) => void) | null;
+    children?: ReactNode;
+}
+export {};

package/dist/components/features/map/use-map-color-scheme.d.ts

@@ -0,0 +1,2 @@
+/** Observe inherited CSS theme classes without adding a second theme store. */
+export declare function useMapColorScheme(container: HTMLElement | null): 'light' | 'dark';

package/dist/components/features/media-library/hooks/index.d.ts

@@ -0,0 +1 @@
+export { formatMediaLibrarySize, getMediaLibraryDimensions, resolveMediaLibraryAccessors, useMediaLibrary, } from './use-media-library';

package/dist/components/features/media-library/hooks/use-media-library.d.ts

@@ -0,0 +1,5 @@
+import type { MediaLibraryAccessors, MediaLibraryItem, ResolvedMediaLibraryAccessors, UseMediaLibraryOptions, MediaLibraryState } from '../media-library.types';
+export declare function resolveMediaLibraryAccessors<TItem = MediaLibraryItem>(accessors?: MediaLibraryAccessors<TItem>): ResolvedMediaLibraryAccessors<TItem>;
+export declare function formatMediaLibrarySize(bytes?: number): string;
+export declare function getMediaLibraryDimensions<TItem>(item: TItem, accessors: ResolvedMediaLibraryAccessors<TItem>): string;
+export declare function useMediaLibrary<TItem = MediaLibraryItem>({ items: itemsProp, fetcher, accessors: accessorsProp, selectionMode, value, defaultValue, onValueChange, onItemUpdate, onItemDelete, onUpload, onError, tab: tabProp, defaultTab, onTabChange, view: viewProp, defaultView, onViewChange, query: queryProp, defaultQuery, onQueryChange, type: typeProp, defaultType, onTypeChange, collection: collectionProp, defaultCollection, onCollectionChange, sort: sortProp, defaultSort, onSortChange, uploadOptions: uploadOptionsProp, defaultUploadOptions, onUploadOptionsChange, }?: UseMediaLibraryOptions<TItem>): MediaLibraryState<TItem>;

package/dist/components/features/media-library/index.d.ts

@@ -0,0 +1,6 @@
+export { MediaLibrary, MediaLibraryDialog, } from './media-library';
+export { MediaResourceGallery, } from './media-resource-gallery';
+export { defaultMediaLibraryStrings, formatMediaLibraryString, type MediaLibraryStrings, } from './media-library.strings';
+export { formatMediaLibrarySize, getMediaLibraryDimensions, resolveMediaLibraryAccessors, useMediaLibrary, } from './hooks';
+export { MediaLibraryCard, MediaLibraryDetailPanel, MediaLibraryEmptyState, MediaLibraryFooter, MediaLibraryList, MediaLibraryToolbar, MediaLibraryUploadPanel, } from './partials';
+export type { MediaLibraryAccessors, MediaLibraryCardProps, MediaLibraryCollectionOption, MediaLibraryDensity, MediaLibraryDetailPanelProps, MediaLibraryDetailRenderContext, MediaLibraryDialogProps, MediaLibraryEmptyStateProps, MediaLibraryFetchParams, MediaLibraryFetchResult, MediaLibraryFetcher, MediaLibraryFooterProps, MediaLibraryItem, MediaLibraryItemPatch, MediaLibraryItemRenderContext, MediaLibraryItemType, MediaLibraryKeyboardEvent, MediaLibraryKeyboardSelectOptions, MediaLibraryProps, MediaLibrarySelectionMode, MediaLibrarySlots, MediaLibrarySort, MediaLibraryStagedFile, MediaLibraryState, MediaLibraryTab, MediaLibraryListProps, MediaLibraryToolbarProps, MediaLibraryTypeFilter, MediaLibraryUploadHandler, MediaLibraryUploadHelpers, MediaLibraryUploadOptions, MediaLibraryUploadPanelProps, MediaLibraryUploadStatus, MediaLibraryView, MediaResourceGalleryItemRenderContext, MediaResourceGalleryLayout, MediaResourceGalleryProps, ResolvedMediaLibraryAccessors, UseMediaLibraryOptions, } from './media-library.types';

package/dist/components/features/media-library/media-library.d.ts

@@ -0,0 +1,3 @@
+import type { MediaLibraryDialogProps, MediaLibraryProps } from './media-library.types';
+export declare function MediaLibrary<TItem = import('./media-library.types').MediaLibraryItem>({ title, description, confirmLabel, cancelLabel, selectionMode, density, showMeta, allowUpload, typeFilters, confirmOnSelect, onConfirm, onCancel, onClose, strings: stringsProp, slots, heightClassName, className, items, fetcher, accessors, collections, value, defaultValue, onValueChange, onItemUpdate, onItemDelete, onUpload, onError, tab, defaultTab, onTabChange, view, defaultView, onViewChange, query, defaultQuery, onQueryChange, type, defaultType, onTypeChange, collection, defaultCollection, onCollectionChange, sort, defaultSort, onSortChange, uploadOptions, defaultUploadOptions, onUploadOptionsChange, ...props }: MediaLibraryProps<TItem>): import("react").JSX.Element;
+export declare function MediaLibraryDialog<TItem = import('./media-library.types').MediaLibraryItem>({ open, onOpenChange, trigger, dialogTitle, dialogDescription, onClose, className, dialogClassName, contentClassName, closeOnEscape, closeOnBackdropClick, ...props }: MediaLibraryDialogProps<TItem>): import("react").JSX.Element;

package/dist/components/features/media-library/media-library.strings.d.ts

@@ -0,0 +1,124 @@
+export interface MediaLibraryStrings {
+    /** Surface title. */
+    title: string;
+    /** Supporting copy shown under the label. */
+    description: string;
+    close: string;
+    tabs: {
+        library: string;
+        upload: string;
+    };
+    searchPlaceholder: string;
+    clearSearch: string;
+    typeFilterLabel: string;
+    collectionFilterLabel: string;
+    sortLabel: string;
+    viewLabel: string;
+    allTypes: string;
+    images: string;
+    videos: string;
+    files: string;
+    allCollections: string;
+    sortNewest: string;
+    sortName: string;
+    sortSize: string;
+    sortUsage: string;
+    gridView: string;
+    tableView: string;
+    countAll: string;
+    countFiltered: string;
+    countSearch: string;
+    activeSearchLabel: string;
+    resultsLabel: string;
+    emptyLibraryTitle: string;
+    emptyLibraryDescription: string;
+    emptyFilteredTitle: string;
+    emptyFilteredDescription: string;
+    clearFilters: string;
+    uploadMedia: string;
+    loading: string;
+    errorTitle: string;
+    errorDescription: string;
+    cardDetails: string;
+    privateLabel: string;
+    publicLabel: string;
+    typeImage: string;
+    typeVideo: string;
+    typeFile: string;
+    unknownSize: string;
+    notUsed: string;
+    usedIn: string;
+    table: {
+        name: string;
+        type: string;
+        size: string;
+        collection: string;
+        used: string;
+    };
+    detail: {
+        title: string;
+        altText: string;
+        altPlaceholder: string;
+        collection: string;
+        tags: string;
+        tagsPlaceholder: string;
+        public: string;
+        publicHint: string;
+        privateHint: string;
+        type: string;
+        size: string;
+        dimensions: string;
+        uploaded: string;
+        usedIn: string;
+        replace: string;
+        delete: string;
+        close: string;
+    };
+    upload: {
+        dropTitle: string;
+        dropHint: string;
+        dragOver: string;
+        collection: string;
+        tags: string;
+        tagsPlaceholder: string;
+        public: string;
+        publicHint: string;
+        noFiles: string;
+        stagedCount: string;
+        removeFile: string;
+        uploading: string;
+        done: string;
+    };
+    footer: {
+        pickOne: string;
+        pickMany: string;
+        selectedCount: string;
+        clear: string;
+        cancel: string;
+        confirmEmpty: string;
+        confirmOne: string;
+        confirmMany: string;
+        noFiles: string;
+        stagedSummary: string;
+        upload: string;
+        uploadMany: string;
+        uploading: string;
+    };
+    gallery: {
+        emptyTitle: string;
+        emptyDescription: string;
+        add: string;
+        addMore: string;
+        addTile: string;
+        cover: string;
+        primary: string;
+        setPrimary: string;
+        remove: string;
+        movePrevious: string;
+        moveNext: string;
+        itemPosition: string;
+        maxReached: string;
+    };
+}
+export declare const defaultMediaLibraryStrings: MediaLibraryStrings;
+export declare function formatMediaLibraryString(template: string, values: Record<string, string | number>): string;