@sfperusacdev/sf-ui 0.1.11

package/dist/types/src/components/visualization/types.d.ts

@@ -0,0 +1,38 @@
+export type OrgTreeNode = {
+    id: string;
+    parentId?: string | null;
+    label: string;
+    type: string;
+    shortLabel?: string | null;
+    order?: number;
+    meta?: Record<string, unknown>;
+};
+export type OrgTreeNodeRow<T extends OrgTreeNode = OrgTreeNode> = T & {
+    depth: number;
+    hasChildren: boolean;
+};
+export type OrgTreeTheme = {
+    label: string;
+    labelShort: string;
+    rowClass: string;
+    barClass: string;
+};
+export type NetworkNodeStatus = "normal" | "warning" | "critical" | "maintenance";
+export type NetworkNodeKind = "default" | "nap" | "olt" | "splitter";
+export type NetworkEdgeType = "backbone" | "distribution" | "maintenance";
+export type NetworkBasemap = "street" | "satellite";
+export type NetworkNode = {
+    id: string;
+    label: string;
+    lat: number;
+    lng: number;
+    status: NetworkNodeStatus;
+    kind?: NetworkNodeKind;
+    value?: number;
+    icon?: string;
+};
+export type NetworkEdge = {
+    from: string;
+    to: string;
+    type?: NetworkEdgeType;
+};

package/dist/types/src/constants/index.d.ts

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

package/dist/types/src/constants/maps/index.d.ts

@@ -0,0 +1,8 @@
+import { SfLatLng, SfMapEngineCapabilities } from '../../types/maps';
+export declare const SF_MAPS_CONFIG_ERROR = "Maps config not found. Wrap your app with <SfProvider maps={...}>.";
+export declare const SF_DEFAULT_MAP_CENTER: SfLatLng;
+export declare const SF_DEFAULT_MAP_ZOOM = 13;
+export declare const SF_OSM_TILE_URL = "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png";
+export declare const SF_OSM_ATTRIBUTION = "&copy; <a href=\"https://www.openstreetmap.org/copyright\" target=\"_blank\" rel=\"noreferrer\">OpenStreetMap</a>";
+export declare const SF_LEAFLET_ENGINE_CAPABILITIES: SfMapEngineCapabilities;
+export declare const SF_GOOGLE_ENGINE_CAPABILITIES: SfMapEngineCapabilities;

package/dist/types/src/contracts/maps/index.d.ts

@@ -0,0 +1,27 @@
+import { SfDistanceCapabilities, SfDistanceInput, SfDistanceResult, SfGeocodingCapabilities, SfLatLng, SfMapEngineCapabilities, SfMapRenderer, SfPlace, SfPlacesCapabilities, SfRoute, SfRouteInput, SfRoutingCapabilities } from '../../types/maps';
+export interface IMapEngine {
+    id: string;
+    capabilities: SfMapEngineCapabilities;
+    createRenderer(): SfMapRenderer;
+}
+export interface IGeocoderService {
+    id: string;
+    capabilities: SfGeocodingCapabilities;
+    geocode(query: string): Promise<SfPlace[]>;
+    reverseGeocode(point: SfLatLng): Promise<SfPlace | null>;
+}
+export interface IRouteService {
+    id: string;
+    capabilities: SfRoutingCapabilities;
+    calculateRoute(input: SfRouteInput): Promise<SfRoute>;
+}
+export interface IDistanceService {
+    id: string;
+    capabilities: SfDistanceCapabilities;
+    calculateDistance(input: SfDistanceInput): Promise<SfDistanceResult>;
+}
+export interface IPlacesService {
+    id: string;
+    capabilities: SfPlacesCapabilities;
+    searchPlaces(query: string): Promise<SfPlace[]>;
+}

package/dist/types/src/engines/maps/google/googleMapEngine.d.ts

@@ -0,0 +1,3 @@
+import { IMapEngine } from '../../../contracts/maps';
+import { SfGoogleMapsEngineConfig } from '../../../types/maps';
+export declare const createGoogleMapEngine: (config?: SfGoogleMapsEngineConfig) => IMapEngine;

package/dist/types/src/engines/maps/google/index.d.ts

