@skypath-io/web-sdk 0.4.7 → 0.4.13

package/dist/types/src/core/auth/auth.d.ts

@@ -0,0 +1,27 @@
+export class AuthService {
+    constructor({ environment, proxyUrl }: {
+        environment: any;
+        proxyUrl: any;
+    });
+    authenticate: ({ apiKey, userId, companyName, authCallback }: {
+        apiKey: any;
+        userId: any;
+        companyName: any;
+        authCallback: any;
+    }) => Promise<{
+        fetcher: ({ path, method, params, headers, body, signal, retry, }: {
+            path?: string;
+            method?: string;
+            params: any;
+            headers?: {};
+            body?: any;
+            signal?: any;
+            retry?: number;
+        }) => Promise<any>;
+        me: {
+            companyId: any;
+            userId: any;
+        };
+    }>;
+    #private;
+}

package/dist/types/src/core/auth/consts.d.ts

@@ -0,0 +1,30 @@
+export const DEFAULT_API_BASE_URL: "https://api.skypath.io";
+export namespace ALLOWED_PROTOCOLS {
+    let HTTP: string;
+    let HTTPS: string;
+}
+export namespace ALLOWED_HEADERS {
+    let AUTH_API_KEY: string;
+    let AUTH_TOKEN: string;
+    let CONTENT_TYPE: string;
+}
+export namespace ALLOWED_METHODS {
+    let GET: string;
+    let POST: string;
+}
+export namespace PATHS {
+    let PARTNER_LOGIN: string;
+    let PARTNER_LOGIN_SIGNED: string;
+    let PARTNER_REFRESH_TOKEN: string;
+    let ME: string;
+}
+export const REQUEST_ABORTED_MESSAGE: "[SkyPath SDK]: Old fetch request aborted";
+export namespace ENVIRONMENTS {
+    let LOCAL: string;
+    let DEVELOPMENT: string;
+    let STAGING: string;
+    let PRODUCTION: string;
+}
+export const API_BASE_URLS: {
+    [x: string]: string;
+};

package/dist/types/src/core/auth/index.d.ts

@@ -0,0 +1 @@
+export * from "./auth.js";

package/dist/types/src/core/auth/utils.d.ts

@@ -0,0 +1,3 @@
+export function getErrorMessage({ response }: {
+    response: any;
+}): Promise<string>;

package/dist/types/src/core/emitter/emitter.d.ts

@@ -0,0 +1,8 @@
+export class EventEmitter {
+    on(event: any, listener: any): void;
+    off(event: any, listener: any): void;
+    emit(event: any, ...args: any[]): void;
+    once(event: any, listener: any): void;
+    clear(): void;
+    #private;
+}

package/dist/types/src/core/emitter/index.d.ts

@@ -0,0 +1 @@
+export * from "./emitter";

package/dist/types/src/core/flow/consts.d.ts

@@ -0,0 +1,18 @@
+export namespace ERROR_MESSAGES {
+    let NOT_RUNNING: string;
+    let NOT_STOPPED: string;
+    let ALREADY_STARTED: string;
+    let ALREADY_TERMINATED: string;
+}
+export namespace STATES {
+    let INITIALIZED: string;
+    let RUNNING: string;
+    let STOPPED: string;
+    let TERMINATED: string;
+}
+export namespace DEFAULT_FILTER_VALUES {
+    let HOURS_AGO: number;
+    let SEVERITY: number;
+    let ALT_FROM: number;
+    let ALT_TO: number;
+}

package/dist/types/src/core/flow/flow.d.ts

@@ -0,0 +1,11 @@
+export class Flow {
+    start(): void;
+    stop(): void;
+    terminate(): void;
+    get isInitialRun(): boolean;
+    get state(): string;
+    get isRunning(): boolean;
+    get isStopped(): boolean;
+    get isTerminated(): boolean;
+    #private;
+}

package/dist/types/src/core/flow/index.d.ts

@@ -0,0 +1 @@
+export * from "./flow";

package/dist/types/src/core/geo/geo.d.ts

