@ngx-smz/core 19.2.0

package/lib/builders/smz-gauge/gauge-builder.d.ts

@@ -0,0 +1,188 @@
+import { Observable } from 'rxjs';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzGaugeState, SmzGaugeThreshold } from '../../modules/smz-gauge/smz-gauge.types';
+/**
+ * Classe para construir o estado de um Gauge (medidor) com configurações dinâmicas e personalizadas.
+ * Utiliza o padrão de projeto Builder para facilitar a criação de configurações complexas.
+ *
+ * @example
+ * ```typescript
+ * // Exemplo de uso do SmzGaugeBuilder
+ * import { SmzGaugeBuilder } from './path/to/SmzGaugeBuilder';
+ * import { createRangeObservable } from './path/to/observable-helper';
+ *
+ * const gauge = new SmzGaugeBuilder()
+ *   .withSize(250)
+ *   .withTitle('Plano de Pintura')
+ *   .withTitleStyle('font-bold text-4xl')
+ *   .withValue(createRangeObservable(0, 100, 10000))
+ *   .withValueThrottleTime(300)
+ *   .withDecimalPlaces(2, false)
+ *   .withRange(0, 100)
+ *   .withUnit('%')
+ *   .withBackgroundColor('#e6e6e6')
+ *   .withFont('bold', '#000000')
+ *   .withMinMaxFont('bold', '#000000')
+ *   .addThreshold()
+ *     .withValue(0)
+ *     .withColor('#264653')
+ *     .gauge
+ *   .addThreshold()
+ *     .withValue(25)
+ *     .withColor('#2a9d8f')
+ *     .gauge
+ *   .addThreshold()
+ *     .withValue(50)
+ *     .withColor('#e9c46a')
+ *     .gauge
+ *   .addThreshold()
+ *     .withValue(75)
+ *     .withColor('#f4a261')
+ *     .gauge
+ *   .addThreshold()
+ *     .withValue(100)
+ *     .withColor('#e76f51')
+ *     .gauge
+ *   .build();
+ * ```
+ */
+export declare class SmzGaugeBuilder extends SmzBuilderUtilities<SmzGaugeBuilder> {
+    protected that: this;
+    private _state;
+    /**
+     * Inicializa uma nova instância do SmzGaugeBuilder.
+     */
+    constructor();
+    /**
+     * Define o modo de depuração do medidor.
+     * @param debugMode - Indica se o modo de depuração está ativado.
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withDebugMode(debugMode: boolean): SmzGaugeBuilder;
+    /**
+     * Define o tamanho do medidor em pixels.
+     * @param size - O tamanho desejado em pixels. Deve ser maior ou igual a 100.
+     * @throws Erro se o tamanho for menor que 100.
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withSize(size: number): SmzGaugeBuilder;
+    /**
+     * Define o título do medidor e ativa sua exibição.
+     * @param title - O título a ser exibido.
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withTitle(title: string): SmzGaugeBuilder;
+    /**
+     * Define o estilo CSS do título do medidor.
+     * @param titleStyle - O estilo CSS a ser aplicado ao título.
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withTitleStyle(titleStyle: string): SmzGaugeBuilder;
+    /**
+     * Define o valor do medidor como um Observable.
+     * @param value$ - O Observable que fornece os valores do medidor.
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withValue(value$: Observable<number>): SmzGaugeBuilder;
+    /**
+     * Define o tempo de throttle para o valor do medidor.
+     * @param valueThrottleTime - O tempo de throttle em milissegundos.
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withValueThrottleTime(valueThrottleTime: number): SmzGaugeBuilder;
+    /**
+     * Define o número de casas decimais para o valor do medidor e, opcionalmente, para os valores mínimo e máximo.
+     * @param decimalPlaces - O número de casas decimais (deve ser entre 0 e 3).
+     * @param includeMinMax - Se verdadeiro, aplica o formato também aos valores mínimo e máximo.
+     * @throws Erro se o número de casas decimais for negativo ou maior que 3.
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withDecimalPlaces(decimalPlaces: number, includeMinMax?: boolean): SmzGaugeBuilder;
+    /**
+     * Define os valores mínimo e máximo do medidor.
+     * @param min - O valor mínimo.
+     * @param max - O valor máximo.
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withRange(min: number, max: number): SmzGaugeBuilder;
+    /**
+     * Oculta os valores mínimo e máximo do medidor.
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    hideMinMax(): SmzGaugeBuilder;
+    /**
+     * Define a unidade de medida do medidor e ativa sua exibição.
+     * @param unit - A unidade de medida.
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withUnit(unit: string): SmzGaugeBuilder;
+    /**
+     * Define o peso e a cor da fonte do valor do medidor.
+     * @param fontWeight - O peso da fonte (ex.: "bold").
+     * @param fontColor - A cor da fonte (ex.: "#000000").
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withFont(fontWeight: string, fontColor: string): SmzGaugeBuilder;
+    /**
+     * Define o peso e a cor da fonte para os valores mínimo e máximo do medidor.
+     * @param fontWeight - O peso da fonte (ex.: "bold").
+     * @param fontColor - A cor da fonte (ex.: "#000000").
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withMinMaxFont(fontWeight: string, fontColor: string): SmzGaugeBuilder;
+    /**
+     * Define a cor de fundo do medidor.
+     * @param backgroundColor - A cor de fundo (ex.: "#e6e6e6").
+     * @returns A instância atual do SmzGaugeBuilder para encadeamento de métodos.
+     */
+    withBackgroundColor(backgroundColor: string): SmzGaugeBuilder;
+    /**
+     * Adiciona um novo limite (threshold) ao medidor.
+     * @returns Uma instância do SmzGaugeThresholdBuilder para definir o limite.
+     */
+    addThreshold(): SmzGaugeThresholdBuilder;
+    /**
+     * Constrói e retorna o estado final do medidor, organizando os limites em ordem crescente de valor.
+     * @returns O estado completo do SmzGauge.
+     */
+    build(): SmzGaugeState;
+}
+/**
+ * Builder para definir os limites (thresholds) de um SmzGauge.
+ * Permite a configuração de valores específicos e cores associadas.
+ */
+export declare class SmzGaugeThresholdBuilder extends SmzBuilderUtilities<SmzGaugeThresholdBuilder> {
+    private _parent;
+    private _threshold;
+    private _min;
+    private _max;
+    protected that: this;
+    /**
+     * Inicializa uma nova instância do SmzGaugeThresholdBuilder.
+     * @param _parent - O builder pai (SmzGaugeBuilder) ao qual este threshold pertence.
+     * @param _threshold - O limite (threshold) sendo configurado.
+     */
+    constructor(_parent: SmzGaugeBuilder, _threshold: SmzGaugeThreshold, _min: number, _max: number);
+    /**
+     * Define o valor do limite.
+     * @param value - O valor numérico do limite.
+     * @returns A instância atual do SmzGaugeThresholdBuilder para encadeamento de métodos.
+     */
+    withValue(value: number): SmzGaugeThresholdBuilder;
+    /**
+     * Define a cor associada ao limite.
+     * @param color - A cor hexadecimal a ser associada ao limite (ex.: "#FF0000").
+     * @returns A instância atual do SmzGaugeThresholdBuilder para encadeamento de métodos.
+     */
+    withColor(hexaColor: string): SmzGaugeThresholdBuilder;
+    /**
+     * Retorna ao builder do SmzGauge associado a este threshold.
+     * @returns A instância do SmzGaugeBuilder.
+     */
+    get gauge(): SmzGaugeBuilder;
+    /**
+     * Constrói e retorna o limite configurado.
+     * @returns O limite (SmzGaugeThreshold) completo.
+     */
+    build(): SmzGaugeThreshold;
+}

