@windycom/plugin-devtools 1.0.1

package/types/renderTile.d.ts

@@ -0,0 +1,6 @@
+import type { DataTile } from '@windy/dataLoader';
+import type { TileParams } from '@windy/Renderer.d';
+import type { TileLayerCanvas } from '@windy/TileLayerCanvas.d';
+declare const renderNoDataTile: (canvas: HTMLCanvasElement, url?: string) => void;
+declare const renderTile: (this: TileLayerCanvas, step: 1 | 2, canvas: HTMLCanvasElement, rqrdSyncNum: number, tInfo: TileParams, dTile: DataTile) => void;
+export { renderTile, renderNoDataTile };

package/types/renderUtils.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Shared rendering utilities (and also event emmiter for rendering purposes)
+ */
+import { Evented } from '@windy/Evented';
+import type { Color } from '@windy/Color';
+import type { Layer } from '@windy/Layer';
+import type { FullRenderParameters } from '@windy/Layer.d';
+import type { DataQuality } from '@windy/Product.d';
+import type { TileParams } from '@windy/Renderer.d';
+import type { TilePoint } from '@windy/interfaces.d';
+interface Events {
+    rendered: ['particles' | 'isolines' | 'map' | 'radar' | 'satellite' | 'tileLayer'];
+    glParticlesFailed: [];
+    toggleSeaMask: [boolean];
+    toggleLandMask: [boolean];
+}
+export declare const emitter: Evented<Events>;
+/**
+ * Zoom2zoom transformation table
+ *
+ * Maximal zoomlevels:
+ *
+ * GFS 0, 1, 2
+ * ECMWF 0, 1, 2, 3
+ * NAM/MBEUROPE 0, 1, 2, 3, 4, 5
+ *
+ * WARNING: Minimal dataZoom for map zooms 10,11 is 3 since
+ * maximal amount of data -> pixel trnasition ration is 256 !!!
+ *
+ * NOTE: particles don't work for zoom 0 on -180/180 border ("low" map zooms 3 & 4 changed to data zoom 1)
+ */
+export declare const zoom2zoom: Record<DataQuality, number[]>;
+/**
+ * Return tiles width (amount of tiles) based on zoom level
+ */
+export declare const tileW: (zoom: number) => number;
+/**
+ * return transormation ratio based on map zoom and data zoom
+ */
+export declare const getTrans: (mapZoom: number, dZoom: number) => number;
+/**
+ * Return data zoom based on params
+ * BUG: Sometime we receive not valid dataQuality
+ * if upgradeDataQuality flag is set upgrade to better quality
+ */
+export declare const getDataZoom: (params: FullRenderParameters, tileZoom: number) => number;
+/**
+ * Returns coordinates and details of data tile based on map tile or null if out of bounds
+ */
+export declare const whichTile: (tilePoint: TilePoint, params: FullRenderParameters) => TileParams | null;
+/**
+ * Test that values in blue channel are bigger than X,
+ * which means transparensu for this point in JPG data tile
+ */
+export declare const testJPGtransparency: (source: Uint8ClampedArray, sourceIndex: number) => boolean;
+/**
+ * Test transparency of PNGoverlay
+ */
+export declare const testPNGtransparency: (source: Uint8ClampedArray, sourceIndex: number) => boolean;
+/**
+ * Object containing 3D tables with precalculated
+ * interpolation wights
+ *
+ * @description
+ *
+ * key is trans number (1,2,4,8...)
+ * ```
+ * wTables = {
+ *   '2': [ p00w1, p00w2, p00w3, p00w4,    p01w1, p01w2, p01w3, p01w4,
+ *          p10w1, p10w2, p10w3, p10w4,    p00w1, p00w2, p00w3, p00w4   ]
+ *
+ *    }
+ * ```
+ */
+export declare const wTables: Record<number, Uint16Array>;
+/**
+ * get wTable (and generate it if not done yet)
+ */
+export declare const getWTable: (trans: number) => Uint16Array | null;
+export type ColorizingFun = (x: number, y: number, scalar: number) => void;
+/**
+ * Create function for colorizing x,y, point in step x step area
+ * Allowd values of step are 1,2
+ * Colorizes only for 256x256 tiles
+ */
+export declare const createFillFun: (dest: Uint8ClampedArray, step: 1 | 2, col: Color) => ColorizingFun;
+export type CombinedColorizingFun = (x: number, y: number, value1: number, value2: number) => void;
+/**
+ * Create special colorizing function for 256x256 tile
+ * that will combine two overlays (applies only for 2x2) pixels
+ * Amount can be 0..4
+ *
+ * [1,2]
+ * [3,4]
+ */
+export declare const createCombinedFillFun: (dest: Uint8ClampedArray, c1: Color, c2: Color, amountFun: Layer['getAmountByColor']) => CombinedColorizingFun;
+/**
+ * Reusable 256x256 image data object
+ * WARNING: Watch concurency,only one task can use this
+ */
+export declare const imgData: ImageData;
+/**
+ * Interpolates to nearest discreet value either by using intrpolation table
+ * or a,b,c,d coefs
+ */
+export declare const interpolateNearest: (w: number[] | null, wIndex: number, G00: number, G01: number, G10: number, G11: number, a: number, b: number, c: number, d: number) => number;
+export {};

