51world示例集合

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/columnarheatmap/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, IPointValueAtom, IPoint, ICoordinates } from '../../../common/data-type';
+import { ColumnarHeatMapType, ColumnarHeatMapEntityAtomType } from '../../../common/interface/columnarheatmap';
+import { ObjectController } from '../../../common/object-controller';
+declare class ColumnarHeatMap extends ObjectController implements ObjectAbstract {
+    className: string;
+    private apiClassName;
+    private ColumnarHeatMapEntityAtom;
+    private PointValueAtom;
+    constructor(opt?: ColumnarHeatMapType);
+    get sType(): string;
+    set sType(type: string);
+    get brushDiameter(): number;
+    set brushDiameter(brushDiameter: number);
+    get mappingValueRange(): Array<number>;
+    set mappingValueRange(mappingValueRange: Array<number>);
+    get columnarWidth(): number;
+    set columnarWidth(columnarWidth: number);
+    get mappingHeightRange(): Array<number>;
+    set mappingHeightRange(mappingHeightRange: Array<number>);
+    get enableGap(): boolean;
+    set enableGap(enableGap: boolean);
+    get gradientSetting(): Array<string>;
+    set gradientSetting(gradientSetting: Array<string>);
+    get features(): Array<IPoint>;
+    set features(features: Array<IPoint>);
+    GetsType(): Promise<ResultType>;
+    SetsType(type: string): Promise<ResultType>;
+    GetBrushDiameter(): Promise<ResultType>;
+    SetBrushDiameter(brushDiameter: number): Promise<ResultType>;
+    GetMappingValueRange(): Promise<ResultType>;
+    SetMappingValueRange(mappingValueRange: Array<number>): Promise<ResultType>;
+    GetColumnarWidth(): Promise<ResultType>;
+    SetColumnarWidth(columnarWidth: number): Promise<ResultType>;
+    GetMappingHeightRange(): Promise<ResultType>;
+    SetMappingHeightRange(mappingHeightRange: Array<number>): Promise<ResultType>;
+    GetEnableGap(): Promise<ResultType>;
+    SetEnableGap(enableGap: boolean): Promise<ResultType>;
+    GetGradientSetting(): Promise<ResultType>;
+    SetGradientSetting(gradientSetting: Array<string>): Promise<ResultType>;
+    GetFeatures(): Promise<ResultType>;
+    SetFeatures(features: Array<IPoint>): Promise<ResultType>;
+    GetScheme(): {
+        ColumnarHeatMapEntityAtom: ColumnarHeatMapEntityAtomType;
+        PointValueAtom: IPointValueAtom;
+    };
+    GetData(): ColumnarHeatMapType;
+    SetData(opt: ColumnarHeatMapType): void;
+    generateAtomData(opt: ColumnarHeatMapType): {
+        ColumnarHeatMapEntityAtom?: Partial<ColumnarHeatMapEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        PointValueAtom?: Partial<IPointValueAtom>;
+    };
+    Clip(polygon: ICoordinates, color?: string): Promise<ResultType>;
+    UnClip(): Promise<ResultType>;
+}
+export default ColumnarHeatMap;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/heatmap-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class HeatMapController extends AtomController {
+    constructor(obj: any);
+}
+export default HeatMapController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/heatmap/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, IPointValueAtom, IPoint, ICoordinates } from '../../../common/data-type';
+import { HeatMapType, HeatMapEntityAtomType } from '../../../common/interface/heatmap';
+import { ObjectController } from '../../../common/object-controller';
+declare class HeatMap extends ObjectController implements ObjectAbstract {
+    className: string;
+    private apiClassName;
+    private HeatMapEntityAtom;
+    private PointValueAtom;
+    constructor(opt?: HeatMapType);
+    get sType(): string;
+    set sType(type: string);
+    get brushDiameter(): number;
+    set brushDiameter(brushDiameter: number);
+    get mappingValueRange(): Array<number>;
+    set mappingValueRange(mappingValueRange: Array<number>);
+    get gradientSetting(): Array<string>;
+    set gradientSetting(gradientSetting: Array<string>);
+    get features(): Array<IPoint>;
+    set features(features: Array<IPoint>);
+    GetsType(): Promise<ResultType>;
+    SetsType(type: string): Promise<ResultType>;
+    GetBrushDiameter(): Promise<ResultType>;
+    SetBrushDiameter(brushDiameter: number): Promise<ResultType>;
+    GetMappingValueRange(): Promise<ResultType>;
+    SetMappingValueRange(mappingValueRange: Array<number>): Promise<ResultType>;
+    GetGradientSetting(): Promise<ResultType>;
+    SetGradientSetting(gradientSetting: Array<string>): Promise<ResultType>;
+    GetFeatures(): Promise<ResultType>;
+    SetFeatures(features: Array<IPoint>): Promise<ResultType>;
+    GetScheme(): {
+        HeatMapEntityAtom: HeatMapEntityAtomType;
+        PointValueAtom: IPointValueAtom;
+    };
+    GetData(): HeatMapType;
+    SetData(opt: HeatMapType): void;
+    generateAtomData(opt: HeatMapType): {
+        HeatMapEntityAtom?: Partial<HeatMapEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        PointValueAtom?: Partial<IPointValueAtom>;
+    };
+    Clip(polygon: ICoordinates, color?: string): Promise<ResultType>;
+    UnClip(): Promise<ResultType>;
+}
+export default HeatMap;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/highlightarea-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class HighlightAreaController extends AtomController {
+    constructor(obj: any);
+}
+export default HighlightAreaController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/highlightarea/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, IPolygon2DAtom, ICoordinates2D } from '../../../common/data-type';
+import { HighlightAreaType, HighlightAreaEntityAtomType } from '../../../common/interface/highlightarea';
+import { ObjectController } from '../../../common/object-controller';
+declare class HighlightArea extends ObjectController implements ObjectAbstract {
+    className: string;
+    private HighlightAreaEntityAtom;
+    private Polygon2DAtom;
+    constructor(opt?: HighlightAreaType);
+    get interiorColor(): string;
+    set interiorColor(interiorColor: string);
+    get exteriorColor(): string;
+    set exteriorColor(exteriorColor: string);
+    get exteriorOutlineColor(): string;
+    set exteriorOutlineColor(exteriorOutlineColor: string);
+    get exteriorSaturation(): number;
+    set exteriorSaturation(exteriorSaturation: number);
+    get exteriorBrightness(): number;
+    set exteriorBrightness(exteriorBrightness: number);
+    get exteriorContrast(): number;
+    set exteriorContrast(exteriorContrast: number);
+    get coordinates(): ICoordinates2D;
+    set coordinates(coordinates: ICoordinates2D);
+    get coordZ(): number;
+    set coordZ(coordZ: number);
+    GetInteriorColor(): Promise<ResultType>;
+    SetInteriorColor(interiorColor: string): Promise<ResultType>;
+    GetExteriorColor(): Promise<ResultType>;
+    SetExteriorColor(exteriorColor: string): Promise<ResultType>;
+    GetExteriorOutlineColor(): Promise<ResultType>;
+    SetExteriorOutlineColor(exteriorOutlineColor: string): Promise<ResultType>;
+    GetExteriorSaturation(): Promise<ResultType>;
+    SetExteriorSaturation(exteriorSaturation: number): Promise<ResultType>;
+    GetExteriorBrightness(): Promise<ResultType>;
+    SetExteriorBrightness(exteriorBrightness: number): Promise<ResultType>;
+    GetExteriorContrast(): Promise<ResultType>;
+    SetExteriorContrast(exteriorContrast: number): Promise<ResultType>;
+    GetCoordinates(): Promise<ResultType>;
+    SetCoordinates(coordinates: ICoordinates2D): Promise<ResultType>;
+    GetCoordZ(): Promise<ResultType>;
+    SetCoordZ(coordZ: number): Promise<ResultType>;
+    GetScheme(): {
+        HighlightAreaEntityAtom: HighlightAreaEntityAtomType;
+        Polygon2DAtom: IPolygon2DAtom;
+    };
+    GetData(): HighlightAreaType;
+    SetData(opt: HighlightAreaType): void;
+    generateAtomData(opt: HighlightAreaType): {
+        HighlightAreaEntityAtom?: Partial<HighlightAreaEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        Polygon2DAtom?: Partial<IPolygon2DAtom>;
+    };
+}
+export default HighlightArea;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/parabola-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class ParabolaController extends AtomController {
+    constructor(obj: any);
+}
+export default ParabolaController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/parabola/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, IPolylineATom, ICoordinates } from '../../../common/data-type';
+import { ParabolaType, ParabolaEntityAtomType } from '../../../common/interface/parabola';
+import { ObjectController } from '../../../common/object-controller';
+declare class Parabola extends ObjectController implements ObjectAbstract {
+    className: string;
+    private ParabolaEntityAtom;
+    private PolylineAtom;
+    constructor(opt?: ParabolaType);
+    get sType(): string;
+    set sType(type: string);
+    get topHeight(): number;
+    set topHeight(topHeight: number);
+    get topScale(): number;
+    set topScale(topScale: number);
+    get width(): number;
+    set width(width: number);
+    get color(): string;
+    set color(color: string);
+    get gather(): boolean;
+    set gather(gather: boolean);
+    get coordinates(): ICoordinates;
+    set coordinates(coordinates: ICoordinates);
+    GetsType(): Promise<ResultType>;
+    SetsType(type: string): Promise<ResultType>;
+    GetTopHeight(): Promise<ResultType>;
+    SetTopHeight(topHeight: number): Promise<ResultType>;
+    GetTopScale(): Promise<ResultType>;
+    SetTopScale(topScale: number): Promise<ResultType>;
+    GetWidth(): Promise<ResultType>;
+    SetWidth(width: number): Promise<ResultType>;
+    GetColor(): Promise<ResultType>;
+    SetColor(color: string): Promise<ResultType>;
+    GetGather(): Promise<ResultType>;
+    SetGather(gather: boolean): Promise<ResultType>;
+    GetCoordinates(): Promise<ResultType>;
+    SetCoordinates(coordinates: ICoordinates): Promise<ResultType>;
+    GetScheme(): {
+        ParabolaEntityAtom: ParabolaEntityAtomType;
+        PolylineAtom: IPolylineATom;
+    };
+    GetData(): ParabolaType;
+    SetData(opt: ParabolaType): void;
+    generateAtomData(opt: ParabolaType): {
+        ParabolaEntityAtom?: Partial<ParabolaEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        PolylineAtom?: Partial<IPolylineATom>;
+    };
+}
+export default Parabola;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/particle-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class ParticleController extends AtomController {
+    constructor(obj: any);
+}
+export default ParticleController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/particle/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, TransformAtomType } from '../../../common/data-type';
+import { ParticleType, ParticleEntityAtomType } from '../../../common/interface/particle';
+import { ObjectController } from '../../../common/object-controller';
+declare class Particle extends ObjectController implements ObjectAbstract {
+    className: string;
+    private ParticleEntityAtom;
+    constructor(opt?: ParticleType);
+    get particleType(): string;
+    set particleType(particleType: string);
+    GetParticleType(): Promise<ResultType>;
+    SetParticleType(particleType: string): Promise<ResultType>;
+    GetScheme(): {
+        ParticleEntityAtom: ParticleEntityAtomType;
+    };
+    GetData(): ParticleType;
+    SetData(opt: ParticleType): void;
+    generateAtomData(opt: ParticleType): {
+        ParticleEntityAtom?: Partial<ParticleEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default Particle;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/path-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class PathController extends AtomController {
+    constructor(obj: any);
+}
+export default PathController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/path/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, IPolylineATom, ICoordinates } from '../../../common/data-type';
+import { PathType, PathEntityAtomType } from '../../../common/interface/path';
+import { ObjectController } from '../../../common/object-controller';
+declare class Path extends ObjectController implements ObjectAbstract {
+    className: string;
+    private PathEntityAtom;
+    private PolylineAtom;
+    constructor(opt?: PathType);
+    get sType(): string;
+    set sType(type: string);
+    get width(): number;
+    set width(width: number);
+    get color(): string;
+    set color(color: string);
+    get passColor(): string;
+    set passColor(passColor: string);
+    get coordinates(): ICoordinates;
+    set coordinates(coordinates: ICoordinates);
+    GetsType(): Promise<ResultType>;
+    SetsType(type: string): Promise<ResultType>;
+    GetWidth(): Promise<ResultType>;
+    SetWidth(width: number): Promise<ResultType>;
+    GetColor(): Promise<ResultType>;
+    SetColor(color: string): Promise<ResultType>;
+    GetPassColor(): Promise<ResultType>;
+    SetPassColor(passColor: string): Promise<ResultType>;
+    GetCoordinates(): Promise<ResultType>;
+    SetCoordinates(coordinates: ICoordinates): Promise<ResultType>;
+    GetScheme(): {
+        PathEntityAtom: PathEntityAtomType;
+        PolylineAtom: IPolylineATom;
+    };
+    GetData(): PathType;
+    SetData(opt: PathType): void;
+    generateAtomData(opt: PathType): {
+        PathEntityAtom?: Partial<PathEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        PolylineAtom?: Partial<IPolylineATom>;
+    };
+}
+export default Path;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/poi-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class PoiController extends AtomController {
+    constructor(obj: any);
+}
+export default PoiController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/poi/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, MinMaxType, Coord2DType, BasicInfoAtomType, TransformAtomType } from '../../../common/data-type';
+import { PoiType, PoiEntityAtomType } from '../../../common/interface/poi';
+import { ObjectController } from '../../../common/object-controller';
+declare class Poi extends ObjectController implements ObjectAbstract {
+    className: string;
+    private PoiEntityAtom;
+    constructor(opt?: PoiType);
+    get markerSize(): MinMaxType;
+    set markerSize(markerSize: MinMaxType);
+    get markerNormalUrl(): string;
+    set markerNormalUrl(markerNormalUrl: string);
+    get markerActivateUrl(): string;
+    set markerActivateUrl(markerActivateUrl: string);
+    get labelBgImageUrl(): string;
+    set labelBgImageUrl(labelBgImageUrl: string);
+    get labelBgSize(): MinMaxType;
+    set labelBgSize(labelBgSize: MinMaxType);
+    get labelBgOffset(): Coord2DType;
+    set labelBgOffset(labelBgOffset: Coord2DType);
+    get labelContent(): Array<string>;
+    set labelContent(labelContent: Array<string>);
+    GetMarkerSize(): Promise<ResultType>;
+    SetMarkerSize(markerSize: MinMaxType): Promise<ResultType>;
+    GetMarkerNormalUrl(): Promise<ResultType>;
+    SetMarkerNormalUrl(markerNormalUrl: string): Promise<ResultType>;
+    GetMarkerActivateUrl(): Promise<ResultType>;
+    SetMarkerActivateUrl(markerActivateUrl: string): Promise<ResultType>;
+    GetLabelBgImageUrl(): Promise<ResultType>;
+    SetLabelBgImageUrl(labelBgImageUrl: string): Promise<ResultType>;
+    GetLabelBgSize(): Promise<ResultType>;
+    SetLabelBgSize(labelBgSize: MinMaxType): Promise<ResultType>;
+    GetLabelBgOffset(): Promise<ResultType>;
+    SetLabelBgOffset(labelBgOffset: Coord2DType): Promise<ResultType>;
+    GetLabelContent(): Promise<ResultType>;
+    SetLabelContent(labelContent: Array<string>): Promise<ResultType>;
+    GetScheme(): {
+        PoiEntityAtom: PoiEntityAtomType;
+    };
+    GetData(): PoiType;
+    SetData(opt: PoiType): void;
+    generateAtomData(opt: PoiType): {
+        PoiEntityAtom?: Partial<PoiEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default Poi;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/range-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class RangeController extends AtomController {
+    constructor(obj: any);
+}
+export default RangeController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/range/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, IPolygon2DAtom, ICoordinates2D } from '../../../common/data-type';
+import { RangeType, RangeEntityAtomType } from '../../../common/interface/range';
+import { ObjectController } from '../../../common/object-controller';
+declare class Range extends ObjectController implements ObjectAbstract {
+    className: string;
+    private RangeEntityAtom;
+    private Polygon2DAtom;
+    constructor(opt?: RangeType);
+    get sType(): string;
+    set sType(type: string);
+    get fillAreaType(): string;
+    set fillAreaType(fillAreaType: string);
+    get height(): number;
+    set height(height: number);
+    get strokeWeight(): number;
+    set strokeWeight(strokeWeight: number);
+    get color(): string;
+    set color(color: string);
+    get coordinates(): ICoordinates2D;
+    set coordinates(coordinates: ICoordinates2D);
+    get coordZ(): number;
+    set coordZ(coordZ: number);
+    GetsType(): Promise<ResultType>;
+    SetsType(type: string): Promise<ResultType>;
+    GetFillAreaType(): Promise<ResultType>;
+    SetFillAreaType(fillAreaType: string): Promise<ResultType>;
+    GetHeight(): Promise<ResultType>;
+    SetHeight(height: number): Promise<ResultType>;
+    GetStrokeWeight(): Promise<ResultType>;
+    SetStrokeWeight(strokeWeight: number): Promise<ResultType>;
+    GetColor(): Promise<ResultType>;
+    SetColor(color: string): Promise<ResultType>;
+    GetCoordinates(): Promise<ResultType>;
+    SetCoordinates(coordinates: ICoordinates2D): Promise<ResultType>;
+    GetCoordZ(): Promise<ResultType>;
+    SetCoordZ(coordZ: number): Promise<ResultType>;
+    GetScheme(): {
+        RangeEntityAtom: RangeEntityAtomType;
+        Polygon2DAtom: IPolygon2DAtom;
+    };
+    GetData(): RangeType;
+    SetData(opt: RangeType): void;
+    generateAtomData(opt: RangeType): {
+        RangeEntityAtom?: Partial<RangeEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        Polygon2DAtom?: Partial<IPolygon2DAtom>;
+    };
+}
+export default Range;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/raster-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class RasterController extends AtomController {
+    constructor(obj: any);
+}
+export default RasterController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/raster/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, BasicInfoAtomType, TransformAtomType } from '../../../common/data-type';
+import { RasterType, RasterEntityAtomType } from '../../../common/interface/raster';
+import { ObjectController } from '../../../common/object-controller';
+declare class Raster extends ObjectController implements ObjectAbstract {
+    className: string;
+    private RasterEntityAtom;
+    constructor(opt?: RasterType);
+    get path(): string;
+    set path(path: string);
+    get sType(): string;
+    set sType(type: string);
+    get gradientSetting(): Array<string>;
+    set gradientSetting(gradientSetting: Array<string>);
+    GetPath(): Promise<ResultType>;
+    SetPath(path: string): Promise<ResultType>;
+    GetsType(): Promise<ResultType>;
+    SetsType(type: string): Promise<ResultType>;
+    GetGradientSetting(): Promise<ResultType>;
+    SetGradientSetting(gradientSetting: Array<string>): Promise<ResultType>;
+    GetScheme(): {
+        RasterEntityAtom: RasterEntityAtomType;
+    };
+    GetData(): RasterType;
+    SetData(opt: RasterType): void;
+    generateAtomData(opt: RasterType): {
+        RasterEntityAtom?: Partial<RasterEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default Raster;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/realtimevideo-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class RealTimeVideoController extends AtomController {
+    constructor(obj: any);
+}
+export default RealTimeVideoController;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/realtimevideo/index.d.ts

+import { ObjectAbstract } from '../../../common/object-abstract';
+import { ResultType, MinMaxType, Coord2DType, BasicInfoAtomType, TransformAtomType } from '../../../common/data-type';
+import { RealTimeVideoType, RealTimeVideoEntityAtomType } from '../../../common/interface/realtime-video';
+import { ObjectController } from '../../../common/object-controller';
+declare class RealTimeVideo extends ObjectController implements ObjectAbstract {
+    className: string;
+    private RealTimeVideoEntityAtom;
+    constructor(opt?: RealTimeVideoType);
+    get url(): string;
+    set url(url: string);
+    get resolution(): MinMaxType;
+    set resolution(resolution: MinMaxType);
+    get offset(): Coord2DType;
+    set offset(offset: Coord2DType);
+    get state(): string;
+    set state(state: string);
+    GetUrl(): Promise<ResultType>;
+    SetUrl(url: string): Promise<ResultType>;
+    GetResolution(): Promise<ResultType>;
+    SetResolution(resolution: MinMaxType): Promise<ResultType>;
+    GetOffset(): Promise<ResultType>;
+    SetOffset(offset: Coord2DType): Promise<ResultType>;
+    GetState(): Promise<ResultType>;
+    SetState(state: string): Promise<ResultType>;
+    GetScheme(): {
+        RealTimeVideoEntityAtom: RealTimeVideoEntityAtomType;
+    };
+    GetData(): RealTimeVideoType;
+    SetData(opt: RealTimeVideoType): void;
+    generateAtomData(opt: RealTimeVideoType): {
+        RealTimeVideoEntityAtom?: Partial<RealTimeVideoEntityAtomType>;
+        BasicInfoAtom?: Partial<BasicInfoAtomType>;
+        TransformAtom?: Partial<TransformAtomType>;
+    };
+}
+export default RealTimeVideo;

gis_sdk/world51/51timapi/Plugins/tim/modules/scene/covering/roadheatmap-controller.d.ts

+import { AtomController } from '../../common/atom-controller';
+declare class RoadHeatMapController extends AtomController {
+    constructor(obj: any);
+}
+export default RoadHeatMapController;