package/lib/builders/smz-login/state-builder.d.ts

@@ -0,0 +1,24 @@
+import { SmzForm } from '../../modules/smz-forms/models/smz-forms';
+import { SmzLoginState } from '../../modules/smz-layouts/features/login/login-state';
+import { SmzGenericMenuBuilder } from '../smz-menu/generic-menu-builder';
+export declare class SmzLoginBuilder<TResponse, TPayload> {
+    _state: SmzLoginState<TResponse, TPayload>;
+    constructor();
+    setMessage(message: string): SmzLoginBuilder<TResponse, TPayload>;
+    setLoginButtonLabel(label: string): SmzLoginBuilder<TResponse, TPayload>;
+    setExtraInfo(extraInfo: string): SmzLoginBuilder<TResponse, TPayload>;
+    setPayloadCallback(callback: (response: TResponse) => TPayload): SmzLoginBuilder<TResponse, TPayload>;
+    setSubmitCallback(callback: (response: TResponse) => void): SmzLoginBuilder<TResponse, TPayload>;
+    setLogoType(type: 'horizontal' | 'vertical' | 'icon' | 'typo'): SmzLoginBuilder<TResponse, TPayload>;
+    useCustomLogo(imagePath: string): SmzLoginBuilder<TResponse, TPayload>;
+    addButtons(): SmzGenericMenuBuilder<SmzLoginBuilder<TResponse, TPayload>>;
+    setLogoSize(sizes: 'small' | 'medium' | 'large' | 'hero'): SmzLoginBuilder<TResponse, TPayload>;
+    debugMode(): SmzLoginBuilder<TResponse, TPayload>;
+    setForm(form: SmzForm<TResponse>): SmzLoginBuilder<TResponse, TPayload>;
+    setLogoutAction(action: any, redirection?: string): SmzLoginBuilder<TResponse, TPayload>;
+    setLoginAction(action: any): SmzLoginBuilder<TResponse, TPayload>;
+    disableLoginActionCall(): SmzLoginBuilder<TResponse, TPayload>;
+    setBackground(styleClass: string): SmzLoginBuilder<TResponse, TPayload>;
+    setCard(styleClass: string): SmzLoginBuilder<TResponse, TPayload>;
+    build(): SmzLoginState<TResponse, TPayload>;
+}

