resium/dist/index.d.ts

React component library for Cesium

/// <reference types="cesium" />
/// <reference types="react" />

import { Billboard as Billboard_2 } from 'cesium';
import { BillboardCollection as BillboardCollection_2 } from 'cesium';
import { BillboardGraphics as BillboardGraphics_2 } from 'cesium';
import { BoxGraphics as BoxGraphics_2 } from 'cesium';
import { Camera as Camera_2 } from 'cesium';
import { Cartesian2 } from 'cesium';
import { Cartesian3 } from 'cesium';
import { Cesium3DTile } from 'cesium';
import { Cesium3DTileFeature } from 'cesium';
import { Cesium3DTileset as Cesium3DTileset_2 } from 'cesium';
import { Cesium3DTilesetGraphics as Cesium3DTilesetGraphics_2 } from 'cesium';
import { CesiumWidget as CesiumWidget_2 } from 'cesium';
import { ClassificationPrimitive as ClassificationPrimitive_2 } from 'cesium';
import { Clock as Clock_2 } from 'cesium';
import { ClockRange } from 'cesium';
import { ClockStep } from 'cesium';
import { CloudCollection as CloudCollection_2 } from 'cesium';
import { Color } from 'cesium';
import { ComponentType } from 'react';
import { Consumer as Consumer_2 } from 'react';
import { Context } from 'react';
import { CorridorGraphics as CorridorGraphics_2 } from 'cesium';
import { CSSProperties } from 'react';
import { CumulusCloud as CumulusCloud_2 } from 'cesium';
import { CustomDataSource as CustomDataSource_2 } from 'cesium';
import { CylinderGraphics as CylinderGraphics_2 } from 'cesium';
import { CzmlDataSource as CzmlDataSource_2 } from 'cesium';
import { DataSource } from 'cesium';
import { DataSourceCollection } from 'cesium';
import { DistanceDisplayCondition } from 'cesium';
import { EasingFunction } from 'cesium';
import { EllipseGraphics as EllipseGraphics_2 } from 'cesium';
import { EllipsoidGraphics as EllipsoidGraphics_2 } from 'cesium';
import { Entity as Entity_2 } from 'cesium';
import { EntityCollection } from 'cesium';
import { Event as Event_2 } from 'cesium';
import { FC } from 'react';
import { Fog as Fog_2 } from 'cesium';
import { ForwardRefExoticComponent } from 'react';
import { GeoJsonDataSource as GeoJsonDataSource_2 } from 'cesium';
import { Globe as Globe_2 } from 'cesium';
import { GroundPolylinePrimitive as GroundPolylinePrimitive_2 } from 'cesium';
import { GroundPrimitive as GroundPrimitive_2 } from 'cesium';
import { HeadingPitchRange } from 'cesium';
import { HTMLAttributes } from 'react';
import { ImageryLayer as ImageryLayer_2 } from 'cesium';
import { ImageryLayerCollection as ImageryLayerCollection_2 } from 'cesium';
import { ImageryProvider } from 'cesium';
import { JulianDate } from 'cesium';
import { KeyboardEventModifier } from 'cesium';
import { KmlDataSource as KmlDataSource_2 } from 'cesium';
import { Label as Label_2 } from 'cesium';
import { LabelCollection as LabelCollection_2 } from 'cesium';
import { LabelGraphics as LabelGraphics_2 } from 'cesium';
import { Material } from 'cesium';
import { Matrix4 } from 'cesium';
import { Model as Model_2 } from 'cesium';
import { ModelGraphics as ModelGraphics_2 } from 'cesium';
import { ModelNode } from 'cesium';
import { Moon as Moon_2 } from 'cesium';
import { ParticleSystem as ParticleSystem_2 } from 'cesium';
import { PathGraphics as PathGraphics_2 } from 'cesium';
import { PlaneGraphics as PlaneGraphics_2 } from 'cesium';
import { PointGraphics as PointGraphics_2 } from 'cesium';
import { PointPrimitive as PointPrimitive_2 } from 'cesium';
import { PointPrimitiveCollection as PointPrimitiveCollection_2 } from 'cesium';
import { PolygonGraphics as PolygonGraphics_2 } from 'cesium';
import { Polyline as Polyline_2 } from 'cesium';
import { PolylineCollection as PolylineCollection_2 } from 'cesium';
import { PolylineGraphics as PolylineGraphics_2 } from 'cesium';
import { PolylineVolumeGraphics as PolylineVolumeGraphics_2 } from 'cesium';
import { PostProcessStage as PostProcessStage_2 } from 'cesium';
import { PostProcessStageCollection } from 'cesium';
import { PostProcessStageComposite as PostProcessStageComposite_2 } from 'cesium';
import { Primitive as Primitive_2 } from 'cesium';
import { PrimitiveCollection } from 'cesium';
import { PropsWithChildren } from 'react';
import { PropsWithoutRef } from 'react';
import { Provider as Provider_2 } from 'react';
import { PureComponent } from 'react';
import { ReactNode } from 'react';
import { Rectangle } from 'cesium';
import { RectangleGraphics as RectangleGraphics_2 } from 'cesium';
import { RefAttributes } from 'react';
import { RefObject } from 'react';
import { Resource } from 'cesium';
import { Scene as Scene_2 } from 'cesium';
import { SceneMode } from 'cesium';
import { ScreenSpaceCameraController as ScreenSpaceCameraController_2 } from 'cesium';
import { ScreenSpaceEventHandler as ScreenSpaceEventHandler_2 } from 'cesium';
import { ScreenSpaceEventType } from 'cesium';
import { ShadowMap as ShadowMap_2 } from 'cesium';
import { SkyAtmosphere as SkyAtmosphere_2 } from 'cesium';
import { SkyBox as SkyBox_2 } from 'cesium';
import { Sun as Sun_2 } from 'cesium';
import { TerrainProvider } from 'cesium';
import { TimeDynamicPointCloud as TimeDynamicPointCloud_2 } from 'cesium';
import { Viewer as Viewer_2 } from 'cesium';
import { WallGraphics as WallGraphics_2 } from 'cesium';

export declare const AmbientOcclusion: CesiumComponentType<PostProcessStage_2 | PostProcessStageComposite_2, {} & {
enabled?: boolean | undefined;
selected?: any[] | undefined;
} & Props_4 & {
stages?: any[] | undefined;
}>;

export declare type AmbientOcclusionProps = PostProcessStageCompositeProps & Props_4;

export declare type ArrayKeys<K> = StringOnly<K extends readonly (infer E)[] ? E : K extends (infer E)[] ? E : K>;

export declare const Billboard: CesiumComponentType<Billboard_2, BillboardProps>;

declare type BillboardCesiumProps = PickCesiumProps<Billboard_2, typeof cesiumProps, "position">;

export declare const BillboardCollection: CesiumComponentType<BillboardCollection_2, BillboardCollectionProps>;

declare type BillboardCollectionCesiumProps = PickCesiumProps<BillboardCollection_2, typeof cesiumProps_2>;

