@windycom/plugin-devtools 1.0.9 → 3.0.0

package/README.md

@@ -4,6 +4,10 @@ Check out https://docs.windy-plugins.com for more information.
 
 # CHANGELOG
 
+-   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
+-   2.0.0 - TS declarations for client v42.2.0
 -   1.0.9 - Updated client TS declarations
 -   1.0.6 - Fix plugin version validation
 -   1.0.5 - Fixing .d.ts declarations

package/index.mjs

@@ -222,13 +222,13 @@ export function transformCodeToESMPlugin() {
                 : options.output ?? {};
 
             shouldGenerateSourcemaps = Boolean(outputOptions.sourcemap);
-            outputDirectory = outputOptions.file.replace(/\/[^/]+$/, '');
+            outputDirectory = outputOptions.file.replace(/[\\/][^\\/]*$/, ''); 
 
             return undefined;
         },
         renderChunk(code, chunk) {
             const { facadeModuleId } = chunk;
-            const pathOfTheFile = facadeModuleId.replace(/\/[^/]*$/, '');
+            const pathOfTheFile = facadeModuleId.replace(/[\\/][^\\/]*$/, ''); 
 
             if (!fs.existsSync(outputDirectory)) {
                 fs.mkdirSync(outputDirectory, { recursive: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@windycom/plugin-devtools",
-    "version": "1.0.9",
+    "version": "3.0.0",
     "description": "Developer tools and TS declarations for developers of Windy Plugins.",
     "main": "index.mjs",
     "module": "index.mjs",
@@ -15,7 +15,6 @@
         "eslint-import-resolver-typescript": "^3.6.1",
         "eslint-plugin-svelte": "^2.35.1",
         "less": "^4.2.0",
-        "less-plugin-autoprefixer": "^2.1.0",
         "rollup": "^4.9.6",
         "rollup-plugin-cleanup": "^3.2.1",
         "rollup-plugin-serve": "^1.1.1",
@@ -38,4 +37,4 @@
         "prettier": "^3.2.4",
         "prettier-plugin-svelte": "^3.1.2"
     }
-}
+}

package/types/client/AccessProducts.d.ts

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

package/types/client/BottomSveltePlugins.d.ts

@@ -0,0 +1,8 @@
+import { SveltePlugin } from '@windy/SveltePlugin';
+import type { SveltePluginInitParams } from '@windy/SveltePlugin';
+import type { BottomSveltePlugins } from '@windy/plugins.d';
+export type BottomSveltePluginInitParams<P extends keyof BottomSveltePlugins> = Omit<SveltePluginInitParams<P>, 'ident'> & Pick<BottomSveltePlugin<P>, 'ident'>;
+export declare class BottomSveltePlugin<P extends keyof BottomSveltePlugins> extends SveltePlugin<P> {
+    ident: P;
+    constructor(params: BottomSveltePluginInitParams<P>);
+}

package/types/client/Calendar.d.ts

@@ -4,12 +4,16 @@
 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 } from './d.ts.files/types.d';