package/lib/builders/smz-menu/generic-menu-builder.d.ts

@@ -0,0 +1,31 @@
+import { MenuItem } from 'primeng/api';
+import { SmzMenuItem } from '../../modules/smz-menu/models/smz-menu-item';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+export declare class SmzGenericMenuBuilder<TGet> extends SmzBuilderUtilities<SmzGenericMenuBuilder<TGet>> {
+    private _builder;
+    private _items;
+    protected that: this;
+    constructor(_builder: TGet, _items?: SmzMenuItem[]);
+    item(label: string, icon?: string, tooltip?: string): SmzSmzMenuItemItemBuilder<TGet>;
+    get back(): TGet;
+    build(): SmzMenuItem[];
+}
+export declare class SmzSmzMenuItemItemBuilder<TGet> {
+    private _menuBuilder;
+    private _parent;
+    private _item;
+    constructor(_menuBuilder: SmzGenericMenuBuilder<TGet>, _parent: SmzSmzMenuItemItemBuilder<TGet>, _item: SmzMenuItem);
+    addChild(label: string, icon?: string): SmzSmzMenuItemItemBuilder<TGet>;
+    setCallback<T>(callback: (item: T) => void): SmzSmzMenuItemItemBuilder<TGet>;
+    setRedirect(paths: string[]): SmzSmzMenuItemItemBuilder<TGet>;
+    hasClaimAccess(claim: string): SmzSmzMenuItemItemBuilder<TGet>;
+    setVisibilityRule<T>(callback: (item: T) => boolean): SmzSmzMenuItemItemBuilder<TGet>;
+    setActivationRule<T>(callback: (item: T) => boolean): SmzSmzMenuItemItemBuilder<TGet>;
+    hide(): SmzSmzMenuItemItemBuilder<TGet>;
+    disable(): SmzSmzMenuItemItemBuilder<TGet>;
+    addTransformRule<T>(callback: (item: T) => Partial<MenuItem>): SmzSmzMenuItemItemBuilder<TGet>;
+    askForConfirmation(title: string, message: string): SmzSmzMenuItemItemBuilder<TGet>;
+    askForCriticalConfirmation(title: string, message: string): SmzSmzMenuItemItemBuilder<TGet>;
+    get menu(): SmzGenericMenuBuilder<TGet>;
+    applyChild(): SmzSmzMenuItemItemBuilder<TGet>;
+}

package/lib/builders/smz-menu/menu-builder.d.ts

@@ -0,0 +1,29 @@
+import { MenuItem } from 'primeng/api';
+import { SmzMenuItem } from '../../modules/smz-menu/models/smz-menu-item';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+export declare class SmzMenuBuilder extends SmzBuilderUtilities<SmzMenuBuilder> {
+    protected that: this;
+    private _items;
+    constructor();
+    item(label: string, icon?: string, tooltip?: string): SmzMenuItemBuilder;
+    separator(): SmzMenuBuilder;
+    build(): SmzMenuItem[];
+}
+export declare class SmzMenuItemBuilder {
+    private _menuBuilder;
+    private _parent;
+    private _item;
+    constructor(_menuBuilder: SmzMenuBuilder, _parent: SmzMenuItemBuilder, _item: SmzMenuItem);
+    addChild(label: string, icon?: string): SmzMenuItemBuilder;
+    setCallback<T>(callback: (item: T) => void): SmzMenuItemBuilder;
+    setRedirect(paths: string[]): SmzMenuItemBuilder;
+    setVisibilityRule<T>(callback: (item: T) => boolean): SmzMenuItemBuilder;
+    setActivationRule<T>(callback: (item: T) => boolean): SmzMenuItemBuilder;
+    hide(): SmzMenuItemBuilder;
+    disable(): SmzMenuItemBuilder;
+    addTransformRule<T>(callback: (item: T) => Partial<MenuItem>): SmzMenuItemBuilder;
+    askForConfirmation(title: string, message: string): SmzMenuItemBuilder;
+    askForCriticalConfirmation(title: string, message: string): SmzMenuItemBuilder;
+    get menu(): SmzMenuBuilder;
+    applyChild(): SmzMenuItemBuilder;
+}