declare type BillboardCollectionOtherProps = {
    children?: ReactNode;
};

export declare type BillboardCollectionProps = BillboardCollectionCesiumProps & BillboardCollectionOtherProps;

export declare const BillboardGraphics: CesiumComponentType<BillboardGraphics_2, BillboardGraphicsProps>;

declare type BillboardGraphicsCesiumEvents = {
    onDefinitionChange?: () => void;
};

declare type BillboardGraphicsCesiumProps = PickCesiumProps<Merge<BillboardGraphics_2, BillboardGraphics_2.ConstructorOptions>, typeof cesiumProps_3>;

export declare type BillboardGraphicsProps = BillboardGraphicsCesiumProps & BillboardGraphicsCesiumEvents;

declare type BillboardOtherProps = EventProps<{
    collection: BillboardCollection_2;
    id: string | undefined;
    primitive: Billboard_2;
}>;

export declare type BillboardProps = BillboardCesiumProps & BillboardOtherProps;

export declare const BlackAndWhiteStage: CesiumComponentType<PostProcessStage_2 | PostProcessStageComposite_2, {} & {
enabled?: boolean | undefined;
selected?: any[] | undefined;
} & Props & {
stages?: any[] | undefined;
}>;

export declare type BlackAndWhiteStageProps = PostProcessStageProps & Props;

export declare const Bloom: CesiumComponentType<PostProcessStage_2 | PostProcessStageComposite_2, {} & {
enabled?: boolean | undefined;
selected?: any[] | undefined;
} & Props_5 & {
stages?: any[] | undefined;
}>;

export declare type BloomProps = PostProcessStageCompositeProps & Props_5;

export declare const BlurStage: CesiumComponentType<PostProcessStage_2 | PostProcessStageComposite_2, {} & {
enabled?: boolean | undefined;
selected?: any[] | undefined;
} & Props_6 & {
stages?: any[] | undefined;
}>;

export declare type BlurStageProps = PostProcessStageCompositeProps & Props_6;

export declare const BoxGraphics: CesiumComponentType<BoxGraphics_2, BoxGraphicsProps>;

declare type BoxGraphicsCesiumEvents = {
    onDefinitionChange?: () => void;
};

declare type BoxGraphicsCesiumProps = PickCesiumProps<Merge<BoxGraphics_2, BoxGraphics_2.ConstructorOptions>, typeof cesiumProps_4>;

export declare type BoxGraphicsProps = BoxGraphicsCesiumProps & BoxGraphicsCesiumEvents;

export declare const BrightnessStage: CesiumComponentType<PostProcessStage_2 | PostProcessStageComposite_2, {} & {
enabled?: boolean | undefined;
selected?: any[] | undefined;
} & Props_2 & {
stages?: any[] | undefined;
}>;

export declare type BrightnessStageProps = PostProcessStageProps & Props_2;

export declare type Callback<T = any> = (e: CesiumMovementEvent, source: T) => void;

export declare const Camera: CesiumComponentType<Camera_2, CameraProps>;

declare type CameraCesiumEvents = {
    onChange?: (areaPercentage: number) => void;
    onMoveEnd?: () => void;
    onMoveStart?: () => void;
};

declare type CameraCesiumProps = PickCesiumProps<Camera_2, typeof cesiumProps_5>;

export declare const CameraFlyHome: FC<CameraFlyHomeProps & CameraOperationProps>;

export declare type CameraFlyHomeProps = {
    /** Duration of camera flight (second) */
    duration: number;
    /** If true, cancel camera flight if this component is unmounted. Default value is false. */
    cancelFlightOnUnmount?: boolean;
    /** If true, camera flight will be executed only once time. */
    once?: boolean;
};

export declare const CameraFlyTo: FC<Omit<{
destination: Cartesian3 | Rectangle;
orientation?: any;
duration?: number | undefined;
complete?: Camera_2.FlightCompleteCallback | undefined;
cancel?: Camera_2.FlightCancelledCallback | undefined;
endTransform?: Matrix4 | undefined;
maximumHeight?: number | undefined;
pitchAdjustHeight?: number | undefined;
flyOverLongitude?: number | undefined;
flyOverLongitudeWeight?: number | undefined;
convert?: boolean | undefined;
easingFunction?: EasingFunction.Callback | undefined;
}, "complete" | "cancel"> & {
onComplete?: Options_2["complete"];
onCancel?: Options_2["cancel"];
/** If true, cancel camera flight if this component is unmounted. Default value is false. */
cancelFlightOnUnmount?: boolean | undefined;
/** If true, camera flight will be executed only once time. */
once?: boolean | undefined;
} & CameraOperationProps>;

export declare const CameraFlyToBoundingSphere: FC<Omit<{
duration?: number | undefined;
offset?: HeadingPitchRange | undefined;
complete?: Camera_2.FlightCompleteCallback | undefined;
cancel?: Camera_2.FlightCancelledCallback | undefined;
endTransform?: Matrix4 | undefined;
maximumHeight?: number | undefined;
pitchAdjustHeight?: number | undefined;
flyOverLongitude?: number | undefined;
flyOverLongitudeWeight?: number | undefined;
easingFunction?: EasingFunction.Callback | undefined;
}, "complete" | "cancel"> & {
boundingSphere: Parameters<Camera_2["flyToBoundingSphere"]>[0];
onComplete?: Options_3["complete"];
onCancel?: Options_3["cancel"];
/** If true, cancel camera flight if this component is unmounted. Default value is false. */
cancelFlightOnUnmount?: boolean | undefined;
/** If true, camera flight will be executed only once time. */
once?: boolean | undefined;
} & CameraOperationProps>;

export declare type CameraFlyToBoundingSphereProps = Omit<Options_3, "complete" | "cancel"> & {
    boundingSphere: Parameters<Camera_2["flyToBoundingSphere"]>[0];
    onComplete?: Options_3["complete"];
    onCancel?: Options_3["cancel"];
    /** If true, cancel camera flight if this component is unmounted. Default value is false. */
    cancelFlightOnUnmount?: boolean;
    /** If true, camera flight will be executed only once time. */
    once?: boolean;
};

export declare type CameraFlyToProps = Omit<Options_2, "complete" | "cancel"> & {
    onComplete?: Options_2["complete"];
    onCancel?: Options_2["cancel"];
    /** If true, cancel camera flight if this component is unmounted. Default value is false. */
    cancelFlightOnUnmount?: boolean;
    /** If true, camera flight will be executed only once time. */
    once?: boolean;
};

export declare const CameraLookAt: FC<CameraLookAtProps & CameraOperationProps>;

export declare type CameraLookAtProps = {
    target: Parameters<Camera_2["lookAt"]>[0];
    offset: Parameters<Camera_2["lookAt"]>[1];
};

export declare type CameraOperationProps = {
    cancelFlightOnUnmount?: boolean;
    once?: boolean;
};

export declare type CameraProps = CameraCesiumProps & CameraCesiumEvents;