package/types/renderers.d.ts

@@ -0,0 +1,20 @@
+import { Renderer } from '@windy/Renderer';
+import { TileLayer } from '@windy/TileLayer';
+declare const renderers: {
+    /**
+     * All layers should be now supported by gl-tiles-render
+     * Original tileLayer and patternator rendering ('legacy-tile-render')
+     * is used as backup (or when "Compatibility mode" is active)
+     */
+    tileLayer: TileLayer;
+    noUserControl: TileLayer;
+    radar: Renderer<"radar", typeof import("@plugins/_radar/radar")>;
+    satellite: Renderer<"satellite", typeof import("@plugins/satellite/satellite")>;
+    capAlerts: Renderer<"cap-alerts", typeof import("@plugins/cap-alerts/cap-alerts")>;
+    isolines: Renderer<"isolines", typeof import("@plugins/isolines/isolines")>;
+    particles: Renderer<"gl-particles", typeof import("@plugins/gl-particles/gl-particles")> | Renderer<"particles", typeof import("@plugins/particles/particles")>;
+    /** Extreme forecast and intersucho layers */
+    daySwitcher: TileLayer;
+    accumulations: TileLayer;
+};
+export default renderers;

package/types/reverseName.d.ts

@@ -0,0 +1,10 @@
+import type { ReverseResult } from '@windy/dataSpecifications.d';
+import type { LatLon } from '@windy/interfaces.d';
+/**
+ * Returns reverse data for given lat,lon
+ *
+ * @param latLon `lat` and `lon` of the place to geo reverse
+ * @param forcedZoom Optionally zoom to force
+ * @returns Reverse data, fallback object if anything failed
+ */
+export declare const get: <T extends LatLon>({ lat, lon }: T, forcedZoom?: number) => Promise<ReverseResult>;

package/types/rhMessage.d.ts

@@ -0,0 +1,3 @@
+import type { HTMLString } from '@windy/types';
+export declare const insert: (html: HTMLString) => void;
+export declare const clear: () => void;

package/types/rootScope.d.ts

