@thibezer/ui-components-kit 1.0.0

package/dist/components/ui-camadas/index.d.ts

@@ -0,0 +1,11 @@
+export * from './tipos';
+export * from './camadas-icones';
+export * from './camadas-metricas';
+export * from './camadas-mapas-base';
+export * from './camadas-rodape';
+export * from './camadas-arvore-renderer';
+export * from './camadas-drag-drop';
+export * from './camadas-persistencia';
+export * from './camadas-host';
+export * from './camadas-selecao';
+export * from './ui-camadas';

package/dist/components/ui-camadas/tipos.d.ts

@@ -0,0 +1,116 @@
+export type TipoGeometriaFeicao = 'Point' | 'LineString' | 'Polygon' | 'MultiPoint' | 'MultiLineString' | 'MultiPolygon' | string;
+export type StatusGeometriaFeicao = 'oficial' | 'previa' | 'rascunho' | string;
+export interface FeicaoEstilo {
+    cor?: string;
+    fillColor?: string;
+    strokeColor?: string;
+    strokeWidth?: number;
+    opacity?: number;
+    fillOpacity?: number;
+    dashArray?: string;
+    [key: string]: unknown;
+}
+export type CoordenadasGeoJSON = [number, number] | [number, number][] | [number, number][][] | [number, number][][][] | number[] | number[][] | number[][][] | number[][][][] | unknown;
+export interface FeicaoItem {
+    id: string;
+    name: string;
+    layerId: string;
+    type?: TipoGeometriaFeicao;
+    geometryType?: string;
+    visible?: boolean;
+    locked?: boolean;
+    color?: string;
+    style?: FeicaoEstilo;
+    category?: string;
+    status?: StatusGeometriaFeicao;
+    coordinates?: CoordenadasGeoJSON;
+    properties?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface CamadaItem {
+    id: string;
+    name: string;
+    color?: string;
+    visible?: boolean;
+    locked?: boolean;
+    opacity?: number;
+    order?: number;
+    count?: number;
+    description?: string;
+    [key: string]: unknown;
+}
+export interface MapaBaseItem {
+    id: string;
+    nome: string;
+    descricao?: string;
+    thumbnailUrl?: string;
+    icone?: string;
+}
+export type AbaPainelCamadas = 'camadas' | 'inspecao' | 'equipe';
+export interface UICamadasOpcoes {
+    camadas?: CamadaItem[];
+    feicoes?: FeicaoItem[];
+    mapasBase?: MapaBaseItem[];
+    mapaBaseAtivo?: string;
+    camadaAtivaId?: string;
+    abaAtiva?: AbaPainelCamadas;
+    colapsavel?: boolean;
+    colapsado?: boolean;
+    flutuante?: boolean;
+    mostrarMapasBase?: boolean;
+    mostrarRodape?: boolean;
+    mostrarBusca?: boolean;
+    densidade?: 'compacto' | 'normal';
+}
+export interface DetalheEventoCamada {
+    camadaId: string;
+    camada?: CamadaItem;
+}
+export interface DetalheEventoVisibilidadeCamada {
+    camadaId: string;
+    visivel: boolean;
+}
+export interface DetalheEventoBloqueioCamada {
+    camadaId: string;
+    bloqueado: boolean;
+}
+export interface DetalheEventoOpacidadeCamada {
+    camadaId: string;
+    opacidade: number;
+}
+export interface DetalheEventoCorCamada {
+    camadaId: string;
+    cor: string;
+}
+export interface DetalheEventoRenomearCamada {
+    camadaId: string;
+    novoNome: string;
+}
+export interface DetalheEventoFeicao {
+    feicaoId: string;
+    feicao?: FeicaoItem;
+}
+export interface DetalheEventoVisibilidadeFeicao {
+    feicaoId: string;
+    visivel: boolean;
+}
+export interface DetalheEventoBloqueioFeicao {
+    feicaoId: string;
+    bloqueado: boolean;
+}
+export interface DetalheEventoRenomearFeicao {
+    feicaoId: string;
+    novoNome: string;
+}
+export interface DetalheEventoMoverFeicao {
+    feicaoId: string;
+    camadaOrigemId: string;
+    camadaDestinoId: string;
+    feicao: FeicaoItem;
+}
+export interface DetalheEventoAcaoMassa {
+    feicoesIds: string[];
+    feicoes: FeicaoItem[];
+    acao: 'visibilidade' | 'bloqueio' | 'cor' | 'mover' | 'excluir' | 'limpar';
+    valor?: unknown;
+}

package/dist/components/ui-camadas/ui-camadas.d.ts

@@ -0,0 +1,112 @@
+import { SafeHTMLElement } from '../../core/ssr-safe';
+import { CamadaItem, FeicaoItem, MapaBaseItem, AbaPainelCamadas } from './tipos';
+import { CamadasHostCompleto } from './camadas-host';
+export declare class UICamadas extends SafeHTMLElement implements CamadasHostCompleto {
+    static get observedAttributes(): string[];
+    private shadow;
+    private listeners;
+    private dragDropManager;
+    private resizerController;
+    private alturaCustomizada;
+    private conectado;
+    private origensCamadas;
+    private salvarLembrancaDebounced;
+    camadas: CamadaItem[];
+    feicoes: FeicaoItem[];
+    mapasBase: MapaBaseItem[];
+    expandedLayers: Set<string>;
+    selectedFeatureIds: Set<string>;
+    lastClickedFeatureId: string | null;
+    activeSettingsLayerId: string | null;
+    editingLayerId: string | null;
+    editingFeatureId: string | null;
+    searchQuery: string;
+    private corpoElement;
+    private btnExpandirFlutuante;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldVal: string | null, newVal: string | null): void;
+    get titulo(): string;
+    set titulo(valor: string);
+    get camadaAtivaId(): string | null;
+    set camadaAtivaId(id: string | null);
+    get mapaBaseAtivo(): string;
+    set mapaBaseAtivo(valor: string);
+    selecionarMapaBase(id: string, emitirEvento?: boolean): void;
+    private marcarMapaBaseAtivoNoDOM;
+    get abaAtiva(): AbaPainelCamadas;
+    set abaAtiva(aba: AbaPainelCamadas);
+    get colapsado(): boolean;
+    set colapsado(valor: boolean);
+    get colapsavel(): boolean;
+    set colapsavel(valor: boolean);
+    get flutuante(): boolean;
+    set flutuante(valor: boolean);
+    get densidade(): 'compacto' | 'normal';
+    set densidade(valor: 'compacto' | 'normal');
+    get mostrarMapasBase(): boolean;
+    set mostrarMapasBase(valor: boolean);
+    get mostrarRodape(): boolean;
+    set mostrarRodape(valor: boolean);
+    get mostrarBusca(): boolean;
+    set mostrarBusca(valor: boolean);
+    get persistir(): boolean;
+    set persistir(valor: boolean);
+    get storageKey(): string | null;
+    set storageKey(valor: string | null);
+    get redimensionavel(): boolean;
+    set redimensionavel(valor: boolean);
+    get altura(): string | null;
+    set altura(valor: string | number | null);
+    definirAltura(alturaPx: number | string | null, persistir?: boolean): void;
+    obterChaveStorageAtual(): string;
+    /** Versão com debounce, para interações contínuas (seletor de cor, slider de opacidade). */
+    agendarSalvarLembranca(): void;
+    salvarLembrancaEstado(): void;
+    limparLembranca(): void;
+    /** Atalho reativo para `definirCamadas()` — não dispara eventos. */
+    get layers(): CamadaItem[];
+    set layers(camadas: CamadaItem[]);
+    /** Atalho reativo para `definirFeicoes()` — não dispara eventos. */
+    get features(): FeicaoItem[];
+    set features(feicoes: FeicaoItem[]);
+    /** Atalho reativo para `definirMapasBase()` — não dispara eventos. */
+    get basemaps(): MapaBaseItem[];
+    set basemaps(mapas: MapaBaseItem[]);
+    definirCamadas(camadas: CamadaItem[], feicoes?: FeicaoItem[]): void;
+    definirFeicoes(feicoes: FeicaoItem[]): void;
+    definirMapasBase(mapas: MapaBaseItem[]): void;
+    definirCamadaAtiva(camadaId: string, emitirEvento?: boolean): void;
+    obterCamada(id: string): CamadaItem | undefined;
+    obterCamadaAtiva(): CamadaItem | undefined;
+    obterFeicao(id: string): FeicaoItem | undefined;
+    obterFeicoesSelecionadas(): FeicaoItem[];
+    adicionarCamada(camada: CamadaItem): void;
+    removerCamada(camadaId: string): void;
+    adicionarFeicao(feicao: FeicaoItem): void;
+    atualizarFeicao(feicaoAtualizada: FeicaoItem): void;
+    removerFeicao(feicaoId: string): void;
+    selecionarFeicao(feicaoId: string, acumular?: boolean, intervalo?: boolean, emitirEvento?: boolean): void;
+    selecionarFeicoes(ids: string[], emitirEvento?: boolean): void;
+    limparSelecao(emitirEvento?: boolean): void;
+    expandirTodas(): void;
+    colapsarTodas(): void;
+    alternarVisibilidadeTodas(emitirEvento?: boolean): void;
+    colapsar(emitirEvento?: boolean): void;
+    expandir(emitirEvento?: boolean): void;
+    alternarColapso(emitirEvento?: boolean): void;
+    private definirColapso;
+    solicitarRenderizacao(): void;
+    dispararEvento(nome: string, detalhe: unknown): void;
+    private render;
+    private conectarEventosGerais;
+    private sincronizarCamadaAtivaDOM;
+    sincronizarSelecaoDOM(): void;
+    private sincronizarSelecoesComFeicoesValidas;
+    notificarMudancaSelecao(): void;
+}
+export declare class UIPainelCamadas extends UICamadas {
+}
+export declare class UILayerPanel extends UICamadas {
+}

