@gdacm/grafana-items 0.1.1

package/dist/items/FieldConfigCustomTimeSerie.d.ts

@@ -0,0 +1,54 @@
+import { FieldConfigCustom } from "./FieldConfigCustom.js";
+import { ScaleDistribution } from "./ScaleDistribution.js";
+import { HideFrom } from "./HideFrom.js";
+import { LineStyle } from "./LineStyle.js";
+import { Stacking } from "./Stacking.js";
+import { ThresholdStyle } from "./ThresholdStyle.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class FieldConfigCustomTimeSerie extends FieldConfigCustom {
+    setAxisBorderShow(axisBorderShow: Boolean): this;
+    setAxisCenteredZero(axisCenteredZero: Boolean): this;
+    setAxisColorMode(axisColorMode: String): this;
+    setAxisGridShow(axisGridShow: Boolean): this;
+    setAxisLabel(axisLabel: String): this;
+    setAxisPlacement(axisPlacement: String): this;
+    setAxisSoftMax(axisSoftMax: Number): this;
+    setAxisSoftMin(axisSoftMin: Number): this;
+    setAxisWidth(axisWidth: Number): this;
+    setScaleDistribution(scaleDistribution: ScaleDistribution): this;
+    withScaleDistribution(onWith: (item: ScaleDistribution) => void): this;
+    get scaleDistribution(): ScaleDistribution;
+    setBarAlignment(barAlignment: Number): this;
+    setBarMaxWidth(barMaxWidth: Number): this;
+    setBarWidthFactor(barWidthFactor: Number): this;
+    setDrawStyle(drawStyle: String): this;
+    setFillBelowTo(fillBelowTo: String): this;
+    setFillColor(fillColor: String): this;
+    setFillOpacity(fillOpacity: Number): this;
+    setGradientMode(gradientMode: String): this;
+    setHideFrom(hideFrom: HideFrom): this;
+    withHideFrom(onWith: (item: HideFrom) => void): this;
+    get hideFrom(): HideFrom;
+    setInsertNulls(insertNulls: Boolean): this;
+    setLineInterpolation(lineInterpolation: String): this;
+    setLineStyle(lineStyle: LineStyle): this;
+    withLineStyle(onWith: (item: LineStyle) => void): this;
+    get lineStyle(): LineStyle;
+    setLineStyleFill(fill: string): this;
+    setLineWidth(lineWidth: Number): this;
+    setPointColor(pointColor: String): this;
+    setPointSize(pointSize: Number): this;
+    setPointSymbol(pointSymbol: String): this;
+    setShowPoints(showPoints: String): this;
+    setShowValues(showValues: Boolean): this;
+    setSpanNulls(spanNulls: Boolean): this;
+    setStacking(stacking: Stacking): this;
+    withStacking(onWith: (item: Stacking) => void): this;
+    get stacking(): Stacking;
+    setThresholdsStyle(thresholdsStyle: ThresholdStyle): this;
+    withThresholdsStyle(onWith: (item: ThresholdStyle) => void): this;
+    get thresholdsStyle(): ThresholdStyle;
+    setThresholdsStyleMode(mode: string): this;
+}

package/dist/items/FieldConfigDefault.d.ts

@@ -0,0 +1,31 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+import { Color } from "./Color.js";
+import { FieldConfigCustom } from "./FieldConfigCustom.js";
+import { Mapping } from "./Mapping.js";
+import { Thresholds } from "./Thresholds.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class FieldConfigDefault extends GrafanaItem {
+    setColor(color: Color): this;
+    setNewColor(onNewCreated: ((item: Color) => Color) | undefined): this;
+    withColor(onWith: (item: Color) => void): this;
+    get color(): Color;
+    setCustom(custom: FieldConfigCustom): this;
+    withCustom(onWith: (item: FieldConfigCustom) => void): this;
+    get custom(): FieldConfigCustom;
+    setDecimals(decimals: Number): this;
+    setFieldMinMax(fieldMinMax: Boolean): this;
+    initMappings(): this;
+    get mappings(): Mapping[];
+    addMapping(mapping: Mapping): this;
+    addNewMapping(onNewCreated: (item: Mapping) => Mapping): this;
+    withMappings(onWith: (mappings: Mapping[]) => void): this;
+    setMax(max: Number): this;
+    setMin(min: Number): this;
+    setThresholds(thresholds: Thresholds): this;
+    withThresholds(onWith: (item: Thresholds) => void): this;
+    get thresholds(): Thresholds;
+    setUnit(unit: String): this;
+    setColorMode(mode: string): this;
+}