package/lib/builders/smz-menu/menu-creation-builder.d.ts

@@ -0,0 +1,26 @@
+import { MenuCreation } from '../../modules/smz-layouts/core/models/menu-creation';
+import { SmzMenuItem } from '../../modules/smz-menu/models/smz-menu-item';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+export declare class SmzMenuCreationBuilder<TGet> extends SmzBuilderUtilities<SmzMenuCreationBuilder<TGet>> {
+    private _builder;
+    private _items;
+    protected that: this;
+    constructor(_builder: TGet, _items?: MenuCreation[]);
+    item(label: string, icon?: string, tooltip?: string): SmzMenuCreationItemBuilder<TGet>;
+    get back(): TGet;
+    build(): SmzMenuItem[];
+}
+export declare class SmzMenuCreationItemBuilder<TGet> {
+    private _menuBuilder;
+    private _parent;
+    private _item;
+    constructor(_menuBuilder: SmzMenuCreationBuilder<TGet>, _parent: SmzMenuCreationItemBuilder<TGet>, _item: MenuCreation);
+    addChild(label: string, icon?: string): SmzMenuCreationItemBuilder<TGet>;
+    setCallback<T>(callback: (item: T) => void): SmzMenuCreationItemBuilder<TGet>;
+    setRedirect(paths: string[]): SmzMenuCreationItemBuilder<TGet>;
+    hasClaimAccess(claim: string): SmzMenuCreationItemBuilder<TGet>;
+    hide(): SmzMenuCreationItemBuilder<TGet>;
+    disable(): SmzMenuCreationItemBuilder<TGet>;
+    get menu(): SmzMenuCreationBuilder<TGet>;
+    applyChild(): SmzMenuCreationItemBuilder<TGet>;
+}

package/lib/builders/smz-multi-tables/state-builder.d.ts

@@ -0,0 +1,12 @@
+import { SmzMultiTablesState } from '../../modules/smz-multi-tables/multi-tables.state';
+import { SmzMultiTablesTabBuilder } from './tab-builder';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+export declare class SmzMultiTablesBuilder extends SmzBuilderUtilities<SmzMultiTablesBuilder> {
+    protected that: this;
+    _state: SmzMultiTablesState;
+    constructor();
+    setTitle(styleClass: string): SmzMultiTablesBuilder;
+    tab(label: string): SmzMultiTablesTabBuilder;
+    debugMode(): SmzMultiTablesBuilder;
+    build(): SmzMultiTablesState;
+}

package/lib/builders/smz-multi-tables/tab-builder.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { SmzMultiTablesTab } from '../../modules/smz-multi-tables/multi-tables.state';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzMultiTablesBuilder } from './state-builder';
+import { SmzMultiTablesTabHeaderBuilder } from './tab-header-builder';
+import { SmzTableState } from '../../modules/smz-tables/models/table-state';
+export declare class SmzMultiTablesTabBuilder extends SmzBuilderUtilities<SmzMultiTablesTabBuilder> {
+    private _builder;
+    private _tab;
+    private label;
+    protected that: this;
+    constructor(_builder: SmzMultiTablesBuilder, _tab: SmzMultiTablesTab, label: string);
+    setStyleClass(styleClass: string): SmzMultiTablesTabBuilder;
+    allowClose(): SmzMultiTablesTabBuilder;
+    setAsSelected(): SmzMultiTablesTabBuilder;
+    allowDuplication(): SmzMultiTablesTabBuilder;
+    header(): SmzMultiTablesTabHeaderBuilder;
+    table(items$: Observable<any>, state: SmzTableState): SmzMultiTablesTabBuilder;
+    get tab(): SmzMultiTablesBuilder;
+}

package/lib/builders/smz-multi-tables/tab-header-builder.d.ts

@@ -0,0 +1,15 @@
+import { SmzMultiTablesTab } from '../../modules/smz-multi-tables/multi-tables.state';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzMultiTablesTabBuilder } from './tab-builder';
+export declare class SmzMultiTablesTabHeaderBuilder extends SmzBuilderUtilities<SmzMultiTablesTabHeaderBuilder> {
+    private _builder;
+    private _tab;
+    protected that: this;
+    constructor(_builder: SmzMultiTablesTabBuilder, _tab: SmzMultiTablesTab);
+    setStyleClass(styleClass: string): SmzMultiTablesTabHeaderBuilder;
+    setName(name: string): SmzMultiTablesTabHeaderBuilder;
+    setNameStyleClass(styleClass: string): SmzMultiTablesTabHeaderBuilder;
+    setIcon(icon: string): SmzMultiTablesTabHeaderBuilder;
+    setIconStyleClass(styleClass: string): SmzMultiTablesTabHeaderBuilder;
+    get header(): SmzMultiTablesTabBuilder;
+}