@@ -0,0 +1,152 @@
+import type { Iconfont } from '@windy/iconfont';
+import type { Isolines, Pois } from '@windy/rootScope.d';
+import type { LoadedTranslations } from '@windy/trans.d';
+/**
+ * Version of Windy.com client (as taken from package.json)
+ * @ignore
+ */
+export declare const version: string;
+/**
+ * Target
+ * @ignore
+ */
+export declare const target: "index" | "mobile" | "lib" | "embed2";
+/**
+ * Platform
+ * @ignore
+ */
+export declare const platform: import("../../types/types").Platform;
+/**
+ * Device
+ * @ignore
+ */
+export declare const device: import("../../types/types").Device;
+/**
+ * List of Windy's supported languages
+ */
+export declare const supportedLanguages: readonly ["en", "zh-TW", "zh", "ja", "fr", "ko", "it", "ru", "nl", "cs", "tr", "pl", "sv", "fi", "ro", "el", "hu", "hr", "ca", "da", "ar", "fa", "hi", "ta", "sk", "uk", "bg", "he", "is", "lt", "et", "vi", "sl", "sr", "id", "th", "sq", "pt", "nb", "es", "de", "bn"];
+/**
+ * Server used to download weather data files. DO NOT PUT TRAILING "/" TO THE URL
+ * @ignore
+ */
+export declare const server: string;
+/**
+ * Server, where our node.js APIs are running. DO NOT PUT TRAILING "/" TO THE URL
+ * @ignore
+ */
+export declare let nodeServer: string;
+/**
+ * For debugging purposes, you can change the server used to query our APIs
+ * @ignore
+ */
+export declare const setNodeServer: (value: string) => void;
+/**
+ * Map tile server
+ * @ignore
+ */
+export declare const tileServer: string;
+/**
+ * Community forum DO NOT PUT TRAILING "/" TO THE URL
+ * @ignore
+ */
+export declare const community = "<!-- @echo NODEBB_HOST -->";
+/**
+ * Where all the assets (libs,fonts,plugins,lang files) are located
+ *
+ * if (DEBUG && TARGET_LIB)  assets = 'http://prod.windy.com:8000/v/' + W.assets;
+ *
+ * @ignore
+ */
+export declare const assets: string;
+/**
+ * Supported list of weather levels
+ */
+export declare const levels: readonly ["surface", "100m", "975h", "950h", "925h", "900h", "850h", "800h", "700h", "600h", "500h", "400h", "300h", "250h", "200h", "150h", "10h"];
+/**
+ * Point forecast API endpoint prefix
+ * @ignore
+ */
+export declare const pointForecast = "v2.7";
+/**
+ * Directory containing latest weather icons
+ * @ignore
+ */
+export declare const iconsDir = "<!-- @echo IMG_RELATIVE_PATH -->/icons6";
+/**
+ * List of valid overlay identifiers
+ */
+export declare const overlays: readonly ["radar", "satellite", "wind", "gust", "gustAccu", "turbulence", "icing", "rain", "rainAccu", "snowAccu", "snowcover", "ptype", "thunder", "temp", "dewpoint", "rh", "deg0", "wetbulbtemp", "solarpower", "uvindex", "clouds", "hclouds", "mclouds", "lclouds", "fog", "cloudtop", "cbase", "visibility", "cape", "ccl", "waves", "swell1", "swell2", "swell3", "wwaves", "sst", "currents", "currentsTide", "no2", "pm2p5", "aod550", "gtco3", "tcso2", "go3", "cosc", "dustsm", "pressure", "efiTemp", "efiWind", "efiRain", "capAlerts", "soilMoisture40", "soilMoisture100", "moistureAnom40", "moistureAnom100", "drought40", "drought100", "fwi", "dfm10h"];
+/**
+ * List of valid accumulation times
+ */
+export declare const acTimes: readonly ["next12h", "next24h", "next2d", "next48h", "next60h", "next3d", "next5d", "next10d"];
+/**
+ * Identifier of products that cover only certain area
+ */
+export declare const localProducts: readonly ["nems", "namConus", "namHawaii", "namAlaska", "iconEu", "iconD2", "arome", "aromeAntilles", "aromeReunion", "camsEu", "iconEuWaves", "hrrrAlaska", "hrrrConus", "bomAccess", "ukv"];
+/**
+ * Identifiers of global products
+ */
+export declare const globalProducts: readonly ["gfs", "ecmwf", "ecmwfAnalysis", "radar", "ecmwfWaves", "gfsWaves", "icon", "iconWaves", "capAlerts", "cams", "efi", "satellite", "cmems", "drought", "fireDanger", "activeFires"];
+/**
+ * Identifiers of sea products
+ */
+export declare const seaProducts: readonly ["ecmwfWaves", "gfsWaves", "iconWaves", "iconEuWaves", "cmems"];
+/**
+ * identifiers of air quality product
+ */
+export declare const airQualityProducts: readonly ["cams", "camsEu"];
+/**
+ * identifiers of local products, that have point forecast
+ */
+export declare const localPointProducts: readonly ["namConus", "namHawaii", "namAlaska", "iconD2", "iconEu", "iconEuWaves", "arome", "aromeAntilles", "aromeReunion", "hrrrAlaska", "hrrrConus", "bomAccess", "ukv"];
+/**
+ * Identifiers of global products, that have point forecast
+ */
+export declare const globalPointProducts: readonly ["gfs", "ecmwf", "icon", "mblue"];
+/**
+ * Identifiers of all land products combined
+ */
+export declare const products: readonly ["gfs", "ecmwf", "ecmwfAnalysis", "radar", "ecmwfWaves", "gfsWaves", "icon", "iconWaves", "capAlerts", "cams", "efi", "satellite", "cmems", "drought", "fireDanger", "activeFires", "nems", "namConus", "namHawaii", "namAlaska", "iconEu", "iconD2", "arome", "aromeAntilles", "aromeReunion", "camsEu", "iconEuWaves", "hrrrAlaska", "hrrrConus", "bomAccess", "ukv", "cams", "camsEu", "mblue"];
+/**
+ * Identifiers of all point products combines
+ */
+export declare const pointProducts: readonly ["gfs", "ecmwf", "icon", "mblue", "namConus", "namHawaii", "namAlaska", "iconD2", "iconEu", "iconEuWaves", "arome", "aromeAntilles", "aromeReunion", "hrrrAlaska", "hrrrConus", "bomAccess", "ukv"];
+/**
+ * IndicatesIndicates that that browsing device is mobile
+ */
+export declare const isMobile: boolean;
+/**
+ * Indicates that browsing device is tablet
+ */
+export declare const isTablet: boolean;
+/**
+ * Indicates that browsing device is mobile or tablet
+ */
+export declare const isMobileOrTablet: boolean;
+/**
+ * Indicates that browsing device has retina display
+ * @ignore
+ */
+export declare const isRetina: boolean;
+/**
+ * Preferred browsers' language (not the used one). Can contain language that is not supported by Windy
+ */
+export declare const prefLang: string;
+/**
+ * Valid levels, their identifier and display string
+ * @ignore this will crash Markdown parser
+ */
+export declare const levelsData: {
+    [L in (typeof levels)[number]]: [string, string];
+};
+/**
+ * Valid POI layers, their name and icon
+ * @ignore this will crash Markdown parser
+ */
+export declare const pois: Record<Pois, [keyof LoadedTranslations | string, Iconfont]>;
+/**
+ * List of valid isoline identifiers
+ * @ignore this will crash Markdown parser
+ */
+export declare const isolines: Isolines[];