package/dist/components/ui-campo-texto/campo-texto-estados.d.ts

@@ -0,0 +1,12 @@
+export interface ContextoLabelPlaceholder {
+    labelElement: HTMLLabelElement;
+    inputElement: HTMLInputElement;
+    labelText: string | null;
+    placeholderText: string;
+    isFlutuante: boolean;
+    estaFocado: boolean;
+    obrigatorio?: boolean;
+}
+export declare function sincronizarLabelEPlaceholder(ctx: ContextoLabelPlaceholder): void;
+export declare function sincronizarIconeSenha(container: HTMLSpanElement, ehSenhaOuAlternar: boolean, senhaVisivel: boolean): void;
+export declare function sincronizarFeedbackErro(wrapper: HTMLDivElement, input: HTMLInputElement, helper: HTMLDivElement, temErro: boolean, mensagemErro: string | null, helperText: string | null): void;

package/dist/components/ui-campo-texto/campo-texto-template.d.ts

@@ -0,0 +1,2 @@
+export declare const ATRIBUTOS_OBSERVADOS_CAMPO_TEXTO: string[];
+export declare function criarTemplateCampoTexto(): string;

package/dist/components/ui-campo-texto/index.d.ts

@@ -0,0 +1 @@
+export * from './ui-campo-texto';

