@windycom/plugin-devtools 3.0.0 → 3.0.2

package/README.md

@@ -4,6 +4,8 @@ Check out https://docs.windy-plugins.com for more information.
 
 # CHANGELOG
 
+-   3.0.2 - TS declarations for client v47.0.2
+-   3.0.1 - TS declarations for client v46.1.0
 -   3.0.0 - TS declarations for client v45.0.0
 -   2.0.2 - Support Windows in file path regex
 -   2.0.1 - Remove less-autoprefixer

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@windycom/plugin-devtools",
-    "version": "3.0.0",
+    "version": "3.0.2",
     "description": "Developer tools and TS declarations for developers of Windy Plugins.",
     "main": "index.mjs",
     "module": "index.mjs",

package/types/client/BottomSlide.d.ts

@@ -48,6 +48,9 @@ export declare class BottomSlide extends Drag {
     ondrag(_x: number, y: number, e: Event): void;
     ondragend(): void;
     startDrag(e: TouchEvent): void;
+    release(): void;
     private initCloseOnSwipeDown;
+    private setHalfOpen;
     private updatePosition;
+    private onRqstPluginHalfOpen;
 }

package/types/client/Calendar.d.ts

@@ -1,139 +1,169 @@
+import type { Products } from '@windy/rootScope.d';
+import type { ISODateString, Path, Timestamp, LoadedTranslations } from '@windy/types.d';
 /**
- * Object containing timestamps and methods for given weather product
+ * Main minifest object received from backend
  */