package/types/router.d.ts

@@ -0,0 +1,30 @@
+import { type ParsedQueryString } from '../utils/queryString';
+import type { Coords, PickerCoords } from '@windy/interfaces.d';
+import type { ExternalPluginIdent } from '@windy/types';
+import type { PluginIdent } from '@windy/Plugin';
+type StartupCoords = {
+    sharedCoords: Coords | null;
+    pickerCoords: PickerCoords | null;
+};
+/**
+ * Parse URL to plugin and its parameters (if any)
+ *
+ * @returns true if some of the plugins was matched, false otherwise
+ */
+export declare function resolveRoute(purl: string, source: 'url' | 'back-button', parsedQs?: ParsedQueryString): ExternalPluginIdent | PluginIdent | void;
+/**
+ * Parse search part of the URL
+ * eg: https://www.windy.com/?overlay,level,acTime,lat,lon,zoom,marker
+ * lat,lon,zoom are obligatory and must go always together
+ * All other params are optional and can be in any order
+ * WARNING: This method has thousands of side effects!!
+ *
+ * @param searchQuery Search part of the URL, eg: lat,lon,zoom,marker
+ * @returns Coordinates from the URL (if any) and coordinates of the picker (if any)
+ */
+export declare function parseSearch(searchQuery: string | undefined, parsedQs?: ParsedQueryString): StartupCoords | undefined;
+/**
+ * Parsed coordinates from URL
+ */
+export declare const sharedCoords: Coords;
+export {};

package/types/seoParser.d.ts

@@ -0,0 +1,19 @@
+declare const _default: {
+    /**
+     * Language parsed from startupUrl, null if cannot be parsed
+     */
+    lang: string;
+    /**
+     * Path part of the startup URL without SEO parts
+     */
+    purl: string;
+    /**
+     * Path part of the initial URL when client was open
+     */
+    startupUrl: string;
+    /**
+     * Overlay parsed from startupUrl, null if cannot be parsed
+     */
+    overlay: string;
+};
+export default _default;