@@ -0,0 +1 @@
+export { createGoogleMapEngine } from './googleMapEngine';

package/dist/types/src/engines/maps/index.d.ts

@@ -0,0 +1,2 @@
+export * from './google';
+export * from './leaflet';

package/dist/types/src/engines/maps/leaflet/index.d.ts

@@ -0,0 +1 @@
+export { createLeafletMapEngine } from './leafletMapEngine';

package/dist/types/src/engines/maps/leaflet/leafletMapEngine.d.ts

@@ -0,0 +1,3 @@
+import { IMapEngine } from '../../../contracts/maps';
+import { SfLeafletEngineConfig } from '../../../types/maps';
+export declare const createLeafletMapEngine: (config?: SfLeafletEngineConfig) => IMapEngine;

package/dist/types/src/hooks/index.d.ts

@@ -0,0 +1,11 @@
+export { useMaestroFilter } from './useMaestroFilter';
+export type { UseMaestroFilterOptions, UseMaestroFilterResult } from './useMaestroFilter';
+export { useFilterData } from './useFilterData';
+export { useArrayPaginator, defaultOnSortFunc } from './useArrayPaginator';
+export { useStoredState } from './useStoredState';
+export { useQueryStringState } from './useQueryStringState';
+export { useClickAway } from './useClickAway';
+export { useIsClient } from './useIsClient';
+export { useCustomForm } from './useCustomForm';
+export type { UseCustomFormProps } from './useCustomForm';
+export * from './maps';

package/dist/types/src/hooks/maps/index.d.ts

@@ -0,0 +1,3 @@
+export { useAddressSearch } from './useAddressSearch';
+export { useMapEngine } from './useMapEngine';
+export { useMapsConfig } from './useMapsConfig';

package/dist/types/src/hooks/maps/useAddressSearch.d.ts

@@ -0,0 +1,7 @@
+import { SfPlace } from '../../types/maps';
+export declare const useAddressSearch: () => {
+    loading: boolean;
+    results: SfPlace[];
+    error: string | null;
+    search: (query: string) => Promise<SfPlace[]>;
+};

package/dist/types/src/hooks/maps/useAddressSearch.test.d.ts

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

package/dist/types/src/hooks/maps/useMapEngine.d.ts

@@ -0,0 +1,5 @@
+export declare const useMapEngine: () => {
+    id: string;
+    capabilities: import('../..').SfMapEngineCapabilities;
+    renderer: import('../..').SfMapRenderer;
+};

package/dist/types/src/hooks/maps/useMapsConfig.d.ts

@@ -0,0 +1 @@
+export declare const useMapsConfig: () => import('../..').SfMapsConfig;

package/dist/types/src/hooks/useArrayPaginator.d.ts

@@ -0,0 +1,21 @@
+import { SortingState } from '@tanstack/react-table';
+type LimitOffset = {
+    limit: number;
+    offset: number;
+};
+export declare const defaultOnSortFunc: <T>(a: T, b: T, columnId: string) => number;
+export declare const useArrayPaginator: <T>(array: T[], opts?: {
+    limit?: number;
+    onSortFunc?: (a: T, b: T, columnId: string) => number;
+    strictSort?: boolean;
+}) => {
+    pageConstraints: {
+        limitItems: number;
+        offsetItems: number;
+        totalItems: number;
+    };
+    setLimitOffset: ({ limit, offset }: LimitOffset) => void;
+    onSortChange: import('react').Dispatch<import('react').SetStateAction<SortingState>>;
+    pageData: T[];
+};
+export {};

package/dist/types/src/hooks/useClickAway.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare const useClickAway: <T extends HTMLElement>(onClickAway: (event: MouseEvent | TouchEvent) => void) => RefObject<T | null>;

package/dist/types/src/hooks/useCustomForm.d.ts