@@ -0,0 +1,213 @@
+export const HEX_RESOLUTION_BUFFERS: {
+    0: number;
+    1: number;
+};
+export namespace POLYGON_TYPE {
+    let SMALL: string;
+    let MEDIUM: string;
+    let LARGE: string;
+    let CORRIDOR: string;
+}
+/**
+ * Generates a GeoJSON FeatureCollection from H3 hexagon IDs, adjusting coordinates for antimeridian crossing
+ * and ensuring valid longitude and latitude ranges, without mutating the original data.
+ *
+ * @param {Array<{hexId: string}>} hexagons - Array of objects containing 'hexId' for H3 hexagons.
+ * @param {number} [scale=1] - Optional. The scale factor to apply to the hexagons.
+ * @returns {Object} A GeoJSON FeatureCollection representing the hexagons.
+ */
+export function getHexagonsFeatureCollection(hexagons?: Array<{
+    hexId: string;
+}>, scale?: number): any;
+/**
+ * Gets H3 hexagon IDs that intersect with the given map bounds at a specified resolution.
+ *
+ * @param {Array<number>} mapBounds - The bounding box of the map.
+ * @param {number} resolution - The H3 resolution to use.
+ * @returns {Array<string>} An array of H3 hexagon IDs.
+ */
+export function getHexIdsByMapBoundsAndResolution(mapBounds: Array<number>, resolution?: number): Array<string>;
+/**
+ * Gets viewport H3 hexagon IDs from a Mapbox map instance.
+ *
+ * @param {object} map - The Mapbox map instance.
+ * @param {number} [resolution] - Optional. The H3 resolution to use.
+ * @returns {Array<string>} An array of H3 hexagon IDs.
+ */
+export function getHexIdsFromMapboxMap(map: object, resolution?: number): Array<string>;
+/**
+ * Gets H3 hexagon IDs that intersect with the given polygon at a specified resolution.
+ *
+ * @param {Array<Array<number>>} polygon
+ * @param {number} resolution
+ * @param {boolean} shouldInvertLatLng
+ * @returns {Array<string>} An array of H3 hexagon IDs.
+ */
+export function getHexIdsByPolygonAndResolution(polygon: Array<Array<number>>, resolution?: number, shouldInvertLatLng?: boolean): Array<string>;
+/**
+ * Gets viewport polygon from a Mapbox map instance.
+ *
+ * @param {object} map - The Mapbox map instance.
+ * @returns {number[][]} lat lng polygon.
+ */
+export function getMapPolygon(map: object): number[][];
+/**
+ * Inverts the order of longitude and latitude in a coordinate pair.
+ *
+ * @param {Array<number>} coordinate - The coordinate pair to invert.
+ * @returns {Array<number>} The inverted coordinate pair.
+ */
+export function invertLatLng([lng, lat]: Array<number>): Array<number>;
+/**
+ * Adjusts the longitude of geographical coordinates in an array to account for antimeridian crossing.
+ * The antimeridian is a meridian at 180 degrees longitude, crossing which requires adjusting coordinates
+ * for continuity in geographical data representation.
+ *
+ * @param {Array<Array<number>>} coordinates - An array of coordinates, where each coordinate is a cortege of 2 numbers. The first element in each coordinate array is expected to be the longitude.
+ * @returns {Array<Array<number>>} A new array with adjusted coordinates `Array<[number, number]>`.
+ */
+export function adjustAntiMeridianCrossing(coordinates: Array<Array<number>>): Array<Array<number>>;
+/**
+ * Adjusts the coordinates of a feature to handle antimeridian crossing and ensures
+ * that longitude and latitude values are within their valid ranges.
+ *
+ * @param {Array<Array<number>>} coordinates - The array of coordinates to adjust.
+ * @returns {Array<Array<number>>} The adjusted array of coordinates.
+ */
+export function adjustFeatureCoordinates(coordinates: Array<Array<number>>): Array<Array<number>>;
+/**
+ * Convert a single H3 hexagon to a `Polygon` GEOJson feature
+ *
+ * @param  {string} h3Index   Hexagon index
+ * @param  {object} [properties] Optional feature properties
+ * @return {object}             GeoJSON Feature object
+ */
+export function h3ToFeature(h3Index: string, properties?: object): object;
+/**
+ * Convert a set of H3 hexagons to a GeoJSON `FeatureCollection` with each hexagon
+ * in a separate `Polygon` feature with optional properties.
+ *
+ * @param  {Array<string>} hexagons Hexagon addresses
+ * @param  {Function} [getProperties] Optional function returning properties for a hexagon: f(h3Index) => Object
+ * @return {Object} GeoJSON FeatureCollection object
+ */
+export function h3SetToFeatureCollection(hexagons: Array<string>, getProperties?: Function): any;
+/**
+ * Normalizes the coordinates of a polygon or line string to account for antimeridian crossing.
+ *
+ * @param {Array<Array<number>>} array - The array of coordinates to normalize.
+ * @returns {Array<Array<number>>} The normalized array of coordinates.
+ */
+export function normalizeAntiMeridian(array: Array<Array<number>>): Array<Array<number>>;
+/**
+ * Ensures longitude and latitude values are within their valid ranges.
+ *
+ * @param {Array<number>} coordinate - The [longitude, latitude] pair to adjust.
+ * @returns {Array<number>} The adjusted [longitude, latitude] pair.
+ */
+export function clampCoordinates([lng, lat]: Array<number>): Array<number>;
+/**
+ * Filters hexagons (observations, ADS-B) data based on provided filters.
+ *
+ * @param {Object} params - The parameters.
+ * @param {Object} params.data - The hexagons data.
+ * @param {Object} params.filters - The filters to apply.
+ * @param {number} [params.filters.hoursAgo] - The number of hours ago to filter data.
+ * @param {number} [params.filters.altitudeFrom] - The minimum altitude to filter data.
+ * @param {number} [params.filters.altitudeTo] - The maximum altitude to filter data.
+ * @param {number} [params.filters.severity] - The minimum severity to filter data.
+ * @returns {Object} The filtered hexagons data.
+ */
+export function getHexagonsDataSlice({ data, filters }: {
+    data: any;
+    filters: {
+        hoursAgo?: number;
+        altitudeFrom?: number;
+        altitudeTo?: number;
+        severity?: number;
+    };
+}): any;
+/**
+ * Filters hexagons (observations, ADS-B) data based on provided filters.
+ *
+ * @param {Object} params - The parameters.
+ * @param {Object} params.data - The hexagons data.
+ * @param {Object} params.filters - The filters to apply.
+ * @param {number} [params.filters.altitudeFrom] - The minimum altitude to filter data.
+ * @param {number} [params.filters.altitudeTo] - The maximum altitude to filter data.
+ * @param {number} [params.filters.severity] - The minimum severity to filter data.
+ * @returns {Object} The filtered hexagon data.
+ */
+export function getOneLayerHexagonsDataSlice({ data, filters }: {
+    data: any;
+    filters: {
+        altitudeFrom?: number;
+        altitudeTo?: number;
+        severity?: number;
+    };
+}): any;
+/**
+ * Prepares hexagons data for map hexagons.
+ *
+ * @param {Object} params - The parameters.
+ * @param {Object} params.data - The hexagons data.
+ * @param {number} [params.resolution=DEFAULT_MAP_DISPLAY_RESOLUTION] - The resolution for the map hexagons.
+ * @returns {Array} The prepared hexagons data for map hexagons.
+ */
+export function prepareHexagonsDataForMapHexagons({ data, resolution, }: {
+    data: any;
+    resolution?: number;
+}): any[];
+/**
+ * Prepares hexagons data for map hexagons.
+ *
+ * @param {Object} params - The parameters.
+ * @param {Object} params.data - The hexagons data.
+ * @param {number} [params.resolution=DEFAULT_MAP_DISPLAY_RESOLUTION] - The resolution for the map hexagons.
+ * @returns {Array} The prepared hexagons data for map hexagons.
+ */
+export function prepareOneLayerHexagonsDataForMapHexagons({ data, resolution, }: {
+    data: any;
+    resolution?: number;
+}): any[];
+/**
+ * Extends a polygon by a resolution-dependent buffer size.
+ *
+ * @param {Object} params - The parameters.
+ * @param {Array<Array<number>>} params.polygon - The polygon to extend.
+ * @param {number} params.resolution - The resolution to use.
+ * @param {number} [params.extensionFactor=1] - The factor by which to extend the polygon.
+ * @returns {Array<Array<number>>} The extended polygon.
+ */
+export function extendPolygonByResolution({ polygon, resolution, extensionFactor, }: {
+    polygon: Array<Array<number>>;
+    resolution: number;
+    extensionFactor?: number;
+}): Array<Array<number>>;
+/**
+ * Gets the zoom level of a polygon.
+ *
+ * @param {Object} params - The parameters.
+ * @param {Array<Array<number>>} params.polygon - The polygon.
+ * @param {number} [params.precision=1] - The precision.
+ * @returns {number} The zoom level.
+ */
+export function getZoomLevel({ polygon, precision }: {
+    polygon: Array<Array<number>>;
+    precision?: number;
+}): number;
+export function getPolygonSize(polygon: any, mapping?: {
+    [x: string]: number;
+}): string;
+/**
+ * Get mercator center from bbox
+ *
+ * @param {number[]} bbox - [minLon, minLat, maxLon, maxLat]
+ * @returns {number[]} [lat, lon]
+ */
+export function getMercatorCenterFromBbox(bbox: number[]): number[];
+export function getMiddleArea({ polygon, resolution, extensionFactor }: {
+    polygon: any;
+    resolution: any;
+    extensionFactor: any;
+}): number[][];

