@windycom/plugin-devtools 3.0.1 → 3.0.3

package/types/client/GlProgram.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @class A wrapper class for WebGLProgram
+ *        - used for creating shader programs (compilation of shaders, linking of shader programs etc.)
+ */
+export declare class GlProgram {
+    private static numPrograms;
+    private _program;
+    /** Class instance unique id, tracks number of created instances */
+    private _programId;
+    private _programName;
+    private constructor();
+    /**
+     * @summary Resets program instance counter on plugin cleanup, used for debugging
+     */
+    static reset(): void;
+    /**
+     * @returns Unique program id
+     */
+    get programId(): number;
+    /**
+     * @summary Creates shader program from shader sources in strings (vertex and fragment shader source codes)
+     * @param vertexShaderSourceCode String with VS shader code
+     * @param fragmentShaderSourceCode String with FS shader code
+     * @param name String with program name, required for proper error reporting
+     * @returns {GlProgram} Created GlProgram instance
+     * @throws {GlError} When shader compilation fails or program linking fails
+     */
+    static constructWithSources(gl: WebGLRenderingContext, vertexShaderSourceCode: string, fragmentShaderSourceCode: string, name: string): GlProgram;
+    /**
+     * @summary Sets the program as current for rendering
+     */
+    use(gl: WebGL2RenderingContext | WebGLRenderingContext): void;
+    /**
+     * @returns {WebGLProgram} WebGLProgram handle (id)
+     */
+    getProgram(): WebGLProgram;
+    /**
+     * @summary Safely deletes the shader program including its shaders
+     */
+    destroy(gl: WebGL2RenderingContext | WebGLRenderingContext): void;
+}

package/types/client/GlRenderer.d.ts