package/types/share.d.ts

@@ -0,0 +1 @@
+export declare const share: () => void;

package/types/showableErrorsService.d.ts

@@ -0,0 +1,31 @@
+import type { ErrorCategory, ShowableError } from '@windy/types.d';
+/**
+ * Add showableError to local storage
+ * @param error
+ */
+export declare const add: (error: ShowableError) => void;
+/**
+ * Sets showableError to not be displayed anymore
+ * @param errorId
+ */
+export declare const close: (errorId: string) => void;
+/**
+ * It return array unresolvedErrors with removed showableError
+ * @param errorId
+ */
+export declare const resolve: (errorId: string) => void;
+/**
+ * It resolve whole category of errors from unresolvedErrors
+ * @param category
+ */
+export declare const resolveCategory: (category: ErrorCategory) => void;
+/**
+ * Returns unresolved errors
+ * @returns ShowableError[]
+ */
+export declare const getUnresolvedErrors: () => ShowableError[];
+/**
+ * Control if error was resolved, based on category of the error
+ * @param error
+ */
+export declare function checkError(error: ShowableError): void;

package/types/singleclick.d.ts

@@ -0,0 +1,52 @@
+/**
+ * # @windy/singleclick
+ *
+ * Handles singleclick events on map and determines, which consumer should get it.
+ * If none is found, it emits event with `click` topic, which is usually cached by `@windy/picker`
+ * module and it opens weather picker on desired location.
+ *
+ * @example
+ * ```typescript
+ * import { singleclick } from '@windy/singleclick';
+ *
+ * // Plugin will get singleclick events ONLY if they are properly configured
+ * // to get singleclick events
+ * singleclick.on('windy-plugin-name', (ev) => {
+ *    console.log('I got singleclick event', ev);
+ * })
+ * ```
+ *
+ * @module singleclick
+ */
+import { Evented } from '@windy/Evented';
+import type { PluginIdent } from '@windy/Plugin';
+import type { SingleclickTypes, ListeningPriority } from '@windy/singleclick.d';
+/**
+ * Main singleclick event emitter (instance of class {@link Evented.Evented | Evented }.)
+ *
+ * It contains well defined methods `on`, `off` and `once`
+ * and it emits events, whose topic is one of eligible consumer
+ */
+export declare const singleclick: Evented<SingleclickTypes>;
+/**
+ * Register the plugin (identified by its ident) to be on the list to
+ * receive singleclick events.
+ *
+ * There can be only one listener with high priority (usually actually opened
+ * plugin), and one with low priority (usually some map layer).
+ *
+ * Well configured plugins do not need to use this method, as they are automatically
+ * released, by Windy's plugin system when they are closed.
+ */
+export declare const register: (ident: PluginIdent, priority: ListeningPriority) => keyof import("../pluginSystem/plugins").Plugins;
+/**
+ * Release the plugin from the list of singleclick events. Well configured plugins
+ * do not need to use this method, as they are automatically released, by Windy's
+ * plugin system when they are closed.
+ */
+export declare const release: (ident: PluginIdent, priority: ListeningPriority) => void;
+/**
+ * Handles all singleclick events from instance of Leaflet map
+ * @ignore
+ */
+export declare const opener: (ev: L.LeafletMouseEvent) => void;

package/types/storage.d.ts

@@ -0,0 +1,3 @@
+import type { Storage } from '@windy/storage.d';
+declare const _default: Storage;
+export default _default;

package/types/store.d.ts