+import type { ISODateString, Path, Timestamp, YYYYMMDDHH } from './d.ts.files/types.d';
 export type CalendarInitParams = Pick<Calendar, 'numOfHours' | 'minifestFile'> & {
     /**
      * Ident of product that this calendar is for
      */
     product: Products;
+    /**
+     * This product is a free product
+     */
+    freeProduct?: boolean;
     /**
      * Optional latest timestamp (for use for offline mode for example)
      */
@@ -25,10 +29,6 @@ export declare class Calendar {
      * Number of hours covered by this calendar
      */
     numOfHours: number;
-    /**
-     * Type of the calendare
-     */
-    type: 'historical' | 'mixed' | 'forecast';
     calendarHours: number;
     /**
      * Today midnigh in LT of user's computer
@@ -47,21 +47,13 @@ export declare class Calendar {
      */
     premiumStart: Timestamp | null;
     /**
-     * End of calendar timeline
-     */
-    endOfcalendar: Date;
-    /**
-     * endOfcalendar as timestamp
+     * endOfCalendar as timestamp
      */
     endOfCal: Timestamp;
     /**
      * endOfCal or latest timestamp, whiever is smaller
      */
     end: Timestamp;
-    /**
-     * Max timestamp value, usually same as end (should be updated later on basis of minifest)
-     */
-    maxTimestamp: Timestamp;
     /**
      * Array of calendayr days to be used in UI
      */
@@ -85,7 +77,7 @@ export declare class Calendar {
     /**
      * Minifests's reference time is some non stndard format
      */
-    refTime: string;
+    refTime: YYYYMMDDHH;
     /**
      * Minifests's reference time
      */
@@ -125,7 +117,7 @@ export declare class Calendar {
      * Return YYYY/MM/DD/HH or YYYYMMDDHH on a basis of provided date
      * we do not CHECK existence of path in minifest
      */
-    static date2path(date: Date): Path;
+    static date2path(date: Date): YYYYMMDDHH;
     /**
      * Returns JavaScript date object corresponding
      * to provided path in a form YYYY/MM/DD/HH or YYYYMMDDHH
@@ -145,5 +137,5 @@ export declare class Calendar {
     /**
      * Return nearest midnight
      */
-    static getMidnight(): Date;
+    static getMidnight(ts?: number): Date;
 }

package/types/client/Color.d.ts

@@ -1,106 +1,65 @@
-import type { ColorGradient, ColorIdent, PluginColorIdent, RGBA, RGBString } from './d.ts.files/Color.d';
-import type { StoreOptions } from './d.ts.files/store.d';
+import type { ColorGradient, AnyColorIdent, RGBA, RGBString } from './d.ts.files/Color.d';
 import type { NumValue } from './d.ts.files/types.d';
-export type ColorInitParams = Pick<Color, 'ident'> & Partial<Pick<Color, 'qualitative' | 'save'>> & {
+export type ColorInitParams = Pick<Color, 'ident'> & Partial<Pick<Color, 'qualitative'>> & {
     steps: number;
-    default?: ColorGradient | null;
+    default: ColorGradient;
     opaque?: boolean;
-    defaultKey?: string;
-    sync?: boolean;
     prepare?: boolean;
 };
 export declare class Color {
     /**
      * Should be color table prepared in advance without calling getColor()
-     * DO NOT MISUSE THIS PROPERTY. Use only for few colors that are used
-     * for initial rendering and overall app
+     *
+     * DO NOT MISUSE THIS PROPERTY, generating color gradients is expensive
+     * CPU operation and should be done only when needed
+     *
+     * Use only for few colors that are used
+     * for initial rendering and overall app, like temp, wind
      */
     private prepare?;
-    /**
-     * Sync color to the cloud.  By default is set true
-     */
-    private sync?;
-    /**
-     * set all alpha values to 255.  By default is set true
-     */
+    /** Set all alpha values to 255.  By default is set true */
     private opaque?;
+    /** Items precomputed for fast color access */
     private maxIndex;
+    /** Items precomputed for fast color access */
     private step;
-    /**
-     * Index of neutral gray color
-     */
+    /** Index of neutral gray color */
     private neutralGrayIndex;
-    /**
-     * Initial gradient
-     */
-    private default?;
-    /**
-     * Ident of color
-     */
-    ident: ColorIdent | PluginColorIdent | 'pressureIsolines' | 'temporary' | 'direction';
-    /**
-     * Store key
-     */
-    key: `color2_${string}`;
-    /**
-     * For color loaded from info,json
-     */
-    defaultKey?: string;
-    /**
-     * globe: use discrete palette (not blending between colors)
-     */
-    qualitative?: boolean;
-    /**
-     * Numebr of steps for colors table
-     */
-    steps: number;
-    /**
-     * Actually used gradient (can be sifferent than default)
-     */
-    gradient: ColorGradient;
-    /**
-     * Big interpolated RGBA Type array color table
-     * If defined mean someone already used the color
-     */
-    colors?: Uint8Array | null;
-    /**
-     * Save color to lcal storage. By default is set true
-     */
-    save?: boolean;
-    /**
-     * Min value
-     */
+    /** Initial gradient */
+    private defaultColorGradient;
+    /** Custom modified gradient */
+    private customColorGradient?;
+    /** Big interpolated RGBA Type array color table, generated when color is required */
+    private colors?;
+    /** Min value of associated numerical value  */
     min: NumValue;
-    /**
-     * Max value
-     */
+    /** Max value  of associated numerical value  */
     max: NumValue;
+    /** Ident of color */
+    ident: AnyColorIdent;
+    /** globe: use discrete palette (not blending between colors) */
+    qualitative?: boolean;
+    /** Number of steps for colors table */
+    steps: number;
     constructor(params: ColorInitParams);
+    getColorTable(): Uint8Array;
+    loadCustomColor(): Promise<void>;
+    hasCustomColor(): boolean;
     /**
-     * Inserts the color to the store & prepares it
-     *
-     * @param defaultColors Default color
-     */
-    defineColor(defaultColors: ColorGradient): void;
-    /**
-     * Saves new color gradient to data store
+     * Updates custom color gradient
      */
-    changeColor(gradient: ColorGradient, storeOpts?: StoreOptions): void;
+    setCustomColor(gradient: ColorGradient, saveToIdb?: boolean): Promise<void>;
     /**
-     * Back to default settings
+     * Removes custom color gradient
      */
-    toDefault(): void;
-    /**
-     * Same as getColor, but forces to generate new col tables
-     */
-    forceGetColor(): this;
+    removeCustomColor(): Promise<void>;
     /**
      * Returns a color based 'rgb()' string on provided value
      */
     color(value: NumValue): RGBString;
     /**
-     * Returns darkened or lightened cersion of original color. Uses the
-     * most primitive method of darkening/lightening by substracting or
+     * Returns darkened or lightened coercion of original color. Uses the
+     * most primitive method of darkening/lightening by subtracting or
      * adding vale to RGB components
      *
      * @param value Original numerical value
@@ -119,28 +78,19 @@ export declare class Color {
      * return .. output Uint8Array with color data
      */
     createGradientArray(bOpaque?: boolean, bPremultiply?: boolean, valueScale?: number): Uint8Array;
-    createSteppedArray(sourceSmoothArray: Uint8Array, step: number, firstStep?: number): Uint8Array;
     /**
-     * Returns color instance and creates color table (if not yet created)
+     * Generates gradient array for fast access to color table
      */
     getColor(): this;
     /**
      * Returns index to the color table based on value
      */
     value2index(value: NumValue): number;
-    getColorTable(): ColorGradient | null | undefined;
+    getColorGradient(): ColorGradient;
     /**
      * Checks validity of a gradient that it adheres to type ColorGradient
      */
-    private checkValidity;
-    /**
-     * Forces to generate new color table
-     */
-    private colorChanged;
-    /**
-     * Sets max, min values
-     */
-    private setMinMax;
+    static checkValidity(obj: unknown): boolean;
     /**
      * return array multiplied by mul coef
      */
@@ -161,7 +111,6 @@ export declare class Color {
      * preserveSaturation .. (maintain |UV| size)
      */
     private gradYuva;
-    private vec2size;
     /**
      * interpolation between 2 colors in selected space (type)
      * type .. color space / interpolation type: 'RGB' - linear in RGB space (default)
@@ -172,4 +121,8 @@ export declare class Color {
      * rgbaArray .. [r, g, b, a]; componnents in interval <0;255>
      */
     private makePremultiplied;
+    /**
+     * If color table was already generated, we need to regenerate it
+     */
+    private regenerateColorTable;
 }

package/types/client/Drag.d.ts

@@ -1,8 +1,15 @@
 /**
- * Drag: Basic draggable Class
+ * # @windy/Drag
+ *
+ * module contains Class that makes elements draggable
  *
  * @module Drag
  */
+/**
+ * Makes elements in GUI draggable
+ *
+ * @class Drag
+ */
 export type DragInitParams = Pick<Drag, 'el'> & {
     supportTouch?: boolean;
     preventDefault?: boolean;

package/types/client/Evented.d.ts

@@ -71,6 +71,10 @@ export declare class Evented<T> {
     once<K extends keyof T, Q extends T[K]>(topic: K, callback: (...data: TrimUndefinedFromRight<Arrayify<Q>>) => void, context?: ThisType<unknown>): number;
     off(id: number): void;
     off<K extends keyof T, Q extends T[K]>(topic: K, callback: (...data: TrimUndefinedFromRight<Arrayify<Q>>) => void, context?: ThisType<unknown>): void;
+    /**
+     * Unhooks all registered callbacks
+     */
+    offAll(): void;
     /**
      * @ignore
      */

package/types/client/ExternalSveltePlugin.d.ts

@@ -1,7 +1,7 @@
 import { SveltePlugin, type ExternalSvelteApp } from '@windy/SveltePlugin';
 import type { WindowPluginInitParams } from '@windy/WindowPlugin';
 import type { SveltePanePlugins, SveltePlugins } from '@windy/plugins.d';
-import type { CompiledExternalPluginConfig, ExternalPluginConfig, InstalledExternalPluginConfig } from '@windy/interfaces';
+import type { CompiledExternalPluginConfig, ExternalPluginConfig, InstalledExternalPluginConfig, PluginOpeningOptions } from '@windy/interfaces';
 import type { PluginPane } from './Plugin';
 /** Allowed params to SveltePlugin constructor (private and protected props are omitted by default) */
 export type ExternalSveltePluginInitParams<P extends keyof SveltePlugins | keyof SveltePanePlugins> = Omit<WindowPluginInitParams<P>, 'ident'> & Pick<SveltePlugin<P>, 'ident'> & Partial<SveltePlugin<P>>;
@@ -25,6 +25,7 @@ export declare class ExternalSveltePlugin extends SveltePlugin<'windy-external-p
     listenToSingleclick: ExternalPluginConfig['listenToSingleclick'];
     addToContextmenu: ExternalPluginConfig['addToContextmenu'];
     constructor(params: WindowPluginInitParams<'windy-external-plugin'>, { desktopUI, title, mobileUI, desktopWidth, routerPath, listenToSingleclick, addToContextmenu, url, }: InstalledExternalPluginConfig);
+    open({ params, disableOpeningAnimation, qs, }: PluginOpeningOptions<'windy-external-plugin'>): Promise<void | boolean>;
     getCss(): string;
 }
 export {};

package/types/client/IDB.d.ts

@@ -0,0 +1,63 @@
+import type { Timestamp } from '@windy/types.d';
+/**
+ * Allowed data types for storage
+ */
+export type DatabaseStore = 'userFavs' | 'userAlerts' | 'customColors' | 'searchRecents' | 'markedNotams' | 'minifests' | 'seenArticles' | 'seenPromos';
+export type BackendItem<V> = {
+    updated: Timestamp;
+    id: string;
+    value: V;
+};
+export type BackendPayload<V> = BackendItem<V>[];
+export type SupportedApiEndpoints = 'notams' | 'colors' | 'alerts' | 'favs';
+export type StoredObjectWithId = {
+    id: string;
+};
+export interface IDBParams {
+    storeId: DatabaseStore;
+    initPromise: Promise<IDBDatabase>;
+    backendApiEndpoint?: SupportedApiEndpoints;
+}
+/**
+ * Wrapper around IndexedDB to provide async storage
+ *
+ * Synchronization with backend database is also supported
+ */
+export declare class IDB<K extends string | number, V, W = V> {
+    private storeId;
+    private memoryCache;
+    private cacheIsValid;
+    private initPromise;
+    /**
+     * Is this db synced with backend?
+     *
+     * Storing to user backend is possible only for registered and properly logged in users
+     * The check if user is logged in, must be dome outside of this class, preferably in GUI
+     */
+    private usesBackendSync;
+    /**
+     * URL of the API endpoint, where data should be stored
+     */
+    private apiEndpoint;
+    /**
+     * Timestamp of last db update on this device (used only when collection has userBackend)
+     */
+    private readonly lastTimeUpdatedKey;
+    constructor(params: IDBParams);
+    /** Returns all items form IDB as an array */
+    getAll(): Promise<V[]>;
+    removeAll(): Promise<void>;
+    hasKey(key: K): Promise<boolean>;
+    get(key: K | '__lastTimeUpdated'): Promise<V | null>;
+    remove(key: K, removeJustLocally?: boolean): Promise<void>;
+    /**
+     * Creates data on the backend and uses the received `id` to save it locally.
+     * Only use this method for items not created by {@link put} to avoid key mismatch!
+     */
+    add(data: W): Promise<string>;
+    put(key: K | '__lastTimeUpdated', data: V, insertJustLocally?: boolean): Promise<void>;
+    /**
+     * Loads data from the cloud and returns true if there was a change
+     */
+    loadFromCloud(): Promise<boolean>;
+}

package/types/client/IconProducts.d.ts

@@ -1,5 +1,7 @@
 import { Product } from '@windy/Product';
+import type { Overlays } from '@windy/rootScope.d';
 import type { ProductInitParams } from './Product';
+export declare const iconOverlays: Overlays[];
 export declare class IconProducts extends Product {
     constructor(params: Pick<ProductInitParams, 'modelName'> & Partial<ProductInitParams>);
 }

package/types/client/Layer.d.ts

@@ -3,8 +3,7 @@ import type { FullRenderParameters, Layers, RenderParams, TransformFunction } fr
 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 { Product } from './d.ts.files/Product';
-import type { DataQuality, FileSuffix } from './d.ts.files/Product.d';
+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';

package/types/client/Metric.d.ts

@@ -1,8 +1,7 @@
 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 { LoadedTranslations } from './d.ts.files/trans.d';
-import type { HTMLString, NumValue } from './d.ts.files/types.d';
+import type { HTMLString, NumValue, LoadedTranslations } from './d.ts.files/types.d';
 export declare const rtrnSelf: (x: NumValue) => NumValue;
 /**
  * # @windy/Metric
@@ -30,6 +29,10 @@ export declare abstract class Metric<T extends string | number = string | number
      * Conversion functions
      */
     conv: ConvObj;
+    /**
+     * Backward conversion functions
+     */
+    backConv?: ConvObj;
     /**
      * number ' ' metric separator
      */
@@ -114,15 +117,12 @@ export declare abstract class Metric<T extends string | number = string | number
      * 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): {
+    static getGradientLegend: (col: Color | undefined, legend: Legend, metric: MetricItem) => {
         background: string;
         content: HTMLString;
     } | null;
+    /** 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;

package/types/client/MetricClasses.d.ts

@@ -1,11 +1,12 @@
 import { Metric } from '@windy/Metric';
 import type { MetricItem, MetricInitParams } from '@windy/Metric.d';
-import type { NumValue } from '@windy/types.d';
+import type { NumValue } from '@windy/types';
 export declare class NumberedMetric extends Metric<number> {
     /**
      * produces converted number value without label
+     *  - in case the @param back is set to true, inverse conversion is performed
      */
-    convertNumber(value: NumValue, forcedPrecision?: number, metric?: MetricItem): number;
+    convertNumber(value: NumValue, forcedPrecision?: number, metric?: MetricItem, back?: boolean): number;
 }
 export declare class CapAlertMetric extends Metric<number> {
     /**
@@ -30,7 +31,7 @@ export declare class SatelliteMetric extends NumberedMetric {
      * Dynamic update from minifest/info.json
      * @param pars various pars depending on concrete instance
      */
-    updateLines(pars: [number, number]): void;
+    updateLines(pars: [number, number], radarEnabled?: boolean): void;
 }
 export declare class PrecipMetric extends NumberedMetric {
     initProperties(): void;

package/types/client/Overlay.d.ts

@@ -5,13 +5,13 @@ import type { DirectionFunction } from '@windy/format.d';
 import type { Iconfont } from '@windy/iconfont.d';
 import type { Overlays } from '@windy/rootScope.d';
 import type { RGBNumValues } from '@windy/interpolatorTypes';
-import type { LoadedTranslations } from '@windy/trans.d';
-import type { HTMLString } from '@windy/types';
-export type UsedOverlays = Overlays | 'gh' | 'swell' | 'satelliteIRBT';
+import type { LoadedTranslations, HTMLString } from '@windy/types';
+import type { RGBAString } from '@windy/Color.d';
+export type UsedOverlays = Overlays | 'swell' | 'satelliteIRBT';
 export type OverlayInitParams = Pick<Overlay, 'ident'> & Partial<Overlay>;
 type LayerProperty<L extends Layer | undefined, P extends keyof Layer> = L extends Layer ? L[P] : undefined;
 type MetricProperty<M extends Metric | undefined, P extends keyof Metric> = M extends Metric ? M[P] : undefined;
-export declare class Overlay<I extends Overlays | 'gh' = Overlays | 'gh', M extends I extends Layers ? LayerMetricType[I] : undefined = I extends Layers ? LayerMetricType[I] : undefined, L extends Layer<M> | undefined = I extends Layers ? Layer<M> : undefined> {
+export declare class Overlay<I extends Overlays = Overlays, M extends I extends Layers ? LayerMetricType[I] : undefined = I extends Layers ? LayerMetricType[I] : undefined, L extends Layer<M> | undefined = I extends Layers ? Layer<M> : undefined> {
     /**
      * Main ident
      */
@@ -53,6 +53,10 @@ export declare class Overlay<I extends Overlays | 'gh' = Overlays | 'gh', M exte
      * Hide interpolated weather value over cities, when user switches to POI cities
      */
     hideWxLabels?: boolean;
+    /**
+     * Hide elevation in the desktop picker
+     */
+    hidePickerElevation?: boolean;
     /**
      * Eg. in day-switcher we need as short name as possible
      */
@@ -74,7 +78,7 @@ export declare class Overlay<I extends Overlays | 'gh' = Overlays | 'gh', M exte
      */
     partOf?: Overlays;
     /**
-     * Applies class 'hide-particles' to the body
+     * Hides particle on/off switch in GUI (so far used only in desktop GUI)
      */
     hideParticles?: boolean;
     /**
@@ -100,7 +104,24 @@ export declare class Overlay<I extends Overlays | 'gh' = Overlays | 'gh', M exte
     c: LayerProperty<L, 'c'>;
     l: LayerProperty<L, 'l'>;
     cm: LayerProperty<L, 'cm'>;
+    /**
+     * Do not display this overlay in URL
+     */
+    hideFromURL?: boolean;
+    /**
+     * Optional promo badge to be displayed in GUI
+     */
+    promoBadge?: string;
+    promoBadgeColor?: RGBAString;
+    /**
+     * Optional menu image thumbnail
+     */
+    menuImage?: string;
     constructor(params: OverlayInitParams);
+    /**
+     * When clicking on overlay in menu, do the following action (ready to be overloaded)
+     */
+    onClick(): void;
     /**
      * Render's overlay's legend inside  el
      */
@@ -111,6 +132,10 @@ export declare class Overlay<I extends Overlays | 'gh' = Overlays | 'gh', M exte
      * @param short If true, return shortened version of description if avail
      */
     getName(short?: boolean): string;
+    /**
+     * Return URL of image for overlay
+     */
+    getMenuImagePath(): string;
     /**
      * Get menu title
      *
@@ -131,16 +156,6 @@ export declare class Overlay<I extends Overlays | 'gh' = Overlays | 'gh', M exte
      * @param values Interpolated values
      */
     createPickerHTML(values: RGBNumValues, _directionFormattingFunction: DirectionFunction): HTMLString;
-    /**
-     * In case of picker interpolator returns null value, this method is called
-     * (is consumed by PickerMobile only so far)
-     */
-    createPickerInvalidHTML(): HTMLString;
-    /**
-     * Create title for picker content
-     * @param alternativeContent Alternative text inside title
-     */
-    createPickerTitle(alternativeContent?: string): HTMLString;
     /**
      * Just proxy to the Metric's metric property
      */

package/types/client/OverlayClasses.d.ts

@@ -2,28 +2,32 @@ import { Overlay } from '@windy/Overlay';
 import type { DirectionFunction } from '@windy/format.d';
 import type { Overlays } from '@windy/rootScope.d';
 import type { RGBNumValues } from '@windy/interpolatorTypes';
-import type { LoadedTranslations } from '@windy/trans.d';
-export declare class CurrentOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+import type { LoadedTranslations } from '@windy/types';
+export declare class CurrentOverlay<I extends Overlays = Overlays> extends Overlay<I> {
+    hidePickerElevation: boolean;
     createPickerHTML(values: RGBNumValues, formatDir: DirectionFunction): string;
 }
-export declare class WaveOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+export declare class WaveOverlay<I extends Overlays = Overlays> extends Overlay<I> {
+    hidePickerElevation: boolean;
     createPickerHTML(values: RGBNumValues, formatDir: DirectionFunction): string;
 }
-export declare class AwpOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+export declare class AwpOverlay<I extends Overlays = Overlays> extends Overlay<I> {
     labels: {
         [value: number]: keyof LoadedTranslations;
     };
     createPickerHTML(values: RGBNumValues): string;
 }
-export declare class FwiOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+export declare class FwiOverlay<I extends Overlays = Overlays> extends Overlay<I> {
     labels: {
         [value: number]: keyof LoadedTranslations;
     };
     createPickerHTML(values: RGBNumValues): string;
 }
-export declare class RainPtypeOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+export declare class RainPtypeOverlay<I extends Overlays = Overlays> extends Overlay<I> {
+    hidePickerElevation: boolean;
     createPickerHTML(values: RGBNumValues): string;
 }
-export declare class CloudsOverlay<I extends Overlays | 'gh' = Overlays | 'gh'> extends Overlay<I> {
+export declare class CloudsOverlay<I extends Overlays = Overlays> extends Overlay<I> {
+    hidePickerElevation: boolean;
     createPickerHTML(values: RGBNumValues): string;
 }