@windycom/plugin-devtools 1.0.1

package/types/Favs.d.ts

@@ -0,0 +1,83 @@
+import type { Fav, UpcomingFav } from '@windy/interfaces.d';
+export type FavKey = string;
+export type FavsInitParams = {
+    ident: `favs${number}` | `recents${number}`;
+};
+export declare class Favs<T extends Fav> {
+    /** Local storage key (under which are data stored) */
+    protected ident: `favs${number}` | `recents${number}`;
+    private lastModified?;
+    /** Major data holder */
+    data: Record<FavKey, T>;
+    constructor(params: FavsInitParams);
+    /**
+     * Returning key for item key is either ICAO code or lat/lon stripped to 3 decimals or alertID
+     */
+    key(item: Partial<Fav> | string): string;
+    /**
+     * Add airport or location to local storage
+     */
+    prepareAdd(item: UpcomingFav): FavKey;
+    /**
+     * Add airport or location to local storage and sync with cloud
+     * query parameter is only for inherited classes, it is not used in this class
+     */
+    add(item: Fav, _query?: string): boolean | Promise<string> | void;
+    findFavByProperties(item: Partial<Fav> | FavKey): Fav | undefined;
+    /**
+     * Deduplicates two collections for example favs, recents, search results
+     * returns deduplicated and mergedcollection, whereas collection2 has higher proprity
+     */
+    dedupeAndConcat(collection1: Fav[], collection2: Fav[]): Fav[];
+    /**
+     * Dedupe
+     */
+    dedupeFav(item: Partial<Fav> | FavKey, findingFun: (cmp: (i: Fav) => boolean) => Fav | undefined): Fav | undefined;
+    /**
+     * Check if this is favorite or not
+     */
+    isFav(item: FavKey | Partial<Fav>): boolean;
+    /**
+     * Save all in localStorage
+     */
+    save(): void;
+    /**
+     * Update timestamp in localStorage
+     */
+    updateTimestamp(): void;
+    /**
+     * Load from localStorage
+     */
+    load(): void;
+    /**
+     * Called upon add/removal
+     */
+    onchange(): void;
+    /**
+     * Remove fav item from local storage - key or object
+     */
+    prepareRename(fav: Fav, name: string): boolean;
+    rename(fav: Fav, name: string): void;
+    /**
+     * Remove fav item from local storage - key or object
+     */
+    prepareRemove(item: Fav | FavKey): void;
+    /**
+     * Remove fav item. Second parameter and promise return type is to stay consistent with child types inheriting from this
+     */
+    remove(item: Fav | FavKey, _isAlert?: boolean): Promise<void>;
+    getAll(): Record<string, T>;
+    /**
+     * increase counter of item
+     */
+    hit(item: Fav): void;
+    /**
+     * Filters && sorts items and rtrns a list of keys
+     */
+    sortFavs(query: string | undefined | null, sortProperty: 'timestamp' | 'counter', excludeItems?: FavKey[] | null): FavKey[];
+    /**
+     * Returns array of up to @num most popular items filtered by @query and sorted by @sortProperty. @exclude is list
+     * of items containing keys that should be excluded from result
+     */
+    get(num: number, query: string | undefined | null, sortProperty: 'timestamp' | 'counter', exclude?: Fav[]): Fav[];
+}

package/types/GhostBox.d.ts

@@ -0,0 +1,17 @@
+import type { Drag } from './Drag';
+export type GhostBoxInitParams = {
+    drag: Drag;
+    progressLine: HTMLElement;
+    ghost: HTMLElement | null;
+    updateGhost?(event: MouseEvent | TouchEvent): void;
+};
+export declare class GhostBox {
+    private drag;
+    progressLine: HTMLElement;
+    ghost: HTMLElement | null;
+    constructor(params: GhostBoxInitParams);
+    private updateGhost;
+    private onGhostMouseEnter;
+    private onGhostMouseLeave;
+    private onGhostMouseMove;
+}

package/types/GlObj.d.ts