package/lib/builders/smz-svgs/svg-base-feature.d.ts

@@ -0,0 +1,28 @@
+import { SmzSvgFeature } from '../../modules/smz-svg/models/smz-svg';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzSvgFeatureBuilder } from './svg-feature';
+import { SmzSvgBuilder } from './svg-builder';
+import { SmzSVGWrapper } from '../../modules/smz-svg/models/smz-svg-wrapper';
+import { Container } from '@svgdotjs/svg.js';
+export declare class SmzSvgBaseFeatureBuilder<T> extends SmzBuilderUtilities<T> {
+    _featureBuilder: SmzSvgFeatureBuilder;
+    _feature: SmzSvgFeature;
+    _svgBuilder: SmzSvgBuilder;
+    protected that: T;
+    constructor(_featureBuilder: SmzSvgFeatureBuilder, _feature: SmzSvgFeature, _svgBuilder: SmzSvgBuilder);
+    useTooltip(content: string): T;
+    useAdaptative(minWidth: number, maxWidth: number): T;
+    transform(callback: (container: Container, elementId: string, feature: SmzSvgFeature, draw: SmzSVGWrapper) => void): T;
+    setStyleClass(styleClass: string): T;
+    useHighlight(color: string): T;
+    setClickCallback(callback: (id: string, svg: SmzSVGWrapper, data: any) => void): T;
+    setDbClickCallback(callback: (id: string, svg: SmzSVGWrapper, data: any) => void): T;
+    setFocus(behavior: 'onClick' | 'onDbClick'): T;
+    setData(data: any): T;
+    setId(id: string): T;
+    setColor(color: string): T;
+    setStroke(color: string): T;
+    setFocusApproximation(approximation: number): T;
+    addScope(scope: string): T;
+    get feature(): SmzSvgFeatureBuilder;
+}

package/lib/builders/smz-svgs/svg-builder.d.ts

@@ -0,0 +1,27 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzSvgState } from '../../modules/smz-svg/models/smz-svg';
+import { SmzSvgFeatureBuilder } from './svg-feature';
+import { SmzSvgDispatchBuilder } from './svg-dispatch';
+import { SmzSvgWorldCoordinatesBuilder } from './svg-world-coordinates';
+export declare class SmzSvgBuilder extends SmzBuilderUtilities<SmzSvgBuilder> {
+    protected that: this;
+    private defaultConfig;
+    _state: SmzSvgState;
+    constructor(state?: SmzSvgState);
+    debugMode(): SmzSvgBuilder;
+    setContainerStyles(styleClass: string): SmzSvgBuilder;
+    setContainerSize(width: number, height: number): SmzSvgBuilder;
+    usePan(): SmzSvgBuilder;
+    avoidResetOnInit(): SmzSvgBuilder;
+    executeAfterInit(callback: () => void): SmzSvgBuilder;
+    setInitialScopes(scopes: string[]): SmzSvgBuilder;
+    enhancePerformance(): SmzSvgBuilder;
+    setZoomDebounce(milliseconds: number): SmzSvgBuilder;
+    setAnimationTime(milliseconds: number): SmzSvgBuilder;
+    useMouseZoom(min: number, max: number, factor?: number): SmzSvgBuilder;
+    useTouchZoom(min: number, max: number): SmzSvgBuilder;
+    feature(): SmzSvgFeatureBuilder;
+    dispatch(): SmzSvgDispatchBuilder;
+    useWorldCoordinates(): SmzSvgWorldCoordinatesBuilder;
+    build(): SmzSvgState;
+}

package/lib/builders/smz-svgs/svg-dispatch.d.ts

@@ -0,0 +1,11 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzSvgBuilder } from './svg-builder';
+import { SmzSvgState } from '../../modules/smz-svg/models/smz-svg';
+export declare class SmzSvgDispatchBuilder extends SmzBuilderUtilities<SmzSvgDispatchBuilder> {
+    private _svgBuilder;
+    private _state;
+    protected that: this;
+    constructor(_svgBuilder: SmzSvgBuilder, _state: SmzSvgState);
+    panToId(): SmzSvgDispatchBuilder;
+    get svg(): SmzSvgBuilder;
+}

package/lib/builders/smz-svgs/svg-feature.d.ts