@@ -0,0 +1,148 @@
+/**
+ * # @windy/store
+ *
+ * Represents a key-value store with methods for getting, setting, and observing values.
+ * The store maintains the integrity of the parameters and checks the validity of the input.
+ *
+ * Used store keys are defined as `DataSpecifications` interface.
+ *
+ * Check out complete list of {@link DataSpecifications.DataSpecifications | store properties}.
+ *
+ * Used for storing major parameters and user settings.
+ *
+ * It also supports observing changes to the values and retrieving allowed values for each key.
+ *
+ * Use methods `get` to read value from store, `set` to change value in the store and `on` to observe change of the value.
+ * Some of the items respond to method `getAllowed` to return array of allowed values.
+ *
+ * Method `set` returns `true` if provided value was valid and was actually changed.
+ *
+ * Store is instance of class {@link Evented.Evented | Evented }.
+ *
+ * @example
+ * ```js
+ * var overlay = store.get('overlay');
+ * // 'wind' ... actually used overlay
+ *
+ * var allowedOverlays = store.getAllowed('overlay');
+ * // ['wind', 'rain', ... ] ... list of allowed values
+ *
+ * store.set('overlay', 'rain');
+ * // true ... Overlay was changed to rain
+ *
+ * store.on('overlay', ovr => {
+ *      // Called when value was changed
+ * });
+ * ```
+ *
+ * @module store
+ */
+import { Evented } from '@windy/Evented';
+import type { DataSpecifications, DataSpecificationsObject } from '@windy/dataSpecifications.d';
+import type { SetReturnType, StoreOptions, StoreTypes } from '@windy/store.d';
+declare class Store extends Evented<StoreTypes> {
+    /**
+     * Set default value for given key
+     *
+     * @param name Name
+     * @param value Value
+     */
+    setDefault<T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T, value: Item['def']): void;
+    /**
+     * Defines property in dataSpecification list. Used for example for
+     * definition of `syncSet` or `asyncSet`
+     *
+     * @param name identifier of property in dataSpecification
+     * @param prop property
+     * @param value Value
+     */
+    defineProperty: <T extends keyof DataSpecifications, Prop extends keyof DataSpecifications[T], Value extends DataSpecifications[T][Prop]>(name: T, prop: Prop, value: Value) => void;
+    /**
+     * Retrieves property from dataSpecifications
+     *
+     * @param name identifier of property in dataSpecification
+     * @returns Stored value
+     */
+    getProperty: <T extends keyof DataSpecifications>(name: T) => DataSpecifications[T];
+    /**
+     * Checks existence of property
+     *
+     * @param name Name
+     * @returns True if property exists
+     */
+    hasProperty: <T extends keyof DataSpecifications>(name: T) => boolean;
+    _set<T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T, item: Item, opts: StoreOptions, value: Item['def'] | null): void;
+    /**
+     * Sets a value in key, value store. If succesfull,a nd value has been changed, store will brodcast message with name and value.
+     * Limitation:** Our store is quite primitive so it can not compare Arrays and Objects. Always create new one or use `forceChange` * option.
+     *
+     * @param name Name
+     * @param value Value
+     * @param opts Options
+     * @returns optional, returns true if value was changed, undefined if change failed, Promise obj if change was asynchronous
+     */
+    set<T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T, value: Item['def'] | null, opts?: StoreOptions): SetReturnType<T>;
+    /**
+     * Set it to null leading to defaults values
+     *
+     * @param name Name
+     * @param opts Options
+     */
+    remove: <T extends keyof DataSpecifications>(name: T, opts?: StoreOptions) => void;
+    /**
+     * Outputs all allowed properties for give key into console.log
+     */
+    getAll: () => void;
+    /**
+     * Return list of permitted values for given key
+     *
+     * @param name Name
+     * @returns List of allowed values for the name; or string with info it is checked by function
+     */
+    getAllowed: <T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T) => string | Item["allowed"];
+    /**
+     * Returns default value for given key
+     *
+     * @param name Name
+     * @returns Data specification type
+     */
+    getDefault<T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T): Item['def'];
+    isAsyncStore<T>(item: DataSpecificationsObject<T>): item is DataSpecificationsObject<T> & Required<Pick<DataSpecificationsObject<T>, 'asyncSet'>>;
+    /**
+     * Check if value was changed
+     * !!!! WARNING: for perfomance reasons check only against hot cache, so can
+     * lead to faulty results around default || never used values
+     *
+     * @param name Name
+     * @param item Item
+     * @param value Value
+     * @returns True if value was changed
+     */
+    wasChanged<T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T, item: Item, value: Item['def']): boolean;
+    /**
+     * Insert dataSpecifications key (if not present)
+     *
+     * @param name Name
+     * @param obj Data specifications object
+     */
+    insert: <T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T, obj: Item) => void;
+    /**
+     * Retrieves value stored in store
+     *
+     * @param {string} name Name
+     * @param {boolean} options.forceGet Skip cache and return even nullish value with no default polyfill
+     * @returns stored value
+     */
+    get<T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T, options?: {
+        forceGet: boolean;
+    }): Item['def'];
+    isValid<T>(item: DataSpecificationsObject<T>, value: T): boolean;
+}
+declare const store: Store;
+export declare const getAll: () => void, getAllowed: <T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T) => string | Item["allowed"], getDefault: <T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T) => Item["def"], get: <T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T, options?: {
+    forceGet: boolean;
+}) => Item["def"], on: <K extends keyof StoreTypes, Q extends StoreTypes[K]>(topic: K, callback: (...data: TrimUndefinedFromRight<Arrayify<Q>>) => void, context?: ThisType<unknown>, once?: boolean) => number, off: {
+    (id: number): void;
+    <K extends keyof StoreTypes, Q extends StoreTypes[K]>(topic: K, callback: (...data: TrimUndefinedFromRight<Arrayify<Q>>) => void, context?: ThisType<unknown>): void;
+}, once: <K extends keyof StoreTypes, Q extends StoreTypes[K]>(topic: K, callback: (...data: TrimUndefinedFromRight<Arrayify<Q>>) => void, context?: ThisType<unknown>) => number, set: <T extends keyof DataSpecifications, Item extends DataSpecifications[T]>(name: T, value: Item["def"], opts?: StoreOptions) => SetReturnType<T>;
+export default store;