export declare const Cesium3DTileset: CesiumComponentType<Cesium3DTileset_2, Cesium3DTilesetProps>;

declare type Cesium3DTilesetCesiumEvents = {
    onAllTilesLoad?: () => void;
    onInitialTilesLoad?: () => void;
    onLoadProgress?: (numberOfPendingRequests: number, numberOfTilesProcessing: number) => void;
    onTileFailed?: (error: any) => void;
    onTileLoad?: (tile: Cesium3DTile) => void;
    onTileUnload?: (tile: Cesium3DTile) => void;
    onTileVisible?: (tile: Cesium3DTile) => void;
};

declare type Cesium3DTilesetCesiumProps = PickCesiumProps<Cesium3DTileset_2, typeof cesiumProps_6>;

declare type Cesium3DTilesetCesiumReadonlyProps = PickCesiumProps<Merge<Cesium3DTileset_2, ConstructorOptions<typeof Cesium3DTileset_2>>, typeof cesiumReadonlyProps>;

export declare const Cesium3DTilesetGraphics: CesiumComponentType<Cesium3DTilesetGraphics_2, Cesium3DTilesetGraphicsProps>;

declare type Cesium3DTilesetGraphicsCesiumEvents = {
    onDefinitionChange?: () => void;
};

declare type Cesium3DTilesetGraphicsCesiumProps = PickCesiumProps<Merge<Cesium3DTilesetGraphics_2, Cesium3DTilesetGraphics_2.ConstructorOptions>, typeof cesiumProps_7>;

export declare type Cesium3DTilesetGraphicsProps = Cesium3DTilesetGraphicsCesiumProps & Cesium3DTilesetGraphicsCesiumEvents;

declare type Cesium3DTilesetOtherProps = EventProps<Cesium3DTileFeature> & {
    /** Calls when the tile set is completely loaded. */
    onReady?: (tileset: Cesium3DTileset_2) => void;
    onError?: (err: unknown) => void;
    url: string | Resource | Promise<Resource>;
};

export declare type Cesium3DTilesetProps = Cesium3DTilesetCesiumProps & Cesium3DTilesetCesiumReadonlyProps & Cesium3DTilesetCesiumEvents & Cesium3DTilesetOtherProps;

export declare type CesiumComponentOptions<Element, Props extends RootComponentInternalProps, State = any> = Options<Element, Props, State> & {
    renderContainer?: boolean;
    noChildren?: boolean;
    containerProps?: (keyof Props)[] | ((props: Props) => HTMLAttributes<HTMLDivElement>);
    defaultProps?: Partial<Props>;
};

export declare type CesiumComponentRef<Element> = {
    cesiumElement?: Element;
};

export declare type CesiumComponentType<Element, Props> = ForwardRefExoticComponent<PropsWithoutRef<Props> & RefAttributes<CesiumComponentRef<Element>>>;

export declare const CesiumContext: Context<ResiumContext>;

declare type CesiumEventKeys<T> = {
    [K in keyof T]: T[K] extends Event_2 ? K : never;
}[keyof T];

export declare type CesiumHOCComponentType<E, P> = ForwardRefExoticComponent<PropsWithoutRef<P> & RefAttributes<CesiumInsideComponentType<E, P>>>;

export declare interface CesiumInsideComponentType<E, P = any> extends PureComponent<WithContextProps<P, any>> {
    cesiumElement: E;
}

export declare type CesiumMovementEvent = {
    position?: Cartesian2;
    startPosition?: Cartesian2;
    endPosition?: Cartesian2;
};

export declare type CesiumProp<C> = {
    cesium: C;
};

declare const cesiumProps: readonly ["alignedAxis", "color", "disableDepthTestDistance", "distanceDisplayCondition", "eyeOffset", "height", "heightReference", "horizontalOrigin", "image", "pixelOffset", "splitDirection", "pixelOffsetScaleByDistance", "position", "rotation", "scale", "scaleByDistance", "show", "sizeInMeters", "translucencyByDistance", "verticalOrigin", "width", "id"];

declare const cesiumProps_10: readonly ["canAnimate", "clockRange", "clockStep", "currentTime", "multiplier", "shouldAnimate", "startTime", "stopTime"];

declare const cesiumProps_11: readonly ["noiseDetail", "noiseOffset", "show", "debugBillboards", "debugEllipsoids"];

declare const cesiumProps_12: readonly ["positions", "width", "cornerType", "height", "heightReference", "extrudedHeight", "extrudedHeightReference", "show", "fill", "material", "outline", "outlineColor", "outlineWidth", "granularity", "shadows", "distanceDisplayCondition", "zIndex", "classificationType"];

declare const cesiumProps_13: readonly ["show", "position", "scale", "maximumSize", "slice", "brightness", "color"];

declare const cesiumProps_14: readonly ["clustering", "name", "show", "clock", "isLoading"];

declare const cesiumProps_15: readonly ["heightReference", "length", "topRadius", "bottomRadius", "show", "fill", "material", "outline", "outlineColor", "outlineWidth", "numberOfVerticalLines", "slices", "distanceDisplayCondition", "shadows"];

declare const cesiumProps_16: readonly ["clustering", "show"];

declare const cesiumProps_17: readonly ["semiMajorAxis", "semiMinorAxis", "height", "heightReference", "extrudedHeight", "show", "fill", "material", "outline", "outlineColor", "outlineWidth", "numberOfVerticalLines", "rotation", "stRotation", "granularity", "shadows", "distanceDisplayCondition", "zIndex", "classificationType", "extrudedHeightReference"];

declare const cesiumProps_18: readonly ["heightReference", "radii", "show", "fill", "innerRadii", "material", "maximumClock", "maximumCone", "minimumClock", "minimumCone", "outline", "outlineColor", "outlineWidth", "subdivisions", "stackPartitions", "slicePartitions", "shadows", "distanceDisplayCondition"];

declare const cesiumProps_19: readonly ["availability", "billboard", "box", "corridor", "cylinder", "description", "ellipse", "ellipsoid", "entityCollection", "label", "model", "name", "trackingReferenceFrame", "orientation", "path", "plane", "parent", "point", "polygon", "polyline", "polylineVolume", "position", "properties", "rectangle", "show", "tileset", "viewFrom", "wall"];

declare const cesiumProps_2: readonly ["blendOption", "debugShowBoundingVolume", "debugShowTextureAtlas", "modelMatrix", "show"];

declare const cesiumProps_20: readonly ["density", "enabled", "minimumBrightness", "screenSpaceErrorFactor", "heightScalar", "maxHeight", "visualDensityScalar", "heightFalloff", "renderable"];

declare const cesiumProps_21: readonly ["clustering", "name", "show"];