@@ -0,0 +1,13 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzSvgBuilder } from './svg-builder';
+import { SmzSvgState } from '../../modules/smz-svg/models/smz-svg';
+import { SmzSvgPinBuilder, SmzSvgRootBuilder } from './svg-features';
+export declare class SmzSvgFeatureBuilder extends SmzBuilderUtilities<SmzSvgFeatureBuilder> {
+    private _svgBuilder;
+    private _state;
+    protected that: this;
+    constructor(_svgBuilder: SmzSvgBuilder, _state: SmzSvgState);
+    root(svgData: string, width: number, height: number): SmzSvgRootBuilder;
+    pin(svgData: string, width: number): SmzSvgPinBuilder;
+    get svg(): SmzSvgBuilder;
+}

package/lib/builders/smz-svgs/svg-features.d.ts

@@ -0,0 +1,26 @@
+import { Container, Element } from '@svgdotjs/svg.js';
+import { SmzSvgPin, SmzSvgRoot, SmzSvgAnchorTypes, SmzSvgBaseFeature } from '../../modules/smz-svg/models/smz-svg';
+import { SmzSvgBaseFeatureBuilder } from './svg-base-feature';
+import { SmzSvgBuilder } from './svg-builder';
+import { SmzSvgFeatureBuilder } from './svg-feature';
+export declare class SmzSvgRootBuilder extends SmzSvgBaseFeatureBuilder<SmzSvgRootBuilder> {
+    _featureBuilder: SmzSvgFeatureBuilder;
+    _feature: SmzSvgRoot;
+    _svgBuilder: SmzSvgBuilder;
+    protected that: this;
+    constructor(_featureBuilder: SmzSvgFeatureBuilder, _feature: SmzSvgRoot, _svgBuilder: SmzSvgBuilder);
+    overrideContainerStyles(styleClass: string): SmzSvgRootBuilder;
+    get feature(): SmzSvgFeatureBuilder;
+}
+export declare class SmzSvgPinBuilder extends SmzSvgBaseFeatureBuilder<SmzSvgPinBuilder> {
+    _featureBuilder: SmzSvgFeatureBuilder;
+    _feature: SmzSvgPin;
+    _svgBuilder: SmzSvgBuilder;
+    protected that: this;
+    constructor(_featureBuilder: SmzSvgFeatureBuilder, _feature: SmzSvgPin, _svgBuilder: SmzSvgBuilder);
+    setPosition(x: number, y: number): SmzSvgPinBuilder;
+    setCoordinates(latitude: number, longitude: number): SmzSvgPinBuilder;
+    setDynamicBuild(callback: (rootContainer: Container, feature: SmzSvgBaseFeature) => Element): SmzSvgPinBuilder;
+    setAnchor(anchor: SmzSvgAnchorTypes): SmzSvgPinBuilder;
+    setColor(color: string): SmzSvgPinBuilder;
+}

package/lib/builders/smz-svgs/svg-world-coordinates.d.ts

@@ -0,0 +1,12 @@
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzSvgBuilder } from './svg-builder';
+import { SmzSvgState } from '../../modules/smz-svg/models/smz-svg';
+import { SmzSvgRefPoint } from '../../modules/smz-svg/models/world-coordinates';
+export declare class SmzSvgWorldCoordinatesBuilder extends SmzBuilderUtilities<SmzSvgWorldCoordinatesBuilder> {
+    private _svgBuilder;
+    private _state;
+    protected that: this;
+    constructor(_svgBuilder: SmzSvgBuilder, _state: SmzSvgState);
+    addRefPoint(point: SmzSvgRefPoint): SmzSvgWorldCoordinatesBuilder;
+    get worldCoordinates(): SmzSvgBuilder;
+}

package/lib/builders/smz-tables/batch-menu-builder.d.ts