@@ -0,0 +1,252 @@
+import type { Canvas, ExtendedWebGLTexture, WebGLProgramObject } from '@windy/GlObj.d';
+/**
+ * GLObj - Web GL context wrapper
+ */
+declare class GLObj {
+    /**
+     * Little endianess
+     */
+    static littleEndian: boolean;
+    /**
+     * newId for new instance
+     */
+    static newId: number;
+    /**
+     * New id for gl context
+     */
+    static newGlId: number;
+    /**
+     * id for instances comparison
+     */
+    id: number;
+    /**
+     * Gl context id for comparison
+     */
+    glId: number;
+    /**
+     * Stored param MAX_TEXTURE_SIZE from last gl context
+     */
+    maxTextureSize: number;
+    /**
+     * Name for debug purposes
+     */
+    _name?: string;
+    /**
+     * store WebGL objects references in own arrays
+     */
+    keepRefs: boolean;
+    /**
+     * store reference for vertex and pixel shaders
+     */
+    keepRefsShaders: boolean;
+    /**
+     * arrays for reference storing
+     */
+    framebuffers: WebGLFramebuffer[];
+    buffers: WebGLBuffer[];
+    shaders: WebGLShader[];
+    programs: WebGLProgram[];
+    textures: ExtendedWebGLTexture[];
+    /**
+     * web gl context
+     */
+    _gl: null | WebGLRenderingContext;
+    /**
+     * associated HTMLCanvasElement
+     */
+    canvas: null | Canvas;
+    /**
+     * Last result of checkGlError()
+     */
+    isGlError: boolean;
+    /**
+     * Last error message generated by checkGlError()
+     */
+    lastGlErrorMsg: string;
+    constructor(keepRefs?: boolean, keepRefsShaders?: boolean);
+    /**
+     * reset all
+     */
+    reset(): void;
+    /**
+     * create webGl rendering context on given canvas
+     *
+     * @param canvas HTMLCanvasElement
+     * @param flags contextAttributes
+     * @param name context name for debug purposes
+     */
+    create(canvas: Canvas, flags: WebGLContextAttributes, name?: string): void | WebGLRenderingContext | null;
+    /**
+     * Rets true if canvas or webgl context is NOT valid
+     */
+    isInvalid(): boolean;
+    /**
+     * Get WebGLRendering context. If it is null we consider the error was thrown earlier
+     */
+    gl(): WebGLRenderingContext | null;
+    /**
+     * !DEPRECATED!
+     */
+    get(): WebGLRenderingContext | null;
+    getCanvas(): Canvas | null;
+    /**
+     * Create shader and compile source
+     *
+     * @param source .. shader source string
+     * @param isVertexShader .. shader type (true .. gl.VERTEX_SHADER, false .. gl.FRAGMENT_SHADER)
+     * @param name .. name of shader
+     * @returns shader
+     */
+    createShader(source: string, isVertexShader: boolean, name?: string): WebGLShader | null;
+    /**
+     * create shader program (compile and link vertex and fragment sources and loop through attributes and uniforms )
+     *
+     * @param vertexSource .. shader source string
+     * @param fragmentSource .. shader source string
+     * @param defs .. array of #define strings
+     * @param name .. optional shader name
+     * @returns Object { program, <attributes names>, <uniforms names> };
+     */
+    createProgramObj(vertexSource: string, fragmentSource: string, defs?: string[] | null, name?: string): WebGLProgramObject | null;
+    /**
+     * delete shader program
+     */
+    deleteProgramObj(program: WebGLProgram): void;
+    /**
+     * bind attribute (source of vertex data) to shader program (set before)
+     *
+     * @param buffer .. vertex buffer
+     * @param attribute .. attribute index in shader program
+     * @param numComponents ..attribute vector component <1;4>
+     * @param type .. (gl.UNSIGNED_BYTE, gl.SHORT, gl.UNSIGNED_SHORT, gl.FLOAT)
+     * @param normalized .. normalize fixed-point data (gl.TRUE, gl.FALSE)
+     * @param stride ..in bytes between the beginning of consecutive vertex attributes (vertex size in bytes)
+     * @param offset ..in bytes of the first component in the vertex attribute array. Must be a multiple of type.
+     */
+    bindAttribute(buffer: WebGLBuffer | null, attribute: GLuint, numComponents: GLint, type: GLenum, normalized: GLboolean, stride: GLsizei, offset: GLintptr): void;
+    /**
+     * Loads texture from url
+     * @param name texture name
+     * @param url Texture URL
+     * @param minFilter Min-filter
+     * @param magFilter Mag-filter
+     * @param wrap texture wrap S and texture wrap T
+     * @param genMips generate mipmaps?
+     */
+    textureFromUrlPromise<K extends string>(name: K, url: string, minFilter: GLint, magFilter: GLint, wrap: GLenum, genMips: boolean): Promise<[K, ExtendedWebGLTexture | null]>;
+    /**
+     * Loads texture from base64 image (async! may be delayed)
+     *
+     * @param minFilter ?????
+     * @param magFilter ?????
+     * @param wrap ?????
+     * @param base64 ?????
+     * @param genMips ?????
+     * @returns gl texture object
+     */
+    createTextureFromBase64(minFilter: GLenum, magFilter: GLenum, wrap: GLenum, base64: string, genMips: boolean): ExtendedWebGLTexture | null;
+    /**
+     * create 2D texture
+     *
+     * @param minFilter .. gl.NEAREST, gl.LINEAR, gl.NEAREST_MIPMAP_NEAREST, gl.LINEAR_MIPMAP_NEAREST, gl.NEAREST_MIPMAP_LINEAR, gl.LINEAR_MIPMAP_LINEAR
+     * @param magFilter .. gl.NEAREST, gl.LINEAR
+     * @param wrap .. gl.CLAMP_TO_EDGE, gl.REPEAT, gl.MIRRORED_REPEAT
+     * @param data .. Uint8Array or imageData
+     * @param width .. dimensions for Uint8Array data
+     * @param height .. dimensions for Uint8Array data
+     * @param format .. gl.RGBA, gl.RGB, gl.LUMINANCE_ALPHA, gl.LUMINANCE, gl.ALPHA
+     * @param genMips .. true/false generate mipmap chain (sizes must be power of 2)
+     * @description texImage2D: https://developer.mozilla.org/en/docs/Web/API/WebGLRenderingContext/texImage2D
+     */
+    createTexture2D(minFilter: GLenum, magFilter: GLenum, wrap: GLenum, data: TexImageSource | ArrayBufferView | (TexImageSource | ArrayBufferView)[] | null, width: GLsizei, height: GLsizei, format?: GLenum, genMips?: boolean): ExtendedWebGLTexture | null;
+    /**
+     * resize existing 2D texture
+     *
+     * @param texture .. existing 2D texture
+     * @param data .. Uint8Array or imageData or Array of mips (Uint8Array)
+     * @param width .. dimensions for Uint8Array data
+     * @param height .. dimensions for Uint8Array data
+     * @param format .. gl.RGBA, gl.RGB, gl.LUMINANCE_ALPHA, gl.LUMINANCE, gl.ALPHA
+     * @param genMips .. true/false generate mipmap chain
+     * @description texImage2D: https://developer.mozilla.org/en/docs/Web/API/WebGLRenderingContext/texImage2D
+     */
+    resizeTexture2D(texture: ExtendedWebGLTexture | null, data: TexImageSource | ArrayBufferView | (TexImageSource | ArrayBufferView)[] | null, width: GLsizei, height: GLsizei, format?: GLenum, genMips?: boolean): ExtendedWebGLTexture | null;
+    /**
+     * delete 2D texture object
+     */
+    deleteTexture2D(texture: WebGLTexture): void;
+    /**
+     * activate texture and bind it to sampler unit
+     *
+     * @param texture .. previously created 2D texture
+     * @param unit .. index of sampler unit
+     * @param shaderVar .. optional shader uniform sampler2D variable
+     */
+    bindTexture2D(texture: WebGLTexture | null, unit?: GLenum, shaderVar?: WebGLUniformLocation | null): void;
+    /**
+     * set texture filter and wrap params (bind texture before by bindTexture2D)
+     *
+     * @param minFilter .. gl.LINEAR, gl.NEAREST, gl.NEAREST_MIPMAP_NEAREST, gl.LINEAR_MIPMAP_NEAREST, gl.NEAREST_MIPMAP_LINEAR (default value), gl.LINEAR_MIPMAP_LINEAR
+     * @param magFilter .. gl.LINEAR (default value), gl.NEAREST
+     * @param wrapS .. gl.REPEAT (default value),gl.CLAMP_TO_EDGE, gl.MIRRORED_REPEAT
+     * @param wrapT .. gl.REPEAT (default value),gl.CLAMP_TO_EDGE, gl.MIRRORED_REPEAT
+     */
+    setBindedTexture2DParams(minFilter: GLenum, magFilter: GLenum, wrapS: GLenum, wrapT?: GLenum): void;
+    /**
+     * create vertex (attributes source) buffer from data
+     *
+     * @param data .. ArrayBuffer, SharedArrayBuffer or ArrayBufferView; will be copied into the data store
+     */
+    createBuffer(data: BufferSource): WebGLBuffer | null;
+    /**
+     * delete vertex or index buffer
+     */
+    deleteBuffer(buffer: WebGLBuffer): void;
+    /**
+     * @param buffer .. created vertex buffer
+     * @param data .. ArrayBuffer, SharedArrayBuffer or ArrayBufferView; will be copied into the data store
+     */
+    setBufferData(buffer: WebGLBuffer, data: BufferSource): void;
+    /**
+     * create indices buffer from data
+     *
+     * @param data .. ArrayBuffer, SharedArrayBuffer or ArrayBufferView; will be copied into the data store
+     */
+    createIndexBuffer(data: BufferSource): WebGLBuffer | null;
+    createFramebuffer(): WebGLFramebuffer | null;
+    /**
+     * delete Framebuffer
+     */
+    deleteFramebuffer(framebuffer: WebGLFramebuffer): void;
+    /**
+     * bind or unbind framebuffer
+     *
+     * @param framebuffer .. or null for unbind
+     * @param texture .. compatible 2D texture
+     */
+    bindFramebuffer(framebuffer: WebGLFramebuffer | null, texture?: WebGLTexture | null): void;
+    /**
+     * release all GL resources and reset
+     */
+    release(): void;
+    /**
+     * Sets this.isGlError and this.lastGlErrorMsg
+     * @returns isGlError: boolean
+     */
+    checkGlError(): boolean;
+    /**
+     * Checks WebGL status and returns message
+     * @returns lastGlErrorMsg: string
+     */
+    getGlStatus(): string;
+    /**
+     * get next greater size which is power of 2
+     * (ex: 11 >>> 16, 17 >>> 32, ... )
+     */
+    static getNextPowerOf2Size(size: number): number;
+    /**
+     * remove object from array (Array.findIndex() not supported by all browsers)
+     */
+    static removeFromArray<T = WebGLFramebuffer | WebGLBuffer | WebGLProgram | WebGLShader | ExtendedWebGLTexture>(o: T, a: T[]): number;
+}
+export default GLObj;