@@ -0,0 +1,26 @@
+import { DefaultValues, FieldValues } from 'react-hook-form';
+import type * as yup from "yup";
+type UseCustomFormProps<TValues extends FieldValues> = {
+    defaultValues?: DefaultValues<TValues>;
+};
+export declare const useCustomForm: <TSchema extends yup.ObjectSchema<FieldValues>>(schema: TSchema, props?: UseCustomFormProps<yup.Asserts<TSchema>>) => {
+    handleSubmit: import('react-hook-form').UseFormHandleSubmit<yup.Asserts<TSchema>, yup.Asserts<TSchema>>;
+    watch: import('react-hook-form').UseFormWatch<yup.Asserts<TSchema>>;
+    getValues: import('react-hook-form').UseFormGetValues<yup.Asserts<TSchema>>;
+    getFieldState: import('react-hook-form').UseFormGetFieldState<yup.Asserts<TSchema>>;
+    setError: import('react-hook-form').UseFormSetError<yup.Asserts<TSchema>>;
+    clearErrors: import('react-hook-form').UseFormClearErrors<yup.Asserts<TSchema>>;
+    setValue: import('react-hook-form').UseFormSetValue<yup.Asserts<TSchema>>;
+    setValues: import('react-hook-form').UseFormSetValues<yup.Asserts<TSchema>>;
+    trigger: import('react-hook-form').UseFormTrigger<yup.Asserts<TSchema>>;
+    formState: import('react-hook-form').FormState<yup.Asserts<TSchema>>;
+    resetField: import('react-hook-form').UseFormResetField<yup.Asserts<TSchema>>;
+    reset: import('react-hook-form').UseFormReset<yup.Asserts<TSchema>>;
+    resetDefaultValues: import('react-hook-form').UseFormResetDefaultValues<yup.Asserts<TSchema>>;
+    unregister: import('react-hook-form').UseFormUnregister<yup.Asserts<TSchema>>;
+    control: import('react-hook-form').Control<yup.Asserts<TSchema>, any, yup.Asserts<TSchema>>;
+    register: import('react-hook-form').UseFormRegister<yup.Asserts<TSchema>>;
+    setFocus: import('react-hook-form').UseFormSetFocus<yup.Asserts<TSchema>>;
+    subscribe: import('react-hook-form').UseFormSubscribe<yup.Asserts<TSchema>>;
+};
+export type { UseCustomFormProps };

package/dist/types/src/hooks/useFilterData.d.ts

@@ -0,0 +1,10 @@
+import { Dispatch, SetStateAction } from 'react';
+type SearchableRecord = Record<string, unknown>;
+type FilterFn<T> = (item: T) => boolean;
+type UseFilterDataOptions<T extends SearchableRecord> = {
+    filters?: FilterFn<T>[];
+    searchableKeys?: readonly (keyof T & string)[];
+    ignoredKeys?: readonly (keyof T & string)[];
+};
+export declare const useFilterData: <T extends SearchableRecord>(data: T[] | undefined, options?: UseFilterDataOptions<T>) => [T[], Dispatch<SetStateAction<string>>];
+export {};

package/dist/types/src/hooks/useIsClient.d.ts

@@ -0,0 +1,2 @@
+/** True en el navegador; false durante SSR — evita montar mapas Leaflet en el servidor. */
+export declare const useIsClient: () => boolean;

package/dist/types/src/hooks/useMaestroFilter.d.ts

@@ -0,0 +1,15 @@
+export type UseMaestroFilterOptions = {
+    initialPageSize?: number;
+};
+export type UseMaestroFilterResult<T extends Record<string, unknown>> = {
+    query: string;
+    setQuery: (value: string) => void;
+    pageIndex: number;
+    setPageIndex: (index: number) => void;
+    pageSize: number;
+    setPageSize: (size: number) => void;
+    filteredRows: T[];
+    pageRows: T[];
+    totalItems: number;
+};
+export declare const useMaestroFilter: <T extends Record<string, unknown>>(rows: T[], { initialPageSize }?: UseMaestroFilterOptions) => UseMaestroFilterResult<T>;

package/dist/types/src/hooks/useMaestroFilter.test.d.ts

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

package/dist/types/src/hooks/useQueryStringState.d.ts

@@ -0,0 +1,2 @@
+import { Dispatch, SetStateAction } from 'react';
+export declare const useQueryStringState: (initialState: string | (() => string), queryKey?: string) => [string, Dispatch<SetStateAction<string>>];

package/dist/types/src/hooks/useStoredState.d.ts