@@ -0,0 +1,26 @@
+import { MenuItem } from 'primeng/api';
+import { SmzMenuItem } from '../../modules/smz-menu/models/smz-menu-item';
+import { SmzTableBuilder } from './state-builder';
+export declare class SmzBatchMenuBuilder<TData> {
+    private _tableBuilder;
+    constructor(_tableBuilder: SmzTableBuilder<TData>);
+    item(label: string, icon?: string, tooltip?: string): SmzBatchMenuItemBuilder<TData>;
+    separator(): SmzBatchMenuBuilder<TData>;
+    get table(): SmzTableBuilder<TData>;
+}
+export declare class SmzBatchMenuItemBuilder<TData> {
+    private _menuBuilder;
+    private _parent;
+    private _item;
+    constructor(_menuBuilder: SmzBatchMenuBuilder<TData>, _parent: SmzBatchMenuItemBuilder<TData>, _item: SmzMenuItem);
+    addChild(label: string, icon?: string): SmzBatchMenuItemBuilder<TData>;
+    setCallback<T>(callback: (item: T) => void): SmzBatchMenuItemBuilder<TData>;
+    setRedirect(paths: string[]): SmzBatchMenuItemBuilder<TData>;
+    setVisibilityRule<T>(callback: (item: T) => boolean): SmzBatchMenuItemBuilder<TData>;
+    setActivationRule<T>(callback: (item: T) => boolean): SmzBatchMenuItemBuilder<TData>;
+    hide(): SmzBatchMenuItemBuilder<TData>;
+    disable(): SmzBatchMenuItemBuilder<TData>;
+    addTransformRule<T>(callback: (item: T) => Partial<MenuItem>): SmzBatchMenuItemBuilder<TData>;
+    get menu(): SmzBatchMenuBuilder<TData>;
+    applyChild(): SmzBatchMenuItemBuilder<TData>;
+}

package/lib/builders/smz-tables/caption-buttons-builder.d.ts

@@ -0,0 +1,23 @@
+import { SmzTableBuilder } from './state-builder';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+export declare class SmzCaptionButtonsBuilder<TData> extends SmzBuilderUtilities<SmzCaptionButtonsBuilder<TData>> {
+    protected _parent: SmzTableBuilder<TData>;
+    protected that: this;
+    constructor(_parent: SmzTableBuilder<TData>);
+    add(label: string, callback: () => void): SmzCaptionButtonBuilder<TData>;
+    get table(): SmzTableBuilder<TData>;
+}
+export declare class SmzCaptionButtonBuilder<TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzCaptionButtonsBuilder<TData>;
+    private _action;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzCaptionButtonsBuilder<TData>, label: string, callback?: () => void);
+    customAuthorize(claimsWithAccess: string): SmzCaptionButtonBuilder<TData>;
+    setIcon(icon: string): SmzCaptionButtonBuilder<TData>;
+    setStyleClass(styleClass: string): SmzCaptionButtonBuilder<TData>;
+    setTooltip(tooltip: () => string): SmzCaptionButtonBuilder<TData>;
+    setVisibility(condition: () => boolean): SmzCaptionButtonBuilder<TData>;
+    setActivation(condition: () => boolean): SmzCaptionButtonBuilder<TData>;
+    callback(callback: () => boolean): SmzCaptionButtonBuilder<TData>;
+    get buttons(): SmzCaptionButtonsBuilder<TData>;
+}

package/lib/builders/smz-tables/column-builder.d.ts

