51world示例集合

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/realtime-video.d.ts

+import { MinMaxType, Coord2DType, EntityEidType, BasicInfoAtomType, TransformAtomType } from '../data-type';
+export interface RealTimeVideoEntityAtomType {
+    url: string;
+    resolution: MinMaxType;
+    offset: Coord2DType;
+    state: string;
+}
+export interface RealTimeVideoType extends EntityEidType, Partial<BasicInfoAtomType>, Partial<TransformAtomType> {
+    realTimeVideoStyle?: Partial<RealTimeVideoEntityAtomType>;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/roadheatmap.d.ts

+import { MinMaxType, EntityEidType, BasicInfoAtomType, IPointValueAtom } from '../data-type';
+export interface RoadHeatMapType extends EntityEidType, Partial<BasicInfoAtomType> {
+    roadHeatMapStyle?: Partial<RoadHeatMapEntityAtomType>;
+    points?: IPointValueAtom;
+}
+export interface RoadHeatMapEntityAtomType {
+    type: string;
+    width: number;
+    mappingValueRange: MinMaxType;
+    gradientSetting: Array<string>;
+    filter: Array<string>;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/section.d.ts

+import { TransformAtomType } from '../data-type';
+export interface ISectionStart {
+    coordZRef: string;
+    strokeColor: string;
+    strokeWeight: number;
+    invert: boolean;
+    transform: TransformAtomType;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/setting.d.ts

+export interface IPickFilter {
+    bFilterForExclude?: boolean;
+    filterEntityTypes?: Array<string>;
+    excludeEntities?: Array<any>;
+}
+export interface IDefaultActionSetting {
+    bSelectActionEnabled?: boolean;
+    bClickedEventEnabled?: boolean;
+    pickFilter?: IPickFilter;
+}
+export interface IBatchPlaceAsset {
+    yaw?: number;
+    yawRandomRange?: Array<number>;
+    scale?: number;
+    scaleRandomRange?: Array<number>;
+    assets?: Array<IAsset>;
+}
+export interface IAsset {
+    SeedId: string;
+    Name?: string;
+}
+export interface IGizmoSetting {
+    gizmoState?: string;
+    gizmoCoordinateSystem?: string;
+    bPreserveScaleRatio?: boolean;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/skeletal.d.ts

+import { EntityEidType, BasicInfoAtomType, TransformAtomType, AssetAtomType } from '../data-type';
+export interface SkeletalType extends EntityEidType, Partial<BasicInfoAtomType>, Partial<TransformAtomType>, Partial<AssetAtomType>, Partial<SkeletalMeshAtomType> {
+}
+export interface SkeletalMeshAtomType {
+    animSequenceIndex: number;
+    bPause: boolean;
+    bLoop: boolean;
+    playRate: number;
+    playInterval: {
+        min: number;
+        max: number;
+    };
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/spaceheatmap.d.ts

+import { EntityEidType, BasicInfoAtomType, IPointValueAtom } from '../data-type';
+export interface SpaceHeatMapEntityAtomType {
+    brushDiameter: number;
+    mappingValueRange: Array<number>;
+    gradientSetting: Array<string>;
+}
+export interface SpaceHeatMapType extends EntityEidType, Partial<BasicInfoAtomType> {
+    spaceHeatMapStyle?: Partial<SpaceHeatMapEntityAtomType>;
+    points?: IPointValueAtom;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/static.d.ts

+import { EntityEidType, BasicInfoAtomType, TransformAtomType, AssetAtomType } from '../data-type';
+import { MaterialAtomType } from './material';
+export interface StaticType extends EntityEidType, Partial<BasicInfoAtomType>, Partial<TransformAtomType>, Partial<MaterialAtomType>, Partial<AssetAtomType> {
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/text3d.d.ts

+import { EntityEidType, BasicInfoAtomType, TransformAtomType } from '../data-type';
+export interface Text3DType extends EntityEidType, Partial<BasicInfoAtomType>, Partial<TransformAtomType> {
+    text3DStyle?: Partial<Text3DEntityAtomType>;
+}
+export interface Text3DEntityAtomType {
+    text: string;
+    color: string;
+    type: string;
+    outline: number;
+    portrait: boolean;
+    space: number;
+    bounce: number;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/tiles.d.ts

+import { EntityEidType, EntityGeometryType, BasicInfoAtomType, TransformAtomType } from '../data-type';
+export interface TilesType extends EntityEidType, EntityGeometryType, Partial<BasicInfoAtomType>, Partial<TransformAtomType>, Partial<AesTilesEntityAtomType> {
+}
+export interface AesTilesEntityAtomType {
+    spaceId: string;
+    rangeBox: Array<Array<number>>;
+    version: string;
+}
+export interface IAesTilesVisualAtom {
+    visualGroupToNodes: any;
+    hiddenLayers: Array<any>;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/tool.d.ts

+import { Coord2DType } from '../data-type';
+export interface IPickerRectangle {
+    p0: Coord2DType;
+    p1: Coord2DType;
+    bMustBeFullyEnclosed?: boolean;
+    bHighlightPicked?: boolean;
+    entityTypeFilter: Array<string>;
+    bFilterForExclude?: boolean;
+    selectMode?: string;
+}
+export interface IPickerMaterial {
+    screenPos: Coord2DType;
+    EntityTypeFilter: Array<string>;
+    bFilterForExclude?: boolean;
+}
+export interface IPickerTilesNode {
+    point1: Coord2DType;
+    point2: Coord2DType;
+    bMustBeFullyEnclosed?: boolean;
+    selectMode?: string;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/transaction.d.ts

+export interface StartTransactionType {
+    transactionName: string;
+    bTransactionGroup?: boolean;
+    bCanUndo?: boolean;
+    bCanCommit?: boolean;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/viewshed.d.ts

+import { EntityEidType, EntityGeometryType, BasicInfoAtomType, TransformAtomType } from '../data-type';
+export interface ViewshedType extends EntityEidType, EntityGeometryType, Partial<BasicInfoAtomType>, Partial<TransformAtomType> {
+    viewshedStyle?: Partial<ViewShedEntityAtomType>;
+}
+export interface ViewShedEntityAtomType {
+    visibleColor: string;
+    hiddenColor: string;
+    outline: boolean;
+    fieldOfView: number;
+    radius: number;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/interface/window.d.ts

+import { MinMaxType, Coord2DType, EntityEidType, BasicInfoAtomType, TransformAtomType } from '../data-type';
+export interface WindowType extends EntityEidType, Partial<BasicInfoAtomType>, Partial<TransformAtomType> {
+    windowStyle?: Partial<WindowEntityAtomType>;
+}
+export interface WindowEntityAtomType {
+    url: string;
+    size: MinMaxType;
+    offset: Coord2DType;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/object-abstract.d.ts

+import { ResultType } from './data-type';
+export declare abstract class ObjectAbstract {
+    abstract GetData: () => any;
+    abstract SetData: (obj: any) => void;
+    abstract Update: (opt: any) => Promise<ResultType>;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/common/object-basic.d.ts

+import { ResultType } from './data-type';
+export declare class ObjectBasic implements ObjectBasicAbstract {
+    protected obj: any;
+    protected atomObj: any;
+    protected setObjChannel(obj: any): void;
+    protected setObjAtom(obj: any): void;
+    protected StartApi(apiClassName: string, apiFuncName: string, params: any): Promise<ResultType>;
+}
+declare abstract class ObjectBasicAbstract {
+}
+export {};

gis_sdk/world51/51timapi/Plugins/tim/modules/common/object-controller.d.ts

+import { ObjectBasic } from './object-basic';
+import { ResultType, CoordType, RotatorType, ScaleType, TransformAtomType, EntityEidType, BasicInfoAtomType, VisibleAtomType, CacheAtomType, IVisible2D, Visible2DAtomType, IBaseData, IOperations } from './data-type';
+export declare class ObjectController extends ObjectBasic implements ObjectAbstract {
+    private err;
+    isAuth: boolean;
+    protected Eid: string | null;
+    protected EntityType: string;
+    protected objectType: string;
+    addNewScheme: Record<string, any>;
+    protected BasicInfoAtom: BasicInfoAtomType;
+    protected TransformAtom: TransformAtomType;
+    protected VisibleAtom: VisibleAtomType;
+    protected CacheAtom: CacheAtomType;
+    protected Visible2DAtom: Visible2DAtomType;
+    constructor();
+    get eid(): string | null;
+    set eid(Eid: string | null);
+    get oType(): string;
+    set oType(Type: string);
+    get type(): string;
+    set type(EntityType: string);
+    get bVisible(): boolean;
+    set bVisible(bVisible: boolean);
+    get entityName(): string;
+    set entityName(entityName: string);
+    get customId(): string;
+    set customId(customId: string);
+    get customData(): any;
+    set customData(customData: any);
+    get location(): CoordType;
+    set location(location: CoordType);
+    get rotator(): RotatorType;
+    set rotator(rotator: RotatorType);
+    get scale3d(): ScaleType;
+    set scale3d(scale3d: ScaleType);
+    get bRemoved(): boolean;
+    get hideDistance(): number;
+    set hideDistance(hideDistance: number);
+    get hideType(): string;
+    set hideType(hideType: string);
+    get scaleMode(): string;
+    set scaleMode(scaleMode: string);
+    get clickTop(): boolean;
+    set clickTop(clickTop: boolean);
+    get hoverTop(): boolean;
+    set hoverTop(hoverTop: boolean);
+    GetVisible(): Promise<ResultType>;
+    SetVisible(bVisible?: boolean): Promise<ResultType>;
+    GetEntityName(): Promise<ResultType>;
+    SetEntityName(entityName: string): Promise<ResultType>;
+    GetCustomId(): Promise<ResultType>;
+    SetCustomId(customId: string): Promise<ResultType>;
+    GetCustomData(): Promise<ResultType>;
+    SetCustomData(customData: any): Promise<ResultType>;
+    GetLocation(): Promise<ResultType>;
+    SetLocation(location: CoordType): Promise<ResultType>;
+    GetRotator(): Promise<ResultType>;
+    SetRotator(rotator: RotatorType): Promise<ResultType>;
+    GetScale3d(): Promise<ResultType>;
+    SetScale3d(scale3d: ScaleType): Promise<ResultType>;
+    SetGeometry(geometry: any): Promise<ResultType>;
+    GetHideDistance(): Promise<ResultType>;
+    SetHideDistance(hideDistance: number): Promise<ResultType>;
+    GetHideType(): Promise<ResultType>;
+    SetHideType(hideType: string): Promise<ResultType>;
+    GetScaleMode(): Promise<ResultType>;
+    SetScaleMode(scaleMode: string): Promise<ResultType>;
+    GetClickTop(): Promise<ResultType>;
+    SetClickTop(clickTop: boolean): Promise<ResultType>;
+    GetHoverTop(): Promise<ResultType>;
+    SetHoverTop(hoverTop: boolean): Promise<ResultType>;
+    GetVisible2DScheme(): {
+        Visible2DAtom: Visible2DAtomType;
+    };
+    GetBasicScheme(): {
+        BasicInfoAtom: BasicInfoAtomType;
+    };
+    GetTransformScheme(): {
+        TransformAtom: TransformAtomType;
+    };
+    GetVisibleScheme(): {
+        VisibleAtom: VisibleAtomType;
+    };
+    GetBaseScheme(): {
+        BasicInfoAtom: BasicInfoAtomType;
+        TransformAtom: TransformAtomType;
+        VisibleAtom: VisibleAtomType;
+    };
+    GetAllScheme(): any;
+    setObj(obj: any, objFactory?: any): void;
+    onClick(func: (e: ResultType) => void): void;
+    onDbClick(func: (e: ResultType) => void): void;
+    onMouseEnter(func: (e: ResultType) => void): void;
+    onMouseOut(func: (e: ResultType) => void): void;
+    Get(): Promise<ResultType>;
+    UpdateBasic(opt: any): Promise<ResultType>;
+    Delete(): Promise<ResultType>;
+    Update(opt: Record<string, any>, operations?: IOperations): Promise<ResultType>;
+    SnapTo(operations: IOperations): Promise<ResultType>;
+    DeleteFromCache(bRemoved?: boolean): void;
+    SetVisibleCache(bVisible?: boolean): void;
+    SetVisible2D(opt: IVisible2D): Promise<ResultType>;
+    private handleVisible2DAction;
+    private GetVisible2DData;
+    private SetVisible2DData;
+    private handleVisibleAction;
+    private handleLocationAction;
+    private handleRotatorAction;
+    private handleScale3dAction;
+    private handleGeometryAction;
+    private handleDeleteAction;
+    generateObjectData<T>(atomData: T extends IBaseData ? T : never): void;
+    GetData(): Record<string, any>;
+    generateLocationAtom(location: CoordType): any;
+    generateRotatorAtom(rotator: RotatorType): any;
+    generateScale3dAtom(scale3d: ScaleType): any;
+    generateVisibleAtom(bVisible: boolean): any;
+    protected getOtherData(): Record<string, any>;
+    protected setEid(opt: EntityEidType): void;
+    protected getEid(): EntityEidType;
+    protected setTransformData(opt: Partial<TransformAtomType>): void;
+    protected getTransformData(): TransformAtomType;
+    protected setBasicData(opt: Partial<BasicInfoAtomType>): void;
+    protected getBasicData(): BasicInfoAtomType;
+    protected handleBasicAtom(oriData: Record<string, any>, paramsData: Record<string, any>): void;
+    protected handleTransformAtom(oriData: Record<string, any>, paramsData: Record<string, any>): void;
+}
+declare abstract class ObjectAbstract {
+    abstract Get: () => Promise<ResultType>;
+    abstract Delete: () => Promise<ResultType>;
+    abstract SetVisibleCache: (bVisible: boolean) => void;
+    abstract DeleteFromCache: (bRemoved: boolean) => void;
+    abstract UpdateBasic: (opt: any) => Promise<ResultType>;
+    abstract GetVisible: () => Promise<ResultType>;
+    abstract SetVisible: (bVisible: boolean) => Promise<ResultType>;
+    abstract SetVisible2D: (opt: IVisible2D) => Promise<ResultType>;
+    abstract GetEntityName: () => Promise<ResultType>;
+    abstract SetEntityName: (entityName: string) => Promise<ResultType>;
+    abstract GetCustomId: () => Promise<ResultType>;
+    abstract SetCustomId: (customId: string) => Promise<ResultType>;
+    abstract GetCustomData: () => Promise<ResultType>;
+    abstract SetCustomData: (customData: any) => Promise<ResultType>;
+    abstract GetLocation: () => Promise<ResultType>;
+    abstract SetLocation: (location: CoordType) => Promise<ResultType>;
+    abstract GetRotator: () => Promise<ResultType>;
+    abstract SetRotator: (rotator: RotatorType) => Promise<ResultType>;
+    abstract GetScale3d: () => Promise<ResultType>;
+    abstract SetScale3d: (scale3d: ScaleType) => Promise<ResultType>;
+    abstract SetGeometry: (geometry: any) => Promise<ResultType>;
+    abstract Update: (opt: any) => Promise<ResultType>;
+    abstract generateObjectData: <T>(atomData: T extends IBaseData ? T : never) => void;
+    abstract GetData: () => Record<string, any>;
+}
+export {};

gis_sdk/world51/51timapi/Plugins/tim/modules/common/permission.d.ts

+export declare class Permission {
+    private err;
+    checkPer(p: string): boolean;
+}

gis_sdk/world51/51timapi/Plugins/tim/modules/customize-controller.d.ts

+import { Basic } from './common/basic';
+import { ResultType } from './common/data-type';
+declare class CustomizeController extends Basic {
+    constructor(obj: any);
+    RunCustomizeApi(params: any): Promise<any>;
+    Run(apiClassName: string, apiFuncName: string, params?: any): Promise<ResultType>;
+}
+export default CustomizeController;

gis_sdk/world51/51timapi/Plugins/tim/modules/data-model/assetloader-controller.d.ts

+import { Basic } from '../common/basic';
+import { ResultType } from '../common/data-type';
+declare class AssetLoaderController extends Basic {
+    private apiClassName;
+    constructor(obj: any);
+    LoadAssetById(seedId: string): Promise<ResultType>;
+    ReplaceAssetById(seedId: string, objects: Array<Record<string, any>>): Promise<ResultType>;
+}
+export default AssetLoaderController;

gis_sdk/world51/51timapi/Plugins/tim/modules/data-model/geometry-controller.d.ts

+import { Basic } from '../common/basic';
+import { ResultType } from '../common/data-type';
+import PointController from './geometry/point-controller';
+import PolylineController from './geometry/polyline-controller';
+import Polygon2DController from './geometry/polygon2d-controller';
+declare class GeometryController extends Basic {
+    private apiClassName;
+    private RequestEntity;
+    Point: PointController;
+    Polyline: PolylineController;
+    Polygon2D: Polygon2DController;
+    constructor(obj: any);
+    EnableDraw(): Promise<ResultType>;
+    DisableDraw(): Promise<ResultType>;
+    ClearByTypes(types: Array<string>): Promise<ResultType>;
+    Clear(): Promise<ResultType>;
+    ClearCache(): Promise<ResultType>;
+    CreateGeometryFromGeoJson(url: string): Promise<ResultType>;
+    CreateGeometryFromShapefile(url: string): Promise<ResultType>;
+}
+export default GeometryController;