package/dist/items/FieldConfigOverride.d.ts

@@ -0,0 +1,18 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+import { OverrideMatcher } from "./OverrideMatcher.js";
+import { OverrideProperty } from "./OverrideProperty.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class FieldConfigOverride extends GrafanaItem {
+    setSystemRef(systemRef: String): this;
+    setMatcher(matcher: OverrideMatcher): this;
+    setNewMatcher(onNewCreated: ((item: OverrideMatcher) => OverrideMatcher) | undefined): this;
+    withMatcher(onWith: (item: OverrideMatcher) => void): this;
+    get matcher(): OverrideMatcher;
+    initProperties(): this;
+    get properties(): OverrideProperty[];
+    addProperty(property: OverrideProperty): this;
+    addNewProperty(onNewCreated: (item: OverrideProperty) => OverrideProperty): this;
+    withProperties(onWith: (properties: OverrideProperty[]) => void): this;
+}

package/dist/items/Gauge.d.ts

@@ -0,0 +1,14 @@
+import { Panel } from "./Panel.js";
+import { FieldConfigCustomGauge } from "./FieldConfigCustomGauge.js";
+import { PanelOptionsGauge } from "./PanelOptionsGauge.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class Gauge extends Panel {
+    constructor(metaOptions: GenericMetaOptions)
+    get custom(): FieldConfigCustomGauge;
+    withCustom(code: (custom: FieldConfigCustomGauge) => void): this
+    setNewOptions(onNewCreated: ((item: PanelOptionsGauge) => PanelOptionsGauge) | undefined): this;
+    withOptions(onWith: (item: PanelOptionsGauge) => void): this;
+    get options(): PanelOptionsGauge;
+}

package/dist/items/Geomap.d.ts

@@ -0,0 +1,14 @@
+import { Panel } from "./Panel.js";
+import { FieldConfigCustomGeomap } from "./FieldConfigCustomGeomap.js";
+import { PanelOptionsGeomap } from "./PanelOptionsGeomap.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class Geomap extends Panel {
+    constructor(metaOptions: GenericMetaOptions)
+    get custom(): FieldConfigCustomGeomap;
+    withCustom(code: (custom: FieldConfigCustomGeomap) => void): this
+    setNewOptions(onNewCreated: ((item: PanelOptionsGeomap) => PanelOptionsGeomap) | undefined): this;
+    withOptions(onWith: (item: PanelOptionsGeomap) => void): this;
+    get options(): PanelOptionsGeomap;
+}

package/dist/items/GrafanaItem.d.ts

@@ -0,0 +1,18 @@
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class GrafanaItem {
+    constructor(metaOptions: GenericMetaOptions)
+    get metaOptions(): GenericMetaOptions
+    withMetaOptions(code: (metaOptions: GenericMetaOptions) => void): this
+    with(code: (item: this) => void): this
+    asJson(): Object;
+    _onInit(): void;
+    _setValue<T>(key: string, value: T): this;
+    _getValue<T>(key: string): T;
+    _initArray(key: string): this;
+    _getArray<T>(key: string): T[];
+    _addArrayItem<T>(key: string, item: T): this;
+    _setObject<T>(key: string, value: T): this;
+    _getObject<T>(key: string): T;
+    _withObject<T>(key: string, code: (item: T) => void): this;
+}

package/dist/items/GridPos.d.ts

@@ -0,0 +1,12 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class GridPos extends GrafanaItem {
+    setX(x: Number): this;
+    setY(y: Number): this;
+    setW(w: Number): this;
+    setH(h: Number): this;
+    setPos(x: number, y: number, w: number, h: number): this;
+}

