@windycom/plugin-devtools 3.0.1 → 3.0.3

package/README.md

@@ -4,6 +4,7 @@ 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

package/package.json

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

package/types/client/Calendar.d.ts

@@ -1,139 +1,173 @@
+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 one letter/symbol abbreviation
      */
-    startOfTimeline: Date;
+    displayShort: keyof LoadedTranslations;
     /**
-     * startOfTimeline in the form of timestamp
+     * Translation ID for week day abbreviation
      */
-    start: Timestamp;
+    display: keyof LoadedTranslations;
     /**
-     * startOfPremiumTimeline in the form of timestamp; null if it is free in whole range
+     * Translation ID for week day abbreviation
      */
-    premiumStart: Timestamp | null;
+    displayLong: keyof LoadedTranslations;
     /**
-     * endOfCalendar as timestamp
+     * Start of the day
      */
-    endOfCal: Timestamp;
+    start: Timestamp;
     /**
-     * endOfCal or latest timestamp, whiever is smaller
+     * End of the day
      */
     end: Timestamp;
     /**
-     * Array of calendayr days to be used in UI
+     * Midday of the day
      */
-    days: CalendarDay[];
+    middayTs: Timestamp;
     /**
-     * Array of timestamps that contain valid forecast
+     * Day of the month
      */
-    timestamps: Timestamp[];
+    day: number;
     /**
-     * Array of URL paths that equal to timestamps in a form of "2021/05/27/19"
+     * Forecast for this day is for Premium users only
      */