@@ -0,0 +1,2 @@
+import { Dispatch, SetStateAction } from 'react';
+export declare const useStoredState: <T>(key: string, initial: T) => [T, Dispatch<SetStateAction<T>>];

package/dist/types/src/index.d.ts

@@ -0,0 +1,24 @@
+export * from './components/inputs';
+export * from './components/table';
+export * from './components/buttons';
+export * from './components/feedback';
+export * from './components/overlays';
+export * from './components/layout';
+export * from './components/advanced-inputs';
+export * from './components/cards';
+export * from './components/dashboard';
+export * from './components/document-inputs';
+export * from './components/range-inputs';
+export * from './components/media-inputs';
+export * from './components/maps';
+export * from './components/interactive-inputs';
+export * from './components/visualization';
+export * from './components/display';
+export * from './components/charts';
+export * from './components/icons';
+export * from './providers';
+export * from './types/maps';
+export * from './contracts/maps';
+export * from './constants';
+export * from './hooks';
+export * from './utils';

package/dist/types/src/performance/catalogPhases.performance.test.d.ts

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

package/dist/types/src/performance/componentRender.performance.test.d.ts

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

package/dist/types/src/providers/SfProvider.d.ts

@@ -0,0 +1,21 @@
+import { PropsWithChildren } from 'react';
+import { IDistanceService, IGeocoderService, IMapEngine, IPlacesService, IRouteService } from '../contracts/maps';
+import { SfMapsConfig } from '../types/maps';
+export type SfProviderProps = PropsWithChildren<{
+    maps?: SfMapsConfig;
+}>;
+export type SfMapsRuntime = {
+    config: SfMapsConfig;
+    engine: IMapEngine;
+    geocodingService: IGeocoderService;
+    placesService: IPlacesService;
+    routingService: IRouteService;
+    distanceService: IDistanceService;
+};
+type SfProviderValue = {
+    maps?: SfMapsRuntime;
+};
+export declare const SfProvider: ({ maps, children }: SfProviderProps) => import("react").JSX.Element;
+export declare const useSf: () => SfProviderValue;
+export declare const useSfMaps: () => SfMapsRuntime;
+export {};

package/dist/types/src/providers/SfProvider.maps.test.d.ts

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

package/dist/types/src/providers/index.d.ts

@@ -0,0 +1,2 @@
+export { SfProvider, useSf, useSfMaps } from './SfProvider';
+export type { SfMapsRuntime, SfProviderProps } from './SfProvider';

package/dist/types/src/services/maps/distance/basicDistanceService.d.ts

@@ -0,0 +1,2 @@
+import { IDistanceService } from '../../../contracts/maps';
+export declare const createBasicDistanceService: () => IDistanceService;

package/dist/types/src/services/maps/distance/basicDistanceService.test.d.ts

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

package/dist/types/src/services/maps/distance/index.d.ts

@@ -0,0 +1 @@
+export { createBasicDistanceService } from './basicDistanceService';

package/dist/types/src/services/maps/geocoding/googleGeocodingService.d.ts

@@ -0,0 +1,3 @@
+import { IGeocoderService } from '../../../contracts/maps';
+import { SfGoogleMapsEngineConfig } from '../../../types/maps';
+export declare const createGoogleGeocodingService: (config: SfGoogleMapsEngineConfig) => IGeocoderService;

package/dist/types/src/services/maps/geocoding/index.d.ts

@@ -0,0 +1,2 @@
+export { createGoogleGeocodingService } from './googleGeocodingService';
+export { createNominatimGeocodingService } from './nominatimGeocodingService';

package/dist/types/src/services/maps/geocoding/nominatimGeocodingService.d.ts

@@ -0,0 +1,2 @@
+import { IGeocoderService } from '../../../contracts/maps';
+export declare const createNominatimGeocodingService: () => IGeocoderService;

package/dist/types/src/services/maps/googleMapsLoader.d.ts