package/dist/items/HideFrom.d.ts

@@ -0,0 +1,10 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class HideFrom extends GrafanaItem {
+    setLegend(legend: Boolean): this;
+    setTooltip(tooltip: Boolean): this;
+    setViz(viz: Boolean): this;
+}

package/dist/items/Influxdb.d.ts

@@ -0,0 +1,8 @@
+import { Datasource } from "./Datasource.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class Influxdb extends Datasource {
+    constructor(metaOptions: GenericMetaOptions)
+}

package/dist/items/LineStyle.d.ts

@@ -0,0 +1,8 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class LineStyle extends GrafanaItem {
+    setFill(fill: String): this;
+}

package/dist/items/Link.d.ts

@@ -0,0 +1,22 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class Link extends GrafanaItem {
+    constructor(metaOptions: GenericMetaOptions)
+    setAsDropdown(asDropdown: Boolean): this;
+    setIcon(icon: String): this;
+    setIncludeVars(includeVars: Boolean): this;
+    setKeepTime(keepTime: Boolean): this;
+    initTags(): this;
+    get tags(): String[];
+    addTag(tag: String): this;
+    addNewTag(onNewCreated: (item: String) => String): this;
+    withTags(onWith: (tags: String[]) => void): this;
+    setTargetBlank(targetBlank: Boolean): this;
+    setTitle(title: String): this;
+    setTooltip(tooltip: String): this;
+    setType(type: String): this;
+    setUrl(url: String): this;
+}

package/dist/items/Mapping.d.ts

@@ -0,0 +1,8 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class Mapping extends GrafanaItem {
+
+}

package/dist/items/OverrideMatcher.d.ts

@@ -0,0 +1,11 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class OverrideMatcher extends GrafanaItem {
+    setId(id: String): this;
+    setOptions(options: Object): this;
+    withOptions(onWith: (item: Object) => void): this;
+    get options(): Object;
+}

package/dist/items/OverrideMatcherOptionsByNames.d.ts

@@ -0,0 +1,15 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class OverrideMatcherOptionsByNames extends GrafanaItem {
+    setMode(mode: String): this;
+    initNames(): this;
+    get names(): String[];
+    addName(name: String): this;
+    addNewName(onNewCreated: (item: String) => String): this;
+    withNames(onWith: (names: String[]) => void): this;
+    setPrefix(prefix: String): this;
+    setReadOnly(readOnly: Boolean): this;
+}

package/dist/items/OverrideProperty.d.ts

@@ -0,0 +1,9 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class OverrideProperty extends GrafanaItem {
+    setId(id: String): this;
+    setValue(value: Object): this;
+}

package/dist/items/Panel.d.ts