declare const cesiumProps_22: readonly ["atmosphereBrightnessShift", "atmosphereHueShift", "atmosphereSaturationShift", "backFaceCulling", "baseColor", "clippingPlanes", "clippingPolygons", "depthTestAgainstTerrain", "enableLighting", "lightingFadeInDistance", "lightingFadeOutDistance", "material", "maximumScreenSpaceError", "nightFadeInDistance", "nightFadeOutDistance", "oceanNormalMapUrl", "shadows", "show", "showGroundAtmosphere", "showWaterEffect", "tileCacheSize", "loadingDescendantLimit", "preloadAncestors", "preloadSiblings", "fillHighlightColor", "dynamicAtmosphereLighting", "dynamicAtmosphereLightingFromSun", "showSkirts", "cartographicLimitRectangle", "translucency", "undergroundColor", "undergroundColorAlphaByDistance", "lambertDiffuseMultiplier", "atmosphereLightIntensity", "atmosphereRayleighCoefficient", "atmosphereMieCoefficient", "atmosphereRayleighScaleHeight", "atmosphereMieScaleHeight", "atmosphereMieAnisotropy", "vertexShadowDarkness"];

declare const cesiumProps_23: readonly ["appearance", "classificationType", "debugShowBoundingVolume", "debugShowShadowVolume", "show"];

declare const cesiumProps_24: readonly ["appearance", "classificationType", "debugShowBoundingVolume", "debugShowShadowVolume", "show"];

declare const cesiumProps_25: readonly ["show", "destroyPrimitives", "primitiveAdded", "primitiveRemoved"];

declare const cesiumProps_26: readonly ["alpha", "brightness", "contrast", "hue", "saturation", "gamma", "splitDirection", "minificationFilter", "magnificationFilter", "cutoutRectangle", "show", "nightAlpha", "dayAlpha", "colorToAlpha", "colorToAlphaThreshold", "index"];

declare const cesiumProps_27: readonly ["clustering", "name", "show"];

declare const cesiumProps_28: readonly ["backgroundColor", "backgroundPadding", "disableDepthTestDistance", "distanceDisplayCondition", "eyeOffset", "fillColor", "font", "heightReference", "horizontalOrigin", "id", "outlineColor", "outlineWidth", "pixelOffset", "pixelOffsetScaleByDistance", "position", "scale", "scaleByDistance", "show", "showBackground", "style", "text", "translucencyByDistance", "verticalOrigin"];

declare const cesiumProps_29: readonly ["blendOption", "debugShowBoundingVolume", "modelMatrix", "show"];

declare const cesiumProps_3: readonly ["image", "show", "scale", "horizontalOrigin", "verticalOrigin", "eyeOffset", "pixelOffset", "rotation", "alignedAxis", "splitDirection", "width", "height", "color", "scaleByDistance", "translucencyByDistance", "pixelOffsetScaleByDistance", "imageSubRegion", "sizeInMeters", "heightReference", "distanceDisplayCondition", "disableDepthTestDistance"];

declare const cesiumProps_30: readonly ["text", "font", "style", "fillColor", "outlineColor", "outlineWidth", "show", "showBackground", "backgroundColor", "backgroundPadding", "scale", "horizontalOrigin", "verticalOrigin", "eyeOffset", "pixelOffset", "translucencyByDistance", "pixelOffsetScaleByDistance", "scaleByDistance", "heightReference", "distanceDisplayCondition", "disableDepthTestDistance"];

declare const cesiumProps_31: readonly ["backFaceCulling", "clampAnimations", "clippingPlanes", "color", "colorBlendAmount", "colorBlendMode", "customShader", "debugShowBoundingVolume", "debugWireframe", "distanceDisplayCondition", "featureIdLabel", "heightReference", "id", "imageBasedLighting", "instanceFeatureIdLabel", "lightColor", "maximumScale", "minimumPixelSize", "modelMatrix", "clippingPolygons", "outlineColor", "scale", "shadows", "show", "showCreditsOnScreen", "showOutline", "silhouetteColor", "silhouetteSize", "splitDirection", "style"];

declare const cesiumProps_32: readonly ["uri", "show", "scale", "minimumPixelSize", "maximumScale", "incrementallyLoadTextures", "runAnimations", "clampAnimations", "nodeTransformations", "environmentMapOptions", "enableVerticalExaggeration", "shadows", "heightReference", "distanceDisplayCondition", "silhouetteColor", "silhouetteSize", "color", "colorBlendMode", "colorBlendAmount", "clippingPlanes", "imageBasedLightingFactor", "lightColor", "articulations", "customShader"];

declare const cesiumProps_33: readonly ["onlySunLighting", "show", "textureUrl"];

declare const cesiumProps_34: readonly ["show", "emitter", "modelMatrix", "emitterModelMatrix", "emissionRate", "bursts", "loop", "startScale", "endScale", "startColor", "endColor", "image", "imageSize", "minimumImageSize", "maximumImageSize", "speed", "minimumSpeed", "maximumSpeed", "lifetime", "particleLife", "minimumParticleLife", "maximumParticleLife", "mass", "minimumMass", "maximumMass", "sizeInMeters"];

declare const cesiumProps_35: readonly ["leadTime", "trailTime", "show", "width", "material", "resolution", "distanceDisplayCondition"];

declare const cesiumProps_36: readonly ["plane", "dimensions", "show", "fill", "material", "outline", "outlineColor", "outlineWidth", "shadows", "distanceDisplayCondition"];

declare const cesiumProps_37: readonly ["color", "pixelSize", "outlineColor", "outlineWidth", "show", "scaleByDistance", "translucencyByDistance", "heightReference", "splitDirection", "distanceDisplayCondition", "disableDepthTestDistance"];

declare const cesiumProps_38: readonly ["color", "disableDepthTestDistance", "distanceDisplayCondition", "id", "outlineColor", "splitDirection", "outlineWidth", "pixelSize", "position", "scaleByDistance", "show", "translucencyByDistance"];

declare const cesiumProps_39: readonly ["blendOption", "debugShowBoundingVolume", "modelMatrix", "show"];

declare const cesiumProps_4: readonly ["heightReference", "dimensions", "show", "fill", "material", "outline", "outlineColor", "outlineWidth", "shadows", "distanceDisplayCondition"];

declare const cesiumProps_40: readonly ["arcType", "hierarchy", "height", "heightReference", "extrudedHeight", "extrudedHeightReference", "show", "fill", "material", "outline", "outlineColor", "outlineWidth", "stRotation", "granularity", "perPositionHeight", "closeTop", "closeBottom", "shadows", "distanceDisplayCondition", "zIndex", "classificationType", "textureCoordinates"];

declare const cesiumProps_41: readonly ["distanceDisplayCondition", "id", "loop", "material", "positions", "show", "width"];

declare const cesiumProps_42: readonly ["debugShowBoundingVolume", "length", "modelMatrix", "show"];

declare const cesiumProps_43: readonly ["arcType", "classificationType", "positions", "clampToGround", "width", "show", "material", "depthFailMaterial", "granularity", "shadows", "distanceDisplayCondition", "zIndex"];

declare const cesiumProps_44: readonly ["positions", "shape", "cornerType", "show", "fill", "material", "outline", "outlineColor", "outlineWidth", "granularity", "shadows", "distanceDisplayCondition"];