package/dist/types/src/core/geo/index.d.ts

@@ -0,0 +1 @@
+export * from "./geo";

package/dist/types/src/core/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./utils";
+export * from "./geo";

package/dist/types/src/core/monitoring/consts.d.ts

@@ -0,0 +1,9 @@
+export namespace PREFIXES {
+    let SDK: string;
+    let NETWORK: string;
+}
+export const CLIENT_TOKEN: "pub0b945dd1505a74367a4f900219c56210";
+export const SERVICE_NAME: "skypath-web-sdk";
+export const DATADOG_SITE: "datadoghq.com";
+export const SDK_LOGGER_NAME: "SDKLogger";
+export const SDK_VERSION: string;

package/dist/types/src/core/monitoring/datadog.d.ts

@@ -0,0 +1,10 @@
+export function initDatadog({ isEnabled, collectConsole, collectErrors, applicationId, environment, companyId, userId, }: {
+    isEnabled: any;
+    collectConsole: any;
+    collectErrors: any;
+    applicationId: any;
+    environment: any;
+    companyId: any;
+    userId: any;
+}): void;
+export function getLogger(): import("@datadog/browser-logs").Logger;

package/dist/types/src/core/monitoring/errors.d.ts

@@ -0,0 +1,29 @@
+export namespace ERROR_MESSAGES {
+    let INVALID_LISTENER: string;
+    let MISSING_AUTH_PARAMS: string;
+    let FAILED_TO_AUTHENTICATE_WITH_AUTH_CALLBACK: string;
+    let FAILED_TO_AUTHENTICATE_WITH_API_KEY: string;
+    let FAILED_TO_GET_AUTH_TOKEN: string;
+}
+export class SkyPathError extends Error {
+    constructor({ error, context }: {
+        error: any;
+        context?: {};
+    });
+    context: {};
+}
+export class ValidationError extends SkyPathError {
+    constructor(message: any, context?: {});
+}
+export class NetworkError extends SkyPathError {
+    constructor(message: any, context?: {});
+}
+export class InitializationError extends SkyPathError {
+    constructor(message: any, context?: {});
+}
+export class AuthenticationError extends SkyPathError {
+    constructor(message: any, context?: {});
+}
+export class FlowError extends SkyPathError {
+    constructor(message: any, context?: {});
+}