@@ -0,0 +1,57 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+import { Datasource } from "./Datasource.js";
+import { FieldConfig } from "./FieldConfig.js";
+import { GridPos } from "./GridPos.js";
+import { Link } from "./Link.js";
+import { Target } from "./Target.js";
+import { DataTransformation } from "./DataTransformation.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class Panel extends GrafanaItem {
+    setCacheTimeout(cacheTimeout: String): this;
+    setDatasource(datasource: Datasource): this;
+    withDatasource(onWith: (item: Datasource) => void): this;
+    get datasource(): Datasource;
+    setDescription(description: String): this;
+    setFieldConfig(fieldConfig: FieldConfig): this;
+    withFieldConfig(onWith: (item: FieldConfig) => void): this;
+    get fieldConfig(): FieldConfig;
+    setGridPos(gridPos: GridPos): this;
+    setNewGridPos(onNewCreated: ((item: GridPos) => GridPos) | undefined): this;
+    withGridPos(onWith: (item: GridPos) => void): this;
+    get gridPos(): GridPos;
+    setPos(x: number, y: number, w: number, h: number): this;
+    setHideTimeOverride(hideTimeOverride: Boolean): this;
+    setId(id: Number): this;
+    setInterval(interval: String): this;
+    initLinks(): this;
+    get links(): Link[];
+    addLink(link: Link): this;
+    addNewLink(onNewCreated: (item: Link) => Link): this;
+    withLinks(onWith: (links: Link[]) => void): this;
+    setMaxDataPoints(maxDataPoints: Number): this;
+    setMaxPerRow(maxPerRow: Number): this;
+    setOptions(options: Object): this;
+    withOptions(onWith: (item: Object) => void): this;
+    get options(): Object;
+    setPluginVersion(pluginVersion: String): this;
+    setQueryCachingTTL(queryCachingTTL: Number): this;
+    setRepeat(repeat: String): this;
+    setRepeatDirection(repeatDirection: String): this;
+    initTargets(): this;
+    get targets(): Target[];
+    addTarget(target: Target): this;
+    addNewTarget(onNewCreated: (item: Target) => Target): this;
+    withTargets(onWith: (targets: Target[]) => void): this;
+    addTargetWithParams(refId: string, query: string, datasource: Datasource): this;
+    setTimeFrom(timeFrom: String): this;
+    setTimeShift(timeShift: String): this;
+    initTransformations(): this;
+    get transformations(): DataTransformation[];
+    addTransformation(transformation: DataTransformation): this;
+    addNewTransformation(onNewCreated: (item: DataTransformation) => DataTransformation): this;
+    withTransformations(onWith: (transformations: DataTransformation[]) => void): this;
+    setType(type: String): this;
+    setTitle(title: String): this;
+}

package/dist/items/PanelOptions.d.ts

@@ -0,0 +1,8 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptions extends GrafanaItem {
+
+}

package/dist/items/PanelOptionsBarChart.d.ts

@@ -0,0 +1,30 @@
+import { PanelOptions } from "./PanelOptions.js";
+import { VizLegendOptions } from "./VizLegendOptions.js";
+import { VizTextDisplayOptions } from "./VizTextDisplayOptions.js";
+import { VizTooltipOptions } from "./VizTooltipOptions.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsBarChart extends PanelOptions {
+    setBarRadius(barRadius: Number): this;
+    setBarWidth(barWidth: Number): this;
+    setColorByField(colorByField: String): this;
+    setFullHighlight(fullHighlight: Boolean): this;
+    setGroupWidth(groupWidth: Number): this;
+    setLegend(legend: VizLegendOptions): this;
+    withLegend(onWith: (item: VizLegendOptions) => void): this;
+    get legend(): VizLegendOptions;
+    setOrientation(orientation: String): this;
+    setShowValue(showValue: String): this;
+    setStacking(stacking: String): this;
+    setText(text: VizTextDisplayOptions): this;
+    withText(onWith: (item: VizTextDisplayOptions) => void): this;
+    get text(): VizTextDisplayOptions;
+    setTooltip(tooltip: VizTooltipOptions): this;
+    withTooltip(onWith: (item: VizTooltipOptions) => void): this;
+    get tooltip(): VizTooltipOptions;
+    setXField(xField: String): this;
+    setXTickLabelMaxLength(xTickLabelMaxLength: Number): this;
+    setXTickLabelRotation(xTickLabelRotation: Number): this;
+    setXTickLabelSpacing(xTickLabelSpacing: Number): this;
+}

package/dist/items/PanelOptionsGauge.d.ts