-import type { CalendarDay, MinifestObject, Weekday } from './d.ts.files/Calendar.d';
-import type { TimeFormatFunction } from './d.ts.files/format.d';
-import type { Products } from './d.ts.files/rootScope.d';
-import type { ISODateString, Path, Timestamp, YYYYMMDDHH } from './d.ts.files/types.d';
-export type CalendarInitParams = Pick<Calendar, 'numOfHours' | 'minifestFile'> & {
+export interface MinifestObject {
     /**
-     * Ident of product that this calendar is for
+     * Version
      */
-    product: Products;
+    v: string;
     /**
-     * This product is a free product
+     * Array of hour moments that contain forecast data
      */
-    freeProduct?: boolean;
+    dst: number[][];
     /**
-     * Optional latest timestamp (for use for offline mode for example)
+     * Main identifier, identifying the refTime on the backend.
      */
-    lastTimestamp?: Timestamp;
-};
-export declare class Calendar {
+    info: string;
     /**
-     * Time formatting function
+     * Reference time of forecast
      */
-    static readonly localeHours: TimeFormatFunction;
-    static readonly weekdays: Weekday[];
+    ref: ISODateString;
     /**
-     * Number of hours covered by this calendar
+     * Update time of the forecast
      */
-    numOfHours: number;
-    calendarHours: number;
+    update: ISODateString;
     /**
-     * Today midnigh in LT of user's computer
+     * In an emergency case backend can set `force` property at minifest. It breaks minifest client cache and set minifest at any circumstances
      */
-    midnight: Date;
+    forced?: boolean;
+}
+/**
+ * Main Calendar Day Object
+ */
+export interface CalendarDay {
     /**
-     * This midnight of other defined start of timeline
+     * Translation ID for week day abbreviation
      */
-    startOfTimeline: Date;
+    display: keyof LoadedTranslations;
     /**
-     * startOfTimeline in the form of timestamp
+     * Translation ID for week day abbreviation
      */
-    start: Timestamp;
+    displayLong: keyof LoadedTranslations;
     /**
-     * startOfPremiumTimeline in the form of timestamp; null if it is free in whole range
+     * Start of the day
      */
-    premiumStart: Timestamp | null;
+    start: Timestamp;
     /**
-     * endOfCalendar as timestamp
+     * End of the day
      */
-    endOfCal: Timestamp;
+    end: Timestamp;
     /**
-     * endOfCal or latest timestamp, whiever is smaller
+     * Midday of the day
      */
-    end: Timestamp;
+    middayTs: Timestamp;
     /**
-     * Array of calendayr days to be used in UI
+     * Day of the month
      */
-    days: CalendarDay[];
+    day: number;
     /**
-     * Array of timestamps that contain valid forecast
+     * Forecast for this day is for Premium users only
      */
-    timestamps: Timestamp[];
+    premium: boolean;
     /**
-     * Array of URL paths that equal to timestamps in a form of "2021/05/27/19"
+     * Forecast for this day is available
      */
-    paths: string[];
+    hasForecast: boolean;
+}
+/**
+ * Valid translation keys
+ */
+export type Weekday = 'SUN' | 'MON' | 'TUE' | 'WED' | 'THU' | 'FRI' | 'SAT';
+export type CalendarInitParams = {
     /**
      * Minifest that led to construction of this instance
      */
-    minifestFile: MinifestObject;
+    minifest: MinifestObject;
     /**
-     * Is the minifest valid or emergency, created out of the air?
+     * Ident of product that this calendar is created for
      */
-    minifestValid: boolean;
+    productIdent: Products;
     /**
-     * Minifests's reference time is some non stndard format
+     * This product is a free product
      */
-    refTime: YYYYMMDDHH;
+    freeProduct?: boolean;
     /**
-     * Minifests's reference time
+     * Minimum number of hours this calendar should cover
      */
-    refTimeTs: Timestamp;
+    minimumHours: number;
+};
+export declare class Calendar {
+    static readonly weekdays: Weekday[];
     /**
-     * Minifests's reference time
+     * At what day we start premium forecast
      */
-    refTimeTxt: ISODateString;
+    private premiumStartDay;
     /**
-     * Forecast update time
+     * Ident of a product that this Calendar is associated with (just for debug purposes)
      */
-    updateTs: Timestamp;
+    private productIdent;
     /**
-     * Forecast update time
+     * Number of hours in the calendar
      */
-    updateTxt: ISODateString;
-    constructor(params: CalendarInitParams);
-    initProperties(): void;
+    calendarHours: number;
     /**
-     * Bound ts to be be within limit of calendar
+     * Today midnight in LT of user's computer
      */
-    boundTs(ts: Timestamp): Timestamp;
+    midnight: Date;
     /**
-     * Finds closes valid path on the basis of timestamp
+     * startOfTimeline in the form of timestamp
      */
-    ts2path(ts: Timestamp): Path;
+    start: Timestamp;
     /**
-     * Creates timestamps out of the air, with 3h interval (fixed)
+     * startOfPremiumTimeline in the form of timestamp; null if it is free in whole range
      */
-    createTimestamps(): void;
-    prepareTimesFromMinifest(minifest: MinifestObject): boolean;
+    premiumStart: Timestamp | null;
     /**
-     * Creates timestamps & paths arrays from minifest
+     * endOfPremiumTimeline in the form of timestamp; null if it is free in whole range
      */
-    createTimestampsFromMinifest(minifest: MinifestObject): boolean;
+    premiumEnd: Timestamp | null;
     /**
-     * Return YYYY/MM/DD/HH or YYYYMMDDHH on a basis of provided date
-     * we do not CHECK existence of path in minifest
+     * endOfCalendar as timestamp
      */
-    static date2path(date: Date): YYYYMMDDHH;
+    endOfCal: Timestamp;
     /**
-     * Returns JavaScript date object corresponding
-     * to provided path in a form YYYY/MM/DD/HH or YYYYMMDDHH
+     * endOfCal or latest timestamp, whoever is smaller
      */
-    static path2date(path: string): Date;
+    end: Timestamp;
     /**
-     * Returns nice, human readable date string out of ts
+     * Array of calendar days to be used in UI
      */
-    static ts2string(ts: string | number): string;
+    days: CalendarDay[];
+    /**
+     * Array of timestamps that contain valid forecast
+     */
+    timestamps: Timestamp[];
+    /**
+     * Array of URL paths that equal to timestamps in a form of "2021/05/27/19"
+     */
+    paths: Path[];
+    /**
+     * Forecast update time
+     */
+    updateTs: Timestamp;
+    /**
+     * Minifests's reference time
+     */
+    refTimeTs: Timestamp;
+    constructor({ productIdent, minifest, freeProduct, minimumHours }: CalendarInitParams);
+    /**
+     * Bound ts to be be within limit of calendar
+     */
+    boundTs(ts: Timestamp): Timestamp;
+    /**
+     * Finds closes valid path on the basis of timestamp
+     */
+    ts2path(ts: Timestamp): Path;
+    private createDays;
+    private createTimestamps;
     /**
      * Adds hours or days to date
      *
      * @example
      * date = this.add( new Date(), 13, 'days' )
      */
-    static add(date: Date, x: number, what?: 'days' | 'hours' | undefined): Date;
+    private add;
     /**
      * Return nearest midnight
      */

package/types/client/Color.d.ts

@@ -1,8 +1,14 @@
-import type { ColorGradient, AnyColorIdent, RGBA, RGBString } from './d.ts.files/Color.d';
-import type { NumValue } from './d.ts.files/types.d';
+import type { RGBA, RGBString, ColorGradient, NumValue, ColorGradientString } from '@windy/types.d';
+export type ColorIdent = 'temp' | 'wind' | 'rh' | 'pressure' | 'cclAltitude' | 'altitude' | 'deg0' | 'levels' | 'rain' | 'ptype' | 'rainClouds' | 'clouds' | 'lclouds' | 'hclouds' | 'mclouds' | 'cape' | 'lightDensity' | 'cbase' | 'snow' | 'rainAccu' | 'waves' | 'currents' | 'visibility' | 'gtco3' | 'aod550' | 'pm2p5' | 'no2' | 'tcso2' | 'go3' | 'cosc' | 'dust' | 'satellite' | 'radar' | 'radarPlus' | 'fog' | 'justGray' | 'efiWind' | 'efiTemp' | 'efiRain' | 'moistureAnom40' | 'moistureAnom100' | 'drought' | 'soilMoisture' | 'fwi' | 'dfm10h' | 'solarpower' | 'uvindex' | 'turbulence' | 'icing' | 'wetbulbtemp' | 'aqi' | 'dewpoint';
+export type PluginColorIdent = 'windDetail' | 'wavesDetail' | 'periodDetail' | 'altitudeDetail' | 'visibilityDetail' | 'dewpointSpreadDetail' | 'blitz' | 'radiation' | 'pmDetail' | 'dustDetail' | 'coscDetail' | 'no2Detail' | 'pollenDetail' | 'so2Detail' | 'aqiGradientDetail';
+export type AnyColorIdent = ColorIdent | PluginColorIdent | 'pressureIsolines' | 'temporary' | 'direction' | 'airgramColor' | 'tempFillColors' | 'tideGraphColors' | 'aqiFillColors';
+export interface UserColor {
+    id: AnyColorIdent;
+    gradient: ColorGradient;
+}
 export type ColorInitParams = Pick<Color, 'ident'> & Partial<Pick<Color, 'qualitative'>> & {
-    steps: number;
-    default: ColorGradient;
+    default: ColorGradientString;
+    steps?: number;
     opaque?: boolean;
     prepare?: boolean;
 };
@@ -26,7 +32,9 @@ export declare class Color {
     /** Index of neutral gray color */
     private neutralGrayIndex;
     /** Initial gradient */
-    private defaultColorGradient;
+    private initialColorGradient;
+    /** Initial gradient, that was parsed to RGBA arrays from RGBAStrings */
+    private defaultColorGradient?;
     /** Custom modified gradient */
     private customColorGradient?;
     /** Big interpolated RGBA Type array color table, generated when color is required */
@@ -75,7 +83,7 @@ export declare class Color {
      * bOpaque .. set alpha to 255
      * bPremultiply .. mul RGB by A
      * valueScale .. optional scale used for WebGL texture data (coef 0.5 means half step - gradient size is doubled)
-     * return .. output Uint8Array with color data
+     * return .. output Uint8Array with color data (NOTE: Uint8ClampedArray NOT SUPPORTED in WebGL!)
      */
     createGradientArray(bOpaque?: boolean, bPremultiply?: boolean, valueScale?: number): Uint8Array;
     /**
@@ -91,6 +99,11 @@ export declare class Color {
      * Checks validity of a gradient that it adheres to type ColorGradient
      */
     static checkValidity(obj: unknown): boolean;
+    private parseRGBAString;
+    /**
+     * Converts ColorGradientString into ColorGradient
+     */
+    private parseColorGradient;
     /**
      * return array multiplied by mul coef
      */

package/types/client/DataTiler.d.ts

@@ -1,5 +1,5 @@
 import { dataLoader } from '@windy/dataLoader';
-import type { FullRenderParameters } from './d.ts.files/Layer.d';
+import type { FullRenderParameters } from './d.ts.files/interfaces';
 import type { DataTile } from './d.ts.files/dataLoader';
 import type { ExtendedTileParams } from './DataTiler.d';
 export interface TilePoint {

package/types/client/ExternalSveltePlugin.d.ts

@@ -22,10 +22,15 @@ export declare class ExternalSveltePlugin extends SveltePlugin<'windy-external-p
     mobileConfig: Record<InstalledExternalPluginConfig['mobileUI'], Config2config>;
     desktopConfig: Record<InstalledExternalPluginConfig['desktopUI'], Config2config>;
     widthOfRhPane: number;
+    version: string;
     listenToSingleclick: ExternalPluginConfig['listenToSingleclick'];
     addToContextmenu: ExternalPluginConfig['addToContextmenu'];
-    constructor(params: WindowPluginInitParams<'windy-external-plugin'>, { desktopUI, title, mobileUI, desktopWidth, routerPath, listenToSingleclick, addToContextmenu, url, }: InstalledExternalPluginConfig);
+    constructor(params: WindowPluginInitParams<'windy-external-plugin'>, { desktopUI, title, mobileUI, desktopWidth, routerPath, listenToSingleclick, addToContextmenu, url, version, }: InstalledExternalPluginConfig);
     open({ params, disableOpeningAnimation, qs, }: PluginOpeningOptions<'windy-external-plugin'>): Promise<void | boolean>;
+    hasNewerVersion(latestVersion: string): boolean;
+    showConfirmationWindow(): Promise<boolean>;
+    getDayDiff(timestamp: string): number;
+    uninstallPlugin(): Promise<void>;
     getCss(): string;
 }
 export {};

package/types/client/IDB.d.ts

@@ -1,8 +1,14 @@
 import type { Timestamp } from '@windy/types.d';
+/**
+ * List of all collections we will need in our database
+ * remember to update this list when adding new collections
+ * Collections MUST be created at once
+ */
+export declare const allUsedCollections: readonly ["customColors", "installedPlugins", "likedStoryComments", "log", "markedNotams", "popularLocations", "searchRecents2", "seenArticles", "seenPromos", "seenStories", "slidedCapAlerts", "userAlerts", "userFavs"];
 /**
  * Allowed data types for storage
  */
-export type DatabaseStore = 'userFavs' | 'userAlerts' | 'customColors' | 'searchRecents' | 'markedNotams' | 'minifests' | 'seenArticles' | 'seenPromos';
+export type DatabaseStore = (typeof allUsedCollections)[number];
 export type BackendItem<V> = {
     updated: Timestamp;
     id: string;

package/types/client/Layer.d.ts

@@ -1,13 +1,97 @@
-import type { Color } from './d.ts.files/Color';
-import type { FullRenderParameters, Layers, RenderParams, TransformFunction } from './d.ts.files/Layer.d';
-import type { Metric } from './d.ts.files/Metric';
-import type { Legend } from './d.ts.files/Metric.d';
-import type { NumberedMetric } from './d.ts.files/MetricClasses';
-import type { DataQuality, FileSuffix, Product } from './d.ts.files/Product';
-import type { Renderers } from './d.ts.files/Renderer.d';
-import type { WeatherParameters } from './d.ts.files/interfaces.d';
-import type { Levels, Products } from './d.ts.files/rootScope.d';
-import type { Timestamp } from './d.ts.files/types';
+import type { Color } from '@windy/Color';
+import type { Metric } from '@windy/Metric';
+import type { Legend } from '@windy/Metric.d';
+import type { DataQuality, FileSuffix } from '@windy/Product';
+import type { Renderers } from '@windy/Renderer';
+import type { Levels, Products } from '@windy/rootScope.d';
+import type { NumberedMetric, PrecipMetric, PtypeMetric, UVIndexMetric } from '@windy/MetricClasses';
+import type { TransformFunction } from '@windy/types';
+import type { RenderParams } from '@windy/interfaces';
+/**
+ * All available layers and their metric value type
+ */
+export interface LayerMetricType {
+    capAlerts: undefined;
+    pressureIsolines: undefined;
+    ghIsolines: undefined;
+    tempIsolines: undefined;
+    deg0Isolines: undefined;
+    windParticles: undefined;
+    ecmwfWindParticles: undefined;
+    ecmwfWindParticles150h: undefined;
+    ecmwfWindParticles500h: undefined;
+    ecmwfWindParticles600h: undefined;
+    waveParticles: undefined;
+    currentParticles: undefined;
+    currentsTideParticles: undefined;
+    wind: NumberedMetric;
+    temp: NumberedMetric;
+    wetbulbtemp: NumberedMetric;
+    solarpower: NumberedMetric;
+    uvindex: UVIndexMetric;
+    dewpoint: NumberedMetric;
+    gust: NumberedMetric;
+    gustAccu: NumberedMetric;
+    rh: NumberedMetric;
+    pressure: NumberedMetric;
+    ccl: NumberedMetric;
+    rain: PrecipMetric;
+    ptype: PtypeMetric;
+    thunder: NumberedMetric;
+    clouds: NumberedMetric;
+    lclouds: NumberedMetric;
+    mclouds: NumberedMetric;
+    hclouds: NumberedMetric;
+    cape: NumberedMetric;
+    cbase: NumberedMetric;
+    fog: NumberedMetric;
+    snowAccu: NumberedMetric;
+    rainAccu: NumberedMetric;
+    waves: NumberedMetric;
+    wwaves: NumberedMetric;
+    swell1: NumberedMetric;
+    swell2: NumberedMetric;
+    swell3: NumberedMetric;
+    swell: NumberedMetric;
+    currents: NumberedMetric;
+    currentsTide: NumberedMetric;
+    sst: NumberedMetric;
+    visibility: NumberedMetric;
+    snowcover: NumberedMetric;
+    cloudtop: NumberedMetric;
+    deg0: NumberedMetric;
+    cosc: NumberedMetric;
+    dustsm: NumberedMetric;
+    radar: NumberedMetric;
+    satellite: NumberedMetric;
+    radarPlus: NumberedMetric;
+    gtco3: NumberedMetric;
+    pm2p5: NumberedMetric;
+    no2: NumberedMetric;
+    aod550: NumberedMetric;
+    tcso2: NumberedMetric;
+    go3: NumberedMetric;
+    gh: NumberedMetric;
+    efiWind: NumberedMetric;
+    efiTemp: NumberedMetric;
+    efiRain: NumberedMetric;
+    moistureAnom40: PrecipMetric;
+    moistureAnom100: PrecipMetric;
+    drought40: NumberedMetric;
+    drought100: NumberedMetric;
+    soilMoisture40: NumberedMetric;
+    soilMoisture100: NumberedMetric;
+    fwi: NumberedMetric;
+    dfm10h: NumberedMetric;
+    turbulence: NumberedMetric;
+    icing: NumberedMetric;
+    topoMap: undefined;
+    aqi: NumberedMetric;
+}
+/**
+ * All layers available
+ */
+export type Layers = keyof LayerMetricType;
 type LayerInitParams = Pick<Layer, 'ident'> & Partial<Layer>;
 export declare class Layer<M extends Metric | undefined = Metric | undefined> {
     /**
@@ -75,7 +159,7 @@ export declare class Layer<M extends Metric | undefined = Metric | undefined> {
      */
     levels: Levels[];
     /**
-     * Optional quary string that enhances query string
+     * Optional query string that enhances query string
      */
     query?: string;
     /**
@@ -91,10 +175,6 @@ export declare class Layer<M extends Metric | undefined = Metric | undefined> {
      * 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
      */
@@ -116,21 +196,10 @@ export declare class Layer<M extends Metric | undefined = Metric | undefined> {
      * 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/client/LayerClasses.d.ts

@@ -0,0 +1,5 @@
+import { Layer } from '@windy/Layer';
+import type { NumberedMetric } from '@windy/MetricClasses';
+export declare class WaveLayer extends Layer<NumberedMetric> {
+    initProperties(): void;
+}

package/types/client/Metric.d.ts

@@ -1,7 +1,6 @@
 import type { Color } from './d.ts.files/Color';
-import type { RGBString } from './d.ts.files/Color.d';
-import type { ConvObj, Legend, LegendDescription, LegendLines, MetricIdent, MetricInitParams, MetricItem, MetricKey } from './d.ts.files/Metric.d';
-import type { HTMLString, NumValue, LoadedTranslations } from './d.ts.files/types.d';
+import type { ConvObj, Legend, LegendDescription, LegendLines, MetricIdent, MetricInitParams, MetricItem } from './d.ts.files/Metric.d';
+import type { NumValue, LoadedTranslations, RGBString } from './d.ts.files/types.d';
 export declare const rtrnSelf: (x: NumValue) => NumValue;
 /**
  * # @windy/Metric
@@ -13,26 +12,23 @@ export declare const rtrnSelf: (x: NumValue) => NumValue;
  * 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;
+    private key;
     /**
-     * Actually selected metric
+     * Keeps cohesion in between multiple metric instances. For example setting `in`
+     * in rain will set `in` in snow also
      */
-    metric: MetricItem;
+    cohesion?: {
+        [ident in MetricIdent]?: {
+            [unit in MetricItem]?: MetricItem;
+        };
+    };
     /**
      * Conversion functions
      */
     conv: ConvObj;
-    /**
-     * Backward conversion functions
-     */
-    backConv?: ConvObj;
     /**
      * number ' ' metric separator
      */
@@ -47,22 +43,25 @@ export declare abstract class Metric<T extends string | number = string | number
      */
     nativeSync: boolean;
     /**
-     * Legend description
+     * Identifies metric
      */
-    description: LegendDescription;
+    ident: MetricIdent;
+    /**
+     * Backward conversion functions
+     */
+    backConv?: ConvObj;
     /**
      * 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
+     * Actually selected metric
      */
-    cohesion?: {
-        [ident in MetricIdent]?: {
-            [unit in MetricItem]?: MetricItem;
-        };
-    };
+    metric: MetricItem;
+    /**
+     * Legend description
+     */
+    description: LegendDescription;
     /**
      * Some metrics have discrete legend.
      * If so, these labels define it, where NumValue is numerical value, to grab color from color table
@@ -81,18 +80,11 @@ export declare abstract class Metric<T extends string | number = string | number
          */
         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;
+    convertValue(value: NumValue, separator?: string, suffix?: string, forcedPrecision?: number): string;
     /**
      * Not available
      */
@@ -102,7 +94,7 @@ export declare abstract class Metric<T extends string | number = string | number
      */
     abstract convertNumber(value: NumValue, forcedPrecision?: number, metric?: MetricItem): T;
     /**
-     * List all avail metrics
+     * List all avail units
      */
     listMetrics(): MetricItem[];
     /**
@@ -112,21 +104,18 @@ export declare abstract class Metric<T extends string | number = string | number
     /**
      * Stores required metric into storage
      */
-    setMetric(metric: MetricItem, uiIdent?: string): void;
+    setMetric(metric: MetricItem, ignoreCohesion?: boolean): void;
     /**
      * Cycles throu different metrics (for example after clicking on a legend)
      */
-    cycleMetric(uiIdent?: string): void;
-    static getGradientLegend: (col: Color | undefined, legend: Legend, metric: MetricItem) => {
-        background: string;
-        content: HTMLString;
-    } | null;
+    cycleMetric(): 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;
-    renderDiscreteLegend(): {
-        background: '';
-        content: HTMLString;
-    };
     protected initProperties(): void;
-    private _createKey;
+    private onMetricChanged;
+    private getDefault;
+    private setDefault;
+    private getGradientLegend;
+    private renderDiscreteLegend;
+    private createKey;
 }