declare const cesiumProps_45: readonly ["enabled", "selected"];

declare const cesiumProps_46: readonly ["enabled", "selected"];

declare const cesiumProps_47: readonly ["appearance", "cull", "debugShowBoundingVolume", "depthFailAppearance", "modelMatrix", "shadows", "show"];

declare const cesiumProps_48: readonly ["classificationType", "coordinates", "height", "heightReference", "extrudedHeight", "extrudedHeightReference", "show", "fill", "material", "outline", "outlineColor", "outlineWidth", "rotation", "stRotation", "granularity", "shadows", "distanceDisplayCondition", "zIndex"];

declare const cesiumProps_49: readonly ["backgroundColor", "completeMorphOnUserInput", "debugCommandFilter", "debugShowCommands", "debugShowDepthFrustum", "debugShowFramesPerSecond", "debugShowFrustumPlanes", "debugShowFrustums", "eyeSeparation", "farToNearRatio", "focalLength", "fog", "gamma", "globe", "highDynamicRange", "invertClassification", "invertClassificationColor", "light", "logarithmicDepthBuffer", "logarithmicDepthFarToNearRatio", "maximumRenderTimeChange", "minimumDisableDepthTestDistance", "moon", "morphTime", "nearToFarDistance2D", "pickTranslucentDepth", "requestRenderMode", "rethrowRenderErrors", "shadowMap", "skyAtmosphere", "skyBox", "specularEnvironmentMaps", "sphericalHarmonicCoefficients", "sun", "sunBloom", "terrainProvider", "useDepthPicking", "useWebVR", "postProcessStages", "msaaSamples", "splitPosition", "debugCommandFilter", "verticalExaggeration", "verticalExaggerationRelativeHeight", "atmosphere"];

declare const cesiumProps_5: readonly ["position", "direction", "up", "right", "frustum", "defaultMoveAmount", "defaultLookAmount", "defaultRotateAmount", "defaultZoomAmount", "constrainedAxis", "maximumZoomFactor", "percentageChanged"];

declare const cesiumProps_50: readonly ["bounceAnimationTime", "enableCollisionDetection", "enableInputs", "enableLook", "enableRotate", "enableTilt", "enableTranslate", "enableZoom", "zoomFactor", "maximumTiltAngle", "inertiaSpin", "inertiaTranslate", "inertiaZoom", "lookEventTypes", "maximumMovementRatio", "maximumZoomDistance", "minimumCollisionTerrainHeight", "minimumPickingTerrainHeight", "minimumTrackBallHeight", "minimumZoomDistance", "rotateEventTypes", "tiltEventTypes", "translateEventTypes", "zoomEventTypes", "minimumPickingTerrainDistanceWithInertia"];

declare const cesiumProps_51: readonly ["darkness", "fadingEnabled", "maximumDistance", "enabled", "normalOffset", "softShadows", "size"];

declare const cesiumProps_52: readonly ["brightnessShift", "hueShift", "saturationShift", "show", "perFragmentAtmosphere", "atmosphereLightIntensity", "atmosphereRayleighCoefficient", "atmosphereMieCoefficient", "atmosphereRayleighScaleHeight", "atmosphereMieScaleHeight", "atmosphereMieAnisotropy"];

declare const cesiumProps_53: readonly ["sources", "show"];

declare const cesiumProps_54: readonly ["glowFactor", "show"];

declare const cesiumProps_55: readonly ["clippingPlanes", "maximumMemoryUsage", "modelMatrix", "shadows", "show", "style", "intervals"];

declare const cesiumProps_56: readonly ["terrainShadows", "clockTrackedDataSource", "targetFrameRate", "useDefaultRenderLoop", "resolutionScale", "allowDataSourcesToSuspendAnimation", "trackedEntity", "ellipsoid", "selectedEntity", "shadows", "useBrowserRecommendedResolution", "creditDisplay"];

declare const cesiumProps_57: readonly ["positions", "maximumHeights", "minimumHeights", "show", "fill", "material", "outline", "outlineColor", "outlineWidth", "granularity", "shadows", "distanceDisplayCondition"];

declare const cesiumProps_58: readonly ["enabled", "selected"];

declare const cesiumProps_6: readonly ["show", "modelMatrix", "shadows", "maximumScreenSpaceError", "cullRequestsWhileMoving", "cullRequestsWhileMovingMultiplier", "preloadWhenHidden", "preloadFlightDestinations", "preferLeaves", "progressiveResolutionHeightFraction", "foveatedScreenSpaceError", "foveatedConeSize", "foveatedMinimumScreenSpaceErrorRelaxation", "foveatedInterpolationCallback", "foveatedTimeDelay", "dynamicScreenSpaceError", "dynamicScreenSpaceErrorDensity", "dynamicScreenSpaceErrorFactor", "dynamicScreenSpaceErrorHeightFalloff", "skipLevelOfDetail", "baseScreenSpaceError", "skipScreenSpaceErrorFactor", "skipLevels", "immediatelyLoadDesiredLevelOfDetail", "loadSiblings", "clippingPlanes", "clippingPolygons", "classificationType", "ellipsoid", "lightColor", "colorBlendAmount", "colorBlendMode", "debugFreezeFrame", "debugColorizeTiles", "debugWireframe", "debugShowBoundingVolume", "debugShowContentBoundingVolume", "debugShowViewerRequestVolume", "debugShowGeometricError", "debugShowRenderingStatistics", "debugShowMemoryUsage", "debugShowUrl", "style", "backFaceCulling", "vectorClassificationOnly", "vectorKeepDecodedPositions", "splitDirection", "customShader", "imageBasedLighting", "showCreditsOnScreen", "featureIdLabel", "instanceFeatureIdLabel", "imageBasedLighting", "outlineColor", "cacheBytes", "maximumCacheOverflowBytes", "enableCollision"];

declare const cesiumProps_7: readonly ["show", "uri", "maximumScreenSpaceError"];

declare const cesiumProps_8: readonly ["resolutionScale", "useDefaultRenderLoop", "targetFrameRate", "useBrowserRecommendedResolution", "creditDisplay"];

declare const cesiumProps_9: readonly ["classificationType", "debugShowBoundingVolume", "debugShowShadowVolume", "show"];

declare type CesiumPureProps<T> = Exclude<StringOnly<keyof T>, FunctionKeys<T> | Exclude<ReadonlyKeys<T>, CesiumEventKeys<T>> | "prototype">;

declare const cesiumReadonlyProps: readonly ["showOutline", "cullWithChildrenBounds", "debugHeatmapTilePropertyName", "enableDebugWireframe", "environmentMapOptions", "modelUpAxis", "modelForwardAxis", "projectTo2D", "enableShowOutline", "enablePick"];

declare const cesiumReadonlyProps_10: readonly ["canvas", "camera", "ellipsoid", "clampToGround", "sourceUri", "credit", "screenOverlayContainer"];