-    paths: string[];
+    premium: boolean;
+    /**
+     * Forecast for this day is available
+     */
+    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,10 +1,22 @@
-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' | 'fog' | 'justGray' | 'efiWind' | 'efiTemp' | 'efiRain' | 'moistureAnom40' | 'moistureAnom100' | 'drought' | 'soilMoisture' | 'fwi' | 'dfm10h' | 'solarpower' | 'wavePower' | 'uvindex' | 'turbulence' | 'icing' | 'wetbulbtemp' | 'aqi' | 'dewpoint';
+export type PluginColorIdent = 'windDetail' | 'wavesDetail' | 'periodDetail' | 'altitudeDetail' | 'visibilityDetail' | 'dewpointSpreadDetail' | 'blitz' | 'radiation' | 'pmDetail' | 'dustDetail' | 'coscDetail' | 'no2Detail' | 'pollenDetail' | 'so2Detail' | 'aqiGradientDetail' | 'wavePowerDetail';
+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;
+    /**
+     * Min and max gradient value override
+     *  - used for gradients with constant min and max values
+     *  - e.g. radar with [0,256] in all cases (gradient is not resized based on the current gradient extents)
+     */
+    minMaxValue?: [NumValue, NumValue];
 };
 export declare class Color {
     /**
@@ -26,9 +38,12 @@ 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?;
+    private minMaxValue?;
     /** Big interpolated RGBA Type array color table, generated when color is required */
     private colors?;
     /** Min value of associated numerical value  */
@@ -91,6 +106,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,6 +1,6 @@
 import { dataLoader } from '@windy/dataLoader';
-import type { FullRenderParameters } from './d.ts.files/Layer.d';
-import type { DataTile } from './d.ts.files/dataLoader';
+import type { FullRenderParameters } from '@windy/interfaces';
+import type { DataTile } from '@windy/dataLoader';
 import type { ExtendedTileParams } from './DataTiler.d';
 export interface TilePoint {
     x: number;

package/types/client/EcmwfProduct.d.ts

@@ -1,7 +1,29 @@
 import { Calendar } from '@windy/Calendar';
 import { Product } from '@windy/Product';
 import type { ProductInitParams } from '@windy/Product';
+/**
+ * Common product params for ECMWF products.
+ */
+export declare const EcmwfProductParams: {
+    modelName: string;
+    modelResolution: number;
+    provider: string;
+    interval: number;
+    intervalPremium: number;
+    maxTileZoom: {
+        free: number;
+        premium: number;
+    };
+    dataQuality: "normal";
+};
 export declare class EcmwfProduct extends Product {
     calendar: Calendar;
     constructor(params: Partial<ProductInitParams>);
+    /**
+     * Create fake minifest file for ECMWF product to use it during rendering of
+     * UI before real minifest is loaded.
+     *
+     * DO NOT TRY TO USE THIS CALENDAR FOR FETCHING DATA FROM SERVER!!!!
+     */
+    static createVirtualCalendar(this: EcmwfProduct): Calendar;
 }

package/types/client/EventManager.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="svelte" />
+import store from '@windy/store';
+import type { StoreTypes } from '@windy/store.d';
+import type { Evented as MaplibreEvented, Listener, MapEventType, MapLayerEventType, LeafletEventHandlerFn } from '@leafletGl';
+import type { Evented } from '@windy/Evented';
+import type { BcastTypes } from '@windy/broadcast.d';
+import type { Plugins } from '@windy/plugins.d';
+import type { Readable, Subscriber } from 'svelte/store';
+type MapLibreEventTypes = MapLayerEventType | MapEventType | string;
+type BcastEventTypes = keyof BcastTypes<keyof Plugins>;
+/**
+ * @class A class for managing event listeners
+ *  - used to safely bind AND unbind listeners by storing callback references
+ */
+export declare class EventManager {
+    private DOMCallbacks;
+    private MapLibreCallbacks;
+    private storeCallbacks;
+    private eventedCallbacks;
+    private broadcastCallbacks;
+    private mapCallbacks;
+    private unsubscribers;
+    /**
+     * @summary Registers specific event listener on a given DOM target with a given callback
+     * @param target    - target to listen on
+     * @param topic     - which event to listen for
+     * @param callback  - callback function that should process the event
+     */
+    addDOMListener<T extends EventTarget>(target: T, topic: Parameters<T['addEventListener']>[0], callback: Parameters<T['addEventListener']>[1]): void;
+    /**
+     * @summary Registers specific event listener on a given MapLibre target with a given callback
+     * @param target    - target to listen on
+     * @param topic     - which event to listen for
+     * @param callback  - callback function that should process the event
+     */
+    addMapLibreListener<T extends MapLibreEventTypes>(target: MaplibreEvented, topic: T, callback: Listener): void;
+    /**
+     * @summary Registers specific event listener on windy store with a given callback
+     * @param topic     - which event to listen for
+     * @param callback  - callback function that should process the event
+     */
+    addStoreListener<T extends keyof StoreTypes>(topic: T, callback: Parameters<(typeof store)['on']>[1]): void;
+    /**
+     * @summary Registers specific event listener on a given windy/evented target with a given callback
+     * @param target    - target to listen on
+     * @param topic     - which event to listen for
+     * @param callback  - callback function that should process the event
+     */
+    addEventedListener<T>(target: Evented<T>, topic: keyof T, callback: (typeof this.eventedCallbacks)[string][number]['ref']): void;
+    /**
+     * @summary Registers specific event listener on windy broadcast with a given callback
+     * @param topic     - which event to listen for
+     * @param callback  - callback function that should process the event
+     */
+    addBroadcastListener(topic: BcastEventTypes, callback: (typeof this.broadcastCallbacks)[string][number]['ref']): void;
+    addMapListener(topic: string, callback: LeafletEventHandlerFn): void;
+    addSvelteStoreListener<T>(svelteStore: Readable<T>, callback: Subscriber<T>, onlyOnChange?: boolean): void;
+    /**
+     * Subscribe to DOM mutations using MutationObserver
+     *
+     * See https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+     */
+    addMutationObserverListener(target: Node, options: MutationObserverInit, callback: MutationCallback): void;
+    /**
+     * @summary Cleanup method to remove (unregister) all registered listeners
+     */
+    removeListeners(): void;
+}
+export {};

package/types/client/ExternalSveltePlugin.d.ts

@@ -2,7 +2,8 @@ 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, PluginOpeningOptions } from '@windy/interfaces';
-import type { PluginPane } from './Plugin';
+import type { PluginPane } from '@windy/Plugin';
+import type { SemVersion } from '@windy/types';
 /** 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>>;
 export type LoadeExternalSveltePlugin = {
@@ -22,12 +23,12 @@ export declare class ExternalSveltePlugin extends SveltePlugin<'windy-external-p
     mobileConfig: Record<InstalledExternalPluginConfig['mobileUI'], Config2config>;
     desktopConfig: Record<InstalledExternalPluginConfig['desktopUI'], Config2config>;
     widthOfRhPane: number;
-    version: string;
+    version: SemVersion;
     listenToSingleclick: ExternalPluginConfig['listenToSingleclick'];
     addToContextmenu: ExternalPluginConfig['addToContextmenu'];
     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;
+    hasNewerVersion(latestVersion: SemVersion): boolean;
     showConfirmationWindow(): Promise<boolean>;
     getDayDiff(timestamp: string): number;
     uninstallPlugin(): Promise<void>;

package/types/client/GlBuffer.d.ts

@@ -0,0 +1,45 @@
+import type { TypedArray } from '@windy/glUtils.d';
+export declare enum GlBufferType {
+    VERTEX,
+    INDEX
+}
+export declare enum GlBufferUsage {
+    STATIC,
+    DYNAMIC
+}
+/**
+ * @class A wrapper class over WebGLBuffer
+ */
+export declare class GlBuffer {
+    private static idCounter;
+    /** Reference to the WebGL buffer on the GPU */
+    protected readonly buffer: WebGLBuffer;
+    protected type: GlBufferType;
+    /** Length of uploaded data array in the buffer */
+    protected _dataLength: number;
+    /** Class instance unique id, for debug, tracks number of created instances */
+    protected readonly bufferId: number;
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, type: GlBufferType);
+    /**
+     * @summary Resets buffer instance counter on plugin cleanup, used for debugging
+     */
+    static reset(): void;
+    /**
+     * @summary Binds buffer for subsequent operations
+     */
+    bind(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Unbinds the buffer
+     */
+    unbind(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Updates data in the GPU buffer
+     * @param data Data to be uploaded to the GPU buffer
+     * @param usage Buffer update frequency (how the buffer will be updated)
+     */
+    update(gl: WebGLRenderingContext | WebGL2RenderingContext, data: TypedArray, usage?: GlBufferUsage): void;
+    /** @summary Returns number of elements inside the buffer */
+    get length(): number;
+    /** @summary Deletes the WebGL buffer */
+    destroy(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+}

package/types/client/GlMesh.d.ts

@@ -0,0 +1,147 @@
+import type { TypedArray } from '@windy/glUtils.d';
+import type { GlProgram } from '@windy/GlProgram';
+/**
+ * @class A class that represents abstraction of a renderable logical geometry chunk
+ *          - (geometry with the same properties, requiring same rendering approach)
+ */
+export declare class GlMesh {
+    private static numMeshes;
+    /**
+     * Array of vertex streams (Vertex Buffer Objects) used for rendering the mesh
+     *  - GPU buffer references | Key-value map in the future (multiple geometry buffers)
+     */
+    private readonly vbos;
+    /** Size of the GPU buffer | Key-value map in the future (multiple geometry buffers) */
+    private vertexCount;
+    /**
+     * Array of vertex attributes mapping
+     *  - one map for each vertex stream, since every stream has at least one attribute defined by layout index and size
+     *  - maps attributes bound to the given GPU buffer (VBO)
+     */
+    private readonly attributes;
+    /**
+     * Size of all attributes for one vertex in the given vertex stream
+     *  e.g. one vertex has Vec3 position, Vec2 uv, and Vec3 color --> stride is 3+2+3 = 8 bytes
+     * */
+    private readonly buffersStride;
+    /** Element Buffer Object for storing vertex indices for indexed rendering */
+    private ebo?;
+    /**
+     * Map of Vertex Array Objects
+     *  VAO - represents binding of geometry layout with a given shader program
+     *  - one VAO is for given GlProgram (not per vertex stream)
+     *  - one VAO handles binding of all vertex streams, but for every GlProgram, new VAO should be created since each shader can have different layout
+     */
+    private readonly vaos;
+    private readonly meshId;
+    private instanceBuffer?;
+    private instanceAttributes?;
+    private instanceBufferStride;
+    private instancingInitialized;
+    private drawElementsCall;
+    private drawArraysCall;
+    private vertexDivisorCall;
+    /**
+     * @param vertexData Default vertex stream data (can be interleaved - defined by layout)
+     * @param indexData Optional index buffer data (in case of indexed data rendering)
+     * @param dynamic Signals, whether the geometry will be updated frequently or is static
+     */
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, vertexData: Float32Array, indexData?: Uint16Array, dynamic?: boolean);
+    /**
+     * @summary Resets mesh instance counter on plugin cleanup, used for debugging
+     */
+    static reset(): void;
+    /**
+     * @summary Performs draw call of the mesh w.r.t. current state defined by VAO / attributes layout + given shader program
+     *          - WARNING: this call assumes, that GlProgram.use() / gl.useProgram(programId) was already called!
+     *          - automatically performs the appropriate call -> instanced/non-instanced + indexed/non-indexed - all based on the state given by the supplied data
+     * @param program Shader program used to identify the render/geometry state
+     * @param primType Which primitives to draw with the vertex data
+     * @param offset Offset in the geometry buffer (defaults to 0)
+     * @param count Number of vertices / elements to draw from the buffer (defaults to full size of the geometry)
+     * @param numInstances When instanced rendering used, signals, how many instances to draw
+     */
+    render(gl: WebGLRenderingContext | WebGL2RenderingContext, program: GlProgram, primitiveType?: GLenum, numInstances?: number): void;
+    /**
+     * @summary Creates new geometry layout binding / (new VAO if available) w.r.t. supplied shader program
+     *          - goal: the same mesh geometry can be reused by many shaders with different layouts (we are binding to the given shader)
+     *          - TODO: currently works with only one buffer (interleaved/joined data), extend this to support multiple buffers (streams) + per-buffer layout setup
+     * @param shaderProgram Shader program for which to setup the layout
+     * @param vertexAttribLayout Specifies, how the mesh data should be mapped to the given shader (VS)
+     *          - e.g. {a_pos : 3, a_uv : 2} defines two attributes, first vertex position with three components, second texture coordinates vector with two components
+     *          - the object keys must respect names of the attribute variables in the Vertex Shader
+     * @param vertexStreamIndex Index of vertex stream (VBO) for which the layout is being registered. Default one is 0
+     */
+    registerShaderGeometryLayout(gl: WebGLRenderingContext | WebGL2RenderingContext, shaderProgram: GlProgram, vertexAttribLayout: Record<string, number>, vertexStreamIndex?: number): void;
+    /**
+     * @summary Destructor
+     */
+    destroy(gl: WebGLRenderingContext | WebGL2RenderingContext): void;
+    /**
+     * @summary Appends vertex stream to the mesh.
+     *      Do not forget to register vertex layout for this stream via {@link registerShaderGeometryLayout} method
+     * @param vertexData Typed array (Float32Array) with vertex data (position, tex. coordinates etc.)
+     * @param dynamic Whether the data will be updated frequently or not
+     * @returns Index of the newly registered vertex stream
+     */
+    addVertexStream(gl: WebGLRenderingContext | WebGL2RenderingContext, vertexData: Float32Array, dynamic?: boolean): number;
+    /**
+     * @summary Dynamically updates content of the given vertex stream. Assumes, that the layout remains the same
+     * @param streamIndex Which stream data to update
+     * @param vertexData New vertex data
+     */
+    updateVertexStream(gl: WebGLRenderingContext | WebGL2RenderingContext, streamIndex: number, vertexData: Float32Array): boolean;
+    /**
+     * @summary Initializes instancing-related methods based on used WebGL context
+     *  - if not called explicitly, it is called during instanced rendering (however in that case we don't get the status, whether instancing is available)
+     * @returns Status, whether instancing was successfully initialized or whether it failed (extension not supported...)
+     */
+    initInstancing(gl: WebGL2RenderingContext | WebGLRenderingContext): boolean;
+    /**
+     * @summary Adds / updates instance data, binds instance buffer with the given shader
+     *          - signals, that further rendering will be performed as instanced (based on thw supplied "numInstances" parameter in the render method)
+     * @param program Shader program used for instanced rendering
+     * @param instanceData Per-instance data (buffer with elements, where each element is assigned to one instance (defined by "gl.vertexAttribDivisor"))
+     * @returns true/false, whether update was successful (can fail, when WebGL2 not available together with 'ANGLE_instanced_arrays' extension not available)
+     */
+    setInstanceStream(gl: WebGLRenderingContext | WebGL2RenderingContext, program: GlProgram, instanceData: TypedArray, instanceAttribLayout: Record<string, [number, number]>): boolean;
+    /**
+     * @summary Dynamically updates content of the mesh instance stream.
+     *  - Assumes, that the layout remains the same
+     *  - Currently only one instance stream is supported
+     * @param instanceData New instance data
+     */
+    updateInstanceStream(gl: WebGLRenderingContext | WebGL2RenderingContext, instanceData: TypedArray): boolean;
+    /**
+     * @returns {boolean} Flag, that instance stream was already created, so subsequent data uploads should call {@link updateInstanceStream}
+     */
+    hasInstanceStream(): boolean;
+    /**
+     * @summary Binds geometry (and index if available) buffer for following operations (e.g. rendering)
+     *  - Also used for layout definition when creating VAO {@link GlVertexArray}
+     */
+    private bindGeometry;
+    /**
+     * @summary Performs rendering of the mesh numInstances-times using WebGL2 context or WebGL1 extension
+     */
+    private renderInstanced;
+}
+/**
+ * @class A container with common geometries
+ */
+export declare class MeshFactory {
+    /** 2D Quad geometry containing only unique vertices (for indexed rendering / triangle fan)
+     * Contains vertex coordinates + UV coordinates
+     *  - an appropriate vertex layout should be {a_pos: 2, u_uv: 2}
+     */
+    static quadMeshUniqueVtxUv: number[];
+    /** 2D Quad mesh with unique vertices with only vertex positions
+     *  - an appropriate vertex layout should be {a_pos: 2}
+     */
+    static quadMeshUniqueVtx: number[];
+    /** 2D Quad mesh with defined as two triangles - 6 vertices (not - unique)
+     *  - basically geometry for drawArrays as gl.TRIANGLE
+     *  - an appropriate vertex layout should be {a_pos: 2}
+     */
+    static quadMeshTrianglesVtx: number[];
+}