@@ -0,0 +1,95 @@
+import { GlProgram, GlslDataType, type GlMesh } from '@windy/glUtils';
+import type { UniformDataType, UniformRecord } from '@windy/glUtils.d';
+import type { MapLibreMap as MaplibreGlMap } from '@leafletGl';
+import type { Vector4 } from '@windy/math';
+/**
+ * @class WebGL renderer abstraction class
+ *        - class the should provide simple setup and usage of WebGL renderer
+ */
+export declare class GlRenderer {
+    private ident;
+    protected static numRenderers: number;
+    /** List of meshes to be rendered by the renderer */
+    protected readonly meshes: GlMesh[];
+    /** Map of uniform variables used for rendering */
+    protected readonly uniforms: Map<string, UniformRecord>;
+    /** Set of uniform ids which values recently changed and therefore should be re-uploaded to the GPU */
+    protected readonly dirtyUniforms: Set<string>;
+    /** Textures must be treated separately since they must be bound each frame */
+    protected readonly uniformTextures: Map<string, UniformRecord>;
+    /** Program used for rendering */
+    protected program: GlProgram;
+    protected renderReady: boolean;
+    /** Color used to clear the bound framebuffer before rendering the content */
+    protected clearColor?: Vector4;
+    protected readonly rendererId: number;
+    constructor(ident: string);
+    /**
+     * @summary Resets renderer instance counter on plugin cleanup, used for debugging
+     */
+    static reset(): void;
+    /**
+     * @summary Initializes the renderer together with creating its shader program using the already fetched shader sources (strings)
+     * @param vsSrc String with source code of the Vertex Shader
+     * @param fsSrc String with source code of the Fragment Shader
+     */
+    initFromSources(gl: WebGLRenderingContext | WebGL2RenderingContext, vsSrc: string, fsSrc: string): void;
+    /**
+     * @summary Rerenders content into the currently bound framebuffer
+     * @param primitiveType Which primitives to draw (points, lines, triangles,..)
+     * @param numInstances If set >0, geometry is rendered as N instances
+     */
+    render(gl: WebGLRenderingContext | WebGL2RenderingContext, primitiveType?: GLenum, numInstances?: number): void;
+    /**
+     * @summary Updates value of the given uniform (global value sent to the GPU)
+     * @param uniformId Which uniform to update
+     * @param value New uniform value
+     */
+    updateUniformValue(uniformId: string, value: UniformDataType): void;
+    /**
+     * @summary Registers new uniform value to be used during rendering (uniform must be defined in the shader)
+     * @param uniformId Name of the uniform variable in the shader code
+     * @param dataType Data type of the uniform variable
+     * @returns {boolean} Whether the uniform was successfully registered or not
+     *  - it can fail, for example, when the passed uniformId does not match its name defined in the program
+     *      (or simply when it is not defined in the program)
+     *
+     */
+    registerUniformRecord(gl: WebGLRenderingContext | WebGL2RenderingContext, uniformId: string, dataType: GlslDataType, defaultValue?: UniformDataType): boolean;
+    /**
+     *  @summary Checks whether the uniform record is already registered (to prevent multi registering)
+     */
+    isUniformRecordRegistered(uniformId: string): boolean;
+    /**
+     * @summary Adds mesh to the list of meshes to be rendered
+     * @param mesh
+     */
+    addMesh(mesh: GlMesh): void;
+    /**
+     * @summary Retrieves shader program owned by the renderer
+     */
+    getAttachedShader(): GlProgram;
+    destroy(gl: WebGLRenderingContext | WebGL2RenderingContext, map?: MaplibreGlMap): void;
+    /**
+     * @summary Sets color used for clearing the framebuffer
+     * @param color Values in range <0.0, 1.0>, if undefined, the color is unset
+     */
+    setClearColor(color: Vector4 | undefined): void;
+    /**
+     * @summary Clears the framebuffer with previously set clear-color
+     */
+    clear(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Binds dirty uniform variables for rendering
+     *  - dirty uniform is when its value has changed and must be re-uploaded to the GPU
+     *  - when value does not change, there is no need to upload it in every frame
+     */
+    protected bindUniforms(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Binds all textures that are registered in the shader for rendering
+     *  - texture uniforms (more specifically texture units and textures) must be bound for every frame since it changes global WebGL state
+     *  - texture unit id uniform is already set by "bindUniforms" method (this does not have to be updated each frame in case the texture unit does not change)
+     *  - texture activation and binding must be preformed each frame (in case we are using multiple programs because texture binding changes global WebGL state)
+     */
+    private bindTextures;
+}

package/types/client/GlTexture.d.ts

@@ -0,0 +1,98 @@
+import type { Vector2 } from '@windy/math';
+import type { GlColorFormat } from '@windy/glUtils.d';
+/**
+ * @class A wrapper class for WebGL Texture
+ */
+export declare class GlTexture {
+    private static numTextures;
+    static reset(): void;
+    /**
+     * @summary Creates texture instance using remote image
+     * @param url Url of the image to fetch
+     */
+    static createFromUrl(gl: WebGLRenderingContext | WebGL2RenderingContext, url: string): Promise<GlTexture>;
+    /** Texture target (e.g. TEXTURE_2D) */
+    private readonly _target;
+    /** WebGL texture object */
+    private readonly _texture;
+    /** Class instance unique id, for debug, tracks number of created instances */
+    private readonly _textureId;
+    /** Texture color WebGL format */
+    private _internalFormat;
+    /** Current texture dimension (pixels) */
+    private _dimensions;
+    private _uvDownScale;
+    /** Texture uv coordinates wrapping strategy (how to handle uv coordinates out of <0.0,1.0> range) */
+    private wrap;
+    /** Texture magnification and minification filtering */
+    private filter;
+    private _usedMemory;
+    /**
+     * @param format Texture internal format (data representation, e.g. RGB, RGBA, LUMINANCE_ALPHA etc.)
+     * @param target Target - TEXTURE_2D, cubemap, array texture etc.
+     */
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, format?: GlColorFormat, target?: GLenum, fromTexture?: WebGLTexture);
+    /**
+     * @returns The original WebGL texture object handle
+     */
+    get texture(): WebGLTexture;
+    /**
+     * @returns Class instance unique identifier
+     */
+    get textureId(): number;
+    /**
+     * @returns Texture target / type (TEXTURE_2D, array texture, cubemap, etc.)
+     */
+    get target(): GLenum;
+    /**
+     * @returns {Vector2} Dimensions of the texture
+     */
+    get dimensions(): Vector2;
+    set format(format: GlColorFormat);
+    get format(): GlColorFormat;
+    get uvDownScale(): Vector2;
+    /**
+     * @summary Returns gpu memory size currently used by the texture (in bytes)
+     */
+    get usedMemory(): number;
+    /**
+     * @summary Uploads new image data into the texture
+     * @param data either HTMLImageElement or tuple of [RawData, Dimensions]
+     * @param wrap texture wrapping (clamp, repeat...)
+     * @param filter texture minification and magnification filtering (nearest, linear)
+     * @param premultiply flag, whether to premultiply RGB channels by Alpha channel before uploading data to the GPU (UNPACK_PREMULTIPLY_ALPHA_WEBGL)
+     * ToDo: mip-maps, per-coordinate wrap, per mag/min filtering
+     */
+    updateContent(gl: WebGLRenderingContext | WebGL2RenderingContext, data: HTMLImageElement | [Uint8Array, Vector2] | [Uint8ClampedArray, Vector2] | HTMLCanvasElement | ImageBitmap, wrap?: GLenum, filter?: GLenum, premultiply?: boolean): void;
+    /**
+     * @summary Binds the texture for rendering and other operations
+     * @param wrap Wrap settings, how to handle texture coordinates out of <0.0, 1.0> bounds (where to read)
+     * @param filter Texture minification and magnification filtering (nearest / interpolation)
+     */
+    bind(gl: WebGLRenderingContext | WebGL2RenderingContext, wrap?: GLenum, filter?: GLenum): void;
+    /**
+     * @summary Unbinds the texture
+     */
+    unbind(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Destructor, releases WebGL texture
+     */
+    destroy(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Resizes the texture with null data and/or sets new texture format
+     *  - the reason of performing both in one method is to ideally perform both operations using single gl.texImage2D call
+     * @param newSize Dimensions in pixels
+     * @param disableDownscale Flag that disables the resize
+     *      (since there are multiple conditions, that can lead to preventing the resize from outer scope)
+     * @param newFormat Optional new color format to be set to the texture
+     * @returns {Vector2} A rescale vector representing the factor by which the original UV coordinates should be rescaled
+     *      in case texture down-scaling is disabled {@link disableDownscale} --> in this way the UV range is constrained only to the valid area
+     */
+    resize(gl: WebGLRenderingContext | WebGL2RenderingContext, newSize: Vector2, disableDownscale?: boolean, newFormat?: GlColorFormat): Vector2;
+    /**
+     * @summary Reallocates the texture based on the new dimensions and/or new color format
+     */
+    private reallocate;
+    private setupProfiling;
+    private updateProfilingStats;
+}

package/types/client/GlVertexArray.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @class A wrapper class for WebGL VertexArrayObject (VAO)
+ */
+export declare class GlVertexArray {
+    private static vaosCount;
+    private readonly vaoId;
+    private vao;
+    /**
+     * @summary Resets vao instance counter on plugin cleanup, used for debugging
+     */
+    static reset(): void;
+    /**
+     * @summary Tries to create WebGL VertexArrayObject
+     * @returns {GlVertexArray | null} GlVertexArray instance or null,
+     *      if WebGL1 used and VAO extension (OES_vertex_array_object) is not available
+     */
+    static create(gl: WebGLRenderingContext | WebGL2RenderingContext): GlVertexArray | null;
+    /**
+     * @summary Binds the Vertex Array for rendering
+     *          - Binds proper VAO (either by WebGL2 or by WebGL1 extension)
+     */
+    bind(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Unbinds the Vertex Array
+     */
+    unbind(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Destructor - releases all WebGL resources
+     */
+    destroy(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Tries to initialize the WebGL/WebGL2 VertexArrayObject
+     * @returns {boolean} Flag whether the initialization was successful
+     *  - it can fail in case the WebGL2 is not supported and
+     *    the WebGL1 extension "OES_vertex_array_object" is not available
+     */
+    private init;
+}

package/types/client/IDB.d.ts

@@ -1,10 +1,22 @@
+import { Evented } from '@windy/Evented';
 import type { Timestamp } from '@windy/types.d';
+import type { IdbConnection } from '@windy/idbConnection';
 /**
  * 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", "searchRecents", "seenArticles", "seenPromos", "seenStories", "slidedCapAlerts", "userAlerts", "userFavs"];
+export declare const allUsedCollections: readonly ["customColors", "installedPlugins2", "likedStoryComments", "log", "markedNotams", "popularLocations", "searchRecents2", "upvotedArticles", "seenPromos", "slidedCapAlerts", "userAlerts", "userFavs"];
+interface IdbEvent {
+    _nativeSync: [{
+        storeId: DatabaseStore;
+        syncToNativeStorage: boolean;
+    }];
+}
+/**
+ * Used by nativeStorage.ts to sync IDB with native storage
+ */
+export declare const idbEmitter: Evented<IdbEvent>;
 /**
  * Allowed data types for storage
  */
@@ -15,14 +27,18 @@ export type BackendItem<V> = {
     value: V;
 };
 export type BackendPayload<V> = BackendItem<V>[];
-export type SupportedApiEndpoints = 'notams' | 'colors' | 'alerts' | 'favs';
+/**
+ * Any objecgs synced with cloud MUST have an unique id property
+ */
+export type SupportedApiEndpoints = 'notams' | 'colors' | 'alerts' | 'favs' | 'plugins';
 export type StoredObjectWithId = {
     id: string;
 };
 export interface IDBParams {
     storeId: DatabaseStore;
-    initPromise: Promise<IDBDatabase>;
+    connection: IdbConnection;
     backendApiEndpoint?: SupportedApiEndpoints;
+    syncToNativeStorage?: boolean;
 }
 /**
  * Wrapper around IndexedDB to provide async storage
@@ -33,7 +49,7 @@ export declare class IDB<K extends string | number, V, W = V> {
     private storeId;
     private memoryCache;
     private cacheIsValid;
-    private initPromise;
+    private connection;
     /**
      * Is this db synced with backend?
      *
@@ -45,6 +61,10 @@ export declare class IDB<K extends string | number, V, W = V> {
      * URL of the API endpoint, where data should be stored
      */
     private apiEndpoint;
+    /**
+     * Should this DB sync with mobile native storage
+     */
+    private syncToNativeStorage;
     /**
      * Timestamp of last db update on this device (used only when collection has userBackend)
      */
@@ -67,3 +87,4 @@ export declare class IDB<K extends string | number, V, W = V> {
      */
     loadFromCloud(): Promise<boolean>;
 }
+export {};

package/types/client/LabelsLayer.d.ts

@@ -1,2 +1,69 @@
-declare const _default: any;
-export default _default;
+import { GridLayer, LeafletGlMap, type Coords, type GridLayerOptions } from '@leafletGl';
+import type { CityDiv, CityDivId, CityLabel, CityLabelData } from './d.ts.files/LabelsLayer.d';
+import type { Products } from './d.ts.files/rootScope.d';
+import type { MetricIdent, MetricItem } from './d.ts.files/Metric.d';
+import type { CityTemperaturesDto } from '@windy-types/citytile2';
+/**
+ * Leaflet layer with city labels and temperatures
+ */
+declare class LabelsLayer extends GridLayer<CityLabelData> {
+    static defaultOptions: Required<GridLayerOptions>;
+    /** Currently selected product in client */
+    product?: Products;
+    /** Cache of leaflet tiles with labels and temperatures */
+    cityDivs: Record<CityDivId, CityDiv>;
+    /** Currently selected forecast timestamp in client */
+    ts: number;
+    /** Whether hooks are binded (true) or not (false) */
+    hasHooks: boolean;
+    forecastLoaded: boolean;
+    /** URL for getting label tiles */
+    tilesUrl?: string;
+    /** Current reftime in client */
+    refTime?: string;
+    /** Temperature unit */
+    temperatureUnit?: MetricItem;
+    constructor(options?: GridLayerOptions);
+    onAdd(leafletMap: LeafletGlMap): this;
+    onRemove(leafletMap: LeafletGlMap): this;
+    /** Creates and stores URL for fetching label tiles */
+    createTilesUrl(): void;
+    /** Update labels (e.g. when language is changed) */
+    updateLabels(): void;
+    /**
+     * Updates product name and reference time, also can fetch and update temperature data
+     * @param refreshWeather Whether fetch forecast data or not (true from store event)
+     */
+    updateProduct(refreshWeather?: boolean): Promise<void>;
+    /** Click event for labels */
+    onClick(sourceEl: HTMLElement): void;
+    /** TS change event whenever client's timestamp (progress bar) is changed */
+    onTsChange(ts: number): void;
+    /** Load new data when temperature unit is changed  */
+    onMetricChanged(ident: MetricIdent, item: MetricItem): void;
+    /** Update temp values for all tiles, e.g. when timestamp or metric is changed (it doesn't fetch new data from the server) */
+    refreshWeather(): void;
+    /** Redraw whole layer as it was first loaded */
+    _reset(): void;
+    /** Returns array of all cities in a form { id, el } */
+    toArray(): CityLabel[];
+    getCityDivs(): CityDiv[];
+    /** Fetch forecast temperature data for the tile */
+    loadTileForecast(tileDiv: CityDiv): void;
+    /** Callback when forecast data are retrieved */
+    onForecastLoaded(tileDiv: CityDiv, data: CityTemperaturesDto): void;
+    protected _loadTileData(coords: Coords, abort: AbortSignal): Promise<CityLabelData | null>;
+    protected _createTileContents(tileRoot: HTMLElement, coords: Coords, data: CityLabelData): void;
+    /**
+     * Adds DIVs with labels to the DOM, it does not fetch any data (called e.g. after retrieving labels data)
+     * It does not render temperature which is appended to this div later
+     */
+    private renderTile;
+    private getIndexToCityTileData;
+    /**
+     * Render forecast data for the tile, it does not fetch forecast data (called e.g. whenever refreshWeather is called)
+     * Enhances DIV with data-id="id" with loaded weather.
+     */
+    private renderWeather;
+}
+export default LabelsLayer;

package/types/client/Layer.d.ts

@@ -1,13 +1,98 @@
-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;
+    waveParticlesWaves: undefined;
+    currentParticles: undefined;
+    currentsTideParticles: undefined;
+    wind: NumberedMetric;
+    temp: NumberedMetric;
+    wetbulbtemp: NumberedMetric;
+    solarpower: NumberedMetric;
+    wavePower: 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;
+    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 +160,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 +176,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 +197,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;
+}