package/types/HrrrProducts.d.ts

@@ -0,0 +1,5 @@
+import { Product } from '@windy/Product';
+import type { ProductInitParams } from '@windy/Product';
+export declare class HrrrProducts extends Product {
+    constructor(params: Partial<ProductInitParams>);
+}

package/types/IconProducts.d.ts

@@ -0,0 +1,5 @@
+import { Product } from '@windy/Product';
+import type { ProductInitParams } from './Product';
+export declare class IconProducts extends Product {
+    constructor(params: Pick<ProductInitParams, 'modelName'> & Partial<ProductInitParams>);
+}

package/types/LabelsLayer.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/types/LandMask.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/types/Layer.d.ts

@@ -0,0 +1,137 @@
+import type { Color } from '@windy/Color';
+import type { FullRenderParameters, Layers, RenderParams, TransformFunction } from '@windy/Layer.d';
+import type { Metric } from '@windy/Metric';
+import type { Legend } from '@windy/Metric.d';
+import type { NumberedMetric } from '@windy/MetricClasses';
+import type { Product } from '@windy/Product';
+import type { DataQuality, FileSuffix } from '@windy/Product.d';
+import type { Renderers } from '@windy/Renderer.d';
+import type { WeatherParameters } from '@windy/interfaces.d';
+import type { Levels, Products } from '@windy/rootScope.d';
+import type { Timestamp } from '@windy/types';
+type LayerInitParams = Pick<Layer, 'ident'> & Partial<Layer>;
+export declare class Layer<M extends Metric | undefined = Metric | undefined> {
+    /**
+     * Colors instance(s) used for this overlay
+     */
+    c: Color;
+    /**
+     * Metric instances used for this overlay
+     */
+    m: M extends Metric ? M : undefined;
+    /**
+     * Alternative legend
+     */
+    l?: Legend;
+    /**
+     * Layer identifier (used for metric settings) since some overlays are just pointers to
+     * other overlays, identifier can be same for more overlays.
+     */
+    ident: Layers;
+    /**
+     * Standard renderer ident
+     */
+    renderer: Renderers;
+    /**
+     * If set replaces overlay as filename for particular file path
+     */
+    filename?: string;
+    /**
+     * If true applies "sea" class to body tag which influencess way, the globe is displayed
+     */
+    sea: boolean;
+    /**
+     * If defined overwrites data precision quality of product
+     */
+    dataQuality: DataQuality;
+    /**
+     * If set overrides file suffix of product
+     */
+    fileSuffix: FileSuffix;
+    /**
+     * Blue channel defines transparency
+     */
+    JPGtransparency: boolean;
+    /**
+     * PNG file with defined transparency
+     */
+    PNGtransparency?: boolean;
+    /**
+     * Overrides product's maxTileZoom
+     */
+    maxTileZoom?: {
+        free: number;
+        premium: number;
+    };
+    /**
+     * These properties are passed directlly to renderer
+     */
+    renderParams: RenderParams;
+    /**
+     * Overrides param's product
+     */
+    product?: Products;
+    /**
+     * Overrides products or params levels
+     */
+    levels: Levels[];
+    /**
+     * Optional quary string that enhances query string
+     */
+    query?: string;
+    /**
+     * webGL transformation
+     */
+    wTransformR?: number | 'rainLog';
+    /**
+     * What is this? webGL or Globe hasParticles?
+     */
+    hasParticles?: boolean;
+    /**
+     * Metrics to use in color settings
+     * If users opts to change colors of this layer, use this metrics
+     */
+    cm?: Metric;
+    /**
+     * Overwrite's products pathgenerator
+     */
+    pathGenerator?: string;
+    /**
+     * Method to transfrom value in R channel
+     */
+    transformR?: TransformFunction;
+    /**
+     * Method to transfrom value in G channel
+     */
+    transformG?: TransformFunction;
+    /**
+     * Method to transfrom value in B channel
+     */
+    transformB?: TransformFunction;
+    constructor(params: LayerInitParams);
+    /**
+     * Just calls Color's getColor() method
+     */
+    getColor(): ReturnType<Color['getColor']>;
+    /**
+     * getColor for layers, with mutliple colors (like rainClouds)
+     */
+    getColor2?(): ReturnType<Color['getColor']>;
+    /**
+     * Just call Product's open and return its Calendar
+     */
+    getCalendar(prodIdent: Products): ReturnType<Product['open']>;
+    /**
+     * Creates RenderingParameters
+     */
+    getParams(weatherParams: WeatherParameters, productIdent: Products, timestamp?: Timestamp, refTime?: string): Promise<FullRenderParameters>;
+    /**
+     * Return amounts of dots, based on rain
+     */
+    getAmountByColor?(Rf: number, Gf: number): 0 | 1 | 2 | 3 | 4;
+    protected initProperties(): void;
+}
+export declare class WaveLayer extends Layer<NumberedMetric> {
+    initProperties(): void;
+}
+export {};