@@ -0,0 +1,30 @@
+import { PanelOptions } from "./PanelOptions.js";
+import { PanelOptionsGaugeEffect } from "./PanelOptionsGaugeEffect.js";
+import { PanelOptionsGaugeReduceOptions } from "./PanelOptionsGaugeReduceOptions.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGauge extends PanelOptions {
+    setBarShape(barShape: String): this;
+    setBarWidthFactor(barWidthFactor: Number): this;
+    setEffects(effects: PanelOptionsGaugeEffect): this;
+    setNewEffects(onNewCreated: ((item: PanelOptionsGaugeEffect) => PanelOptionsGaugeEffect) | undefined): this;
+    withEffects(onWith: (item: PanelOptionsGaugeEffect) => void): this;
+    get effects(): PanelOptionsGaugeEffect;
+    setEndpointMarker(endpointMarker: String): this;
+    setMinVizHeight(minVizHeight: Number): this;
+    setMinVizWidth(minVizWidth: Number): this;
+    setOrientation(orientation: String): this;
+    setReduceOptions(reduceOptions: PanelOptionsGaugeReduceOptions): this;
+    setNewReduceOptions(onNewCreated: ((item: PanelOptionsGaugeReduceOptions) => PanelOptionsGaugeReduceOptions) | undefined): this;
+    withReduceOptions(onWith: (item: PanelOptionsGaugeReduceOptions) => void): this;
+    get reduceOptions(): PanelOptionsGaugeReduceOptions;
+    setSegmentCount(segmentCount: Number): this;
+    setSegmentSpacing(segmentSpacing: Number): this;
+    setShape(shape: String): this;
+    setShowThresholdLabels(showThresholdLabels: Boolean): this;
+    setShowThresholdMarkers(showThresholdMarkers: Boolean): this;
+    setSizing(sizing: String): this;
+    setSparkline(sparkline: Boolean): this;
+    setTextMode(textMode: String): this;
+}

package/dist/items/PanelOptionsGaugeEffect.d.ts

@@ -0,0 +1,10 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGaugeEffect extends GrafanaItem {
+    setBarGlow(barGlow: Boolean): this;
+    setCenterGlow(centerGlow: Boolean): this;
+    setGradient(gradient: Boolean): this;
+}

package/dist/items/PanelOptionsGaugeReduceOptions.d.ts

@@ -0,0 +1,15 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGaugeReduceOptions extends GrafanaItem {
+    initCalcs(): this;
+    get calcs(): String[];
+    addCalc(calc: String): this;
+    addNewCalc(onNewCreated: (item: String) => String): this;
+    withCalcs(onWith: (calcs: String[]) => void): this;
+    setFields(fields: String): this;
+    setLimit(limit: Number): this;
+    setValues(values: Boolean): this;
+}

package/dist/items/PanelOptionsGeomap.d.ts

@@ -0,0 +1,32 @@
+import { PanelOptions } from "./PanelOptions.js";
+import { PanelOptionsGeomapBasemap } from "./PanelOptionsGeomapBasemap.js";
+import { PanelOptionsGeomapControls } from "./PanelOptionsGeomapControls.js";
+import { PanelOptionsGeomapLayer } from "./PanelOptionsGeomapLayer.js";
+import { PanelOptionsGeomapTooltip } from "./PanelOptionsGeomapTooltip.js";
+import { PanelOptionsGeomapView } from "./PanelOptionsGeomapView.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGeomap extends PanelOptions {
+    setBasemap(basemap: PanelOptionsGeomapBasemap): this;
+    setNewBasemap(onNewCreated: ((item: PanelOptionsGeomapBasemap) => PanelOptionsGeomapBasemap) | undefined): this;
+    withBasemap(onWith: (item: PanelOptionsGeomapBasemap) => void): this;
+    get basemap(): PanelOptionsGeomapBasemap;
+    setControls(controls: PanelOptionsGeomapControls): this;
+    setNewControls(onNewCreated: ((item: PanelOptionsGeomapControls) => PanelOptionsGeomapControls) | undefined): this;
+    withControls(onWith: (item: PanelOptionsGeomapControls) => void): this;
+    get controls(): PanelOptionsGeomapControls;
+    initLayers(): this;
+    get layers(): PanelOptionsGeomapLayer[];
+    addLayer(layer: PanelOptionsGeomapLayer): this;
+    addNewLayer(onNewCreated: (item: PanelOptionsGeomapLayer) => PanelOptionsGeomapLayer): this;
+    withLayers(onWith: (layers: PanelOptionsGeomapLayer[]) => void): this;
+    setTooltip(tooltip: PanelOptionsGeomapTooltip): this;
+    setNewTooltip(onNewCreated: ((item: PanelOptionsGeomapTooltip) => PanelOptionsGeomapTooltip) | undefined): this;
+    withTooltip(onWith: (item: PanelOptionsGeomapTooltip) => void): this;
+    get tooltip(): PanelOptionsGeomapTooltip;
+    setView(view: PanelOptionsGeomapView): this;
+    setNewView(onNewCreated: ((item: PanelOptionsGeomapView) => PanelOptionsGeomapView) | undefined): this;
+    withView(onWith: (item: PanelOptionsGeomapView) => void): this;
+    get view(): PanelOptionsGeomapView;
+}