package/dist/types/src/core/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./utils";

package/dist/types/src/core/utils/utils.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Debounces a function to prevent it from being called multiple times within a specified delay.
+ *
+ * @param {Function} fn - The function to debounce.
+ * @param {number} delay - The delay in milliseconds.
+ * @returns {Function} - The debounced function.
+ */
+export function debounce(fn: Function, delay: number): Function;
+/**
+ * Throttles a function to prevent it from being called multiple times within a specified delay.
+ *
+ * @param {Function} fn - The function to throttle.
+ * @param {number} delay - The delay in milliseconds.
+ * @returns {Function} - The throttled function.
+ */
+export function throttle(fn: Function, delay: number): Function;
+/**
+ * Merges two arrays of objects by a specified property.
+ *
+ * @param {object[]} target - target array of objects
+ * @param {object[]} source - source array of objects
+ * @param {string} propName - the prop name of the object to marge by
+ * @returns {object[]}
+ */
+export function mergeByProperty(target: object[], source: object[], propName: string): object[];
+/**
+ * Builds a data key from components.
+ * @param {object} options
+ * @param {string[]} options.components - The components to build the data key from.
+ * @param {string} [options.separator] - The separator to use.
+ * @returns {string} - The data key.
+ */
+export function buildDataKeyFromComponents({ components, separator, }: {
+    components: string[];
+    separator?: string;
+}): string;
+/**
+ * Parses a data key into components.
+ * @param {object} options
+ * @param {string} options.dataKey - The data key to parse.
+ * @param {string} [options.separator] - The separator to use.
+ * @returns {string[]} - The components.
+ */
+export function parseDataKeyToComponents({ dataKey, separator, }: {
+    dataKey: string;
+    separator?: string;
+}): string[];
+/**
+ * Maps an aircraft ICAO code to an aircraft type.
+ * @param {object} options
+ * @param {string} options.icao - The aircraft ICAO code.
+ * @param {object[]} options.mapping - The aircraft mapping.
+ * @returns {string} - The aircraft type.
+ * @throws {Error} - Throws an error if the aircraft type is not found.
+ */
+export function mapAircraftIcaoToAircraftType({ icao, mapping }: {
+    icao: string;
+    mapping: object[];
+}): string;
+export function isUndefined(value: any): boolean;
+export function isFunction(fn: any): boolean;
+export function isObject(value: any): boolean;
+export function isChanged(current: any, next: any): any;
+export function getTimer(time: any): {
+    run: (callback: any) => void;
+    cancel: () => void;
+};
+export function getChangedFields({ current, next }: {
+    current: any;
+    next: any;
+}): Set<any>;