package/types/Legend.d.ts

@@ -0,0 +1,6 @@
+export declare class Legend {
+    el: HTMLDivElement;
+    constructor(el: HTMLDivElement);
+    onclick(): void;
+    render(): void;
+}

package/types/LongTap.d.ts

@@ -0,0 +1,21 @@
+import type { HapticsPlugin } from '@capacitor/haptics';
+export type LongTapInitParams = Pick<LongTap, 'el'> & {
+    useHaptics?: boolean;
+    onClick?(e: MouseEvent | TouchEvent): void;
+    onLongTap?(ev: MouseEvent | TouchEvent): void;
+};
+export declare class LongTap {
+    el: HTMLElement;
+    useHaptics: boolean;
+    haptics: HapticsPlugin | null;
+    timer: ReturnType<typeof setTimeout> | null;
+    longPressed: boolean;
+    constructor(params: LongTapInitParams);
+    onClick(_e: MouseEvent | TouchEvent): void;
+    onLongTap(_e: MouseEvent | TouchEvent): void;
+    onCLickPressed(e: MouseEvent | TouchEvent): void;
+    longTapPressed(e: TouchEvent): void;
+    touchStart(e: TouchEvent): void;
+    touchEnd(): void;
+    clearLongPressTimer(): void;
+}

package/types/Metric.d.ts

