zenit-sdk 0.0.1

package/dist/index-C_2fk0Fk.d.ts

@@ -0,0 +1,690 @@
+import React from 'react';
+import L, { PathOptions } from 'leaflet';
+import 'lucide-react';
+
+interface ZenitSdkError {
+    success: false;
+    statusCode: number;
+    timestamp?: string;
+    path?: string;
+    method?: string;
+    error?: string;
+    message: string;
+}
+type TokenResolver = () => {
+    accessToken?: string;
+    sdkToken?: string;
+};
+type AuthorizationHeaderResolver = () => Record<string, string>;
+interface HttpClientOptions {
+    baseUrl: string;
+    resolveTokens?: TokenResolver;
+    resolveAuthorizationHeader?: AuthorizationHeaderResolver;
+}
+/**
+ * Minimal fetch-based HTTP client for the Zenit SDK.
+ * Responsible for setting base URL, auth headers and error normalization.
+ *
+ * - El header `Authorization` se usa para JWT de usuario o JWT obtenido vía `/sdk-auth/exchange`.
+ * - El header `X-SDK-Token` se usa para enviar el token SDK crudo a endpoints como
+ *   `/sdk-auth/validate` y `/sdk-auth/exchange`.
+ */
+declare class HttpClient {
+    private readonly baseUrl;
+    private readonly resolveTokens?;
+    private readonly resolveAuthorizationHeader;
+    constructor(options: HttpClientOptions);
+    get<T>(path: string, options?: RequestInit): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: RequestInit): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: RequestInit): Promise<T>;
+    patch<T>(path: string, body?: unknown, options?: RequestInit): Promise<T>;
+    delete<T>(path: string, options?: RequestInit): Promise<T>;
+    private request;
+}
+
+type LoginRequest = {
+    email: string;
+    password: string;
+};
+type UserSummary = {
+    id: number | string;
+    email: string;
+    roles: string[];
+    employeeCode?: string;
+};
+type LoginResponse = {
+    accessToken: string;
+    refreshToken: string;
+    user: UserSummary;
+};
+type RefreshResponse = {
+    accessToken: string;
+    refreshToken: string;
+};
+type MeResponse = UserSummary;
+type ValidateResponse = {
+    valid: boolean;
+};
+
+/**
+ * Client to manage user authentication endpoints.
+ */
+declare class ZenitAuthClient {
+    private readonly http;
+    private readonly updateTokens;
+    private readonly config;
+    constructor(http: HttpClient, updateTokens: (tokens: {
+        accessToken?: string;
+        refreshToken?: string;
+    }) => void, config: ZenitSdkConfig);
+    login(credentials: LoginRequest): Promise<LoginResponse>;
+    refresh(refreshToken?: string): Promise<RefreshResponse>;
+    me(): Promise<MeResponse>;
+    validate(): Promise<ValidateResponse>;
+}
+
+type SdkTokenValidateResponse = {
+    valid: boolean;
+    clientId?: string | number;
+    clientName?: string;
+    scopes?: string[];
+    reason?: string;
+};
+type SdkTokenExchangeResponse = {
+    accessToken: string;
+    expiresIn: number;
+    tokenType: 'Bearer';
+};
+
+/**
+ * Client to manage SDK token validation and exchange endpoints.
+ */
+declare class ZenitSdkAuthClient {
+    private readonly http;
+    private readonly updateAccessToken;
+    private readonly config;
+    constructor(http: HttpClient, updateAccessToken: (token?: string) => void, config: ZenitSdkConfig);
+    /**
+     * Validate an SDK token. If no token argument is provided, it falls back to config.sdkToken.
+     */
+    validateSdkToken(token?: string): Promise<SdkTokenValidateResponse>;
+    /**
+     * Exchange an SDK token for an access token. Token can come from method args or config.sdkToken.
+     */
+    exchangeSdkToken(token?: string): Promise<SdkTokenExchangeResponse>;
+}
+
+interface LayerDto {
+    id: number | string;
+    name?: string;
+    description?: string;
+    totalFeatures?: number;
+    layerType?: string;
+    [key: string]: unknown;
+}
+type LayerSummary = Pick<LayerDto, 'id' | 'name'>;
+interface GeoJsonPoint {
+    type: 'Point';
+    coordinates: [number, number];
+    [key: string]: unknown;
+}
+interface GeoJsonPolygon {
+    type: 'Polygon';
+    coordinates: number[][][];
+    [key: string]: unknown;
+}
+interface GeoJsonFeature<TProperties = Record<string, unknown>, TGeometry = unknown> {
+    type: 'Feature';
+    geometry: TGeometry;
+    properties?: TProperties;
+    [key: string]: unknown;
+}
+interface GeoJsonFeatureCollection<TProperties = Record<string, unknown>, TGeometry = GeoJsonPoint | GeoJsonPolygon | unknown> {
+    type: 'FeatureCollection';
+    features: Array<GeoJsonFeature<TProperties, TGeometry>>;
+    [key: string]: unknown;
+}
+interface GeoJsonGeometryCollection<TGeometry = unknown> {
+    type: 'GeometryCollection';
+    geometries: TGeometry[];
+    [key: string]: unknown;
+}
+interface Bbox {
+    minLon: number;
+    minLat: number;
+    maxLon: number;
+    maxLat: number;
+}
+type LayerDataStrategy = 'geojson' | 'bbox' | 'intersect';
+interface ApiEnvelope<TData, TMetadata = Record<string, unknown>> {
+    success: boolean;
+    timestamp?: string;
+    path?: string;
+    method?: string;
+    data: TData;
+    message?: string;
+    metadata?: TMetadata;
+    limitedMessage?: string;
+    totalFeatures?: number;
+}
+type ApiResponseData<TData, TMetadata = Record<string, unknown>> = ApiEnvelope<TData, TMetadata>;
+interface LayerMetadata {
+    totalFeatures?: number;
+    limit?: number;
+    limited?: boolean;
+    limitedMessage?: string;
+    [key: string]: unknown;
+}
+interface GeoJsonRequestOptions {
+    maxFeatures?: number;
+    simplify?: boolean;
+}
+interface GeoJsonBBoxRequest extends GeoJsonRequestOptions {
+    id: number | string;
+    bbox: Bbox;
+}
+interface GeoJsonIntersectRequest extends GeoJsonRequestOptions {
+    id: number | string;
+    geometry: unknown;
+}
+interface LayerAoi {
+    bbox?: Bbox;
+    geometry?: GeoJsonGeometryCollection;
+}
+interface ResolveLayerStrategyParams {
+    layerDetail: LayerDto;
+    bbox?: Bbox;
+    filterBBox?: Bbox;
+    filteredGeoJSON?: GeoJsonFeatureCollection | null;
+    isVisible?: boolean;
+    maxFeaturesFullGeojson?: number;
+    allowLargeGeojson?: boolean;
+}
+interface ResolveLayerStrategyResult {
+    strategy: LayerDataStrategy;
+    intersectionGeometry?: GeoJsonGeometryCollection | null;
+    effectiveBBox?: Bbox;
+}
+interface LoadLayerDataParams extends GeoJsonRequestOptions {
+    id: number | string;
+    layerDetail: LayerDto;
+    bbox?: Bbox;
+    filterBBox?: Bbox;
+    filteredGeoJSON?: GeoJsonFeatureCollection | null;
+    isVisible?: boolean;
+    maxFeaturesFullGeojson?: number;
+    allowLargeGeojson?: boolean;
+}
+interface LoadLayerDataResult<TMetadata = LayerMetadata> {
+    geojson: GeoJsonFeatureCollection;
+    strategy: LayerDataStrategy;
+    limitedMessage?: string;
+    totalFeatures?: number;
+    metadata?: TMetadata;
+}
+interface LayerFeatureCatalogItem {
+    id: string;
+    featureIndex: number;
+    properties: Record<string, string | number | boolean | null>;
+    bboxGeometry: GeoJsonPolygon;
+    centroid: GeoJsonPoint;
+    areaKm2: string;
+    geometryType: string;
+}
+interface LayerFeaturesCatalogDto {
+    layerId: number;
+    layerName: string;
+    layerType: string;
+    totalFeatures: number;
+    features: LayerFeatureCatalogItem[];
+}
+type FilterValue = string | number | boolean | Array<string | number | boolean>;
+type LayerFilters = Record<string, FilterValue | null | undefined>;
+interface FilterMultipleMetadata {
+    totalLayers?: number;
+    totalFeatures?: number;
+    appliedFilters?: Record<string, string | string[]>;
+    bbox?: unknown;
+    warnings?: string[];
+    layers?: Array<{
+        layerId: number;
+        layerName?: string;
+        featuresCount?: number;
+    }>;
+    [key: string]: unknown;
+}
+interface FilterMultipleLayerMeta {
+    layerId: number | string;
+    layerType?: string;
+    totalFeatures?: number;
+    label?: string;
+    prefilters?: LayerFilters;
+}
+interface FilterMultipleWithFallbackResult {
+    perLayer: Record<string, GeoJsonFeatureCollection>;
+    metadata?: FilterMultipleMetadata;
+    aoi?: LayerAoi | null;
+}
+
+interface MapSettings {
+    center?: {
+        lat: number;
+        lon: number;
+    } | [number, number];
+    zoom?: number;
+    basemap?: string;
+}
+interface MapLayerConfig {
+    layerId?: number | string;
+    isVisible?: boolean;
+    order?: number | string;
+    displayOrder?: number | string;
+    opacity?: number | string;
+    layer?: LayerDto;
+    name?: string;
+    layerType?: string;
+    geometryType?: string;
+    /** Estilo de la capa, cuando viene embebido en el MapDto */
+    style?: {
+        color?: string;
+        weight?: number;
+        fillColor?: string;
+        fillOpacity?: number;
+    } | null;
+    layerConfig?: {
+        prefilters?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    /** Filtros aplicados actualmente a esta capa (se setea después de operaciones de filtrado) */
+    appliedFilters?: Record<string, string | string[]>;
+    [key: string]: unknown;
+}
+interface NormalizedMapLayer {
+    layerId: number | string;
+    isVisible: boolean;
+    opacity: number;
+    displayOrder: number;
+    layer?: LayerDto;
+    layerType?: string;
+    geometryType?: string;
+    layerName?: string;
+    mapLayer: MapLayerConfig;
+}
+interface MapDto {
+    id: number | string;
+    mapType?: {
+        code?: string;
+    };
+    settings?: MapSettings;
+    mapLayers?: MapLayerConfig[];
+    layers?: LayerSummary[];
+}
+
+declare class ZenitMapsClient {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    getMap(mapId: number | string, includeLayers?: boolean): Promise<MapDto>;
+}
+
+declare function buildLayerFilters(filters?: LayerFilters): URLSearchParams;
+declare function buildFilterMultipleParams(params: {
+    layerIds: Array<number | string>;
+    filters?: LayerFilters;
+}): URLSearchParams;
+declare const DEFAULT_MAX_FEATURES_FULL_GEOJSON = 50000;
+declare function shouldUseFilterMultiple(layerType?: string): boolean;
+declare function shouldSkipGeojsonDownload(layerType?: string, totalFeatures?: number, thresholds?: {
+    maxFeatures: number;
+    allowLargeGeojson?: boolean;
+}): boolean;
+declare function buildAoiFromFeatureCollection(featureCollection: GeoJsonFeatureCollection, metadata?: FilterMultipleMetadata): LayerAoi | null;
+declare function resolveLayerStrategy(params: ResolveLayerStrategyParams): ResolveLayerStrategyResult;
+declare function buildLimitedMessage(metadata?: LayerMetadata): string | undefined;
+declare class ZenitLayersClient {
+    private readonly httpClient;
+    constructor(httpClient: HttpClient);
+    getLayer(layerId: number | string): Promise<ApiResponseData<LayerDto>>;
+    getLayerGeoJson(layerId: number | string, options?: GeoJsonRequestOptions): Promise<ApiResponseData<GeoJsonFeatureCollection>>;
+    getLayerFeaturesCatalog(layerId: number | string, options?: {
+        layerType?: string;
+        geometryType?: string;
+        strict?: boolean;
+    }): Promise<ApiResponseData<LayerFeaturesCatalogDto>>;
+    getLayerFeatures(layerId: number | string, featureIds: Array<number | string>): Promise<ApiResponseData<GeoJsonFeatureCollection>>;
+    filterLayerFeatures(layerId: number | string, filters: LayerFilters): Promise<ApiResponseData<GeoJsonFeatureCollection>>;
+    filterMultipleLayersFeatures(params: {
+        layerIds: Array<number | string>;
+        filters?: LayerFilters;
+    }): Promise<ApiResponseData<GeoJsonFeatureCollection, FilterMultipleMetadata>>;
+    filterMultiple(params: {
+        layerIds: Array<number | string>;
+        filters?: LayerFilters;
+    }): Promise<ApiResponseData<GeoJsonFeatureCollection, FilterMultipleMetadata>>;
+    /**
+     * Resilient filter-multiple helper:
+     * - Usa filter-multiple SOLO en capas multipolygon.
+     * - Para otras capas aplica filterLayerFeatures o getLayerGeoJson según haya filtros.
+     * - Nunca falla toda la operación por una capa inválida.
+     *
+     * Para mejor detección de layerType, pasa layerMetas con el layerType de cada capa.
+     */
+    filterMultipleWithFallback(params: {
+        layerIds: Array<number | string>;
+        filters?: LayerFilters;
+        layerMetas?: FilterMultipleLayerMeta[];
+        maxFeaturesFullGeojson?: number;
+        allowLargeGeojson?: boolean;
+    }): Promise<FilterMultipleWithFallbackResult>;
+    getLayerGeoJsonBBox(request: GeoJsonBBoxRequest): Promise<ApiResponseData<GeoJsonFeatureCollection>>;
+    getLayerGeoJsonIntersect(request: GeoJsonIntersectRequest): Promise<ApiResponseData<GeoJsonFeatureCollection>>;
+    getLayerTileTemplate(layerId: number | string): Promise<string>;
+    loadLayerData(params: LoadLayerDataParams): Promise<LoadLayerDataResult>;
+    loadFilteredFeatures(params: {
+        layerIds: Array<number | string>;
+        filters: LayerFilters;
+    }): Promise<{
+        geojson: GeoJsonFeatureCollection;
+        metadata?: FilterMultipleMetadata;
+        totalFeatures?: number;
+    }>;
+    private fetchByStrategy;
+    private unwrapResponse;
+}
+
+interface ZenitSdkConfig {
+    baseUrl: string;
+    sdkToken?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    onAuthError?(error: ZenitSdkError): void;
+    onTokenRefreshed?(tokens: {
+        accessToken: string;
+        refreshToken?: string;
+    }): void;
+}
+declare class ZenitClient {
+    private readonly config;
+    private accessToken?;
+    private refreshToken?;
+    private sdkToken?;
+    private readonly httpClient;
+    readonly auth: ZenitAuthClient;
+    readonly sdkAuth: ZenitSdkAuthClient;
+    readonly maps: ZenitMapsClient;
+    readonly layers: ZenitLayersClient;
+    constructor(config: ZenitSdkConfig);
+    /**
+     * Update tokens in memory and propagate to config callbacks.
+     */
+    private updateTokens;
+    private updateAccessTokenFromSdkExchange;
+    setAccessToken(token: string): void;
+    setRefreshToken(token: string): void;
+    getAuthorizationHeader(): Record<string, string>;
+    getHttpClient(): HttpClient;
+}
+
+type LayerLike = Pick<MapLayerConfig | NormalizedMapLayer, 'layerId' | 'isVisible' | 'opacity'>;
+interface LayerBaseState {
+    layerId: number | string;
+    baseVisible: boolean;
+    baseOpacity: number;
+}
+interface LayerOverrideState {
+    layerId: number | string;
+    overrideVisible?: boolean | null;
+    overrideOpacity?: number | string | null;
+}
+interface EffectiveLayerState extends LayerBaseState, LayerOverrideState {
+    visible: boolean;
+    opacity: number;
+}
+declare function initLayerStates(mapLayers: LayerLike[]): EffectiveLayerState[];
+declare function applyLayerOverrides(states: EffectiveLayerState[], overrides: LayerOverrideState[]): EffectiveLayerState[];
+declare function resetOverrides(states: EffectiveLayerState[]): EffectiveLayerState[];
+
+interface ChatRequestDto {
+    message: string;
+    conversationId?: number;
+    filteredLayerIds?: number[];
+    filters?: Record<string, unknown>;
+    userId?: number | null;
+}
+interface SuggestedAction {
+    id?: string | number;
+    type?: 'highlight' | 'zoom' | 'filter' | 'navigate';
+    label?: string;
+    action?: string;
+    layerId?: number;
+    featureId?: number | string;
+    filter?: {
+        property: string;
+        operator: 'equals' | 'contains' | 'gt' | 'lt' | 'in';
+        value: string | number | boolean | Array<string | number>;
+    };
+    bbox?: [number, number, number, number] | {
+        minLon: number;
+        minLat: number;
+        maxLon: number;
+        maxLat: number;
+    };
+    coordinates?: {
+        lat: number;
+        lon: number;
+    };
+    payload?: Record<string, unknown>;
+}
+interface ChatResponseDto {
+    conversationId: number;
+    answer: string;
+    metadata?: Record<string, unknown>;
+    suggestedActions?: SuggestedAction[];
+    relevantFeatures?: Array<Record<string, unknown>>;
+    needsMoreInfo?: boolean;
+    followUpQuestions?: string[];
+    confidence?: number;
+    systemMetadata?: Record<string, unknown>;
+}
+
+interface ChatServiceConfig {
+    baseUrl: string;
+    accessToken?: string;
+    getAccessToken?: () => string | Promise<string>;
+}
+interface ChatRequestOptions {
+    baseUrl?: string;
+    accessToken?: string;
+    getAccessToken?: () => string | Promise<string>;
+    signal?: AbortSignal;
+}
+interface ChatStreamCallbacks {
+    onChunk?: (chunk: ChatResponseDto, aggregatedText: string) => void;
+    onComplete?: (response: ChatResponseDto) => void;
+    onError?: (error: unknown) => void;
+}
+declare const sendMessage: (mapId: number, request: ChatRequestDto, options?: ChatRequestOptions, config?: ChatServiceConfig) => Promise<ChatResponseDto>;
+declare const sendMessageStream: (mapId: number, request: ChatRequestDto, callbacks?: ChatStreamCallbacks, options?: ChatRequestOptions, config?: ChatServiceConfig) => Promise<ChatResponseDto>;
+declare const createChatService: (config: ChatServiceConfig) => {
+    sendMessage: (mapId: number, request: ChatRequestDto, options?: ChatRequestOptions) => Promise<ChatResponseDto>;
+    sendMessageStream: (mapId: number, request: ChatRequestDto, callbacks?: ChatStreamCallbacks, options?: ChatRequestOptions) => Promise<ChatResponseDto>;
+};
+
+interface LayerStyle$1 {
+    color?: string;
+    weight?: number;
+    fillColor?: string;
+    fillOpacity?: number;
+}
+/**
+ * Resuelve el color de acento para una capa basado en su estilo.
+ * Prioridad: fillColor → color → null
+ */
+declare function resolveLayerAccent(style?: LayerStyle$1 | null): string | null;
+/**
+ * Obtiene el color de acento para una capa, con fallback a un color neutral.
+ * @param style - El estilo de la capa
+ * @param fallback - Color de fallback (por defecto gris neutral)
+ */
+declare function getLayerColor(style?: LayerStyle$1 | null, fallback?: string): string;
+/**
+ * Busca el estilo de una capa en un arreglo de mapLayers por su layerId.
+ */
+declare function getStyleByLayerId(layerId: string | number, mapLayers?: Array<{
+    layerId: number | string;
+    style?: LayerStyle$1 | null;
+}>): LayerStyle$1 | null;
+/**
+ * Obtiene el color de acento de una capa por su layerId.
+ */
+declare function getAccentByLayerId(layerId: string | number, mapLayers?: Array<{
+    layerId: number | string;
+    style?: LayerStyle$1 | null;
+}>): string | null;
+
+interface LayerSnapshot {
+    layerId: number | string;
+    visible: boolean;
+    opacity: number;
+}
+interface ZenitMapRef {
+    setLayerOpacity: (layerId: number | string, opacity: number) => void;
+    setLayerVisibility: (layerId: number | string, visible: boolean) => void;
+    fitBounds: (bbox: Bbox, options?: {
+        padding?: [number, number];
+        animate?: boolean;
+    }) => void;
+    setView: (coordinates: {
+        lat: number;
+        lon: number;
+    }, zoom?: number) => void;
+    getLayerSnapshot: () => LayerSnapshot[];
+    restoreLayerSnapshot: (snapshot: LayerSnapshot[]) => void;
+    highlightFeature: (layerId: number | string, featureId?: number | string) => void;
+    getMapInstance: () => L.Map | null;
+}
+interface ZenitMapProps {
+    client: ZenitClient;
+    mapId: number;
+    height?: string;
+    width?: string;
+    initialZoom?: number;
+    initialCenter?: [number, number];
+    showLayerPanel?: boolean;
+    overlayGeojson?: GeoJsonFeatureCollection | null;
+    overlayStyle?: PathOptions;
+    layerControls?: Array<{
+        layerId: number | string;
+        visible?: boolean;
+        opacity?: number;
+    }>;
+    layerStates?: EffectiveLayerState[];
+    layerGeojson?: Record<string | number, GeoJsonFeatureCollection | null | undefined>;
+    onLayerStateChange?: (states: EffectiveLayerState[]) => void;
+    onError?: (error: unknown, ctx: 'map') => void;
+    onLoadingChange?: (ctx: 'map', loading: boolean) => void;
+    onFeatureClick?: (feature: any, layerId?: number | string) => void;
+    onFeatureHover?: (feature: any, layerId?: number | string) => void;
+    featureInfoMode?: 'popup' | 'none';
+    mapLayers?: Array<{
+        layerId: number | string;
+        style?: LayerStyle$1 | null;
+    }>;
+    zoomToBbox?: Bbox | null;
+    zoomToGeojson?: GeoJsonFeatureCollection | null;
+    onZoomChange?: (zoom: number) => void;
+    onMapReady?: (map: L.Map) => void;
+}
+declare const ZenitMap: React.ForwardRefExoticComponent<ZenitMapProps & React.RefAttributes<ZenitMapRef>>;
+
+interface LayerStyle {
+    color?: string;
+    weight?: number;
+    fillColor?: string;
+    fillOpacity?: number;
+}
+interface ZenitLayerManagerProps {
+    client: ZenitClient;
+    mapId: number | string;
+    side?: 'left' | 'right';
+    className?: string;
+    style?: React.CSSProperties;
+    height?: string;
+    layerStates?: EffectiveLayerState[];
+    onLayerStatesChange?: (states: EffectiveLayerState[]) => void;
+    mapZoom?: number;
+    autoOpacityOnZoom?: boolean;
+    autoOpacityConfig?: {
+        minZoom?: number;
+        maxZoom?: number;
+        minOpacity?: number;
+        maxOpacity?: number;
+    };
+    showUploadTab?: boolean;
+    showLayerVisibilityIcon?: boolean;
+    layerFeatureCounts?: Record<string | number, number | null | undefined>;
+    mapLayers?: Array<{
+        layerId: number | string;
+        geometryType?: string | null;
+        layerType?: string | null;
+        name?: string | null;
+        style?: LayerStyle | null;
+        bboxGeometry?: GeoJsonPolygon | null;
+        displayOrder?: number | null;
+    }>;
+    onZoomToLayer?: (layerId: number | string, bboxGeometry?: GeoJsonPolygon | null) => void;
+}
+declare const ZenitLayerManager: React.FC<ZenitLayerManagerProps>;
+
+interface ZenitFeatureFilterPanelProps {
+    title?: string;
+    description?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    filters?: LayerFilters;
+    onChange?: (filters: LayerFilters) => void;
+    children?: React.ReactNode;
+}
+declare const ZenitFeatureFilterPanel: React.FC<ZenitFeatureFilterPanelProps>;
+
+interface FloatingChatBoxProps {
+    mapId?: number;
+    filteredLayerIds?: number[];
+    filters?: Record<string, unknown>;
+    userId?: number | null;
+    baseUrl?: string;
+    accessToken?: string;
+    getAccessToken?: () => string | Promise<string>;
+    onActionClick?: (action: SuggestedAction) => void;
+}
+declare const FloatingChatBox: React.FC<FloatingChatBoxProps>;
+
+declare const useSendMessage: (config?: ChatServiceConfig) => {
+    sendMessage: (mapId: number, request: ChatRequestDto, options?: ChatRequestOptions) => Promise<ChatResponseDto>;
+    isLoading: boolean;
+    error: unknown;
+};
+declare const useSendMessageStream: (config?: ChatServiceConfig) => {
+    sendMessage: (mapId: number, request: ChatRequestDto, options?: ChatRequestOptions) => Promise<ChatResponseDto>;
+    isStreaming: boolean;
+    streamingText: string;
+    completeResponse: ChatResponseDto | null;
+    error: unknown;
+    reset: () => void;
+};
+
+interface ZoomOpacityOptions {
+    minZoom?: number;
+    maxZoom?: number;
+    minFactor?: number;
+    maxFactor?: number;
+    minOpacity?: number;
+    maxOpacity?: number;
+}
+declare function clampNumber(value: number, min: number, max: number): number;
+declare function clampOpacity(value: number): number;
+declare function isPolygonLayer(layerType?: string, geometryType?: string): boolean;
+declare function getZoomOpacityFactor(zoom: number, options?: ZoomOpacityOptions): number;
+declare function getLayerZoomOpacityFactor(zoom: number, layerType?: string, geometryType?: string, options?: ZoomOpacityOptions): number;
+declare function getEffectiveLayerOpacity(baseOpacity: number, zoom: number, layerType?: string, geometryType?: string, options?: ZoomOpacityOptions): number;
+
+export { type FilterValue as $, type GeoJsonGeometryCollection as A, type Bbox as B, type LayerDataStrategy as C, DEFAULT_MAX_FEATURES_FULL_GEOJSON as D, type ApiEnvelope as E, type FilterMultipleMetadata as F, type GeoJsonFeature as G, type HttpClientOptions as H, type ApiResponseData as I, type LayerMetadata as J, type GeoJsonBBoxRequest as K, type LayerFilters as L, type MapDto as M, type NormalizedMapLayer as N, type GeoJsonIntersectRequest as O, type LayerAoi as P, type ResolveLayerStrategyParams as Q, type RefreshResponse as R, type SdkTokenValidateResponse as S, type ResolveLayerStrategyResult as T, type UserSummary as U, type ValidateResponse as V, type LoadLayerDataParams as W, type LoadLayerDataResult as X, type LayerFeatureCatalogItem as Y, type ZenitSdkConfig as Z, type LayerFeaturesCatalogDto as _, type GeoJsonFeatureCollection as a, type FilterMultipleLayerMeta as a0, type FilterMultipleWithFallbackResult as a1, type LayerBaseState as a2, type LayerOverrideState as a3, type EffectiveLayerState as a4, initLayerStates as a5, applyLayerOverrides as a6, resetOverrides as a7, type ChatServiceConfig as a8, type ChatRequestOptions as a9, getZoomOpacityFactor as aA, getLayerZoomOpacityFactor as aB, getEffectiveLayerOpacity as aC, type ChatStreamCallbacks as aa, sendMessage as ab, sendMessageStream as ac, createChatService as ad, type ChatRequestDto as ae, type SuggestedAction as af, type ChatResponseDto as ag, ZenitMap as ah, type ZenitMapRef as ai, type LayerSnapshot as aj, type ZenitMapProps as ak, ZenitLayerManager as al, ZenitFeatureFilterPanel as am, FloatingChatBox as an, type FloatingChatBoxProps as ao, useSendMessage as ap, useSendMessageStream as aq, type LayerStyle$1 as ar, resolveLayerAccent as as, getLayerColor as at, getStyleByLayerId as au, getAccentByLayerId as av, type ZoomOpacityOptions as aw, clampNumber as ax, clampOpacity as ay, isPolygonLayer as az, type GeoJsonRequestOptions as b, type GeoJsonPolygon as c, ZenitClient as d, type LoginRequest as e, type LoginResponse as f, type MeResponse as g, ZenitAuthClient as h, type SdkTokenExchangeResponse as i, ZenitSdkAuthClient as j, type ZenitSdkError as k, HttpClient as l, ZenitMapsClient as m, type MapSettings as n, type MapLayerConfig as o, buildLayerFilters as p, buildFilterMultipleParams as q, shouldSkipGeojsonDownload as r, shouldUseFilterMultiple as s, buildAoiFromFeatureCollection as t, resolveLayerStrategy as u, buildLimitedMessage as v, ZenitLayersClient as w, type LayerDto as x, type LayerSummary as y, type GeoJsonPoint as z };