package/dist/types/src/features/adsb/consts.d.ts

@@ -0,0 +1,26 @@
+export namespace PATHS {
+    let DATA: string;
+}
+export namespace DEFAULT_FILTER_VALUES {
+    let HOURS_AGO: number;
+    let SEVERITY: number;
+    let ALT_FROM: number;
+    let ALT_TO: number;
+}
+export const SIZE_TO_RESOLUTION_MAP: {
+    [x: string]: number;
+};
+export const SIZE_TO_MIN_SEVERITY_MAP: {
+    [x: string]: number;
+};
+export const SIZE_TO_EXTENSION_FACTOR_MAP: {
+    [x: string]: number;
+};
+export const DEBOUNCE_TIME_SEC: number;
+export const REFRESH_TIME_SEC: number;
+export namespace CONFIG_KEYS {
+    let POLYGON: string;
+    let IS_CORRIDOR_MODE: string;
+}
+export const DEFAULT_RESOLUTION: 1;
+export const MAP_RESOLUTION: 5;

package/dist/types/src/features/adsb/flow.d.ts

@@ -0,0 +1,17 @@
+export class ADSBFlow {
+    constructor({ fetcher }: {
+        fetcher: any;
+    });
+    onData: (callback: any) => void;
+    onError: (callback: any) => void;
+    onIsProcessingChange: (callback: any) => void;
+    start: () => void;
+    stop: () => void;
+    terminate: () => void;
+    get isRunning(): any;
+    updateConfig: ({ polygon, isCorridorMode }: {
+        polygon: any;
+        isCorridorMode: any;
+    }) => void;
+    #private;
+}

package/dist/types/src/features/adsb/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./flow";
+export * from "./service";

package/dist/types/src/features/adsb/service.d.ts

@@ -0,0 +1,12 @@
+export class ADSBService {
+    constructor({ fetcher }: {
+        fetcher: any;
+    });
+    fetch: ({ polygon, polygonSize }: {
+        polygon: any;
+        polygonSize: any;
+    }, signal: any) => Promise<any>;
+    expire: () => void;
+    dispose: () => void;
+    #private;
+}

package/dist/types/src/features/adsb/utils.d.ts

