@reearth/core 0.0.7-alpha.5 → 0.0.7-beta.1

package/dist/index.d.ts

@@ -20,13 +20,6 @@ import { RefObject } from 'react';
 import { RequireExactlyOne } from 'type-fest';
 import { WritableAtom } from 'jotai';
 
-export declare type AmbientOcclusionProperty = {
-    enabled?: boolean;
-    quality?: "low" | "medium" | "high" | "extreme";
-    intensity?: number;
-    ambientOcclusionOnly?: boolean;
-};
-
 export declare const appearanceKeyObj: {
     [k in keyof AppearanceTypes]: 1;
 };
@@ -53,18 +46,6 @@ export declare type AppearanceTypes = {
 declare type Array_2 = any[];
 export { Array_2 as Array }
 
-export declare type AssetsCesiumProperty = {
-    terrain?: {
-        ionAccessToken?: string;
-        ionAsset?: string;
-        ionUrl?: string;
-    };
-};
-
-export declare type AssetsProperty = {
-    cesium?: AssetsCesiumProperty;
-};
-
 export declare type Atom = ReturnType<typeof computeAtom>;
 
 export declare type Bound = {
@@ -119,14 +100,6 @@ export declare type Camera = {
     aspectRatio?: number;
 };
 
-export declare type CameraLimiterProperty = {
-    enabled?: boolean;
-    targetArea?: Camera;
-    targetWidth?: number;
-    targetLength?: number;
-    showHelper?: boolean;
-};
-
 export declare type CameraOptions = {
     /** Seconds */
     duration?: number;
@@ -137,28 +110,23 @@ export declare type CameraOptions = {
 /** Represents the camera position and state */
 export declare type CameraPosition = {
     /** degrees */
-    lat?: number;
+    lat: number;
     /** degrees */
-    lng?: number;
+    lng: number;
     /** meters */
-    height?: number;
+    height: number;
     /** radians */
-    heading?: number;
+    heading: number;
     /** radians */
-    pitch?: number;
+    pitch: number;
     /** radians */
-    roll?: number;
+    roll: number;
     /** Field of view expressed in radians */
-    fov?: number;
+    fov: number;
     /** Aspect ratio of frustum */
     aspectRatio?: number;
 };
 
-export declare type CameraProperty = {
-    allowEnterGround?: boolean;
-    limiter?: CameraLimiterProperty;
-};
-
 export declare type Cesium3DTilesAppearance = {
     show?: boolean;
     color?: string;
@@ -317,6 +285,8 @@ declare type CoreContext = {
     };
     selectedComputedFeature?: ComputedFeature | undefined;
     viewport?: Viewport;
+    overriddenSceneProperty?: SceneProperty;
+    overrideSceneProperty?: (pluginId: string, property: SceneProperty) => void;
     handleCameraForceHorizontalRollChange?: (enable?: boolean) => void;
     handleInteractionModeChange?: (mode?: InteractionModeType | undefined) => void;
     onSketchPluginFeatureCreate?: (cb: SketchEventCallback) => void;
@@ -339,10 +309,9 @@ export declare type CoreVisualizerProps = {
     engine?: EngineType;
     isBuilt?: boolean;
     isEditable?: boolean;
-    viewerProperty?: ViewerProperty;
+    sceneProperty?: SceneProperty;
     layers?: Layer[];
     clusters?: Cluster[];
-    time?: string | Date;
     camera?: Camera;
     interactionMode?: InteractionModeType;
     shouldRender?: boolean;
@@ -402,11 +371,6 @@ export declare type DataRange = {
 
 export declare type DataType = "geojson" | "3dtiles" | "osm-buildings" | "google-photorealistic" | "czml" | "csv" | "wms" | "mvt" | "kml" | "gpx" | "shapefile" | "gtfs" | "gml" | "georss" | "gltf" | "tiles" | "tms" | "heatMap";
 
-export declare type DebugProperty = {
-    showGlobeWireframe?: boolean;
-    showFramesPerSecond?: boolean;
-};
-
 export declare type DefaultInfobox = {
     title?: string;
     content: {
@@ -421,14 +385,6 @@ export declare type DefaultInfobox = {
     };
 };
 
-export declare type ElevationHeatMapProperty = {
-    type?: "custom";
-    colorLUT?: LUT;
-    minHeight?: number;
-    maxHeight?: number;
-    logarithmic?: boolean;
-};
-
 export declare type EllipseAppearance = {
     show?: boolean;
     heightReference?: "none" | "clamp" | "relative";
@@ -472,8 +428,7 @@ export declare type EngineProps = {
     style?: CSSProperties;
     isEditable?: boolean;
     isBuilt?: boolean;
-    property?: ViewerProperty;
-    time?: string | Date;
+    property?: SceneProperty;
     camera?: Camera;
     cameraForceHorizontalRoll?: boolean;
     small?: boolean;
@@ -520,7 +475,7 @@ export declare type EngineRef = {
     getLocationFromScreen: (x: number, y: number, withTerrain?: boolean) => LatLngHeight | undefined;
     sampleTerrainHeight: (lng: number, lat: number) => Promise<number | undefined>;
     computeGlobeHeight: (lng: number, lat: number, height?: number) => number | undefined;
-    getGlobeHeight: () => number | undefined;
+    getGlobeHeight: () => void;
     toXYZ: (lng: number, lat: number, height: number, options?: {
         useGlobeEllipsoid?: boolean;
     }) => [x: number, y: number, z: number] | undefined;
@@ -700,7 +655,7 @@ export declare const FEATURE_FLAGS: {
 
 export declare type FeatureComponentProps = {
     layer: ComputedLayer;
-    viewerProperty?: ViewerProperty;
+    sceneProperty?: SceneProperty;
     onFeatureRequest?: (range: DataRange) => void;
     onLayerFetch?: (value: Partial<Pick<LayerSimple, "properties">>) => void;
     onFeatureFetch?: (features: Feature[]) => void;
@@ -731,11 +686,6 @@ export declare type FlyToDestination = {
     fov?: number;
 };
 
-export declare type FogProperty = {
-    enabled?: boolean;
-    density?: number;
-};
-
 export declare type FrustumAppearance = {
     show?: boolean;
     color?: string;
@@ -771,21 +721,6 @@ declare const globalDataFeaturesCache: {
     getAll: Atom_2<(key: string) => Feature[][] | undefined>;
 };
 
-export declare type GlobeAtmosphereProperty = {
-    enabled?: boolean;
-    lightIntensity?: number;
-    brightnessShift?: number;
-    hueShift?: number;
-    saturationShift?: number;
-};
-
-export declare type GlobeProperty = {
-    baseColor?: string;
-    enableLighting?: boolean;
-    atmosphere?: GlobeAtmosphereProperty;
-    depthTestAgainstTerrain?: boolean;
-};
-
 export declare function guessType(url: string | undefined): DataType | undefined;
 
 export declare type HeatMapAppearance = {
@@ -804,18 +739,7 @@ export declare type HeatMapAppearance = {
     logarithmic?: boolean;
 };
 
-export declare type ImageBasedLighting = {
-    enabled?: boolean;
-    intensity?: number;
-    specularEnvironmentMaps?: string;
-    sphericalHarmonicCoefficients?: [number, number, number][];
-};
-
-export declare type IndicatorProperty = {
-    type?: "default" | "crosshair" | "custom";
-    image?: string;
-    imageScale?: number;
-};
+export declare type IndicatorTypes = "default" | "crosshair" | "custom";
 
 declare type Infobox<BP = any> = {
     featureId?: string;
@@ -954,7 +878,6 @@ export declare type LayersRef = {
     }) | null) => void;
     deleteLayer: (...ids: string[]) => void;
     isLayer: (obj: any) => obj is LazyLayer;
-    isComputedLayer: (obj: any) => obj is ComputedLayer;
     layers: () => LazyLayer[];
     walk: <T>(fn: (layer: LazyLayer, index: number, parents: LazyLayer[]) => T | void) => T | undefined;
     find: (fn: (layer: LazyLayer, index: number, parents: LazyLayer[]) => boolean) => LazyLayer | undefined;
@@ -1044,11 +967,100 @@ export declare type LegacyPhotooverlayAppearance = {
     far?: number;
 };
 
-export declare type LightProperty = {
-    type?: "sunLight" | "directionalLight";
-    direction?: [x: number, y: number, z: number];
-    color?: string;
-    intensity?: number;
+declare type LegacySceneProperty = {
+    default?: {
+        camera?: Camera;
+        allowEnterGround?: boolean;
+        skybox?: boolean;
+        bgcolor?: string;
+        ion?: string;
+        sceneMode?: SceneMode;
+        vr?: boolean;
+    } & TerrainProperty;
+    cameraLimiter?: {
+        cameraLimitterEnabled?: boolean;
+        cameraLimitterShowHelper?: boolean;
+        cameraLimitterTargetArea?: Camera;
+        cameraLimitterTargetWidth?: number;
+        cameraLimitterTargetLength?: number;
+    };
+    indicator?: {
+        indicator_type: IndicatorTypes;
+        indicator_image?: string;
+        indicator_image_scale?: number;
+    };
+    tiles?: {
+        id: string;
+        tile_type?: string;
+        tile_url?: string;
+        tile_zoomLevel?: number[];
+        tile_opacity?: number;
+    }[];
+    terrain?: TerrainProperty;
+    atmosphere?: {
+        enable_sun?: boolean;
+        enableMoon?: boolean;
+        enable_lighting?: boolean;
+        ground_atmosphere?: boolean;
+        sky_atmosphere?: boolean;
+        shadows?: boolean;
+        shadowResolution?: 1024 | 2048 | 4096;
+        softShadow?: boolean;
+        shadowDarkness?: number;
+        shadowMaximumDistance?: number;
+        fog?: boolean;
+        fog_density?: number;
+        hue_shift?: number;
+        brightness_shift?: number;
+        surturation_shift?: number;
+        skyboxBrightnessShift?: number;
+        skyboxSurturationShift?: number;
+        globeShadowDarkness?: number;
+        globeImageBasedLighting?: boolean;
+        globeBaseColor?: string;
+    };
+    timeline?: {
+        animation?: boolean;
+        visible?: boolean;
+        current?: string;
+        start?: string;
+        stop?: string;
+        stepType?: "rate" | "fixed";
+        multiplier?: number;
+        step?: number;
+        rangeType?: "unbounded" | "clamped" | "bounced";
+    };
+    googleAnalytics?: {
+        enableGA?: boolean;
+        trackingId?: string;
+    };
+    theme?: {
+        themeType?: "light" | "dark" | "forest" | "custom";
+        themeTextColor?: string;
+        themeSelectColor?: string;
+        themeBackgroundColor?: string;
+    };
+    ambientOcclusion?: {
+        enabled?: boolean;
+        quality?: "low" | "medium" | "high" | "extreme";
+        intensity?: number;
+        ambientOcclusionOnly?: boolean;
+    };
+    light?: {
+        lightType?: "sunLight" | "directionalLight";
+        lightDirectionX?: number;
+        lightDirectionY?: number;
+        lightDirectionZ?: number;
+        lightColor?: string;
+        lightIntensity?: number;
+        specularEnvironmentMaps?: string;
+        sphericalHarmonicCoefficients?: [x: number, y: number, z: number][];
+        imageBasedLightIntensity?: number;
+    };
+    render?: {
+        antialias?: "low" | "medium" | "high" | "extreme";
+        debugFramePerSecond?: boolean;
+    };
 };
 
 export declare type LookAtDestination = {
@@ -1075,7 +1087,7 @@ export declare type LUT = readonly ColorTuple[];
 declare const Map_2: ForwardRefExoticComponent<    {
 engines?: Record<string, Engine> | undefined;
 engine?: string | undefined;
-} & Omit<Props_2, "Feature" | "viewerProperty" | "selectionReason" | "delegatedDataTypes" | "clusterComponent" | "selectedLayerId"> & Omit<EngineProps, "onLayerSelect" | "selectedLayerId" | "layerSelectionReason"> & Omit<SketchProps, "engineRef" | "layersRef" | "SketchComponent"> & {
+} & Omit<Props_2, "Feature" | "selectionReason" | "delegatedDataTypes" | "clusterComponent" | "selectedLayerId"> & Omit<EngineProps, "onLayerSelect" | "selectedLayerId" | "layerSelectionReason"> & Omit<SketchProps, "engineRef" | "layersRef" | "SketchComponent"> & {
 cursor?: CursorType | undefined;
 } & RefAttributes<MapRef>>;
 export { Map_2 as Map }
@@ -1165,10 +1177,6 @@ export declare type ModifiedCameraEventType = {
     modifier: OverideKeyboardEventModifier;
 };
 
-export declare type MoonProperty = {
-    show?: boolean;
-};
-
 export declare type MouseEventCallback = (props: MouseEventProps) => void;
 
 export declare type MouseEventCallbacks = {
@@ -1177,18 +1185,18 @@ export declare type MouseEventCallbacks = {
 
 export declare type MouseEventHandles = {
     onClick: (fn: MouseEvents["click"]) => void;
-    onDoubleClick: (fn: MouseEvents["doubleClick"]) => void;
-    onMouseDown: (fn: MouseEvents["mouseDown"]) => void;
-    onMouseUp: (fn: MouseEvents["mouseUp"]) => void;
-    onRightClick: (fn: MouseEvents["rightClick"]) => void;
-    onRightDown: (fn: MouseEvents["rightDown"]) => void;
-    onRightUp: (fn: MouseEvents["rightUp"]) => void;
-    onMiddleClick: (fn: MouseEvents["middleClick"]) => void;
-    onMiddleDown: (fn: MouseEvents["middleDown"]) => void;
-    onMiddleUp: (fn: MouseEvents["middleUp"]) => void;
-    onMouseMove: (fn: MouseEvents["mouseMove"]) => void;
-    onMouseEnter: (fn: MouseEvents["mouseEnter"]) => void;
-    onMouseLeave: (fn: MouseEvents["mouseLeave"]) => void;
+    onDoubleClick: (fn: MouseEvents["doubleclick"]) => void;
+    onMouseDown: (fn: MouseEvents["mousedown"]) => void;
+    onMouseUp: (fn: MouseEvents["mouseup"]) => void;
+    onRightClick: (fn: MouseEvents["rightclick"]) => void;
+    onRightDown: (fn: MouseEvents["rightdown"]) => void;
+    onRightUp: (fn: MouseEvents["rightup"]) => void;
+    onMiddleClick: (fn: MouseEvents["middleclick"]) => void;
+    onMiddleDown: (fn: MouseEvents["middledown"]) => void;
+    onMiddleUp: (fn: MouseEvents["middleup"]) => void;
+    onMouseMove: (fn: MouseEvents["mousemove"]) => void;
+    onMouseEnter: (fn: MouseEvents["mouseenter"]) => void;
+    onMouseLeave: (fn: MouseEvents["mouseleave"]) => void;
     onWheel: (fn: MouseEvents["wheel"]) => void;
 };
 
@@ -1208,7 +1216,7 @@ export declare type MouseEvents = {
     wheel: MouseWheelEventCallback;
 };
 
-export declare type MouseEventTypes = "click" | "doubleClick" | "mouseDown" | "mouseUp" | "rightClick" | "rightDown" | "rightUp" | "middleClick" | "middleDown" | "middleUp" | "mouseMove" | "mouseEnter" | "mouseLeave" | "wheel";
+export declare type MouseEventTypes = "click" | "doubleclick" | "mousedown" | "mouseup" | "rightclick" | "rightdown" | "rightup" | "middleclick" | "middledown" | "middleup" | "mousemove" | "mouseenter" | "mouseleave" | "wheel";
 
 export declare type MouseWheelEventCallback = (props: MouseEventProps) => void;
 
@@ -1317,7 +1325,7 @@ declare type PropertyItem<T> = {
 export declare type Props = {
     engines?: Record<string, Engine>;
     engine?: string;
-} & Omit<Props_2, "Feature" | "clusterComponent" | "selectionReason" | "delegatedDataTypes" | "selectedLayerId" | "viewerProperty"> & Omit<EngineProps, "onLayerSelect" | "layerSelectionReason" | "selectedLayerId"> & Omit<SketchProps, "layersRef" | "engineRef" | "SketchComponent"> & {
+} & Omit<Props_2, "Feature" | "clusterComponent" | "selectionReason" | "delegatedDataTypes" | "selectedLayerId"> & Omit<EngineProps, "onLayerSelect" | "layerSelectionReason" | "selectedLayerId"> & Omit<SketchProps, "layersRef" | "engineRef" | "SketchComponent"> & {
     cursor?: CursorType;
 };
 
@@ -1328,7 +1336,7 @@ declare type Props_2 = Omit<Props_3, "atomMap" | "isHidden" | "selectedLayerId">
         reason?: LayerSelectionReason;
     };
     hiddenLayers?: string[];
-    viewerProperty?: ViewerProperty;
+    sceneProperty?: any;
     requestingRenderMode?: MutableRefObject<RequestingRenderMode>;
     engineRef?: RefObject<EngineRef>;
     onLayerSelect?: (layerId: string | undefined, featureId: string | undefined, layer: (() => Promise<ComputedLayer | undefined>) | undefined, reason: LayerSelectionReason | undefined, info: SelectedFeatureInfo | undefined) => void;
@@ -1345,7 +1353,7 @@ declare type Props_3 = {
     isHidden?: (id: string) => boolean;
     clusters?: Cluster[];
     delegatedDataTypes?: DataType[];
-    viewerProperty?: ViewerProperty;
+    sceneProperty?: any;
     clusterComponent?: ClusterComponentType;
     Feature?: Props_4["Feature"];
 } & Omit<CommonProps, "isSelected" | "isHidden" | "selectedFeatureId">;
@@ -1355,7 +1363,7 @@ declare type Props_4 = {
     atom?: Atom;
     overrides?: Record<string, any>;
     delegatedDataTypes?: DataType[];
-    viewerProperty?: ViewerProperty;
+    sceneProperty?: any;
     selectedFeatureId?: string;
     /** Feature component should be injected by a map engine. */
     Feature?: ComponentType<FeatureComponentProps>;
@@ -1378,11 +1386,6 @@ export declare type Rect = {
     north: number;
 };
 
-export declare type RenderPeropty = {
-    antialias?: "low" | "medium" | "high" | "extreme";
-    ambientOcclusion?: AmbientOcclusionProperty;
-};
-
 export declare type RequestingRenderMode = -1 | 0 | 1;
 
 export declare type ResourceAppearance = {
@@ -1401,15 +1404,67 @@ export declare type ResourceAppearance = {
 export declare type SceneMode = "3d" | "2d" | "columbus";
 
 export declare type SceneProperty = {
-    backgroundColor?: string;
-    mode?: SceneMode;
-    verticalExaggeration?: number;
-    verticalExaggerationRelativeHeight?: number;
-    vr?: boolean;
-    light?: LightProperty;
-    shadow?: ShadowProperty;
-    imageBasedLighting?: ImageBasedLighting;
-};
+    main?: {
+        sceneMode?: SceneMode;
+        ion?: string;
+        vr?: boolean;
+    };
+    tiles?: {
+        id: string;
+        tile_type?: string;
+        tile_url?: string;
+        tile_zoomLevel?: number[];
+        tile_zoomLevelForURL?: number[];
+        tile_opacity?: number;
+        heatmap?: boolean;
+    }[];
+    tileLabels?: {
+        id: string;
+        labelType: "japan_gsi_optimal_bvmap";
+        style: Record<string, any>;
+    }[];
+    terrain?: {
+        terrain?: boolean;
+        terrainType?: "cesium" | "arcgis" | "cesiumion";
+        terrainCesiumIonAsset?: string;
+        terrainCesiumIonAccessToken?: string;
+        terrainCesiumIonUrl?: string;
+        terrainExaggeration?: number;
+        terrainExaggerationRelativeHeight?: number;
+        depthTestAgainstTerrain?: boolean;
+    };
+    globeLighting?: {
+        globeLighting?: boolean;
+    };
+    globeShadow?: {
+        globeShadow?: boolean;
+    };
+    globeAtmosphere?: {
+        globeAtmosphere?: boolean;
+        globeAtmosphereIntensity?: number;
+    };
+    skyBox?: {
+        skyBox?: boolean;
+    };
+    sun?: {
+        sun?: boolean;
+    };
+    moon?: {
+        moon?: boolean;
+    };
+    skyAtmosphere?: {
+        skyAtmosphere?: boolean;
+        skyAtmosphereIntensity?: number;
+    };
+    camera?: {
+        camera?: Camera;
+        allowEnterGround?: boolean;
+        fov?: number;
+    };
+    render?: {
+        showWireframe?: boolean;
+    };
+} & LegacySceneProperty;
 
 export declare type ScreenSpaceCameraControllerOptions = {
     zoomEventTypes?: (OverideCameraEventType | ModifiedCameraEventType)[];
@@ -1444,19 +1499,6 @@ declare type SetTimeCommand = {
     };
 };
 
-export declare type ShadowMapProperty = {
-    size?: 1024 | 2048 | 4096;
-    softShadows?: boolean;
-    darkness?: number;
-    maximumDistance?: number;
-};
-
-export declare type ShadowProperty = {
-    enabled?: boolean;
-    darkness?: number;
-    shadowMap?: ShadowMapProperty;
-};
-
 export declare type SketchAppearance = Partial<LayerAppearanceTypes>;
 
 declare type SketchComponentProps = RequireExactlyOne<{
@@ -1485,16 +1527,6 @@ export declare type SketchFeature = Feature_2<Polygon_2 | MultiPolygon | Point |
     extrudedHeight: number;
 }>;
 
-export declare type SketchOptions = {
-    color?: string;
-    appearance?: SketchAppearance;
-    dataOnly?: boolean;
-    disableShadow?: boolean;
-    enableRelativeHeight?: boolean;
-    rightClickToAbort?: boolean;
-    autoResetInteractionMode?: boolean;
-};
-
 export declare type SketchProps = {
     layersRef: RefObject<LayersRef>;
     engineRef: RefObject<EngineRef>;
@@ -1509,33 +1541,18 @@ export declare type SketchProps = {
 };
 
 export declare type SketchRef = {
-    getType: () => SketchType | undefined;
     setType: (type: SketchType | undefined, from?: "editor" | "plugin") => void;
-    getOptions: () => SketchOptions;
-    overrideOptions: (options: SketchOptions) => void;
+    setColor: (color: string) => void;
+    setDefaultAppearance: (appearance: SketchAppearance) => void;
+    disableShadow: (disable: boolean) => void;
+    enableRelativeHeight: (enable: boolean) => void;
+    createDataOnly: (dataOnly: boolean) => void;
+    allowRightClickToAbort: (allow: boolean) => void;
+    allowAutoResetInteractionMode: (allow: boolean) => void;
 };
 
 export declare type SketchType = "marker" | "polyline" | "circle" | "rectangle" | "polygon" | "extrudedCircle" | "extrudedRectangle" | "extrudedPolygon";
 
-export declare type SkyAtmosphereProperty = {
-    show?: boolean;
-    lightIntensity?: number;
-    saturationShift?: number;
-    brightnessShift?: number;
-};
-
-export declare type SkyBoxProperty = {
-    show?: boolean;
-};
-
-export declare type SkyProperty = {
-    skyBox?: SkyBoxProperty;
-    sun?: SunProperty;
-    moon?: MoonProperty;
-    fog?: FogProperty;
-    skyAtmosphere?: SkyAtmosphereProperty;
-};
-
 export declare type Spacing = {
     bottom: number;
     left: number;
@@ -1545,10 +1562,6 @@ export declare type Spacing = {
 
 export declare type StyleExpression = ConditionsExpression | string;
 
-export declare type SunProperty = {
-    show?: boolean;
-};
-
 export declare type Tag = {
     id: string;
     label: string;
@@ -1556,11 +1569,21 @@ export declare type Tag = {
 };
 
 export declare type TerrainProperty = {
-    enabled?: boolean;
-    type?: "cesium" | "arcgis" | "cesiumion";
-    url?: string;
-    normal?: boolean;
-    elevationHeatMap?: ElevationHeatMapProperty;
+    terrain?: boolean;
+    terrainType?: "cesium" | "arcgis" | "cesiumion";
+    terrainExaggeration?: number;
+    terrainExaggerationRelativeHeight?: number;
+    depthTestAgainstTerrain?: boolean;
+    terrainCesiumIonAsset?: string;
+    terrainCesiumIonAccessToken?: string;
+    terrainCesiumIonUrl?: string;
+    terrainUrl?: string;
+    terrainNormal?: boolean;
+    heatmapType?: "custom";
+    heatmapColorLUT?: LUT;
+    heatmapMinHeight?: number;
+    heatmapMaxHeight?: number;
+    heatmapLogarithmic?: boolean;
 };
 
 export declare type TickEvent = (cb: TickEventCallback) => void;
@@ -1577,22 +1600,6 @@ declare type TickEventCallback_2 = (current: Date, clock: {
     stop: Date;
 }) => void;
 
-export declare type TileLabelProperty = {
-    id: string;
-    labelType: "japan_gsi_optimal_bvmap";
-    style: Record<string, any>;
-};
-
-export declare type TileProperty = {
-    id: string;
-    type?: string;
-    url?: string;
-    opacity?: number;
-    zoomLevel?: number[];
-    zoomLevelForURL?: number[];
-    heatmap?: boolean;
-};
-
 export declare type TimeInterval = [start: Date, end?: Date];
 
 export declare type Timeline = {
@@ -1612,7 +1619,7 @@ declare type TimelineCommit = (PlayCommand | PauseCommand | SetTimeCommand | Set
 };
 
 export declare type TimelineCommitter = {
-    source: "widgetContext" | "pluginAPI" | "featureResource" | "storyTimelineBlock" | "storyPage" | "initialize";
+    source: "overrideSceneProperty" | "widgetContext" | "pluginAPI" | "featureResource" | "storyTimelineBlock" | "storyPage";
     id?: string;
 };
 
@@ -1676,6 +1683,8 @@ export declare type Undefinable<T extends object> = {
 
 export declare function useGet<T>(value: T): () => T;
 
+export declare function useOverriddenProperty<T extends {}>(property: T | undefined): [T, (pluginId: string, property: T) => void];
+
 export declare const useVisualizer: () => RefObject<MapRef>;
 
 export declare type ValueType = keyof ValueTypes;
@@ -1699,20 +1708,6 @@ export declare type ValueTypes = {
     timeline: Timeline;
 };
 
-export declare type ViewerProperty = {
-    globe?: GlobeProperty;
-    terrain?: TerrainProperty;
-    scene?: SceneProperty;
-    tiles?: TileProperty[];
-    tileLabels?: TileLabelProperty[];
-    sky?: SkyProperty;
-    camera?: CameraProperty;
-    render?: RenderPeropty;
-    assets?: AssetsProperty;
-    debug?: DebugProperty;
-    indicator?: IndicatorProperty;
-};
-
 export declare type Viewport = {
     width: number | undefined;
     height: number | undefined;