declare const cesiumReadonlyProps_11: readonly ["allowPicking", "asynchronous", "basePath", "credit", "enableDebugWireframe", "gltf", "heightReference", "incrementallyLoadTextures", "scene", "releaseGltfJson", "cull", "opaquePass", "enableVerticalExaggeration", "environmentMapOptions", "upAxis", "forwardAxis", "content", "scene", "enableShowOutline", "projectTo2D", "classificationType", "errorEvent", "readyEvent", "texturesReadyEvent", "gltfCallback", "enablePick"];

declare const cesiumReadonlyProps_12: readonly ["ellipsoid"];

declare const cesiumReadonlyProps_13: readonly ["color", "imageSize", "speed", "scale", "particleLife", "mass"];

declare const cesiumReadonlyProps_14: readonly ["clearColor", "forcePowerOfTwo", "fragmentShader", "name", "pixelDatatype", "pixelFormat", "sampleMode", "scissorRectangle", "textureScale", "uniforms"];

declare const cesiumReadonlyProps_15: readonly ["inputPreviousStageTexture", "name", "stages", "uniforms"];

declare const cesiumReadonlyProps_16: readonly ["allowPicking", "asynchronous", "compressVertices", "geometryInstances", "interleave", "releaseGeometryInstances", "vertexCacheOptimize"];

declare const cesiumReadonlyProps_17: readonly ["clock", "shading"];

declare const cesiumReadonlyProps_18: readonly ["baseLayer", "animation", "baseLayerPicker", "fullscreenButton", "vrButton", "geocoder", "homeButton", "infoBox", "sceneModePicker", "selectionIndicator", "timeline", "navigationHelpButton", "navigationInstructionsInitiallyVisible", "scene3DOnly", "shouldAnimate", "clockViewModel", "selectedImageryProviderViewModel", "imageryProviderViewModels", "selectedTerrainProviderViewModel", "terrainProviderViewModels", "skyBox", "skyAtmosphere", "fullscreenElement", "showRenderLoopErrors", "automaticallyTrackDataSourceClocks", "contextOptions", "sceneMode", "mapProjection", "globe", "orderIndependentTranslucency", "creditContainer", "creditViewport", "dataSources", "mapMode2D", "projectionPicker", "requestRenderMode", "maximumRenderTimeChange", "depthPlaneEllipsoidOffset", "msaaSamples", "blurActiveElementOnCanvasFocus", "terrain"];

declare const cesiumReadonlyProps_2: readonly ["clock", "baseLayer", "terrainProvider", "skyBox", "skyAtmosphere", "sceneMode", "scene3DOnly", "orderIndependentTranslucency", "mapMode2D", "mapProjection", "globe", "showRenderLoopErrors", "contextOptions", "creditContainer", "creditViewport", "shadows", "terrainShadows", "ellipsoid", "dataSources", "allowDataSourcesToSuspendAnimation", "trackedEntity", "trackedEntityChanged", "clockTrackedDataSource", "shouldAnimate", "automaticallyTrackDataSourceClocks", "terrain", "requestRenderMode", "maximumRenderTimeChange", "msaaSamples", "blurActiveElementOnCanvasFocus"];

declare const cesiumReadonlyProps_3: readonly ["allowPicking", "asynchronous", "compressVertices", "geometryInstances", "interleave", "releaseGeometryInstances", "vertexCacheOptimize", "appearance"];

declare const cesiumReadonlyProps_4: readonly ["name", "sourceUri", "credit"];

declare const cesiumReadonlyProps_5: readonly ["id"];

declare const cesiumReadonlyProps_6: readonly ["clampToGround", "sourceUri", "credit", "markerSize", "markerSymbol", "markerColor", "stroke", "strokeWidth", "fill", "describe"];

declare const cesiumReadonlyProps_7: readonly ["allowPicking", "asynchronous", "geometryInstances", "interleave", "releaseGeometryInstances"];

declare const cesiumReadonlyProps_8: readonly ["allowPicking", "asynchronous", "compressVertices", "geometryInstances", "interleave", "releaseGeometryInstances", "vertexCacheOptimize"];

declare const cesiumReadonlyProps_9: readonly ["rectangle", "maximumAnisotropy", "minimumTerrainLevel", "maximumTerrainLevel", "readyEvent", "imageryProvider"];

export declare const CesiumWidget: CesiumComponentType<CesiumWidget_2, CesiumWidgetProps>;

declare type CesiumWidgetCesiumProps = PickCesiumProps<CesiumWidget_2, typeof cesiumProps_8>;

declare type CesiumWidgetCesiumReadonlyProps = PickCesiumProps<Target, typeof cesiumReadonlyProps_2>;

declare type CesiumWidgetOtherProps = RootEventProps & RootComponentInternalProps & {
    /** Applied to outer `div` element */
    className?: string;
    /** Applied to outer `div` element */
    id?: string;
    /** Applied to outer `div` element */
    style?: CSSProperties;
    /** Same as `style={{ position: "absolute", top: 0, left: 0, right: 0, bottom: 0 }}` if it is true. */
    full?: boolean;
    /** All props applied to outer `div` element */
    containerProps?: any;
    children?: ReactNode;
};

export declare type CesiumWidgetProps = CesiumWidgetCesiumProps & CesiumWidgetCesiumReadonlyProps & CesiumWidgetOtherProps;

export declare const ClassificationPrimitive: CesiumComponentType<ClassificationPrimitive_2, ClassificationPrimitiveProps>;

declare type ClassificationPrimitiveCesiumProps = PickCesiumProps<Target_2, typeof cesiumProps_9>;

declare type ClassificationPrimitiveCesiumReadonlyProps = PickCesiumProps<Target_2, typeof cesiumReadonlyProps_3>;

declare type ClassificationPrimitiveOtherProps = EventProps<ClassificationPrimitive_2> & {
    /** Calls when [Primitive#readyPromise](https://cesium.com/docs/cesiumjs-ref-doc/ClassificationPrimitive.html#readyPromise) is fullfilled */
    onReady?: (primitive: ClassificationPrimitive_2) => void;
};

export declare type ClassificationPrimitiveProps = ClassificationPrimitiveCesiumProps & ClassificationPrimitiveCesiumReadonlyProps & ClassificationPrimitiveOtherProps;

export declare const Clock: CesiumComponentType<Clock_2, ClockProps>;

declare type ClockCesiumEvents = {
    onStop?: (clock: Clock_2) => void;
    onTick?: (clock: Clock_2) => void;
};

declare type ClockCesiumProps = PickCesiumProps<Clock_2, typeof cesiumProps_10> & {
    canAnimate?: boolean;
    clockRange?: ClockRange;
    clockStep?: ClockStep;
    currentTime?: JulianDate;
    multiplier?: number;
    shouldAnimate?: boolean;
    startTime?: JulianDate;
    stopTime?: JulianDate;
};

export declare type ClockProps = ClockCesiumProps & ClockCesiumEvents;

export declare const CloudCollection: CesiumComponentType<CloudCollection_2, CloudCollectionProps>;