@@ -0,0 +1,14 @@
+export function validateInput({ polygon, isCorridorMode }: {
+    polygon: any;
+    isCorridorMode: any;
+}): void;
+export function mapPolygonToHexIds({ polygon, polygonSize }: {
+    polygon: any;
+    polygonSize: any;
+}): {
+    hexIds: string[];
+    childCells: string[];
+};
+export function mapReportsArrayToReportsObject(reports: any): any;
+export function storeToResult(store: any, selector: any, options?: {}): any;
+export function mapResponseToReportsArray(response: any): any;

package/dist/types/src/features/aircraft/consts.d.ts

@@ -0,0 +1,3 @@
+export namespace PATHS {
+    let MAPPING: string;
+}

package/dist/types/src/features/aircraft/index.d.ts

@@ -0,0 +1 @@
+export * from "./service";

package/dist/types/src/features/aircraft/service.d.ts

@@ -0,0 +1,31 @@
+export class AircraftService {
+    constructor({ fetcher }: {
+        fetcher: any;
+    });
+    /**
+     * Fetches the aircraft mapping.
+     * @returns {Promise<Array<{
+     *  id: string,
+     *  icao: string,
+     *  iata: string,
+     *  group: string,
+     *  title: string,
+     *  size: string,
+     *  family: string,
+     *  created_at: string,
+     *  updated_at: string
+     * }>>} - The aircraft mapping.
+     */
+    getMapping(): Promise<Array<{
+        id: string;
+        icao: string;
+        iata: string;
+        group: string;
+        title: string;
+        size: string;
+        family: string;
+        created_at: string;
+        updated_at: string;
+    }>>;
+    #private;
+}

package/dist/types/src/features/cacheToken/consts.d.ts

@@ -0,0 +1,3 @@
+export namespace PATHS {
+    let TOKEN: string;
+}

package/dist/types/src/features/cacheToken/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./service";
+export * from "./utils";

package/dist/types/src/features/cacheToken/service.d.ts

@@ -0,0 +1,11 @@
+export class CacheTokenService {
+    constructor({ fetcher }: {
+        fetcher: any;
+    });
+    getToken: () => Promise<any>;
+    checkToken: (token: {
+        expireAt: string;
+        token: string;
+    }) => boolean;
+    #private;
+}

package/dist/types/src/features/cacheToken/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Check if the token is valid
+ *
+ * @param {{ expireAt: string, token: string }} token
+ * @returns {boolean}
+ */
+export function checkTokenIsValid(token: {
+    expireAt: string;
+    token: string;
+}): boolean;

package/dist/types/src/features/gtg/consts.d.ts

@@ -0,0 +1,4 @@
+export namespace PATHS {
+    let INFO: string;
+    let DATA: string;
+}

package/dist/types/src/features/gtg/index.d.ts

@@ -0,0 +1 @@
+export * from "./service";

package/dist/types/src/features/gtg/service.d.ts

@@ -0,0 +1,13 @@
+export class GtgService {
+    constructor({ fetcher }: {
+        fetcher: any;
+    });
+    getInfo(): Promise<any>;
+    getData({ resolution, hexId, lastUpdatedAt, token }: {
+        resolution: any;
+        hexId: any;
+        lastUpdatedAt: any;
+        token: any;
+    }): Promise<any>;
+    #private;
+}

package/dist/types/src/features/gtg/utils.d.ts

@@ -0,0 +1,3 @@
+export function getSeverityValueByEdrValue({ edrValue }: {
+    edrValue: any;
+}): 0 | 1 | 2 | 3 | 4;

package/dist/types/src/features/nowcasting/consts.d.ts

@@ -0,0 +1,20 @@
+export const DEFAULT_INTERVAL_TIME_MS: number;
+export const DEFAULT_RESOLUTION: 0;
+export const DEFAULT_MAP_DISPLAY_RESOLUTION: 5;
+export namespace PATHS {
+    let INFO: string;
+    let DATA: string;
+}
+export namespace INTERNAL_EVENTS {
+    let DATA_1: string;
+    export { DATA_1 as DATA };
+    export let UPDATE_CONFIG: string;
+    export let UPDATE_INTERVAL: string;
+    export let LOAD_NOWCASTING_DATA: string;
+    export let IS_PENDING_CHANGE: string;
+}
+export namespace DEFAULT_FILTER_VALUES {
+    let FORECAST: number;
+    let SEVERITY: number;
+    let ALTITUDE: number;
+}