package/types/subscription.d.ts

@@ -0,0 +1,65 @@
+import type { SubTier } from '@windy/types.d';
+import type { SubscriptionInfo } from '@plugins/_shared/subscription-services/subscription-services.d';
+export type SubscriptionIssue = {
+    type: 'graced' | 'paused' | 'onhold';
+} | {
+    type: 'expiring';
+    expiresInHours: number;
+};
+/**
+ * Get the current tier of the user.
+ *
+ * @returns "premium" for premium user, null otherwise
+ */
+export declare const getTier: () => SubTier;
+/**
+ * When any user changes his/her premium status (redeem, restore, ...), we need to refresh token2 to
+ * reflect premium status for our backends
+ */
+declare const reloadUserToken: () => void;
+/**
+ * Clear pending subscription (i.e. unclaimed, not-redeemed subscription) from store.
+ */
+export declare const clearPendingSubscription: () => void;
+/**
+ * Set pending subscription to store.
+ *
+ * @param {string} redeemCode Code to store
+ */
+export declare const setPendingSubscription: (redeemCode: string) => void;
+/**
+ * Disable all premium features for the user. It does not deactivate subscription, it is just client GUI reset.
+ */
+export declare const deactivateAllFeatures: () => void;
+/**
+ * Set a tier for the user. It also clears pending and failed subscriptions if tier is passed.
+ *
+ * @param value Tier to set for the user, "null" for the subscription deactivation
+ * @param options Optionally `reloadUserToken: true` if client should reload JWT token after setting the tier
+ * @returns Same value which has been set
+ */
+export declare const setTier: (value: SubTier, options?: {
+    reloadUserToken?: boolean;
+    subscriptionInfo?: SubscriptionInfo;
+}) => SubTier;
+/**
+ * Returns boolean value if user has any valid premium subscription.
+ *
+ * @returns True if user has a valid premium subscription, false otherwise
+ */
+export declare const hasAny: () => boolean;
+/**
+ * Returns null if everything is ok, object with issue otherwise.
+ */
+export declare const getIssue: () => SubscriptionIssue | null;
+/**
+ * Check if any pending subscription (i.e. unclaimed, not-redeemed subscription) is stored.
+ * Open `pending-subscription` plugin if yes, void otherwise
+ */
+export declare const checkPendingSubscription: () => void;
+/**
+ * Returns short text for buttons which inform user about any subscription issue.
+ * It is used only as a gateway to solving the whole issue. It must be short and clear.
+ */
+export declare const getBaitTitle: (issue: SubscriptionIssue | null) => string;
+export {};