@@ -0,0 +1,66 @@
+import { SfGoogleMapsEngineConfig } from '../../types/maps';
+export type GoogleMapsListener = {
+    remove?: () => void;
+};
+export type GoogleMapInstance = {
+    setCenter?: (center: {
+        lat: number;
+        lng: number;
+    }) => void;
+    setZoom?: (zoom: number) => void;
+    addListener?: (eventName: string, handler: (event: {
+        latLng?: {
+            lat: () => number;
+            lng: () => number;
+        };
+    }) => void) => GoogleMapsListener;
+};
+type GoogleMapsNamespace = {
+    maps?: {
+        Map: new (element: HTMLElement, options: Record<string, unknown>) => GoogleMapInstance;
+        Marker: new (options: Record<string, unknown>) => {
+            addListener?: (eventName: string, handler: () => void) => GoogleMapsListener;
+            getPosition?: () => {
+                lat: () => number;
+                lng: () => number;
+            } | null;
+            setMap?: (map: unknown | null) => void;
+            setOptions?: (options: Record<string, unknown>) => void;
+            setPosition?: (position: {
+                lat: number;
+                lng: number;
+            }) => void;
+        };
+        Geocoder: new () => {
+            geocode: (request: Record<string, unknown>, callback: (results: unknown[] | null, status: string) => void) => void;
+        };
+        LatLngBounds: new () => {
+            extend: (point: {
+                lat: number;
+                lng: number;
+            }) => void;
+        };
+        Polyline: new (options: Record<string, unknown>) => {
+            setMap?: (map: unknown | null) => void;
+            setOptions?: (options: Record<string, unknown>) => void;
+            setPath?: (path: {
+                lat: number;
+                lng: number;
+            }[]) => void;
+        };
+        Polygon: new (options: Record<string, unknown>) => {
+            setMap?: (map: unknown | null) => void;
+            setOptions?: (options: Record<string, unknown>) => void;
+            setPaths?: (paths: {
+                lat: number;
+                lng: number;
+            }[]) => void;
+        };
+        event?: {
+            clearInstanceListeners: (instance: unknown) => void;
+        };
+    };
+};
+export declare const getGoogleMapsNamespace: () => GoogleMapsNamespace | undefined;
+export declare const loadGoogleMaps: (config: SfGoogleMapsEngineConfig) => Promise<GoogleMapsNamespace>;
+export {};

package/dist/types/src/services/maps/index.d.ts

@@ -0,0 +1,5 @@
+export * from './distance';
+export * from './geocoding';
+export * from './googleMapsLoader';
+export * from './places';
+export * from './routing';

package/dist/types/src/services/maps/places/index.d.ts

@@ -0,0 +1 @@
+export { createMapsPlacesService } from './mapsPlacesService';

package/dist/types/src/services/maps/places/mapsPlacesService.d.ts

@@ -0,0 +1,2 @@
+import { IGeocoderService, IPlacesService } from '../../../contracts/maps';
+export declare const createMapsPlacesService: (geocoder: IGeocoderService) => IPlacesService;

package/dist/types/src/services/maps/routing/basicRouteService.d.ts

@@ -0,0 +1,2 @@
+import { IRouteService } from '../../../contracts/maps';
+export declare const createBasicRouteService: () => IRouteService;

package/dist/types/src/services/maps/routing/basicRouteService.test.d.ts

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

package/dist/types/src/services/maps/routing/index.d.ts

@@ -0,0 +1 @@
+export { createBasicRouteService } from './basicRouteService';

package/dist/types/src/types/maps/index.d.ts