package/dist/components/ui-campo-texto/ui-campo-texto.d.ts

@@ -0,0 +1,57 @@
+import { FormAssociatedElement } from '../../core/form-associated-element';
+export declare class UICampoTexto extends FormAssociatedElement {
+    static get observedAttributes(): string[];
+    private labelElement;
+    private wrapperElement;
+    private inputElement;
+    private helperElement;
+    private rightIconContainer;
+    private leftSlotElement;
+    private _senhaVisivel;
+    private _checkTimer;
+    private _focado;
+    private _inputId;
+    private _defaultValue;
+    constructor();
+    focus(options?: FocusOptions): void;
+    blur(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    get value(): string;
+    set value(val: string);
+    formResetCallback(): void;
+    formStateRestoreCallback(state: any, _mode: 'restore' | 'autocomplete'): void;
+    get name(): string;
+    set name(val: string);
+    get type(): string;
+    get disabled(): boolean;
+    set disabled(val: boolean);
+    get minLength(): number;
+    set minLength(val: number);
+    get maxLength(): number;
+    set maxLength(val: number);
+    get pattern(): string;
+    set pattern(val: string);
+    atualizarValidade(): void;
+    alternarVisibilidadeSenha(): void;
+    private handleSlotChange;
+    protected syncState(): void;
+    /**
+     * Sem o atributo `label`, o input nativo herda o nome acessível de fora do Shadow DOM
+     * (`aria-label` no host, `<label for>` ou `<label>` envolvente).
+     */
+    private sincronizarNomeAcessivel;
+    private handleHostClick;
+    private handleRightIconClick;
+    private handleRightIconKeyDown;
+    private handleFocus;
+    private handleBlur;
+    private handleInput;
+    private handleChange;
+}
+/** Alias semântico: `<ui-input>` é idêntico a `<ui-campo-texto>`. */
+export declare class UIInput extends UICampoTexto {
+}
+export * from './campo-texto-estados';
+export * from './campo-texto-template';

package/dist/components/ui-canvas-cad/cad-atributos-sync.d.ts

@@ -0,0 +1,13 @@
+import { UICanvasCAD } from './ui-canvas-cad';
+import { GerenciadorBroadcastConfig } from './cad-broadcast';
+import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
+export interface ContextoAtributosCAD {
+    host: UICanvasCAD;
+    controller: GerenciGeoMapaController;
+    mapContainer: HTMLDivElement | null;
+    broadcastConfig: GerenciadorBroadcastConfig;
+    setLayerOpacity: (id: string, op: number) => void;
+    setLayerScaleMode: (id: string, mode: any) => void;
+    atualizarZonaProjecao: (zona: number) => void;
+}
+export declare function sincronizarAtributoCAD(ctx: ContextoAtributosCAD, name: string, oldVal: string, newVal: string): void;

package/dist/components/ui-canvas-cad/cad-broadcast.d.ts

@@ -0,0 +1,19 @@
+import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
+export interface ContextoBroadcastCAD {
+    host: HTMLElement;
+    controller: GerenciGeoMapaController;
+    mapContainer: HTMLDivElement | null;
+    setLayerOpacity: (camadaId: string, opacidade: number) => void;
+}
+/**
+ * Gerencia a comunicação assíncrona desacoplada via BroadcastChannel
+ * para aplicar parâmetros de tema, cursor e opacidade em tempo real.
+ */
+export declare class GerenciadorBroadcastConfig {
+    private canal;
+    private contexto;
+    constructor(contexto: ContextoBroadcastCAD);
+    conectar(canalNome?: string | null): void;
+    processarMensagem(data: any): void;
+    desconectar(): void;
+}

package/dist/components/ui-canvas-cad/cad-colecoes-dados.d.ts

@@ -0,0 +1,46 @@
+import { default as L } from 'leaflet';
+import { Ponto, Segmento, BancoPonto, Confrontante, PontoCAD, ConexaoCAD, PoligonoCAD } from '../../gerencigeo-canvas/types';
+import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
+export interface ContextoColecoesDados {
+    obterController: () => GerenciGeoMapaController;
+    obterChaveGrupo: () => string | undefined;
+    setLayerVisibility: (id: string, visivel: boolean) => void;
+}
+/**
+ * Gerencia as coleções de entidades geométricas em memória (pontos, segmentos,
+ * banco de pontos, confrontantes) e a sincronização com a engine de mapa.
+ */
+export declare class GerenciadorColecoesDados {
+    private contexto;
+    private _pontos;
+    private _segmentos;
+    private _bancoPontos;
+    private _confrontantes;
+    customMarkerClickHandler?: (pontoId: number, isVizinho?: boolean) => void;
+    constructor(contexto: ContextoColecoesDados);
+    get pontos(): Ponto[];
+    set pontos(val: Ponto[]);
+    get segmentos(): Segmento[];
+    set segmentos(val: Segmento[]);
+    get bancoPontos(): BancoPonto[];
+    set bancoPontos(val: BancoPonto[]);
+    get confrontantes(): Confrontante[];
+    set confrontantes(val: Confrontante[]);
+    sincronizarInicial(): void;
+    obterElementoPorId(id: string | number): any;
+    plotarPontos(pontos?: PontoCAD[] | null, camadaId?: string, onClique?: (ponto: PontoCAD) => void): void;
+    plotarConexoes(conexoes?: ConexaoCAD[] | null, camadaId?: string): void;
+    plotarPolilinhaSequencial(pontos?: PontoCAD[] | null, fechar?: boolean, camadaId?: string, chaveGrupo?: string): void;
+    plotarPoligonos(poligonos?: PoligonoCAD[] | null, camadaId?: string): void;
+    limparCamadas(idsCamadas?: string[]): void;
+    obterMarcadores(camadaId?: string): L.Marker[];
+    plotPontos(pontos?: Ponto[] | null, onMarkerClick?: (pontoId: number, isVizinho?: boolean) => void): void;
+    plotSegmentos(segmentos?: Segmento[] | null, pontos?: Ponto[] | null): void;
+    plotPolilinhaTemporaria(pontos?: Ponto[] | null): void;
+    plotPoligonalHomologada(bancoPontos?: BancoPonto[] | null): void;
+    plotPontosVizinhos(pontos?: Ponto[] | null): void;
+    plotPoligonosVizinhos(confrontantes?: Confrontante[] | null): void;
+    clearOverlays(manterBanco?: boolean): void;
+    getMarkers(): L.Marker[];
+    getVizinhosMarkers(): L.Marker[];
+}

package/dist/components/ui-canvas-cad/cad-eventos-canvas.d.ts

@@ -0,0 +1,26 @@
+import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
+export interface ContextoEventosCanvas {
+    host: HTMLElement;
+    controller: GerenciGeoMapaController;
+    mapContainer: HTMLElement | null;
+    modoSequencial: boolean;
+    mouseMovedSinceDown: boolean;
+    obterElementoPorId: (id: string | number) => any;
+    fecharPopup: () => void;
+}
+export declare function processarCliqueLivreCanvas(ctx: ContextoEventosCanvas, e: MouseEvent | any, latLngParam?: {
+    lat: number;
+    lng?: number;
+    lon?: number;
+}, containerPointParam?: {
+    x: number;
+    y: number;
+}): boolean;
+export declare function processarAcaoPopup(ctx: ContextoEventosCanvas, acaoId: string, elementoId: string | number, elemento?: any): void;
+export declare function tratarCliqueMarcador(ctx: ContextoEventosCanvas, pId: string | number, isVizinho: boolean | undefined, elemento: any, coords: {
+    lat: number;
+    lon: number;
+} | undefined, prevMarkerClick?: (pId: string | number, isVizinho?: boolean, elemento?: any, coords?: {
+    lat: number;
+    lon: number;
+}) => void, customMarkerClickHandler?: (pontoId: number, isVizinho?: boolean) => void): void;

package/dist/components/ui-canvas-cad/cad-inicializador.d.ts

@@ -0,0 +1,19 @@
+import { UICanvasCAD } from './ui-canvas-cad';
+import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
+import { GerenciadorToolbarPainel } from './cad-toolbar-painel';
+import { GerenciadorColecoesDados } from './cad-colecoes-dados';
+import { ContextoEventosCanvas } from './cad-eventos-canvas';
+export interface ContextoInicializadorCAD {
+    host: UICanvasCAD;
+    shadow: ShadowRoot;
+    mapContainer: HTMLDivElement | null;
+    controller: GerenciGeoMapaController;
+    toolbarPainel: GerenciadorToolbarPainel;
+    colecoesDados: GerenciadorColecoesDados;
+    obterContextoEventos: () => ContextoEventosCanvas;
+    renderLayersUI: () => void;
+    invalidateSizeSafely: () => void;
+    tratarCliqueLivreCanvas: (e: any, latlng?: any, containerPoint?: any) => void;
+    dispararAcaoPopup: (acaoId: string, elementoId: string | number, elemento?: any) => void;
+}
+export declare function inicializarCAD(ctx: ContextoInicializadorCAD): void;

package/dist/components/ui-canvas-cad/cad-painel-camadas.d.ts

@@ -0,0 +1,9 @@
+import { CanvasLayerDef, ScaleMode } from '../../gerencigeo-canvas/types';
+import { ListenerBag } from '../../core/listener-bag';
+export interface PainelCamadasCallbacks {
+    setLayerVisibility: (id: string, visivel: boolean) => void;
+    setLayerOpacity: (id: string, opacidade: number) => void;
+    setLayerBlocked: (id: string, bloqueada: boolean) => void;
+    setLayerScaleMode: (id: string, mode: ScaleMode) => void;
+}
+export declare function renderizarPainelCamadas(container: HTMLElement | null, layers: CanvasLayerDef[], layerItemListeners: ListenerBag, callbacks: PainelCamadasCallbacks): void;

package/dist/components/ui-canvas-cad/cad-tamanho-observer.d.ts

@@ -0,0 +1,7 @@
+import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
+export interface ControladorTamanhoCanvas {
+    observe: () => void;
+    disconnect: () => void;
+    invalidateSizeSafely: () => void;
+}
+export declare function criarControladorTamanho(host: HTMLElement, controller: GerenciGeoMapaController): ControladorTamanhoCanvas;

package/dist/components/ui-canvas-cad/cad-template.d.ts

@@ -0,0 +1 @@
+export declare function obterTemplateCanvasCAD(): string;

package/dist/components/ui-canvas-cad/cad-toolbar-painel.d.ts

@@ -0,0 +1,29 @@
+export interface ContextoToolbarPainel {
+    shadow: ShadowRoot;
+    mapContainer: HTMLDivElement | null;
+    layersPanel: HTMLDivElement | null;
+    onToggleCamadas?: () => void;
+    onCloseCamadas?: () => void;
+    onZoomExtents?: () => void;
+    onLimparSelecao?: () => void;
+    onTratarCliqueCanvas?: (e: MouseEvent) => void;
+    onDispararAcaoPopup?: (acaoId: string, elementoId: string | number) => void;
+}
+/**
+ * Gerencia a interação da interface com a barra de ferramentas rápida,
+ * painel retrátil de camadas e detecção de clique versus pan no container do mapa.
+ */
+export declare class GerenciadorToolbarPainel {
+    private contexto;
+    private uiListeners;
+    private isLayersPanelOpen;
+    private mouseMovedSinceDown;
+    private mouseDownPos;
+    constructor(contexto: ContextoToolbarPainel);
+    get estaPainelAberto(): boolean;
+    get houveMovimentoMouse(): boolean;
+    toggleLayersPanel(): void;
+    closeLayersPanel(): void;
+    vincularEventos(): void;
+    limpar(): void;
+}

package/dist/components/ui-canvas-cad/index.d.ts

@@ -0,0 +1,8 @@
+export * from './ui-canvas-cad';
+export * from './cad-painel-camadas';
+export * from './cad-eventos-canvas';
+export * from './cad-tamanho-observer';
+export * from '../../gerencigeo-canvas/types';
+export * from '../../gerencigeo-canvas/layer_manager';
+export * from '../../gerencigeo-canvas/layer_renderer_factory';
+export * from '../../gerencigeo-canvas/mapa_controller';

package/dist/components/ui-canvas-cad/ui-canvas-cad.d.ts

@@ -0,0 +1,91 @@
+import { default as L } from 'leaflet';
+import { Ponto, Segmento, BancoPonto, Confrontante, CanvasLayerState, CanvasGraphicScale, ScaleMode, PontoCAD, ConexaoCAD, PoligonoCAD, DestacarElementoOpcoes } from '../../gerencigeo-canvas/types';
+import { GerenciGeoMapaController } from '../../gerencigeo-canvas/mapa_controller';
+import { CanvasLayerManager } from '../../gerencigeo-canvas/layer_manager';
+import { SafeHTMLElement } from '../../core/ssr-safe';
+export declare class UICanvasCAD extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    private shadow;
+    private mapContainer;
+    private layersPanel;
+    private controller;
+    private controladorTamanho;
+    private toolbarPainel;
+    private broadcastConfig;
+    private colecoesDados;
+    private layerItemListeners;
+    private initTimeout?;
+    private lastPopupActionEmit?;
+    private lastCanvasClickTime;
+    private _chaveGrupo?;
+    private _zonaProjecao;
+    constructor();
+    connectedCallback(): void;
+    destroy(): void;
+    disconnectedCallback(): void;
+    invalidateSizeSafely(): void;
+    attributeChangedCallback(name: string, oldVal: string, newVal: string): void;
+    private initCAD;
+    private obterContextoEventos;
+    tratarCliqueLivreCanvas(e: MouseEvent | any, latLng?: any, pt?: any): void;
+    dispararAcaoPopup(acaoId: string, elementoId: string | number, elemento?: any): void;
+    toggleLayersPanel(): void;
+    closeLayersPanel(): void;
+    private renderLayersUI;
+    get pontos(): Ponto[];
+    set pontos(val: Ponto[]);
+    get segmentos(): Segmento[];
+    set segmentos(val: Segmento[]);
+    get bancoPontos(): BancoPonto[];
+    set bancoPontos(val: BancoPonto[]);
+    get pontosHomologados(): BancoPonto[];
+    set pontosHomologados(val: BancoPonto[]);
+    get confrontantes(): Confrontante[];
+    set confrontantes(val: Confrontante[]);
+    get vizinhos(): Confrontante[];
+    set vizinhos(val: Confrontante[]);
+    get modoSequencial(): boolean;
+    set modoSequencial(val: boolean);
+    get chaveGrupo(): string | undefined;
+    set chaveGrupo(val: string | undefined);
+    get zonaProjecao(): number;
+    set zonaProjecao(val: number);
+    get canalConfiguracao(): string | null;
+    set canalConfiguracao(val: string | null);
+    fitBounds(pontos?: Ponto[], padding?: [number, number], incluirVizinhos?: boolean): void;
+    zoomExtents(): void;
+    selectPonto(id: string | number, zoomLevel?: number): void;
+    selecionarPonto(id: string | number, zoomLevel?: number): void;
+    get pontosSelecionados(): (string | number)[];
+    set pontosSelecionados(ids: (string | number)[]);
+    atualizarDestaqueMarcadores(): void;
+    limparSelecao(): void;
+    setLayerVisibility(id: string, visivel: boolean): void;
+    setLayerOpacity(id: string, opacidade: number): void;
+    setLayerScaleMode(id: string, mode: ScaleMode): void;
+    setGraphicScale(scale: Partial<CanvasGraphicScale>): void;
+    exportState(): CanvasLayerState[];
+    importState(state: CanvasLayerState[]): void;
+    invalidateSize(): void;
+    get destaqueAtivo(): boolean;
+    destacarElemento(id: string | number, opcoes?: DestacarElementoOpcoes): void;
+    limparDestaque(): void;
+    plotarPontos(p?: PontoCAD[] | null, c?: string, cl?: (p: PontoCAD) => void): void;
+    plotarConexoes(conexoes?: ConexaoCAD[] | null, camadaId?: string): void;
+    plotarPolilinhaSequencial(p?: PontoCAD[] | null, f?: boolean, c?: string, cg?: string): void;
+    plotarPoligonos(poligonos?: PoligonoCAD[] | null, camadaId?: string): void;
+    limparCamadas(idsCamadas?: string[]): void;
+    obterMarcadores(camadaId?: string): L.Marker[];
+    plotPontos(p?: Ponto[] | null, cl?: (id: number, viz?: boolean) => void): void;
+    plotSegmentos(s?: Segmento[] | null, p?: Ponto[] | null): void;
+    plotPolilinhaTemporaria(pontos?: Ponto[] | null): void;
+    plotPoligonalHomologada(bancoPontos?: BancoPonto[] | null): void;
+    plotPontosVizinhos(pontos?: Ponto[] | null): void;
+    plotPoligonosVizinhos(confrontantes?: Confrontante[] | null): void;
+    clearOverlays(manterBanco?: boolean): void;
+    getMarkers(): L.Marker[];
+    getVizinhosMarkers(): L.Marker[];
+    getMap(): L.Map | null;
+    getController(): GerenciGeoMapaController;
+    getLayerManager(): CanvasLayerManager;
+}

