@webspatial/react-sdk 1.0.4 → 1.1.0

package/dist/default/index.d.ts

@@ -1,51 +1,117 @@
+import { SpatialSceneCreationOptions, SpatialSceneType, SpatialTapEvent as SpatialTapEvent$1, SpatialDragEvent as SpatialDragEvent$1, SpatialRotateEvent as SpatialRotateEvent$1, SpatialMagnifyEvent as SpatialMagnifyEvent$1, SpatializedElement, Point3D, SpatialObject, SpatialSession, SpatializedDynamic3DElement, Vec3, SpatialEntity, SpatialRotateEndEvent as SpatialRotateEndEvent$1, SpatialMagnifyEndEvent as SpatialMagnifyEndEvent$1, SpatialBoxGeometryOptions, SpatialUnlitMaterialOptions, SpatialSphereGeometryOptions, SpatialConeGeometryOptions, SpatialCylinderGeometryOptions, SpatialPlaneGeometryOptions } from '@webspatial/core-sdk';
+export { Point3D, Vec3 } from '@webspatial/core-sdk';
 import * as React$1 from 'react';
-import React__default, { ReactNode, CSSProperties, ElementType, ForwardedRef } from 'react';
-import { BackgroundMaterialType, CornerRadius, SpatialEntity, Vec3, SpatialSession, WindowContainerOptions as WindowContainerOptions$1 } from '@webspatial/core-sdk';
-import { ModelViewerElement } from '@google/model-viewer';
-import { WindowContainerOptions } from '@webspatial/core-sdk/';
-export { WindowContainerOptions } from '@webspatial/core-sdk/';
-
-type vecType = {
-    x: number;
-    y: number;
-    z: number;
-};
-type quatType = {
-    x: number;
-    y: number;
-    z: number;
-    w: number;
-};
-
-type spatialStyleDef = {
-    position: Partial<vecType>;
-    rotation: quatType;
-    scale: Partial<vecType>;
-    zIndex?: number;
-    material?: {
-        type: BackgroundMaterialType;
-    };
-    cornerRadius: number | CornerRadius;
-    visible?: boolean;
-};
-interface SpatialReactComponentProps {
-    allowScroll?: boolean;
-    scrollWithParent?: boolean;
-    spatialStyle?: Partial<spatialStyleDef>;
-    children?: ReactNode;
-    className?: string;
-    style?: CSSProperties | undefined;
-    component?: ElementType;
-    debugName?: string;
-    debugShowStandardInstance?: boolean;
+import React__default, { ElementType, ForwardedRef } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+declare function enableDebugTool(): void;
+
+declare function initScene(name: string, callback: (pre: SpatialSceneCreationOptions) => SpatialSceneCreationOptions, options?: {
+    type: SpatialSceneType;
+}): void | undefined;
+
+declare const SpatialID = "data-spatial-id";
+
+type SpatialEventProps<T extends SpatializedElementRef> = {
+    onSpatialTap?: (event: SpatialTapEvent<T>) => void;
+    onSpatialDragStart?: (event: SpatialDragStartEvent<T>) => void;
+    onSpatialDrag?: (event: SpatialDragEvent<T>) => void;
+    onSpatialDragEnd?: (event: SpatialDragEndEvent<T>) => void;
+    onSpatialRotateStart?: (event: SpatialRotateStartEvent<T>) => void;
+    onSpatialRotate?: (event: SpatialRotateEvent<T>) => void;
+    onSpatialRotateEnd?: (event: SpatialRotateEndEvent<T>) => void;
+    onSpatialMagnifyStart?: (event: SpatialMagnifyStartEvent<T>) => void;
+    onSpatialMagnify?: (event: SpatialMagnifyEvent<T>) => void;
+    onSpatialMagnifyEnd?: (event: SpatialMagnifyEndEvent<T>) => void;
+};
+interface StandardSpatializedContainerProps extends React__default.ComponentPropsWithoutRef<'div'> {
+    component: ElementType;
+    inStandardSpatializedContainer?: boolean;
+    [SpatialID]: string;
 }
-type SpatialReactComponentRef = ForwardedRef<HTMLDivElement>;
+type RealityProps = SpatialEventProps<SpatializedElementRef> & React__default.ComponentPropsWithRef<'div'>;
+type PortalSpatializedContainerProps<T extends SpatializedElementRef> = SpatialEventProps<T> & React__default.ComponentPropsWithoutRef<'div'> & {
+    component: ElementType;
+    spatializedContent: ElementType;
+    createSpatializedElement: () => Promise<SpatializedElement>;
+    getExtraSpatializedElementProperties?: (computedStyle: CSSStyleDeclaration) => Record<string, any>;
+    [SpatialID]: string;
+};
+type SpatializedContainerProps<T extends SpatializedElementRef> = Omit<StandardSpatializedContainerProps & PortalSpatializedContainerProps<T>, typeof SpatialID | 'onLoad' | 'onError'> & {
+    extraRefProps?: (domProxy: T) => Record<string, () => any>;
+};
+type Spatialized2DElementContainerProps<P extends ElementType> = SpatialEventProps<SpatializedElementRef> & React__default.ComponentPropsWithRef<'div'> & {
+    component: P;
+};
+type SpatializedStatic3DContainerProps = SpatialEventProps<SpatializedStatic3DElementRef> & Omit<React__default.ComponentPropsWithoutRef<'div'>, 'onLoad' | 'onError'> & {
+    src?: string;
+    onLoad?: (event: ModelLoadEvent) => void;
+    onError?: (event: ModelLoadEvent) => void;
+};
+type SpatializedElementRef<T extends HTMLElement = HTMLElement> = T;
+type SpatializedDivElementRef = SpatializedElementRef<HTMLDivElement>;
+type SpatializedStatic3DElementRef = SpatializedDivElementRef & {
+    currentSrc: string;
+    ready: Promise<ModelLoadEvent>;
+    entityTransform: DOMMatrix;
+};
+type CurrentTarget<T extends SpatializedElementRef> = {
+    currentTarget: T;
+};
+type SpatialTapEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialTapEvent$1 & CurrentTarget<T>;
+type SpatialDragStartEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialDragEvent$1 & CurrentTarget<T>;
+type SpatialDragEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialDragEvent$1 & CurrentTarget<T>;
+type SpatialDragEndEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialDragEvent$1 & CurrentTarget<T>;
+type SpatialRotateStartEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialRotateEvent$1 & CurrentTarget<T>;
+type SpatialRotateEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialRotateEvent$1 & CurrentTarget<T>;
+type SpatialRotateEndEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialRotateEvent$1 & CurrentTarget<T>;
+type SpatialMagnifyStartEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialMagnifyEvent$1 & CurrentTarget<T>;
+type SpatialMagnifyEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialMagnifyEvent$1 & CurrentTarget<T>;
+type SpatialMagnifyEndEvent<T extends SpatializedElementRef = SpatializedElementRef> = SpatialMagnifyEvent$1 & CurrentTarget<T>;
+type ModelSpatialTapEvent = SpatialTapEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialDragStartEvent = SpatialDragStartEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialDragEvent = SpatialDragEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialDragEndEvent = SpatialDragEndEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialRotateStartEvent = SpatialRotateStartEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialRotateEvent = SpatialRotateEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialRotateEndEvent = SpatialRotateEndEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialMagnifyEvent = SpatialMagnifyEvent<SpatializedStatic3DElementRef>;
+type ModelSpatialMagnifyEndEvent = SpatialMagnifyEndEvent<SpatializedStatic3DElementRef>;
+type ModelLoadEvent = CustomEvent & {
+    target: SpatializedStatic3DElementRef;
+};
+
+declare const SpatializedContainer: <T extends SpatializedElementRef>(props: SpatializedContainerProps<T> & {
+    ref?: ForwardedRef<SpatializedElementRef<T>>;
+}) => React.ReactElement | null;
+
+declare const Spatialized2DElementContainer: <P extends ElementType>(props: Spatialized2DElementContainerProps<P> & {
+    ref: ForwardedRef<SpatializedElementRef>;
+}) => React__default.ReactElement | null;
+
+declare const SpatializedStatic3DElementContainer: React$1.ForwardRefExoticComponent<{
+    onSpatialTap?: ((event: SpatialTapEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDragStart?: ((event: SpatialDragStartEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDrag?: ((event: SpatialDragEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDragEnd?: ((event: SpatialDragEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialRotateStart?: ((event: SpatialRotateStartEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialRotate?: ((event: SpatialRotateEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialRotateEnd?: ((event: SpatialRotateEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialMagnifyStart?: ((event: SpatialMagnifyStartEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialMagnify?: ((event: SpatialMagnifyEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialMagnifyEnd?: ((event: SpatialMagnifyEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+} & Omit<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onLoad" | "onError"> & {
+    src?: string;
+    onLoad?: (event: ModelLoadEvent) => void;
+    onError?: (event: ModelLoadEvent) => void;
+} & React$1.RefAttributes<SpatializedStatic3DElementRef>>;
+
+declare function withSpatialized2DElementContainer<P extends ElementType>(Component: P): P | React$1.ForwardRefExoticComponent<Omit<Spatialized2DElementContainerProps<P>, "ref"> & React$1.RefAttributes<HTMLElement>>;
 
-declare const SpatialReactComponent: React$1.ForwardRefExoticComponent<SpatialReactComponentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare function toSceneSpatial(point: Point3D, spatializedElement: SpatializedElementRef): DOMPoint;
+declare function toLocalSpace(point: Point3D, spatializedElement: SpatializedElementRef): DOMPoint;
 
-declare function withSpatial(Component: React__default.ElementType): any;
-declare const SpatialPrimitive: Record<string, typeof SpatialReactComponent>;
-declare const SpatialDiv: React__default.ForwardRefExoticComponent<SpatialReactComponentProps & React__default.RefAttributes<HTMLDivElement>>;
+declare function initPolyfill(): void;
 
 declare function withSpatialMonitor(El: React__default.ElementType): any;
 
@@ -54,141 +120,171 @@ type SpatialMonitorProps = {
 };
 declare const SpatialMonitor: React$1.ForwardRefExoticComponent<SpatialMonitorProps & React$1.RefAttributes<HTMLElement>>;
 
-/**
- * External-developers can call this function to sync the standardInstance layout to PortalInstance.
- *
- * Currently: notifyUpdateStandInstanceLayout is called when the document head changed
- * or when the monitored div changed (in both cases spatialDiv's layout may be changed, so we need to update the layout)
- */
-declare function notifyUpdateStandInstanceLayout(): void;
+declare class ResourceRegistry {
+    private resources;
+    add<T extends SpatialObject>(id: string, resource: Promise<T>): void;
+    remove(id: string): void;
+    removeAndDestroy(id: string): void;
+    get<T extends SpatialObject>(id: string): Promise<T>;
+    destroy(): void;
+}
+
+type RealityContextValue = {
+    session: SpatialSession;
+    reality: SpatializedDynamic3DElement;
+    resourceRegistry: ResourceRegistry;
+} | null;
+
+interface EntityRefShape {
+    convertFromEntityToEntity: (fromEntityId: string, toEntityId: string, position: Vec3) => Promise<Vec3>;
+    convertFromEntityToReality: (entityId: string, position: Vec3) => Promise<Vec3>;
+    convertFromRealityToEntity: (entityId: string, position: Vec3) => Promise<Vec3>;
+    id: string | undefined;
+    name: string | undefined;
+    entity: SpatialEntity | null;
+}
+declare class EntityRef implements EntityRefShape {
+    private _entity;
+    private _ctx;
+    constructor(entity?: SpatialEntity | null, ctx?: RealityContextValue | null);
+    updateEntity(entity?: SpatialEntity | null): void;
+    updateCtx(ctx?: RealityContextValue | null): void;
+    destroy(): void;
+    get entity(): SpatialEntity | null;
+    get id(): string | undefined;
+    get name(): string | undefined;
+    convertFromEntityToEntity(fromEntityId: string, toEntityId: string, position: Vec3): Promise<Vec3>;
+    convertFromEntityToReality(entityId: string, position: Vec3): Promise<Vec3>;
+    convertFromRealityToEntity(entityId: string, position: Vec3): Promise<Vec3>;
+}
 
-declare function parseCornerRadius(computedStyle: CSSStyleDeclaration): {
-    topLeading: number;
-    bottomLeading: number;
-    topTrailing: number;
-    bottomTrailing: number;
+type EntityProps = {
+    id?: string;
+    name?: string;
+    position?: Vec3;
+    rotation?: Vec3;
+    scale?: Vec3;
+};
+type allTarget<T extends EntityRefShape> = {
+    target: T;
+    currentTarget: T;
+};
+type SpatialTapEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialTapEvent$1 & allTarget<T>;
+type SpatialDragEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialDragEvent$1 & allTarget<T>;
+type SpatialRotateEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialRotateEvent$1 & allTarget<T>;
+type SpatialRotateEndEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialRotateEndEvent$1 & allTarget<T>;
+type SpatialMagnifyEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialMagnifyEvent$1 & allTarget<T>;
+type SpatialMagnifyEndEntityEvent<T extends EntityRefShape = EntityRefShape> = SpatialMagnifyEndEvent$1 & allTarget<T>;
+type EntityEventHandler = {
+    onSpatialTap?: (event: SpatialTapEntityEvent) => void;
+    onSpatialDragStart?: (event: SpatialDragEntityEvent) => void;
+    onSpatialDrag?: (event: SpatialDragEntityEvent) => void;
+    onSpatialDragEnd?: (event: SpatialDragEntityEvent) => void;
+    onSpatialRotateStart?: (event: SpatialRotateEntityEvent) => void;
+    onSpatialRotate?: (event: SpatialRotateEntityEvent) => void;
+    onSpatialRotateEnd?: (event: SpatialRotateEndEntityEvent) => void;
+    onSpatialMagnifyStart?: (event: SpatialMagnifyEntityEvent) => void;
+    onSpatialMagnify?: (event: SpatialMagnifyEntityEvent) => void;
+    onSpatialMagnifyEnd?: (event: SpatialMagnifyEndEntityEvent) => void;
+};
+declare const eventMap: {
+    readonly onSpatialTap: "spatialtap";
+    readonly onSpatialDragStart: "spatialdragstart";
+    readonly onSpatialDrag: "spatialdrag";
+    readonly onSpatialDragEnd: "spatialdragend";
+    readonly onSpatialRotateStart: "spatialrotatestart";
+    readonly onSpatialRotate: "spatialrotate";
+    readonly onSpatialRotateEnd: "spatialrotateend";
+    readonly onSpatialMagnifyStart: "spatialmagnifystart";
+    readonly onSpatialMagnify: "spatialmagnify";
+    readonly onSpatialMagnifyEnd: "spatialmagnifyend";
 };
 
-declare const CSSSpatialComponent: React$1.ForwardRefExoticComponent<SpatialReactComponentProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const Entity: React__default.ForwardRefExoticComponent<EntityProps & EntityEventHandler & {
+    children?: React__default.ReactNode;
+} & React__default.RefAttributes<EntityRefShape>>;
 
-declare function withCSSSpatial(Component: React__default.ElementType): any;
-declare const CSSSpatialPrimitive: Record<string, typeof CSSSpatialComponent>;
-declare const CSSSpatialDiv: React__default.ForwardRefExoticComponent<SpatialReactComponentProps & React__default.RefAttributes<HTMLDivElement>>;
+declare const BoxEntity: React__default.ForwardRefExoticComponent<EntityProps & EntityEventHandler & {
+    children?: React__default.ReactNode;
+    materials?: string[];
+} & SpatialBoxGeometryOptions & React__default.RefAttributes<EntityRefShape>>;
 
-interface SpatialViewProps extends React__default.HTMLAttributes<HTMLDivElement> {
-    onViewLoad?: (viewEnt: SpatialEntity) => void;
-    onViewUnload?: () => void;
-}
-interface SpatialViewRef extends HTMLDivElement {
-    getViewEntity: () => Promise<SpatialEntity | null>;
-}
-/**
- * [Experimental] Allows embedding 3D dynamic content within the webpage
- */
-declare const SpatialView: React__default.ForwardRefExoticComponent<SpatialViewProps & React__default.RefAttributes<SpatialViewRef>>;
-
-type PartialSpatialTransformType = {
-    position?: Partial<vecType>;
-    rotation?: Partial<quatType>;
-    scale?: Partial<vecType>;
-};
-interface ModelEvent {
-    target: ModelElement;
-}
-interface ModelDragEvent extends ModelEvent {
-    eventType: 'dragstart' | 'dragend' | 'drag';
-    translation3D: Vec3;
-    startLocation3D: Vec3;
-}
-interface Model3DProps {
-    spatialTransform?: PartialSpatialTransformType;
-    modelUrl: string;
-    visible: boolean;
-    contentMode?: 'fill' | 'fit';
-    resizable?: boolean;
-    aspectRatio?: number;
-    className?: string;
-    style?: CSSProperties | undefined;
-    children?: React.ReactNode;
-    onLoad?: (event: ModelEvent) => void;
-    onDragStart?: (dragEvent: ModelDragEvent) => void;
-    onDrag?: (dragEvent: ModelDragEvent) => void;
-    onDragEnd?: (dragEvent: ModelDragEvent) => void;
-    onTap?: (event: ModelEvent) => void;
-    onDoubleTap?: (event: ModelEvent) => void;
-    onLongPress?: (event: ModelEvent) => void;
-}
-interface ModelElement extends HTMLDivElement {
-    ready: boolean;
-    currentSrc: string;
-}
-type ModelElementRef = ForwardedRef<ModelElement>;
-type CSSModel3DProps = Omit<Model3DProps, 'spatialTransform' | 'visible'>;
+type Props$2 = {
+    children?: React__default.ReactNode;
+    id: string;
+} & SpatialUnlitMaterialOptions;
+declare const UnlitMaterial: React__default.FC<Props$2>;
 
-declare const Model3D: React$1.ForwardRefExoticComponent<Model3DProps & React$1.RefAttributes<ModelElement>>;
+declare const SphereEntity: React__default.ForwardRefExoticComponent<EntityProps & EntityEventHandler & {
+    children?: React__default.ReactNode;
+    materials?: string[];
+} & SpatialSphereGeometryOptions & React__default.RefAttributes<EntityRefShape>>;
 
-declare const CSSModel3D: React$1.ForwardRefExoticComponent<CSSModel3DProps & React$1.RefAttributes<ModelElement>>;
+declare const ConeEntity: React__default.ForwardRefExoticComponent<EntityProps & EntityEventHandler & {
+    children?: React__default.ReactNode;
+    materials?: string[];
+} & SpatialConeGeometryOptions & React__default.RefAttributes<EntityRefShape>>;
 
-declare global {
-    namespace JSX {
-        interface IntrinsicElements {
-            'model-viewer': ModelViewerElement | {
-                ref: any;
-            };
-        }
-    }
-}
-type ModelChildren = React__default.ReactElement<{
-    type: string;
-    src: string;
-}> | [React__default.ReactElement<{
-    type: string;
-    src: string;
-}>, React__default.ReactElement] | React__default.ReactElement<{
-    type: string;
-    src: string;
-}>[];
-interface ModelProps {
-    className?: string;
-    style?: CSSProperties | undefined;
-    children: ModelChildren;
-    onLoad?: (event: ModelEvent) => void;
-    contentMode?: 'fill' | 'fit';
-    resizable?: boolean;
-    aspectRatio?: number;
-    onDragStart?: (dragEvent: ModelDragEvent) => void;
-    onDrag?: (dragEvent: ModelDragEvent) => void;
-    onDragEnd?: (dragEvent: ModelDragEvent) => void;
-    onTap?: (event: ModelEvent) => void;
-    onDoubleTap?: (event: ModelEvent) => void;
-    onLongPress?: (event: ModelEvent) => void;
-    poster?: string;
-}
-declare const Model: React__default.ForwardRefExoticComponent<ModelProps & React__default.RefAttributes<ModelElement>>;
+declare const CylinderEntity: React__default.ForwardRefExoticComponent<EntityProps & EntityEventHandler & {
+    children?: React__default.ReactNode;
+    materials?: string[];
+} & SpatialCylinderGeometryOptions & React__default.RefAttributes<EntityRefShape>>;
 
-/** @hidden */
-declare function getSession(): SpatialSession | null;
+declare const PlaneEntity: React__default.ForwardRefExoticComponent<EntityProps & EntityEventHandler & {
+    children?: React__default.ReactNode;
+    materials?: string[];
+} & SpatialPlaneGeometryOptions & React__default.RefAttributes<EntityRefShape>>;
 
-declare function enableDebugTool(): void;
+type Props$1 = {
+    children?: React__default.ReactNode;
+};
+declare const SceneGraph: React__default.FC<Props$1>;
 
-declare const defaultSceneConfig: WindowContainerOptions;
-declare class XRApp {
-    private static instance;
-    static getInstance(): XRApp;
-    handleATag(event: MouseEvent): true | undefined;
-    init(): void;
-    deinit(): void;
-    private configMap;
-    private getConfig;
-    show(window: Window, cfg: WindowContainerOptions): Promise<void>;
-    open: (url?: string, target?: string, features?: string) => Window | null;
-    initScene(name: string, callback: (pre: WindowContainerOptions) => WindowContainerOptions): void;
-}
+type Props = {
+    children?: React__default.ReactNode;
+    id: string;
+    src: string;
+    onLoad?: () => void;
+    onError?: (error: any) => void;
+};
+declare const ModelAsset: React__default.FC<Props>;
+
+declare const ModelEntity: React__default.ForwardRefExoticComponent<EntityProps & {
+    model: string;
+} & EntityEventHandler & {
+    children?: React__default.ReactNode;
+} & React__default.RefAttributes<EntityRefShape>>;
 
-declare function initScene(name: string, callback: (pre: WindowContainerOptions$1) => WindowContainerOptions$1): void;
+declare const Reality: React__default.ForwardRefExoticComponent<Omit<RealityProps, "ref"> & React__default.RefAttributes<HTMLElement>>;
+
+type ModelProps = SpatializedStatic3DContainerProps & {
+    'enable-xr'?: boolean;
+};
+type ModelRef = SpatializedStatic3DElementRef;
+declare const Model: React$1.ForwardRefExoticComponent<Omit<{
+    onSpatialTap?: ((event: SpatialTapEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDragStart?: ((event: SpatialDragStartEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDrag?: ((event: SpatialDragEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialDragEnd?: ((event: SpatialDragEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialRotateStart?: ((event: SpatialRotateStartEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialRotate?: ((event: SpatialRotateEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialRotateEnd?: ((event: SpatialRotateEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialMagnifyStart?: ((event: SpatialMagnifyStartEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialMagnify?: ((event: SpatialMagnifyEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+    onSpatialMagnifyEnd?: ((event: SpatialMagnifyEndEvent<SpatializedStatic3DElementRef>) => void) | undefined;
+} & Omit<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "onLoad" | "onError"> & {
+    src?: string;
+    onLoad?: (event: ModelLoadEvent) => void;
+    onError?: (event: ModelLoadEvent) => void;
+} & {
+    'enable-xr'?: boolean;
+} & React$1.RefAttributes<SpatializedStatic3DElementRef>, "ref"> & React$1.RefAttributes<any>>;
 
-declare function spatialPolyfill(): void;
+declare const SSRProvider: ({ isSSR: initialIsSSR, children, }: {
+    isSSR?: boolean;
+    children: React__default.ReactNode;
+}) => react_jsx_runtime.JSX.Element;
 
 declare const version: string;
 
-export { CSSModel3D, CSSSpatialDiv, CSSSpatialPrimitive, Model, Model3D, type Model3DProps, type ModelDragEvent, type ModelElement, type ModelElementRef, type ModelEvent, type ModelProps, SpatialDiv, type SpatialReactComponentProps as SpatialDivProps, type SpatialReactComponentRef as SpatialDivRef, SpatialMonitor, SpatialPrimitive, type SpatialReactComponentProps, type SpatialReactComponentRef, SpatialView, type SpatialViewRef, XRApp, defaultSceneConfig, enableDebugTool, getSession, initScene, notifyUpdateStandInstanceLayout, parseCornerRadius, spatialPolyfill, version, withCSSSpatial, withSpatial, withSpatialMonitor };
+export { BoxEntity, ConeEntity, CylinderEntity, Entity, type EntityEventHandler, type EntityProps, EntityRef, Model, ModelAsset, ModelEntity, type ModelLoadEvent, type ModelProps, type ModelRef, type ModelSpatialDragEndEvent, type ModelSpatialDragEvent, type ModelSpatialDragStartEvent, type ModelSpatialMagnifyEndEvent, type ModelSpatialMagnifyEvent, type ModelSpatialRotateEndEvent, type ModelSpatialRotateEvent, type ModelSpatialRotateStartEvent, type ModelSpatialTapEvent, PlaneEntity, Reality, SSRProvider, SceneGraph, type SpatialDragEndEvent, type SpatialDragEntityEvent, type SpatialDragEvent, type SpatialDragStartEvent, type SpatialMagnifyEndEntityEvent, type SpatialMagnifyEndEvent, type SpatialMagnifyEntityEvent, type SpatialMagnifyEvent, type SpatialMagnifyStartEvent, SpatialMonitor, type SpatialRotateEndEntityEvent, type SpatialRotateEndEvent, type SpatialRotateEntityEvent, type SpatialRotateEvent, type SpatialRotateStartEvent, type SpatialTapEntityEvent, type SpatialTapEvent, Spatialized2DElementContainer, type Spatialized2DElementContainerProps, SpatializedContainer, type SpatializedElementRef, type SpatializedStatic3DContainerProps, SpatializedStatic3DElementContainer, type SpatializedStatic3DElementRef, SphereEntity, UnlitMaterial, enableDebugTool, eventMap, initPolyfill, initScene, toLocalSpace, toSceneSpatial, version, withSpatialMonitor, withSpatialized2DElementContainer };