package/dist/items/PanelOptionsGeomapBasemap.d.ts

@@ -0,0 +1,14 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGeomapBasemap extends GrafanaItem {
+    setConfig(config: Object): this;
+    setNewConfig(onNewCreated: ((item: Object) => Object) | undefined): this;
+    withConfig(onWith: (item: Object) => void): this;
+    get config(): Object;
+    setName(name: String): this;
+    setNoRepeat(noRepeat: Boolean): this;
+    setType(type: String): this;
+}

package/dist/items/PanelOptionsGeomapControls.d.ts

@@ -0,0 +1,13 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGeomapControls extends GrafanaItem {
+    setMouseWheelZoom(mouseWheelZoom: Boolean): this;
+    setShowAttribution(showAttribution: Boolean): this;
+    setShowDebug(showDebug: Boolean): this;
+    setShowMeasure(showMeasure: Boolean): this;
+    setShowScale(showScale: Boolean): this;
+    setShowZoom(showZoom: Boolean): this;
+}

package/dist/items/PanelOptionsGeomapLayer.d.ts

@@ -0,0 +1,19 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+import { PanelOptionsGeomapLayerConfig } from "./PanelOptionsGeomapLayerConfig.js";
+import { PanelOptionsGeomapLayerLocation } from "./PanelOptionsGeomapLayerLocation.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGeomapLayer extends GrafanaItem {
+    setConfig(config: PanelOptionsGeomapLayerConfig): this;
+    setNewConfig(onNewCreated: ((item: PanelOptionsGeomapLayerConfig) => PanelOptionsGeomapLayerConfig) | undefined): this;
+    withConfig(onWith: (item: PanelOptionsGeomapLayerConfig) => void): this;
+    get config(): PanelOptionsGeomapLayerConfig;
+    setLocation(location: PanelOptionsGeomapLayerLocation): this;
+    setNewLocation(onNewCreated: ((item: PanelOptionsGeomapLayerLocation) => PanelOptionsGeomapLayerLocation) | undefined): this;
+    withLocation(onWith: (item: PanelOptionsGeomapLayerLocation) => void): this;
+    get location(): PanelOptionsGeomapLayerLocation;
+    setName(name: String): this;
+    setTooltip(tooltip: Boolean): this;
+    setType(type: String): this;
+}

package/dist/items/PanelOptionsGeomapLayerConfig.d.ts

@@ -0,0 +1,12 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+import { PanelOptionsGeomapLayerConfigStyle } from "./PanelOptionsGeomapLayerConfigStyle.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGeomapLayerConfig extends GrafanaItem {
+    setShowLegend(showLegend: Boolean): this;
+    setStyle(style: PanelOptionsGeomapLayerConfigStyle): this;
+    setNewStyle(onNewCreated: ((item: PanelOptionsGeomapLayerConfigStyle) => PanelOptionsGeomapLayerConfigStyle) | undefined): this;
+    withStyle(onWith: (item: PanelOptionsGeomapLayerConfigStyle) => void): this;
+    get style(): PanelOptionsGeomapLayerConfigStyle;
+}

package/dist/items/PanelOptionsGeomapLayerConfigStyle.d.ts