package/dist/components/ui-card/index.d.ts

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

package/dist/components/ui-card/ui-card.d.ts

@@ -0,0 +1,18 @@
+import { SafeHTMLElement } from '../../core/ssr-safe';
+export declare class UICard extends SafeHTMLElement {
+    static get observedAttributes(): string[];
+    private cardElement;
+    private listeners;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
+    private handleSlotChange;
+    get clicavel(): boolean;
+    set clicavel(val: boolean);
+    get disabled(): boolean;
+    set disabled(val: boolean);
+    private syncState;
+    private handleClick;
+    private handleKeyDown;
+}

package/dist/components/ui-checkbox/index.d.ts

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

package/dist/components/ui-checkbox/ui-checkbox.d.ts

@@ -0,0 +1,36 @@
+import { FormAssociatedElement } from '../../core/form-associated-element';
+export declare class UICheckbox extends FormAssociatedElement {
+    static get observedAttributes(): string[];
+    private containerElement;
+    private markElement;
+    private labelElement;
+    private listeners;
+    private _defaultChecked;
+    private _defaultIndeterminate;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(_name: string, _old: string | null, _value: string | null): void;
+    get marcado(): boolean;
+    set marcado(val: boolean);
+    get checked(): boolean;
+    set checked(val: boolean);
+    get value(): string;
+    set value(val: string);
+    get name(): string;
+    set name(val: string);
+    get indeterminado(): boolean;
+    set indeterminado(val: boolean);
+    get disabled(): boolean;
+    set disabled(val: boolean);
+    get type(): string;
+    atualizarValidade(): void;
+    alternar(): void;
+    protected syncState(): void;
+    formResetCallback(): void;
+    formStateRestoreCallback(state: any, _mode: 'restore' | 'autocomplete'): void;
+    private handleClick;
+    private handleKeyDown;
+    private handleFocus;
+    private handleBlur;
+}