@mappable-world/mappable-types 0.0.1 → 0.0.3

package/README.md

@@ -7,7 +7,7 @@ Type definitions for Mappable Maps JavaScript API (https://mappable.world).
 ## Getting started
 
 ```bash
-npm i @mappable/mappable-types -D
+npm i @mappable-world/mappable-types -D
 ```
 
 tsconfig.json
@@ -15,7 +15,7 @@ tsconfig.json
 ```json
 {
   "compilerOptions": {
-    "types": ["@mappable/mappable-types"]
+    "types": ["@mappable-world/mappable-types"]
   }
 }
 ```

package/imperative/MMap/index.d.ts

@@ -99,9 +99,6 @@ export type MMapProps = {
          */
     worldOptions?: WorldOptions;
 };
-export interface Experiments {
-    mappableVectorGraphics?: boolean;
-}
 declare const defaultProps: Readonly<{
     className: "";
     camera: {
@@ -122,7 +119,7 @@ declare const defaultProps: Readonly<{
         cycledY: boolean;
     };
     restrictMapArea: false;
-    readonly config: Config | undefined;
+    readonly config: Config;
     projection: Projection;
 }>;
 type DefaultProps = typeof defaultProps;
@@ -167,7 +164,7 @@ declare class MMap extends GenericRootEntity<MMapProps, DefaultProps> {
             cycledY: boolean;
         };
         restrictMapArea: false;
-        readonly config: Config | undefined;
+        readonly config: Config;
         projection: Projection;
     }>;
     /** @internal */

package/imperative/MMapCoverage/index.d.ts

@@ -2,6 +2,7 @@ import { MMapComplexEntity } from "../MMapEnities";
 interface MMapCoverageProps {
     onError?: (e: Error) => void;
 }
+export declare const COVERAGE_LAYERS_TO_SOURCES: Record<string, string>;
 /**
  * The component of loading data on copyrights on the map and the zoom range for
  * the area where the center of the map is located

package/imperative/MMapDefaultSchemeLayer/index.d.ts

@@ -42,7 +42,7 @@ declare const defaultProps: {
 };
 type DefaultProps = typeof defaultProps;
 /**
- * Map default layer to show mappable scheme on map.
+ * Map default layer to show mappable-world scheme on map.
  *
  * @example
  * ```javascript

package/imperative/MMapTileDataSource/index.d.ts

@@ -49,7 +49,7 @@ type MMapTileDataSourceProps = {
  * ```
  */
 declare class MMapTileDataSource extends MMapEntity<MMapTileDataSourceProps> {
-    private _id?;
+    private _id;
     protected _onAttach(): void;
     protected _onDetach(): void;
     protected _onUpdate(props: Partial<MMapTileDataSourceProps>): void;

package/imperative/config.d.ts

@@ -1,6 +1,5 @@
 export class Config {
+    readonly description: string;
+    setExperiments(experiments: Record<string, boolean>): void;
 }
-export type ConfigMeta = {
-    hosts: {};
-};
-export type ConfigMetaMetrics = {};
+export function getDefaultConfig(): Config;

package/imperative/index.d.ts

@@ -3,24 +3,26 @@ export { MMapCopyrightsPosition } from "./MMapCopyrights";
 export { MMapEntity, MMapComplexEntity, MMapGroupEntity, MMapContext } from "./MMapEnities";
 export { MMapDefaultFeaturesLayer, MMapDefaultFeaturesLayerProps } from "./MMapDefaultFeaturesLayer";
 export { MMapDefaultSchemeLayer, MMapDefaultSchemeLayerProps } from "./MMapDefaultSchemeLayer";
-export { MMapDefaultSatelliteLayer, MMapDefaultSatelliteLayerProps } from "./MMapDefaultSatelliteLayer";
 export * from "./MMapFeature";
 export { MMapFeatureDataSource, MMapFeatureDataSourceProps } from "./MMapFeatureDataSource";
 export { MMapLayer, MMapLayerProps } from "./MMapLayer";
 export * from "./MMapListener";
 export * from "./MMapHotspot";
+export * from "./wrappers";
 export { MMapMarker, MMapMarkerProps, MMapMarkerEventHandler } from "./MMapMarker";
 export { MMapTileDataSource, MMapTileDataSourceProps } from "./MMapTileDataSource";
 export { MMapControls, MMapControlsProps } from "./MMapControls";
 export { MMapControl, MMapControlProps, MMapControlButton, MMapControlButtonProps, MMapControlCommonButton } from "./MMapControl";
 export { MMapCollection } from "./MMapCollection";
-export * from "./mappableMaps";
+export * from "./mappable-worldMaps";
 export * from "./search";
 export * from "./suggest";
 export * from "./route";
 export { geolocation } from "./geolocation";
 export { useDomContext } from "./DomContext";
-export { Config } from "./config";
+export { Config, getDefaultConfig } from "./config";
 export { fetchConfig, FetchConfigOptions } from "./fetchConfig";
 export * as projections from "./utils/projections";
+/** Toggle this to enable/disable strict mode. */
+export declare let strictMode: boolean;
 export type { LngLat, ReadonlyLngLat, LngLatBounds, BehaviorType, MapMode, Margin, ZoomRange, ZoomStrategy, ZoomRounding, VectorCustomization, RasterTileDataSourceDescription, VectorTileDataSourceDescription, RasterLayerOptions, EasingFunctionDescription, EasingPresetName, EasingBezierPreset, EasingFunction, DrawingStyle, DrawingStyleIcon, VectorTileSize, VectorObjectsCollisionPriority, VectorDataSourcePriority } from "../common/types";

package/imperative/route/index.d.ts

@@ -44,8 +44,10 @@ export interface RouteOptions {
     results?: 1;
     /** Traffic jams requesting flag. If specified, jams will be returned in properties. Default is `false`. */
     jams?: boolean;
-    /** Traffic jams requesting flag. If specified, jams will be returned in properties. Default is `false`. */
+    /** If specified, bounding box of the route will be returned in properties. Default is `false`. */
     bounds?: boolean;
+    /** Avoid roads with tolls. Default is `false`. */
+    avoidTolls?: boolean;
 }
 export interface BaseRouteResponse {
     /** Return requested route as {@link RouteFeature RouteFeature}. */

package/imperative/suggest.d.ts

@@ -1,18 +1,22 @@
 import type { LngLat, LngLatBounds } from "../common/types";
 import { Config } from "./config";
-type GeoSuggestType = "all" | "toponyms" | "addresses" | "organizations";
+type DeprecatedGeoSuggestType = "all" | "toponyms" | "addresses" | "organizations";
+type GeoSuggestType = "biz" | "geo" | "street" | "metro" | "district" | "locality" | "area" | "province" | "country" | "house";
 export type SuggestOptions = {
     text: string;
     center?: LngLat;
     span?: LngLat;
     bounds?: LngLatBounds;
-    countries?: string;
-    type?: GeoSuggestType;
     limit?: number;
     localOnly?: number;
     highlight?: boolean;
+    types?: GeoSuggestType[];
+    /** @deprecated */
+    countries?: string;
+    /** @deprecated use types instead */
+    type?: DeprecatedGeoSuggestType;
 };
-type ObjectType = "unknown" | "toponym" | "business" | "transit";
+type DeprecatedObjectType = "unknown" | "toponym" | "business" | "transit";
 /** Positions of chars to highlight between  */
 type Highlight = [
     number,
@@ -22,15 +26,25 @@ type TextWithHighlight = {
     text: string;
     hl: Highlight[];
 };
+type Distance = {
+    text: string;
+    value: number;
+};
 export type SuggestResponseItem = {
-    /** Type of suggested object */
-    type?: ObjectType;
     /** Human-readable object title with matching highlighting */
     title: TextWithHighlight;
     /** Human-readable object subtitle with matching highlighting */
     subtitle?: TextWithHighlight;
-    /** Object value. Useful for next substitution in mappable.search function */
+    /** Distance to the object in meters */
+    distance?: Distance;
+    /** Additional object information that can be used in a Geocoder HTTP API request. */
+    uri?: string;
+    /** Object tags. Possible values: business, street, metro, district, locality, area, province, country, hydro, railway, station, route, vegetation, airport, other, house */
+    tags?: string[];
+    /** @deprecated Use uri instead */
     value: string;
+    /** @deprecated Use tags instead */
+    type?: DeprecatedObjectType;
 };
 export type SuggestResponse = SuggestResponseItem[];
 export declare function suggest(options: SuggestOptions, config?: Config | undefined): Promise<SuggestResponse>;

package/imperative/utils/metrics.d.ts

@@ -1,4 +1,5 @@
-import type { ConfigMetaMetrics } from "../config";
+/** @internal */
+export type MetricsConfig = {};
 type Metrics = {};
 type TransportOptions = {
     share?: number;
@@ -9,8 +10,8 @@ type CreateTransportOptions = {
     /** Events with share (if defined) less than this value will not be sent, should be in [0, 1] range */
     sendBoundary?: number;
 };
-export declare function createMetricsTransport<T extends Record<string, unknown>>(metaMetrics: ConfigMetaMetrics, options?: CreateTransportOptions): MetricsTransport<T>;
+export declare function createMetricsTransport<T extends Record<string, unknown>>(config: MetricsConfig, options?: CreateTransportOptions): MetricsTransport<T>;
 export declare const SEND_BOUNDARY: number;
-export declare function initMetrics(config: ConfigMetaMetrics): void;
+export declare function initMetrics(config: MetricsConfig): void;
 export declare function sendMetrics(data: Metrics, options?: TransportOptions): void;
 export {};

package/imperative/wrappers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Key is used in `reactify` wrapper, to define custom implementations for react mappable.MMapEntity entities
+ * ```typescript
+ * type MMapSomeClassProps = {
+ *     id: string;
+ * };
+ * export class MMapSomeClass extends mappable.MMapComplexEntity<MMapSomeClassProps> {
+ *  static [mappable.overrideKeyReactify] = MMapSomeClassReactifyOverride;
+ *  //...
+ * }
+ * ```
+ * and
+ * ```jsx
+ * export const MMapSomeClassReactifyOverride = (
+ *   MMapSomeClassI, // it is same MMapSomeClass
+ *   {reactify, React}
+ * ) => {
+ *   const MMapSomeClassReactified = reactify.entity(MMapSomeClassI); // Standard reactivation method
+ *     const MMapSomeClassR = React.forwardRef((props, ref) => {
+ *       return (<>
+ *         <MMapSomeClassReactified {...props} ref={ref} ... />
+ *       </>);
+ *     })
+ *   return MMapSomeClassR;
+ * }
+ * ```
+ * and in the end app
+ * ```jsx
+ * import {MMapSomeClass} from './some-class';
+ * import React from 'react';
+ * import ReactDOM from 'react-dom';
+ * // ...
+ * const mappableReact = await mappable.import('@mappable-world/mappable-reactify');
+ * const reactify = mappableReact.reactify.bindTo(React, ReactDOM);
+ * const {MMapSomeClass as MMapSomeClassR} = reactify.module({MMapSomeClass});
+ *
+ * function App() {
+ *     return <MMapSomeClassR id="some_id"/>;
+ * }
+ * ```
+ */
+export declare const overrideKeyReactify: unique symbol;

package/import.d.ts

@@ -20,7 +20,7 @@ export interface Import {
 declare global {
     const __MODULES__: string[];
     const __PACKAGES__: string[];
-    const __VENDOR__: "mappable" | "mappable";
+    const __VENDOR__: "mappable-world" | "mappable-world";
     const __NAMESPACE__: "mappable" | "mappable";
     const __LOGO_WIDHT__: `${number}px`;
 }

package/main.d.ts

@@ -1,4 +1,2 @@
 export * from "./imperative";
-/** Toggle this to enable/disable strict mode. */
-export declare let strictMode: boolean;
 export declare const __DTS_HIDDEN_BEGIN__: unknown;

package/modules/types.d.ts

@@ -1,7 +1,7 @@
 import "../import";
 declare module "../import" {
     interface Import {
-        (pkg: "@mappable/mappable-controls-extra"): Promise<typeof import("./controls-extra")>;
-        (pkg: "@mappable/mappable-reactify"): Promise<typeof import("../reactify")>;
+        (pkg: "@mappable-world/mappable-controls-extra"): Promise<typeof import("./controls-extra")>;
+        (pkg: "@mappable-world/mappable-reactify"): Promise<typeof import("../reactify")>;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mappable-world/mappable-types",
-    "version": "0.0.1",
+    "version": "0.0.3",
     "description": "Types for mappable maps library",
     "main": "",
     "types": "index.d.ts",

package/packages/cartesian-projection/index.d.ts

@@ -18,7 +18,7 @@ import type { Projection, LngLat, WorldCoordinates } from "../../common/types";
  *     const PIC_WIDTH = 2526;
  *     const PIC_HEIGHT = 1642;
  *
- *     const {Cartesian} = await mappable.import('@mappable/mappable-cartesian-projection@0.0.1');
+ *     const {Cartesian} = await mappable.import('@mappable-world/mappable-cartesian-projection@0.0.1');
  *     // We set as a projection Cartesian. With this calculation, the center of the image will lie in the coordinates [0, 0].
  *     const projection = new Cartesian([
  *         [-PIC_WIDTH / 2, PIC_HEIGHT / 2 - worldSize],

package/packages/clusterer/MMapClusterer/MMapClusterer.d.ts

@@ -1,6 +1,5 @@
 import type { MMapEntity } from "../../..";
 import type { LngLat } from "../../../common/types";
-import { reactify } from "../../../reactify";
 import type { ClustererObject, Feature, IClusterMethod } from "./interface";
 /**
  * MMapClusterer props
@@ -21,7 +20,7 @@ type MMapClustererProps = {
 };
 type DefaultProps = typeof defaultProps;
 declare const defaultProps: Readonly<{
-    tickTimeout: 100;
+    tickTimeout: 200;
 }>;
 /**
  * Display clustered features on a map.
@@ -49,10 +48,10 @@ declare const defaultProps: Readonly<{
  */
 declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProps, DefaultProps> {
     static defaultProps: Readonly<{
-        tickTimeout: 100;
+        tickTimeout: 200;
     }>;
     /** @internal */
-    static [reactify.overrideKey]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<MMapClustererProps & {
+    static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapClusterer, import("react").ForwardRefExoticComponent<MMapClustererProps & {
         marker: (feature: Feature) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
         cluster: (coordinates: LngLat, features: Feature[]) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
     } & import("react").RefAttributes<MMapEntity<MMapClustererProps & {
@@ -60,7 +59,7 @@ declare class MMapClusterer extends mappable.MMapComplexEntity<MMapClustererProp
         cluster: (coordinates: LngLat, features: Feature[]) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
     }, {}>>>>;
     /** All created entities with cluster id*/
-    private _entitiesData;
+    private _entitiesCache;
     /** Viewport entities with cluster id */
     private _visibleEntities;
     /** Store to add entities on a map */

package/packages/clusterer/MMapClusterer/constants.d.ts

@@ -1 +1 @@
-export declare const THROTTLE_DEFAULT_TIMEOUT_MS = 100;
+export declare const THROTTLE_DEFAULT_TIMEOUT_MS = 200;

package/packages/controls/MMapZoomControl/index.d.ts

@@ -20,7 +20,7 @@ type DefaultProps = typeof defaultProps;
  * @example
  * ```javascript
  * const controls = new MMapControls({position: 'right'});
- * const {MMapZoomControl} = await mappable.import('@mappable/mappable-controls@0.0.1');
+ * const {MMapZoomControl} = await mappable.import('@mappable-world/mappable-controls@0.0.1');
  * const zoomControl = new MMapZoomControl();
  * controls.addChild(zoomControl);
  * map.addChild(controls);

package/packages/hint/MMapHint/index.d.ts

@@ -11,14 +11,14 @@ declare const MMapHintContext: import("../../../imperative/Entities").Context<un
  *
  * @example
  * ```javascript
- * const {MMapHint, MMapHintContext} = await mappable.import('@mappable/mappable-hint@0.0.1');
+ * const {MMapHint, MMapHintContext} = await mappable.import('@mappable-world/mappable-hint@0.0.1');
  * map.addChild(defaultFeatures = new MMapDefaultFeaturesLayer());
  * map.addChild(hint = MMapHint({
  *    layers: [defaultFeatures.layer],
  *    hint: object => object?.properties?.hint
  * }));
  *
- * const {MMapDefaultMarker} = await mappable.import('@mappable/mappable-markers@0.0.1');
+ * const {MMapDefaultMarker} = await mappable.import('@mappable-world/mappable-markers@0.0.1');
  * map.addChild(new MMapDefaultMarker({coordinates: [37, 55], properties: {hint: 'Hello world!'}}));
  *
  * hint.addChild(new class MyHint extends mappable.MMapEntity {

package/packages/markers/MMapDefaultMarker/index.d.ts

@@ -1,6 +1,5 @@
 import type { LngLat } from "../../../common/types";
 import type { MMapMarkerProps } from "../../../imperative/MMapMarker";
-import { reactify } from "../../../reactify";
 type DefaultMarkerCustomProps = {
     /** Marker title */
     title?: string;
@@ -31,7 +30,7 @@ type DefaultProps = typeof defaultProps;
  *
  * @example
  * ```javascript
- * const {MMapDefaultMarker} = await mappable.import('@mappable/mappable-markers@0.0.1');
+ * const {MMapDefaultMarker} = await mappable.import('@mappable-world/mappable-markers@0.0.1');
  * map.addChild(new MMapDefaultMarker({
  *     coordinates: [34, 54],
  *     title: 'Hello World!',
@@ -45,8 +44,8 @@ declare class MMapDefaultMarker extends mappable.MMapComplexEntity<MMapDefaultMa
         color: "#f33";
     }>;
     /** @internal */
-    static [reactify.overrideKey]: import("../../../reactify/reactify").CustomReactify<MMapDefaultMarker, import("react").ForwardRefExoticComponent<{
-        coordinates: LngLat;
+    static [mappable.overrideKeyReactify]: import("../../../reactify/reactify").CustomReactify<MMapDefaultMarker, import("react").ForwardRefExoticComponent<{
+        coordinates: LngLat; /** Should popup hide marker. Default is false */
         source?: string | undefined;
         zIndex?: number | undefined;
         properties?: Record<string, unknown> | undefined;

package/packages/spherical-mercator-projection/index.d.ts

@@ -7,7 +7,7 @@ import type { Projection } from "../../common/types";
  * @static
  * @example
  * ```js
- * const { SphericalMercator } = await mappable.import('@mappable/mappable-spherical-mercator-projection@0.0.1');
+ * const { SphericalMercator } = await mappable.import('@mappable-world/mappable-spherical-mercator-projection@0.0.1');
  * // Create a map in the spherical Mercator projection
  * const map = new mappable.MMap(document.getElementById('MMapsID'), {
  *     location: {

package/packages/types.d.ts

@@ -1,11 +1,11 @@
 import "../import";
 declare module "../import" {
     interface Import {
-        (pkg: "@mappable/mappable-cartesian-projection@0.0.1"): Promise<typeof import("./cartesian-projection")>;
-        (pkg: "@mappable/mappable-spherical-mercator-projection@0.0.1"): Promise<typeof import("./spherical-mercator-projection")>;
-        (pkg: "@mappable/mappable-controls@0.0.1"): Promise<typeof import("./controls")>;
-        (pkg: "@mappable/mappable-markers@0.0.1"): Promise<typeof import("./markers")>;
-        (pkg: "@mappable/mappable-hint@0.0.1"): Promise<typeof import("./hint")>;
-        (pkg: "@mappable/mappable-clusterer@0.0.1"): Promise<typeof import("./clusterer")>;
+        (pkg: "@mappable-world/mappable-cartesian-projection@0.0.1"): Promise<typeof import("./cartesian-projection")>;
+        (pkg: "@mappable-world/mappable-spherical-mercator-projection@0.0.1"): Promise<typeof import("./spherical-mercator-projection")>;
+        (pkg: "@mappable-world/mappable-controls@0.0.1"): Promise<typeof import("./controls")>;
+        (pkg: "@mappable-world/mappable-markers@0.0.1"): Promise<typeof import("./markers")>;
+        (pkg: "@mappable-world/mappable-hint@0.0.1"): Promise<typeof import("./hint")>;
+        (pkg: "@mappable-world/mappable-clusterer@0.0.1"): Promise<typeof import("./clusterer")>;
     }
 }

package/reactify/index.d.ts

@@ -1,10 +1,10 @@
 import type { Reactify, ReactifyEntity, ReactifiedEntity, ReactifyModule, ReactifiedModule } from "./reactify";
-import { overrideKey } from "./reactify";
+import { overrideKeyReactify } from "../imperative/wrappers";
 type TReact = typeof import("react");
 type TReactDOM = typeof import("react-dom");
 export type { Reactify, ReactifyEntity, ReactifiedEntity, ReactifyModule, ReactifiedModule };
 export type GenericReactify = {
-    readonly overrideKey: typeof overrideKey;
+    readonly overrideKey: typeof overrideKeyReactify;
     bindTo(React: TReact, ReactDOM: TReactDOM): Reactify;
 };
 export declare const reactify: Readonly<GenericReactify>;

package/reactify/reactify.d.ts

@@ -1,6 +1,7 @@
 import type TReact from "react";
 import type TReactDOM from "react-dom";
 import { GenericEntity, Context, EntityConstructor, EntityProps } from "../imperative/Entities";
+import { overrideKeyReactify } from "../imperative/wrappers";
 type RefInstance<TEntity extends GenericEntity<unknown>> = React.MutableRefObject<TEntity | undefined>;
 interface ReactParent {
     entityRef: RefInstance<GenericEntity<unknown>>;
@@ -15,7 +16,6 @@ export type Reactify = {
     entity: ReactifyEntity;
 };
 export declare const moduleOverrideExport: string;
-export declare const overrideKey: unique symbol;
 export type CustomReactify<TEntity extends GenericEntity<unknown>, TResult> = (ctor: EntityConstructor<TEntity>, params: {
     reactify: {
         module: <TModule extends BaseModule>(module: TModule) => ReactifiedModule<TModule>;
@@ -27,7 +27,7 @@ export type CustomReactify<TEntity extends GenericEntity<unknown>, TResult> = (c
     ReactDOM: typeof TReactDOM;
 }) => TResult;
 export type Overrided<TReactResult> = {
-    [overrideKey]: CustomReactify<GenericEntity<unknown>, TReactResult>;
+    [overrideKeyReactify]: CustomReactify<GenericEntity<unknown>, TReactResult>;
 };
 type InternalReactify<TEntity extends GenericEntity<unknown>> = (ctor: EntityConstructor<TEntity>, displayName?: string) => TReact.ForwardRefExoticComponent<TReact.PropsWithoutRef<TReact.PropsWithChildren<EntityProps<TEntity>>> & React.RefAttributes<TEntity | undefined>>;
 type InternalReactifyEntity<TCtor extends EntityConstructor<GenericEntity<unknown>>> = (ctor: TCtor, displayName?: string) => TCtor extends Overrided<infer TResult> ? TResult : ReturnType<InternalReactify<InstanceType<TCtor>>>;

package/imperative/MMapDefaultSatelliteLayer/index.d.ts

@@ -1,41 +0,0 @@
-import { MMapComplexEntity } from "../MMapEnities";
-/**
- * MMapDefaultSatelliteLayer props
- */
-type MMapDefaultSatelliteLayerProps = {
-    /** Should show layer */
-    visible?: boolean;
-};
-declare const defaultProps: {
-    readonly visible: true;
-    readonly source: "mappable-default-satellite";
-};
-type DefaultProps = typeof defaultProps;
-/**
- * Map satellite layer to show satellite tiles on map.
- *
- * @example
- * ```javascript
- * const defaultSatelliteLayer = new MMapDefaultSatelliteLayer();
- * // add to map
- * map.addChild(defaultSatelliteLayer);
- * // update
- * defaultSatelliteLayer.update({visible: false});
- * ```
- */
-declare class MMapDefaultSatelliteLayer extends MMapComplexEntity<MMapDefaultSatelliteLayerProps, DefaultProps> {
-    static defaultProps: {
-        readonly visible: true;
-        readonly source: "mappable-default-satellite";
-    };
-    private _dataSource?;
-    private _layer?;
-    private _unwatchMapContext?;
-    protected __implGetDefaultProps(): DefaultProps;
-    protected _onAttach(): void;
-    protected _onDetach(): void;
-    protected _onUpdate(propsDiff: Partial<MMapDefaultSatelliteLayerProps>): void;
-    private _createTileUrl;
-    private _getDataSourceDescription;
-}
-export { MMapDefaultSatelliteLayer, MMapDefaultSatelliteLayerProps };

package/init.template.d.ts

@@ -1,33 +0,0 @@
-import { ConfigMeta } from "./imperative/config";
-import type { Import } from "./import";
-import { mappableImport } from "./import";
-interface Config {
-    meta?: ConfigMeta;
-    src: {
-        base: string;
-    };
-}
-interface AdhocConfig {
-    /** All logic with this field is for development and CI only. */
-    adhoc?: {
-        meta: {
-            hosts: ConfigMeta["hosts"];
-            apikey: string;
-        };
-        options: {
-            lang: string;
-            signal?: AbortSignal;
-        };
-    };
-}
-type MainModule = typeof import("./main");
-interface MMaps3 extends MainModule {
-    import: Import;
-    ready: Promise<void>;
-    __implReactify: typeof import("./reactify");
-}
-declare global {
-    const __CFG__: Config & AdhocConfig;
-}
-declare const ready: Promise<MMaps3>;
-export { mappableImport as import, ready };