declare type CloudCollectionCesiumProps = PickCesiumProps<CloudCollection_2, typeof cesiumProps_11>;

declare type CloudCollectionOtherProps = {
    children?: ReactNode;
};

export declare type CloudCollectionProps = CloudCollectionCesiumProps & CloudCollectionOtherProps;

export declare type ConstructorOptions<T extends new (...args: any[]) => any> = NonNullable<ConstructorParameters<T>[0]>;

export declare type ConstructorOptions2<T extends new (...args: any[]) => any> = NonNullable<ConstructorParameters<T>[1]>;

export declare const Consumer: Consumer_2<ResiumContext>;

declare type CorridorCesiumEvents = {
    onDefinitionChange?: () => void;
};

export declare const CorridorGraphics: CesiumComponentType<CorridorGraphics_2, CorridorGraphicsProps>;

declare type CorridorGraphicsCesiumProps = PickCesiumProps<Merge<CorridorGraphics_2, CorridorGraphics_2.ConstructorOptions>, typeof cesiumProps_12>;

export declare type CorridorGraphicsProps = CorridorGraphicsCesiumProps & CorridorCesiumEvents;

export declare const createCameraOperation: <P>(name: string, cameraOperationStart: (camera: Camera_2, props: P, prevProps?: P) => void) => FC<P & CameraOperationProps>;

export declare const createCesiumComponent: <Element, Props extends {}, State = any>({ renderContainer, noChildren, containerProps, defaultProps, ...options }: CesiumComponentOptions<Element, Props, State>) => CesiumComponentType<Element, Props>;

export declare const createPostProcessStage: <UniformProps>(opts: {
    name: string;
    props: (keyof UniformProps)[];
    readonlyProps?: (keyof UniformProps)[] | undefined;
    noMount?: boolean | undefined;
    create(props: Readonly<UniformProps & PostProcessStageCesiumProps>, postProcessStages: PostProcessStageCollection): PostProcessStage_2 | PostProcessStageComposite_2;
}) => CesiumComponentType<PostProcessStage_2 | PostProcessStageComposite_2, {} & {
enabled?: boolean | undefined;
selected?: any[] | undefined;
} & UniformProps & {
stages?: any[] | undefined;
}>;

declare type CreateReturnType<Element, State = any> = Element | [Element, State] | undefined;

export declare const CumulusCloud: CesiumComponentType<CumulusCloud_2, CumulusCloudCesiumProps>;

declare type CumulusCloudCesiumProps = PickCesiumProps<CumulusCloud_2, typeof cesiumProps_13>;

export declare type CumulusCloudProps = CumulusCloudCesiumProps;

export declare const CustomDataSource: CesiumComponentType<CustomDataSource_2, CustomDataSourceProps>;

declare type CustomDataSourceCesiumEvents = {
    onChange?: (customDataSource: CustomDataSource_2) => void;
    onError?: (customDataSource: CustomDataSource_2, error: any) => void;
    onLoading?: (customDataSource: CustomDataSource_2, isLoaded: boolean) => void;
};

declare type CustomDataSourceCesiumProps = PickCesiumProps<CustomDataSource_2, typeof cesiumProps_14>;

declare type CustomDataSourceOtherProps = EventProps<EventTarget_2> & {
    children?: ReactNode;
};

export declare type CustomDataSourceProps = CustomDataSourceCesiumProps & CustomDataSourceCesiumEvents & CustomDataSourceOtherProps;

declare type CylinderCesiumEvents = {
    onDefinitionChange?: () => void;
};

export declare const CylinderGraphics: CesiumComponentType<CylinderGraphics_2, CylinderGraphicsProps>;

declare type CylinderGraphicsCesiumProps = PickCesiumProps<Merge<CylinderGraphics_2, CylinderGraphics_2.ConstructorOptions>, typeof cesiumProps_15>;

export declare type CylinderGraphicsProps = CylinderGraphicsCesiumProps & CylinderCesiumEvents;

export declare const CzmlDataSource: CesiumComponentType<CzmlDataSource_2, CzmlDataSourceProps>;

declare type CzmlDataSourceCesiumEvents = {
    onChange?: (CzmlDataSource: CzmlDataSource_2) => void;
    onError?: (CzmlDataSource: CzmlDataSource_2, error: any) => void;
    onLoading?: (CzmlDataSource: CzmlDataSource_2, isLoaded: boolean) => void;
};

declare type CzmlDataSourceCesiumProps = PickCesiumProps<CzmlDataSource_2, typeof cesiumProps_16>;

declare type CzmlDataSourceCesiumReadonlyProps = PickCesiumProps<Target_3, typeof cesiumReadonlyProps_4>;

declare type CzmlDataSourceOtherProps = EventProps<EventTarget_2> & {
    /** Calls when the Promise for loading data is fullfilled. */
    onLoad?: (CzmlDataSouce: CzmlDataSource_2) => void;
    data?: Parameters<CzmlDataSource_2["load"]>[0];
};

export declare type CzmlDataSourceProps = CzmlDataSourceCesiumProps & CzmlDataSourceCesiumReadonlyProps & CzmlDataSourceCesiumEvents & CzmlDataSourceOtherProps;

export declare const DepthOfFieldStage: CesiumComponentType<PostProcessStage_2 | PostProcessStageComposite_2, {} & {
enabled?: boolean | undefined;
selected?: any[] | undefined;
} & Props_7 & {
stages?: any[] | undefined;
}>;

export declare type DepthOfFieldStageProps = PostProcessStageCompositeProps & Props_7;

export declare type Destroyable = {
    isDestroyed(): boolean;
    destroy(): void;
};

export declare const EdgeDetectionStage: CesiumComponentType<PostProcessStage_2 | PostProcessStageComposite_2, {} & {
enabled?: boolean | undefined;
selected?: any[] | undefined;
} & Props_8 & {
stages?: any[] | undefined;
}>;

export declare type EdgeDetectionStageProps = PostProcessStageCompositeProps & Props_8;

export declare const EllipseGraphics: CesiumComponentType<EllipseGraphics_2, EllipseGraphicsProps>;

declare type EllipseGraphicsCesiumEvents = {
    onDefinitionChange?: () => void;
};

declare type EllipseGraphicsCesiumProps = PickCesiumProps<Merge<EllipseGraphics_2, EllipseGraphics_2.ConstructorOptions>, typeof cesiumProps_17>;

export declare type EllipseGraphicsProps = EllipseGraphicsCesiumProps & EllipseGraphicsCesiumEvents;

export declare const EllipsoidGraphics: CesiumComponentType<EllipsoidGraphics_2, EllipsoidGraphicsProps>;

declare type EllipsoidGraphicsCesiumEvents = {
    onDefinitionChange?: () => void;
};

declare type EllipsoidGraphicsCesiumProps = PickCesiumProps<Target_4, typeof cesiumProps_18>;

export declare type EllipsoidGraphicsProps = EllipsoidGraphicsCesiumProps & EllipsoidGraphicsCesiumEvents;