@@ -0,0 +1,155 @@
+import { ReactNode } from 'react';
+export type SfMapEngineId = "leaflet" | "google" | (string & {});
+export type SfMapServiceId = "leaflet" | "google" | "nominatim" | "osrm" | (string & {});
+export type SfDistanceUnit = "km" | "mi";
+export type SfAreaUnit = "m2" | "ha";
+export type SfLatLng = {
+    lat: number;
+    lng: number;
+};
+export type SfBounds = {
+    north: number;
+    south: number;
+    east: number;
+    west: number;
+};
+export type SfPlace = {
+    id: string;
+    label: string;
+    address?: string;
+    location: SfLatLng;
+    provider?: string;
+    raw?: unknown;
+};
+export type SfAddress = SfPlace;
+export type SfRoute = {
+    origin: SfLatLng;
+    destination: SfLatLng;
+    waypoints: SfLatLng[];
+    distanceMeters?: number;
+    durationSeconds?: number;
+    polyline?: SfLatLng[];
+};
+export type SfRouteInput = {
+    origin: SfLatLng;
+    destination: SfLatLng;
+    waypoints?: SfLatLng[];
+    travelMode?: SfTravelMode;
+};
+export type SfDistanceInput = {
+    origins: SfLatLng[];
+    destinations: SfLatLng[];
+    travelMode?: SfTravelMode;
+};
+export type SfDistanceResult = {
+    distanceMeters: number;
+    durationSeconds?: number;
+};
+export type SfGeofence = {
+    id: string;
+    name?: string;
+    polygon: SfLatLng[];
+};
+export type SfVehicleLocation = {
+    vehicleId: string;
+    location: SfLatLng;
+    timestamp: string;
+    accuracyMeters?: number;
+    speedMps?: number;
+    heading?: number;
+};
+export type SfTravelMode = "driving" | "walking" | "bicycling" | "transit";
+export type SfMapMarker = {
+    id: string;
+    position: SfLatLng;
+    label?: string;
+    title?: string;
+    color?: string;
+    options?: SfMapMarkerOptions;
+    data?: unknown;
+};
+export type SfMapMarkerOptions = {
+    draggable?: boolean;
+    selectable?: boolean;
+};
+export type SfMapShape = {
+    id: string;
+    points: SfLatLng[];
+    color?: string;
+    fillColor?: string;
+    label?: string;
+};
+export type SfMapClickEvent = {
+    location: SfLatLng;
+};
+export type SfMarkerClickEvent = {
+    marker: SfMapMarker;
+};
+export type SfMarkerDragEvent = {
+    marker: SfMapMarker;
+    location: SfLatLng;
+};
+export type SfMapEngineCapabilities = {
+    drawing: "none" | "basic" | "advanced";
+    streetView: "none" | "static" | "interactive";
+    clustering: "none" | "client" | "server";
+    heatmap: "none" | "basic" | "weighted";
+};
+export type SfGeocodingCapabilities = {
+    geocoding: "none" | "basic" | "full";
+};
+export type SfRoutingCapabilities = {
+    routing: "none" | "basic" | "waypoints" | "optimized";
+    traffic?: "none" | "basic" | "full";
+};
+export type SfPlacesCapabilities = {
+    places: "none" | "basic" | "full";
+};
+export type SfDistanceCapabilities = {
+    distance: "none" | "point-to-point" | "matrix";
+    traffic?: "none" | "basic" | "full";
+};
+export type SfGoogleMapsEngineConfig = {
+    apiKey: string;
+    language?: string;
+    region?: string;
+    libraries?: string[];
+    mapId?: string;
+};
+export type SfLeafletEngineConfig = {
+    tileUrl?: string;
+    attribution?: string;
+};
+export type SfMapsConfig = {
+    defaultEngine: SfMapEngineId;
+    engines: Partial<{
+        google: SfGoogleMapsEngineConfig;
+        leaflet: SfLeafletEngineConfig;
+    }> & Record<string, unknown>;
+    services?: Partial<{
+        geocoding: SfMapServiceId;
+        routing: SfMapServiceId;
+        places: SfMapServiceId;
+        distance: SfMapServiceId;
+    }>;
+    units?: {
+        distance?: SfDistanceUnit;
+        area?: SfAreaUnit;
+    };
+};
+export type SfMapRendererProps = {
+    center?: SfLatLng;
+    zoom?: number;
+    markers?: SfMapMarker[];
+    routes?: SfMapShape[];
+    areas?: SfMapShape[];
+    height?: number | string;
+    className?: string;
+    readOnly?: boolean;
+    onClick?: (event: SfMapClickEvent) => void;
+    onMarkerClick?: (event: SfMarkerClickEvent) => void;
+    onMarkerDoubleClick?: (event: SfMarkerClickEvent) => void;
+    onMarkerDrag?: (event: SfMarkerDragEvent) => void;
+    onMarkerDragEnd?: (event: SfMarkerDragEvent) => void;
+};
+export type SfMapRenderer = (props: SfMapRendererProps) => ReactNode;

package/dist/types/src/utils/exportTableCsv.d.ts