@@ -0,0 +1,31 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+import { StyleColor } from "./StyleColor.js";
+import { StyleRotation } from "./StyleRotation.js";
+import { StyleSize } from "./StyleSize.js";
+import { StyleSymbol } from "./StyleSymbol.js";
+import { StyleSymbolAlign } from "./StyleSymbolAlign.js";
+import { StyleTextConfig } from "./StyleTextConfig.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGeomapLayerConfigStyle extends GrafanaItem {
+    setColor(color: StyleColor): this;
+    withColor(onWith: (item: StyleColor) => void): this;
+    get color(): StyleColor;
+    setOpacity(opacity: Number): this;
+    setRotation(rotation: StyleRotation): this;
+    withRotation(onWith: (item: StyleRotation) => void): this;
+    get rotation(): StyleRotation;
+    setSize(size: StyleSize): this;
+    withSize(onWith: (item: StyleSize) => void): this;
+    get size(): StyleSize;
+    setSymbol(symbol: StyleSymbol): this;
+    withSymbol(onWith: (item: StyleSymbol) => void): this;
+    get symbol(): StyleSymbol;
+    setSymbolAlign(symbolAlign: StyleSymbolAlign): this;
+    withSymbolAlign(onWith: (item: StyleSymbolAlign) => void): this;
+    get symbolAlign(): StyleSymbolAlign;
+    setTextConfig(textConfig: StyleTextConfig): this;
+    withTextConfig(onWith: (item: StyleTextConfig) => void): this;
+    get textConfig(): StyleTextConfig;
+}

package/dist/items/PanelOptionsGeomapLayerLocation.d.ts

@@ -0,0 +1,8 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGeomapLayerLocation extends GrafanaItem {
+    setMode(mode: String): this;
+}

package/dist/items/PanelOptionsGeomapTooltip.d.ts

@@ -0,0 +1,8 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGeomapTooltip extends GrafanaItem {
+    setMode(mode: String): this;
+}

package/dist/items/PanelOptionsGeomapView.d.ts

@@ -0,0 +1,14 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsGeomapView extends GrafanaItem {
+    setAllLayers(allLayers: Boolean): this;
+    setId(id: String): this;
+    setLat(lat: Number): this;
+    setLon(lon: Number): this;
+    setNoRepeat(noRepeat: Boolean): this;
+    setShared(shared: Boolean): this;
+    setZoom(zoom: Number): this;
+}

package/dist/items/PanelOptionsStat.d.ts

@@ -0,0 +1,8 @@
+import { PanelOptions } from "./PanelOptions.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsStat extends PanelOptions {
+
+}

package/dist/items/PanelOptionsTable.d.ts

@@ -0,0 +1,14 @@
+import { PanelOptions } from "./PanelOptions.js";
+import { PanelOptionsTableSortBy } from "./PanelOptionsTableSortBy.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsTable extends PanelOptions {
+    setCellHeight(cellHeight: String): this;
+    setShowHeader(showHeader: Boolean): this;
+    initSortBy(): this;
+    get sortBy(): PanelOptionsTableSortBy[];
+    addSortByItem(sortByItem: PanelOptionsTableSortBy): this;
+    addNewSortByItem(onNewCreated: (item: PanelOptionsTableSortBy) => PanelOptionsTableSortBy): this;
+    withSortBy(onWith: (sortBy: PanelOptionsTableSortBy[]) => void): this;
+}

package/dist/items/PanelOptionsTableSortBy.d.ts

@@ -0,0 +1,9 @@
+import { GrafanaItem } from "./GrafanaItem.js";
+
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsTableSortBy extends GrafanaItem {
+    setDesc(desc: Boolean): this;
+    setDisplayName(displayName: String): this;
+}

package/dist/items/PanelOptionsText.d.ts

@@ -0,0 +1,12 @@
+import { PanelOptions } from "./PanelOptions.js";
+import { PanelOptionsTextCode } from "./PanelOptionsTextCode.js";
+
+import type { GenericMetaOptions } from "@gdacm/base-types";
+
+export declare class PanelOptionsText extends PanelOptions {
+    setCode(code: PanelOptionsTextCode): this;
+    withCode(onWith: (item: PanelOptionsTextCode) => void): this;
+    get code(): PanelOptionsTextCode;
+    setContent(content: String): this;
+    setMode(mode: String): this;
+}