export declare const Entity: CesiumComponentType<Entity_2, EntityProps>;

declare type EntityCesiumEvents = {
    onDefinitionChange?: () => void;
};

declare type EntityCesiumProps = PickCesiumProps<Merge<Entity_2, Entity_2.ConstructorOptions>, typeof cesiumProps_19>;

declare type EntityCesiumReadonlyProps = PickCesiumProps<Entity_2, typeof cesiumReadonlyProps_5>;

export declare const EntityDescription: FC<EntityDescriptionProps>;

export declare type EntityDescriptionProps = PropsWithChildren<{
    container?: Element;
    resizeInfoBox?: boolean;
}>;

declare type EntityOtherProps = RootComponentInternalProps & EventProps<EventTarget_2> & {
    children?: ReactNode;
    /** If true, the entity will be selected. It works only inside Viewer not CesiumWidget. */
    selected?: boolean;
    /** If true, the entity will be tracked by the camera. It works only inside Viewer not CesiumWidget. */
    tracked?: boolean;
};

export declare type EntityProps = EntityCesiumProps & EntityCesiumReadonlyProps & EntityCesiumEvents & EntityOtherProps;

export declare function entries<T extends {}>(obj: T): [keyof T, T[keyof T]][];

export declare type EventkeyMap<T, P> = {
    [K in keyof P]?: keyof T;
};

export declare class EventManager {
    private static eventTypeMap;
    private scene;
    private sshe;
    private events;
    private hovered;
    constructor(scene?: Scene_2);
    destroy(): void;
    isDestroyed(): boolean;
    on(element: any, type: EventType, cb: Callback): void;
    off(element: any, type: EventType): void;
    setEvents(element: any, props: any): void;
    clearEvents(element: any): void;
    commit(): void;
    getScreenSpaceEventHandler(): ScreenSpaceEventHandler_2;
    private getEventCallback;
    private onMouseMove;
    private eventCallback;
    private pick;
}

export declare const eventManagerContextKey = "__RESIUM_EVENT_MANAGER";

export declare const eventNames: EventType[];

export declare type EventProps<T> = {
    onClick?: (movement: CesiumMovementEvent, target: T) => void;
    onDoubleClick?: (movement: CesiumMovementEvent, target: T) => void;
    onMouseDown?: (movement: CesiumMovementEvent, target: T) => void;
    onMouseUp?: (movement: CesiumMovementEvent, target: T) => void;
    onMiddleClick?: (movement: CesiumMovementEvent, target: T) => void;
    onMiddleDown?: (movement: CesiumMovementEvent, target: T) => void;
    onMiddleUp?: (movement: CesiumMovementEvent, target: T) => void;
    onMouseMove?: (movement: CesiumMovementEvent, target: T) => void;
    onPinchEnd?: (movement: CesiumMovementEvent, target: T) => void;
    onPinchMove?: (movement: CesiumMovementEvent, target: T) => void;
    onPinchStart?: (movement: CesiumMovementEvent, target: T) => void;
    onRightClick?: (movement: CesiumMovementEvent, target: T) => void;
    onRightDown?: (movement: CesiumMovementEvent, target: T) => void;
    onRightUp?: (movement: CesiumMovementEvent, target: T) => void;
    onMouseEnter?: (movement: CesiumMovementEvent, target: T) => void;
    onMouseLeave?: (movement: CesiumMovementEvent, target: T) => void;
};

declare type EventTarget_2 = {
    id: Entity_2;
} & ({
    primitive: Primitive_2;
} | {
    primitive: Model_2;
    node: ModelNode;
} | {
    collection: BillboardCollection_2;
    primitive: Billboard_2;
} | {
    collection: LabelCollection_2;
    primitive: Label_2;
} | {
    collection: PointPrimitiveCollection_2;
    primitive: PointPrimitive_2;
} | {
    collection: PolylineCollection_2;
    primitive: Polyline_2;
});
export { EventTarget_2 as EventTarget }

export declare type EventType = keyof RootEventProps;

export declare const Fog: CesiumComponentType<Fog_2, FogCesiumProps>;

declare type FogCesiumProps = PickCesiumProps<Fog_2, typeof cesiumProps_20>;

export declare type FogProps = FogCesiumProps;

declare type FunctionKeys<T> = {
    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
}[keyof T];

export declare const Fxaa: CesiumComponentType<PostProcessStage_2 | PostProcessStageComposite_2, {} & {
enabled?: boolean | undefined;
selected?: any[] | undefined;
} & {
stages?: any[] | undefined;
}>;

export declare const GeoJsonDataSource: CesiumComponentType<GeoJsonDataSource_2, GeoJsonDataSourceProps>;

declare type GeoJsonDataSourceCesiumEvents = {
    onChange?: (GeoJsonDataSource: GeoJsonDataSource_2) => void;
    onError?: (GeoJsonDataSource: GeoJsonDataSource_2, error: any) => void;
    onLoading?: (GeoJsonDataSource: GeoJsonDataSource_2, isLoaded: boolean) => void;
};

declare type GeoJsonDataSourceCesiumProps = PickCesiumProps<GeoJsonDataSource_2, typeof cesiumProps_21>;

declare type GeoJsonDataSourceCesiumReadonlyProps = PickCesiumProps<Target_5, typeof cesiumReadonlyProps_6>;

declare type GeoJsonDataSourceOtherProps = EventProps<EventTarget_2> & {
    /** Calls when the Promise for loading data is fullfilled. */
    onLoad?: (GeoJsonDataSouce: GeoJsonDataSource_2) => void;
    data?: Parameters<InstanceType<typeof GeoJsonDataSource_2>["load"]>[0];
};

export declare type GeoJsonDataSourceProps = GeoJsonDataSourceCesiumProps & GeoJsonDataSourceCesiumReadonlyProps & GeoJsonDataSourceCesiumEvents & GeoJsonDataSourceOtherProps;

export declare const Globe: CesiumComponentType<Globe_2, GlobeProps>;

declare type GlobeCesiumEvents = {
    onImageryLayersUpdate?: () => void;
    onTerrainProviderChange?: (terrainProvider: TerrainProvider) => void;
    onTileLoadProgress?: (currentLoadQueueLength: number) => void;
};

declare type GlobeCesiumProps = PickCesiumProps<Globe_2, typeof cesiumProps_22>;

declare type GlobeOtherProps = {
    terrainProvider?: TerrainProvider | Promise<TerrainProvider>;
};

export declare type GlobeProps = GlobeCesiumProps & GlobeCesiumEvents & GlobeOtherProps;

export declare const GroundPolylinePrimitive: CesiumComponentType<GroundPolylinePrimitive_2, GroundPolylinePrimitiveProps>;

declare type GroundPolylinePrimitiveCesiumProps = PickCesiumProps<Target_6, typeof cesiumProps_23>;

declare type GroundPolylinePrimitiveCesiumReadonlyProps = PickCesiumProps<Target_6, typeof cesiumReadonlyProps_7>;

d