@@ -0,0 +1,11 @@
+export type ExportTableColumn<T> = {
+    id: string;
+    header: string;
+    getValue: (row: T) => unknown;
+};
+export type ExportTableCsvOptions<T> = {
+    filename?: string;
+    columns: ExportTableColumn<T>[];
+};
+/** Exporta filas visibles a CSV (UTF-8 BOM para Excel). */
+export declare const exportTableCsv: <T>(rows: T[], options: ExportTableCsvOptions<T>) => void;

package/dist/types/src/utils/exportTableXlsx.d.ts

@@ -0,0 +1,5 @@
+import { ExportTableColumn, ExportTableCsvOptions } from './exportTableCsv';
+export type ExportTableXlsxOptions<T> = ExportTableCsvOptions<T>;
+/** Exporta filas a Excel (.xls SpreadsheetML) sin peer externo. */
+export declare const exportTableXlsx: <T>(rows: T[], options: ExportTableXlsxOptions<T>) => void;
+export type { ExportTableColumn };

package/dist/types/src/utils/index.d.ts

@@ -0,0 +1,9 @@
+export { toStringArray } from './toStringArray';
+export { readQueryValue, updateQueryValue, removeQueryValue } from './queryParams';
+export { exportTableCsv } from './exportTableCsv';
+export type { ExportTableColumn, ExportTableCsvOptions } from './exportTableCsv';
+export { exportTableXlsx } from './exportTableXlsx';
+export type { ExportTableXlsxOptions } from './exportTableXlsx';
+export { createFormSchema, nullableBoolean, nullableCelular, nullableEmail, nullableNumber, nullableOrMatchString, nullablePositiveInteger, nullablePositiveNumber, nullableString, nullableStringArray, nullableStringNumbersOnly, requiredBoolean, requiredCelular, requiredEmail, requiredMatchString, requiredNumber, requiredPositiveInteger, requiredPositiveNumber, requiredString, requiredStringArray, requiredStringNumbersOnly, transformNullIfEmpty, validators, } from './validators';
+export type { ShapeFactory } from './validators';
+export * from './maps';

package/dist/types/src/utils/maps/geocoder.d.ts

@@ -0,0 +1,8 @@
+export type MapGeocoderResult = {
+    lat: number;
+    lng: number;
+    label: string;
+};
+export declare const MIN_MAP_GEOCODER_QUERY_LENGTH = 3;
+export declare const searchMapAddresses: (query: string, limit?: number) => Promise<MapGeocoderResult[]>;
+export declare const formatMapGeocoderLabel: (label: string, maxParts?: number) => string;

package/dist/types/src/utils/maps/index.d.ts

@@ -0,0 +1,10 @@
+import { SfLatLng, SfMapMarker } from '../../types/maps';
+export declare const sfFormatCoordinate: (value: number) => string;
+export declare const sfClampLatitude: (value: number) => number;
+export declare const sfClampLongitude: (value: number) => number;
+export declare const sfParseCoordinate: (value: string | number, fallback?: number) => number;
+export declare const sfLatLngToString: (point: SfLatLng) => string;
+export declare const sfNormalizeLatLng: (value: unknown, fallback: SfLatLng) => SfLatLng;
+export declare const sfMarkerFromLatLng: (position: SfLatLng, label?: string) => SfMapMarker;
+export { MIN_MAP_GEOCODER_QUERY_LENGTH, formatMapGeocoderLabel, searchMapAddresses, } from './geocoder';
+export type { MapGeocoderResult } from './geocoder';

package/dist/types/src/utils/maps/index.test.d.ts

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

package/dist/types/src/utils/queryParams.d.ts

@@ -0,0 +1,3 @@
+export declare const readQueryValue: (name: string) => string | null;
+export declare const updateQueryValue: (name: string, value: string | null | undefined) => void;
+export declare const removeQueryValue: (name: string) => void;

package/dist/types/src/utils/resolveCssVar.d.ts

@@ -0,0 +1,2 @@
+/** Resuelve `var(--sf-*)` a valor computado (Leaflet SVG, canvas, etc.). */
+export declare const resolveCssVar: (value: string, fallback?: string) => string;