@@ -0,0 +1,101 @@
+import { SmzContentType, SmzExportableContentType } from '../../modules/smz-tables/models/content-types';
+import { SmzFilterType } from '../../modules/smz-tables/models/filter-types';
+import { SmzTableColumn } from '../../modules/smz-tables/models/table-column';
+import { SmzBuilderUtilities } from '../common/smz-builder-utilities';
+import { SmzContentActionsBuilder } from './column-content-action-builder';
+import { SmzEditableCollectionBuilder } from './editable-builder';
+import { SmzTableBuilder } from './state-builder';
+import { SmzHeaderActionsBuilder } from './column-header-action-builder';
+export declare abstract class SmzBaseColumnBuilder<T extends SmzBaseColumnBuilder<T, TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzColumnCollectionBuilder<TData>;
+    protected that: T;
+    _column: SmzTableColumn;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzColumnCollectionBuilder<TData>, type: SmzContentType, filterType: SmzFilterType, field: string, header: string, isOrderable: boolean, width?: string);
+    overrideFilter(propertyPath?: string, filterType?: SmzFilterType): T;
+    overrideSort(propertyPath?: string): T;
+    overrideGlobalFilter(propertyPath?: string): T;
+    disableSort(): T;
+    hide(condition?: boolean): T;
+    setVisibility(callback: (field: string) => boolean): T;
+    frozen(): T;
+    addStyles(styleClass: string): T;
+    overideContentStyleClass(styleClass: string): T;
+    addTooltip(tooltip: (item: any) => string): T;
+    useSubTotal(): T;
+    ignoreOnGlobalFilter(): T;
+    disableFilter(): T;
+    ignoreOnExport(): T;
+    overrideExportHeader(header: string): T;
+    exportAs(type: SmzExportableContentType): T;
+    setExportTransform(callback: (data: any, row: any, index: number) => any): T;
+    setExportAsMultilined(overrideNewlineSeparator?: string): T;
+    setExportDataFormat(format: string): T;
+    editable(): SmzEditableCollectionBuilder<TData>;
+    actions(): SmzContentActionsBuilder<T, TData>;
+    headerActions(): SmzHeaderActionsBuilder<T, TData>;
+    get columns(): SmzColumnCollectionBuilder<TData>;
+}
+export declare class SmzDateColumnBuilder<TData> extends SmzBaseColumnBuilder<SmzDateColumnBuilder<TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzColumnCollectionBuilder<TData>;
+    protected that: this;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzColumnCollectionBuilder<TData>, field: string, header: string, width?: string);
+    setDateFormat(format: 'shortDate' | 'short' | 'medium' | 'long' | 'mediumDate' | 'longDate' | 'shortTime'): SmzDateColumnBuilder<TData>;
+    setFilter(type: SmzFilterType): SmzDateColumnBuilder<TData>;
+}
+export declare class SmzCurrencyColumnBuilder<TData> extends SmzBaseColumnBuilder<SmzCurrencyColumnBuilder<TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzColumnCollectionBuilder<TData>;
+    protected that: this;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzColumnCollectionBuilder<TData>, field: string, header: string, width?: string);
+}
+export declare class SmzTextColumnBuilder<TData> extends SmzBaseColumnBuilder<SmzTextColumnBuilder<TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzColumnCollectionBuilder<TData>;
+    protected that: this;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzColumnCollectionBuilder<TData>, field: string, header: string, width?: string);
+    setFilter(type: SmzFilterType): SmzTextColumnBuilder<TData>;
+}
+export declare class SmzCustomColumnBuilder<TData> extends SmzBaseColumnBuilder<SmzCustomColumnBuilder<TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzColumnCollectionBuilder<TData>;
+    protected that: this;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzColumnCollectionBuilder<TData>, field: string, header: string, width?: string);
+    setFilter(type: SmzFilterType): SmzCustomColumnBuilder<TData>;
+    enableSort(): SmzCustomColumnBuilder<TData>;
+    forceGlobalFilter(): SmzCustomColumnBuilder<TData>;
+    setFilterableData(getFilterableDataCallback: (data: any, row: any, index: number) => string): SmzCustomColumnBuilder<TData>;
+}
+export declare class SmzIconColumnBuilder<TData> extends SmzBaseColumnBuilder<SmzIconColumnBuilder<TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzColumnCollectionBuilder<TData>;
+    protected that: this;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzColumnCollectionBuilder<TData>, field: string, header: string, width?: string);
+    addIconConfiguration(icon: string, value: any, styleClass?: string, tooltip?: string): SmzIconColumnBuilder<TData>;
+    setFilter(type: SmzFilterType): SmzIconColumnBuilder<TData>;
+    forceGlobalFilter(): SmzIconColumnBuilder<TData>;
+    setFilterableData(getFilterableDataCallback: (data: any, row: any, index: number) => string): SmzIconColumnBuilder<TData>;
+}
+export declare class SmzDataTransformColumnBuilder<TData> extends SmzBaseColumnBuilder<SmzDataTransformColumnBuilder<TData>, TData> {
+    protected _table: SmzTableBuilder<TData>;
+    protected _parent: SmzColumnCollectionBuilder<TData>;
+    protected that: this;
+    constructor(_table: SmzTableBuilder<TData>, _parent: SmzColumnCollectionBuilder<TData>, field: string, header: string, callback: (data: any, row: any, index: number) => string, width?: string);
+    setFilter(type: SmzFilterType): SmzDataTransformColumnBuilder<TData>;
+    filterWithTransformedData(): SmzDataTransformColumnBuilder<TData>;
+    ignoreTransformOnExport(): SmzDataTransformColumnBuilder<TData>;
+    setFilterableData(getFilterableDataCallback: (data: any, row: any, index: number) => string): SmzDataTransformColumnBuilder<TData>;
+}
+export declare class SmzColumnCollectionBuilder<TData> extends SmzBuilderUtilities<SmzColumnCollectionBuilder<TData>> {
+    private _tableBuilder;
+    protected that: this;
+    constructor(_tableBuilder: SmzTableBuilder<TData>);
+    text(field: string, header: string, width?: string): SmzTextColumnBuilder<TData>;
+    custom(field: string, header: string, width?: string): SmzCustomColumnBuilder<TData>;
+    icon(field: string, header: string, width?: string): SmzIconColumnBuilder<TData>;
+    date(field: string, header: string, width?: string): SmzDateColumnBuilder<TData>;
+    currency(field: string, header: string, width?: string): SmzCurrencyColumnBuilder<TData>;
+    dataTransform(field: string, header: string, callback: (data: any, row: any, index: number) => string, width?: string): SmzDataTransformColumnBuilder<TData>;
+    get table(): SmzTableBuilder<TData>;
+}