@@ -0,0 +1,132 @@
+import type { Color } from '@windy/Color';
+import type { RGBString } from '@windy/Color.d';
+import type { ConvObj, Legend, LegendDescription, LegendLines, MetricIdent, MetricInitParams, MetricItem, MetricKey } from '@windy/Metric.d';
+import type { LoadedTranslations } from '@windy/trans.d';
+import type { HTMLString, NumValue } from '@windy/types.d';
+export declare const rtrnSelf: (x: NumValue) => NumValue;
+/**
+ * # @windy/Metric
+ *
+ * Major Windy class for conversion of units, that are used in Windy.com.
+ *
+ * Enjoy methods like `convertValue`, `convertNumber`, `listMetrics`, `howManyMetrics`
+ *
+ * Never ever, change users selected metric without their consent.
+ */
+export declare abstract class Metric<T extends string | number = string | number> {
+    /**
+     * Identifies metric
+     */
+    ident: MetricIdent;
+    /**
+     * Store key
+     */
+    key: MetricKey;
+    /**
+     * Actually selected metric
+     */
+    metric: MetricItem;
+    /**
+     * Conversion functions
+     */
+    conv: ConvObj;
+    /**
+     * number ' ' metric separator
+     */
+    separator: '' | ' ';
+    /**
+     * Default metric for start-up
+     * [ metric, imperial, ??? ]
+     */
+    defaults: MetricItem[];
+    /**
+     * Sync the metric to native iOS/Android apps
+     */
+    nativeSync: boolean;
+    /**
+     * Legend description
+     */
+    description: LegendDescription;
+    /**
+     * Array defining how the legend will look like
+     */
+    lines: LegendLines;
+    /**
+     * Keeps cohesion in between multiple metric instances. For example setting `in`
+     * in rain will set `in` in snow also
+     */
+    cohesion?: {
+        [ident in MetricIdent]?: {
+            [unit in MetricItem]?: MetricItem;
+        };
+    };
+    /**
+     * Some metrics have discrete legend.
+     * If so, these labels define it, where NumValue is numerical value, to grab color from color table
+     */
+    discreteLegend?: {
+        /**
+         * Should all items in legend have same width?
+         */
+        hasEqualItemsWidth?: boolean;
+        /**
+         * Array of trans strings and clored string.
+         *
+         * For simplicity of sloution, the legned colors are hardcoded
+         * thus they do not react on 'users' defined color. This will
+         * be know bug and we will not handle this case.
+         */
+        labels: [keyof LoadedTranslations, RGBString][];
+    };
+    /**
+     * Colors used to render discrete legend
+     * @param params
+     */
+    constructor(params: MetricInitParams);
+    onMetricChanged(metric: MetricItem): void;
+    getDefault(): MetricItem;
+    setDefault(): void;
+    /**
+     * get value + label on a basis of user selected metric
+     */
+    convertValue(value: NumValue, separator?: string, suffix?: string): string;
+    /**
+     * Not available
+     */
+    na(): string | '-';
+    /**
+     * produces converted number value without label
+     */
+    abstract convertNumber(value: NumValue, forcedPrecision?: number, metric?: MetricItem): T;
+    /**
+     * List all avail metrics
+     */
+    listMetrics(): MetricItem[];
+    /**
+     * How many metrics we have
+     */
+    howManyMetrics(): number;
+    /**
+     * Stores required metric into storage
+     */
+    setMetric(metric: MetricItem, uiIdent?: string): void;
+    /**
+     * Cycles throu different metrics (for example after clicking on a legend)
+     */
+    cycleMetric(uiIdent?: string): void;
+    /** color object is required for classic gradient metrics, discrete ones do not need it as colors are hardcoded for them */
+    renderLegend(col: Color | undefined, el: HTMLDivElement, legend: Legend): void;
+    /**
+     * Renders colorfull legent onto the el
+     */
+    renderGradientLegend(col: Color | undefined, el: HTMLDivElement, legend: Legend): {
+        background: string;
+        content: HTMLString;
+    } | null;
+    renderDiscreteLegend(): {
+        background: '';
+        content: HTMLString;
+    };
+    protected initProperties(): void;
+    private _createKey;
+}