// WaveStudio Monaco IntelliSense — generated from the canonical public contract.
// Do NOT edit manually. Run: npm run generate-wave-studio-authoring-interface

declare interface WaveStudioWorldPositionTarget {
  getWorldPosition(): Vector3Like;
}

type AabbFaceCenterDirection = Direction.Left | Direction.Right | Direction.Up | Direction.Down | Direction.Forward | Direction.Backward;

interface Action {

  canHold?: boolean;

  category: ActionCategory;

  defaultSensitivity?: number;

  description?: string;

  name: string;

  valueType: ActionValueType;

}

interface ActionBindingInfo {

  readonly actionName: string;

  readonly isOverride: boolean;

  readonly priority: number;

  readonly profileId?: string;

  readonly schemaName?: ControlSchemaName;

  readonly source: BindingSource;

  readonly triggers: readonly ActionTriggerConfig[];

  readonly value?: BindingValue;

}

interface ActionBindingsInfo {

  readonly actionName: string;

  readonly bindings: readonly ActionBindingInfo[];

  readonly profileId: string;

}

type ActionCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: ActionCallbackContext<TOwner>) => void;

interface ActionCallbackContext<TOwner extends WaveEntity = WaveEntity> {

  data: ActionEventData;

  owner: TOwner;

}

interface ActionCallbackOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  name?: string;

  once?: boolean;

  priority?: number;

}

declare enum ActionCategory {

  Camera = "camera",

  Combat = "combat",

  Custom = "custom",

  Flight = "flight",

  Interaction = "interaction",

  Movement = "movement",

  UI = "ui",

  Vehicle = "vehicle",

}

interface ActionEventData {

  action: Action;

  entityId?: number;

  holdDurationMs?: number;

  holdTicks?: number;

  phase: InputPhase;

  sequenceNumber: number;

  targetEntityId?: number;

  timestamp: number;

  value: ActionValue;

}

interface ActionMapBinding {

  readonly actionName: string;

  readonly id?: string;

  readonly modifiers?: readonly InputModifier[];

  readonly priority?: number;

  readonly source: BindingSource;

  readonly triggers?: readonly ActionTriggerConfig[];

  readonly value?: BindingValue;

}

interface ActionScheme {

  onBrake?: "decelerate" | "reverse" | "none";

  onCrouch: "modifier" | "toggle" | "holdToCrouch" | "none";

  onJump: "impulse" | "teleport" | "none";

  onLook: "pan" | "orbit" | "freelook" | "turret" | "custom";

  onMove: "translate" | "strafe" | "fly" | "swim" | "steer" | "spectator" | "custom";

  onSprint: "modifier" | "toggle" | "holdToRun" | "none";

  onSteer?: "yaw" | "bankAndYaw" | "none";

  onThrottle?: "accelerate" | "none";

}

interface ActionTriggerConfig {

  doubleTapTime?: number;

  holdTime?: number;

  pulseInterval?: number;

  tapTime?: number;

  threshold?: number;

  type: ActionTriggerType;

}

declare enum ActionTriggerType {

  Changed = 7,

  DoubleTap = 6,

  Down = 0,

  Held = 2,

  HoldStart = 4,

  Pulse = 5,

  Tap = 3,

  Up = 1,

}

type ActionValue = boolean | number | Vector2 | Vector3 | SerializableVector2 | SerializableVector3;

declare enum ActionValueType {

  Axis1D = 1,

  Axis2D = 2,

  Axis3D = 3,

  Bool = 0,

}

declare class ActivePhysicsHumanoidEquipmentMountBuilder {

  collideWithForeignRigs(): this;

  collideWithOwnerRig(): this;

  ignoreForeignRigs(): this;

  ignoreOwnerRig(): this;

  move(direction: DirectionInput, distance: number): this;

  onBody(entityId: ActivePhysicsHumanoidEntityId): this;

  onLeftHand(): this;

  onRightHand(): this;

  rotate(axis: DirectionInput, degrees: number): this;

  scaledBy(scale: number): this;

  useModel(model: string): this;

  withAngularDamping(value: number): this;

  withBoxCollider(): this;

  withCapsuleCollider(): this;

  withCylinderCollider(): this;

  withFriction(value: number): this;

  withLinearDamping(value: number): this;

  withMass(mass: number): this;

  withRestitution(value: number): this;

  withSphereCollider(): this;

}

type ActivePhysicsHumanoidEquipmentMountConfigurator = (mount: ActivePhysicsHumanoidEquipmentMountBuilder) => void | ActivePhysicsHumanoidEquipmentMountBuilder;

type AdoptedPartRigidBodySuspendState = { wasEnabled: boolean; }

interface AdoptPartOptions {

  readonly includeInPhysics?: boolean;

  readonly materialIsolation?: PartMaterialIsolationMode;

  readonly partName?: string;

}

interface AdoptPartsOptions {

  readonly includeInPhysics?: boolean;

  readonly materialIsolation?: PartMaterialIsolationMode;

}

interface AmbientState {

  color: number;

  intensity: number;

}

interface AnchorMarkerOptions {

  duration?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  color?: unknown | string | number;

  fontSize?: number;

  labelOffset3D?: Vector3 | Vector3Like;

  labelOffset3DSpace?: "world" | "local";

  size?: number;

}

type AnimationAssetValue = { readonly kind: "metadataClipTemplate"; readonly template: CompiledMetadataAnimationTemplate; } | { readonly kind: "poseTemplate"; readonly pose: WaveModelRigPoseSnapshotMetadata; } | { readonly kind: "modelEmbeddedTemplate"; readonly model: AnimationModelDependencyFacts; readonly descriptor: ModelEmbeddedAnimationDescriptor; readonly selector: GltfClipSelector; } | { readonly kind: "vatTemplate"; readonly texture: unknown; readonly ranges: readonly VATAnimationRange[]; readonly layout: VertexAnimationAssetLayout; readonly facts: VatTemplateFacts; } | { readonly kind: "proceduralTemplate"; readonly compiledPlan: CompiledProceduralAnimationTemplate; } | { readonly kind: "gltfClipTemplate"; readonly channels: readonly GltfClipChannelTemplate[]; readonly descriptor: ModelEmbeddedAnimationDescriptor; readonly facts: GltfClipTemplateFacts; }

type AnimationBindingValue = MetadataClipBindingValue | PoseBindingValue | ModelEmbeddedClipBindingValue | VatBindingValue | ProceduralAnimationBindingValue | GltfClipBindingValue;

declare class AnimationEvent {

  constructor(data: AnimationEventData);

  readonly at: WaveModelTimeSpanMetadata;

  readonly atMilliseconds: number;

  readonly atSeconds: number;

  readonly atTicks: number;

  readonly channel?: WaveEventChannel;

  readonly event: WaveEventDefinitionMetadata;

  readonly id?: string;

  readonly name: string;

  readonly payload?: WaveModelSerializableValue;

  readonly time: number;

}

interface AnimationEventData {

  readonly at: WaveModelTimeSpanMetadata;

  readonly atMilliseconds: number;

  readonly atSeconds: number;

  readonly atTicks: number;

  readonly channel?: WaveEventChannel;

  readonly event: WaveEventDefinitionMetadata;

  readonly id?: string;

  readonly name: string;

  readonly payload?: WaveModelSerializableValue;

  readonly time: number;

}

interface AnimationModelDependencyFacts {

  readonly modelContentKey: AssetContentKey;

  readonly selectedMeshId?: string;

  readonly topologySignature: string;

}

declare enum AnimationPlayState {

  Paused = "paused",

  Playing = "playing",

  Stopped = "stopped",

}

type AnimationSceneTemplateValue = AnimationBindingValue;

declare enum AnimationType {

  PartPose = "partPose",

  Procedural = "procedural",

  TransformSnapshot = "transformSnapshot",

  VAT = "vat",

}

type AnimatorStateChangeCallback = (newState: AnimationPlayState, previousState: AnimationPlayState) => void;

interface AnnulusSpawnOpts {

  height?: NumLike;

  innerRadius: NumLike;

  offset?: Partial<Vector3Like>;

  outerRadius: NumLike;

}

type AnyWaveObject = WaveSpatial3DObject | WaveSpatial2DObject;

type AppliedPreset<TPreset, TTerminal extends "apply" | "toRecipe" = "apply"> = TPreset extends (...args: infer TArgs) => infer TBuilder ? TTerminal extends "apply" ? TBuilder extends { apply(): infer TResult; } ? (...args: TArgs) => TResult : never : TBuilder extends { toRecipe(): infer TResult; } ? (...args: TArgs) => TResult : never : never;

interface ApplyTransformIntentOptions {

  readonly directionalScaleLocalBounds?: DirectionalScaleLocalBounds | null;

  readonly physicsMotion?: TransformPhysicsMotionMode;

}

interface ApplyTransformSnapshotOptions {

  readonly notifyDependents?: boolean;

  readonly physicsMotion?: TransformPhysicsMotionMode;

  readonly preserveLocalScale?: boolean;

}

type AreaLightEmissionTextureInput = string;

interface AreaLightEmissionTextureOptions {

  preprocessed?: boolean;

}

declare const ASSET_FAMILIES: readonly ["model", "material", "texture", "animation", "audio", "video", "font", "data"];

declare const ASSET_ISOLATION_MODES: readonly ["shared", "copyOnWrite", "private"];

declare class AssetArena {

  constructor(options: AssetArenaOptions);

  acquire<F extends AssetFamily, TValue = unknown>(id: AssetIdentity<F>, label?: string): AssetHandle<F, TValue>;

  acquireExact<F extends AssetFamily, TValue = unknown>(id: AssetIdentity<F>, key: AssetContentKey, label?: string): AssetHandle<F, TValue>;

  get active(): boolean;

  get activeHandleCount(): number;

  get activeTicketCount(): number;

  createTicket(label: string): AssetArenaTicket;

  get generation(): number;

  readonly kind: AssetArenaKind;

  readonly parent: AssetArena | null;

  patchCatalog(patch: AssetArenaCatalogPatch): void;

  preflightCatalog(entries: readonly AssetArenaCatalogEntry[], preparedFamilies?: ReadonlyMap<AssetContentKey, AssetFamily>): void;

  replaceCatalog(entries: readonly AssetArenaCatalogEntry[]): void;

  resolve(id: AssetIdentity): AssetArenaCatalogEntry | null;

  resolveLocal(id: AssetIdentity): AssetArenaCatalogEntry | null;

  retire(): void;

  trackFiniteBinding(label: string, releaseOwned: () => void): { release(): void; }

}

interface AssetArenaCatalogEntry<F extends AssetFamily = AssetFamily> {

  readonly id: AssetIdentity<F>;

  readonly key: AssetContentKey;

}

interface AssetArenaCatalogPatch {

  readonly removals?: readonly AssetIdentity[];

  readonly upserts: readonly AssetArenaCatalogEntry[];

}

type AssetArenaKind = "engine" | "scene" | "setup" | "main";

interface AssetArenaOptions {

  readonly beforeRetire?: () => void;

  readonly generation?: number;

  readonly kind: AssetArenaKind;

  readonly onCatalogMutation?: (kind: "replace" | "patch", upsertCount: number, removalCount: number) => void;

  readonly onCatalogRetirementError?: (error: unknown) => void;

  readonly onLeakedHandle?: (arena: AssetArena, label: string) => void;

  readonly onRetire?: (arena: AssetArena) => void;

  readonly parent?: AssetArena;

  readonly store: AssetStore;

}

declare class AssetArenaTicket {

  constructor(_arena: AssetArena, label: string, _generation: number);

  close(): void;

  isCurrent(): boolean;

  readonly label: string;

  requireCurrent(): void;

  get signal(): AbortSignal;

}

type AssetCapabilityId = string;

type AssetCatalog = Readonly<Record<string, Readonly<Record<string, string>>>>;

interface AssetConsumerBindingSnapshot<F extends AssetFamily = AssetFamily> {

  readonly intent?: SerializableDataValue;

  readonly resolvedRef: ExactAssetRef<F>;

  readonly source: AssetConsumerSourceSnapshot<F>;

}

type AssetConsumerSourceSnapshot<F extends AssetFamily = AssetFamily> = { readonly kind: "followCurrent"; readonly identity: AssetIdentity<F>; } | { readonly kind: "exact"; readonly ref: ExactAssetRef<F>; }

type AssetContentKey = string & { readonly [assetContentKeyBrand]: true; }

declare const assetContentKeyBrand: unique symbol;

interface AssetDeclarationLookup {

  getSerialDeclaration(ref: ExactAssetRef): SerializedAssetDeclaration | null;

  resolveCurrentRef(ref: AssetRef): ExactAssetRef | null;

}

interface AssetDefinition<F extends AssetFamily = AssetFamily> {

  readonly dependencies: readonly AssetRef[];

  readonly descriptor: AssetDescriptor<F>;

  readonly recipe: SerializableAssetRecipe;

}

interface AssetDescriptor<F extends AssetFamily = AssetFamily> {

  readonly capabilities: readonly AssetCapabilityId[];

  readonly identity: AssetIdentity<F>;

  readonly kind: AssetKindId;

  readonly provenance: AssetProvenance;

  readonly representation?: AssetRepresentationId;

  readonly role?: AssetRoleId;

  readonly sourceFormat?: AssetFormatId;

}

interface AssetDriver<F extends AssetFamily = AssetFamily, TValue = unknown> {

  readonly compilerVersion: string;

  readonly family: F;

  readonly kinds: readonly AssetKindId[];

  readonly needsSourceForPrepare: boolean;

  normalizeDefinition(definition: AssetDefinition): NormalizedAssetBody;

  normalizeSource(request: AssetLoadRequest, source: AssetSourceResult<AssetFamily, AssetLoadedSource>): NormalizedAssetBody;

  prepare(spec: ResolvedAssetSpec, context: AssetPrepareContext): PreparedAsset<TValue> | Promise<PreparedAsset<TValue>>;

  resolveDependencies?(normalized: NormalizedAssetBody, dependencyKeys: readonly AssetContentKey[]): ResolvedAssetDependencyShape;

}

type AssetFamily = (typeof ASSET_FAMILIES)[number];

type AssetFetchBytes = (locator: string, signal?: AbortSignal, onProgress?: (progress: AssetLoadProgress) => void) => Promise<Uint8Array>;

type AssetFormatId = string;

interface AssetHandle<F extends AssetFamily = AssetFamily, TValue = unknown> {

  readonly family: F;

  readonly id: AssetIdentity<F>;

  readonly key: AssetContentKey;

  release(): void;

  readonly value: TValue;

}

interface AssetIdentity<F extends AssetFamily = AssetFamily> {

  readonly family: F;

  readonly id: string;

}

type AssetIdentityKey = string & { readonly [assetIdentityKeyBrand]: true; }

declare const assetIdentityKeyBrand: unique symbol;

type AssetIsolationMode = (typeof ASSET_ISOLATION_MODES)[number];

type AssetKindId = string;

interface AssetLoadedSource {

  readonly bytes: Uint8Array;

  readonly contentHash: string;

  readonly decoded?: SerializableDataValue;

  readonly decodeOptions?: SerializableDataValue;

  readonly decoderVersion: string;

  readonly format: AssetFormatId;

  readonly kind: AssetLoadedSourceKind;

  readonly locator: string;

  readonly modelSourceBundle?: ModelSourceBundle;

  takeBytes(): Uint8Array;

  verifyIntegrity(): void;

}

type AssetLoadedSourceKind = "bytes" | "text" | "json";

declare class AssetLoader {

  constructor(options?: AssetLoaderOptions);

  close(): void;

  diagnostics(): AssetLoaderDiagnostics;

  load<F extends AssetFamily>(request: AssetLoadRequest<F>): Promise<AssetSourceResult<F, AssetLoadedSource>>;

}

interface AssetLoaderDiagnostics {

  readonly sourceByteHashCount: number;

  readonly sourceCacheBytes: number;

  readonly sourceCacheEntryCount: number;

  readonly sourceCacheHitCount: number;

  readonly sourceLoadCount: number;

}

interface AssetLoaderOptions {

  readonly fetch?: typeof globalThis.fetch;

  readonly fetchBytes?: AssetFetchBytes;

  readonly sourceCache?: AssetSourceCache;

}

interface AssetLoadProgress {

  readonly loadedBytes: number;

  readonly totalBytes?: number;

}

interface AssetLoadRequest<F extends AssetFamily = AssetFamily> {

  readonly declaredDependencies?: readonly AssetRef[];

  readonly decodeOptions?: SerializableDataValue;

  readonly decoderVersion: string;

  readonly descriptor: AssetDescriptor<F>;

  readonly expectedByteSize?: number;

  readonly onProgress?: (progress: AssetLoadProgress) => void;

  readonly representation?: AssetRepresentationId;

  readonly signal?: AbortSignal;

  readonly source: AssetSourceLocator;

  readonly sourceFormat?: AssetFormatId;

}

type AssetPlanPriority = "critical" | "streaming";

interface AssetPrepareContext {

  readonly dependencies: readonly AssetResolvedDependency[];

  readonly signal: AbortSignal;

  readonly source?: AssetPrepareSource;

}

interface AssetPrepareSource {

  readonly canonicalSource: AssetLoadedSource;

  readonly descriptor: AssetDescriptor;

}

interface AssetProvenance {

  readonly contentHash?: string;

  readonly kind: AssetProvenanceKind;

  readonly providerId?: string;

  readonly sourceId?: string;

}

type AssetProvenanceKind = "warehouse" | "project" | "generated" | "plugin" | "remote" | "external";

interface AssetRef<F extends AssetFamily = AssetFamily> {

  readonly identity: AssetIdentity<F>;

  readonly revision?: AssetRevisionId;

}

type AssetRepresentationId = string;

interface AssetResolvedDependency {

  readonly id: AssetIdentity;

  readonly key: AssetContentKey;

  readonly value: unknown;

}

type AssetResourceDisposer = () => void;

declare class AssetResourceOwner {

  add(label: string, disposer: AssetResourceDisposer): void;

  adopt(other: AssetResourceOwner): void;

  dispose(): void;

  get disposed(): boolean;

  get transferable(): boolean;

}

interface AssetRevisionChange<F extends AssetFamily = AssetFamily> {

  readonly identity: AssetIdentity<F>;

  readonly nextRef: ExactAssetRef<F>;

  readonly previousRef: ExactAssetRef<F> | null;

}

type AssetRevisionId = OpaqueString<typeof assetRevisionIdBrand>;

declare const assetRevisionIdBrand: unique symbol;

type AssetRevisionKey = OpaqueString<typeof assetRevisionKeyBrand>;

declare const assetRevisionKeyBrand: unique symbol;

type AssetRoleId = string;

declare class AssetRuntime {

  constructor(options: AssetRuntimeOptions);

  assertNoSceneNativeRecords(): void;

  compileDeltaPlan(delta: SceneAssetPlanDeltaInput, arena: AssetArena, previous: SceneAssetPlanState): SceneAssetDeltaPlan;

  compilePlan(inputs: readonly SceneAssetPlanEntryInput[], arena: AssetArena, previous?: SceneAssetPlanState): SceneAssetPlan;

  createMainArena(setup: AssetArena, generation: number): AssetArena;

  createSceneArena(): AssetArena;

  createSetupArena(scene: AssetArena): AssetArena;

  diagnostics(): AssetRuntimeCounters;

  dispose(): void;

  readonly engineArena: AssetArena;

  expectedDefinitionContentKey(definition: AssetDefinition, arena: AssetArena): AssetContentKey;

  readonly hasDriver: (family: AssetFamily, kind: AssetKindId) => boolean;

  preparePlan(plan: SceneAssetPlan, arena: AssetArena, ticket?: AssetArenaTicket): Promise<PreparedAssetPlan>;

  preparePlanSync(plan: SceneAssetPlan, arena: AssetArena, ticket?: AssetArenaTicket): PreparedAssetPlan;

  readExact(key: AssetContentKey): AssetStoreView | null;

  requireDriver(family: AssetFamily, kind: string): AssetDriver<AssetFamily, unknown>;

}

interface AssetRuntimeCounters {

  readonly activeAnimationRecordCount: number;

  readonly activeAudioRecordCount: number;

  readonly activeHandleCount: number;

  readonly activeMaterialRecordCount: number;

  readonly activeModelRecordCount: number;

  readonly activeRecordCount: number;

  readonly activeRetainCount: number;

  readonly activeTextureRecordCount: number;

  readonly activeTicketCount: number;

  readonly activeVideoRecordCount: number;

  readonly catalogPatchCount: number;

  readonly catalogPatchRemovalCount: number;

  readonly catalogPatchUpsertCount: number;

  readonly catalogReplaceCount: number;

  readonly catalogReplaceEntryCount: number;

  readonly contentKeyCount: number;

  readonly deltaPlanCompileCount: number;

  readonly deltaPlanCompileEntryCount: number;

  readonly driverPrepareCount: number;

  readonly normalizeCount: number;

  readonly planCompileCount: number;

  readonly planCompileEntryCount: number;

  readonly planPrepareSyncCount: number;

  readonly planPrepareSyncEntryCount: number;

  readonly recentCatalogPatchUpsertCounts: readonly number[];

  readonly recentCatalogReplaceEntryCounts: readonly number[];

  readonly recentDeltaPlanCompileEntryCounts: readonly number[];

  readonly recentPlanCompileEntryCounts: readonly number[];

  readonly recentPlanPrepareSyncEntryCounts: readonly number[];

  readonly sourceByteHashCount: number;

  readonly sourceCacheBytes: number;

  readonly sourceCacheEntryCount: number;

  readonly sourceCacheHitCount: number;

  readonly sourceLoadCount: number;

  readonly storeInsertCount: number;

  readonly storeReuseCount: number;

}

interface AssetRuntimeOptions {

  readonly onCleanupError?: ((key: AssetContentKey, error: unknown) => void) | undefined;

  readonly drivers: readonly AssetDriver<AssetFamily, unknown>[];

  readonly loader?: AssetLoader;

  readonly onLeakedHandle?: AssetArenaOptions["onLeakedHandle"];

}

interface AssetSourceCache {

  close(): void;

  delete(key: string): void;

  readonly entryCount: number;

  get(key: string): Uint8Array | null;

  getContentHash(key: string): string | null;

  readonly maximumBytes: number;

  put(key: string, bytes: Uint8Array, contentHash?: string): void;

  setContentHash(key: string, contentHash: string): void;

  readonly totalBytes: number;

}

interface AssetSourceLocator {

  readonly locator: string;

  readonly validator?: string;

}

interface AssetSourceReference<F extends AssetFamily = AssetFamily> {

  readonly contentHash?: string;

  readonly format?: AssetFormatId;

  readonly ref: AssetRef<F>;

  readonly uri: string;

  readonly usages: readonly string[];

}

interface AssetSourceResult<F extends AssetFamily, TCanonicalSource> {

  readonly canonicalSource: TCanonicalSource;

  readonly descriptor: AssetDescriptor<F>;

  readonly discoveredDependencies: readonly AssetSourceReference[];

  disposeDetached(): void;

}

declare class AssetStore {

  constructor(options?: AssetStoreOptions);

  adopt(candidates: readonly AssetStoreCandidate[]): void;

  adoptPrepared(insertions: readonly AssetStoreCandidate[]): void;

  diagnostics(): AssetStoreDiagnostics;

  has(key: AssetContentKey): boolean;

  preflight(candidates: readonly AssetStoreCandidate[]): void;

  prepareInsertions(candidates: readonly AssetStoreCandidate[]): readonly AssetStoreCandidate[];

  read(key: AssetContentKey): AssetStoreView | null;

  release(key: AssetContentKey): void;

  requireView(key: AssetContentKey): AssetStoreView;

  retain(key: AssetContentKey): void;

}

interface AssetStoreCandidate<TValue = unknown> {

  readonly resources: AssetResourceOwner;

  readonly spec: ResolvedAssetSpec;

  readonly value: TValue;

}

interface AssetStoreDiagnostics {

  readonly recordCount: number;

  readonly recordsByFamily: Readonly<Record<AssetFamily, number>>;

  readonly retainCount: number;

}

interface AssetStoreOptions {

  readonly onCleanupError?: (key: AssetContentKey, error: AggregateError) => void;

}

interface AssetStoreView<TValue = unknown> {

  readonly family: AssetFamily;

  readonly key: AssetContentKey;

  readonly kind: AssetKindId;

  readonly value: TValue;

}

declare const ATLAS_TEXTURE_RECIPE_SCHEMA: "wave.texture.atlas.v1";

interface AtlasMotionTextureBinding {

  readonly backward: unknown;

  readonly forward: unknown;

}

interface AtlasTextureAssetValue {

  readonly kind: "atlas";

  readonly manifest: AtlasTextureRecipe["manifest"];

  readonly motionTextures?: { readonly forward: unknown; readonly backward: unknown; }

  readonly pages: readonly AtlasTexturePageValue[];

  readonly runtimeView: WaveTextureAtlasRuntimeView;

  readonly sampling: AtlasTextureRecipe["manifest"]["sampling"];

}

interface AtlasTexturePageBinding {

  readonly id: string;

  readonly ref: ExactAssetRef<"texture">;

  readonly texture: unknown;

}

interface AtlasTexturePageValue {

  readonly id: string;

  readonly texture: unknown;

}

interface AtlasTextureRecipe {

  readonly kind: "atlas";

  readonly manifest: WaveTextureAtlasManifest;

  readonly schema: typeof ATLAS_TEXTURE_RECIPE_SCHEMA;

}

declare class AttractBuilder {

  animate(): WaveGeometryDeformAnimationBuilder;

  apply(): MeshEditResult;

  forceMergeMesh(force?: boolean): this;

  mode(mode: DeformApplyMode): this;

  toward(...points: readonly WavePointInput[]): this;

  towardPoint(point: WavePointInput): this;

  towardPoints(points: readonly WavePointInput[]): this;

  withFalloff(power: number): this;

  withRadius(r: number): this;

  withStrength(s: number): this;

}

interface AttractOptions {

  applyMode?: DeformApplyMode;

  falloff?: number;

  radius?: number;

  strength: number;

  targetPoint: Vector3;

  targetPoints?: readonly Vector3[];

}

declare enum AudioAnalysisBandName {

  Bass = "bass",

  Brilliance = "brilliance",

  HighMid = "highMid",

  LowMid = "lowMid",

  Mid = "mid",

  Presence = "presence",

  SubBass = "subBass",

}

declare enum AudioBusType {

  Ambient = "ambient",

  Master = "master",

  Music = "music",

  SFX = "sfx",

  Voice = "voice",

}

interface AudioClipBindingValue {

  readonly buffer: AudioBuffer;

  readonly facts: AudioClipFacts;

  readonly kind: "clip";

}

interface AudioClipFacts {

  readonly channelCount: number;

  readonly durationSeconds: number;

  readonly frameCount: number;

  readonly sampleRate: number;

}

declare enum AudioDistanceModel {

  Exponential = "exponential",

  Inverse = "inverse",

  Linear = "linear",

}

interface AudioGraphBindingValue {

  readonly impulseResponses: ReadonlyMap<number, AudioBuffer>;

  readonly kind: "graphTemplate";

  readonly nodes: readonly NormalizedWaveAudioFxNode[];

}

interface AudioInputData {

  confidence?: number;

  text?: string;

  timestamp: number;

  type: "speech" | "loudness";

  value?: number;

}

interface AudioInstrumentBindingValue {

  readonly config: AudioInstrumentTemplate["config"];

  readonly impulseResponses: AudioInstrumentTemplate["impulseResponses"];

  readonly kind: "instrumentTemplate";

  readonly zones: AudioInstrumentTemplate["zones"];

}

interface AudioInstrumentTemplate {

  readonly config: Readonly<WaveInstrumentConfig>;

  readonly impulseResponses: ReadonlyMap<number, AudioBuffer>;

  readonly zones: readonly AudioInstrumentTemplateZone[];

}

interface AudioInstrumentTemplateZone {

  readonly buffer: AudioBuffer;

  readonly sampleRef: ExactAssetRef<"audio">;

  readonly zone: WaveInstrumentZone;

  readonly zoneId: string;

}

interface AudioOptions {

  autoplay?: boolean;

  bus?: AudioBusType | string;

  distanceModel?: AudioDistanceModel;

  isStreaming?: boolean;

  loop?: boolean;

  maxDistance?: number;

  panningModel?: AudioPanningModel;

  pitchCents?: number;

  playbackRate?: number;

  refDistance?: number;

  rolloffFactor?: number;

  spatialSound?: boolean;

  volume?: number;

}

declare enum AudioPanningModel {

  EqualPower = "equalpower",

  HRTF = "HRTF",

}

type AudioSceneAssetValue = AudioClipBindingValue | AudioInstrumentBindingValue | AudioGraphBindingValue;

type AuroraConfig = EnabledEnvironmentPatch<AuroraState>;

declare class AuroraConfigurator<TEngine extends unknown = unknown> {

  constructor(_sky: SkyConfigurator<TEngine>);

  angularWidth(value: number): this;

  apply(): SkyConfigurator<TEngine>;

  azimuthDegrees(value: number): this;

  baseGlow(value: number): this;

  brightness(value: number): this;

  colorMix(value: number): this;

  colors(bottom: ColorInput, top: ColorInput, accent: ColorInput): this;

  configure(patch: AuroraConfig): this;

  curtainFolds(value: number): this;

  disable(): SkyConfigurator<TEngine>;

  elevation(min: number, max: number): this;

  pulsation(value: number): this;

  rayIntensity(value: number): this;

  speed(value: number): this;

}

interface AuthoredDefinitionBundle {

  readonly definitions: readonly AssetDefinition[];

  readonly primaryRef: AssetRef;

  readonly sources?: readonly AssetLoadRequest[];

}

declare enum AutoColliderFromMeshMethod {

  Vhacd = "vhacd",

  VoxelBoxes = "voxelBoxes",

}

interface AutoColliderFromMeshOptions {

  max?: number;

  maxChildren?: number;

  method?: AutoColliderFromMeshMethod;

  padding?: number;

  vhacdMaxSplits?: number;

  vhacdMinVoxelsPerHull?: number;

  voxelResolution?: number;

}

interface AutoLODConfig {

  cullDistance?: number;

  levels?: number;

  minTriangles?: number;

  ratios?: number[];

}

declare class AutoLODConfigurator<TEngine extends unknown = unknown> {

  apply(): WaveScene<TEngine>;

  apply(patch: Partial<AutoLODConfig>): WaveScene<TEngine>;

  cullDistance(val: number): AutoLODConfigurator<TEngine>;

  disable(): WaveScene<TEngine>;

  enable(config?: AutoLODConfig): AutoLODConfigurator<TEngine>;

  levels(val: number): AutoLODConfigurator<TEngine>;

  minTriangles(val: number): AutoLODConfigurator<TEngine>;

  ratios(val: number[]): AutoLODConfigurator<TEngine>;

}

interface AxisArrowOptions {

  arrowHeadSize?: number | undefined;

  arrowShaftThickness?: number | undefined;

  color?: any;

  duration?: number | undefined;

  length?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  axes?: ("x" | "y" | "z")[];

  coordinateSpace?: ToolLocalOrWorldSpace;

  labelFontSize?: number;

  labelOffset3D?: Vector3 | Vector3Like;

  labelOffset3DSpace?: "world" | "local";

  showLabels?: boolean;

}

interface AxisFriction {

  axis: ConstraintAxis;

  value: number;

}

interface AxisLimit {

  axis: ConstraintAxis;

  maxLimit?: number;

  minLimit?: number;

}

type AxisName = "x" | "y" | "z";

declare const BABYLON_EXTERNAL_IMPORT_FORMATS: readonly ["nodeMaterialJson", "nodeMaterialSnippet", "nodeGeometryJson", "nodeGeometrySnippet", "shaderSnippet", "materialJson", "postProcessChainJson"];

declare const BABYLON_EXTERNAL_LOCATOR_TYPES: readonly ["filePath", "url", "snippetId"];

type BabylonExternalImportFormat = (typeof BABYLON_EXTERNAL_IMPORT_FORMATS)[number];

type BabylonExternalLocatorType = (typeof BABYLON_EXTERNAL_LOCATOR_TYPES)[number];

type BabylonExternalProjectAssetType = ProjectAssetTypesForSource<"babylonExternal">;

declare enum bakIntoPropPolicy {

  destoryGroup = "destoryGroup",

  retainGroup = "retainGroup",

}

interface BallAndSocketConfig {

  axisA?: DirectionInput | undefined;

  axisB?: DirectionInput | undefined;

  enableCollisions?: boolean | undefined;

  limits?: AxisLimit[] | undefined;

  motors?: MotorConfig[] | undefined;

  perpAxisA?: DirectionInput | undefined;

  perpAxisB?: DirectionInput | undefined;

  pivotA?: any;

  pivotB?: any;

  coneLimit?: number;

  twistLimit?: { min: number; max: number; }

  type: ConstraintType.BallAndSocket;

}

interface BaseEngineConfig {

  assetBaseUrl?: string;

  assetSigningUrl?: string;

  babylonSceneGraphOptimization?: WaveBabylonSceneGraphOptimizationConfigInput;

  backbufferPolicy?: RenderBackbufferPolicy;

  canvas?: WaveRenderSurface;

  debugRenderWatchdogOverlay?: boolean;

  enableAssetCaching?: boolean;

  fixedDelta?: number;

  gravity?: Vector3;

  httpConfig?: HttpConfig;

  llmConfig?: LLMConfig;

  networkIceServers?: readonly RTCIceServer[];

  networkProxyPort?: MessagePort;

  networkRegion?: NetworkRegion;

  networkTransport?: NetworkTransport;

  profile: WaveEngineProfileName;

  renderProfile?: WaveRenderProfile;

  requiredConsents?: string[];

  showFramerate?: boolean;

  showMemoryUsage?: boolean;

  signalServerUrl?: string;

  socketServerUrl?: string;

  systemErrorMode?: WaveSystemErrorMode;

  useLargeWorldRendering?: boolean;

}

type BaseEngineRef = unknown;

type BaseEngineRef = unknown;

interface BaseInteractableCallbackOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  holdThreshold?: WaveTimeSpan;

  name?: string;

  once?: boolean;

  priority?: number;

}

interface BehaviorObservationRuntimeHost {

  getLastTickNumber(): number;

  readonly isEnabled: boolean;

  offPreUpdate(callbackOrName: string): boolean;

  onPreUpdate(callback: (target: this, deltaTime: number) => void, name: string): this;

}

declare class BendBuilder {

  along(axis: DirectionInput): this;

  angleDegrees(deg: number): this;

  animate(): WaveGeometryDeformAnimationBuilder;

  apply(): MeshEditResult;

  forceMergeMesh(force?: boolean): this;

  inRegion(start: number, end: number): this;

  mode(mode: DeformApplyMode): this;

  regionEnd(pos: number): this;

  regionStart(pos: number): this;

  toward(dir: DirectionInput): this;

}

interface BendOptions {

  angleDeg: number;

  applyMode?: DeformApplyMode;

  axis: DirectionInput;

  direction: DirectionInput;

  endPos?: number;

  startPos?: number;

}

type BindingSource = { device: "keyboard"; key: Keyboard; } | { device: "mouseButton"; button: MouseButton; } | { device: "mouseDelta"; scale?: number; invertX?: boolean; invertY?: boolean; } | { device: "mouseWheel"; axis?: AxisName; scale?: number; invert?: boolean; } | { device: "gamepadButton"; button: GamepadButton | number; gamepadIndex?: number; } | { device: "gamepadAxis"; axis: GamepadAxis | number; gamepadIndex?: number; deadZone?: number; scale?: number; invert?: boolean; } | { device: "gamepadStick"; stick: "left" | "right"; gamepadIndex?: number; deadZone?: number; scale?: number; invertX?: boolean; invertY?: boolean; } | { device: "gamepadTrigger"; side: "left" | "right"; gamepadIndex?: number; deadZone?: number; scale?: number; } | { device: "touchVirtualStick"; stick: "move" | "look"; deadZone?: number; scale?: number; } | { device: "xrButton"; control: "select" | "squeeze" | "button"; button?: number; handedness?: XRHandedness; } | { device: "xrAxis"; axis: number; handedness?: XRHandedness; deadZone?: number; scale?: number; invert?: boolean; } | { device: "xrStick"; handedness?: XRHandedness; axes?: readonly [number, number]; deadZone?: number; scale?: number; invertX?: boolean; invertY?: boolean; } | { device: "visionGesture"; gesture: VisionGestureName; handIndex?: number; minConfidence?: number; } | { device: "audioLoudness"; threshold?: number; scale?: number; } | { device: "audioSpeech"; phrase?: string; match?: "exact" | "includes"; minConfidence?: number; } | { device: "hardwareControl"; id?: string; control: string; }

type BindingValue = { type: ActionValueType.Bool; value: boolean; } | { type: ActionValueType.Axis1D; value: number; } | { type: ActionValueType.Axis2D; value: SerializableVector2; } | { type: ActionValueType.Axis3D; value: SerializableVector3; }

type BindMeshesToPartConflictPolicy = "error" | "rebind";

interface BindMeshesToPartOptions {

  entityCreation?: PartEntityCreationMode | undefined;

  includeInPhysics?: boolean | undefined;

  materialIsolation?: PartMaterialIsolationMode | undefined;

  scope?: WaveModelPartScope | undefined;

  readonly onConflict?: BindMeshesToPartConflictPolicy;

}

type BivariantCallback<TArgs extends unknown[], TResult> = { bivarianceHack(...args: TArgs): TResult; }["bivarianceHack"];

type BivariantCallback<TArgs extends unknown[], TResult> = { bivarianceHack(...args: TArgs): TResult; }["bivarianceHack"];

interface BlackAndWhiteOptions {

  degree?: number;

}

interface BlankPixelInput {

  readonly a?: number;

  readonly b?: number;

  readonly g?: number;

  readonly inside?: boolean;

  readonly luminance?: number;

  readonly r?: number;

  readonly srgbColor?: Pick<SampledRgbaColor, "r" | "g" | "b" | "a">;

}

interface BlankPixelOptions {

  readonly maxChroma?: number;

  readonly minAlpha?: number;

  readonly minLuminance?: number;

  readonly minRgb?: number;

  readonly treatOutsideAsBlank?: boolean;

}

interface BloomOptions {

  kernel?: number;

  scale?: number;

  threshold?: number;

  weight?: number;

}

type BoneSocket = WaveAttachmentSocket;

interface BoneSocketAttachOptions {

  autoAvoidCollision?: boolean;

  collisionTargets?: wave3DObject | readonly wave3DObject[];

}

interface BoneSocketCreateOptions {

  autoAvoidCollisionOnAttach?: boolean;

  resolveDefaultCollisionTargets?: () => readonly wave3DObject[];

  scaleMode?: BoneSocketScaleMode;

  sphere?: boolean | BoneSocketSphereVisualOptions;

}

type BoneSocketScaleMode = "inherit" | "preserve-world";

interface BoneSocketSphereVisualOptions {

  arc?: number | undefined;

  backUVs?: any;

  baseCapSegments?: number | undefined;

  cap?: number | undefined;

  capBase?: boolean | undefined;

  capSides?: boolean | undefined;

  capSubdivisions?: number | undefined;

  color?: string | ColorInput | undefined;

  depth?: number | undefined;

  depthSegments?: number | undefined;

  diameter?: number | undefined;

  diameterBottom?: number | undefined;

  diameterTop?: number | undefined;

  diameterX?: number | undefined;

  diameterY?: number | undefined;

  diameterZ?: number | undefined;

  enclose?: boolean | undefined;

  faceColors?: ColorInputAlpha[] | undefined;

  faceUV?: unknown[] | undefined;

  flat?: boolean | undefined;

  frontUVs?: any;

  height?: number | undefined;

  heightSegments?: number | undefined;

  horizontalArc?: number | undefined;

  innerRadius?: number | undefined;

  invertNormals?: boolean | undefined;

  materialType?: PrimitiveMaterialType | undefined;

  orientation?: number | undefined;

  outerRadius?: number | undefined;

  p?: number | undefined;

  planeOrientation?: "xy" | "ground" | undefined;

  q?: number | undefined;

  radialSegments?: number | undefined;

  radius?: number | undefined;

  radiusBottom?: number | undefined;

  radiusTop?: number | undefined;

  segments?: number | undefined;

  shape?: Vector3[] | undefined;

  sideCapSegments?: number | undefined;

  sideOrientation?: number | undefined;

  size?: number | undefined;

  slice?: number | undefined;

  subdivisions?: number | undefined;

  subdivisionsX?: number | undefined;

  subdivisionsY?: number | undefined;

  taperX?: number | undefined;

  taperZ?: number | undefined;

  tessellation?: number | undefined;

  thickness?: number | undefined;

  topDepth?: number | undefined;

  topOffsetX?: number | undefined;

  topOffsetZ?: number | undefined;

  topology?: "uv" | "ico" | undefined;

  topWidth?: number | undefined;

  updatable?: boolean | undefined;

  verticalArc?: number | undefined;

  verticalSegments?: number | undefined;

  width?: number | undefined;

  widthSegments?: number | undefined;

  assetName?: string;

  opacity?: number;

  renderMode?: "normal" | "overlay";

  visualScale?: Vector3Like | number;

  wireframe?: boolean;

}

declare class BooleanObservationSource<TEntity extends BehaviorObservationRuntimeHost> implements WaveBooleanObservationSource<TEntity> {

  constructor(target: ObservationSourceBuilderTarget<TEntity>, source: ObservationSourceDefinition<TEntity>);

  changes(change: ObservationChangeToken, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  do(action: ObservationAction<TEntity>): ObservationHandle;

  enterState(state: unknown): ObservationHandle;

}

interface BooleanPredicateDefinition {

  change: ObservationChangeKind;

  kind: "changes";

  occurrence: ObservationOccurrenceKind;

}

type BooleanSelector<TEntity extends object> = BivariantCallback<[entity: TEntity], boolean>;

interface BoundAudioClipEntry {

  readonly clipBinding: AssetConsumerBindingSnapshot<"audio">;

  readonly defaults: NormalizedAudioPlaybackDefaults;

  readonly handle: WaveSceneAudioBinding;

  readonly name: string;

}

interface BoundingBoxOptions {

  duration?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  color?: unknown | string | number;

  lineThickness?: number;

}

declare enum BoundsSpace {

  Anchor = "anchor",

  Visual = "visual",

  World = "world",

}

interface BreadcrumbTrailGlowOptions {

  readonly color?: ColorInput;

  readonly enabled: boolean;

  readonly intensity?: number;

  readonly spread?: WaveRenderGraphWorldGlowSpread;

}

interface BreadcrumbTrailOptions {

  readonly color?: ColorInput;

  readonly colorPerInstance?: ColorInput | ColorCallbackInput;

  readonly everyTicks?: number;

  readonly glow?: BreadcrumbTrailGlowOptions;

  readonly maxMarks?: number;

  readonly size?: number;

}

interface BrowserSpeechSynthesisTTSConfig {

  cancelQueued?: boolean;

  enabled?: boolean;

  lang?: string;

  pitch?: number;

  preferLocalService?: boolean;

  rate?: number;

  speechConcurrency?: WaveTTSSpeechConcurrency;

  voiceName?: string;

  voicePreference?: BrowserSpeechSynthesisVoicePreference;

  voiceURI?: string;

  volume?: number;

  waitForVoicesMs?: number;

}

type BrowserSpeechSynthesisVoicePreference = "default" | "natural" | "youngFemale";

interface BrowserVectorFontBindingValue {

  readonly declaredFamily: string;

  readonly fontFace: FontFace;

  readonly kind: "browserVector";

  readonly ref: ExactAssetRef<"font">;

  readonly runtimeFamily: string;

  readonly stretch: string;

  readonly style: string;

  readonly weight: string;

}

type BrushFalloff = MaterialSplatFalloff;

type BuilderWithMethods<TParts extends Readonly<Record<string, string>>, TMethods extends object> = WavePrefabModelBuilder<TParts, TMethods>;

type CallbackEventType = InputEventType | string;

interface CallbackHandle {

  eventType: CallbackEventType;

  id: string;

  name?: string;

  off: () => void;

}

interface CallbackOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  entityId?: number;

  filter?: Keyboard | MouseButton | GamepadButton | number;

  holdThreshold?: WaveTimeSpan;

  name?: string;

  once?: boolean;

  priority?: number;

}

interface CallbackRegistrationMetadata {

  name?: string;

  options?: CallbackOptions | ActionCallbackOptions;

  type: InputEventType | WaveActionName | string;

}

declare class CameraConfigurator<TEngine extends unknown = unknown> {

  apply(): WaveScene<TEngine>;

  apply(patch: Partial<WaveSceneCameraConfig>): WaveScene<TEngine>;

  activate(): WaveScene<TEngine>;

  avoid(volume: CameraVolumeConstraintSource, options?: CameraConstraintOptions | number): CameraConfigurator<TEngine>;

  centerAtECEF(center: Vector3Like): this;

  centerAtECEF(x: number, y: number, z: number): this;

  clearCameraConstraints(): CameraConfigurator<TEngine>;

  clearPostFx(cameraId: string): WaveScene<TEngine>;

  controlAsGeospatial(input?: GeospatialCameraControlInput): this;

  create(name: string, options?: CameraCreateOptions): string;

  deactivate(): WaveScene<TEngine>;

  disableOrbit(): CameraConfigurator<TEngine>;

  far(val: number): CameraConfigurator<TEngine>;

  fov(val: number): CameraConfigurator<TEngine>;

  gestureOrbit(opts: NonNullable<WaveSceneCameraConfig["gestureOrbit"]>): CameraConfigurator<TEngine>;

  gestureOrbitEnabled(val: boolean): CameraConfigurator<TEngine>;

  getPositionToRef(result: Vector3Like): boolean;

  has(cameraId: string): boolean;

  ids(): string[];

  keepAbove(surface: CameraHeightSurfaceSource, options?: CameraConstraintOptions | number): CameraConfigurator<TEngine>;

  near(val: number): CameraConfigurator<TEngine>;

  nearAuto(options?: CameraNearAutoOptions): CameraConfigurator<TEngine>;

  orbit(): WaveSceneCameraOrbitConfigurator<TEngine>;

  orbit(opts: OrbitOptions): CameraConfigurator<TEngine>;

  orbitFrom(input: GeospatialCameraOrbitInput): this;

  orbitFrom(radius: number, yawRadians?: number, pitchRadians?: number): this;

  possess(cameraId?: string): this;

  postFx(cameraId: string): WaveCameraPostFx;

  remove(cameraId: string): WaveScene<TEngine>;

  setGeospatialControls(settings: GeospatialCameraControlSettings): this;

  stayInside(volume: CameraVolumeConstraintSource, options?: CameraStayInsideOptions | number): CameraConfigurator<TEngine>;

  target(target: WavePointInput | WaveSpatial3DEntity | WaveGroup): CameraConfigurator<TEngine>;

  targetOptions(opts: OrbitTargetOptions): CameraConfigurator<TEngine>;

}

type CameraConstraintConfig = { kind: "keepAboveSurface"; source: CameraHeightSurfaceSource; clearance: number; } | { kind: "stayOutsideVolume"; source: CameraVolumeConstraintSource; clearance: number; } | { kind: "stayInsideVolume"; source: CameraVolumeConstraintSource; clearance: number; }

interface CameraConstraintOptions {

  clearance?: number;

}

interface CameraCreateOptions {

  enablePostProcessing?: boolean;

  fov?: number;

  geospatial?: GeospatialCameraControlConfig;

  kind?: CameraKind;

  position?: Vector3;

  projection?: CameraProjection;

  target?: Vector3;

}

declare enum CameraFocusPoint {

  Origin = "Origin",

  VisualCenter = "VisualCenter",

}

type CameraFollowOffsetFrame = WaveTransformFrameSpace;

interface CameraFollowViewBlendOptions {

  curve?: WaveValueCurveInput;

  damping?: number;

  directionBlend?: CameraRigDirectionBlend;

  durationSeconds?: number;

}

interface CameraFollowViewConfig {

  constraint: FollowConstraint;

  focus: CameraFocusPoint;

  lookAtOffset: Vector3;

  offset: Vector3;

  offsetFrame: CameraFollowOffsetFrame;

  offsetFrameOf?: TransformReferenceLike;

  offsetFrameParentDepth: number;

  pointOffset: Vector3;

  rigTransition: CameraRigTransitionConfig;

  target?: TransformReferenceLike;

  targetTracking: CameraTargetTrackingConfig;

}

interface CameraFollowViewInput {

  constraint?: FollowConstraint;

  distance: number;

  focus?: CameraFocusPoint;

  frameOf?: TransformReferenceLike;

  from: DirectionInput;

  offsetFrame?: CameraFollowOffsetFrame;

  parentFrameDepth?: number;

  pointOffset?: WavePointInput | TransformReferenceLike;

  rigTransition?: CameraRigTransitionInput;

  target?: TransformReferenceLike;

  targetTracking?: CameraTargetTrackingInput;

  tiltDegrees?: number;

}

interface CameraHeightSurfaceSource {

  getHeightAt?: (x: number, z: number) => number | null;

  heightAt?: (x: number, z: number) => number | null;

}

type CameraKind = "perspective" | "orthographic" | "geospatial";

interface CameraNearAutoConfig {

  constraintClearanceRatio: number;

  distanceRatio: number;

  max: number;

  maxFarNearRatio: number;

  min: number;

}

interface CameraNearAutoOptions {

  constraintClearanceRatio?: number;

  distanceRatio?: number;

  max?: number;

  maxFarNearRatio?: number;

  min?: number;

}

type CameraNearPlaneInput = number | "auto" | CameraNearAutoOptions;

declare enum CameraProjection {

  Orthographic = "Orthographic",

  Perspective = "Perspective",

}

type CameraRigDirectionBlend = "linear" | "arc";

type CameraRigTransitionConfig = { kind: "snap"; } | { kind: "blend"; directionBlend: CameraRigDirectionBlend; durationSeconds?: number; damping?: number; curve?: WaveValueCurveSpec; }

type CameraRigTransitionInput = "snap" | "blend" | { kind?: "snap" | "blend"; directionBlend?: CameraRigDirectionBlend; durationSeconds?: number; damping?: number; curve?: WaveValueCurveInput; }

interface CameraStayInsideOptions {

  clearance?: number | undefined;

  wallClearance?: number;

}

type CameraTargetTrackingConfig = { kind: "rigid"; } | { kind: "smoothed"; smoothing: number; } | { kind: "cinematic"; lookAheadSeconds: number; cruiseSmoothing: number; catchUpSmoothing: number; accelThreshold: number; }

type CameraTargetTrackingInput = CameraTargetTrackingConfig | "rigid" | "smoothed" | "cinematic";

type CameraViewport = WaveCanvasNormalizedViewport;

interface CameraVolumeBoundsLike {

  readonly centerWorld?: Vector3Like;

  readonly halfExtents?: Vector3Like;

  readonly maxWorld?: Vector3Like;

  readonly minWorld?: Vector3Like;

}

interface CameraVolumeConstraintProvider {

  readonly center?: Vector3Like;

  readonly depth?: number;

  getBoundingBox?: () => CameraVolumeBoundsLike | null;

  getWorldPosition?: () => Vector3Like;

  readonly height?: number;

  readonly isDestroyed?: boolean;

  readonly isEnabled?: boolean;

  readonly position?: Vector3Like;

  readonly radius?: number;

  readonly shape?: WaveRangeShape;

  readonly width?: number;

}

type CameraVolumeConstraintSource = CameraVolumeConstraintProvider | WaveRangeShape;

type CanvasNormalizedPoint = Vector2 & { readonly [WAVE_SCREEN_COORDINATE_SPACE]: "canvasNormalized"; }

type CanvasNormalizedViewport = ScreenRect & { readonly [WAVE_SCREEN_COORDINATE_SPACE]: "canvasNormalizedViewport"; }

type CanvasPixelPoint = Vector2 & { readonly [WAVE_SCREEN_COORDINATE_SPACE]: "canvasPixel"; }

type CanvasPixelRect = ScreenRect & { readonly [WAVE_SCREEN_COORDINATE_SPACE]: "canvasPixelRect"; }

interface CanvasTextureWriter {

  clear(): this;

  readonly context: CanvasRenderingContext2D;

  update(): this;

}

interface CaptureConfig {

  enableBuiltInVisionGestures?: boolean;

  facingMode?: "user" | "environment";

  fftSize?: number;

  frameRate?: number;

  height?: number;

  maxDecibels?: number;

  mediapipeGestureModelAssetPath?: string;

  mediapipeWasmBaseUrl?: string;

  minDecibels?: number;

  smoothingTimeConstant?: number;

  visionInferenceFps?: number;

  visionMaxHands?: number;

  visionMinGestureConfidence?: number;

  width?: number;

}

declare enum CaptureState {

  Active = 2,

  Error = 4,

  Inactive = 0,

  Starting = 1,

  Stopping = 3,

}

interface CastToPropOptions {

  cloneMaterial?: boolean;

  name?: string;

  removeOriginal?: boolean;

}

interface CausticOverlayConfig {

  blurRadius?: number;

  enabled: boolean;

  intensity?: number;

  ior?: number;

  resolution?: number;

  scale?: number;

  softEdge?: number;

  speed?: number;

}

interface CausticPatternConfig {

  chromaticAberration?: boolean;

  color?: ColorInput;

  intensity?: number;

  octaves?: number;

  resolution?: number;

  scale?: number;

  speed?: number;

}

type CelestialBodiesConfig = CelestialBodyConfig[];

declare class CelestialBodiesConfigurator<TEngine extends unknown = unknown> {

  constructor(_sky: SkyConfigurator<TEngine>);

  apply(): SkyConfigurator<TEngine>;

  body(body: CelestialBodyConfig): this;

  clear(): SkyConfigurator<TEngine>;

  set(bodies: CelestialBodiesConfig): this;

}

type CelestialBodyConfig = Partial<CelestialBodyState>;

declare class ChainBuilder {

  constructor(anchor: waveProp, scene: WaveGroupSceneBridge);

  addTo(group: WaveGroup): this;

  apply(): waveProp[];

  build(): waveProp[];

  color(start: ColorInput, end?: ColorInput): this;

  damping(value: number): this;

  from(point: WavePointInput): this;

  from(x: number, y: number, z: number): this;

  gravityFactor(value: number): this;

  inDirection(direction: DirectionInput): this;

  length(len: number): this;

  radius(start: number, end?: number): this;

  segments(count: number): this;

  usePrefab(prefab: waveProp): this;

}

type ChanceEntityProxy<TEntity extends object> = TEntity & ChanceProxySurface<TEntity>;

interface ChanceProxySurface<TEntity extends object> {

  after(duration: WaveTimeSpan): ChanceEntityProxy<TEntity>;

  after(value: number, unit: WaveTimeUnit): ChanceEntityProxy<TEntity>;

  do(callback: (entity: TEntity) => void): TEntity;

}

type CharacterEventCallback = (controller: cmp_kinematicController) => void;

type CharacterEventType = "landed" | "airborne" | "jumpStarted" | "sprintStarted" | "sprintEnded" | "crouchStarted" | "crouchEnded";

declare enum CharacterSupportState {

  Sliding = 1,

  Supported = 2,

  Unsupported = 0,

}

interface ChromaticAberrationOptions {

  aberrationAmount?: number;

  direction?: { x: number; y: number; }

  radialIntensity?: number;

}

interface ChunkBoundsXZ {

  centerX: number;

  centerZ: number;

  maxX: number;

  maxZ: number;

  minX: number;

  minZ: number;

}

type ChunkKey = string;

interface ClampModifier {

  max: number;

  min: number;

  type: ModifierType.Clamp;

}

type ClickToMarkCoordinateDisplaySpace = ToolLocalOrWorldSpace;

interface ClickToMarkOptions {

  color?: any;

  decimals?: number | undefined;

  duration?: number | undefined;

  fontAsset?: string | undefined;

  fontSize?: number | undefined;

  labelOffset3D?: any;

  labelOffset3DSpace?: "world" | "local" | undefined;

  showCoordinate?: boolean | undefined;

  size?: number | undefined;

  textColor?: any;

  updateMode?: DevToolUpdateMode | undefined;

  agentLabel?: string;

  alignToHitNormal?: boolean;

  callback?: (context: InteractionContext, point: Vector3, marker: waveMarker | null) => void;

  coordinateDisplaySpace?: ClickToMarkCoordinateDisplaySpace;

  coordinateSpace?: ToolLocalOrWorldSpace;

  exposeToAgent?: boolean;

  markerModel?: string;

  markerWorldSize?: number;

  spawnWaveMarker?: boolean;

  surfaceYaw?: number;

  tag?: string;

  tags?: readonly string[];

}

interface ClientInfo {

  clientId: string;

  connectedAt: number;

  lastSeenAt?: number;

  metadata?: Record<string, unknown>;

  onboardedAt?: number;

  playerName?: string;

  state: ClientState;

}

type ClientState = "connecting" | "connected" | "onboarding" | "ready" | "disconnecting" | "disconnected" | "kicked";

interface CloneOptions {

  callOnCloneFinalized?: boolean;

  cloneChildren?: boolean;

  copyColliderOffsets?: boolean;

  copyComponentState?: boolean;

  copyCurrentState?: boolean;

  copyLifecycleCallbacks?: boolean;

  copyLightOnState?: boolean;

  copyObservers?: boolean;

  copyScopedObservers?: boolean;

  copyStateMachineDefinitions?: boolean;

  copyTags?: boolean;

  copyTickableCallbacks?: boolean;

  copyVertexArrayMap?: boolean;

  deepCopyAssets?: boolean;

  deepCopyMaterials?: boolean;

  generatedAssetReuse?: GeneratedAssetCloneReuseIntent;

}

interface ClothGridOptions {

  color?: ColorInput;

  cols?: number;

  damping?: number;

  horizontal?: boolean;

  includeShear?: boolean;

  material?: string;

  materialUVScale?: number;

  name?: string;

  nodeColliderShape?: WaveSoftBodyNodeColliderShape;

  nodeMass?: number;

  nodeRadius?: number;

  particleCollision?: WaveSoftBodyParticleCollisionPolicyInput;

  pinCorners?: boolean;

  pinTopRow?: boolean;

  position: WavePointInput;

  rows?: number;

  showNodes?: boolean;

  spacing?: number;

}

declare class cmp_instanceAnimator extends cmp_animatorBase {

  constructor(owner: WaveEntity);

  static readonly typeName = ComponentTypeName.InstanceAnimator;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  createVertexAnimation(name: string, options: CreateVertexAnimationOptions): string;

  deformGeometry(intent: WaveGeometryDeformIntent): this;

  get deformPlan(): WaveGeometryGpuDeformPlan | null;

  destroy(): void;

  pause(): void;

  play(): void;

  playVertexAnimation(assetName: string, options?: VertexAnimationPlayOptions): this;

  playVertexAnimation(options?: VertexAnimationPlayOptions): this;

  resume(): void;

  setDeformationAmount(value: number): this;

  setDeformationDirection(x: number, y: number, z: number): this;

  setVertexAnimationTime(seconds: number): this;

  set speed(value: number);

  stop(): void;

  get targetMesh(): unknown | null;

  useVertexAnimation(assetName: string, rangeName?: string): this;

}

declare class cmp_instanceMesh {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroyPriority: number;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity, config?: InstanceMeshConfig);

  static readonly typeName = ComponentTypeName.InstanceMesh;

  get castShadow(): boolean;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  destroy(): void;

  disableGlow(): this;

  enableGlow(intensity?: number, color?: ColorInput | null): this;

  get forceActiveWhenOffscreen(): boolean;

  getBoundingBox(): ModelBoundingBox | null;

  getColor(): unknown | null;

  getModelBounds(space?: BoundsSpace, _useRestPose?: boolean, forceRefresh?: boolean): ModelBounds | null;

  getOrientedBounds(): ModelOrientedBounds | null;

  getVertexAnimationSourceMesh(): unknown | null;

  getVisualBounds(space?: BoundsSpace): ModelBounds | null;

  get glowColor(): ColorInput | null;

  get glowEnabled(): boolean;

  get glowIntensity(): number;

  get instancedMesh(): unknown | null;

  get isMeshInitialized(): boolean;

  get isVisible(): boolean;

  get meshes(): unknown[];

  get meshInitializationError(): unknown;

  get model(): string;

  get modelSource(): ModelConsumerSource | null;

  onScaleChanged(options?: { hasActiveRotationPivot?: boolean; }): void;

  onTransformChanged(change?: { positionChanged?: boolean; rotationChanged?: boolean; }, options?: { hasActiveRotationPivot?: boolean; }): void;

  readVatOwnerCompatibilityFacts(mesh: unknown): VatModelCompatibilityFacts;

  refreshBoundingInfo(): this;

  get resolvedModelRef(): ExactAssetRef<"model"> | null;

  setAnimationSpeed(speed: number): this;

  setAnimationTime(time: number): this;

  setCastShadow(castShadow?: boolean): this;

  setColor(color: ColorInput, alpha?: number): this;

  setForceActiveWhenOffscreen(forceActive?: boolean): this;

  setGlowIntensity(intensity: number): this;

  setModel(model: InstanceMeshModelInput): this;

  setVertexAnimation(vatAsset: VertexAnimationAsset, rangeName?: string): this;

  setVisible(visible: boolean): this;

  useVertexAnimation(assetName: string, rangeName?: string): this;

  get vatAsset(): VertexAnimationAsset | null;

  get vatManager(): unknown | null;

}

declare class cmp_profile {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroy(): void;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  setEnabled(value: boolean): this;

  typeName: string;

  static CarryPrimaryStateTag(enabled?: boolean): boolean;

  static readonly typeName: string;

  addTag(tag: string): void;

  addTags(...tags: string[]): void;

  adoptedPartRigidBodySuspendState: AdoptedPartRigidBodySuspendState | undefined;

  get archetype(): string;

  get attachedTo(): WaveEntity | null;

  clearPickable(): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  get destroyPriority(): number;

  get displayName(): string;

  field<T extends ProfileFieldValue = number>(name: string, dataType?: ProfileFieldType, initialValue?: T): ProfileField<T>;

  get fieldNames(): string[];

  getFieldSnapshot(): Record<string, { value: ProfileFieldValue; type: ProfileFieldType; }>;

  getFieldValue(name: string): ProfileFieldValue | undefined;

  hasAllTags(...tags: string[]): boolean;

  hasAnyTag(...tags: string[]): boolean;

  hasField(name: string): boolean;

  hasPickingCategory(pickingTag: SystemTag): boolean;

  hasTag(tag: string): boolean;

  get isPickable(): boolean;

  get isPrefab(): boolean;

  matchesMask(mask: bigint): boolean;

  partOwnerEntityId: number | undefined;

  get pickingMask(): bigint;

  get preferredCloneOptions(): Partial<CloneOptions> | null;

  removeTag(tag: string): void;

  removeTags(...tags: string[]): void;

  serialize(): SerializedCall[];

  setArchetype(type: string): this;

  setAttachedTo(entity: WaveEntity | null): this;

  setDisplayName(name: string): this;

  setField(name: string, value: ProfileFieldValue, dataType?: ProfileFieldType): this;

  setIsPrefab(value: boolean): this;

  setPickable(pickingTag?: SystemTag): this;

  setPreferredCloneOptions(options: Partial<CloneOptions> | null): this;

  setTags(tags: string[]): void;

  setTagsMask(mask: bigint | string): this;

  setTeamId(id: number): this;

  syncPrimaryStateTag(state: unknown): void;

  get tags(): string[];

  get tagsMask(): bigint;

  get teamId(): number;

  visualPartId: VisualPartId | undefined;

}

declare class cmp_transform2D {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  disable(): this;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity);

  static readonly typeName = ComponentTypeName.Transform2D;

  get activePresentationChannels(): readonly WaveTransform2DPresentationChannel[];

  addTransform2DChangedListener(listener: (dirty: WaveTransform2DDirtyMask, revision: number) => void): () => void;

  animateContinuous(direction: Readonly<SerializableVector2>, frame: WaveTransformFrameSpace, frameEntityId: string | null, parentFrameDepth: number, rateUnitsPerSecond: number, durationSeconds: number | null, config: TransformVerbAnimationConfig<WaveTransform2DProgressState>, viewId: string | null): WaveTransform2DAnimationRegistration;

  animateContinuousRotation(rateDegreesPerSecond: number, durationSeconds: number | null, config: TransformVerbAnimationConfig<WaveTransform2DProgressState>, viewId: string | null): WaveTransform2DAnimationRegistration;

  animateContinuousScale(direction: Readonly<SerializableVector2>, frame: WaveTransformFrameSpace, frameEntityId: string | null, parentFrameDepth: number, mode: "along" | "toward", factorPerSecond: number, durationSeconds: number | null, config: TransformVerbAnimationConfig<WaveTransform2DProgressState>, viewId: string | null): WaveTransform2DAnimationRegistration;

  animateContinuousTurnTo(target: WaveTransform2DContinuousTurnTarget, rateDegreesPerSecond: number, toleranceDegrees: number, durationSeconds: number | null, config: TransformVerbAnimationConfig<WaveTransform2DProgressState>, viewId: string | null): WaveTransform2DAnimationRegistration;

  animateContinuousUniformScale(factorPerSecond: number, durationSeconds: number | null, config: TransformVerbAnimationConfig<WaveTransform2DProgressState>, viewId: string | null): WaveTransform2DAnimationRegistration;

  animateTo(target: WaveTransform2DPoseSnapshot, channels: WaveTransform2DChannelMask, config: TransformVerbAnimationConfig<WaveTransform2DProgressState>, rotationInterpolation?: "shortest" | "signed", viewId?: string | null, fromOverride?: WaveTransform2DPoseSnapshot): WaveTransform2DAnimationRegistration;

  applyAuthoredPoseSnapshot(snapshot: WaveTransform2DPoseSnapshot): this;

  applyPoseChannels(snapshot: WaveTransform2DPoseSnapshot, channels: WaveTransform2DChannelMask): this;

  applyTransformStateSnapshot(state: WaveTransform2DStateSnapshot): this;

  applyUILayoutCommand(command: WaveUILayoutCommand): this;

  assertKnownView(viewId: string, operation: string): void;

  assertRootViewQualification(viewId: string | null, operation: string): void;

  authoredPoseSnapshot(): WaveTransform2DPoseSnapshot;

  bindResolutionProvider(provider: WaveTransform2DResolutionProvider | null): void;

  cancelActiveAnimations(policy: TransitionCancellationPolicy, viewId?: string | null): this;

  cancelAnimation(animationId: number, policy: TransitionCancellationPolicy, viewId?: string | null): boolean;

  canPairAnimationPlacements(from: Wave2DPlacementBasis, to: Wave2DPlacementBasis, viewId: string | null): boolean;

  clearDirtyMask(mask?: WaveTransform2DDirtyMask): void;

  clearHistory(viewId?: string | null): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  destroy(): void;

  get destroyPriority(): number;

  get dirtyMask(): WaveTransform2DDirtyMask;

  dispose(): void;

  getAcceleration(terms?: WaveTransform2DHistoryTerms, viewId?: string | null): Vector2;

  getAccelerationMagnitude(terms?: WaveTransform2DHistoryTerms, viewId?: string | null): number;

  getActiveChannelSnapshots(): readonly WaveTransform2DChannelSnapshot[];

  getAngularRate(terms?: WaveTransform2DHistoryTerms, viewId?: string | null): number;

  getHistorySample(when: WaveTimeLookback, viewId?: string | null): WaveTransform2DHistorySample | null;

  getHistorySamples(viewId?: string | null): readonly WaveTransform2DHistorySample[];

  getSpeed(terms?: WaveTransform2DHistoryTerms, viewId?: string | null): number;

  getSpeedDeclineRate(terms?: WaveTransform2DHistoryTerms, viewId?: string | null): number;

  getSpeedGrowthRate(terms?: WaveTransform2DHistoryTerms, viewId?: string | null): number;

  getVelocity(terms?: WaveTransform2DHistoryTerms, viewId?: string | null): Vector2;

  historyDepth(viewId?: string | null): number;

  historySampleCount(viewId?: string | null): number;

  isRecordingHistory(viewId?: string | null): boolean;

  get layerState(): WaveVisual2DLayerState;

  get layoutState(): WaveUILayoutState;

  get logicalToCssScale(): number;

  markMotionDiscontinuous(viewId?: string | null): this;

  motionReadiness(terms?: WaveTransform2DHistoryTerms, viewId?: string | null): WaveTransform2DMotionReadiness;

  observeAngularMotion(terms?: WaveTransform2DHistoryTerms, viewId?: string | null): this;

  observeMotion(terms?: WaveTransform2DHistoryTerms, viewId?: string | null): this;

  parentSnapshot(viewId?: string | null): WaveTransform2DFrameSnapshot;

  parentSnapshot(viewId: string | null, when: WaveTimeLookback): WaveTransform2DFrameSnapshot | null;

  get pose(): Readonly<WaveTransform2DPose>;

  prepareAnimationRestart(animationId: number): boolean;

  readHistoricalPosition(terms: WaveTransform2DHistoryTerms, when: WaveTimeLookback, viewId?: string | null): SerializableVector2 | null;

  readHistoricalRotation(terms: WaveTransform2DHistoryTerms, when: WaveTimeLookback, viewId?: string | null): number | null;

  readHistoricalScale(terms: WaveTransform2DHistoryTerms, when: WaveTimeLookback, viewId?: string | null): SerializableVector2 | null;

  recordHistory(options?: TransformHistoryRecordingOptions, terms?: WaveTransform2DHistoryTerms, viewId?: string | null): this;

  reparentPreservingRootPose(parentTransform: cmp_transform2D | null, viewId: string, rootPlacement?: Wave2DPlacementBasis | null): boolean;

  resetLayout(): this;

  resolveDirectionalScaleBodySizeToRef(out: SerializableVector2, operation: string, viewId?: string | null): SerializableVector2;

  get resolvedRootMatrixCount(): number;

  get resolvedStackingKey(): WaveTransform2DStackingKey | null;

  resolveFrameDeltaToLocalDelta(delta: Readonly<SerializableVector2>, frame: WaveTransformFrameSpace, frameEntityId: string | null, parentFrameDepth: number, viewId: string | null, localRotationDegrees: number, out: SerializableVector2, rootScratch: SerializableVector2, frameMatrixScratch: WaveAffine2D): void;

  get revision(): number;

  setHistoryDepth(depth: number, viewId?: string | null): this;

  setLayer(layer: number): this;

  setParentEntity(parent: WaveEntity | null, rootPlacement?: Wave2DPlacementBasis | null): this;

  setParentTransform(parentTransform: cmp_transform2D | null, rootPlacement?: Wave2DPlacementBasis | null): this;

  stopRecordingHistory(options?: { clear?: boolean; }, viewId?: string | null): this;

  takePresentationSnapshot(channels?: WaveTransform2DChannelMask, viewId?: string | null): WaveTransform2DPoseSnapshot;

  takeStateSnapshot(): WaveTransform2DStateSnapshot;

  tryConvertParentPointToLocalPosition(viewId: string | null, parentPoint: Readonly<SerializableVector2>, out: SerializableVector2): boolean;

  tryConvertRootDeltaToLocalDelta(viewId: string | null, rootDelta: Readonly<SerializableVector2>, out: SerializableVector2): boolean;

  tryConvertRootPointToLocalPosition(rootPoint: Readonly<SerializableVector2>, out: SerializableVector2): boolean;

  tryConvertRootPointToLocalPositionInView(viewId: string, rootPoint: Readonly<SerializableVector2>, out: SerializableVector2): boolean;

  tryResolveEntityBodyGeometry(entityId: string, viewId: string | null, out: WaveResolved2DBodyGeometry): boolean;

  tryResolveEntityRootMatrix(entityId: string, viewId: string | null, out: WaveAffine2D): boolean;

  tryResolveEntityRootPivotPoint(entityId: string, viewId: string | null, out: SerializableVector2): boolean;

  tryResolveEntityRootTransformPosition(entityId: string, viewId: string | null, out: SerializableVector2): boolean;

  tryResolveParentTransformPosition(viewId: string | null, out: SerializableVector2): boolean;

  tryResolveQualifiedRootMatrix(viewId: string | null, out: WaveAffine2D): boolean;

  tryResolveRootMatrix(out: WaveAffine2D): boolean;

  tryResolveRootMatrixAt(index: number, out: WaveAffine2D): string | null;

  tryResolveRootMatrixForView(viewId: string, out: WaveAffine2D): boolean;

  tryResolveRootPivotPoint(viewId: string | null, out: SerializableVector2): boolean;

  tryResolveRootTransformPosition(viewId: string | null, out: SerializableVector2): boolean;

  tryResolveScreenPointToRootPoint(point: WaveScreenPointRef, viewId: string | null, out: SerializableVector2): boolean;

  worldSnapshot(viewId?: string | null): WaveTransform2DFrameSnapshot;

  worldSnapshot(viewId: string | null, when: WaveTimeLookback): WaveTransform2DFrameSnapshot | null;

}

interface CollisionEvent {

  impactEnergy?: number | null;

  impactFidelity?: PhysicsImpactFidelity;

  impactMomentum?: number | null;

  impactMomentumWorld?: Vector3Like | null;

  impactSpeed?: number;

  impulse: number;

  normal: Vector3Like | null;

  other: ContactEventComponent;

  otherPartInfo?: VisualPartInfo;

  phase: CollisionPhase;

  point: Vector3Like | null;

  reducedMass?: number | null;

  relativeImpactSpeed: number;

  relativeVelocityWorld?: Vector3Like | null;

  self: ContactEventComponent;

  selfPartInfo?: VisualPartInfo;

  solverImpulse?: number;

  tangentialRelativeVelocityWorld?: Vector3Like | null;

  tangentialSpeed?: number;

}

type CollisionPhase = "begin" | "continue" | "end";

type ColorCallbackColorInput = ColorInput | ColorCallbackInput;

type ColorCallbackGradientInput = readonly number[] | ColorGradientOptions | ColorPalette | readonly ColorGradientStop[];

type ColorCallbackInput = { readonly kind: "color.callback"; readonly op: "random"; readonly seed: number; readonly colors: readonly ColorCallbackColorInput[]; } | { readonly kind: "color.callback"; readonly op: "randomFrom"; readonly seed: number; readonly colors: readonly ColorCallbackColorInput[]; } | { readonly kind: "color.callback"; readonly op: "randomSeeded"; readonly seed: number; } | { readonly kind: "color.callback"; readonly op: "randomVibrant"; readonly seed: number; readonly saturation: number; readonly value: number; } | { readonly kind: "color.callback"; readonly op: ColorCallbackRgbOp; readonly r: number; readonly g: number; readonly b: number; readonly a?: number; } | { readonly kind: "color.callback"; readonly op: "hsv"; readonly h: number; readonly s: number; readonly v: number; } | { readonly kind: "color.callback"; readonly op: "fromHexNumber"; readonly hexNumber: number; } | { readonly kind: "color.callback"; readonly op: "fromHexString"; readonly hexString: string; } | { readonly kind: "color.callback"; readonly op: ColorCallbackUnaryPercentOp; readonly color: ColorCallbackColorInput; readonly percentage: number; } | { readonly kind: "color.callback"; readonly op: "mix"; readonly from: ColorCallbackColorInput; readonly to: ColorCallbackColorInput; readonly t: number; } | { readonly kind: "color.callback"; readonly op: "withAlpha"; readonly color: ColorCallbackColorInput; readonly alpha: number; } | { readonly kind: "color.callback"; readonly op: "sampleGradient"; readonly input: ColorCallbackGradientInput; readonly position: number; }

type ColorCallbackRgbOp = "rgb" | "rgba" | "rgbNormalized" | "rgbaNormalized" | "fromNormalizedRGB";

type ColorCallbackUnaryPercentOp = "scaleRed" | "scaleGreen" | "scaleBlue" | "scaleAlpha" | "lighten" | "darken";

interface ColoredShadowConfig {

  enabled: boolean;

  isTranslucentSource?: boolean;

  resolution?: number;

  transmittedAlpha?: number;

  transmittedColor?: ColorInput;

}

interface ColorGradientOptions {

  colors: number[];

  name?: string;

}

interface ColorGradientStop {

  color: ColorInput;

  position: number;

}

interface ColorGradientStopAlpha {

  color: ColorInputAlpha;

  position: number;

}

type ColorInput = number | WaveRgbChannels;

type ColorInputAlpha = number | { r: number; g: number; b: number; a?: number; }

type ColorLike = WaveColorValueInput;

interface ColorPalette {

  colors: { r: number; g: number; b: number; }[];

  gradientStops: ColorGradientStop[];

  name: string;

}

interface CombinePartsOptions {

  entityCreation?: PartEntityCreationMode | undefined;

  materialIsolation?: PartMaterialIsolationMode | undefined;

  scope?: WaveModelPartScope | undefined;

  readonly includeInPhysics?: boolean;

  readonly name?: string;

  readonly partName?: string;

}

declare const COMBO_TILE_KIT_PRESENTATION_LOOK: Readonly<{ readonly StorybookNoon: "storybookNoon"; }>;

interface ComboTileKitBoundaryConfig {

  readonly east?: string;

  readonly north?: string;

  readonly south?: string;

  readonly west?: string;

}

interface ComboTileKitCellBiasRule {

  readonly match: ComboTileKitTileNameMatcher;

  readonly multiplier: number;

  readonly region?: ComboTileKitCellRegionConfig;

}

interface ComboTileKitCellRegionConfig {

  readonly centerDistanceMax?: number;

  readonly centerDistanceMin?: number;

  readonly colFractionMax?: number;

  readonly colFractionMin?: number;

  readonly invert?: boolean;

  readonly rowFractionMax?: number;

  readonly rowFractionMin?: number;

  readonly sineColumnBand?: ComboTileKitSineBandConfig;

  readonly sineRowBand?: ComboTileKitSineBandConfig;

}

type ComboTileKitEdgeTuple = readonly [string, string, string, string];

type ComboTileKitGrammarBiasInput = Partial<Record<ComboTileKitSemanticTag, number>>;

interface ComboTileKitGrammarConfig {

  readonly boundary?: ComboTileKitBoundaryConfig;

  readonly cellBiases?: readonly ComboTileKitCellBiasRule[];

  readonly fallbackTileName?: string;

  readonly grammarId?: string;

  readonly tiles: readonly ComboTileKitGrammarTile[];

  readonly wfcMaxAttempts?: number;

}

interface ComboTileKitGrammarTile {

  readonly edges: ComboTileKitEdgeTuple;

  readonly name: string;

  readonly weight?: number;

}

interface ComboTileKitGrammarTuningConfig {

  readonly finiteRegionBiasScale?: number;

  readonly semanticBiases?: readonly ComboTileKitSemanticBiasRule[];

}

interface ComboTileKitMaterialPolicyConfig {

  readonly alphaCutoff?: number;

  readonly atlasFlipY?: boolean;

  readonly billboardLighting?: "lit" | "unlitEmissive";

  readonly liquidColor?: string;

  readonly nearestAtlasSampling?: boolean;

}

interface ComboTileKitNamingConfig {

  readonly edgeMarkerPattern?: string;

  readonly instancePattern?: string;

  readonly tileGroupPattern?: string;

}

type ComboTileKitPresentationLook = typeof COMBO_TILE_KIT_PRESENTATION_LOOK[keyof typeof COMBO_TILE_KIT_PRESENTATION_LOOK];

interface ComboTileKitSemanticBiasRule {

  readonly multiplier: number;

  readonly tag: ComboTileKitSemanticTag;

}

interface ComboTileKitSineBandConfig {

  readonly amplitudeFraction?: number;

  readonly centerFraction: number;

  readonly frequency?: number;

  readonly radiusCells?: number;

  readonly seedScale?: number;

}

type ComboTileKitSourceConfig = WaveWorldSourceConfig<ComboTileKitSourceOptions>;

type ComboTileKitSourceInput = ComboTileKitSourceOptions | string;

interface ComboTileKitSourceOptions {

  readonly atlas?: string;

  readonly cloudNoise?: string;

  readonly grammar?: ComboTileKitGrammarConfig;

  readonly grammarTuning?: ComboTileKitGrammarTuningConfig;

  readonly manifest?: string;

  readonly materialPolicy?: ComboTileKitMaterialPolicyConfig;

  readonly model: string;

  readonly naming?: ComboTileKitNamingConfig;

  readonly tileSize?: number;

}

interface ComboTileKitTileNameMatcher {

  readonly equals?: string;

  readonly excludes?: readonly string[];

  readonly includes?: readonly string[];

}

interface ComboTileKitWorldElementInput {

  readonly id: string;

  readonly options: WaveWorldElementRecipeOptions;

}

interface ComboTileKitWorldOptions {

  readonly budgets?: WaveWorldBudgetPolicy;

  readonly cellSize?: number;

  readonly cols?: number;

  readonly comboTiles?: boolean | WaveTilemapComboConfig;

  readonly description?: string;

  readonly elements?: readonly ComboTileKitWorldElementInput[];

  readonly endless?: boolean;

  readonly grammarId?: string;

  readonly grammarTuning?: ComboTileKitGrammarTuningConfig;

  readonly grid?: Omit<WaveTilemapGridConfig, "rows" | "cols" | "cellSize">;

  readonly layerId?: string;

  readonly name?: string;

  readonly physics?: WorldStreamingPhysicsConfig;

  readonly queryPriority?: number;

  readonly renderer?: WaveTilemapRendererConfig;

  readonly required?: boolean;

  readonly rows?: number;

  readonly seed?: number;

  readonly solver?: Omit<WaveTilemapSolverConfig, "kind">;

  readonly source: ComboTileKitSourceInput | ComboTileKitSourceConfig;

  readonly streaming?: WaveWorldStreamingPolicy;

  readonly workers?: WaveWorldWorkerPolicy;

}

interface CommittedExactModelRequirement {

  readonly contentToken: string;

  readonly logicalRef: ExactAssetRef<"model">;

  readonly policy: ModelRevisionPolicy;

  readonly use: "copy" | "direct";

}

interface CommittedMediaResolution<F extends "audio" | "video" | "animation" | "data"> {

  readonly ref: ExactAssetRef<F>;

}

interface CommittedModelResolution {

  readonly policy: ModelRevisionPolicy;

  readonly ref: ExactAssetRef<"model">;

}

interface CompiledFxEmitter {

  emitterParamDefaults: Readonly<Record<string, WaveValue>>;

  emitterParamOffsets: Map<string, number>;

  emitterParamTypes: Map<string, WaveValueKind>;

  eventHandlers: Map<string, FxCompiledStack>;

  gpuProgram: FxGpuEmitterProgram | null;

  layoutOffsets: Map<string, number>;

  layoutTypes: Map<string, WaveValueKind>;

  motionPathParamOffsets: ReadonlyArray<FxMotionPathParamOffsets>;

  motionPathPlacements: ReadonlyArray<WaveFxAnchorBinding | null>;

  motionPaths: ReadonlyArray<CompiledWavePathTable>;

  particleDefaultsRecord: Float32Array;

  particleStride: number;

  renderPlan: FxRenderPlan;

  scripts: { emitterSpawn: FxCompiledStack; emitterUpdate: FxCompiledStack; particleSpawn: FxCompiledStack; particleUpdate: FxCompiledStack; }

  validated: ValidatedFxEmitter;

}

interface CompiledFxSystem {

  deterministic: boolean;

  emitters: CompiledFxEmitter[];

  reusable: boolean;

  systemParamDefaults: Readonly<Record<string, WaveValue>>;

  systemParamOffsets: Map<string, number>;

  systemParamTypes: Map<string, WaveValueKind>;

  usesControllerThrottle: boolean;

  validated: ValidatedFxSystem;

}

type CompiledMetadataAnimationTemplate = { readonly kind: "partPose"; readonly config: WavePartPoseClipConfig; readonly events: readonly WaveAnimationEventDefinition[]; } | { readonly kind: "transform"; readonly config: WaveTransformSnapshotClipConfig; readonly events: readonly WaveAnimationEventDefinition[]; }

interface CompiledProceduralAnimationTemplate {

  readonly compiledPlan: WaveGeometryGpuDeformPlan;

  readonly plan: SerializableDataValue;

  readonly planType: "gpuPathFollow" | "procedural";

}

interface CompiledSceneAssetPlanEntry {

  readonly declaration: SceneAssetPlanDeclaration;

  readonly dependencies: readonly AssetIdentity[];

  readonly driver: AssetDriver<AssetFamily, unknown>;

  readonly id: AssetIdentity;

  readonly lifetime: AssetArenaKind;

  readonly normalized?: NormalizedAssetBody;

  readonly previousSemantic?: NormalizedAssetBody;

  readonly previousSpec?: ResolvedAssetSpec;

  readonly priority: AssetPlanPriority;

  readonly reuseToken: AssetDefinition | string;

}

interface CompiledWaveModelPhysicsJointRecipe {

  readonly joint: WaveModelJointMetadata;

  readonly staticConfig: WaveJointConfig | null;

}

interface CompiledWavePathTable {

  readonly closed: boolean;

  readonly id: string;

  readonly length: number;

  readonly points: readonly Vector3Like[];

  readonly revisionKey: string;

  readonly sourceRevision?: number;

}

type ComponentConstructor<T extends WaveComponent> = Function & { readonly prototype: T; readonly name: string; readonly typeName?: string; }

type ComponentLifecycleCallback = () => void;

type ComponentLifecycleCallbackNameOrOptions = string | ComponentLifecycleCallbackOptions;

type ComponentLifecycleCallbackOptions = WaveAuthoredCallbackOptions & { name?: string; }

interface ComponentPresentationCommandStream {

  readonly active: boolean;

  dispose(): void;

  publish(args: readonly unknown[]): void;

}

interface ComponentPresentationCommandStreamConfig {

  readonly componentName: string;

  readonly maxInFlight?: number;

  readonly methodName: string;

  readonly retainLatest?: boolean;

  readonly semantics: ComponentPresentationDeliverySemantics;

  readonly target: WaveEntity;

  readonly transformSources: readonly WaveEntity[];

}

type ComponentPresentationDeliverySemantics = "replaceable-state" | "ordered-authoritative-event";

declare enum ComponentTypeName {

  Audio = "cmp_audio",

  Camera = "cmp_camera",

  Decal = "cmp_decal",

  Environment = "cmp_environment",

  FX = "cmp_fx",

  InstanceAnimator = "cmp_instanceAnimator",

  InstanceMesh = "cmp_instanceMesh",

  Interactable2D = "cmp_2dInteractable",

  Interactable3d = "cmp_3dInteractable",

  KinematicController = "cmp_kinematicController",

  Light = "cmp_light",

  ModelAnimator = "cmp_modelAnimator",

  MovementController = "cmp_movementController",

  NetworkBehavior = "cmp_networkBehavior",

  PhysicsBody = "cmp_physicsBody",

  Profile = "cmp_profile",

  Rig = "cmp_rig",

  Sensing = "cmp_sensing",

  ThinBatchTransform = "cmp_thinBatchTransform",

  ThinInstanceAnimator = "cmp_thinInstanceAnimator",

  Thinking = "cmp_thinking",

  Tool = "cmp_tool",

  Transform = "cmp_transform",

  Transform2D = "cmp_transform2D",

  TransformAnimator = "cmp_transformAnimator",

  Visual2DModel = "cmp_visual2DModel",

  Visual3DModel = "cmp_visual3DModel",

  XRAnchor = "cmp_xrAnchor",

  XRInteractable = "cmp_xrInteractable",

}

interface CompoundColliderChildConfig {

  hull?: ConvexHullGeometryData;

  localPos?: Vector3Like;

  localRot?: Vector3Like | QuaternionLike;

  size: Vector3Like;

  type: CompoundColliderChildType;

}

declare enum CompoundCollidersFromMeshesMethod {

  ConvexHull = "convexHull",

  MeshShape = "meshShape",

  Simple = "simple",

}

interface CompoundCollidersFromMeshesOptions {

  max?: number | undefined;

  method?: CompoundCollidersFromMeshesMethod | undefined;

  maxChildren?: number;

}

interface CompoundPathExtrusionProfileInput {

  holes?: PathExtrusionContourInput[];

  outer: PathExtrusionContourInput;

}

interface ConeTrailFxOpts {

  anchorOffset?: Partial<Vector3Like_2> | undefined;

  blend?: "multiply" | "alpha" | "additive" | undefined;

  color?: WaveColorValueInput | undefined;

  density?: WaveNumberValueInput | undefined;

  depthWrite?: boolean | undefined;

  direction?: FxVelocityConeDirectionInput | undefined;

  directionSpace?: VelocityConeDirectionSpace | undefined;

  drag?: WaveNumberValueInput | undefined;

  fade?: [ number, number ][] | undefined;

  glow?: FxGlowConfig | undefined;

  lifetime?: WaveNumberValueInput | undefined;

  maxPoints?: number | undefined;

  maxSegmentLength?: number | undefined;

  smoothing?: number | undefined;

  speed?: WaveNumberValueInput | undefined;

  spreadAngle?: WaveNumberValueInput | undefined;

  worldSpace?: boolean | undefined;

  diameterProfile?: [number, number][];

  radialSegments?: number;

}

interface ConeTrailOpts {

  blend?: "additive" | "alpha" | "multiply";

  depthWrite?: boolean;

  diameterOverLength?: FxValueCurveInput;

  fadeByAge?: boolean;

  glow?: FxGlowConfig;

  maxPoints?: number;

  maxSegmentLength?: number;

  radialSegments?: number;

  smoothing?: number;

  texture?: string;

  textureMode?: "stretch" | "tile" | "distanceRepeat";

  textureRepeatDistance?: number;

  worldSpace?: boolean;

}

interface ConsentReport {

  denied: SensingDevice[];

  granted: SensingDevice[];

  unsupported: string[];

}

interface ConstantForceConfig {

  contactPoint?: any;

  contactPointSpace?: ConstantForceSpace | undefined;

  enabled?: boolean | undefined;

  name?: string | undefined;

  space?: ConstantForceSpace | undefined;

  direction?: DirectionInput;

  force?: Vector3Like;

  strength?: number;

}

interface ConstantForceEntry {

  contactPoint?: Vector3Like;

  contactPointSpace?: ConstantForceSpace;

  enabled: boolean;

  force: Vector3Like;

  name: string;

  space: ConstantForceSpace;

}

interface ConstantForceOptions {

  contactPoint?: WavePointInput;

  contactPointSpace?: ConstantForceSpace;

  enabled?: boolean;

  name?: string;

  space?: ConstantForceSpace;

}

interface ConstantTorqueConfig {

  enabled?: boolean | undefined;

  name?: string | undefined;

  space?: ConstantForceSpace | undefined;

  axis?: DirectionInput;

  strength?: number;

  torque?: Vector3Like;

}

interface ConstantTorqueEntry {

  enabled: boolean;

  name: string;

  space: ConstantForceSpace;

  torque: Vector3Like;

}

interface ConstantTorqueOptions {

  enabled?: boolean;

  name?: string;

  space?: ConstantForceSpace;

}

declare enum ConstraintAxis {

  ANGULAR_X = 3,

  ANGULAR_Y = 4,

  ANGULAR_Z = 5,

  LINEAR_DISTANCE = 6,

  LINEAR_X = 0,

  LINEAR_Y = 1,

  LINEAR_Z = 2,

}

type ConstraintConfig = LockConfig | BallAndSocketConfig | HingeConfig | PrismaticConfig | SliderConfig | DistanceConfig | SixDoFConfig;

interface ConstraintConfigSnapshot {

  config: ConstraintConfig;

  id: string;

  target: PhysicsConstraintEndpoint;

}

declare enum ConstraintType {

  BallAndSocket = 1,

  Distance = 5,

  Hinge = 2,

  Lock = 0,

  Prismatic = 3,

  SixDoF = 6,

  Slider = 4,

}

type ContactEvent = CollisionEvent;

type ContactEventComponent = cmp_physicsBody | cmp_kinematicController;

interface ContactMonitorOptions {

  endGraceSubsteps?: number;

  maxContacts?: number;

  verificationDistance?: number;

}

interface ControllerConfig {

  actionScheme: ActionScheme;

  inputAdapters: InputAdapterConfig[];

  inputRegime: InputRegime;

  movement: MovementParameters;

  movementMode: MovementMode;

  movementStrategy: MovementStrategy;

  rotation: RotationParameters;

  rotationMode: RotationMode;

  touchConfig: TouchControlConfig;

}

interface ControllerIntent {

  brake?: number;

  lookDelta: SerializableVector2;

  moveDirection: SerializableVector3;

  moveIntensity: number;

  rollInput?: number;

  sequenceNumber: number;

  steerInput?: number;

  throttle?: number;

  timestamp: number;

  wantsCrouch: boolean;

  wantsJump: boolean;

  wantsSprint: boolean;

}

interface ControllerState {

  airTime: number;

  angularVelocity: SerializableVector3;

  currentSpeed: number;

  currentSpeedPercent: number;

  isCrouching: boolean;

  isFalling: boolean;

  isGrounded: boolean;

  isJumping: boolean;

  isMoving: boolean;

  isSliding: boolean;

  isSprinting: boolean;

  jumpCooldown: number;

  pitch: number;

  position: SerializableVector3;

  roll: number;

  rotation: SerializableQuaternion;

  velocity: SerializableVector3;

  yaw: number;

}

type ControlSchemaName = string;

interface ControlSphereOptions {

  duration?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  color?: unknown | string | number;

  diameter?: number;

  opacity?: number;

  radius?: number;

  segments?: number;

  wireframe?: boolean;

}

interface ConvexHullGeometryData {

  indices: number[];

  positions: number[];

}

interface CoordinateDisplayOptions {

  color?: any;

  decimals?: number | undefined;

  duration?: number | undefined;

  fontAsset?: string | undefined;

  fontSize?: number | undefined;

  labelOffset3D?: any;

  labelOffset3DSpace?: "world" | "local" | undefined;

  size?: number | undefined;

  textColor?: any;

  updateMode?: DevToolUpdateMode | undefined;

  aabbFaceCenters?: boolean | AabbFaceCenterDirection | readonly AabbFaceCenterDirection[];

  showText?: boolean;

}

interface CreateInstanceSourceOptions {

  name?: string;

}

interface CreateMeshMorphVertexAnimationOptions {

  readonly durationSeconds?: number;

  readonly easing?: MeshMorphVertexAnimationEasing;

  readonly fps?: number;

  readonly frameCount?: number;

  readonly morph?: WaveGeometryMorphOptions;

  readonly preferHalfFloat?: boolean;

  readonly range?: string;

  readonly target: WaveEntity | WaveGeometryMorphTargetInput;

  readonly targetMeshName?: string;

}

interface CreatePartsOptions {

  entityCreation?: PartEntityCreationMode;

  includeInPhysics?: boolean;

  materialIsolation?: PartMaterialIsolationMode;

  scope?: WaveModelPartScope;

}

interface CreateRoomOptions {

  maxPlayers?: number;

  roomId?: string;

}

interface CreateVertexAnimationOptions {

  readonly animation?: string;

  readonly clip?: string;

  readonly fps?: number | "source";

  readonly preferHalfFloat?: boolean;

  readonly range?: string;

  readonly ranges?: readonly VATAnimationRange[];

  readonly rootMotion?: VertexAnimationRootMotionMode;

  readonly targetMeshName?: string;

}

declare class CSGBatchBuilder {

  apply(): CSGResult;

  applyAsync(): Promise<CSGResult>;

  closeBoundaryLoops(close?: boolean): this;

  destroyTool(destroy?: boolean): this;

  forceMergeMesh(force?: boolean): this;

  intersect(operand: VisualModelBooleanInput, ...operands: VisualModelBooleanInput[]): this;

  intersectMany(operands: readonly VisualModelBooleanInput[]): this;

  intoFree3DObject(): this;

  intoFree3DObjects(): this;

  intoParts(options?: CreatePartsOptions): this;

  keepTool(): this;

  preserveMaterials(preserve?: boolean): this;

  recomputeNormals(recompute?: boolean): this;

  removeDegenerateFaces(remove?: boolean): this;

  step(step: VisualModelBooleanBatchStep): this;

  steps(steps: readonly VisualModelBooleanBatchStep[]): this;

  subtract(operand: VisualModelBooleanInput, ...operands: VisualModelBooleanInput[]): this;

  subtractMany(operands: readonly VisualModelBooleanInput[]): this;

  union(operand: VisualModelBooleanInput, ...operands: VisualModelBooleanInput[]): this;

  unionMany(operands: readonly VisualModelBooleanInput[]): this;

  weldVertices(weld?: boolean): this;

  withStrategy(strategy: WaveBooleanBatchStrategy): this;

  withWeldEpsilon(epsilon: number): this;

}

declare class CSGBuilder {

  apply(): CSGResult;

  applyAsync(): Promise<CSGResult>;

  closeBoundaryLoops(close?: boolean): this;

  destroyTool(destroy?: boolean): this;

  forceMergeMesh(force?: boolean): this;

  intoFree3DObject(): this;

  intoFree3DObjects(): this;

  intoParts(options?: CreatePartsOptions): this;

  keepTool(): this;

  preserveMaterials(preserve?: boolean): this;

  recomputeNormals(recompute?: boolean): this;

  removeDegenerateFaces(remove?: boolean): this;

  weldVertices(weld?: boolean): this;

  with(operand: VisualModelBooleanInput): this;

  withMany(operands: readonly VisualModelBooleanInput[]): this;

  withStrategy(strategy: WaveBooleanBatchStrategy): this;

  withWeldEpsilon(epsilon: number): this;

}

interface CSGPartHandle<TEntity = unknown, TPart = unknown, TEntry = unknown, TCreateOptions = CreatePartsOptions> {

  createPart?: (options?: TCreateOptions) => TEntity;

  entity?: TEntity;

  entry?: TEntry;

  info?: TPart;

  mesh?: unknown;

  promote?: () => TEntity;

}

interface CSGResult {

  error?: string;

  part?: CSGPartHandle;

  parts?: unknown[];

  resultMesh?: unknown;

  success: boolean;

  surfaceIdentityInvalidation?: WaveModelSurfaceIdentityInvalidation;

}

declare class CubeBackgroundConfigurator<TEngine extends unknown = unknown> {

  apply(): EnvironmentConfigurator<TEngine>;

  iblTexture(texture: string): this;

  at(value: Vector3Like): this;

  backgroundIntensity(intensity: number): this;

  backgroundTexture(texture: string): this;

  center(value: Vector3Like): this;

  cubeMapTexture(texture: string): this;

  iblIntensity(intensity: number): this;

  size(value: number): this;

}

interface CubeBackgroundState {

  backgroundTexture: string;

  brightness: number;

  center: Vector3Like;

  size: number;

}

declare class CubeSkyboxConfigurator<TEngine extends unknown = unknown> {

  apply(): EnvironmentConfigurator<TEngine>;

  iblTexture(texture: string): this;

  backgroundIntensity(intensity: number): this;

  backgroundTexture(texture: string): this;

  cubeMapTexture(texture: string): this;

  iblIntensity(intensity: number): this;

  size(value: number): this;

  visible(value?: boolean): this;

}

interface CubeSkyboxState {

  backgroundTexture: string;

  visibleSky: boolean;

}

type CursorDimension = number;

interface CurveModifier {

  exponent: number;

  type: ModifierType.Curve;

}

interface CurveResult {

  curvePoints: Vector3[];

  mesh: unknown;

  name: string;

}

interface CustomDirectionArrowOptions {

  arrowHeadSize?: number | undefined;

  arrowShaftThickness?: number | undefined;

  color?: any;

  duration?: number | undefined;

  length?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  offset?: number;

}

type CustomMovementCallback<TOwner extends WaveEntity = WaveEntity> = (controller: cmp_movementController<TOwner>, intent: ControllerIntent, deltaTime: number) => void;

interface CustomPostProcessOptions {

  fragmentShader: string;

  uniforms?: string[];

  uniformValues?: Record<string, CustomPostProcessUniformValue>;

}

type CustomPostProcessUniformValue = UniformValue;

declare class CutBuilder {

  apply(): CutResult;

  destroyTool(destroy?: boolean): this;

  intoFree3DObject(): this;

  intoFree3DObjects(): this;

  intoParts(options?: CreatePartsOptions): this;

  preserveMaterial(preserve?: boolean): this;

  withCapColor(color: FragInteriorColorInput): this;

  withInteriorColor(color: FragInteriorColorInput): this;

}

interface CutOptions {

  capColor?: FragInteriorColorInput;

  destroyTool?: boolean;

  interiorColor?: FragInteriorColorInput;

  preserveMaterial?: boolean;

}

interface CutResult {

  error?: string;

  inside?: CutRoleHandle;

  insideMesh?: unknown;

  originalMesh?: unknown;

  outside?: CutRoleHandle;

  outsideMesh?: unknown;

  parts?: unknown[];

  success: boolean;

}

interface CutRoleHandle<TEntity = unknown, TPart = unknown, TEntry = unknown, TCreateOptions = CreatePartsOptions> {

  createPart?: (options?: TCreateOptions) => TEntity;

  entity?: TEntity;

  entry?: TEntry;

  mesh?: unknown;

  part?: TPart;

  promote?: () => TEntity;

  role: "inside" | "outside";

}

interface CutToolLike {

  destroy?: () => void;

  model?: { getMeshes?: () => readonly unknown[]; }

}

interface DamageVignetteOptions {

  color?: ColorInput;

  intensity?: number;

  noiseStrength?: number;

  pulseAmount?: number;

  pulseSpeed?: number;

  radius?: number;

  softness?: number;

}

type DataPayload = (Readonly<{ readonly encoding: "structured"; readonly value: SerializableDataValue; }> | Readonly<{ readonly encoding: "base64"; readonly value: string; }>) & Readonly<{ readonly source?: DataSourceIdentity; }>;

type DataSourceIdentity = Readonly<Record<string, SerializableDataValue>>;

interface DeadZoneModifier {

  inner: number;

  outer: number;

  type: ModifierType.DeadZone;

}

type DecalBlendMode = "alpha" | "multiply" | "additive";

interface DecalBuilder {

  at(surfacePoint: DecalSurfacePointLike): this;

  at(pointSource: WavePointSource): this;

  atLocal(position: Vector3Like): this;

  atLocal(x: number, y: number, z: number): this;

  atWorld(position: Vector3Like): this;

  atWorld(position: Vector3Like, normal: Vector3Like): this;

  atWorld(x: number, y: number, z: number): this;

  direction(direction: DirectionInput): this;

  paint(): waveDecal;

  sized(width: number, height: number): this;

  surface(surface: WaveSurface): this;

  useMask(mask: DecalProceduralMask): this;

  withDepth(depth: number): this;

  withMaskFeather(value: number): this;

  withNormal(normal: Vector3Like): this;

  withPriority(priority: number): this;

}

type DecalMaskMode = "rectangular" | "circular";

type DecalMaterialAnimatedScalar = "opacity" | "glowIntensity" | "uvRotation";

type DecalMaterialBlendMode = "normal" | "multiply" | "additive";

interface DecalMaterialEditorHost {

  animateScalar(property: DecalMaterialAnimatedScalar, target: number): WaveMaterialPropertyAnimationBuilder;

  disableGlow(): void;

  enableGlow(intensity?: number, color?: ColorInput | null): void;

  setAngleFade(degrees: number): void;

  setBaseTexture(texturePath: string): void;

  setBlendMode(mode: DecalMaterialBlendMode): void;

  setColor(color: ColorInput): void;

  setEmissiveColor(color: ColorInput | null): void;

  setEmissiveIntensity(intensity: number): void;

  setGlowColor(color: ColorInput | null): void;

  setGlowIntensity(intensity: number): void;

  setMetalness(multiplier: number): void;

  setNormalBlendMode(mode: DecalMaterialNormalBlendMode): void;

  setNormalTexture(texturePath: string): void;

  setOpacity(value: number): void;

  setPriority(priority: number): void;

  setRoughness(multiplier: number): void;

  setTextures(textures: DecalMaterialTextureSet): void;

  setUVOffset(x: number, y: number): void;

  setUVRotation(degrees: number): void;

}

declare class DecalMaterialEditorView {

  constructor(_host: DecalMaterialEditorHost);

  disableGlow(): this;

  enableGlow(intensity?: number, color?: ColorInput | null): this;

  glow(intensity: number, color?: ColorInput | null): this;

  setAngleFade(degrees: number): this;

  setBaseTexture(texturePath: string): this;

  setBlendMode(mode: DecalMaterialBlendMode): this;

  setColor(color: ColorInput): this;

  setEmissiveColor(color: ColorInput | null): this;

  setEmissiveIntensity(intensity: number): this;

  setGlowColor(color: ColorInput | null): this;

  setGlowIntensity(intensity: number): this;

  setGlowIntensity(intensity: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setMetalness(multiplier: number): this;

  setNormalBlendMode(mode: DecalMaterialNormalBlendMode): this;

  setNormalTexture(texturePath: string): this;

  setOpacity(value: number): this;

  setOpacity(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setPriority(priority: number): this;

  setRoughness(multiplier: number): this;

  setTextures(textures: DecalMaterialTextureSet): this;

  setUVOffset(x: number, y: number): this;

  setUVRotation(degrees: number): this;

  setUVRotation(degrees: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

}

type DecalMaterialNormalBlendMode = "override" | "blend";

interface DecalMaterialTextureSet {

  albedo?: string;

  normal?: string;

}

type DecalNormalBlendMode = "override" | "blend";

interface DecalOptions {

  albedoTexture?: string;

  albedoTint?: ColorInput;

  angleFade?: number;

  blendMode?: DecalBlendMode;

  emissiveIntensity?: number;

  glowColor?: ColorInput;

  height?: number;

  layerMask?: number;

  length?: number;

  mask?: DecalMaskMode;

  maskFeather?: number;

  metallicMultiplier?: number;

  normalBlendMode?: DecalNormalBlendMode;

  normalTexture?: string;

  opacity?: number;

  priority?: number;

  roughnessMultiplier?: number;

  uvOffset?: { x: number; y: number; }

  uvRotation?: number;

  width?: number;

}

type DecalProceduralMask = "rectangular" | "circular";

interface DecalSurfaceNormalLike {

  hitNormal?: Vector3Like;

  worldHitNormal?: Vector3Like;

}

type DecalSurfacePointLike = DecalSurfaceNormalLike & ({ hitPoint: Vector3Like; worldHitLocation?: Vector3Like; } | { hitPoint?: Vector3Like; worldHitLocation: Vector3Like; });

declare enum DeformApplyMode {

  Absolute = "absolute",

  Accumulate = "accumulate",

  Delta = "delta",

}

interface DelayedActionSurface<TEntity extends object> {

  atChanceOf(probability: number): DelayedEntityProxy<TEntity>;

  do(callback: (entity: TEntity) => void): TEntity;

}

type DelayedEntityProxy<TEntity extends object> = TEntity & DelayedActionSurface<TEntity>;

interface DepthOfFieldOptions {

  blurLevel?: unknown;

  focalLength?: number;

  focusDistance?: number;

  fStop?: number;

  lensSize?: number;

}

type DetectionFilter = (hit: unknown) => boolean;

interface DetectionHit {

  entityId: number;

  entryDistance: number;

  entryNormal: SerializableVector3;

  entryPoint: SerializableVector3;

  exitDistance: number | null;

  exitNormal: SerializableVector3 | null;

  exitPoint: SerializableVector3 | null;

  tagMask: bigint;

  thinBatchIndex: number;

}

interface DetectionResult {

  closest: DetectionHit | null;

  count: number;

  hasHits: boolean;

  hits: DetectionHit[];

}

interface DevToolTextOptions {

  duration?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  decimals?: number;

  fontAsset?: string;

  fontSize?: number;

  labelOffset3D?: Vector3 | Vector3Like;

  labelOffset3DSpace?: "world" | "local";

  textColor?: unknown | string | number;

}

type DevToolUpdateMode = "live" | "snapshot";

interface DimensionArrowOptions {

  decimals?: number | undefined;

  duration?: number | undefined;

  fontAsset?: string | undefined;

  fontSize?: number | undefined;

  labelOffset3D?: any;

  labelOffset3DSpace?: "world" | "local" | undefined;

  textColor?: any;

  updateMode?: DevToolUpdateMode | undefined;

  arrowHeadSize?: number;

  arrowShaftThickness?: number;

  axes?: DimensionAxis[];

  axisColors?: Partial<Record<DimensionAxis, unknown | string | number>>;

  color?: unknown | string | number;

  labelOffset?: number;

  unit?: string;

}

type DimensionAxis = "x" | "y" | "z";

interface DirectionalScaleLocalBounds {

  centerLocal: Vector3;

  halfExtentsLocal: Vector3;

}

interface DirectionAndAxisArrowOptions {

  arrowHeadSize?: number | undefined;

  arrowShaftThickness?: number | undefined;

  color?: any;

  duration?: number | undefined;

  length?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  directions?: Direction[];

  labelFontSize?: number;

  labelOffset3D?: Vector3 | Vector3Like;

  labelOffset3DSpace?: "world" | "local";

  offset?: number;

  showLabels?: boolean;

}

interface DirectionArrowOptions {

  arrowHeadSize?: number | undefined;

  arrowShaftThickness?: number | undefined;

  color?: any;

  duration?: number | undefined;

  length?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  directions?: Direction[];

  labelFontSize?: number;

  labelOffset3D?: Vector3 | Vector3Like;

  labelOffset3DSpace?: "world" | "local";

  offset?: number;

  origin?: "anchor" | "pivot";

  showLabels?: boolean;

}

interface DirectionBasisConfig {

  forward?: { vector: Vector3Like; space: WaveSpace; }

  up?: { vector: Vector3Like; space: WaveSpace; }

}

interface DirectionBasisConfig {

  forward?: DirectionBasisConfigEntry;

  up?: DirectionBasisConfigEntry;

}

interface DirectionBasisConfigEntry {

  space: DirectionBasisConfigSpace;

  vector: Vector3Like;

}

type DirectionBasisConfigSpace = "world" | "parent";

type DirectionInput = Direction | DirectionVector;

type DirectionVector = Readonly<SerializableVector3>;

interface DisablePhysicsOptions {

  clearDeferredOps?: boolean;

  clearPendingRebuild?: boolean;

  preserveConstraintConfig?: boolean;

  reason?: PhysicsParticipationDisableReason;

  snapshotMotion?: boolean;

}

declare class DisplaceBuilder {

  animate(): WaveGeometryDeformAnimationBuilder;

  apply(): MeshEditResult;

  atCenters(centers: readonly Vector3Like[], radius: number): this;

  flowingToward(direction: DirectionInput): this;

  forceMergeMesh(force?: boolean): this;

  inDirection(direction: DirectionInput): this;

  randomizeSeed(randomize?: boolean): this;

  withAmplitude(amplitude: number): this;

  withFalloff(falloff: "smooth" | "linear" | "sharp" | "gaussian"): this;

  withFrequency(frequency: number): this;

  withSeed(seed: number): this;

  withTurbulence(enabled?: boolean): this;

}

interface DistanceArrowOptions {

  arrowHeadSize?: number | undefined;

  arrowShaftThickness?: number | undefined;

  color?: any;

  decimals?: number | undefined;

  duration?: number | undefined;

  fontAsset?: string | undefined;

  fontSize?: number | undefined;

  labelOffset3D?: any;

  labelOffset3DSpace?: "world" | "local" | undefined;

  length?: number | undefined;

  textColor?: any;

  updateMode?: DevToolUpdateMode | undefined;

  unit?: string;

  useBoundingBox?: boolean;

}

interface DistanceConfig {

  axisA?: DirectionInput | undefined;

  axisB?: DirectionInput | undefined;

  enableCollisions?: boolean | undefined;

  limits?: AxisLimit[] | undefined;

  motors?: MotorConfig[] | undefined;

  perpAxisA?: DirectionInput | undefined;

  perpAxisB?: DirectionInput | undefined;

  pivotA?: any;

  pivotB?: any;

  maxDistance?: number;

  minDistance?: number;

  spring?: SpringConfig;

  type: ConstraintType.Distance;

}

type DistanceEntityTarget = WaveEntity & WaveSpatial3DEntity;

interface DistanceFieldBounds3D {

  readonly max: Vector3Like;

  readonly min: Vector3Like;

}

type DistanceFieldGradient = Readonly<SerializableVector3>;

type DistanceFieldGradientSampler3D = (x: number, y: number, z: number) => DistanceFieldGradient;

type DistanceFieldSampler3D = (x: number, y: number, z: number) => number;

type DistanceFieldUnits3D = "world" | "local";

type DistanceTarget = DistanceEntityTarget | cmp_light | cmp_camera;

declare const DOUBLE_SIDED_HEIGHTFIELD_PARTS: Readonly<{ readonly topSurface: "double_side_heightfield_top_surface"; readonly bottomSurface: "double_side_heightfield_bottom_surface"; }>;

declare class DrawBetweenBuilder {

  avoid(obstacles: WavePathRangeInputSet, options?: WavePathAvoidOptions): this;

  constrainedBy(guidePath: wavePath, maxDrift?: number): this;

  create(): wavePath;

  stayWithin(bounds: WavePathRangeInputSet, options?: WavePathRangeConstraintOptions): this;

  throughWaypoints(waypoints: PathPointInput | ReadonlyArray<PathPointInput>): this;

  toInput(): WavePathDrawBetweenInput;

  toRuntimeBindings(): WavePathDrawBetweenRuntimeBindings;

  withDrift(drift: number): this;

  withSeed(seed: number): this;

  withSubdivisions(n: number): this;

}

interface DrawBetweenCommonOptions {

  readonly avoid?: ReadonlyArray<WavePathDrawBetweenRangeRecipe>;

  readonly drift?: number;

  readonly seed?: number;

  readonly stayWithin?: ReadonlyArray<WavePathDrawBetweenRangeRecipe>;

  readonly subdivisions?: number;

}

type DrawBetweenOptions = DrawBetweenCommonOptions & ({ readonly waypoints: ReadonlyArray<WavePathDrawBetweenPointRecipe>; readonly constraintPath?: never; readonly maxDrift?: never; } | { readonly waypoints?: never; readonly constraintPath: WavePathDrawBetweenBindingSlot; readonly maxDrift?: number; } | { readonly waypoints?: never; readonly constraintPath?: never; readonly maxDrift?: never; });

interface ElevenLabsTTSConfig {

  allowClientDirect?: boolean;

  baseUrl?: string;

  clientAccessMode?: HttpAccessMode;

  defaultModelId?: string;

  defaultOutputFormat?: string;

  defaultVoiceId: string;

  defaultVoiceSettings?: ElevenLabsVoiceSettings;

  endpointId?: string;

  makeDefaultHttpEndpoint?: boolean;

}

interface ElevenLabsVoiceSettings {

  similarityBoost?: number;

  stability?: number;

  style?: number;

  useSpeakerBoost?: boolean;

}

declare class EmissiveDistortionBuilder {

  constructor(_host: VisualEmissiveDistortionHost);

  apply(): EmissiveDistortionHandle;

  withRipple(config?: EmissiveDistortionRippleConfig): this;

  withWobble(config?: EmissiveDistortionWobbleConfig): this;

}

interface EmissiveDistortionConfig {

  readonly ripple?: EmissiveDistortionRippleConfig;

  readonly wobble?: EmissiveDistortionWobbleConfig;

}

declare class EmissiveDistortionHandle {

  constructor(_host: VisualEmissiveDistortionHost);

  clear(): this;

  setWobbleInput(x: number, y: number): this;

  triggerRipple(u?: number, v?: number, strength?: number): this;

}

interface EmissiveDistortionRippleConfig {

  frequency?: number;

  maxDisplacement?: number;

  propagationSpeed?: number;

  spatialDecay?: number;

  temporalDecay?: number;

}

interface EmissiveDistortionWobbleConfig {

  frequency?: number;

  maxDisplacement?: number;

  smoothing?: number;

  speed?: number;

}

interface EmitterBindingOpts {

  anchor?: WaveFxAnchorBinding;

  emitterParams?: Record<string, FxValue>;

  enabled?: FxBoolExpr;

}

type EnabledEnvironmentPatch<TState extends { enabled: boolean; }> = Partial<Omit<TState, "enabled">>;

interface EnablePhysicsOptions {

  forceImmediateMaterialization?: boolean;

  restoreMotion?: PhysicsParticipationRestoreMotion;

  wakeUp?: boolean;

}

type EndEffectorIntent = { readonly kind: "moveTo"; readonly endEffector: string; readonly target: TransformReferenceLike | WavePointInput; readonly terms: WaveTransformTermsSpace; } | { readonly kind: "moveBy"; readonly endEffector: string; readonly delta: Vector3Like; readonly terms: WaveTransformTermsSpace; } | { readonly kind: "moveByDirection"; readonly endEffector: string; readonly axis: DirectionInput; readonly scope: TransformVerbScope; readonly distance?: number; } | { readonly kind: "rotateTo"; readonly endEffector: string; readonly rotation: Quaternion; readonly terms: WaveTransformTermsSpace; } | { readonly kind: "rotateAround"; readonly endEffector: string; readonly axis: DirectionInput; readonly scope: TransformVerbScope; readonly deltaDegrees?: number; readonly targetDegrees?: number; }

declare const ENGINE_SYSTEM_CONTRACTS: Readonly<{ network: EngineSystemContract<unknown, never>; signalInput: EngineSystemContract<unknown, never>; inputAction: EngineSystemContract<unknown, never>; moving: EngineSystemContract<unknown, never>; physics: EngineSystemContract<unknown, never>; rendering: EngineSystemContract<unknown, never>; media: EngineSystemContract<unknown, never>; animation: EngineSystemContract<unknown, never>; thinking: EngineSystemContract<unknown, never>; fx: EngineSystemContract<unknown, never>; terrain: EngineSystemContract<unknown, "worldStreaming">; worldStreaming: EngineSystemContract<unknown, never>; }>;

interface EngineInitializationOptions {

  renderProfile?: WaveRenderProfile;

}

type EngineLocalConfig = Omit<BaseEngineConfig, "profile">;

type EngineP2PHostConfig = Omit<BaseEngineConfig, "profile" | "networkTransport"> & Readonly<{ networkTransport: Exclude<NetworkTransport, "none">; }>;

declare enum EngineStage {

  ASSETS_LOADED = "ASSETS_LOADED",

  CONSTRUCTED = "CONSTRUCTED",

  DISPOSED = "DISPOSED",

  ENGINESCENE_READY = "RENDERING_READY",

  NETWORK_CONNECTED = "NETWORK_CONNECTED",

  RUNNING = "RUNNING",

  SCENE_READY = "SCENE_READY",

  STOPPED = "STOPPED",

  STOPPING = "STOPPING",

  SYSTEMS_INITIALIZED = "SYSTEMS_INITIALIZED",

}

type EngineSystemBootstrapPhase = "preScene" | "scene";

interface EngineSystemContract<TSystem extends unknown, TDependency extends string = string> {

  readonly dependencies: readonly TDependency[];

  readonly label: string;

  readonly load: () => Promise<unknown>;

  readonly phase: EngineSystemBootstrapPhase;

  readonly systemType?: TSystem;

}

type EngineSystemType<TContract> = TContract extends EngineSystemContract<infer TSystem> ? TSystem : never;

type EngineThinClientConfig = Omit<BaseEngineConfig, "profile" | "networkTransport"> & Readonly<{ networkTransport: Exclude<NetworkTransport, "none">; }>;

type EntityBehaviorCallback<TEntity extends WaveEntity<unknown>> = { bivarianceHack(entity: TEntity): void; }["bivarianceHack"];

type EntityBooleanSelector<TEntity extends WaveEntity<unknown>> = { bivarianceHack(entity: TEntity): boolean; }["bivarianceHack"];

type EntityLifecycleCallback<TEntity extends WaveEntity<unknown> = WaveEntity<unknown>> = BivariantCallback<[entity: TEntity], void>;

type EntityLifecycleCallbackNameOrOptions = string | EntityLifecycleCallbackOptions;

type EntityLifecycleCallbackOptions = WaveAuthoredCallbackOptions & { name?: string; }

type EntityNumericSelector<TEntity extends WaveEntity<unknown>> = { bivarianceHack(entity: TEntity): number; }["bivarianceHack"];

interface EntityStateApi<TEntity extends object, TState> {

  readonly current: TState | null;

  history(): readonly TState[];

  in(state: TState): boolean;

  inAny(...states: TState[]): boolean;

  offEnter(state: TState, callback: (target: TEntity) => void): boolean;

  offExit(state: TState, callback: (target: TEntity) => void): boolean;

  onEnter(state: TState, callback: (target: TEntity) => void): TEntity;

  onExit(state: TState, callback: (target: TEntity) => void): TEntity;

  readonly previous: TState | null;

  timeInCurrentState(): WaveTimeSpan;

  timesEnteredIn(state: TState, value: number, unit: WaveTimeUnit): number;

  timesEnteredIn(state: TState, within: WaveTimeLookback): number;

  timesExitedIn(state: TState, value: number, unit: WaveTimeUnit): number;

  timesExitedIn(state: TState, within: WaveTimeLookback): number;

  totalTimeIn(state: TState): number;

  whenIn(...args: [ TState ] | [ TState, (target: TEntity) => void, (WaveTimeRule | undefined)? ]): TEntity | WaveScopedObservationBuilder<TEntity, TState>;

  blockEnterFor(state: TState, duration: WaveTimeSpan): TEntity;

  blockEnterFor(state: TState, value: number, unit: WaveTimeUnit): TEntity;

  blockExitFor(state: TState, duration: WaveTimeSpan): TEntity;

  blockExitFor(state: TState, value: number, unit: WaveTimeUnit): TEntity;

  cycle(...states: TState[]): CycleController<TEntity, TState>;

  enter(state: TState): TEntity;

  exit(): TEntity;

  goBackBy(steps: number): TEntity;

  isEnterBlocked(state: TState): boolean;

  isExitBlocked(state: TState): boolean;

  toggle(stateA: TState, stateB: TState): ToggleController<TEntity, TState>;

  unblockEnter(state: TState): TEntity;

  unblockExit(state: TState): TEntity;

}

type EntityStateCallback<TEntity extends object> = { bivarianceHack(target: TEntity): void; }["bivarianceHack"];

interface EntityStateControllerHost<TEntity extends object, TState> {

  readonly currentState: unknown | null;

  enterState(state: TState): TEntity;

  readonly isDestroyed: boolean;

  onEnter(state: TState, callback: EntityStateCallback<TEntity>): TEntity;

}

declare enum EntityType {

  net2DObject = "net2DObject",

  net3DObject = "net3DObject",

  netActor = "netActor",

  netCamera = "netCamera",

  netCapsule = "netCapsule",

  netCavity = "netCavity",

  netCone = "netCone",

  netCube = "netCube",

  netCylinder = "netCylinder",

  netDecal = "netDecal",

  netDisc = "netDisc",

  netHumanoid = "netHumanoid",

  netInstanceMesh = "netInstanceMesh",

  netKinematicActor = "netKinematicActor",

  netLathe = "netLathe",

  netLight = "netLight",

  netObject = "netObject",

  netPath = "netPath",

  netPlane = "netPlane",

  netPoint = "netPoint",

  netPolygon = "netPolygon",

  netProp = "netProp",

  netSceneRoot = "netSceneRoot",

  netSphere = "netSphere",

  netTorus = "netTorus",

  netTorusKnot = "netTorusKnot",

  netWedge = "netWedge",

  netXR3DObject = "netXR3DObject",

  netXRActor = "netXRActor",

  netXRProp = "netXRProp",

  wave2DObject = "wave2DObject",

  wave3DObject = "wave3DObject",

  waveActor = "waveActor",

  waveBoneHandle = "waveBoneHandle",

  waveCamera = "waveCamera",

  waveCapsule = "waveCapsule",

  waveCavity = "waveCavity",

  waveCone = "waveCone",

  waveCube = "waveCube",

  waveCylinder = "waveCylinder",

  waveDecal = "waveDecal",

  waveDisc = "waveDisc",

  waveGeometry = "waveGeometry",

  waveHumanoid = "waveHumanoid",

  waveInstanceMesh = "waveInstanceMesh",

  waveKinematicActor = "waveKinematicActor",

  waveLathe = "waveLathe",

  waveLight = "waveLight",

  waveMarker = "waveMarker",

  WaveObject = "WaveObject",

  wavePath = "wavePath",

  wavePathExtrusion = "wavePathExtrusion",

  wavePathSurface = "wavePathSurface",

  wavePlane = "wavePlane",

  wavePoint = "wavePoint",

  wavePointNet = "wavePointNet",

  wavePolygon = "wavePolygon",

  waveProp = "waveProp",

  waveSceneDirector = "waveSceneDirector",

  waveSceneRoot = "waveSceneRoot",

  waveSphere = "waveSphere",

  waveTerrainTile = "waveTerrainTile",

  waveTextBatch = "waveTextBatch",

  waveThinBatch = "waveThinBatch",

  waveTorus = "waveTorus",

  waveTorusKnot = "waveTorusKnot",

  waveUIButton = "waveUIButton",

  waveUICanvas = "waveUICanvas",

  waveUICrosshair = "waveUICrosshair",

  waveUIDebugOverlay = "waveUIDebugOverlay",

  waveUIDropdown = "waveUIDropdown",

  waveUIHandGestureOverlay = "waveUIHandGestureOverlay",

  waveUIImage = "waveUIImage",

  waveUIInventory = "waveUIInventory",

  waveUIMinimap = "waveUIMinimap",

  waveUINotification = "waveUINotification",

  waveUIPanel = "waveUIPanel",

  waveUIProgressBar = "waveUIProgressBar",

  waveUIProgressRing = "waveUIProgressRing",

  waveUISlider = "waveUISlider",

  waveUIText = "waveUIText",

  waveUITextArea = "waveUITextArea",

  waveUITextInput = "waveUITextInput",

  waveUIToggle = "waveUIToggle",

  waveUITooltip = "waveUITooltip",

  waveWedge = "waveWedge",

  xr3DObject = "xr3DObject",

  xrActor = "xrActor",

  xrProp = "xrProp",

}

declare class EnvironmentConfigurator<TEngine extends unknown = unknown> {

  constructor(_scene: WaveScene<TEngine>);

  backgroundColor(color: ColorInput): WaveScene<TEngine>;

  cubeBackground(): CubeBackgroundConfigurator<TEngine>;

  cubeSkybox(): CubeSkyboxConfigurator<TEngine>;

  skybox(): EnvironmentSkyboxConfigurator<TEngine>;

}

declare class EnvironmentSkyboxConfigurator<TEngine extends unknown = unknown> {

  apply(): EnvironmentConfigurator<TEngine>;

  iblIntensity(intensity: number): this;

  iblTexture(texture: string): this;

  alpha(value: number): this;

  backgroundColor(color: ColorInput): this;

  backgroundIntensity(intensity: number): this;

  backgroundTexture(texture: string): this;

  fovMultiplier(value: number): this;

  rotation(value: number): this;

  size(value: number): this;

  skyboxIntensity(intensity: number): this;

  skyboxTexture(texture: string): this;

}

interface EnvironmentState {

  ambient: AmbientState;

  aurora?: AuroraState;

  backgroundColor: number;

  celestialBodies?: CelestialBodyState[];

  cubeBackground?: CubeBackgroundState;

  cubeSkybox?: CubeSkyboxState;

  environmentIntensity: number;

  fog: FogState;

  globalIllumination: GlobalIlluminationState;

  ibl: IBLState;

  mainLight: MainLightState;

  physicalAtmosphere?: PhysicalAtmosphereState;

  proceduralSky?: ProceduralSkyState;

  skybox: SkyboxState;

  starField?: StarFieldState;

  timeOfDay?: TimeOfDayState;

  volumetricClouds?: VolumetricCloudState;

  volumetricFog?: VolumetricFogState;

}

type EventHandler = (...args: unknown[]) => void;

interface ExactAssetRef<F extends AssetFamily = AssetFamily> {

  readonly identity: AssetIdentity<F>;

  readonly revision: AssetRevisionId;

  readonly revisionKey: AssetRevisionKey;

}

interface ExhaustOpts {

  anchorOffset?: Partial<Vector3Like>;

  billboard?: SpriteOpts["billboard"];

  blend?: SpriteOpts["blend"];

  color?: ColorLike;

  density?: NumLike;

  direction?: FxVelocityConeDirectionInput;

  directionSpace?: VelocityConeDirectionSpace;

  drag?: NumLike;

  fade?: [number, number][];

  glow?: SpriteOpts["glow"];

  growth?: [number, number][];

  lifetime?: NumLike;

  size?: NumLike;

  softness?: "tight" | "balanced" | "billowy";

  sort?: SpriteOpts["sort"];

  speed?: NumLike;

  spin?: boolean | NumLike;

  spreadAngle?: NumLike;

  texture: string;

}

declare class ExplodeBuilder {

  apply(): WaveGroup<wave3DObject> | null;

  applyAsync(): Promise<WaveGroup<wave3DObject> | null>;

  atLocalPosition(x: number, y: number, z: number): this;

  atPosition(position: WavePointInput): this;

  atPosition(x: number, y: number, z: number): this;

  avoidFragmentCollisions(avoid?: boolean): this;

  enablePhysics(enable?: boolean): this;

  forceMergeMesh(force?: boolean): this;

  ignoreGravity(ignore?: boolean): this;

  intoPieces(count: number): this;

  showColliders(show?: boolean | ColorInput): this;

  withFragmentCollider(collider: ExplodeFragmentCollider): this;

  withInteriorColor(color: FragInteriorColorInput): this;

  withLifeTime(duration: WaveTimeSpan): this;

  withLifeTime(value: number, unit: WaveTimeUnit): this;

  withPhysicalClusters(maxPhysicalClusters: number): this;

  withSeed(seed: number): this;

  withStrength(impulse: number): this;

}

type ExplodeFragmentCollider = "box" | "convexHull";

interface ExplodeOptions {

  avoidFragmentCollisions?: boolean;

  count?: number;

  enableGravity?: boolean;

  enablePhysics?: boolean;

  force?: boolean;

  fragmentCollider?: ExplodeFragmentCollider;

  impulseStrength?: number;

  interiorColor?: FragInteriorColorInput;

  lifeTime?: WaveTimeSpan;

  localOrigin?: Vector3Like;

  maxPhysicalClusters?: number;

  seed?: number;

  showColliders?: boolean | ColorInput;

  worldOrigin?: WavePointInput;

}

interface ExposedParamOpts {

  clamp?: FxUserParamSchema["clamp"];

  replicate?: FxUserParamSchema["replicate"];

}

interface ExtractPartsOptions {

  readonly cloneName?: string;

  readonly includeInPhysics?: boolean;

  readonly materialIsolation?: PartMaterialIsolationMode;

  readonly mode: WaveModelPartExtractionMode;

  readonly name?: string;

  readonly partName?: string;

  readonly source?: wave3DObject;

}

declare class ExtrudeBuilder {

  along(axis: DirectionInput): this;

  animate(): WaveGeometryDeformAnimationBuilder;

  apply(): MeshEditResult;

  atCenter(center: WavePointInput): this;

  axisMode(): this;

  forceMergeMesh(force?: boolean): this;

  inDirection(dir: DirectionInput): this;

  inRegion(start: number, end: number): this;

  mode(mode: DeformApplyMode): this;

  pointMode(): this;

  regionEnd(pos: number): this;

  regionStart(pos: number): this;

  withFalloff(falloff: ExtrudeFalloff): this;

  withRadius(r: number): this;

  withStrength(s: number): this;

}

type ExtrudeFalloff = "linear" | "smooth" | "sharp" | "flat" | "gaussian";

type ExtrudeMode = "point" | "axis";

interface ExtrudeOptions {

  applyMode?: DeformApplyMode;

  axis?: DirectionInput;

  center?: Vector3;

  direction?: DirectionInput;

  endPos?: number;

  falloff?: ExtrudeFalloff;

  mode?: ExtrudeMode;

  radius?: number;

  startPos?: number;

  strength: number;

}

interface FacetypeFontBindingValue {

  readonly data: SerializableFacetypeFontData;

  readonly kind: "facetype";

  readonly ref: ExactAssetRef<"font">;

}

type FacetypeFontDefinitionInput = SerializableFacetypeFontData;

type FieldOwner = object;

type FitBetweenAxis = "auto" | DirectionInput;

declare class FitBetweenBuilder<T extends wave3DAbstract = wave3DAbstract> {

  along(axis: FitBetweenAxis): this;

  apply(): T;

  autoResize(enable?: boolean): this;

  between(start: FitBetweenPoint, end: FitBetweenPoint): this;

  centered(): this;

  from(start: FitBetweenPoint): this;

  fromEnd(): this;

  fromStart(): this;

  keepFitted(): T;

  to(end: FitBetweenPoint): this;

  withoutResize(): this;

}

type FitBetweenIntent = Extract<TransformVerbIntent, { kind: "fitBetween"; }>;

interface FitBetweenOptions {

  autoResize?: boolean;

  axis?: FitBetweenAxis;

  placement?: FitBetweenPlacement;

}

type FitBetweenPlacement = WaveTransformFitPlacement;

type FitBetweenPoint = WavePointInput | wave3DAbstract;

type FitBetweenTarget = TransformReferenceLike | WavePointInput;

declare class FlexBuilder {

  animate(): WaveGeometryDeformAnimationBuilder;

  inSpace(space: "model" | "world"): this;

  rootedAt(position: number): this;

  toward(direction: DirectionInput): this;

  withAttenuation(attenuation: number): this;

  withReferenceSize(referenceSize: number): this;

  withStrength(strength: number): this;

}

interface FluentPalette {

  colors: { r: number; g: number; b: number; }[];

  gradientStops: ColorGradientStop[];

  name: string;

  darken(amount: number): FluentPalette;

  lighten(amount: number): FluentPalette;

}

declare class FogConfigurator<TEngine extends unknown = unknown> {

  apply(): WaveScene<TEngine>;

  apply(patch: Partial<WaveSceneFogConfig>): WaveScene<TEngine>;

  asExponential(): FogConfigurator<TEngine>;

  asExponentialSquared(): FogConfigurator<TEngine>;

  asLinear(): FogConfigurator<TEngine>;

  color(color: ColorInput): FogConfigurator<TEngine>;

  density(val: number): FogConfigurator<TEngine>;

  disable(): FogConfigurator<TEngine>;

  disableStreamingWorld(): FogConfigurator<TEngine>;

  end(val: number): FogConfigurator<TEngine>;

  exp(): FogConfigurator<TEngine>;

  exp2(): FogConfigurator<TEngine>;

  followStreamingWorld(policy?: Partial<Omit<WaveStreamingFogPolicy, "enabled">>): FogConfigurator<TEngine>;

  linear(): FogConfigurator<TEngine>;

  mode(mode: FogMode): FogConfigurator<TEngine>;

  off(): FogConfigurator<TEngine>;

  start(val: number): FogConfigurator<TEngine>;

  streamingWorld(policy?: Partial<Omit<WaveStreamingFogPolicy, "enabled">>): FogConfigurator<TEngine>;

}

declare enum FogMode {

  EXP = 1,

  EXP2 = 2,

  LINEAR = 3,

  NONE = 0,

}

interface FogState {

  color: number;

  density: number;

  end: number;

  mode: FogMode;

  start: number;

  streaming?: WaveStreamingFogPolicy;

}

type FollowConstraint = WavePlane | Direction | null;

type FollowPathFrameIntent = { readonly kind: "path"; readonly path: FollowPathSource; } | { readonly kind: "world"; }

interface FollowPathLike {

  frameAtProgress(progress: number, options?: PathFrameOptions): PathFrame;

  frameAtProgressToRef?(progress: number, result: PathFrame, options?: PathFrameOptions): PathFrame;

  length(options?: { readonly space?: "world" | "local"; }): number;

  projectPoint(point: Vector3): { progress: number; }

}

type FollowPathOffsetAmountInput = WaveValueCurveInput;

interface FollowPathOffsetIntent {

  readonly amount: FollowPathOffsetAmountInput;

  readonly direction: DirectionInput;

  readonly frame: FollowPathFrameIntent;

}

interface FollowPathOptions {

  byLocking?: DirectionInput | undefined;

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  withTolerance?: number | undefined;

  callbacks?: TransitionLifecycleCallbacks<FollowPathState>;

  direction?: "forward" | "backward";

  ease?: WaveEasing;

  faceTarget?: TransformReferenceLike | WavePointInput;

  laps?: number;

  lookAheadProgress?: number;

  maxTurnDegreesPerSecond?: number;

  offsets?: readonly FollowPathOffsetIntent[];

  orientation?: Extract<PathOrientationMode, "upright" | "pathNormal">;

  rotationOffsets?: readonly FollowPathRotationOffsetIntent[];

  speedByProgress?: WaveMotionSpeedInput;

  startPaused?: boolean;

  timeScale?: number;

  turnToFace?: boolean;

  upVector?: Vector3Like;

}

declare class FollowPathPlaybackHandle extends TransitionLifecycleHandle<FollowPathState, FollowPathSource> {

  setOffsetAlong(direction: DirectionInput, amount: FollowPathOffsetAmountInput): this;

}

type FollowPathRotationDegreesInput = WaveValueCurveInput;

interface FollowPathRotationOffsetIntent {

  readonly axis: DirectionInput;

  readonly degrees: FollowPathRotationDegreesInput;

  readonly frame: FollowPathFrameIntent;

}

type FollowPathSource = readonly Vector3[] | FollowPathLike;

interface FollowPathState {

  [key: string]: number;

  directedProgress: number;

  lap: number;

  progress: number;

  speed: number;

}

type FontBindingValue = BrowserVectorFontBindingValue | FacetypeFontBindingValue | SdfAtlasFontBindingValue;

interface ForceArrowOptions {

  arrowHeadSize?: number | undefined;

  arrowShaftThickness?: number | undefined;

  color?: any;

  duration?: number | undefined;

  length?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  normalized?: boolean;

  scale?: number;

}

type FragInteriorColorInput = WaveFractureInteriorColorInput;

interface FragResult {

  error?: string;

  fragments: unknown[];

  originalMesh?: unknown;

  parts?: unknown[];

  success: boolean;

}

type FrameAdaptiveBackbufferAdjustment = "downshift" | "upshift";

interface FrameAdaptiveBackbufferDiagnostics {

  readonly adjustmentCount: number;

  readonly cooldownRemainingMs: number;

  readonly downshiftFrameRate: number;

  readonly downshiftProgressFrames: number;

  readonly downshiftSustainFrames: number;

  readonly emaFrameRate: number | null;

  readonly emaFrameTimeMs: number | null;

  readonly lastAdjustment: FrameAdaptiveBackbufferAdjustment | null;

  readonly lastExclusion: FrameAdaptiveBackbufferExclusionReason | null;

  readonly maximumPixelRatio: number;

  readonly minimumPixelRatio: number;

  readonly pendingUpshiftPixelRatio: number | null;

  readonly rejectedUpshiftPixelRatio: number | null;

  readonly targetFrameRate: number;

  readonly targetPixelRatio: number | null;

  readonly upshiftFrameRate: number;

  readonly upshiftProgressFrames: number;

  readonly upshiftSustainFrames: number;

}

type FrameAdaptiveBackbufferExclusionReason = "captureOverride" | "hidden" | "notRendered" | "paused" | "stalled";

interface FrameAuthoredLinearVelocityIntent {

  frame: WaveTransformFrameSpace;

  frameOf?: TransformReferenceLike;

  localPosition?: Vector3Like;

  localRotation?: QuaternionLike;

  localVelocity: Vector3Like;

  parentFrameDepth: number;

}

interface FXAAOptions {

}

declare class FxAnchorBuilder {

  addXBy(value: number): this;

  addYBy(value: number): this;

  addZBy(value: number): this;

  alongBy(direction: DirectionInput, distance: number, frame?: WavePointSourceSpace, parentFrameDepth?: number): this;

  backwardBy(value: number, frame?: WavePointSourceSpace, parentFrameDepth?: number): this;

  build(): WaveFxAnchorBinding;

  downBy(value: number, frame?: WavePointSourceSpace, parentFrameDepth?: number): this;

  forwardBy(value: number, frame?: WavePointSourceSpace, parentFrameDepth?: number): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  leftBy(value: number, frame?: WavePointSourceSpace, parentFrameDepth?: number): this;

  rightBy(value: number, frame?: WavePointSourceSpace, parentFrameDepth?: number): this;

  subXBy(value: number): this;

  subYBy(value: number): this;

  subZBy(value: number): this;

  upBy(value: number, frame?: WavePointSourceSpace, parentFrameDepth?: number): this;

}

declare class FxAroundPlacementBuilder {

  at(origin: WavePointInput): FxAroundPlacementBuilder;

  at(x: number, y: number, z: number): FxAroundPlacementBuilder;

  inRange(range: PlacementRangeInputSet): FxAroundPlacementBuilder;

  inTotal(count: number): FxAroundPlacementBuilder;

  notInRange(range: PlacementRangeInputSet): FxAroundPlacementBuilder;

  originAt(origin: WavePointInput): FxAroundPlacementBuilder;

  snapToSurface(surface: WaveTerrainSurface): FxAroundPlacementBuilder;

  startPaused(paused?: boolean): FxAroundPlacementBuilder;

  withCount(count: number): FxAroundPlacementBuilder;

  withParams(values: Record<string, WaveValue>): FxAroundPlacementBuilder;

  withRandomYaw(min?: number, max?: number): FxAroundPlacementBuilder;

  withSeed(seed: number): FxAroundPlacementBuilder;

  withYawRange(min: number, max: number): FxAroundPlacementBuilder;

  withYOffset(offset: number): FxAroundPlacementBuilder;

  constructor(spawner: WaveSpawner, system: FxPlayableSystem, target?: WavePointInput | WaveSpatial3DObject);

  evenlySpaced(): this;

  faceCenter(face?: boolean): this;

  faceOutward(face?: boolean): this;

  inRadius(radius: number): this;

  inRadius(minRadius: number, maxRadius: number): this;

  insidePerimeter(): this;

  onPerimeter(): this;

  onPlane(plane: WavePlaneFrameInput): this;

  onXYPlane(): this;

  onXZPlane(): this;

  onYZPlane(): this;

  outsidePerimeter(outerRadius?: number): this;

  place(): FxPlacementGroupHandle;

  withHeightRange(min: number, max: number): this;

  withJitter(jitter: Vector3Like | number): this;

  withMinRadius(radius: number): this;

  withRadius(radius: number): this;

  withRandomStrength(strength: number): this;

}

interface FxAttributeSchema {

  default: WaveValue;

  name: string;

  type: WaveValueKind;

}

type FxAuthorityMode = "cosmetic" | "authoritative" | "hybrid";

interface FxCollectiveNeighborhoodDefinition {

  readonly limits?: { readonly maximumCells: number; readonly maximumCandidates: number; }

  readonly maximumRange: number;

  readonly mode: FxNeighborMode;

  readonly neighbors?: number;

  readonly perception?: { readonly frontFieldOfViewDegrees?: number; readonly rearFieldOfViewDegrees?: number; readonly cohort?: FxNeighborCohortFilter; readonly cohortAttribute?: string; }

  readonly quality: FxNeighborQuality;

}

interface FxCollisionPlaneBounds {

  readonly halfDepth?: WaveValueExpr;

  readonly halfWidth?: WaveValueExpr;

}

interface FxCollisionPlaneSurface {

  readonly bounds?: FxCollisionPlaneBounds;

  readonly kind: "plane";

  readonly normal: WaveValueExpr;

  readonly origin: WaveValueExpr;

  readonly u: WaveValueExpr;

  readonly v: WaveValueExpr;

}

type FxCollisionSurface = FxCollisionPlaneSurface | FxCollisionTerrainSurface;

interface FxCollisionTerrainSurface {

  readonly heightOffset: WaveValueExpr;

  readonly kind: "terrain";

  readonly source: { readonly owner: WaveEntityIdentityRef; readonly channelId: string; }

}

interface FxCompiledStack {

  executors: FxModuleExecFn[];

}

declare class FxConditionMetricBuilder {

  constructor(_source: FxTrackMetricSource);

  above(value: number, opts?: FxTrackConditionMetricOptions): FxTrackCondition;

  below(value: number, opts?: FxTrackConditionMetricOptions): FxTrackCondition;

  between(minValue: number, maxValue: number, opts?: FxTrackConditionMetricOptions): FxTrackCondition;

}

interface FxConeTrailRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  bindings: { position: "Particles.Position"; color?: string; diameter?: string; }

  coneTrail: { maxPoints: number; radialSegments?: number; worldSpace?: boolean; fadeByAge?: boolean; diameterOverLength?: WaveValueCurveSpec; smoothing?: number; maxSegmentLength?: number; }

  textureAsset?: string;

  textureMode?: "stretch" | "tile" | "distanceRepeat";

  textureRepeatDistance?: number;

  type: "coneTrail";

}

interface FxCreateSmokeOptions {

  emitterId?: string;

  texture?: string;

}

type FxCurveInputArgs = [curve: FxValueCurveInput, options?: FxValueCurveSamplingOptions] | FxCurveTuple[];

type FxCurveTuple = readonly [number, number];

interface FxDefinitionAssetValue {

  readonly compiled: CompiledFxSystem;

  readonly dependencies: FxResolvedDependencyTable;

}

interface FxEmitterDefinition {

  collectiveNeighborhood?: FxCollectiveNeighborhoodDefinition;

  emitterParameters?: FxEmitterParamSchema[];

  eventHandlers?: FxEventHandlerSpec[];

  id: string;

  motion?: FxMotionGraph;

  particleLayout: FxParticleLayout;

  renderers: FxRendererSpec[];

  retainedVolume?: FxRetainedVolumeDefinition;

  ribbonAnchors?: { tip: WaveFxAnchorBinding; base: WaveFxAnchorBinding; }

  scalability?: FxEmitterScalabilityPolicy;

  scripts: FxEmitterScripts;

  simTarget: FxSimTarget;

  surfaceSpawn?: { source: WaveSurfaceSourceStructure; areaWeighted?: boolean; normalOffset?: number; }

}

interface FxEmitterParamSchema {

  clamp?: { min?: number; max?: number; }

  default: WaveValue;

  name: string;

  type: WaveValueKind;

}

interface FxEmitterRuntimeSurface {

  alphaOverLife(...args: [curve: FxValueCurveInput, options?: FxValueCurveSamplingOptions] | FxCurveTuple[]): FxEmitterBuilder;

  burst(count: NumLike): FxEmitterBuilder;

  color(opts: ColorLike): FxEmitterBuilder;

  drag(coefficient: NumLike): FxEmitterBuilder;

  lifetime(val: NumLike): FxEmitterBuilder;

  rate(perSecond: NumLike): FxEmitterBuilder;

  rotation(val?: NumLike): FxEmitterBuilder;

  setAttribute(attribute: string, val: NumLike, component?: number): FxEmitterBuilder;

  size(val: NumLike): FxEmitterBuilder;

  sizeOverLife(...args: [curve: FxValueCurveInput, options?: FxValueCurveSamplingOptions] | FxCurveTuple[]): FxEmitterBuilder;

}

interface FxEmitterScalabilityPolicy {

  allowSimTargets?: Array<"gpu" | "cpu">;

  budgets?: { maxParticles?: number; maxSpawnPerFrame?: number; }

  cullDistance?: number;

  fixedBounds?: { min: Vector3Like; max: Vector3Like; }

}

interface FxEmitterScripts {

  emitterSpawn: FxScriptStack;

  emitterUpdate: FxScriptStack;

  particleSpawn: FxScriptStack;

  particleUpdate: FxScriptStack;

}

interface FxEmitterStructureSurface {

  budget(budgets: NonNullable<FxEmitterScalabilityPolicy["budgets"]>): FxEmitterBuilder;

  collectiveNeighborhood(definition: FxCollectiveNeighborhoodDefinition): FxEmitterBuilder;

  coneTrail(opts?: ConeTrailOpts): FxEmitterBuilder;

  gpu(): FxEmitterBuilder;

  light(opts?: LightOpts): FxEmitterBuilder;

  lightBeam(opts: LightBeamOpts): FxEmitterBuilder;

  mesh(opts: MeshOpts): FxEmitterBuilder;

  module(stage: "emitterSpawn" | "particleSpawn" | "particleUpdate", moduleId: string, inputs?: Record<string, FxExpr>, outputs?: Record<string, string>): FxEmitterBuilder;

  motion(configure: (motion: FxMotionBuilder) => FxMotionBuilder | void): FxEmitterBuilder;

  noAutoAgeAndKill(): FxEmitterBuilder;

  noAutoIntegrate(): FxEmitterBuilder;

  particles(capacity: number): FxEmitterBuilder;

  pointField(opts: PointFieldOpts): FxEmitterBuilder;

  presetBillboard(opts: PresetBillboardOpts): FxEmitterBuilder;

  renderAsDebugOverlay(): FxEmitterBuilder;

  renderAsGameplayOverlay(): FxEmitterBuilder;

  renderAsUi3D(): FxEmitterBuilder;

  renderInWorld(): FxEmitterBuilder;

  renderOnly(): FxEmitterBuilder;

  retainedVolume(volume: WaveFxRetainedVolume): FxEmitterBuilder;

  ribbon(opts?: RibbonOpts): FxEmitterBuilder;

  screenLayer(opts: ScreenLayerOpts): FxEmitterBuilder;

  simTarget(target: FxSimTarget): FxEmitterBuilder;

  spawnAlongPath(path: FxMotionPathSource, opts: PathSpawnOpts): FxEmitterBuilder;

  spawnFromAnchor(offset?: Partial<Vector3Like>): FxEmitterBuilder;

  spawnInAnnulusFromAnchor(opts: AnnulusSpawnOpts): FxEmitterBuilder;

  sprite(opts: SpriteOpts): FxEmitterBuilder;

  surfaceEffect(opts: SurfaceEffectOpts): FxEmitterBuilder;

  text(opts: TextParticleOpts): FxEmitterBuilder;

  velocityCone(opts: VelocityConeOpts): FxEmitterBuilder;

  volumeShell(opts: VolumeShellOpts): FxEmitterBuilder;

  weaponSwoosh(opts: WeaponSwooshOpts): FxEmitterBuilder;

}

interface FxEventHandlerSpec {

  eventName: string;

  script: FxScriptStack;

  spawnCount?: WaveValueExpr;

}

interface FxExecContext {

  dt: number;

  emitterParams: FxParameterStore;

  eventPayload?: Readonly<Record<string, WaveValue>>;

  lod: number;

  seed: number;

  systemParams: FxParameterStore;

  time: number;

}

declare class FxFacade {

  constructor(entity: WaveEntity, cmpClass: typeof cmp_fx);

  createSmoke(systemId: FxSystemId, opts?: FxCreateSmokeOptions): FxSmokeController;

  drain(): FxTrackController;

  localPoint(point: WavePointInput): WaveFxAnchorBinding;

  localPointFromWorld(point: WavePointInput): WaveFxAnchorBinding;

  pause(): FxTrackController;

  play(systemId: FxPlayableSystem, opts?: FxPlayOptions): FxTrackController;

  quick(systemId: FxPlayableSystem, opts?: FxPlayOptions): void;

  resume(): FxTrackController;

  setUserParam(name: string, value: FxValue): FxTrackController;

  setUserParams(values: Record<string, FxValue>): FxTrackController;

  spawn(systemId: FxPlayableSystem, opts?: FxPlayOptions): FxInstanceHandle;

  stop(opts?: FxStopOptions): FxTrackController;

  track(trackName: string): FxTrackController;

  warningState(warningActive: boolean, values: { normal: Record<string, FxValue>; warning: Record<string, FxValue>; }): FxTrackController;

  worldPoint(point: WavePointInput): WaveFxAnchorBinding;

  worldSurfacePoint(point: WavePointInput, surface: FxSurfaceSnapSource, options?: FxSurfaceSnapOptions): WaveFxAnchorBinding;

}

interface FxGlowConfig {

  color?: ColorInput;

  enabled: boolean;

  intensity?: number;

}

interface FxGpuCollectiveProgram {

  readonly auxiliaryStrideWords: number;

  readonly buildWgsl: string;

  readonly clearWgsl: string;

  readonly maximumCandidates: number;

  readonly maximumCells: number;

  readonly maximumRange: number;

  readonly mode: "metricRadius" | "hybridKWithinRadius";

  readonly quality: "exact" | "bounded";

  readonly selectedK: number;

  readonly updateWgsl: string;

}

interface FxGpuDrivenModelTerminal {

  readonly authoredOpacity: number;

  readonly conservativePadding: number;

  readonly kind: "gpuDrivenModel";

  readonly livePathSource: WavePathSourceHandle | null;

  readonly model: WaveGpuDrivenRuntimeModelInput;

  readonly pathAlphaBindingName: "pathAlpha";

  readonly pathChannelId: "pathTable";

  readonly pathTimeBindingName: "pathTime";

  readonly rendererId: string;

  readonly rendererIndex: number;

  readonly sourceRendererType: "ribbon" | "coneTrail";

}

interface FxGpuEmitterProgram {

  readonly ageOffset: number;

  readonly collective: FxGpuCollectiveProgram | null;

  readonly compactWgsl: string;

  readonly contactEventStream: WaveGpuEventStreamRef | null;

  readonly emitterId: string;

  readonly emitterParamFloatCount: number;

  readonly lifetimeOffset: number;

  readonly particleStride: number;

  readonly resetCompactWgsl: string;

  readonly retainedVolume: FxGpuRetainedVolumeProgram | null;

  readonly schema: "wave.fxGpuEmitterProgram.v5";

  readonly spawnWgsl: string;

  readonly staticFloats: Float32Array;

  readonly systemParamFloatCount: number;

  readonly terrainContactSource: FxCollisionTerrainSurface["source"] | null;

  readonly topologySignature: string;

  readonly updateWgsl: string;

}

interface FxGpuRetainedVolumeProgram {

  readonly cellCount: number;

  readonly clearDepositsWgsl: string;

  readonly evolveWgsl: string;

  readonly fieldBodyWgsl: string;

  readonly fieldSupportWgsl: string;

  readonly fixedPointScale: number;

  readonly hasDeposits: boolean;

  readonly hasParticleMotion: boolean;

  readonly needsEvolution: boolean;

  readonly particleWgsl: string;

  readonly physicalHeight: number;

  readonly physicalWidth: number;

  readonly resolution: readonly [number, number, number];

  readonly seed: { readonly kind: "zero"; } | { readonly kind: "dense"; readonly data: Float32Array; }

}

interface FxGroundCollisionSurfaceOpts {

  normal?: DirectionInput;

  y?: number;

}

interface FxHistoryTrailTerminal {

  readonly kind: "historyTrail";

  readonly rendererIndex: number;

}

declare class FxInGridPlacementBuilder {

  at(origin: WavePointInput): FxInGridPlacementBuilder;

  at(x: number, y: number, z: number): FxInGridPlacementBuilder;

  inRange(range: PlacementRangeInputSet): FxInGridPlacementBuilder;

  inTotal(count: number): FxInGridPlacementBuilder;

  notInRange(range: PlacementRangeInputSet): FxInGridPlacementBuilder;

  originAt(origin: WavePointInput): FxInGridPlacementBuilder;

  snapToSurface(surface: WaveTerrainSurface): FxInGridPlacementBuilder;

  startPaused(paused?: boolean): FxInGridPlacementBuilder;

  withCount(count: number): FxInGridPlacementBuilder;

  withParams(values: Record<string, WaveValue>): FxInGridPlacementBuilder;

  withRandomYaw(min?: number, max?: number): FxInGridPlacementBuilder;

  withSeed(seed: number): FxInGridPlacementBuilder;

  withYawRange(min: number, max: number): FxInGridPlacementBuilder;

  withYOffset(offset: number): FxInGridPlacementBuilder;

  onPlane(plane: WavePlaneFrameInput): this;

  onXYPlane(): this;

  onXZPlane(): this;

  onYZPlane(): this;

  place(): FxPlacementGroupHandle;

  randomizeCells(random?: boolean): this;

  withCols(cols: number): this;

  withColSpacing(spacing: number): this;

  withGridTopology(topology: GridTopology): this;

  withJitter(jitter: Vector3Like | number): this;

  withLayers(layers: number): this;

  withLayerSpacing(spacing: number): this;

  withRows(rows: number): this;

  withRowSpacing(spacing: number): this;

  withSize(rows: number, cols: number, layers?: number): this;

  withSpacing(spacing: number): this;

}

declare class FxInlinePlacementBuilder {

  at(origin: WavePointInput): FxInlinePlacementBuilder;

  at(x: number, y: number, z: number): FxInlinePlacementBuilder;

  inRange(range: PlacementRangeInputSet): FxInlinePlacementBuilder;

  inTotal(count: number): FxInlinePlacementBuilder;

  notInRange(range: PlacementRangeInputSet): FxInlinePlacementBuilder;

  originAt(origin: WavePointInput): FxInlinePlacementBuilder;

  snapToSurface(surface: WaveTerrainSurface): FxInlinePlacementBuilder;

  startPaused(paused?: boolean): FxInlinePlacementBuilder;

  withCount(count: number): FxInlinePlacementBuilder;

  withParams(values: Record<string, WaveValue>): FxInlinePlacementBuilder;

  withRandomYaw(min?: number, max?: number): FxInlinePlacementBuilder;

  withSeed(seed: number): FxInlinePlacementBuilder;

  withYawRange(min: number, max: number): FxInlinePlacementBuilder;

  withYOffset(offset: number): FxInlinePlacementBuilder;

  alignToPath(align?: boolean): this;

  endAt(point: WavePointInput): this;

  from(point: WavePointInput): this;

  place(): FxPlacementGroupHandle;

  randomizeAlongPath(random?: boolean): this;

  startFrom(point: WavePointInput): this;

  to(point: WavePointInput): this;

  withJitter(jitter: Vector3Like | number): this;

  withSpacing(spacing: number): this;

  withUpVector(up: Vector3): this;

}

declare class FxInRangePlacementBuilder {

  at(origin: WavePointInput): FxInRangePlacementBuilder;

  at(x: number, y: number, z: number): FxInRangePlacementBuilder;

  inRange(range: PlacementRangeInputSet): FxInRangePlacementBuilder;

  inTotal(count: number): FxInRangePlacementBuilder;

  notInRange(range: PlacementRangeInputSet): FxInRangePlacementBuilder;

  originAt(origin: WavePointInput): FxInRangePlacementBuilder;

  snapToSurface(surface: WaveTerrainSurface): FxInRangePlacementBuilder;

  startPaused(paused?: boolean): FxInRangePlacementBuilder;

  withCount(count: number): FxInRangePlacementBuilder;

  withParams(values: Record<string, WaveValue>): FxInRangePlacementBuilder;

  withRandomYaw(min?: number, max?: number): FxInRangePlacementBuilder;

  withSeed(seed: number): FxInRangePlacementBuilder;

  withYawRange(min: number, max: number): FxInRangePlacementBuilder;

  withYOffset(offset: number): FxInRangePlacementBuilder;

  constructor(spawner: WaveSpawner, system: FxPlayableSystem, _range: WaveRange | string);

  evenlySpaced(): this;

  facing(target: TransformReferenceLike | WavePointInput): this;

  insideRange(): this;

  onRangeSurface(): this;

  place(): FxPlacementGroupHandle;

  withInset(inset: number): this;

  withJitter(jitter: Vector3Like | number): this;

  withRandomStrength(strength: number): this;

}

interface FxInstanceHandle {

  dispose(): void;

  readonly id: FxInstanceId;

  setUserParam(name: string, value: FxValue): void;

  setUserParams(values: Record<string, FxValue>): void;

  stop(opts?: FxStopOptions): void;

  readonly systemId: FxSystemId;

  triggerEvent(eventName: string, payload?: Record<string, FxValue>): void;

}

type FxInstanceId = string;

interface FxInstanceSnapshot {

  activeWhen?: FxTrackCondition;

  anchor?: WaveFxAnchorBinding;

  disposeOnDrain?: boolean;

  inactiveBehavior?: FxTrackInactiveBehavior;

  playheadTicks: number;

  playState: FxPlayState;

  renderingGroupId?: number;

  rootTable?: FxRootTableEntry[];

  seed: number;

  startTick: number;

  stateTick: number;

  stopFade?: WaveTimeSpanSpec;

  stopTick?: number;

  systemBinding?: AssetConsumerBindingSnapshot<"data">;

  systemId: FxSystemId;

  systemRevision: string;

  userParamBindings?: FxUserParamBinding[];

  userParams?: Record<string, WaveValue>;

}

interface FxLightBeamMaskSpec {

  columns: number;

  frame: number;

  invert?: boolean;

  rows: number;

  strength?: WaveValueExpr;

  textureAsset: string;

}

interface FxLightBeamRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  attenuation?: { equation: "linear" | "quadratic" | "exponential"; startDistance?: WaveValueExpr; }

  beam: { shape: "cone" | "cylinder"; axis?: Direction; length: WaveValueExpr; sourceRadius: WaveValueExpr; endRadius?: WaveValueExpr; spotAngle?: WaveValueExpr; capGeom?: boolean; sides?: number; segments?: number; }

  color: ColorInputAlpha | { gradient: readonly ColorGradientStopAlpha[]; }

  glareFromBehind?: WaveValueExpr;

  glareFrontal?: WaveValueExpr;

  intensity?: WaveValueExpr;

  mask?: FxLightBeamMaskSpec;

  noise3D?: { enabled: boolean; intensity?: WaveValueExpr; scale?: WaveValueExpr; velocity?: Vector3Like; }

  sideThickness?: WaveValueExpr;

  softIntersection?: { opaqueGeometryDistance?: number; cameraNearDistance?: number; }

  type: "lightBeam";

}

declare const FxLightmask: { readonly ConeComposedA: "coneComposedA"; readonly ConeComposedB: "coneComposedB"; readonly ConeComposedC: "coneComposedC"; readonly ConeComposedD: "coneComposedD"; readonly ConeComposedE: "coneComposedE"; readonly ConeComposedF: "coneComposedF"; readonly ConeSoftA: "coneSoftA"; readonly ConeSoftB: "coneSoftB"; readonly ConeSoftC: "coneSoftC"; readonly StreaksA: "streaksA"; readonly StreaksB: "streaksB"; readonly StreaksC: "streaksC"; readonly StreaksD: "streaksD"; readonly StreaksE: "streaksE"; readonly StreaksF: "streaksF"; readonly StreaksG: "streaksG"; readonly StreaksH: "streaksH"; readonly FanA: "fanA"; readonly FanB: "fanB"; readonly FanC: "fanC"; readonly FanD: "fanD"; readonly CircleRingsA: "circleRingsA"; readonly CircleRingsB: "circleRingsB"; readonly CircleRingsC: "circleRingsC"; readonly CircleRingsD: "circleRingsD"; readonly RingA: "ringA"; readonly RingB: "ringB"; readonly RingC: "ringC"; readonly FoliageCanopyA: "foliageCanopyA"; readonly FoliageCanopyB: "foliageCanopyB"; readonly WaterCausticsA: "waterCausticsA"; readonly WindowSoftA: "windowSoftA"; };

type FxLightmaskId = typeof FxLightmask[keyof typeof FxLightmask];

interface FxLightRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  bindings?: { position?: string; color?: string; intensity?: string; range?: string; }

  mode: "perParticle" | "single";

  type: "light";

}

interface FxLightTerminal {

  readonly kind: "light";

  readonly rendererIndex: number;

}

interface FxMeshRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  bindings: { position: "Particles.Position"; rotation?: string; scale?: string; color?: string; }

  meshAssetId: string | AssetRef<"model"> | ExactAssetRef<"model">;

  type: "mesh";

}

interface FxModelBatchTerminal {

  readonly kind: "modelBatch";

  readonly rendererIndex: number;

}

type FxModuleExecFn = (ctx: FxExecContext) => void;

interface FxModuleInvocation {

  directionSpace?: Exclude<WavePointSourceSpace, "parent">;

  enabled?: WaveBoolExpr;

  inputs?: Record<string, WaveValueExpr>;

  module: string;

  outputs?: Record<string, string>;

}

interface FxMotionBounceIntent {

  friction?: WaveValueExpr;

  kind: "bounce";

  minBounceSpeed?: WaveValueExpr;

  radius?: WaveValueExpr;

  restitution?: WaveValueExpr;

  surface: FxCollisionSurface;

}

interface FxMotionBounceOptions {

  friction?: NumLike;

  minBounceSpeed?: NumLike;

  radius?: NumLike;

  restitution?: NumLike;

}

interface FxMotionCollectiveIntent {

  readonly alignment: WaveValueExpr;

  readonly cohesion: WaveValueExpr;

  readonly kind: "collective";

  readonly prioritySeparation?: boolean;

  readonly separation: WaveValueExpr;

  readonly separationRadius: WaveValueExpr;

}

interface FxMotionCollectiveOptions {

  alignment: NumLike;

  cohesion: NumLike;

  prioritySeparation?: boolean;

  separation: NumLike;

  separationRadius: NumLike;

}

interface FxMotionConstantAccelerationIntent {

  acceleration: WaveValueExpr;

  kind: "constantAcceleration";

}

interface FxMotionFallOptions {

  direction?: DirectionInput;

  gravity?: number;

}

interface FxMotionFollowPathOptions {

  loop?: boolean;

  mode?: FxMotionPathMode;

  offset?: NumLike;

  outlierChance?: NumLike;

  outlierSpread?: NumLike;

  speed?: NumLike;

  spread?: NumLike;

  strength?: NumLike;

  wander?: NumLike;

}

interface FxMotionGraph {

  intents: FxMotionIntent[];

  paths?: FxMotionPathSpec[];

}

interface FxMotionHeadingResponseIntent {

  readonly kind: "headingResponse";

  readonly maximumSpeed: WaveValueExpr;

  readonly maximumTurnRate: WaveValueExpr;

  readonly minimumSpeed: WaveValueExpr;

  readonly speedConvergence?: WaveValueExpr;

}

interface FxMotionHeadingResponseOptions {

  maximumSpeed: NumLike;

  maximumTurnRate: NumLike;

  minimumSpeed: NumLike;

  speedConvergence?: NumLike;

}

interface FxMotionIntegrateIntent {

  damping?: WaveValueExpr;

  kind: "integrate";

  maxSpeed?: WaveValueExpr;

}

interface FxMotionIntegrateOptions {

  damping?: NumLike;

  maxSpeed?: NumLike;

}

type FxMotionIntent = FxMotionPointIntent | FxMotionPathFollowIntent | FxMotionConstantAccelerationIntent | FxMotionBounceIntent | FxMotionSpeedClampIntent | FxMotionOrientIntent | FxMotionCollectiveIntent | FxMotionHeadingResponseIntent | FxMotionRetainedVolumeIntent | FxMotionIntegrateIntent;

interface FxMotionOrientIntent {

  kind: "orient";

  mode: FxMotionOrientMode;

  pitchOffset?: WaveValueExpr;

  rollOffset?: WaveValueExpr;

  target?: WaveValueExpr;

  yawOffset?: WaveValueExpr;

}

type FxMotionOrientMode = "velocity" | "target";

interface FxMotionOrientOptions {

  pitchOffset?: NumLike;

  rollOffset?: NumLike;

  yawOffset?: NumLike;

}

interface FxMotionPathFollowIntent {

  kind: "pathFollow";

  loop?: boolean;

  mode?: FxMotionPathMode;

  offset?: WaveValueExpr;

  outlierChance?: WaveValueExpr;

  outlierSpread?: WaveValueExpr;

  pathIndex: number;

  speed?: WaveValueExpr;

  spread?: WaveValueExpr;

  strength?: WaveValueExpr;

  wander?: WaveValueExpr;

}

type FxMotionPathMode = "age" | "time";

interface FxMotionPathParamOffsets {

  forward: number;

  position: number;

  right: number;

  up: number;

}

type FxMotionPathSource = wavePath | ReadonlyArray<Vector3Like>;

interface FxMotionPathSpec {

  placement?: WaveFxAnchorBinding;

  reference: WavePathReference;

}

interface FxMotionPointIntent {

  axis?: WaveValueExpr;

  falloff?: WaveValueCurveFalloffMode;

  kind: FxMotionPointIntentKind;

  radius?: WaveValueExpr;

  softening?: WaveValueExpr;

  strength?: WaveValueExpr;

  target: WaveValueExpr;

}

type FxMotionPointIntentKind = "attract" | "repel" | "gravity" | "orbit";

interface FxMotionRetainedVolumeDepositOptions {

  radius?: NumLike;

  scalar?: NumLike;

  vector?: FxMotionTargetInput;

}

interface FxMotionRetainedVolumeGradientSampleOptions {

  gradientAttribute?: string;

}

type FxMotionRetainedVolumeIntent = { readonly kind: "retainedVolume"; readonly volumeId: string; readonly operation: "sample"; readonly vectorAttribute: string; readonly scalarAttribute: string; } | { readonly kind: "retainedVolume"; readonly volumeId: string; readonly operation: "sampleGradient"; readonly gradientAttribute: string; } | { readonly kind: "retainedVolume"; readonly volumeId: string; readonly operation: "followVector" | "climbScalar" | "descendScalar"; readonly strength: WaveValueExpr; } | { readonly kind: "retainedVolume"; readonly volumeId: string; readonly operation: "pairedSensors"; readonly forwardOffset: WaveValueExpr; readonly lateralOffset: WaveValueExpr; readonly response: readonly number[]; readonly strength: WaveValueExpr; } | { readonly kind: "retainedVolume"; readonly volumeId: string; readonly operation: "deposit"; readonly vector: WaveValueExpr; readonly scalar: WaveValueExpr; readonly radius: WaveValueExpr; }

interface FxMotionRetainedVolumeSampleOptions {

  scalarAttribute?: string;

  vectorAttribute?: string;

}

interface FxMotionRetainedVolumeSensorOptions {

  forwardOffset: NumLike;

  lateralOffset: NumLike;

  response: readonly [turnDifference: number, forwardSum?: number];

  strength?: NumLike;

}

interface FxMotionRetainedVolumeSteeringOptions {

  strength?: NumLike;

}

interface FxMotionSpeedClampIntent {

  kind: "speedClamp";

  maxSpeed: WaveValueExpr;

}

type FxMotionTargetInput = FxExpr | Vector3Like;

type FxNeighborCohortFilter = "all" | "same" | "other";

type FxNeighborMode = "metricRadius" | "hybridKWithinRadius";

type FxNeighborQuality = "exact" | "bounded";

declare class FxOnPathPlacementBuilder {

  at(origin: WavePointInput): FxOnPathPlacementBuilder;

  at(x: number, y: number, z: number): FxOnPathPlacementBuilder;

  inRange(range: PlacementRangeInputSet): FxOnPathPlacementBuilder;

  inTotal(count: number): FxOnPathPlacementBuilder;

  notInRange(range: PlacementRangeInputSet): FxOnPathPlacementBuilder;

  originAt(origin: WavePointInput): FxOnPathPlacementBuilder;

  snapToSurface(surface: WaveTerrainSurface): FxOnPathPlacementBuilder;

  startPaused(paused?: boolean): FxOnPathPlacementBuilder;

  withCount(count: number): FxOnPathPlacementBuilder;

  withParams(values: Record<string, WaveValue>): FxOnPathPlacementBuilder;

  withRandomYaw(min?: number, max?: number): FxOnPathPlacementBuilder;

  withSeed(seed: number): FxOnPathPlacementBuilder;

  withYawRange(min: number, max: number): FxOnPathPlacementBuilder;

  withYOffset(offset: number): FxOnPathPlacementBuilder;

  alignToPath(align?: boolean): this;

  along(path: WaveCurveInput): this;

  followingPath(path: WaveCurveInput): this;

  place(): FxPlacementGroupHandle;

  randomizeAlongPath(random?: boolean): this;

  withJitter(jitter: Vector3Like | number): this;

  withSpacing(spacing: number): this;

  withUpVector(up: Vector3): this;

}

declare class FxOnSurfacePlacementBuilder {

  at(origin: WavePointInput): FxOnSurfacePlacementBuilder;

  at(x: number, y: number, z: number): FxOnSurfacePlacementBuilder;

  inRange(range: PlacementRangeInputSet): FxOnSurfacePlacementBuilder;

  inTotal(count: number): FxOnSurfacePlacementBuilder;

  notInRange(range: PlacementRangeInputSet): FxOnSurfacePlacementBuilder;

  originAt(origin: WavePointInput): FxOnSurfacePlacementBuilder;

  snapToSurface(surface: WaveTerrainSurface): FxOnSurfacePlacementBuilder;

  startPaused(paused?: boolean): FxOnSurfacePlacementBuilder;

  withCount(count: number): FxOnSurfacePlacementBuilder;

  withParams(values: Record<string, WaveValue>): FxOnSurfacePlacementBuilder;

  withRandomYaw(min?: number, max?: number): FxOnSurfacePlacementBuilder;

  withSeed(seed: number): FxOnSurfacePlacementBuilder;

  withYawRange(min: number, max: number): FxOnSurfacePlacementBuilder;

  withYOffset(offset: number): FxOnSurfacePlacementBuilder;

  constructor(spawner: WaveSpawner, system: FxPlayableSystem, _placementSurface: SpawnSurface);

  alignToNormal(align?: boolean): this;

  notInRiver(river: SurfaceRiverNoPlaceSource, options?: SurfaceRiverNoPlaceOptions): this;

  place(): FxPlacementGroupHandle;

  projectFrom(point: TransformReferenceLike | WavePointInput): this;

  withJitter(jitter: Vector3Like | number): this;

  withSurfaceOffset(offset: number): this;

}

type FxOrphanPolicy = "freezeWorld" | "stopFade" | "reanchorOwner";

interface FxParameterStore {

  data: Float32Array;

  offsets: ReadonlyMap<string, number>;

  types: ReadonlyMap<string, WaveValueKind>;

}

interface FxParametricPathNoiseSpec {

  readonly amplitude?: number;

  readonly frequency?: number;

  readonly speed?: number;

}

interface FxParticleLayout {

  attributes: FxAttributeSchema[];

}

declare const FxParticleMask: { readonly Circle01: "circle01"; readonly Circle02: "circle02"; readonly Circle03: "circle03"; readonly Circle04: "circle04"; readonly Circle05: "circle05"; readonly Dirt01: "dirt01"; readonly Dirt02: "dirt02"; readonly Dirt03: "dirt03"; readonly Fire01: "fire01"; readonly Fire02: "fire02"; readonly Flame01: "flame01"; readonly Flame02: "flame02"; readonly Flame03: "flame03"; readonly Flame04: "flame04"; readonly Flame05: "flame05"; readonly Flame06: "flame06"; readonly Flare01: "flare01"; readonly Light01: "light01"; readonly Light02: "light02"; readonly Light03: "light03"; readonly Magic01: "magic01"; readonly Magic02: "magic02"; readonly Magic03: "magic03"; readonly Magic04: "magic04"; readonly Magic05: "magic05"; readonly Muzzle01: "muzzle01"; readonly Muzzle02: "muzzle02"; readonly Muzzle03: "muzzle03"; readonly Muzzle04: "muzzle04"; readonly Muzzle05: "muzzle05"; readonly Flame05Rotated: "flame05Rotated"; readonly Flame06Rotated: "flame06Rotated"; readonly Muzzle01Rotated: "muzzle01Rotated"; readonly Muzzle02Rotated: "muzzle02Rotated"; readonly Muzzle03Rotated: "muzzle03Rotated"; readonly Muzzle04Rotated: "muzzle04Rotated"; readonly Muzzle05Rotated: "muzzle05Rotated"; readonly Spark05Rotated: "spark05Rotated"; readonly Spark06Rotated: "spark06Rotated"; readonly Trace01Rotated: "trace01Rotated"; readonly Trace02Rotated: "trace02Rotated"; readonly Trace03Rotated: "trace03Rotated"; readonly Trace04Rotated: "trace04Rotated"; readonly Trace05Rotated: "trace05Rotated"; readonly Trace06Rotated: "trace06Rotated"; readonly Trace07Rotated: "trace07Rotated"; readonly Scorch01: "scorch01"; readonly Scorch02: "scorch02"; readonly Scorch03: "scorch03"; readonly Scratch01: "scratch01"; readonly Slash01: "slash01"; readonly Slash02: "slash02"; readonly Slash03: "slash03"; readonly Slash04: "slash04"; readonly Smoke01: "smoke01"; readonly Smoke02: "smoke02"; readonly Smoke03: "smoke03"; readonly Smoke04: "smoke04"; readonly Smoke05: "smoke05"; readonly Smoke06: "smoke06"; readonly Smoke07: "smoke07"; readonly Smoke08: "smoke08"; readonly Smoke09: "smoke09"; readonly Smoke10: "smoke10"; readonly Spark01: "spark01"; readonly Spark02: "spark02"; readonly Spark03: "spark03"; readonly Spark04: "spark04"; readonly Spark05: "spark05"; readonly Spark06: "spark06"; readonly Spark07: "spark07"; readonly Star01: "star01"; readonly Star02: "star02"; readonly Star03: "star03"; readonly Star04: "star04"; readonly Star05: "star05"; readonly Star06: "star06"; readonly Star07: "star07"; readonly Star08: "star08"; readonly Star09: "star09"; readonly Symbol01: "symbol01"; readonly Symbol02: "symbol02"; readonly Trace01: "trace01"; readonly Trace02: "trace02"; readonly Trace03: "trace03"; readonly Trace04: "trace04"; readonly Trace05: "trace05"; readonly Trace06: "trace06"; readonly Trace07: "trace07"; readonly Twirl01: "twirl01"; readonly Twirl02: "twirl02"; readonly Twirl03: "twirl03"; readonly Window01: "window01"; readonly Window02: "window02"; readonly Window03: "window03"; readonly Window04: "window04"; };

type FxParticleMaskId = typeof FxParticleMask[keyof typeof FxParticleMask];

interface FxPlacementGroupHandle {

  readonly count: number;

  dispose(): void;

  readonly id: string;

  readonly instanceIds: readonly FxInstanceId[];

  setUserParam(name: string, value: FxValue): void;

  setUserParams(values: Record<string, FxValue>): void;

  stop(opts?: FxStopOptions): void;

  readonly systemId: FxSystemId;

}

interface FxPlaneCollisionSurfaceOpts {

  halfDepth?: NumLike;

  halfWidth?: NumLike;

  normal?: DirectionInput;

  point: Vector3Like;

  u?: DirectionInput;

}

type FxPlayableSystem = FxSystemId | WaveFxSystemAsset;

interface FxPlayOptions {

  activeWhen?: FxTrackCondition;

  anchor?: WaveFxAnchorBinding;

  inactiveBehavior?: FxTrackInactiveBehavior;

  renderingGroupId?: number;

  seed?: number;

  startPaused?: boolean;

  userParams?: Record<string, FxValue>;

}

type FxPlayState = "playing" | "paused" | "stopping" | "draining";

interface FxPointFieldMouseRepelSpec {

  mouseParam: string;

  radius?: WaveValueExpr;

  strength?: WaveValueExpr;

  swirl?: WaveValueExpr;

}

interface FxPointFieldPointSizeSpec {

  base?: WaveValueExpr;

  max?: WaveValueExpr;

  min?: WaveValueExpr;

}

interface FxPointFieldRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  ambientFraction?: number;

  bounds: Vector3Like;

  count: number;

  mouseRepel?: FxPointFieldMouseRepelSpec;

  palette: ColorInputAlpha[];

  pointSize?: FxPointFieldPointSizeSpec;

  randomSeed?: number;

  streams: FxPointFieldStreamSpec[];

  twinkle?: FxPointFieldTwinkleSpec;

  type: "pointField";

}

interface FxPointFieldStreamSpec {

  phase: number;

  span: number;

  spin: number;

  width: number;

  yAmp: number;

  yOffset: number;

  yWave: number;

  zAmp: number;

  zOffset: number;

}

interface FxPointFieldTwinkleSpec {

  amount?: WaveValueExpr;

  speed?: WaveValueExpr;

}

type FxPresetBillboardPreset = "firePlume" | "smokeColumn" | "explosionRing" | "muzzleFlash" | "electricBolt" | "magicCircleAura" | "healingPulse" | "wetMist" | "snowOrRainSpray";

interface FxPresetBillboardRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  billboardMode?: "all" | "y" | "none";

  color?: ColorInputAlpha;

  delayMs?: number;

  durationMs?: number;

  intensity?: WaveValueExpr;

  loop?: boolean;

  normal?: Vector3Like;

  offset?: Vector3Like;

  preset: FxPresetBillboardPreset;

  samplerOverrides?: Record<string, string>;

  scale?: WaveValueExpr;

  type: "presetBillboard";

  uniformOverrides?: Record<string, WaveShaderUniformValue<"float" | "vec2" | "vec3" | "vec4" | "color3" | "color4">>;

  upHint?: Vector3Like;

}

interface FxQueuedEvent {

  eventName: string;

  instanceId: FxInstanceId;

  payload?: Record<string, FxValue>;

}

type FxRendererSpec = FxPresetBillboardRendererSpec | FxPointFieldRendererSpec | FxScreenLayerRendererSpec | FxSpriteRendererSpec | FxRibbonRendererSpec | FxConeTrailRendererSpec | FxWeaponSwooshRendererSpec | FxMeshRendererSpec | FxTextRendererSpec | FxLightRendererSpec | FxVolumeShellRendererSpec | FxLightBeamRendererSpec | FxSurfaceEffectRendererSpec;

interface FxRenderPlan {

  readonly schema: "wave.fxRenderPlan.v1";

  readonly terminals: readonly (FxRenderTerminal | null)[];

}

type FxRenderTerminal = FxSpriteBatchTerminal | FxModelBatchTerminal | FxGpuDrivenModelTerminal | FxHistoryTrailTerminal | FxLightTerminal | FxScreenLayerTerminal | FxTextBatchTerminal;

type FxResetMaterialView = { readonly kind?: string; readonly material?: unknown; readonly sourceMaterial?: unknown; }

interface FxResolvedDependencyRole {

  readonly dependencyIndex: number;

  readonly rendererIndex: number;

  readonly role: string;

  readonly slot?: string | undefined;

  readonly family: AssetFamily;

  readonly identity: AssetIdentity;

}

interface FxResolvedDependencyTable {

  require(rendererIndex: number, role: string, operation: string, slot?: string): FxResolvedDependencyView;

  readonly roles: readonly FxResolvedDependencyRole[];

  view(rendererIndex: number, role: string, slot?: string): FxResolvedDependencyView | null;

}

type FxResolvedDependencyView = { readonly kind: "texture"; readonly sample: SampledTextureAssetValue | AtlasTextureAssetValue; } | { readonly kind: "material"; readonly material: FxResetMaterialView; } | { readonly kind: "model"; readonly model: ModelAssetValue; } | { readonly kind: "animation"; readonly animation: AnimationAssetValue; } | { readonly kind: "foreign-texture"; readonly texture: unknown; } | { readonly kind: "foreign-material"; readonly material: unknown; } | { readonly kind: "foreign-mesh"; readonly mesh: unknown; }

type FxRetainedVolumeBoundary = "wrap" | "clamp" | "zero";

interface FxRetainedVolumeBounds {

  readonly center: Vector3Like;

  readonly halfExtents: Vector3Like;

  readonly kind: WaveRangeAabbShape["kind"];

}

interface FxRetainedVolumeDefinition {

  readonly boundary: FxRetainedVolumeBoundary;

  readonly bounds: FxRetainedVolumeBounds;

  readonly evolution: { readonly retain?: WaveValueExpr; readonly decay?: WaveValueExpr; readonly diffuse?: WaveValueExpr; readonly addDeposits?: boolean; readonly clamp?: { readonly vectorMagnitude?: WaveValueExpr; readonly scalarMin?: WaveValueExpr; readonly scalarMax?: WaveValueExpr; }; }

  readonly id: string;

  readonly initialState: { readonly kind: "zero"; } | { readonly kind: "dense"; readonly cells: readonly FxRetainedVolumeSeedCell[]; }

  readonly resolution: { readonly x: number; readonly y: number; readonly z: number; }

}

interface FxRetainedVolumeSeedCell {

  readonly scalar: number;

  readonly vector: Vector3Like;

}

interface FxRibbonRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  bindings: { position: "Particles.Position"; color?: string; width?: string; ribbonId?: string; }

  ribbon: { maxPoints: number; worldSpace?: boolean; fadeByAge?: boolean; widthOverLength?: WaveValueCurveSpec; smoothing?: number; maxSegmentLength?: number; bundle?: { strandCount?: number; spread?: number; spreadOverLength?: WaveValueCurveSpec; twistOverLength?: WaveValueCurveSpec; twist?: number; phaseSpeed?: number; jitter?: number; strandWidthScale?: number; }; }

  textureAsset?: string;

  textureMode?: "stretch" | "tile" | "distanceRepeat";

  textureRepeatDistance?: number;

  type: "ribbon";

}

interface FxRootTableEntry {

  forward?: Vector3Like;

  position: Vector3Like;

  rootId: string;

  scale?: number;

  seed: number;

  up?: Vector3Like;

}

interface FxScalabilityPolicy {

  budgets?: { maxInstances?: number; maxEmittersPerInstance?: number; maxTotalParticles?: number; }

  cullDistance?: number;

  fixedBounds?: { min: Vector3Like; max: Vector3Like; }

  lodDistances?: number[];

}

interface FxScreenLayerRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  distance?: number;

  emissiveIntensity?: number;

  fit?: "stretch";

  flipbook?: { columns: number; rows: number; frameRate: number; startFrame?: number; playMode: "once" | "loop"; interpolation?: "none" | "crossfade"; }

  ignoreSceneLighting?: boolean;

  opacity?: number;

  textureAsset: string;

  type: "screenLayer";

}

interface FxScreenLayerTerminal {

  readonly kind: "screenLayer";

  readonly rendererIndex: number;

}

interface FxScriptStack {

  modules: FxModuleInvocation[];

}

type FxSimTarget = "none" | "auto" | "gpu" | "cpu";

interface FxSmokeBudgetOptions {

  maxParticles?: number;

  maxSpawnPerFrame?: number;

}

declare class FxSmokeController {

  constructor(facade: FxFacade, systemId: FxSystemId, opts?: FxCreateSmokeOptions);

  at(anchor: WaveFxAnchorBinding): this;

  balanced(): this;

  billowy(): this;

  budget(budgets: FxSmokeBudgetOptions): this;

  build(): WaveFxSystemAsset;

  color(color: WaveColorValueInput): this;

  dense(rate?: WaveNumberValueInput): this;

  density(rate: WaveNumberValueInput): this;

  emit(direction: NonNullable<ExhaustOpts["direction"]>): this;

  emitAgainstMotion(speed?: WaveNumberValueInput): this;

  emitLocal(direction: NonNullable<ExhaustOpts["direction"]>): this;

  emitWithMotion(speed?: WaveNumberValueInput): this;

  falling(speed?: WaveNumberValueInput): this;

  heavy(rate?: WaveNumberValueInput): this;

  heroBudget(): this;

  lifetime(lifetime: WaveNumberValueInput): this;

  lingering(lifetime?: WaveNumberValueInput): this;

  offset(offset: Partial<Vector3Like>): this;

  play(opts?: FxSmokePlayOptions): FxTrackController;

  playEachAt<TItem>(items: readonly TItem[], opts: FxSmokePlayEachAtOptions<TItem>): FxTrackController[];

  quality(quality: FxSmokeQuality): this;

  rising(speed?: WaveNumberValueInput): this;

  size(size: WaveNumberValueInput): this;

  speed(speed: WaveNumberValueInput): this;

  spread(angle: WaveNumberValueInput): this;

  texture(texture: string): this;

  tight(): this;

  track(trackName: string): this;

  wide(angle?: WaveNumberValueInput): this;

}

interface FxSmokePlayEachAtOptions<TItem> {

  activeWhen?: FxTrackCondition;

  anchor: (item: TItem, index: number) => WaveFxAnchorBinding;

  inactiveBehavior?: FxTrackInactiveBehavior;

  seed?: number;

  startPaused?: boolean;

  trackName?: (item: TItem, index: number) => string;

  trackPrefix?: string;

  userParams?: Record<string, WaveValue>;

}

interface FxSmokePlayOptions {

  activeWhen?: FxTrackCondition | undefined;

  anchor?: WaveFxAnchorBinding | undefined;

  inactiveBehavior?: FxTrackInactiveBehavior | undefined;

  renderingGroupId?: number | undefined;

  seed?: number | undefined;

  startPaused?: boolean | undefined;

  userParams?: Record<string, WaveValue> | undefined;

  track?: string;

}

type FxSmokeQuality = "low" | "medium" | "high" | "hero";

interface FxSpriteBatchTerminal {

  readonly kind: "spriteBatch";

  readonly rendererIndex: number;

}

interface FxSpriteRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  billboardMode?: "all" | "y" | "none" | "stretched" | "faceAnchor";

  bindings: { position: "Particles.Position"; size?: string; color?: string; rotation?: string; spriteFrame?: string; }

  cellSize?: number | { width: number; height: number; }

  flipbook?: { columns: number; rows: number; frameRate: number; startFrame?: WaveValueExpr; playMode: "once" | "loop"; driveByAge?: boolean; interpolation?: "none" | "crossfade"; }

  material?: string;

  noMipmap?: boolean;

  sortMode?: "none" | "backToFront" | "frontToBack" | "byAge";

  spriteAnimation?: { atlasAsset: string; animation: string; speed?: number; }

  textureAsset?: string;

  type: "sprite";

  uvInset?: number;

}

interface FxStateSnapshot {

  instances: Record<FxInstanceId, FxInstanceSnapshot>;

  nextInstanceId: number;

}

interface FxStopOptions {

  fade?: WaveTimeSpanSpec;

}

interface FxSurfaceEffectRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  colorRamp: readonly ColorGradientStopAlpha[];

  coverage: WaveValueExpr;

  coverageMode?: "effectMask" | "surfaceDissolve";

  edgeColor?: ColorInputAlpha;

  edgeSoftness?: WaveValueExpr;

  emissionIntensity?: WaveValueExpr;

  material?: "surfaceEffect_default" | "surfaceEffect_portal";

  noise: { type: "simple" | "perlin" | "voronoi" | "worley"; scale: WaveValueExpr; scrollVelocity?: Vector3Like; distortion?: { scale: WaveValueExpr; strength: WaveValueExpr; scrollVelocity?: Vector3Like; }; }

  portal?: { center?: Vector3Like; swirl?: WaveValueExpr; radialScale?: WaveValueExpr; }

  surface: { source: WaveSurfaceSourceStructure; normalOffset?: WaveValueExpr; twoSided?: boolean; }

  triplanarSharpness?: WaveValueExpr;

  type: "surfaceEffect";

  uvMode: "meshUV" | "triplanar";

  vertexDisplacement?: { strength: WaveValueExpr; followNoise?: boolean; noiseScale?: WaveValueExpr; }

}

interface FxSurfaceSnapOptions {

  fallbackToWorldPoint?: boolean;

  forward?: DirectionInput;

  offset?: number;

}

interface FxSurfaceSnapSource {

  getHeightAt?: (x: number, z: number) => number | null | undefined;

  getNormalAt?: (x: number, z: number) => FxSurfaceVector3 | null | undefined;

  heightAt?: (x: number, z: number) => number | null | undefined;

  normalAt?: (x: number, z: number) => FxSurfaceVector3 | null | undefined;

}

interface FxSurfaceVector3 {

  x: number;

  y: number;

  z: number;

}

interface FxSystemDefinition {

  authority?: FxAuthorityMode;

  emitterLibrary: FxEmitterDefinition[];

  emitters: FxSystemEmitterBinding[];

  id: string;

  scalability?: FxScalabilityPolicy;

  systemScripts?: Partial<FxSystemScripts>;

  userParameters: FxUserParamSchema[];

}

interface FxSystemEmitterBinding {

  anchor?: WaveFxAnchorBinding;

  emitterId: string;

  emitterParams?: Record<string, WaveValue>;

  enabled?: WaveBoolExpr;

}

type FxSystemId = string;

interface FxSystemScripts {

  systemSpawn: FxScriptStack;

  systemUpdate: FxScriptStack;

}

interface FxTableCollisionSurfaceOpts {

  center: Vector3Like;

  depth: NumLike;

  normal?: DirectionInput;

  u?: DirectionInput;

  width: NumLike;

}

interface FxTerrainCollisionSurfaceOpts {

  channelId?: string;

  heightOffset?: NumLike;

}

interface FxTextBatchTerminal {

  readonly kind: "textBatch";

  readonly rendererIndex: number;

}

interface FxTextRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  billboardMode?: "all" | "none";

  bindings: { position: string; size?: string; color?: string; }

  fontAsset: string;

  size?: number;

  text: string;

  type: "text";

}

type FxTrackCondition = { type: "metric"; source: FxTrackMetricSource; op: "above" | "below" | "between"; value: number; maxValue?: number; hysteresis?: number; } | { type: "all"; conditions: FxTrackCondition[]; } | { type: "any"; conditions: FxTrackCondition[]; } | { type: "not"; condition: FxTrackCondition; }

interface FxTrackConditionMetricOptions {

  hysteresis?: number;

}

interface FxTrackController {

  activeWhen(condition: FxTrackCondition): FxTrackController;

  bindUserParam(name: string): FxUserParamBindingBuilder;

  clear(): void;

  clearActiveWhen(): FxTrackController;

  drain(): FxTrackController;

  drainWhenFalse(): FxTrackController;

  readonly id: FxInstanceId;

  pause(): FxTrackController;

  pauseWhenFalse(): FxTrackController;

  play(systemId: FxPlayableSystem, opts?: FxPlayOptions): FxTrackController;

  reset(): FxTrackController;

  restart(): FxTrackController;

  resume(): FxTrackController;

  setUserParam(name: string, value: FxValue): FxTrackController;

  setUserParams(values: Record<string, FxValue>): FxTrackController;

  stop(opts?: FxStopOptions): FxTrackController;

  stopWhenFalse(fade?: WaveTimeSpanSpec): FxTrackController;

  readonly systemId: FxSystemId | null;

  readonly track: string;

  triggerEvent(eventName: string, payload?: Record<string, FxValue>): void;

  warningState(warningActive: boolean, values: { normal: Record<string, FxValue>; warning: Record<string, FxValue>; }): FxTrackController;

}

interface FxTrackInactiveBehavior {

  action: "pause" | "drain" | "stop";

  fade?: WaveTimeSpanSpec;

}

type FxTrackMetricSource = "transform.speed" | "transform.bankAngle";

interface FxUserParamBinding {

  expression: WaveValueExpr;

  param: string;

  response: FxUserParamExponentialResponse;

}

declare class FxUserParamBindingBuilder {

  apply(): FxTrackController;

  respondsExponentially(options: FxUserParamExponentialResponseOptions): this;

  to(expression: FxExpr): this;

}

interface FxUserParamExponentialResponse {

  fallRate: number;

  initial: number;

  riseRate: number;

  type: "exponential";

}

interface FxUserParamExponentialResponseOptions {

  fallRate: number;

  initial: number;

  riseRate: number;

}

interface FxUserParamSchema {

  alias?: string;

  clamp?: { min?: number; max?: number; }

  default: WaveValue;

  name: string;

  replicate?: "never" | "value";

  type: WaveValueKind;

}

type FxValueCurveInput = WaveValueCurveInput | readonly FxCurveTuple[];

interface FxValueCurveSamplingOptions {

  sampleCount?: number;

}

type FxVelocityConeDirectionInput = DirectionInput | FxExpr;

interface FxVolumeShellRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  material: string;

  shaderFeatures?: { fresnel?: { power?: WaveValueExpr; color?: ColorInputAlpha; }; depthIntersection?: { thickness?: WaveValueExpr; color?: ColorInputAlpha; }; gridPattern?: { textureAsset: string; scrollSpeed?: Vector2Like; tiling?: Vector2Like; }; scanline?: { speed?: WaveValueExpr; width?: WaveValueExpr; color?: ColorInputAlpha; }; impactRipple?: { maxConcurrent?: number; speed?: WaveValueExpr; width?: WaveValueExpr; color?: ColorInputAlpha; fadeTime?: number; }; }

  shell: { structure: WaveRangeShape | WaveSurfaceSourceStructure; length?: WaveValueExpr; radius?: WaveValueExpr; normalOffset?: WaveValueExpr; twoSided?: boolean; }

  type: "volumeShell";

}

interface FxWeaponSwooshRendererSpec {

  alphaIndex?: number | undefined;

  blendMode?: "multiply" | "alpha" | "additive" | undefined;

  depthWrite?: boolean | undefined;

  enabled?: WaveBoolExpr | undefined;

  glow?: FxGlowConfig | undefined;

  id: string;

  optional?: boolean | undefined;

  renderingGroupId?: number | undefined;

  visualLayer?: VisualLayer | undefined;

  anchors: { base: WaveFxAnchorBinding; tip: WaveFxAnchorBinding; }

  color?: ColorInputAlpha;

  outerColor?: ColorInputAlpha;

  textureAsset?: string;

  textureMode?: "stretch" | "tile" | "distanceRepeat";

  textureRepeatDistance?: number;

  type: "weaponSwoosh";

  weaponSwoosh: { maxPoints: number; lifetimeSeconds?: number; minSampleDistance?: number; fadeByAge?: boolean; innerAlphaScale?: number; scatter?: number; }

}

declare enum GamepadAxis {

  LeftX = 0,

  LeftY = 1,

  RightX = 2,

  RightY = 3,

}

interface GamepadAxisInputData {

  gamepadIndex: number;

  leftStick: SerializableVector2;

  leftTrigger: number;

  rightStick: SerializableVector2;

  rightTrigger: number;

  timestamp: number;

}

declare enum GamepadButton {

  Bottom = 0,

  Center = 16,

  DpadDown = 13,

  DpadLeft = 14,

  DpadRight = 15,

  DpadUp = 12,

  L1 = 4,

  L2 = 6,

  L3 = 10,

  Left = 2,

  R1 = 5,

  R2 = 7,

  R3 = 11,

  Right = 1,

  Select = 8,

  Start = 9,

  Top = 3,

}

interface GamepadButtonInputData {

  button: GamepadButton | number;

  gamepadIndex: number;

  heldDurationMs: number;

  heldFor: WaveTimeSpan;

  heldTicks: number;

  timestamp: number;

  value: number;

}

type GeneratedAssetCloneReuseIntent = "modelDefault" | "sharedUntilRegenerate" | "independent";

interface GeometryInfluenceViewMeshState {

  readonly meshName?: string;

  readonly meshSourceRef?: string;

  readonly meshUniqueId?: number;

  readonly values: Float32Array;

}

interface GeometryInfluenceViewModelState {

  readonly enabled: boolean;

  readonly mode?: GeometryInfluenceViewMode;

  readonly parts: readonly GeometryInfluenceViewMeshState[];

  readonly source?: string | number;

  readonly threshold?: number;

}

interface GeoPOIFeature {

  latitude: number;

  longitude: number;

  category: string;

  id: string;

  name: string;

  properties?: Record<string, unknown>;

}

interface GeospatialCameraControlConfig {

  center?: GeospatialECEFCoordinate;

  controls?: GeospatialCameraControlsConfig;

  fovRadians?: number;

  limits?: GeospatialCameraLimitsConfig;

  pitchRadians?: number;

  radius?: number;

  yawRadians?: number;

}

interface GeospatialCameraControlInput {

  center?: Vec3Like;

  controls?: GeospatialCameraControlsConfig;

  fovDegrees?: number;

  fovRadians?: number;

  latLon?: GeospatialLatLonInput;

  limits?: GeospatialCameraLimitsConfig;

  pitchRadians?: number;

  radius?: number;

  yawRadians?: number;

}

interface GeospatialCameraControlsConfig {

  attachControl?: boolean;

  checkCollisions?: boolean;

  enableClippingBehavior?: boolean;

  mouseWheelPrecision?: number;

  pointerPanSensitivity?: number;

  pointerRotateSensitivity?: number;

}

interface GeospatialCameraControlSettings {

  controls?: GeospatialCameraControlsConfig;

  limits?: GeospatialCameraLimitsConfig;

}

interface GeospatialCameraLimitsConfig {

  pitchMax?: number;

  pitchMin?: number;

  planetRadius?: number;

  radiusMax?: number;

  radiusMin?: number;

  yawMax?: number;

  yawMin?: number;

}

interface GeospatialCameraOrbitInput {

  fovDegrees?: number;

  fovRadians?: number;

  pitchRadians?: number;

  radius?: number;

  yawRadians?: number;

}

interface GeospatialECEFCoordinate {

  x: number;

  y: number;

  z: number;

}

interface GeospatialLatLonInput {

  altitudeMeters?: number;

  latitudeDegrees: number;

  longitudeDegrees: number;

}

interface GestureOrbitOptions {

  panSensitivity?: number;

  rotateSensitivity?: number;

  zoomSensitivity?: number;

}

interface GltfClipBindingValue {

  readonly channels: readonly GltfClipChannelTemplate[];

  readonly descriptor: ModelEmbeddedAnimationDescriptor;

  readonly facts: GltfClipTemplateFacts;

  readonly kind: "gltfClip";

  readonly payloadKind: "gltfClip";

  readonly ref: ExactAssetRef<"animation">;

}

interface GltfClipChannelTargetAddress {

  readonly boneName?: string;

  readonly kind: GltfClipChannelTargetKind;

  readonly meshId?: string;

  readonly meshName?: string;

  readonly morphTargetIndex?: number;

  readonly morphTargetName?: string;

  readonly ownerClass?: string;

  readonly partId?: string;

  readonly path: string;

  readonly property: string;

  readonly skeletonName?: string;

  readonly targetName: string;

}

type GltfClipChannelTargetKind = "skeleton" | "node" | "morph" | "property";

interface GltfClipChannelTemplate {

  readonly address: GltfClipChannelTargetAddress;

  readonly animation: Animation;

}

interface GltfClipSelector {

  readonly groupIndex?: number;

  readonly groupName: string;

}

interface GltfClipTemplateFacts {

  readonly from: number;

  readonly name: string;

  readonly to: number;

}

declare enum GoalType {

  Maximize = "Maximize",

  Minimize = "Minimize",

}

interface GoogleMaps3DTilesSourceAttributionPolicy {

  warnWhenMissing?: boolean;

}

type GoogleMaps3DTilesSourceConfig = WaveWorldSourceConfig<GoogleMaps3DTilesSourceOptions>;

interface GoogleMaps3DTilesSourceOptions {

  apiKey: string;

  attribution?: GoogleMaps3DTilesSourceAttributionPolicy;

  rootTilesetUrl?: string;

}

type GpuDataTextureSamplingMode = "nearest" | "linear" | "bilinear" | "trilinear";

type GpuDataTextureWrapMode = "clamp" | "repeat" | "mirror";

interface GradientColorStop {

  color: ColorInput;

  position: number;

}

interface GrainOptions {

  animated?: boolean;

  intensity?: number;

}

declare const GRASS_PARTS: Readonly<{ readonly blade: "blade"; readonly mediumBlade: "mediumBlade"; readonly lowBlade: "lowBlade"; }>;

interface Grid3DStreamingChunkData {

  col: number;

  key: ChunkKey;

  layer: number;

  row: number;

}

declare class Grid3DStreamingProvider implements StreamingProvider<Grid3DStreamingChunkData, Grid3DStreamingSlot, Grid3DStreamingWorkerRequest> {

  constructor(_options: Grid3DStreamingProviderOptions);

  computeActiveChunks(cameraPosition: Vector3Like): ChunkKey[];

  computeActiveChunksToRef(cameraPosition: Vector3Like, out: ChunkKey[]): ChunkKey[];

  createChunkSlot(key: ChunkKey): Grid3DStreamingSlot;

  createWorkerRequest(key: ChunkKey): Grid3DStreamingWorkerRequest;

  dispose(): void;

  disposeChunkSlot(_slot: Grid3DStreamingSlot): void;

  generateChunk(key: ChunkKey): Grid3DStreamingChunkData;

  getSeed(): number;

  getWorkerSource(): string;

  readonly id: StreamingProviderIdLike;

  initializeGrid(config: unknown): ChunkKey[];

  materializeChunk(_key: ChunkKey, _data: Grid3DStreamingChunkData, _slot: Grid3DStreamingSlot): void;

  prepareChunkSlot(slot: Grid3DStreamingSlot, key: ChunkKey): void;

  querySurface(position: SurfaceQueryPoint): SurfaceQueryResult | null;

  querySurfaceToRef(position: SurfaceQueryPoint, out: SurfaceQueryResult): SurfaceQueryResult | null;

  recycleChunkSlot(_slot: Grid3DStreamingSlot): void;

  readonly workerCapable = true;

}

interface Grid3DStreamingProviderOptions {

  endless?: boolean;

  gridInfo: GridLayout | (() => GridLayout);

  id?: StreamingProviderIdLike;

  querySurface?: (position: SurfaceQueryPoint, cell: GridCellIndex) => SurfaceQueryResult | null;

  radius?: number | Partial<Grid3DStreamingRadius>;

  seed?: number;

  surfaceY?: number | ((position: Vector3Like, cell: GridCellIndex) => number | null);

}

interface Grid3DStreamingRadius {

  cols: number;

  layers: number;

  rows: number;

}

interface Grid3DStreamingSlot {

  col: number;

  key: string;

  layer: number;

  row: number;

  bounds: ChunkBoundsXZ;

  depth: number;

  width: number;

  worldCenterX: number;

  worldCenterY: number;

  worldCenterZ: number;

}

interface Grid3DStreamingWorkerRequest {

  key: ChunkKey;

}

interface GridCellIndex {

  col: number;

  layer: number;

  row: number;

}

type GridCellSnapMode = GridIndexSnapMode;

type GridIndexSnapMode = "nearest" | "floor" | "ceil";

interface GridLayout {

  cols: number;

  colSpacing: number;

  gridTopology?: GridTopology;

  layers: number;

  layerSpacing: number;

  origin: Vector3Like;

  plane: WavePlaneFrameInput;

  rows: number;

  rowSpacing: number;

}

interface GridPathSource<T extends WaveSpatial3DObject> {

  findCell(entity: T): GridCellIndex | null;

  getCell(row: number, col: number, layer?: number): T | undefined;

  getCellCoordinatesAtWorldPosition(position: Vector3Like, snap?: GridCellSnapMode): GridCellIndex | null;

  getCellWorldPosition(row: number, col: number, layer?: number): Vector3;

  readonly gridInfo: Pick<GridLayout, "rows" | "cols" | "layers" | "gridTopology">;

}

type GridTopology = "rectilinear" | "hexagon";

interface HeightfieldData {

  columns: number;

  data: Float32Array;

  maxHeight: number;

  minHeight: number;

  rows: number;

  worldDepth: number;

  worldWidth: number;

}

interface HeightfieldSurfaceOpts {

  layerId?: string;

  surfaceDirection?: WaveHeightfieldSurfaceDirection;

}

interface HingeConfig {

  axisA?: DirectionInput | undefined;

  axisB?: DirectionInput | undefined;

  enableCollisions?: boolean | undefined;

  limits?: AxisLimit[] | undefined;

  motors?: MotorConfig[] | undefined;

  perpAxisA?: DirectionInput | undefined;

  perpAxisB?: DirectionInput | undefined;

  pivotA?: any;

  pivotB?: any;

  angularLimit?: { min: number; max: number; }

  type: ConstraintType.Hinge;

}

interface HotReloadAssetPolicy {

  changed: boolean;

  level: HotReloadAssetSurfaceLevel;

  preloadAssets: string[];

  reasons: string[];

}

type HotReloadAssetSurfaceLevel = "preserve" | "patch" | "full";

type HotReloadGpuResetLevel = "none" | "minimal-cache-reset" | "babylon-cache-soft-reset" | "scene-replacement-soft-reset" | "diagnostic-canvas-cycle";

type HotReloadRuntimeResetLevel = "main-runtime-only" | "scene-rebuild-preserve-babylon-scene" | "subsystem-rebootstrap-preserve-babylon-scene" | "scene-replacement";

interface HotReloadSurfacePolicy {

  assets: HotReloadAssetPolicy;

  changedSurfaces: string[];

  gpuReset: HotReloadGpuResetLevel;

  intent: WaveHotReloadIntent;

  reasons: string[];

  runtimeReset: HotReloadRuntimeResetLevel;

  systemAdmissions?: HotReloadSystemAdmission[];

  systemsMayVeto: boolean;

  terrain: HotReloadTerrainPolicy;

  tier: WaveSceneHotReloadTier;

  worldStreaming: HotReloadWorldStreamingPolicy;

}

interface HotReloadSystemAdmission {

  accepted: boolean;

  reasons: string[];

  requiredGpuReset: HotReloadGpuResetLevel;

  requiredRuntimeReset: HotReloadRuntimeResetLevel;

  systemName: string;

}

interface HotReloadTerrainPolicy {

  changed: boolean;

  level: HotReloadTerrainSurfaceLevel;

  reasons: string[];

}

type HotReloadTerrainSurfaceLevel = "preserve" | "patch" | "rebuild-terrain-runtime" | "full";

interface HotReloadWorldStreamingPolicy {

  changed: boolean;

  level: HotReloadWorldStreamingSurfaceLevel;

  reasons: string[];

}

type HotReloadWorldStreamingSurfaceLevel = "preserve" | "patch" | "rebootstrap-streaming-runtime" | "full";

declare const HOUSE_PARTS: Readonly<{ readonly frontWall: "frontWall"; readonly backWall: "backWall"; readonly leftWall: "leftWall"; readonly rightWall: "rightWall"; readonly floor: "floor"; readonly roof: "roof"; readonly door: "door"; readonly chimney: "chimney"; readonly frontWindow: "frontWindow"; readonly backWindow: "backWindow"; readonly leftWindow: "leftWindow"; readonly rightWindow: "rightWindow"; }>;

type HttpAccessMode = "direct" | "hostProxy";

type HttpBody = { type: "none"; } | { type: "json"; json: unknown; } | { type: "text"; text: string; contentType?: string; } | { type: "base64"; dataBase64: string; mimeType?: string; }

interface HttpConfig {

  allowClientDirect?: boolean;

  clientAccessMode?: HttpAccessMode;

  defaultEndpointId: string;

  endpoints: Record<string, Omit<HttpEndpointConfig, "id">>;

  maxPayloadBytes?: number;

  redactSecrets?: boolean;

  requestContext?: WaveRequestContextPolicy;

  retries?: number;

  timeoutMs?: number;

}

interface HttpEndpointAuthConfig {

  headerName?: string;

  queryParam?: string;

  type: "bearer" | "apiKeyHeader" | "apiKeyQuery";

}

interface HttpEndpointConfig {

  auth?: HttpEndpointAuthConfig;

  headers?: Record<string, string>;

  id: string;

  maxPayloadBytes?: number;

  method?: HttpMethod;

  retries?: number;

  timeoutMs?: number;

  url: string;

}

type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";

interface HttpRequest {

  body?: HttpBody;

  disableAuth?: boolean;

  endpointId?: string;

  headers?: Record<string, string>;

  method?: HttpMethod;

  path?: string;

  query?: Record<string, string | number | boolean | undefined | null>;

  responseType?: HttpResponseType;

  retries?: number;

  timeoutMs?: number;

  urlOverride?: string;

}

interface HttpRequestRuntimeOptions {

  accessMode?: HttpAccessMode;

  targetClientId?: string;

}

interface HttpResponse {

  dataBase64?: string;

  endpointId?: string;

  headers: Record<string, string>;

  json?: unknown;

  mimeType?: string;

  ok: boolean;

  raw?: unknown;

  requestId?: string;

  status: number;

  text?: string;

  url?: string;

}

type HttpResponseType = "auto" | "json" | "text" | "base64";

declare enum HumanoidAnimState {

  CROUCH = "crouch",

  CUSTOM = "custom",

  FALL = "fall",

  IDLE = "idle",

  JUMP = "jump",

  RUN = "run",

  WALK = "walk",

}

declare enum HumanoidBone {

  CHEST = "chest",

  HEAD = "head",

  HIPS = "hips",

  LEFT_FOOT = "leftFoot",

  LEFT_HAND = "leftHand",

  LEFT_LOWER_ARM = "leftLowerArm",

  LEFT_LOWER_LEG = "leftLowerLeg",

  LEFT_SHOULDER = "leftShoulder",

  LEFT_UPPER_ARM = "leftUpperArm",

  LEFT_UPPER_LEG = "leftUpperLeg",

  NECK = "neck",

  RIGHT_FOOT = "rightFoot",

  RIGHT_HAND = "rightHand",

  RIGHT_LOWER_ARM = "rightLowerArm",

  RIGHT_LOWER_LEG = "rightLowerLeg",

  RIGHT_SHOULDER = "rightShoulder",

  RIGHT_UPPER_ARM = "rightUpperArm",

  RIGHT_UPPER_LEG = "rightUpperLeg",

  ROOT = "root",

  SPINE = "spine",

}

interface IBLState {

  intensity: number;

  texture: string;

}

interface IdentityAdapter {

  readonly adapterName: string;

  broadcastSnapshot?(): void;

  configureHttp?(config: HttpConfig | null): void;

  configureLLM?(config: LLMConfig | null): void;

  readonly connectionState?: string;

  dispose(): void;

  filterComponentsForIdentity?(components: string[]): string[];

  getClients?(): ClientInfo[];

  getEntity(networkId: number): WaveEntity | undefined;

  initialize(engine: BaseEngineRef): Promise<void>;

  initialized: boolean;

  interceptComponent?<T extends WaveComponent>(entity: WaveEntity, component: T): T;

  invokeRPC(networkId: number, methodName: string, args: unknown[], targetClients?: string[]): void;

  kickClient?(clientId: string, reason?: string): void;

  readonly onboardingProgress?: number;

  onNetworkReady?(): void;

  onSnapshot?(snapshot: unknown): void;

  openComponentPresentationCommandStream?(config: ComponentPresentationCommandStreamConfig): ComponentPresentationCommandStream | null;

  preparePresentationState?(): void;

  registerComponent(component: WaveComponent): void;

  registerEntity(entity: WaveEntity, networkId?: number): void;

  requestHttp?(request: HttpRequest, options?: HttpRequestRuntimeOptions): Promise<HttpResponse>;

  requestLLM?(request: LLMRequest, options?: LLMRequestRuntimeOptions): Promise<LLMResponse>;

  setHttpApiKey?(endpointId: string, apiKey: string): void;

  setLLMApiKey?(endpointId: string, apiKey: string): void;

  signalReady?(): void;

  unregisterComponent(component: WaveComponent): void;

  unregisterEntity(networkId: number): void;

  upsertHttpEndpoint?(endpoint: HttpEndpointConfig, options?: { makeDefault?: boolean; allowClientDirect?: boolean; clientAccessMode?: HttpAccessMode; timeoutMs?: number; retries?: number; maxPayloadBytes?: number; redactSecrets?: boolean; }): void;

}

interface ImageProcessingOptions {

  colorCurvesEnabled?: boolean;

  contrast?: number;

  exposure?: number;

  toneMappingEnabled?: boolean;

  toneMappingType?: number;

  vignetteBlendMode?: number;

  vignetteColor?: ColorInputAlpha;

  vignetteEnabled?: boolean;

  vignetteWeight?: number;

}

interface ImpactBurstOpts {

  anchorOffset?: Partial<Vector3Like>;

  billboard?: SpriteOpts["billboard"];

  blend?: SpriteOpts["blend"];

  color?: ColorLike;

  count?: NumLike;

  direction?: FxVelocityConeDirectionInput;

  directionSpace?: VelocityConeDirectionSpace;

  drag?: NumLike;

  fade?: [number, number][];

  glow?: SpriteOpts["glow"];

  growth?: [number, number][];

  lifetime?: NumLike;

  size?: NumLike;

  sort?: SpriteOpts["sort"];

  speed?: NumLike;

  spin?: boolean | NumLike;

  spreadAngle?: NumLike;

  style?: "tight" | "balanced" | "flashy";

  texture: string;

}

interface ImpactSparkOptions {

  angle?: number;

  count?: number;

  drag?: number;

  lifetime?: number | [number, number];

  size?: number | [number, number];

  speed?: number | [number, number];

}

interface InputAdapterConfig {

  customMappings?: Record<string, string>;

  deviceType: string;

  invertX: boolean;

  invertY: boolean;

  lookCurve: "linear" | "quadratic" | "cubic";

  lookDeadZone: number;

  moveCurve: "linear" | "quadratic" | "cubic";

  moveDeadZone: number;

}

type InputCallback<TData = unknown, TOwner extends WaveEntity = WaveEntity> = (ctx: InputCallbackContext<TOwner, TData>) => void;

interface InputCallbackContext<TOwner extends WaveEntity = WaveEntity, TData = unknown> {

  data: TData;

  owner: TOwner;

}

declare enum InputDeviceType {

  Audio = 6,

  Gamepad = 3,

  KeyboardDevice = 0,

  Motion = 4,

  Mouse = 1,

  Touch = 2,

  Vision = 7,

  XR = 5,

}

declare enum InputEventType {

  AudioLoudnessPeak = 151,

  AudioSpeech = 150,

  GamepadButtonHolding = 92,

  GamepadButtonPress = 90,

  GamepadButtonRelease = 91,

  GamepadConnected = 97,

  GamepadDisconnected = 98,

  GamepadLeftStickMove = 93,

  GamepadLeftTrigger = 95,

  GamepadRightStickMove = 94,

  GamepadRightTrigger = 96,

  KeyHolding = 2,

  KeyPress = 0,

  KeyRelease = 1,

  MotionAcceleration = 110,

  MotionOrientationChange = 112,

  MotionRotation = 111,

  MotionShake = 113,

  MotionTilt = 114,

  MouseButtonDown = 10,

  MouseButtonHolding = 12,

  MouseButtonUp = 11,

  MouseClick = 13,

  MouseClickOn = 33,

  MouseDoubleClick = 14,

  MouseDoubleClickOn = 34,

  MouseDragEnd = 39,

  MouseDragMove = 38,

  MouseDragStart = 37,

  MouseHoldingOn = 40,

  MouseIntersectionEnter = 30,

  MouseIntersectionExit = 32,

  MouseIntersectionOn = 31,

  MouseMove = 15,

  MouseMoveDown = 17,

  MouseMoveLeft = 18,

  MouseMoveRight = 19,

  MouseMoveUp = 16,

  MousePressOn = 36,

  MouseReleaseOn = 35,

  MouseWheel = 20,

  MouseWheelDown = 22,

  MouseWheelUp = 21,

  TouchDoubleTap = 54,

  TouchDoubleTapOn = 74,

  TouchDown = 50,

  TouchDragEndOn = 79,

  TouchDragMoveOn = 78,

  TouchDragStartOn = 77,

  TouchHolding = 52,

  TouchHoldingOn = 76,

  TouchIntersectionEnter = 70,

  TouchIntersectionExit = 72,

  TouchIntersectionOn = 71,

  TouchMove = 55,

  TouchMoveDown = 57,

  TouchMoveLeft = 58,

  TouchMoveRight = 59,

  TouchMoveUp = 56,

  TouchPinchEnd = 62,

  TouchPinchMove = 61,

  TouchPinchStart = 60,

  TouchReleaseOn = 75,

  TouchRotateEnd = 65,

  TouchRotateMove = 64,

  TouchRotateStart = 63,

  TouchSwipeDown = 67,

  TouchSwipeLeft = 68,

  TouchSwipeRight = 69,

  TouchSwipeUp = 66,

  TouchTap = 53,

  TouchTapOn = 73,

  TouchUp = 51,

  UICanvasClick = 197,

  UICanvasPointerDown = 194,

  UICanvasPointerMove = 195,

  UICanvasPointerUp = 196,

  UIClick = 190,

  UIHolding = 202,

  UIHover = 199,

  UIHoverEnter = 198,

  UIHoverExit = 200,

  UIInputChange = 193,

  UIInputSubmit = 205,

  UIPress = 201,

  UIRelease = 203,

  UISliderChange = 191,

  UIToggle = 192,

  UITouch = 204,

  VisionGesture = 170,

  VisionHandDetected = 171,

  VisionHandLost = 172,

  XRControllerButtonHolding = 132,

  XRControllerButtonPress = 130,

  XRControllerButtonRelease = 131,

  XRControllerMove = 133,

  XRControllerRotate = 134,

  XRGaze = 138,

  XRHandGesture = 137,

  XRHandGrip = 136,

  XRHandPinch = 135,

}

type InputModifier = DeadZoneModifier | InvertModifier | ScaleModifier | ClampModifier | SmoothModifier | SwizzleModifier | NegateModifier | CurveModifier;

declare enum InputRegime {

  AR = "ar",

  Auto = "auto",

  Desktop = "desktop",

  Gamepad = "gamepad",

  Mobile = "mobile",

  Tablet = "tablet",

  VR = "vr",

}

interface InstanceMeshConfig {

  castShadow?: boolean;

  forceActiveWhenOffscreen?: boolean;

  glowColor?: ColorInput | null;

  glowEnabled?: boolean;

  glowIntensity?: number;

  model: string | AssetRef<"model"> | WaveModelInput | ModelConsumerSource;

}

interface InstanceMeshGroupOptions {

  readonly createInstance?: () => waveInstanceMesh;

  readonly instanceNamePrefix?: string;

}

type InstanceMeshModelInput = string | AssetRef<"model"> | WaveModelInput | ModelConsumerSource;

interface InstrumentBootstrapContext<TEngine extends unknown = unknown> {

  readonly engine: TEngine;

  readonly instruments: InstrumentBootstrapRegistry;

  readonly scene: WaveScene<TEngine>;

}

type InstrumentBootstrapFunction<TEngine extends unknown = unknown> = (context: InstrumentBootstrapContext<TEngine>) => Promise<void> | void;

interface InstrumentBootstrapRegistry {

  addAsset(asset: string, options?: WaveInstrumentAliasOptions): string;

  addConfig(config: WaveInstrumentConfig, options?: WaveInstrumentAliasOptions): string;

  addPreset(preset: WaveInstrumentPreset, options?: WaveInstrumentAliasOptions): string;

  has(ref: string): boolean;

  listDeclared(): readonly string[];

  prepare(...instrumentRefs: string[]): void;

  prepareAllDeclared(): void;

}

type InteractionCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: InteractionContext<TOwner>) => void;

type InteractionCallbackOptions = BaseInteractableCallbackOptions;

interface InteractionContext<TOwner extends WaveEntity = WaveEntity> {

  data: InteractionData;

  owner: TOwner;

}

interface InteractionData {

  allHits: readonly PickingHit[];

  button?: MouseButton;

  canvasX: number;

  canvasY: number;

  distance: number;

  entity?: WaveEntity;

  entityId: number;

  faceIndex?: number;

  heldDurationMs?: number;

  heldFor: WaveTimeSpan;

  heldTicks?: number;

  hitNormal: SerializableVector3;

  hitPoint: SerializableVector3;

  inputClientId?: string;

  inputDeviceType?: InputDeviceType;

  inputTargetEntityId?: number;

  localHitLocation?: SerializableVector3;

  localHitNormal?: SerializableVector3;

  localHitPoint?: SerializableVector3;

  meshId?: string;

  meshName?: string;

  partId?: string;

  partName?: string;

  position: SerializableVector2;

  rayDirection?: SerializableVector3;

  rayOrigin?: SerializableVector3;

  tagMask: bigint;

  target?: InteractionVisualTarget;

  thinBatchIndex?: number;

  timestamp: number;

  touchId?: number;

  uv?: SerializableVector2;

  worldHitLocation: SerializableVector3;

  worldHitNormal: SerializableVector3;

}

type InteractionDragCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: InteractionDragContext<TOwner>) => void;

interface InteractionDragContext<TOwner extends WaveEntity = WaveEntity> {

  data: InteractionDragData;

  owner: TOwner;

}

interface InteractionDragData {

  allHits: readonly PickingHit[];

  button?: MouseButton | undefined;

  canvasX: number;

  canvasY: number;

  distance: number;

  entity?: WaveEntity<unknown> | undefined;

  entityId: number;

  faceIndex?: number | undefined;

  heldDurationMs?: number | undefined;

  heldFor: WaveTimeSpan;

  heldTicks?: number | undefined;

  hitNormal: SerializableVector3;

  hitPoint: SerializableVector3;

  inputClientId?: string | undefined;

  inputDeviceType?: InputDeviceType | undefined;

  inputTargetEntityId?: number | undefined;

  localHitLocation?: SerializableVector3 | undefined;

  localHitNormal?: SerializableVector3 | undefined;

  localHitPoint?: SerializableVector3 | undefined;

  meshId?: string | undefined;

  meshName?: string | undefined;

  partId?: string | undefined;

  partName?: string | undefined;

  position: SerializableVector2;

  rayDirection?: SerializableVector3 | undefined;

  rayOrigin?: SerializableVector3 | undefined;

  tagMask: bigint;

  target?: InteractionVisualTarget | undefined;

  thinBatchIndex?: number | undefined;

  timestamp: number;

  touchId?: number | undefined;

  uv?: SerializableVector2 | undefined;

  worldHitLocation: SerializableVector3;

  worldHitNormal: SerializableVector3;

  cameraDistance: number;

  currentHit?: PickingHit;

  currentHits?: PickingHit[];

  deltaCanvasX: number;

  deltaCanvasY: number;

  phase: InputPhase;

  startCanvasX: number;

  startCanvasY: number;

  totalCanvasX: number;

  totalCanvasY: number;

  totalDistance: number;

}

type InteractionDragMoveCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: InteractionDragMoveCallbackContext<TOwner>) => void;

interface InteractionDragMoveCallbackContext<TOwner extends WaveEntity = WaveEntity> {

  drag: InteractionDragContext<TOwner>;

  handle: InteractionDragMoveHandle<TOwner>;

  owner: TOwner;

  state: InteractionDragMoveSnapshot;

}

interface InteractionDragMoveHandle<TOwner extends WaveEntity = WaveEntity> {

  eventType: CallbackEventType;

  id: string;

  name?: string | undefined;

  off: () => void;

  clearLockedAxes(): InteractionDragMoveHandle<TOwner>;

  getState(): InteractionDragMoveSnapshot;

  lockAxes(...axes: DirectionInput[]): InteractionDragMoveHandle<TOwner>;

  lockAxis(axis: DirectionInput): InteractionDragMoveHandle<TOwner>;

  onEnd(callback: InteractionDragMoveCallback<TOwner>): CallbackHandle;

  onMove(callback: InteractionDragMoveCallback<TOwner>): CallbackHandle;

  onStart(callback: InteractionDragMoveCallback<TOwner>): CallbackHandle;

}

interface InteractionDragMoveOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  holdThreshold?: WaveTimeSpan | undefined;

  name?: string | undefined;

  priority?: number | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  button?: MouseButton;

  lockCameraControls?: boolean;

}

interface InteractionDragMoveSnapshot {

  currentPosition: SerializableVector3 | null;

  distanceTraveled: number;

  endPosition: SerializableVector3 | null;

  isActive: boolean;

  lastEvent: InteractionDragData | null;

  startPosition: SerializableVector3 | null;

  totalDelta: SerializableVector3 | null;

}

type InteractionMeshCallback<TOwner extends WaveEntity = WaveEntity> = (mesh: InteractionVisualMeshTarget, ctx: InteractionContext<TOwner>) => void;

type InteractionPartCallback<TOwner extends WaveEntity = WaveEntity> = (part: InteractionVisualPartTarget, ctx: InteractionContext<TOwner>) => void;

interface InteractionVisualMeshTarget {

  readonly displayName: string;

  readonly id: string;

  readonly index: number;

  readonly isQualifiedPart: boolean;

  readonly kind: "mesh";

  readonly name: string;

  readonly part?: InteractionVisualPartTarget;

  readonly qualifiedPartId?: string;

  rename(name: string): string;

}

interface InteractionVisualPartTarget {

  create(): WaveEntity;

  readonly entity?: WaveEntity | null;

  readonly id: string;

  readonly kind: "part";

  readonly meshes: readonly InteractionVisualMeshTarget[];

  readonly name: string;

  rename(name: string): string;

}

interface InteractionVisualTarget {

  readonly kind: "mesh" | "part";

  readonly mesh?: InteractionVisualMeshTarget;

  readonly part?: InteractionVisualPartTarget;

  readonly primary: InteractionVisualMeshTarget | InteractionVisualPartTarget;

}

interface InvertModifier {

  axes?: ("x" | "y" | "z")[];

  type: ModifierType.Invert;

}

interface IRigProvider {

  addSocket(): RigSocketBuilder;

  getAllBones(): ReadonlyMap<string, WaveBone>;

  getAllSockets(): ReadonlyMap<string, BoneSocket>;

  getBone(nameOrPart: string | BodyPart): WaveBone | null;

  getSocket(name: string): BoneSocket | null;

  hasBone(nameOrPart: string | BodyPart): boolean;

  removeSocket(name: string): boolean;

}

interface IslandSettlementWorldOptions {

  readonly budgets?: WaveWorldBudgetPolicy | undefined;

  readonly cellSize?: number | undefined;

  readonly cols?: number | undefined;

  readonly comboTiles?: boolean | WaveTilemapComboConfig | undefined;

  readonly description?: string | undefined;

  readonly elements?: readonly ComboTileKitWorldElementInput[] | undefined;

  readonly endless?: boolean | undefined;

  readonly grammarId?: string | undefined;

  readonly grid?: Omit<WaveTilemapGridConfig, "rows" | "cols" | "cellSize"> | undefined;

  readonly layerId?: string | undefined;

  readonly name?: string | undefined;

  readonly physics?: WorldStreamingPhysicsConfig | undefined;

  readonly queryPriority?: number | undefined;

  readonly renderer?: WaveTilemapRendererConfig | undefined;

  readonly required?: boolean | undefined;

  readonly rows?: number | undefined;

  readonly seed?: number | undefined;

  readonly solver?: Omit<WaveTilemapSolverConfig, "kind"> | undefined;

  readonly streaming?: WaveWorldStreamingPolicy | undefined;

  readonly workers?: WaveWorldWorkerPolicy | undefined;

  readonly finiteRegionBiasScale?: number;

  readonly semanticBiases?: ComboTileKitGrammarBiasInput;

  readonly sourceOverrides?: Partial<ComboTileKitSourceOptions>;

}

type IsWaveActorFamily<T extends WaveSpatial3DObject> = [T] extends [waveActor] ? true : false;

type IsWaveGeometryFamily<T extends WaveSpatial3DObject> = [T] extends [waveGeometry] ? true : false;

type IsWaveKinematicActorFamily<T extends WaveSpatial3DObject> = [T] extends [waveKinematicActor] ? true : false;

type IsWavePropFamily<T extends WaveSpatial3DObject> = [T] extends [waveProp] ? true : false;

interface JoinRoomOptions {

  roomId: string;

}

interface KeyboardAxis2DBindings {

  readonly down?: Keyboard | readonly Keyboard[];

  readonly left?: Keyboard | readonly Keyboard[];

  readonly right?: Keyboard | readonly Keyboard[];

  readonly up?: Keyboard | readonly Keyboard[];

}

interface KeyboardInputData {

  heldDurationMs: number;

  heldFor: WaveTimeSpan;

  heldTicks: number;

  key: Keyboard;

  timestamp: number;

}

type KinematicActorGroundState = "grounded" | "sliding" | "airborne";

interface KinematicActorMovementSnapshot {

  airTime: number;

  facing: Vector3Like;

  groundState: KinematicActorGroundState;

  horizontalSpeed: number;

  isAirborne: boolean;

  isCrouching: boolean;

  isGrounded: boolean;

  isJumping: boolean;

  isMoving: boolean;

  isSliding: boolean;

  isSprinting: boolean;

  speed: number;

  velocity: Vector3Like;

  verticalSpeed: number;

}

interface KinematicActorMovementSnapshotOptions {

  movingSpeedThreshold?: number;

}

type KinematicColliderShapeKind = "capsule" | "box";

interface KinematicConfig {

  acceleration: number;

  airControlMultiplier: number;

  airJumpCount: number;

  ascendSpeedScale: number;

  baseSpeed: number;

  canAirJump: boolean;

  capsuleHeight: number;

  capsuleRadius: number;

  collisionFilterMask: number;

  collisionMembershipMask: number;

  coyoteTime: number;

  crouchMultiplier: number;

  descendSpeedScale: number;

  dynamicFriction: number;

  externalAirDamping: number;

  externalAngularDamping: number;

  externalGroundDamping: number;

  footOffset: number | null;

  gravityMultiplier: number;

  jumpBufferTime: number;

  jumpVelocity: number;

  keepContactTolerance: number;

  keepDistance: number;

  mass: number;

  maxAcceleration: number;

  maxCastIterations: number;

  maxSlopeAngle: number;

  maxStepHeight: number;

  penetrationRecoverySpeed: number;

  pushStrength: number;

  reverseSpeedScale: number;

  sprintMultiplier: number;

  staticFriction: number;

  strafeSpeedScale: number;

  up: Vector3Like;

}

interface KinematicConstantForceConfig {

  enabled?: boolean | undefined;

  name?: string | undefined;

  direction?: DirectionInput;

  force?: Vector3Like;

  strength?: number;

}

interface KinematicConstantForceEntry {

  enabled: boolean;

  force: SerializableVector3;

  name: string;

}

interface KinematicConstantInfluenceOptions {

  enabled?: boolean;

  name?: string;

}

interface KinematicConstantTorqueConfig {

  enabled?: boolean | undefined;

  name?: string | undefined;

  axis?: DirectionInput;

  strength?: number;

  torque?: Vector3Like;

}

interface KinematicConstantTorqueEntry {

  enabled: boolean;

  name: string;

  torque: SerializableVector3;

}

type KinematicContactCallback = (event: ContactEvent) => void;

interface KinematicFlightActorConfig {

  ascendSpeedScale?: number;

  baseSpeed?: number;

  descendSpeedScale?: number;

  invertPitch?: boolean;

  mouseSensitivity?: number;

  pitchRate?: number;

  rollRate?: number;

  throttleSensitivity?: number;

  yawRate?: number;

}

interface KinematicHumanoidActorConfig {

  airControlFactor?: number;

  baseSpeed?: number;

  canSquat?: boolean;

  dynamicFriction?: number;

  footOffset?: number | null;

  friction?: number;

  jumpForce?: number;

  mass?: number;

  maxSlopeAngle?: number;

  maxStepHeight?: number;

  mouseSensitivity?: number;

  pushStrength?: number;

  sprintMultiplier?: number;

  squatSpeed?: number;

  squatSpeedScale?: number;

  staticFriction?: number;

  strafeSpeed?: number;

  strafeSpeedScale?: number;

}

interface KinematicHumanoidDynamicPushOptions {

  mass?: number;

  strength?: number;

}

interface KinematicHumanoidGroundContactOptions {

  dynamicFriction?: number;

  friction?: number;

  staticFriction?: number;

}

interface KinematicState {

  airTime: number;

  isCrouching: boolean;

  isGrounded: boolean;

  isJumping: boolean;

  isSliding: boolean;

  isSprinting: boolean;

  position: SerializableVector3;

  rotation: SerializableQuaternion;

  surface: SurfaceInfo | null;

  velocity: SerializableVector3;

}

interface KinematicTriggerEvent {

  impulse: SerializableVector3;

  position: SerializableVector3;

  triggerBodyId: number;

}

interface KinematicVehicleActorConfig {

  acceleration?: number;

  baseSpeed?: number;

  brakeStrength?: number;

  gravityMultiplier?: number;

  reverseSpeedScale?: number;

  steeringSensitivity?: number;

}

interface LaasWorldOptions {

  readonly description?: string;

  readonly name?: string;

  readonly quality?: LaasWorldQualityProfile;

  readonly rockDensity?: number;

  readonly seed?: number;

  readonly size?: LaasWorldSizeConfig;

  readonly subdivisions?: number;

  readonly undergrowthDensity?: number;

  readonly vegetationDensity?: number;

}

type LaasWorldQualityProfile = "balanced" | "dense" | "vista";

interface LaasWorldSizeConfig {

  readonly depth: number;

  readonly width: number;

}

interface LabelPanelOptions {

  decimals?: number | undefined;

  duration?: number | undefined;

  fontAsset?: string | undefined;

  fontSize?: number | undefined;

  labelOffset3D?: any;

  labelOffset3DSpace?: "world" | "local" | undefined;

  textColor?: any;

  updateMode?: DevToolUpdateMode | undefined;

  verticalOffset?: number | undefined;

  text?: string;

}

type LatheShapeInput = PathShapeInput | SingleContourGeometrySourceInput;

declare class LightAreaFacade {

  constructor(_host: LightAreaFacadeHost);

  clearEmissionTexture(): this;

  setEmissionTexture(texture: AreaLightEmissionTextureInput | null, options?: AreaLightEmissionTextureOptions): this;

  setSize(width: number, height: number): this;

}

interface LightAreaFacadeHost {

  setEmissionTexture(texture: AreaLightEmissionTextureInput | null, options?: AreaLightEmissionTextureOptions): void;

  setSize(width: number, height: number): void;

}

interface LightBeamConfig {

  color?: ColorInput;

  endRadius?: number;

  intensity?: number;

  length?: number;

  noise?: LightBeamNoiseConfig;

  opacity?: number;

  segments?: number;

  shape?: "cone" | "cylinder";

  sides?: number;

  sideThickness?: number;

  sourceRadius?: number;

  spotAngle?: number;

}

declare class LightBeamFacade {

  constructor(_host: LightBeamFacadeHost);

  configure(config: LightBeamConfig): this;

  disable(): this;

  enable(config?: LightBeamConfig): this;

}

interface LightBeamFacadeHost {

  configure(config: LightBeamConfig): void;

  disable(): void;

}

interface LightBeamNoiseConfig {

  intensity?: number;

  scale?: number;

  velocity?: Vector3Like;

}

interface LightBeamOpts {

  alphaIndex?: number;

  attenuation?: "linear" | "quadratic" | "exponential";

  attenuationStartDistance?: NumLike;

  axis?: Direction;

  capGeom?: boolean;

  color?: ColorLike;

  endRadius?: NumLike;

  glareFromBehind?: NumLike;

  glareFrontal?: NumLike;

  intensity?: NumLike;

  length: NumLike;

  mask?: FxLightmaskId;

  maskInvert?: boolean;

  maskStrength?: NumLike;

  noise?: { intensity?: NumLike; scale?: NumLike; velocity?: { x?: number; y?: number; z?: number; }; }

  segments?: number;

  shape?: "cone" | "cylinder";

  sides?: number;

  sideThickness?: NumLike;

  sourceRadius: NumLike;

  spotAngle?: NumLike;

}

declare class LightInfluenceFacade {

  constructor(_host: LightInfluenceFacadeHost);

  clearExcludedMeshes(): this;

  excludeMeshes(meshes: unknown[]): this;

  excludeObjects(...objects: LightInfluenceObject[]): this;

  setLayerMask(includeOnlyWithLayerMask?: number, excludeWithLayerMask?: number): this;

}

interface LightInfluenceFacadeHost {

  excludeObjects(...objects: LightInfluenceObject[]): void;

  setExcludedMeshes(meshes: unknown[]): void;

  setLayerMask(includeOnlyWithLayerMask?: number, excludeWithLayerMask?: number): void;

}

interface LightInfluenceObject {

  model: { getMeshes(scope?: MeshScope): readonly unknown[]; }

}

declare class LightingConfigurator<TEngine extends unknown = unknown> {

  apply(): WaveScene<TEngine>;

  apply(patch: Partial<WaveSceneLightingConfig>): WaveScene<TEngine>;

  ambient(opts: NonNullable<WaveSceneLightingConfig["ambient"]>): LightingConfigurator<TEngine>;

  ambientColor(color: ColorInput): LightingConfigurator<TEngine>;

  ambientIntensity(val: number): LightingConfigurator<TEngine>;

  ambientOff(): LightingConfigurator<TEngine>;

  bounceLighting(opts?: GlobalIlluminationConfig): LightingConfigurator<TEngine>;

  directLightOff(): LightingConfigurator<TEngine>;

  disableGlobalIllumination(): LightingConfigurator<TEngine>;

  environmentIntensity(val: number): LightingConfigurator<TEngine>;

  gi(opts?: GlobalIlluminationConfig): LightingConfigurator<TEngine>;

  giBounceSourceIntensity(val: number): LightingConfigurator<TEngine>;

  giIntensity(val: number): LightingConfigurator<TEngine>;

  giOff(): LightingConfigurator<TEngine>;

  giQuality(quality: GlobalIlluminationQuality): LightingConfigurator<TEngine>;

  globalIllumination(opts?: GlobalIlluminationConfig): LightingConfigurator<TEngine>;

  globalIlluminationIntensity(val: number): LightingConfigurator<TEngine>;

  globalIlluminationOff(): LightingConfigurator<TEngine>;

  globalIlluminationQuality(quality: GlobalIlluminationQuality): LightingConfigurator<TEngine>;

  ibl(opts: NonNullable<WaveSceneLightingConfig["ibl"]>): LightingConfigurator<TEngine>;

  iblIntensity(val: number): LightingConfigurator<TEngine>;

  iblTexture(tex: string): LightingConfigurator<TEngine>;

  indirectLighting(opts?: GlobalIlluminationConfig): LightingConfigurator<TEngine>;

  remove(): WaveScene<TEngine>;

  shadowDistance(val: number): LightingConfigurator<TEngine>;

  shadowIntensity(val: number): LightingConfigurator<TEngine>;

  shadows(val?: boolean): LightingConfigurator<TEngine>;

  sun(opts: NonNullable<WaveSceneLightingConfig["worldLight"]>): LightingConfigurator<TEngine>;

  sunColor(color: ColorInput): LightingConfigurator<TEngine>;

  sunDirection(dir: Vector3Like): LightingConfigurator<TEngine>;

  sunIntensity(val: number): LightingConfigurator<TEngine>;

  sunOff(): LightingConfigurator<TEngine>;

}

interface LightOpts {

  maxLights?: number;

  mode?: "perParticle" | "single";

}

declare class LightProjectorFacade {

  constructor(_host: LightProjectorFacadeHost);

  clear(): this;

  fitTo(receiver: LightProjectorFitReceiver): LightProjectorFitBuilder;

  gradientTo(newStops: GradientColorStop[], duration: WaveTimeSpan): this;

  gradientTo(newStops: GradientColorStop[], value: number, unit: WaveTimeUnit): this;

  project(preset: ProjectionContent): this;

  setCaustic(config: CausticOverlayConfig): this;

  setRange(near: number, far: number): this;

  setRippleEffect(config: RippleEffectConfig): this;

  setSoftEdge(amount: number): this;

  setWobbleEffect(config: WobbleEffectConfig): this;

  setWobbleInput(dirX: number, dirY: number): this;

  triggerRipple(u?: number, v?: number, strength?: number): this;

}

interface LightProjectorFacadeHost {

  applyFit(intent: LightProjectorFitIntent): void;

  createFitReceiverRef(receiver: LightProjectorFitReceiver): WaveEntityIdentityRef;

  gradientTo(newStops: GradientColorStop[], durationOrValue: WaveTimeSpan | number, unit?: WaveTimeUnit): void;

  project(preset: ProjectionContent | null): void;

  setCaustic(config: CausticOverlayConfig): void;

  setRange(near: number, far: number): void;

  setRippleEffect(config: RippleEffectConfig): void;

  setSoftEdge(amount: number): void;

  setWobbleEffect(config: WobbleEffectConfig): void;

  setWobbleInput(dirX: number, dirY: number): void;

  triggerRipple(u?: number, v?: number, strength?: number): void;

}

declare class LightProjectorFitBuilder {

  constructor(_projector: LightProjectorFacade, _host: LightProjectorFacadeHost, receiver: WaveEntityIdentityRef);

  apply(): LightProjectorFacade;

  withAngularPadding(radians: number): this;

  withInnerConeRatio(ratio: number): this;

  withMaximumAngle(radians: number): this;

  withMinimumAngle(radians: number): this;

  withNearPlane(distance: number): this;

  withRangePadding(units: number): this;

}

interface LightProjectorFitIntent {

  angularPadding: number;

  innerConeRatio?: number;

  maximumOuterAngle?: number;

  minimumOuterAngle?: number;

  nearPlane?: number;

  rangePadding: number;

  receiver: WaveEntityIdentityRef;

}

type LightProjectorFitReceiver = WaveEntity & { readonly networkID: number; getBoundingBox(): ModelBoundingBox | null; getOrientedBounds(): ModelOrientedBounds | null; }

interface LightRuntimeOptions {

  angle?: number | undefined;

  areaEmissionTexturePreprocessed?: boolean | undefined;

  areaHeight?: number | undefined;

  areaWidth?: number | undefined;

  castShadow?: boolean | undefined;

  color?: ColorInput | undefined;

  coloredShadow?: ColoredShadowConfig | undefined;

  diffuseColor?: ColorInput | undefined;

  direction?: any;

  directionLabel?: Direction | undefined;

  exponent?: number | undefined;

  groundColor?: ColorInput | undefined;

  innerAngle?: number | undefined;

  intensity?: number | undefined;

  isOn?: boolean | undefined;

  lightBeam?: LightBeamConfig | undefined;

  offset?: any;

  projectionCaustic?: CausticOverlayConfig | undefined;

  projectionFar?: number | undefined;

  projectionNear?: number | undefined;

  projectionPreset?: ProjectionContent | null | undefined;

  projectionRipple?: RippleEffectConfig | undefined;

  projectionSoftEdge?: number | undefined;

  projectionWobble?: WobbleEffectConfig | undefined;

  radius?: number | undefined;

  range?: number | undefined;

  shadowAutoAddCasters?: boolean | undefined;

  shadowAutoReceiveShadows?: boolean | undefined;

  shadowBias?: number | undefined;

  shadowCascades?: false | WaveShadowCascadeOptions | undefined;

  shadowContactHardeningRatio?: number | undefined;

  shadowDarkness?: number | undefined;

  shadowDepthScale?: number | undefined;

  shadowEnableSoftTransparentShadow?: boolean | undefined;

  shadowFilter?: ShadowFilterMode | undefined;

  shadowFilteringQuality?: WaveGraphShadowFilteringQuality | undefined;

  shadowFrustumEdgeFalloff?: number | undefined;

  shadowFrustumSize?: number | undefined;

  shadowMapSize?: number | undefined;

  shadowMaxZ?: number | undefined;

  shadowMinZ?: number | undefined;

  shadowNormalBias?: number | undefined;

  shadowTransparencyShadow?: boolean | undefined;

  shadowUpdate?: WaveShadowUpdatePolicy | undefined;

  shadowUseFullFloat?: boolean | undefined;

  shadowUseOpacityTextureForTransparentShadow?: boolean | undefined;

  shadowUseRedTextureType?: boolean | undefined;

  showAreaHelper?: boolean | undefined;

  showConeHelper?: boolean | undefined;

  showDirectionalHelper?: boolean | undefined;

  showHelper?: boolean | undefined;

  showHemisphereHelper?: boolean | undefined;

  showRangeHelper?: boolean | undefined;

  specularColor?: ColorInput | undefined;

  target?: any;

  type?: LightType | undefined;

  volumetricLight?: LightVolumetricConfig | undefined;

  areaEmissionTexture?: RuntimeAreaLightEmissionTextureInput | null;

  excludedMeshes?: unknown[];

  excludeWithLayerMask?: number;

  falloffType?: number;

  includeOnlyWithLayerMask?: number;

  intensityMode?: number;

}

declare class LightShadowFacade {

  constructor(_host: LightShadowFacadeHost);

  auto(options: Pick<ShadowOptions, "shadowAutoAddCasters" | "shadowAutoReceiveShadows">): this;

  cascades(options?: ShadowCascadeOptions): this;

  clearColored(): this;

  colored(config: ColoredShadowConfig): this;

  configure(options: ShadowOptions): this;

  disable(): this;

  enable(options?: ShadowOptions): this;

  setBias(shadowBias: number): this;

  setDarkness(shadowDarkness: number): this;

  setDepthScale(shadowDepthScale: number): this;

  setEdgeFalloff(shadowFrustumEdgeFalloff: number): this;

  setFilter(shadowFilter: ShadowFilterMode): this;

  setMapSize(shadowMapSize: number): this;

  setNormalBias(shadowNormalBias: number): this;

  singleMap(): this;

  transparent(options: Pick<ShadowOptions, "shadowTransparencyShadow" | "shadowEnableSoftTransparentShadow" | "shadowUseOpacityTextureForTransparentShadow">): this;

}

interface LightShadowFacadeHost {

  configure(options: ShadowOptions): void;

  configureAuto(options: Pick<ShadowOptions, "shadowAutoAddCasters" | "shadowAutoReceiveShadows">): void;

  configureCascades(options: ShadowCascadeOptions | false): void;

  configureTransparent(options: Pick<ShadowOptions, "shadowTransparencyShadow" | "shadowEnableSoftTransparentShadow" | "shadowUseOpacityTextureForTransparentShadow">): void;

  disable(): void;

  enable(options?: ShadowOptions): void;

  setBias(shadowBias: number): void;

  setCastShadow(castShadow: boolean): void;

  setColored(config: ColoredShadowConfig): void;

  setDarkness(shadowDarkness: number): void;

  setDepthScale(shadowDepthScale: number): void;

  setEdgeFalloff(shadowFrustumEdgeFalloff: number): void;

  setFilter(shadowFilter: ShadowFilterMode): void;

  setMapSize(shadowMapSize: number): void;

  setNormalBias(shadowNormalBias: number): void;

}

interface LightState {

  angle?: number | undefined;

  areaEmissionTexture?: any;

  areaEmissionTexturePreprocessed?: boolean | undefined;

  areaHeight?: number | undefined;

  areaWidth?: number | undefined;

  castShadow?: boolean | undefined;

  color?: ColorInput | undefined;

  coloredShadow?: ColoredShadowConfig | undefined;

  diffuseColor?: ColorInput | undefined;

  directionLabel?: Direction | undefined;

  excludedMeshes?: unknown[] | undefined;

  excludeWithLayerMask?: number | undefined;

  exponent?: number | undefined;

  falloffType?: number | undefined;

  groundColor?: ColorInput | undefined;

  includeOnlyWithLayerMask?: number | undefined;

  innerAngle?: number | undefined;

  intensity?: number | undefined;

  intensityMode?: number | undefined;

  lightBeam?: LightBeamConfig | undefined;

  projectionCaustic?: CausticOverlayConfig | undefined;

  projectionFar?: number | undefined;

  projectionNear?: number | undefined;

  projectionPreset?: ProjectionContent | null | undefined;

  projectionRipple?: RippleEffectConfig | undefined;

  projectionSoftEdge?: number | undefined;

  projectionWobble?: WobbleEffectConfig | undefined;

  radius?: number | undefined;

  range?: number | undefined;

  shadowAutoAddCasters?: boolean | undefined;

  shadowAutoReceiveShadows?: boolean | undefined;

  shadowBias?: number | undefined;

  shadowCascades?: false | WaveShadowCascadeOptions | undefined;

  shadowContactHardeningRatio?: number | undefined;

  shadowDarkness?: number | undefined;

  shadowDepthScale?: number | undefined;

  shadowEnableSoftTransparentShadow?: boolean | undefined;

  shadowFilter?: ShadowFilterMode | undefined;

  shadowFilteringQuality?: WaveGraphShadowFilteringQuality | undefined;

  shadowFrustumEdgeFalloff?: number | undefined;

  shadowFrustumSize?: number | undefined;

  shadowMapSize?: number | undefined;

  shadowMaxZ?: number | undefined;

  shadowMinZ?: number | undefined;

  shadowNormalBias?: number | undefined;

  shadowTransparencyShadow?: boolean | undefined;

  shadowUpdate?: WaveShadowUpdatePolicy | undefined;

  shadowUseFullFloat?: boolean | undefined;

  shadowUseOpacityTextureForTransparentShadow?: boolean | undefined;

  shadowUseRedTextureType?: boolean | undefined;

  specularColor?: ColorInput | undefined;

  volumetricLight?: LightVolumetricConfig | undefined;

  direction?: Vector3;

  isOn: boolean;

  offset: Vector3;

  showAreaHelper: boolean;

  showConeHelper: boolean;

  showDirectionalHelper: boolean;

  showHelper: boolean;

  showHemisphereHelper: boolean;

  showRangeHelper: boolean;

  target?: Vector3;

  type: LightType;

}

declare enum LightType {

  Directional = "directional",

  Hemispheric = "hemispheric",

  Point = "point",

  RectArea = "rectArea",

  Spot = "spot",

}

declare class LightVolumeFacade {

  constructor(_host: LightVolumeFacadeHost);

  configure(config?: LightVolumetricConfig): this;

  disable(): this;

  enable(config?: Omit<LightVolumetricConfig, "enabled">): this;

}

interface LightVolumeFacadeHost {

  configure(config?: LightVolumetricConfig): void;

  disable(): void;

  enable(config?: Omit<LightVolumetricConfig, "enabled">): void;

}

interface LightVolumetricConfig {

  blurScale?: number;

  coefficient?: number;

  enabled?: boolean;

  power?: number;

  renderRatio?: number;

  steps?: number;

}

interface LineOfSightOptions {

  blockingEntities?: readonly WaveSensingSpatialEntity[];

  blockingMask?: bigint;

  blockingShape?: LineOfSightBlockerShape;

  from?: WavePointInput;

  ignoreEntities?: readonly WaveSensingSpatialEntity[];

  to?: WavePointInput;

}

type LLMAccessMode = "direct" | "hostProxy";

interface LLMConfig {

  allowClientDirect?: boolean;

  clientAccessMode?: LLMAccessMode;

  defaultEndpointId: string;

  endpoints: Record<string, Omit<LLMEndpointConfig, "id">>;

  maxPayloadBytes?: number;

  redactSecrets?: boolean;

  retries?: number;

  timeoutMs?: number;

}

type LLMContent = { type: "text"; text: string; } | { type: "blob"; mimeType: string; dataBase64: string; }

interface LLMEndpointAuthConfig {

  apiKeyEnvVar?: string;

  headerName?: string;

  queryParam?: string;

  type: "bearer" | "apiKeyHeader" | "apiKeyQuery";

}

interface LLMEndpointConfig {

  auth?: LLMEndpointAuthConfig;

  headers?: Record<string, string>;

  id: string;

  mapRequest?: (request: LLMRequest) => unknown;

  mapResponse?: (response: unknown) => LLMResponse;

  method?: "POST";

  retries?: number;

  timeoutMs?: number;

  url: string;

}

interface LLMMessage {

  content: LLMContent[];

  role: LLMRole;

}

interface LLMRequest {

  endpointId?: string;

  maxTokens?: number;

  messages: LLMMessage[];

  providerPayload?: Record<string, unknown>;

  response?: LLMResponseFormat;

  timeoutMs?: number;

}

interface LLMRequestRuntimeOptions {

  accessMode?: LLMAccessMode;

  signal?: AbortSignal;

  targetClientId?: string;

}

interface LLMResponse {

  dataBase64?: string;

  endpointId?: string;

  mimeType?: string;

  raw?: unknown;

  requestId?: string;

  text?: string;

  usage?: LLMUsage;

}

type LLMResponseFormat = { type: "text"; } | { type: "json"; } | { type: "blob"; mimeType?: string; }

type LLMRole = "system" | "user" | "assistant";

interface LLMUsage {

  completionTokens?: number;

  promptTokens?: number;

  totalTokens?: number;

}

declare enum LoadingPhase {

  BUILDING_TERRAIN = "building_terrain",

  BUILDING_WORLD = "building_world",

  INITIALIZING = "initializing",

  LOADING_ASSETS = "loading_assets",

  PREPARING_AUDIO = "preparing_audio",

  READY = "ready",

  SETUP = "setup",

  SIGNING_URLS = "signing_urls",

  WARMING_UP = "warming_up",

}

interface LoadingProgress {

  assetName?: string;

  current: number;

  percentComplete: number;

  phase: LoadingPhase;

  total: number;

}

interface LoadingProgressConfig {

  backgroundColor?: string;

  customContentFactory?: (container: HTMLDivElement) => void;

  fadeOutDuration?: number;

  minDisplayTime?: number;

  pointerEvents?: "none" | "auto";

  progressColor?: string;

  textColor?: string;

  title?: string;

}

interface LockConfig {

  axisA?: DirectionInput | undefined;

  axisB?: DirectionInput | undefined;

  enableCollisions?: boolean | undefined;

  limits?: AxisLimit[] | undefined;

  motors?: MotorConfig[] | undefined;

  perpAxisA?: DirectionInput | undefined;

  perpAxisB?: DirectionInput | undefined;

  pivotA?: any;

  pivotB?: any;

  type: ConstraintType.Lock;

}

interface LoweredAssetDependency {

  readonly origin: { readonly parent: AssetIdentity; readonly fieldPath: string; readonly reason: string; }

  readonly ref: AssetRef;

  readonly source: ResolvedAssetDependencySource;

}

interface MainLightState {

  color: number;

  direction: Vector3Like;

  intensity: number;

  shadowCascades?: WaveShadowCascadeOptions | false;

  shadowDistance: number;

  shadowEnabled: boolean;

  shadowIntensity: number;

  shadowUpdate?: WaveShadowUpdatePolicy;

}

declare const MATERIAL_SPLAT_DEBUG_VIEW: Readonly<{ readonly None: 0; readonly Weights: 1; readonly Roughness: 2; readonly Metallic: 3; readonly AmbientOcclusion: 4; readonly Normals: 5; }>;

interface MaterialAlbedoEmissiveFillState {

  color: unknown;

  intensity: number;

}

type MaterialAlphaMode = ProjectMaterialAlphaMode;

interface MaterialAnisotropyState {

  direction: Vector2;

  enabled: boolean;

  intensity: number;

}

type MaterialBindingValue = unknown;

interface MaterialClearCoatState {

  enabled: boolean;

  indexOfRefraction: number;

  intensity: number;

  roughness: number;

}

type MaterialColorInput = ColorInput | string | [number, number, number];

type MaterialInput = string | WaveMaterialInput;

interface MaterialIridescenceState {

  enabled: boolean;

  indexOfRefraction: number;

  intensity: number;

  maximumThickness: number;

  minimumThickness: number;

}

interface MaterialPretreatmentResult {

  materialsPrepared: number;

  meshesPrepared: number;

  error?: string;

  success: boolean;

}

interface MaterialSheenState {

  color: unknown;

  enabled: boolean;

  intensity: number;

  roughness: number | null;

}

type MaterialSplatDebugViewMode = (typeof MATERIAL_SPLAT_DEBUG_VIEW)[keyof typeof MATERIAL_SPLAT_DEBUG_VIEW];

interface MaterialSplatHeightBlendDefinition {

  readonly bias: number;

  readonly enabled: boolean;

  readonly heightTexture?: string;

  readonly sharpness: number;

  readonly source?: "albedoLuminance" | "heightTexture";

}

type MaterialSplatLayerSelector = MaterialSplatLayerId;

interface MaterialState {

  albedoEmissiveFill: MaterialAlbedoEmissiveFillState | null;

  alphaMode: MaterialAlphaMode | null;

  anisotropy: MaterialAnisotropyState;

  antiTiling: WaveMaterialAntiTilingOptions | null;

  clearCoat: MaterialClearCoatState;

  color: unknown;

  colorExplicitOverride: boolean;

  depthBias: number;

  directIntensity: number | null;

  doubleSided: boolean;

  emissiveColor: unknown;

  emissiveIntensity: number;

  environmentIntensity: number | null;

  iridescence: MaterialIridescenceState;

  materialAssetName: string | null;

  materialRemoved: boolean;

  materialType: "public" | "private";

  maxSimultaneousLights: number | null;

  metalness: number;

  opacity: number;

  roughness: number;

  sheen: MaterialSheenState;

  specularIntensity: number | null;

  subSurface: MaterialSubSurfaceState;

  textures: MaterialTexturePaths;

  transparencyMode: MaterialTransparencyMode | null;

  useRadianceOverAlpha: boolean | null;

  useSpecularOverAlpha: boolean | null;

  uvOffset: Vector2;

  uvRotation: number;

  uvScale: Vector2;

  wireframe: boolean;

}

interface MaterialStatePatch {

  albedoEmissiveFill?: MaterialAlbedoEmissiveFillState | null;

  alphaMode?: MaterialAlphaMode | null;

  anisotropy?: MaterialAnisotropyState;

  antiTiling?: WaveMaterialAntiTilingOptions | null;

  clearCoat?: MaterialClearCoatState;

  color?: unknown;

  colorExplicitOverride?: boolean;

  depthBias?: number;

  directIntensity?: number | null;

  doubleSided?: boolean;

  emissiveColor?: unknown;

  emissiveIntensity?: number;

  environmentIntensity?: number | null;

  iridescence?: MaterialIridescenceState;

  materialAssetName?: string | null;

  materialRemoved?: boolean;

  materialType?: "public" | "private";

  maxSimultaneousLights?: number | null;

  metalness?: number;

  opacity?: number;

  roughness?: number;

  sheen?: MaterialSheenState;

  specularIntensity?: number | null;

  subSurface?: MaterialSubSurfaceState;

  textures?: MaterialTexturePathPatch;

  transparencyMode?: MaterialTransparencyMode | null;

  useRadianceOverAlpha?: boolean | null;

  useSpecularOverAlpha?: boolean | null;

  uvOffset?: Vector2;

  uvRotation?: number;

  uvScale?: Vector2;

  wireframe?: boolean;

}

interface MaterialSubSurfaceState {

  indexOfRefraction: number;

  maximumThickness: number;

  minimumThickness: number;

  refractionIntensity: number;

  tintColor: unknown | null;

  translucencyIntensity: number;

}

interface MaterialTexturePathPatch {

  ao?: string | null;

  base?: string | null;

  emissive?: string | null;

  metallic?: string | null;

  normal?: string | null;

  roughness?: string | null;

  thickness?: string | null;

  translucencyColor?: string | null;

  translucencyIntensity?: string | null;

  transmission?: string | null;

}

interface MaterialTexturePaths {

  ao?: string;

  base?: string;

  emissive?: string;

  metallic?: string;

  normal?: string;

  roughness?: string;

  thickness?: string;

  translucencyColor?: string;

  translucencyIntensity?: string;

  transmission?: string;

}

type MaterialTransparencyMode = ProjectMaterialTransparencyMode;

type MaterialUseMode = "auto" | "public" | "private";

interface MediaContentConfig {

  brightness?: number;

  loop?: boolean;

  playbackRate?: number;

  source: string;

  tint?: ColorInput;

}

interface MediaStartReport {

  results: MediaStartResult[];

}

interface MediaStartResult {

  device: SensingDevice.Audio | SensingDevice.Vision;

  error?: string;

  sessionId?: string;

  started: boolean;

}

interface MeshAutoRenameInput {

  readonly autoRename: true;

}

interface MeshCollidersOptions {

  max?: number;

  method?: CompoundCollidersFromMeshesMethod;

}

interface MeshEditResult {

  error?: string;

  geometryWritten?: boolean;

  success: boolean;

  verticesAffected?: number;

}

interface MeshEntry {

  readonly displayName: string;

  readonly id: WaveModelMeshId;

  readonly index: number;

  readonly mesh: unknown;

  readonly metadata: WaveModelMeshIdentityMetadata;

  readonly name: string;

  readonly qualifiedPartId?: string;

}

type MeshMorphVertexAnimationEasing = "linear" | "smoothstep" | "power2InOut";

interface MeshMorphVertexAnimationInfo {

  readonly durationSeconds: number;

  readonly easing: MeshMorphVertexAnimationEasing;

  readonly frameCount: number;

  readonly sourceMeshName: string;

  readonly targetMeshName?: string;

  readonly textureHeight: number;

  readonly textureWidth: number;

}

interface MeshMutationResult {

  readonly changed: boolean;

  readonly mesh: MeshEntry;

  readonly name: string;

  readonly previousName: string;

}

interface MeshOpts {

  blend?: "additive" | "alpha" | "multiply";

  depthWrite?: boolean;

  glow?: FxGlowConfig;

  meshAsset: string;

  rotation?: boolean;

}

declare enum MeshOwnershipState {

  DecomposedPartShell = "decomposedPartShell",

  EmptyModel = "emptyModel",

  MeshlessModelRoot = "meshlessModelRoot",

  MixedMeshOwner = "mixedMeshOwner",

  OwnedMeshRoot = "ownedMeshRoot",

  PartView = "partView",

  PromotedPart = "promotedPart",

  PromotedSourceShell = "promotedSourceShell",

}

interface MeshPatch {

  readonly name?: string;

  readonly ref: MeshRef;

}

type MeshPatchInput = MeshPatch | readonly MeshPatch[] | Readonly<Record<string, MeshPatchValue>> | MeshAutoRenameInput;

type MeshPatchValue = string | Omit<MeshPatch, "ref">;

type MeshRef = string | number | unknown | MeshEntry | WaveModelMeshReferenceMetadata;

declare enum MeshScope {

  CreatedPart = "createdPart",

  Inventory = "inventory",

  Owned = "owned",

  Part = "part",

}

interface MeshSkinInfluenceFieldOptions {

  readonly meshNames?: readonly string[];

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly skeleton?: unknown | string;

  readonly sourceTag?: string;

}

interface MetadataClipBindingValue {

  readonly kind: "metadataClip";

  readonly payloadKind: "metadataClip";

  readonly ref: ExactAssetRef<"animation">;

  readonly template: CompiledMetadataAnimationTemplate;

}

type MinimapHAlign = "left" | "center" | "right";

type MinimapMarkerShape = "dot" | "diamond" | "ring" | "cross" | "sprite";

type MinimapVAlign = "top" | "center" | "bottom";

declare class MirrorBuilder<T extends WaveSpatial3DObject> {

  constructor(_spawner: WaveSpawner, _input: T);

  copyCallbacksToClone(copy?: boolean): this;

  deepClone(deep?: boolean): this;

  flip(direction: SemanticDirection): this;

  makingEachSpawnIndependent(): this;

  named(name: string): this;

  onPlaced(cb: (entity: T) => void): this;

  place(): T;

  sharingGeneratedAssetsUntilRegenerate(): this;

  skipCallbacksOnClone(): this;

  using(reference: WaveSpatial3DObject): this;

}

interface MirrorOptions<T extends WaveSpatial3DObject = WaveSpatial3DObject> {

  cloneCallbacks?: SpawnCloneCallbackPolicy;

  cloneName?: string;

  deepClone?: boolean;

  flip?: SemanticDirection;

  generatedAssetReuse?: GeneratedAssetCloneReuseIntent;

  onPlaced?: (entity: T) => void;

  using: WaveSpatial3DObject;

}

declare const MODEL_EXPORT_FORMATS: readonly ["glb", "stl"];

declare const MODEL_USE_MODES: readonly ["direct", "instance", "copy"];

type ModelAnimationClipInput = string | WaveAnimationClip;

interface ModelAnimationPlayOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  crossFadeDuration?: number;

  loop?: boolean;

  speed?: number;

}

interface ModelAssetValue {

  readonly kind: "modelTemplate";

  readonly native: Readonly<{ readonly rootNodes: readonly TransformNode[]; readonly meshes: readonly unknown[]; readonly skeletons: readonly unknown[]; readonly animationGroups: readonly AnimationGroup[]; readonly sourceContainer: unknown; }>;

  readonly objectModel: WaveModelObjectModel;

  readonly policy: ModelRevisionPolicy;

  readonly projectionManifest: WaveModelProjectionManifest;

  readonly representation: string;

  readonly runtimeResources?: readonly unknown[];

  readonly simple?: Readonly<{ readonly meshId: string; readonly partId: string; readonly topologySignature: string; }>;

  readonly templateClass: "simpleOneMesh" | "structuredGraph";

}

interface ModelBindingIntent {

  readonly geometry?: AssetIsolationMode;

  readonly hydration?: ModelHydrationIntent;

  readonly materials?: AssetIsolationMode;

  readonly projection?: ModelBindingProjection;

  readonly topology?: ModelTopologyIntent;

  readonly use?: ModelUseMode;

}

type ModelBindingProjection = { readonly kind: "fullGraph"; } | { readonly kind: "singleMesh"; readonly selector: { readonly kind: "primary"; } | { readonly kind: "mesh"; readonly meshId: string; } | { readonly kind: "part"; readonly partId: string; }; }

type ModelBindingProjectionFacts = { readonly kind: "fullGraph"; } | { readonly kind: "singleMesh"; readonly meshId: string; readonly partId: string | null; }

interface ModelBoundingBox {

  centerLocal: Vector3;

  centerWorld: Vector3;

  halfExtents: Vector3;

  maxWorld: Vector3;

  minWorld: Vector3;

  size: Vector3;

}

interface ModelBounds {

  center: Vector3;

  halfExtents: Vector3;

  max: Vector3;

  min: Vector3;

  size: Vector3;

}

type ModelConsumerSource = { readonly kind: "followCurrent"; readonly identity: AssetIdentity<"model">; } | { readonly kind: "exact"; readonly ref: ExactAssetRef<"model">; }

interface ModelEmbeddedAnimationDescriptor {

  readonly durationSeconds: number;

  readonly framesPerSecond: number;

  readonly fromFrame: number;

  readonly id: string;

  readonly name: string;

  readonly sourceGroupIndex: number;

  readonly targetKinds: readonly ("skeleton" | "morphTarget" | "transform" | "property")[];

  readonly targetSignature: string;

  readonly toFrame: number;

}

interface ModelEmbeddedClipBindingValue {

  readonly descriptor: ModelEmbeddedAnimationDescriptor;

  readonly kind: "modelEmbedded";

  readonly modelContentKey: AssetContentKey;

  readonly modelRef: ExactAssetRef<"model">;

  readonly payloadKind: "modelEmbedded";

  readonly ref: ExactAssetRef<"animation">;

  readonly selector: GltfClipSelector;

  readonly topologySignature: string;

}

type ModelExportFormat = (typeof MODEL_EXPORT_FORMATS)[number];

type ModelExportMeshCompression = "none" | "draco";

interface ModelExportTextureCompressionOptions {

  maxSize?: number;

  mimeType?: ModelExportTextureMimeType;

  quality?: number;

  slots?: readonly ModelExportTextureSlot[];

}

type ModelExportTextureMimeType = "image/png" | "image/jpeg" | "image/webp";

type ModelExportTextureSlot = "albedo" | "ambient" | "opacity" | "emissive" | "metallic" | "reflectivity" | "metallicReflectance" | "reflectance" | "microSurface" | "bump" | "lightmap" | "subSurfaceThickness" | "subSurfaceRefraction" | "subSurfaceRefractionIntensity" | "subSurfaceTranslucencyIntensity" | "subSurfaceTranslucencyColor" | "clearCoat" | "clearCoatRoughness" | "clearCoatBump" | "clearCoatTint" | "sheen" | "sheenRoughness" | "iridescence" | "iridescenceThickness" | "anisotropy" | "standardDiffuse" | "standardAmbient" | "standardOpacity" | "standardReflection" | "standardEmissive" | "standardSpecular" | "standardBump" | "standardLightmap";

type ModelHydrationIntent = "eager" | "deferred";

type ModelMutationDomain = "geometry" | "materials" | "hierarchy" | "rig" | "topology";

type ModelMutationPolicy = "forbidden" | "copyOnWrite" | "exclusive" | "revision";

interface ModelOrientedBounds {

  centerLocal: Vector3;

  halfExtentsLocal: Vector3;

  rotationWorld: Quaternion;

  sizeLocal: Vector3;

}

type ModelPoseInput = WaveModelPoseInput;

interface ModelRevisionPolicy {

  readonly allowedUseModes: readonly ModelUseMode[];

  readonly defaultUseMode: ModelUseMode;

  readonly geometryDefault: AssetIsolationMode;

  readonly materialsDefault: AssetIsolationMode;

  readonly maxConcurrentBindings?: number;

  readonly maxConcurrentRealizations?: number;

  readonly mutation: Readonly<Record<ModelMutationDomain, ModelMutationPolicy>>;

  readonly replacementStrategy: "parallelAtomic" | "drainThenRealize";

}

interface ModelSourceBundle {

  dispose(): void;

  readonly manifest: readonly ModelSourceSidecarManifestEntry[];

  readonly primaryContentHash: string;

  readonly primaryUri: string;

  read(uri: string): Uint8Array;

  verifyIntegrity(): void;

}

interface ModelSourceSidecarManifestEntry {

  readonly contentHash: string;

  readonly uri: string;

}

type ModelTopologyIntent = "dynamic" | "fixed";

type ModelUseMode = (typeof MODEL_USE_MODES)[number];

declare enum ModifierType {

  Clamp = 3,

  Curve = 7,

  DeadZone = 0,

  Invert = 1,

  Negate = 6,

  Scale = 2,

  Smooth = 4,

  Swizzle = 5,

}

declare class module_visual3DModelEffectState<TOwner extends wave3DObject = wave3DObject> {

  addLocalAnimations(): void;

  alignOriginToModelBounds(forceAnchorMove?: boolean): this;

  allowUnsafePartDestroy: boolean;

  readonly canRender: boolean;

  castShadow: boolean;

  clearGpuDataSourceBindings(): this;

  collectVatPlaybackMeshes(): readonly { readonly mesh: unknown; readonly meshId?: string; readonly name: string; }[];

  configureGaussianSplat(config: WaveGaussianSplatRuntimeConfig): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  createInstanceSource(options?: CreateInstanceSourceOptions): WaveInstanceSource;

  destroy(): void;

  disableAutoLOD(): this;

  enableAutoLOD(config?: AutoLODConfig): this;

  readonly enabled: boolean;

  readonly engine: unknown;

  gaussianSplat(): WaveGaussianSplatRuntimeHandle<this>;

  getBoundingBox(): ModelBoundingBox | null;

  getBoundingBoxVolume(): number;

  getBoundModelValue(): WaveSceneModelValue | null;

  getColliderBounds(): { centerLocal: Vector3; halfExtents: Vector3; } | null;

  getGaussianSplatInfo(): WaveGaussianSplatRuntimeInfo | null;

  getHalfExtents(): Vector3;

  getMesh(name: string, scope?: MeshScope): unknown | undefined;

  getMeshCount(scope?: MeshScope): number;

  getMeshEntry(meshRef: MeshRef, scope?: MeshScope): MeshEntry | undefined;

  getMeshes(scope?: MeshScope): readonly unknown[];

  getModelBounds(space?: BoundsSpace, useRestPose?: boolean, forceRefresh?: boolean, includeHiddenOrDisabledMeshes?: boolean): ModelBounds | null;

  getModelTopologySignature(): string | null;

  getOrientedBounds(): ModelOrientedBounds | null;

  getOwnerComponent: { <T extends WaveComponent>(ComponentClass: ComponentConstructor<unknown>): unknown | undefined; <T extends WaveComponent>(componentName: string): unknown | undefined; }

  getSize(): Vector3;

  getVisualBounds(space?: BoundsSpace): ModelBounds | null;

  gpuBinding<TType extends WaveShaderBindingType = WaveShaderBindingType>(name: string): WaveGpuDrivenBindingHandle<TType>;

  gpuData(id: string): WaveGpuDrivenDataChannelHandle;

  gpuDataSourceDebugTexel(channelId: string, x: number, y: number): WaveGpuDataSourceDebugTexel | null;

  gpuDataSourceDiagnostics(): WaveGpuDataSourceDiagnostics;

  gpuDataSources(): WaveGpuDataSourceBindingBuilder<this>;

  gpuDrivenDiagnostics(): WaveGpuDrivenModelRuntimeDiagnostics;

  gpuDrivenReady(): Promise<void>;

  gpuStateKernel(id: string): WaveGpuDrivenStateKernelHandle;

  hasFixedModelTopology: boolean;

  hasOwnedMeshes: boolean;

  hide(): void;

  instanceEntries: any;

  invalidateVisualBounds(): void;

  isAggregateMeshOwner: boolean;

  isDecomposedShell: boolean;

  readonly isDestroyed: boolean;

  isDisposed: boolean;

  readonly isDisposing: boolean;

  isGaussianSplat(): boolean;

  isGpuDrivenModel(): boolean;

  isMeshlessModelRoot: boolean;

  isModelRevisionConsumerCurrent(): boolean;

  isPart: boolean;

  isPartView(): boolean;

  listGpuBindings(): readonly string[];

  listGpuDataChannels(): readonly string[];

  listGpuStateKernels(): readonly string[];

  listMeshEntries(scope?: MeshScope): MeshEntry[];

  listMeshes(scope?: MeshScope): MeshEntry[];

  listMeshNames(scope?: MeshScope): string[];

  markPartAsPromoted(partId: string): void;

  materialAlphaMode: ProjectMaterialAlphaMode | null;

  materialOpacity: number;

  materialTransparencyMode: ProjectMaterialTransparencyMode | null;

  meshOwnershipState: MeshOwnershipState;

  modelName: string | null;

  modelRevisionAssetOwner: SceneAssetAccess;

  modelRevisionContributionGeneration: number;

  onCloneFinalized(): void;

  readonly owner: TOwner;

  partOwnerVisual: cmp_visual3DModel<wave3DObject<unknown>> | null;

  primaryMesh: any;

  promotedPartIds: unknown;

  promotedPartSource: PromotedVisualPartSource | null;

  receiveShadow: boolean;

  refreshGpuDataSources(): this;

  reloadModel(modelName: string): void;

  removeModel(): void;

  replaceFollowCurrentModel(change: AssetRevisionChange<"model">): void;

  requireOwnerComponent: { <T extends WaveComponent>(ComponentClass: ComponentConstructor<unknown>): unknown; <T extends WaveComponent>(componentName: string): unknown; }

  resetOrigin(forceAnchorMove?: boolean): this;

  readonly scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setGpuDataSourceBindings(input: WaveGpuDataSourceBindingPlanInput): this;

  show(): void;

  source: ModelConsumerSource | null;

  syncMaterialFreezePolicy(): void;

  readonly typeName: string;

  useFixedGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedGeneratedModel(model: string): boolean;

  useFixedGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedModel(model: Visual3DModelAuthoringInput, options?: Omit<Visual3DModelUseOptions, "topology">): void;

  useGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useGeneratedModel(model: string): boolean;

  useGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useModel(model: Visual3DModelAuthoringInput, options?: Visual3DModelUseOptions): void;

  visualLayer: VisualLayer;

  clearGeometryInfluenceView(): this;

  clearReflectionPolicy(target?: WaveVisualTargetRef): this;

  disableEdgeRendering(): this;

  disableFresnelGlow(): this;

  disableGlow(): this;

  disableHighlight(): this;

  disableOutline(): this;

  disableSelectionOutline(): this;

  disableTrail(): this;

  get edgeColor(): unknown;

  get edgeEpsilon(): number;

  get edgeRenderingEnabled(): boolean;

  get edgeWidth(): number;

  enableEdgeRendering(options?: { width?: number; color?: ColorInput | string | [number, number, number] | number | null; epsilon?: number; }): this;

  enableFresnelGlow(options?: { color?: ColorInput | string | [number, number, number] | number | null; bias?: number; power?: number; }): this;

  enableGlow(intensity?: number, color?: ColorInput | string | [number, number, number] | number | null): this;

  enableHighlight(color?: ColorInput | string | [number, number, number] | number | null, options?: { innerGlow?: boolean; outerGlow?: boolean; glowEmissiveOnly?: boolean; }): this;

  enableOutline(options?: Parameters<module_visual3DModelEffectState["enableSelectionOutline"]>[0]): this;

  enableSelectionOutline(options?: { thicknessPixels?: number; color?: ColorInput | string | [number, number, number] | number | null; occlusionStrength?: number; occlusionThreshold?: number; }): this;

  enableTrail(options?: { blendFactor?: number; halfLifeSeconds?: number; intensity?: number; blendMode?: MotionTrailBlendMode; stretchPixels?: number; samples?: number; stretchDirection?: Vector2Like; worldSpace?: boolean; trailColor?: ColorInput | null; }): this;

  get fresnelBias(): number;

  get fresnelColor(): unknown;

  get fresnelEnabled(): boolean;

  get fresnelPower(): number;

  get geometryInfluenceViewEnabled(): boolean;

  get geometryInfluenceViewState(): GeometryInfluenceViewModelState | null;

  get glowColor(): unknown | null;

  get glowEnabled(): boolean;

  get glowIntensity(): number;

  get highlightColor(): unknown;

  get highlightEnabled(): boolean;

  get highlightGlowEmissiveOnly(): boolean;

  get highlightInnerGlow(): boolean;

  get highlightOuterGlow(): boolean;

  get isEdgeDirty(): boolean;

  get isFresnelDirty(): boolean;

  get isGeometryInfluenceViewDirty(): boolean;

  get isGlowDirty(): boolean;

  get isHighlightDirty(): boolean;

  get isOutlineDirty(): boolean;

  get isReflectionPolicyDirty(): boolean;

  get isRenderTintDirty(): boolean;

  get isTrailDirty(): boolean;

  markEdgeClean(): void;

  markFresnelClean(): void;

  markGeometryInfluenceViewClean(): void;

  markGlowClean(): void;

  markHighlightClean(): void;

  markOutlineClean(): void;

  markReflectionPolicyClean(): void;

  markRenderTintClean(): void;

  markTrailClean(): void;

  get outlineColor(): unknown;

  get outlineEnabled(): boolean;

  get outlineOcclusionStrength(): number;

  get outlineOcclusionThreshold(): number;

  get outlineThicknessPixels(): number;

  reflection(target?: WaveVisualTargetRef): WaveVisualReflectionBuilder;

  get reflectionPolicies(): readonly WaveReflectionReceiverPolicy[];

  get renderTintColor(): unknown;

  get renderTintEnabled(): boolean;

  setGeometryInfluenceView(state: GeometryInfluenceViewModelState): this;

  setGlowColor(color: ColorInput | string | [number, number, number] | number | null): this;

  setGlowIntensity(intensity: number): this;

  setHighlightColor(color: ColorInput | string | [number, number, number] | number): this;

  setReflectionPolicy(policy: WaveReflectionReceiverPolicy): this;

  setTrailBlendFactor(factor: number): this;

  setTrailColor(color: ColorInput | string | [number, number, number] | number | null): this;

  get trailBlendFactor(): number;

  get trailBlendMode(): MotionTrailBlendMode;

  get trailColor(): unknown | null;

  get trailEnabled(): boolean;

  get trailHalfLifeSeconds(): number | null;

  get trailIntensity(): number;

  get trailSamples(): number;

  get trailStretchDirection(): { x: number; y: number; } | null;

  get trailStretchPixels(): number;

  get trailWorldSpace(): boolean;

}

declare class module_visual3DModelGaussianSplat<TOwner extends wave3DObject = wave3DObject> {

  addLocalAnimations(): void;

  alignOriginToModelBounds(_forceAnchorMove?: boolean): this;

  allowUnsafePartDestroy: boolean;

  readonly canRender: boolean;

  castShadow: boolean;

  clearGpuDataSourceBindings(): this;

  collectVatPlaybackMeshes(): readonly { readonly mesh: unknown; readonly meshId?: string; readonly name: string; }[];

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  createInstanceSource(options?: CreateInstanceSourceOptions): WaveInstanceSource;

  destroy(): void;

  disableAutoLOD(): this;

  enableAutoLOD(config?: AutoLODConfig): this;

  readonly enabled: boolean;

  readonly engine: unknown;

  getBoundModelValue(): WaveSceneModelValue | null;

  getMesh(name: string, scope?: MeshScope): unknown | undefined;

  getMeshCount(scope?: MeshScope): number;

  getMeshEntry(meshRef: MeshRef, scope?: MeshScope): MeshEntry | undefined;

  getMeshes(scope?: MeshScope): readonly unknown[];

  getModelBounds(_space?: BoundsSpace, _useRestPose?: boolean, _forceRefresh?: boolean, _includeHiddenOrDisabledMeshes?: boolean): ModelBounds | null;

  getModelTopologySignature(): string | null;

  getOrientedBounds(): ModelOrientedBounds | null;

  getOwnerComponent: { <T extends WaveComponent>(ComponentClass: ComponentConstructor<unknown>): unknown | undefined; <T extends WaveComponent>(componentName: string): unknown | undefined; }

  gpuBinding<TType extends WaveShaderBindingType = WaveShaderBindingType>(name: string): WaveGpuDrivenBindingHandle<TType>;

  gpuData(id: string): WaveGpuDrivenDataChannelHandle;

  gpuDataSourceDebugTexel(channelId: string, x: number, y: number): WaveGpuDataSourceDebugTexel | null;

  gpuDataSourceDiagnostics(): WaveGpuDataSourceDiagnostics;

  gpuDataSources(): WaveGpuDataSourceBindingBuilder<this>;

  gpuDrivenDiagnostics(): WaveGpuDrivenModelRuntimeDiagnostics;

  gpuDrivenReady(): Promise<void>;

  gpuStateKernel(id: string): WaveGpuDrivenStateKernelHandle;

  hasFixedModelTopology: boolean;

  hasOwnedMeshes: boolean;

  hide(): void;

  instanceEntries: any;

  invalidateVisualBounds(): void;

  isAggregateMeshOwner: boolean;

  isDecomposedShell: boolean;

  readonly isDestroyed: boolean;

  isDisposed: boolean;

  readonly isDisposing: boolean;

  isGpuDrivenModel(): boolean;

  isMeshlessModelRoot: boolean;

  isModelRevisionConsumerCurrent(): boolean;

  isPart: boolean;

  isPartView(): boolean;

  listGpuBindings(): readonly string[];

  listGpuDataChannels(): readonly string[];

  listGpuStateKernels(): readonly string[];

  listMeshEntries(scope?: MeshScope): MeshEntry[];

  listMeshes(scope?: MeshScope): MeshEntry[];

  listMeshNames(scope?: MeshScope): string[];

  markPartAsPromoted(partId: string): void;

  materialAlphaMode: ProjectMaterialAlphaMode | null;

  materialOpacity: number;

  materialTransparencyMode: ProjectMaterialTransparencyMode | null;

  meshOwnershipState: MeshOwnershipState;

  modelName: string | null;

  modelRevisionAssetOwner: SceneAssetAccess;

  modelRevisionContributionGeneration: number;

  onCloneFinalized(): void;

  readonly owner: TOwner;

  partOwnerVisual: cmp_visual3DModel<wave3DObject<unknown>> | null;

  primaryMesh: any;

  promotedPartIds: unknown;

  promotedPartSource: PromotedVisualPartSource | null;

  receiveShadow: boolean;

  refreshGpuDataSources(): this;

  reloadModel(modelName: string): void;

  removeModel(): void;

  replaceFollowCurrentModel(change: AssetRevisionChange<"model">): void;

  requireOwnerComponent: { <T extends WaveComponent>(ComponentClass: ComponentConstructor<unknown>): unknown; <T extends WaveComponent>(componentName: string): unknown; }

  readonly scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setGpuDataSourceBindings(input: WaveGpuDataSourceBindingPlanInput): this;

  show(): void;

  source: ModelConsumerSource | null;

  syncMaterialFreezePolicy(): void;

  readonly typeName: string;

  useFixedGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedGeneratedModel(model: string): boolean;

  useFixedGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedModel(model: Visual3DModelAuthoringInput, options?: Omit<Visual3DModelUseOptions, "topology">): void;

  useGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useGeneratedModel(model: string): boolean;

  useGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useModel(model: Visual3DModelAuthoringInput, options?: Visual3DModelUseOptions): void;

  visualLayer: VisualLayer;

  configureGaussianSplat(config: WaveGaussianSplatRuntimeConfig): this;

  gaussianSplat(): WaveGaussianSplatRuntimeHandle<this>;

  getGaussianSplatInfo(): WaveGaussianSplatRuntimeInfo | null;

  isGaussianSplat(): boolean;

}

declare class module_visual3DModelSurfaceState<TOwner extends wave3DObject = wave3DObject> {

  actualizeStoredMaterialState(): boolean;

  addDecal(texture: string): DecalBuilder;

  addingNoise(): NoiseBuilder;

  addLocalAnimations(): void;

  adoptPart(targetObject: wave3DObject, options?: AdoptPartOptions): wave3DObject;

  adoptPartMesh(partEntityId: number, meshName: string): void;

  adoptParts(targetObjects: readonly wave3DObject[], options?: AdoptPartsOptions): wave3DObject[];

  adoptPartsFrom(targetObject: wave3DObject, options?: AdoptPartsOptions): wave3DObject[];

  alignOriginToModelBounds(forceAnchorMove?: boolean): this;

  allowUnsafePartDestroy: boolean;

  anchor(anchorRef: string): WaveAttachmentSocket;

  applyPartPose(values: Readonly<Record<string, WaveModelPoseValue>>, options?: VisualModelPoseApplyOptions): this;

  applyPartPoseBuffer(jointIds: readonly string[], values: Float64Array, options?: VisualModelPoseApplyOptions): this;

  applyPartPoseSnapshot(preset: WaveModelRigPoseSnapshotMetadata, options?: VisualModelPoseApplyOptions): this;

  applySurfaceConfig(config: ObjectSurfaceConfig, options?: { preserveExplicitColor?: boolean; }): void;

  applyTexturePainting(intent: PaintVertexColorsTextureIntent): VertexColorResult;

  attract(options: AttractOptions, force?: boolean): MeshEditResult;

  attracting(): AttractBuilder;

  autoRenameMeshes(): Record<string, string>;

  bend(options: BendOptions, force?: boolean): MeshEditResult;

  bending(): BendBuilder;

  bindMeshesToPart(partRef: PartRef, meshRefs: readonly MeshRef[], options?: BindMeshesToPartOptions): PartEntry;

  booleanBatch(steps: readonly VisualModelBooleanBatchStep[], options?: VisualModelBooleanOptions): CSGResult;

  bulging(): SurfaceDeformationBuilder;

  cacheVertices(force?: boolean): MeshEditResult;

  canEditMesh(): { canEdit: boolean; reason?: string; }

  readonly canRender: boolean;

  capturePartPose(name?: string, options?: VisualModelPoseApplyOptions): WaveModelRigPoseSnapshotMetadata;

  captureProjectMaterialAssetDefinition(): ProjectMaterialAssetDefinition;

  castShadow: boolean;

  clearDecals(): void;

  clearEmissiveDistortionInput(): void;

  clearGeometryInfluenceView(): this;

  clearGpuDataSourceBindings(): this;

  clearPbrModifiers(target?: VisualModelTarget | null): this;

  clearReflectionPolicy(target?: WaveVisualTargetRef): this;

  clearSurfaceVfx(options?: { resetProgress?: boolean; }): this;

  clearVertexCache(force?: boolean): void;

  clearVideo(): void;

  clonePart(partRef: PartRef, options?: Omit<ExtractPartsOptions, "mode" | "source" | "partName">): wave3DObject;

  cloneParts(selection: PartSelection, options?: Omit<ExtractPartsOptions, "mode" | "source" | "partName">): wave3DObject[];

  collectVatPlaybackMeshes(): readonly { readonly mesh: unknown; readonly meshId?: string; readonly name: string; }[];

  combinePart(...args: Array<PartRef | readonly PartRef[] | CombinePartsOptions | null | undefined>): wave3DObject;

  combinePart(partRef: PartRef, options?: CombinePartsOptions): wave3DObject;

  combinePart(partRef: PartRef, secondPartRef: PartRef, ...partRefs: PartRef[]): wave3DObject;

  combinePart(partRef: PartRef, secondPartRef: PartRef, ...partRefsAndOptions: Array<PartRef | CombinePartsOptions>): wave3DObject;

  combinePart(partRefs: readonly PartRef[], options?: CombinePartsOptions): wave3DObject;

  configureGaussianSplat(config: WaveGaussianSplatRuntimeConfig): this;

  createAllParts(options?: CreatePartsOptions): wave3DObject[];

  createInstanceSource(options?: CreateInstanceSourceOptions): WaveInstanceSource;

  createPart(partName: string, options?: CreatePartsOptions): wave3DObject;

  createPart(partRef: PartCreationRef, options?: CreatePartsOptions): wave3DObject;

  createParts(selection?: PartCreationSelection, options?: CreatePartsOptions): wave3DObject[];

  createParts(selection?: string | readonly string[], options?: CreatePartsOptions): wave3DObject[];

  csgBatching(): CSGBatchBuilder;

  cut(tool: CutToolLike, capColorOrOptions?: FragInteriorColorInput | CutOptions): CutResult;

  cutting(tool: CutToolLike): CutBuilder;

  decalLayerMask: number;

  deleteVertexSelection(selection: VertexSelection, options?: VertexDeleteOptions, force?: boolean): VertexSelectionResult;

  destroyAllParts(): PartDeleteResult[];

  destroyPart(partRef: PartRef): void;

  destroyParts(selection: PartDestructiveSelection): PartDeleteResult[];

  disableAutoLOD(): this;

  disableEdgeRendering(): this;

  disableFresnelGlow(): this;

  disableGlow(): this;

  disableHighlight(): this;

  disableOutline(): this;

  disableSelectionOutline(): this;

  disableTrail(): this;

  discolorSurface(options?: SurfaceDiscolorOptions): this;

  displacing(): DisplaceBuilder;

  dispose(): void;

  edgeColor: unknown;

  edgeEpsilon: number;

  edgeRenderingEnabled: boolean;

  edgeWidth: number;

  emissiveDistortion(): EmissiveDistortionBuilder;

  enableAutoLOD(config?: AutoLODConfig): this;

  enableBreadcrumbTrail(options?: BreadcrumbTrailOptions): VisualBreadcrumbTrailHandle;

  readonly enabled: boolean;

  enableEdgeRendering(options?: { width?: number; color?: ColorInput | string | [ number, number, number ] | number | null; epsilon?: number; }): this;

  enableFresnelGlow(options?: { color?: ColorInput | string | [ number, number, number ] | number | null; bias?: number; power?: number; }): this;

  enableGlow(intensity?: number, color?: ColorInput | string | [ number, number, number ] | number | null): this;

  enableHighlight(color?: ColorInput | string | [ number, number, number ] | number | null, options?: { innerGlow?: boolean; outerGlow?: boolean; glowEmissiveOnly?: boolean; }): this;

  enableOutline(options?: Parameters<module_visual3DModelEffectState["enableSelectionOutline"]>[0]): this;

  enableSelectionOutline(options?: { thicknessPixels?: number; color?: ColorInput | string | [ number, number, number ] | number | null; occlusionStrength?: number; occlusionThreshold?: number; }): this;

  enableTrail(options?: { blendFactor?: number; halfLifeSeconds?: number; intensity?: number; blendMode?: MotionTrailBlendMode; stretchPixels?: number; samples?: number; stretchDirection?: Vector2Like_3; worldSpace?: boolean; trailColor?: ColorInput | null; }): this;

  readonly engine: unknown;

  ensureIndependentMaterial(): unknown | null;

  eraseSurface(options?: SurfaceErasureOptions): this;

  eraseVertexColors(center: WavePointInput, radius: number, channel: VertexColorChannel, falloff?: PaintBrushFalloff, force?: boolean): VertexColorResult;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Clone; }): wave3DObject;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Promote | WaveModelPartExtractionMode.Clone; }): TOwner | wave3DObject<unknown>;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Promote; }): TOwner;

  extractParts(selection: PartSelection, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Clone | WaveModelPartExtractionMode.Adopt; }): wave3DObject[];

  extractParts(selection: PartSelection, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Promote; }): TOwner[];

  extractParts(selection: PartSelection, options: ExtractPartsOptions): (TOwner | wave3DObject<unknown>)[];

  extrude(options: ExtrudeOptions, force?: boolean): MeshEditResult;

  extruding(): ExtrudeBuilder;

  findNearestVertex(at: Vector3Like, options?: VertexQueryOptions, force?: boolean): VertexQueryResult;

  flexing(): FlexBuilder;

  frag(fragmentCount: number, interiorColor?: FragInteriorColorInput, seed?: number, localOrigin?: { x: number; y: number; z: number; }, force?: boolean, worldOrigin?: { x: number; y: number; z: number; }): FragResult;

  fragmenting(): WaveSimpleFractureBuilder;

  fresnelBias: number;

  fresnelColor: unknown;

  fresnelEnabled: boolean;

  fresnelPower: number;

  gaussianSplat(): WaveGaussianSplatRuntimeHandle<this>;

  geometryInfluenceViewEnabled: boolean;

  geometryInfluenceViewState: GeometryInfluenceViewModelState | null;

  getAccumulatedDeformation(deformationType: "bend" | "twist" | "skew" | "taper" | "regionalScale" | "extrude", force?: boolean): number | { startScale: number; endScale: number; } | RegionalScaleAccumulation | undefined;

  getBoundingBox(): ModelBoundingBox | null;

  getBoundingBoxVolume(): number;

  getBoundModelValue(): WaveSceneModelValue | null;

  getColliderBounds(): { centerLocal: Vector3; halfExtents: Vector3; } | null;

  getEditableMesh(force?: boolean): unknown | null;

  getGaussianSplatInfo(): WaveGaussianSplatRuntimeInfo | null;

  getHalfExtents(): Vector3;

  getMesh(name: string, scope?: MeshScope): unknown | undefined;

  getMeshCount(scope?: MeshScope): number;

  getMeshEntry(meshRef: MeshRef, scope?: MeshScope): MeshEntry | undefined;

  getMeshes(scope?: MeshScope): readonly unknown[];

  getModelBounds(space?: BoundsSpace, useRestPose?: boolean, forceRefresh?: boolean, includeHiddenOrDisabledMeshes?: boolean): ModelBounds | null;

  getModelTopologySignature(): string | null;

  getOrientedBounds(): ModelOrientedBounds | null;

  getOwnerComponent: { <T extends WaveComponent>(ComponentClass: ComponentConstructor<unknown>): unknown | undefined; <T extends WaveComponent>(componentName: string): unknown | undefined; }

  getPart(partName: string, scope?: WaveModelPartScope): wave3DObject | undefined;

  getPart(partRef: PartRef | VisualPartId, scope?: WaveModelPartScope): wave3DObject | undefined;

  getPartCount(scope?: WaveModelPartScope): number;

  getPartGraphMetadata(): WaveModelRigGraphMetadata | undefined;

  getPartGraphPoseController(): WavePartGraphPoseController;

  getPartInfo(partName: string, scope?: WaveModelPartScope): VisualPartInfo | undefined;

  getPartInfo(partRef: PartRef | VisualPartId, scope?: WaveModelPartScope): VisualPartInfo | undefined;

  getPartMetadata(partRef: PartRef, scope?: WaveModelPartScope): WaveModelPartMetadata | undefined;

  getParts(scope?: WaveModelPartScope): readonly wave3DObject[];

  getPbrModifierInstances(): readonly PbrModifierInstanceSnapshot[];

  getSize(): Vector3;

  getSkinAuthoringMesh(force?: boolean): unknown | null;

  getVertexCache(force?: boolean): VertexCache | undefined;

  getVertexCount(meshName?: string): number;

  getVertexTopologyVersion(force?: boolean): number | null;

  getVisualBounds(space?: BoundsSpace): ModelBounds | null;

  glowColor: any;

  glowEnabled: boolean;

  glowIntensity: number;

  gpuBinding<TType extends WaveShaderBindingType = WaveShaderBindingType>(name: string): WaveGpuDrivenBindingHandle<TType>;

  gpuData(id: string): WaveGpuDrivenDataChannelHandle;

  gpuDataSourceDebugTexel(channelId: string, x: number, y: number): WaveGpuDataSourceDebugTexel | null;

  gpuDataSourceDiagnostics(): WaveGpuDataSourceDiagnostics;

  gpuDataSources(): WaveGpuDataSourceBindingBuilder<this>;

  gpuDrivenDiagnostics(): WaveGpuDrivenModelRuntimeDiagnostics;

  gpuDrivenReady(): Promise<void>;

  gpuStateKernel(id: string): WaveGpuDrivenStateKernelHandle;

  hasFixedModelTopology: boolean;

  hasOwnedMeshes: boolean;

  hasPart(partName: string, scope?: WaveModelPartScope): boolean;

  hasPart(partRef: PartRef | VisualPartId, scope?: WaveModelPartScope): boolean;

  hasSharedMaterial(): boolean;

  hasVertexCache(force?: boolean): boolean;

  hide(): void;

  highlightColor: unknown;

  highlightEnabled: boolean;

  highlightGlowEmissiveOnly: boolean;

  highlightInnerGlow: boolean;

  highlightOuterGlow: boolean;

  initVertexColors(initialChannel?: VertexColorChannel, overwrite?: boolean, force?: boolean): VertexColorResult;

  instanceEntries: any;

  intersect(operand: VisualModelBooleanInput, options?: VisualModelBooleanOptions): CSGResult;

  intersecting(operand: VisualModelBooleanInput): CSGBuilder;

  intersectMany(operands: readonly VisualModelBooleanInput[], options?: VisualModelBooleanOptions): CSGResult;

  invalidateVisualBounds(): void;

  isAggregateMeshOwner: boolean;

  isDecomposedShell: boolean;

  readonly isDestroyed: boolean;

  isDisposed: boolean;

  readonly isDisposing: boolean;

  isEdgeDirty: boolean;

  isFresnelDirty: boolean;

  isGaussianSplat(): boolean;

  isGeometryInfluenceViewDirty: boolean;

  isGlowDirty: boolean;

  isGpuDrivenModel(): boolean;

  isHighlightDirty: boolean;

  isManifold(scope?: MeshScope): boolean;

  isMaterialStateDirty: boolean;

  isMeshlessModelRoot: boolean;

  isModelRevisionConsumerCurrent(): boolean;

  isMultiMesh(): boolean;

  isOutlineDirty: boolean;

  isPart: boolean;

  isPartView(): boolean;

  isReflectionPolicyDirty: boolean;

  isRenderTintDirty: boolean;

  isSingleMesh(): boolean;

  isSurfaceDiscolorDirty: boolean;

  isTrailDirty: boolean;

  listDecals(): waveDecal[];

  listGpuBindings(): readonly string[];

  listGpuDataChannels(): readonly string[];

  listGpuStateKernels(): readonly string[];

  listMeshEntries(scope?: MeshScope): MeshEntry[];

  listMeshes(scope?: MeshScope): MeshEntry[];

  listMeshNames(scope?: MeshScope): string[];

  listPartInfos(scope?: WaveModelPartScope): readonly VisualPartInfo[];

  listPartJointControls(query?: string): readonly WaveModelJointControlInfo[];

  listPartNames(scope?: WaveModelPartScope): string[];

  listParts(scope?: WaveModelPartScope): readonly VisualPartInfo[];

  markEdgeClean(): void;

  markFresnelClean(): void;

  markGeometryInfluenceViewClean(): void;

  markGlowClean(): void;

  markHighlightClean(): void;

  markMaterialStateClean(): void;

  markOutlineClean(): void;

  markPartAsPromoted(partId: string): void;

  markReflectionPolicyClean(): void;

  markRenderTintClean(): void;

  markSurfaceDiscolorClean(): void;

  markTrailClean(): void;

  materialAlphaMode: ProjectMaterialAlphaMode | null;

  materialAnisotropy: MaterialAnisotropyState;

  materialAssetName: string | null;

  materialClearCoat: MaterialClearCoatState;

  materialColor: unknown;

  materialDoubleSided: boolean;

  materialEmissiveColor: unknown;

  materialEmissiveIntensity: number;

  materialEnvironmentIntensity: number | null;

  materialFor(target: VisualModelTarget, slot?: number): MaterialEditorView;

  materialIridescence: MaterialIridescenceState;

  materialMaxSimultaneousLights: number | null;

  materialMetalness: number;

  materialOpacity: number;

  materialRoughness: number;

  materialSheen: MaterialSheenState;

  materialSlotFor(target: VisualModelTarget, slot: number): MaterialEditorView;

  materialSpecularIntensity: number | null;

  materialSubSurface: MaterialSubSurfaceState;

  materialTextures: { base?: string; normal?: string; metallic?: string; roughness?: string; ao?: string; emissive?: string; thickness?: string; transmission?: string; translucencyColor?: string; translucencyIntensity?: string; }

  materialTransparencyMode: ProjectMaterialTransparencyMode | null;

  materialType: "private" | "public";

  materialUseRadianceOverAlpha: boolean | null;

  materialUseSpecularOverAlpha: boolean | null;

  materialUVOffset: Vector2;

  materialUVRotation: number;

  materialUVRotationRadians: number;

  materialUVScale: Vector2;

  materialWireframe: boolean;

  maxDecals: number;

  mergeMeshes(disposeOriginals?: boolean): unknown | null;

  meshMaterial(name: string): MaterialEditorView;

  meshMaterialSlot(name: string, slot: number): MaterialEditorView;

  meshOwnershipState: MeshOwnershipState;

  modelName: string | null;

  modelRevisionAssetOwner: SceneAssetAccess;

  modelRevisionContributionGeneration: number;

  modifyWith(recipe: WavePbrModifierRecipe, options?: WavePbrModifierApplicationOptions): this;

  morphingTo(target: WaveGeometryMorphTarget): MorphToBuilder;

  moveVertices(selection: VertexSelection, movement: DirectionInput, distance: number, options?: VertexMoveOptions, force?: boolean): VertexSelectionResult;

  moveVertices(selection: VertexSelection, movement: Vector3Like, options?: VertexMoveOptions, force?: boolean): VertexSelectionResult;

  noise(options: NoiseOptions, force?: boolean): MeshEditResult;

  onCloneFinalized(): void;

  outlineColor: unknown;

  outlineEnabled: boolean;

  outlineOcclusionStrength: number;

  outlineOcclusionThreshold: number;

  outlineThicknessPixels: number;

  readonly owner: TOwner;

  painting(): PaintVertexColorsBuilder;

  paintingPolygon(): PaintVertexColorsPolygonBuilder;

  paintingTexture(): PaintVertexColorsTextureBuilder;

  paintVertexColors(options: PaintVertexColorsOptions, force?: boolean): VertexColorResult;

  paintVertexColorsPolygon(options: PaintVertexColorsPolygonOptions, force?: boolean): VertexColorResult;

  partMaterial(partRef: PartRef, slot?: number): MaterialEditorView;

  partMaterialSlot(partRef: PartRef, slot: number): MaterialEditorView;

  partOwnerVisual: cmp_visual3DModel<wave3DObject<unknown>> | null;

  pickPartAtWorldPoint(point: Vector3Like, options?: PickPartOptions): wave3DObject | undefined;

  prepareOperablePBR(): MaterialPretreatmentResult;

  previewPartPose(elapsedMs: number, options?: VisualModelPosePreviewOptions): Readonly<Record<string, WaveModelPoseValue>>;

  prewarmSurfaceVfx(options?: SurfaceErasureWarmupOptions): SurfaceErasureWarmupResult;

  primaryMesh: any;

  privatizeMaterial(): void;

  promotedPartIds: unknown;

  promotedPartSource: PromotedVisualPartSource | null;

  promotePart(partRef: PartRef): TOwner;

  promoteParts(selection: PartSelection): TOwner[];

  promoteResultMeshes(meshes: readonly unknown[]): TOwner[];

  qualifyMeshesAsParts(selection?: MeshRef | readonly MeshRef[], options?: CreatePartsOptions): PartEntry[];

  receiveDecals: boolean;

  receiveShadow: boolean;

  reflection(target?: WaveVisualTargetRef): WaveVisualReflectionBuilder;

  reflectionPolicies: readonly WaveReflectionReceiverPolicy[];

  refreshGpuDataSources(): this;

  regionalScaling(): RegionalScaleBuilder;

  reloadModel(modelName: string): void;

  removeAntiTiling(): void;

  removeDecal(decal: waveDecal): void;

  removeEmissiveDistortion(): void;

  removeMaterial(options?: { fromAll?: boolean; restoreInnate?: boolean; }): void;

  removeMeshFromModel(mesh: unknown, meshKey: string): void;

  removeModel(): void;

  removePbrModifier(instanceIdInput: string): this;

  removeWorldEmissive(): void;

  renameMesh(meshRef: MeshRef, newName: string): string;

  renameMeshes(renames?: Readonly<Record<string, string>>): Record<string, string>;

  renamePart(partRef: PartRef, newName: string): string;

  renameParts(renames?: Readonly<Record<string, string>>): Record<string, string>;

  renderTintColor: unknown;

  renderTintEnabled: boolean;

  reparentPart(childPartRef: PartRef, parentPartRef: PartRef | null): PartMutationResult;

  replaceFollowCurrentModel(change: AssetRevisionChange<"model">): void;

  requireEditableMesh(force?: boolean): unknown;

  requireOwnerComponent: { <T extends WaveComponent>(ComponentClass: ComponentConstructor<unknown>): unknown; <T extends WaveComponent>(componentName: string): unknown; }

  requireSkinAuthoringMesh(force?: boolean): unknown;

  resetDeformation(deformationType: "bend" | "twist" | "skew" | "taper" | "regionalScale" | "noise" | "attract" | "extrude" | "all", force?: boolean): MeshEditResult;

  resetOrigin(forceAnchorMove?: boolean): this;

  resetPartPose(options?: VisualModelPoseApplyOptions): this;

  resolveMaterialSplatPaintChannel(layer: VertexColorChannel | MaterialSplatLayerId): VertexColorChannel;

  restoreVertices(force?: boolean): MeshEditResult;

  runTimeCleanUp(): void;

  saveIntoModelAsset(options?: SaveIntoModelAssetOptions): Promise<SaveIntoModelAssetResult>;

  scaleRegion(options: RegionalScaleOptions, force?: boolean): MeshEditResult;

  readonly scene: WaveScene<unknown> | null;

  segment(options: SegmentOptions | readonly SegmentOptions[], force?: boolean): SegmentResult;

  segmenting(): SegmentBuilder;

  selectFaceVertices(faceIndex: number, force?: boolean): VertexSelectionResult;

  selectVertex(vertexIndex: number, force?: boolean): VertexSelectionResult;

  selectVertexNeighbors(selection: VertexSelection, rings?: number, force?: boolean): VertexSelectionResult;

  selectVerticesInRadius(center: Vector3Like, radius: number, options?: VertexQueryOptions, force?: boolean): VertexSelectionResult;

  setAlphaMode(mode: MaterialAlphaMode | null): void;

  setAnisotropy(config: Partial<Omit<MaterialAnisotropyState, "direction">> & { direction?: Vector2 | readonly [ number, number ]; }): void;

  setAntiTiling(options?: WaveMaterialAntiTilingOptions): void;

  setAOTexture(texturePath: string): void;

  setBaseTexture(texturePath: string): void;

  setClearCoat(config: Partial<MaterialClearCoatState>): void;

  setColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setDecalLayerMask(v: number): this;

  setDepthBias(value: number): void;

  setDoubleSided(enabled: boolean): void;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setEmissiveDistortion(config: EmissiveDistortionConfig): void;

  setEmissiveEffect<THandle extends WaveTextureEffectHandle = WaveTextureEffectHandle>(effect: WaveEffectInput): THandle;

  setEmissiveIntensity(intensity: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveIntensity(intensity: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveIntensity(intensity: number): void;

  setEmissiveTexture(texturePath: string): void;

  setEmissiveWobbleInput(x: number, y: number): void;

  setEnvironmentIntensity(value: number): void;

  setGeometryInfluenceView(state: GeometryInfluenceViewModelState): this;

  setGlowColor(color: ColorInput | string | [ number, number, number ] | number | null): this;

  setGlowIntensity(intensity: number): this;

  setGpuDataSourceBindings(input: WaveGpuDataSourceBindingPlanInput): this;

  setHighlightColor(color: ColorInput | string | [ number, number, number ] | number): this;

  setIndexOfRefraction(ior: number): void;

  setIridescence(config: Partial<MaterialIridescenceState>): void;

  setMaxDecals(v: number): this;

  setMaximumThickness(value: number): void;

  setMaxSimultaneousLights(value: number): void;

  setMeshes(input: MeshPatchInput): MeshMutationResult[];

  setMeshMaterialColor(meshName: string, color: unknown | string | [ number, number, number ] | number, preserveInterior?: boolean): boolean;

  setMetallicTexture(texturePath: string): void;

  setMetalness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setMetalness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setMetalness(value: number): void;

  setMinimumThickness(value: number): void;

  setNormalTexture(texturePath: string): void;

  setOpacity(alpha: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setOpacity(alpha: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setOpacity(alpha: number): void;

  setPart(partRef: PartRef, patch: PartPatchValue): PartMutationResult;

  setPartJointValue(jointIdOrName: string, value: WaveModelPoseValue, options?: VisualModelPoseApplyOptions): this;

  setPartMassProperties(partRef: PartRef, input: PartMassPropertiesInput): PartMutationResult;

  setPartMetadata(partRef: PartRef, metadata: WaveModelPartMetadata | null | undefined): PartMutationResult;

  setParts(input: PartPatchInput): PartMutationResult[];

  setPbrModifier(instanceIdInput: string, recipeInput: WavePbrModifierRecipe, options?: SetPbrModifierOptions): this;

  setPbrModifierEnabled(instanceIdInput: string, enabled: boolean): this;

  setPbrModifierInputBindings(instanceIdInput: string, patch: WavePbrModifierInputBindings): this;

  setPbrModifierOrder(instanceIds: readonly string[]): this;

  setPbrModifierParameters(instanceIdInput: string, patch: WavePbrModifierParameterValues): this;

  setReceiveDecals(v: boolean): this;

  setReflectionPolicy(policy: WaveReflectionReceiverPolicy): this;

  setRefractionIntensity(value: number): void;

  setRoughness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setRoughness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setRoughness(value: number): void;

  setRoughnessTexture(texturePath: string): void;

  setSheen(config: Partial<Omit<MaterialSheenState, "color">> & { color?: ColorInput | string | [ number, number, number ] | number; }): void;

  setSpecularIntensity(value: number): void;

  setSubSurface(config: Partial<Omit<MaterialSubSurfaceState, "tintColor">> & { tintColor?: ColorInput | string | [ number, number, number ] | number | null; }): void;

  setSubSurfaceTintColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setSurfacePreset(preset: SurfacePreset, category?: SurfaceCategory): void;

  setSurfaceVfxProgress(progress: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setSurfaceVfxProgress(progress: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setSurfaceVfxProgress(progress: number): this;

  setThicknessTexture(texturePath: string): void;

  setTrailBlendFactor(factor: number): this;

  setTrailColor(color: ColorInput | string | [ number, number, number ] | number | null): this;

  setTranslucencyColorTexture(texturePath: string): void;

  setTranslucencyIntensity(value: number): void;

  setTranslucencyIntensityTexture(texturePath: string): void;

  setTransmissionTexture(texturePath: string): void;

  setUseRadianceOverAlpha(enabled: boolean): void;

  setUseSpecularOverAlpha(enabled: boolean): void;

  setUVOffset(offset: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(offset: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(offset: Vector2): void;

  setUVOffset(uOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, vOffset?: number): void;

  setUVRotation(degrees: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVRotation(degrees: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVRotation(degrees: number): void;

  setUVScale(scale: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(scale: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(scale: Vector2): void;

  setUVScale(uScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, vScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, vScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, vScale?: number): void;

  setWireframe(enabled: boolean): void;

  setWorldEmissive(config: WorldEmissiveConfig): void;

  show(): void;

  showMeshBoundingBox(meshRef: MeshRef, options?: BoundingBoxOptions): this;

  skew(options: SkewOptions, force?: boolean): MeshEditResult;

  skewing(): SkewBuilder;

  source: ModelConsumerSource | null;

  stretching(): StretchBuilder;

  subdivideVertexSelection(selection: VertexSelection, options?: VertexSubdivideOptions, force?: boolean): VertexTopologyResult;

  subtract(operand: VisualModelBooleanInput, options?: VisualModelBooleanOptions): CSGResult;

  subtracting(operand: VisualModelBooleanInput): CSGBuilder;

  subtractMany(operands: readonly VisualModelBooleanInput[], options?: VisualModelBooleanOptions): CSGResult;

  surface(selector: WaveFaceSelector, localDirection?: readonly [ number, number, number ]): WaveGeometrySurfaceHandle<MaterialEditorView>;

  surfaceSelection(id: string): WaveModelSurfaceSelectionBuilder;

  swaying(): SwayBuilder;

  syncMaterialFreezePolicy(): void;

  taper(options: TaperOptions, force?: boolean): MeshEditResult;

  tapering(): TaperBuilder;

  trailBlendFactor: number;

  trailBlendMode: MotionTrailBlendMode;

  trailColor: any;

  trailEnabled: boolean;

  trailHalfLifeSeconds: number | null;

  trailIntensity: number;

  trailSamples: number;

  trailStretchDirection: { x: number; y: number; } | null;

  trailStretchPixels: number;

  trailWorldSpace: boolean;

  transformVertices(selection: VertexSelection, options: VertexTransformOptions, force?: boolean): VertexSelectionResult;

  triggerEmissiveRipple(u?: number, v?: number, strength?: number): void;

  twist(options: TwistOptions, force?: boolean): MeshEditResult;

  twisting(): TwistBuilder;

  readonly typeName: string;

  unbindMeshesFromPart(partRef: PartRef, meshRefs?: readonly MeshRef[]): unknown[];

  union(operand: VisualModelBooleanInput, options?: VisualModelBooleanOptions): CSGResult;

  unioning(operand: VisualModelBooleanInput): CSGBuilder;

  unionMany(operands: readonly VisualModelBooleanInput[], options?: VisualModelBooleanOptions): CSGResult;

  unmanageAllParts(): unknown[];

  unmanagePart(partRef: PartRef): unknown;

  unmanageParts(selection: PartDestructiveSelection): unknown[];

  useFixedGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedGeneratedModel(model: string): boolean;

  useFixedGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedModel(model: Visual3DModelAuthoringInput, options?: Omit<Visual3DModelUseOptions, "topology">): void;

  useGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useGeneratedModel(model: string): boolean;

  useGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useMaterial(material: MaterialInput, toAll?: boolean, materialType?: MaterialUseMode): void;

  useModel(model: Visual3DModelAuthoringInput, options?: Visual3DModelUseOptions): void;

  usePrivateMaterialInput(input: WaveMaterialInput, toAll?: boolean): void;

  useVideo(video: VisualVideoSource, intent?: VideoBindingIntent, serial?: WaveVideoPlaybackSerialState): WaveVideoPlayback | null;

  vertexEditing(): VertexEditingBuilder;

  videoMaterial(videoAssetName?: string): WaveVideoPlayback | null;

  visualLayer: VisualLayer;

  voxelize(options: VoxelizationOptions & { readonly execution: "workerThread"; }): VoxelGridResultAsync;

  voxelize(options: VoxelizationOptions): VoxelGridResult | VoxelGridResultAsync;

  voxelize(options?: VoxelizationOptions & { readonly execution?: "mainThread"; }): VoxelGridResult;

  voxelizing(): Visual3DModelVoxelizingBuilder<TOwner, "mainThread">;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  defineSurfaceState(input: WaveScalarSurfaceStateDefinition): WaveScalarSurfaceStateHandle;

  destroy(): void;

  getSurfaceState(id: string): WaveScalarSurfaceStateHandle | null;

  removeSurfaceState(id: string): boolean;

  serialize(): SerializedCall[];

  surfaceState(id: string): WaveScalarSurfaceStateBuilder<TOwner>;

}

declare class module_visual3DModelVoxelFacade<TOwner extends wave3DObject = wave3DObject> {

  actualizeStoredMaterialState(): boolean;

  addDecal(texture: string): DecalBuilder;

  addLocalAnimations(): void;

  alignOriginToModelBounds(forceAnchorMove?: boolean): this;

  allowUnsafePartDestroy: boolean;

  applySurfaceConfig(config: ObjectSurfaceConfig, options?: { preserveExplicitColor?: boolean; }): void;

  readonly canRender: boolean;

  captureProjectMaterialAssetDefinition(): ProjectMaterialAssetDefinition;

  castShadow: boolean;

  clearDecals(): void;

  clearEmissiveDistortionInput(): void;

  clearGeometryInfluenceView(): this;

  clearGpuDataSourceBindings(): this;

  clearPbrModifiers(target?: VisualModelTarget | null): this;

  clearReflectionPolicy(target?: WaveVisualTargetRef): this;

  clearSurfaceVfx(options?: { resetProgress?: boolean; }): this;

  clearVideo(): void;

  collectVatPlaybackMeshes(): readonly { readonly mesh: unknown; readonly meshId?: string; readonly name: string; }[];

  configureGaussianSplat(config: WaveGaussianSplatRuntimeConfig): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  createInstanceSource(options?: CreateInstanceSourceOptions): WaveInstanceSource;

  decalLayerMask: number;

  destroy(): void;

  disableAutoLOD(): this;

  disableEdgeRendering(): this;

  disableFresnelGlow(): this;

  disableGlow(): this;

  disableHighlight(): this;

  disableOutline(): this;

  disableSelectionOutline(): this;

  disableTrail(): this;

  discolorSurface(options?: SurfaceDiscolorOptions): this;

  dispose(): void;

  edgeColor: unknown;

  edgeEpsilon: number;

  edgeRenderingEnabled: boolean;

  edgeWidth: number;

  emissiveDistortion(): EmissiveDistortionBuilder;

  enableAutoLOD(config?: AutoLODConfig): this;

  enableBreadcrumbTrail(options?: BreadcrumbTrailOptions): VisualBreadcrumbTrailHandle;

  readonly enabled: boolean;

  enableEdgeRendering(options?: { width?: number; color?: ColorInput | string | [ number, number, number ] | number | null; epsilon?: number; }): this;

  enableFresnelGlow(options?: { color?: ColorInput | string | [ number, number, number ] | number | null; bias?: number; power?: number; }): this;

  enableGlow(intensity?: number, color?: ColorInput | string | [ number, number, number ] | number | null): this;

  enableHighlight(color?: ColorInput | string | [ number, number, number ] | number | null, options?: { innerGlow?: boolean; outerGlow?: boolean; glowEmissiveOnly?: boolean; }): this;

  enableOutline(options?: Parameters<module_visual3DModelEffectState["enableSelectionOutline"]>[0]): this;

  enableSelectionOutline(options?: { thicknessPixels?: number; color?: ColorInput | string | [ number, number, number ] | number | null; occlusionStrength?: number; occlusionThreshold?: number; }): this;

  enableTrail(options?: { blendFactor?: number; halfLifeSeconds?: number; intensity?: number; blendMode?: MotionTrailBlendMode; stretchPixels?: number; samples?: number; stretchDirection?: Vector2Like_3; worldSpace?: boolean; trailColor?: ColorInput | null; }): this;

  readonly engine: unknown;

  eraseSurface(options?: SurfaceErasureOptions): this;

  fresnelBias: number;

  fresnelColor: unknown;

  fresnelEnabled: boolean;

  fresnelPower: number;

  gaussianSplat(): WaveGaussianSplatRuntimeHandle<this>;

  geometryInfluenceViewEnabled: boolean;

  geometryInfluenceViewState: GeometryInfluenceViewModelState | null;

  getBoundingBox(): ModelBoundingBox | null;

  getBoundingBoxVolume(): number;

  getBoundModelValue(): WaveSceneModelValue | null;

  getColliderBounds(): { centerLocal: Vector3; halfExtents: Vector3; } | null;

  getGaussianSplatInfo(): WaveGaussianSplatRuntimeInfo | null;

  getHalfExtents(): Vector3;

  getMesh(name: string, scope?: MeshScope): unknown | undefined;

  getMeshCount(scope?: MeshScope): number;

  getMeshEntry(meshRef: MeshRef, scope?: MeshScope): MeshEntry | undefined;

  getMeshes(scope?: MeshScope): readonly unknown[];

  getModelBounds(space?: BoundsSpace, useRestPose?: boolean, forceRefresh?: boolean, includeHiddenOrDisabledMeshes?: boolean): ModelBounds | null;

  getModelTopologySignature(): string | null;

  getOrientedBounds(): ModelOrientedBounds | null;

  getOwnerComponent: { <T extends WaveComponent>(ComponentClass: ComponentConstructor<unknown>): unknown | undefined; <T extends WaveComponent>(componentName: string): unknown | undefined; }

  getPbrModifierInstances(): readonly PbrModifierInstanceSnapshot[];

  getSize(): Vector3;

  getVisualBounds(space?: BoundsSpace): ModelBounds | null;

  glowColor: any;

  glowEnabled: boolean;

  glowIntensity: number;

  gpuBinding<TType extends WaveShaderBindingType = WaveShaderBindingType>(name: string): WaveGpuDrivenBindingHandle<TType>;

  gpuData(id: string): WaveGpuDrivenDataChannelHandle;

  gpuDataSourceDebugTexel(channelId: string, x: number, y: number): WaveGpuDataSourceDebugTexel | null;

  gpuDataSourceDiagnostics(): WaveGpuDataSourceDiagnostics;

  gpuDataSources(): WaveGpuDataSourceBindingBuilder<this>;

  gpuDrivenDiagnostics(): WaveGpuDrivenModelRuntimeDiagnostics;

  gpuDrivenReady(): Promise<void>;

  gpuStateKernel(id: string): WaveGpuDrivenStateKernelHandle;

  hasFixedModelTopology: boolean;

  hasOwnedMeshes: boolean;

  hide(): void;

  highlightColor: unknown;

  highlightEnabled: boolean;

  highlightGlowEmissiveOnly: boolean;

  highlightInnerGlow: boolean;

  highlightOuterGlow: boolean;

  instanceEntries: any;

  invalidateVisualBounds(): void;

  isAggregateMeshOwner: boolean;

  isDecomposedShell: boolean;

  readonly isDestroyed: boolean;

  isDisposed: boolean;

  readonly isDisposing: boolean;

  isEdgeDirty: boolean;

  isFresnelDirty: boolean;

  isGaussianSplat(): boolean;

  isGeometryInfluenceViewDirty: boolean;

  isGlowDirty: boolean;

  isGpuDrivenModel(): boolean;

  isHighlightDirty: boolean;

  isMaterialStateDirty: boolean;

  isMeshlessModelRoot: boolean;

  isModelRevisionConsumerCurrent(): boolean;

  isOutlineDirty: boolean;

  isPart: boolean;

  isPartView(): boolean;

  isReflectionPolicyDirty: boolean;

  isRenderTintDirty: boolean;

  isSurfaceDiscolorDirty: boolean;

  isTrailDirty: boolean;

  listDecals(): waveDecal[];

  listGpuBindings(): readonly string[];

  listGpuDataChannels(): readonly string[];

  listGpuStateKernels(): readonly string[];

  listMeshEntries(scope?: MeshScope): MeshEntry[];

  listMeshes(scope?: MeshScope): MeshEntry[];

  listMeshNames(scope?: MeshScope): string[];

  markEdgeClean(): void;

  markFresnelClean(): void;

  markGeometryInfluenceViewClean(): void;

  markGlowClean(): void;

  markHighlightClean(): void;

  markMaterialStateClean(): void;

  markOutlineClean(): void;

  markPartAsPromoted(partId: string): void;

  markReflectionPolicyClean(): void;

  markRenderTintClean(): void;

  markSurfaceDiscolorClean(): void;

  markTrailClean(): void;

  materialAlphaMode: ProjectMaterialAlphaMode | null;

  materialAnisotropy: MaterialAnisotropyState;

  materialAssetName: string | null;

  materialClearCoat: MaterialClearCoatState;

  materialColor: unknown;

  materialDoubleSided: boolean;

  materialEmissiveColor: unknown;

  materialEmissiveIntensity: number;

  materialEnvironmentIntensity: number | null;

  materialFor(target: VisualModelTarget, slot?: number): MaterialEditorView;

  materialIridescence: MaterialIridescenceState;

  materialMaxSimultaneousLights: number | null;

  materialMetalness: number;

  materialOpacity: number;

  materialRoughness: number;

  materialSheen: MaterialSheenState;

  materialSlotFor(target: VisualModelTarget, slot: number): MaterialEditorView;

  materialSpecularIntensity: number | null;

  materialSubSurface: MaterialSubSurfaceState;

  materialTextures: { base?: string; normal?: string; metallic?: string; roughness?: string; ao?: string; emissive?: string; thickness?: string; transmission?: string; translucencyColor?: string; translucencyIntensity?: string; }

  materialTransparencyMode: ProjectMaterialTransparencyMode | null;

  materialType: "private" | "public";

  materialUseRadianceOverAlpha: boolean | null;

  materialUseSpecularOverAlpha: boolean | null;

  materialUVOffset: Vector2;

  materialUVRotation: number;

  materialUVRotationRadians: number;

  materialUVScale: Vector2;

  materialWireframe: boolean;

  maxDecals: number;

  meshMaterial(name: string): MaterialEditorView;

  meshMaterialSlot(name: string, slot: number): MaterialEditorView;

  meshOwnershipState: MeshOwnershipState;

  modelName: string | null;

  modelRevisionAssetOwner: SceneAssetAccess;

  modelRevisionContributionGeneration: number;

  modifyWith(recipe: WavePbrModifierRecipe, options?: WavePbrModifierApplicationOptions): this;

  onCloneFinalized(): void;

  outlineColor: unknown;

  outlineEnabled: boolean;

  outlineOcclusionStrength: number;

  outlineOcclusionThreshold: number;

  outlineThicknessPixels: number;

  readonly owner: TOwner;

  partMaterial(partRef: PartRef, slot?: number): MaterialEditorView;

  partMaterialSlot(partRef: PartRef, slot: number): MaterialEditorView;

  partOwnerVisual: cmp_visual3DModel<wave3DObject<unknown>> | null;

  prepareOperablePBR(): MaterialPretreatmentResult;

  prewarmSurfaceVfx(options?: SurfaceErasureWarmupOptions): SurfaceErasureWarmupResult;

  primaryMesh: any;

  privatizeMaterial(): void;

  promotedPartIds: unknown;

  promotedPartSource: PromotedVisualPartSource | null;

  receiveDecals: boolean;

  receiveShadow: boolean;

  reflection(target?: WaveVisualTargetRef): WaveVisualReflectionBuilder;

  reflectionPolicies: readonly WaveReflectionReceiverPolicy[];

  refreshGpuDataSources(): this;

  reloadModel(modelName: string): void;

  removeAntiTiling(): void;

  removeDecal(decal: waveDecal): void;

  removeEmissiveDistortion(): void;

  removeMaterial(options?: { fromAll?: boolean; restoreInnate?: boolean; }): void;

  removeModel(): void;

  removePbrModifier(instanceIdInput: string): this;

  removeWorldEmissive(): void;

  renderTintColor: unknown;

  renderTintEnabled: boolean;

  replaceFollowCurrentModel(change: AssetRevisionChange<"model">): void;

  requireOwnerComponent: { <T extends WaveComponent>(ComponentClass: ComponentConstructor<unknown>): unknown; <T extends WaveComponent>(componentName: string): unknown; }

  resetOrigin(forceAnchorMove?: boolean): this;

  runTimeCleanUp(): void;

  readonly scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setAlphaMode(mode: MaterialAlphaMode | null): void;

  setAnisotropy(config: Partial<Omit<MaterialAnisotropyState, "direction">> & { direction?: Vector2 | readonly [ number, number ]; }): void;

  setAntiTiling(options?: WaveMaterialAntiTilingOptions): void;

  setAOTexture(texturePath: string): void;

  setBaseTexture(texturePath: string): void;

  setClearCoat(config: Partial<MaterialClearCoatState>): void;

  setColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setDecalLayerMask(v: number): this;

  setDepthBias(value: number): void;

  setDoubleSided(enabled: boolean): void;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setEmissiveDistortion(config: EmissiveDistortionConfig): void;

  setEmissiveEffect<THandle extends WaveTextureEffectHandle = WaveTextureEffectHandle>(effect: WaveEffectInput): THandle;

  setEmissiveIntensity(intensity: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveIntensity(intensity: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveIntensity(intensity: number): void;

  setEmissiveTexture(texturePath: string): void;

  setEmissiveWobbleInput(x: number, y: number): void;

  setEnvironmentIntensity(value: number): void;

  setGeometryInfluenceView(state: GeometryInfluenceViewModelState): this;

  setGlowColor(color: ColorInput | string | [ number, number, number ] | number | null): this;

  setGlowIntensity(intensity: number): this;

  setGpuDataSourceBindings(input: WaveGpuDataSourceBindingPlanInput): this;

  setHighlightColor(color: ColorInput | string | [ number, number, number ] | number): this;

  setIndexOfRefraction(ior: number): void;

  setIridescence(config: Partial<MaterialIridescenceState>): void;

  setMaxDecals(v: number): this;

  setMaximumThickness(value: number): void;

  setMaxSimultaneousLights(value: number): void;

  setMetallicTexture(texturePath: string): void;

  setMetalness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setMetalness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setMetalness(value: number): void;

  setMinimumThickness(value: number): void;

  setNormalTexture(texturePath: string): void;

  setOpacity(alpha: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setOpacity(alpha: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setOpacity(alpha: number): void;

  setPbrModifier(instanceIdInput: string, recipeInput: WavePbrModifierRecipe, options?: SetPbrModifierOptions): this;

  setPbrModifierEnabled(instanceIdInput: string, enabled: boolean): this;

  setPbrModifierInputBindings(instanceIdInput: string, patch: WavePbrModifierInputBindings): this;

  setPbrModifierOrder(instanceIds: readonly string[]): this;

  setPbrModifierParameters(instanceIdInput: string, patch: WavePbrModifierParameterValues): this;

  setReceiveDecals(v: boolean): this;

  setReflectionPolicy(policy: WaveReflectionReceiverPolicy): this;

  setRefractionIntensity(value: number): void;

  setRoughness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setRoughness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setRoughness(value: number): void;

  setRoughnessTexture(texturePath: string): void;

  setSheen(config: Partial<Omit<MaterialSheenState, "color">> & { color?: ColorInput | string | [ number, number, number ] | number; }): void;

  setSpecularIntensity(value: number): void;

  setSubSurface(config: Partial<Omit<MaterialSubSurfaceState, "tintColor">> & { tintColor?: ColorInput | string | [ number, number, number ] | number | null; }): void;

  setSubSurfaceTintColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setSurfacePreset(preset: SurfacePreset, category?: SurfaceCategory): void;

  setSurfaceVfxProgress(progress: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setSurfaceVfxProgress(progress: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setSurfaceVfxProgress(progress: number): this;

  setThicknessTexture(texturePath: string): void;

  setTrailBlendFactor(factor: number): this;

  setTrailColor(color: ColorInput | string | [ number, number, number ] | number | null): this;

  setTranslucencyColorTexture(texturePath: string): void;

  setTranslucencyIntensity(value: number): void;

  setTranslucencyIntensityTexture(texturePath: string): void;

  setTransmissionTexture(texturePath: string): void;

  setUseRadianceOverAlpha(enabled: boolean): void;

  setUseSpecularOverAlpha(enabled: boolean): void;

  setUVOffset(offset: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(offset: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(offset: Vector2): void;

  setUVOffset(uOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, vOffset?: number): void;

  setUVRotation(degrees: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVRotation(degrees: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVRotation(degrees: number): void;

  setUVScale(scale: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(scale: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(scale: Vector2): void;

  setUVScale(uScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, vScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, vScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, vScale?: number): void;

  setWireframe(enabled: boolean): void;

  setWorldEmissive(config: WorldEmissiveConfig): void;

  show(): void;

  source: ModelConsumerSource | null;

  surface(selector: WaveFaceSelector, localDirection?: readonly [ number, number, number ]): WaveGeometrySurfaceHandle<MaterialEditorView>;

  surfaceSelection(id: string): WaveModelSurfaceSelectionBuilder;

  syncMaterialFreezePolicy(): void;

  trailBlendFactor: number;

  trailBlendMode: MotionTrailBlendMode;

  trailColor: any;

  trailEnabled: boolean;

  trailHalfLifeSeconds: number | null;

  trailIntensity: number;

  trailSamples: number;

  trailStretchDirection: { x: number; y: number; } | null;

  trailStretchPixels: number;

  trailWorldSpace: boolean;

  triggerEmissiveRipple(u?: number, v?: number, strength?: number): void;

  readonly typeName: string;

  useFixedGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedGeneratedModel(model: string): boolean;

  useFixedGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedModel(model: Visual3DModelAuthoringInput, options?: Omit<Visual3DModelUseOptions, "topology">): void;

  useGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useGeneratedModel(model: string): boolean;

  useGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useMaterial(material: MaterialInput, toAll?: boolean, materialType?: MaterialUseMode): void;

  useModel(model: Visual3DModelAuthoringInput, options?: Visual3DModelUseOptions): void;

  usePrivateMaterialInput(input: WaveMaterialInput, toAll?: boolean): void;

  useVideo(video: VisualVideoSource, intent?: VideoBindingIntent, serial?: WaveVideoPlaybackSerialState): WaveVideoPlayback | null;

  videoMaterial(videoAssetName?: string): WaveVideoPlayback | null;

  visualLayer: VisualLayer;

  voxelize(options: VoxelizationOptions & { readonly execution: "workerThread"; }): VoxelGridResultAsync;

  voxelize(options?: VoxelizationOptions & { readonly execution?: "mainThread"; }): VoxelGridResult;

  voxelize(options: VoxelizationOptions): VoxelGridResult | VoxelGridResultAsync;

  voxelizing(): Visual3DModelVoxelizingBuilder<TOwner>;

}

declare class MorphToBuilder {

  animate(): WaveGeometryDeformAnimationBuilder;

  withFactor(factor: number): this;

}

interface MotionTrailOptions {

  backgroundColor?: ColorInput;

  blendFactor?: number;

  blendMode?: MotionTrailBlendMode;

  fadeAlpha?: number;

  halfLifeSeconds?: number;

  intensity?: number;

  keepPipeline?: boolean;

  samples?: number;

  stretchDirection?: Vector2Like;

  stretchPixels?: number;

  targetObject?: MotionTrailTargetObject;

  trailColor?: ColorInput;

  worldSpace?: boolean;

}

interface MotionTrailTargetObject {

  model?: { getSurfaceSourceMeshes?: () => readonly unknown[]; getMeshes?: () => readonly unknown[]; }

}

interface MotorConfig {

  axis: ConstraintAxis;

  damping?: number;

  maxForce?: number;

  mode: MotorMode;

  stiffness?: number;

  target: number;

}

declare enum MotorMode {

  NONE = 0,

  POSITION = 2,

  SPRING_ACCELERATION = 4,

  SPRING_FORCE = 3,

  VELOCITY = 1,

}

interface MouseButtonInputData {

  button: MouseButton;

  entityId?: number;

  heldDurationMs: number;

  heldFor: WaveTimeSpan;

  heldTicks: number;

  position: SerializableVector2;

  timestamp: number;

}

interface MouseMoveInputData {

  delta: SerializableVector2;

  position: SerializableVector2;

  timestamp: number;

}

interface MouseWheelInputData {

  delta: SerializableVector3;

  timestamp: number;

}

interface MovementConfig {

  rotationSpeed?: number;

  speed?: number;

}

interface MovementContext {

  flightPitch?: number;

  flightRoll?: number;

  flightYaw?: number;

  vehicleBrake?: number;

  vehicleSteer?: number;

  vehicleThrottle?: number;

}

interface MovementIntent {

  context?: MovementContext;

  lookDelta: SerializableVector2;

  moveDirection: SerializableVector3;

  sequenceNumber: number;

  throttle: number;

  timestamp: number;

  wantsCrouch: boolean;

  wantsJump: boolean;

  wantsSprint: boolean;

}

declare enum MovementMode {

  Custom = "custom",

  Flying = "flying",

  Spectator = "spectator",

  Swimming = "swimming",

  Vehicle = "vehicle",

  Walking = "walking",

}

interface MovementParameters {

  acceleration: number;

  airAcceleration: number;

  airControlFactor: number;

  airFriction: number;

  ascendSpeedScale: number;

  baseSpeed: number;

  crouchMultiplier: number;

  deceleration: number;

  descendSpeedScale: number;

  friction: number;

  gravityScale: number;

  jumpForce: number;

  rebound: number;

  reverseSpeedScale: number;

  sprintMultiplier: number;

  strafeSpeedScale: number;

  terminalVelocity: number;

}

declare enum MovementStrategy {

  Custom = "custom",

  Kinematic = "kinematic",

  None = "none",

  RigidBody = "rigidBody",

  Transform = "transform",

}

interface MutableWavePhysicsRigDynamicDriveTuning {

  angularDamping?: number;

  damping?: number;

  maxForce?: number;

  maxTorque?: number;

  positionStrength?: number;

  rotationStrength?: number;

  strength?: number;

}

interface MutableWavePhysicsRigDynamicSegmentTarget<T extends WavePhysicsRigPart> {

  axis: DirectionInput;

  body: T;

  end: WavePhysicsRigKinematicPointTarget;

  headingAxis: DirectionInput;

  headingFrame?: TransformReferenceLike;

  kind: "segment";

  readonly memory: WavePhysicsRigDynamicDriveTargetMemory;

  resolvedOptions?: ResolvedDynamicDriveOptions;

  resolvedOptionsRevision: number;

  readonly sourceBasisRotation: Quaternion;

  sourceBasisValid: boolean;

  start: WavePhysicsRigKinematicPointTarget;

  tuning?: MutableWavePhysicsRigDynamicDriveTuning;

}

interface MutableWavePhysicsRigDynamicTransformTarget<T extends WavePhysicsRigPart> {

  body: T;

  kind: "transform";

  readonly memory: WavePhysicsRigDynamicDriveTargetMemory;

  position?: WavePhysicsRigKinematicPointTarget;

  resolvedOptions?: ResolvedDynamicDriveOptions;

  resolvedOptionsRevision: number;

  rotation?: Quaternion;

  tuning?: MutableWavePhysicsRigDynamicDriveTuning;

}

interface MutableWavePhysicsRigKinematicSegmentTarget<T extends WavePhysicsRigPart> {

  autoResize: boolean;

  axis: DirectionInput;

  body: T;

  end: WavePhysicsRigKinematicPointTarget;

  headingAxis: DirectionInput;

  headingFrame?: TransformReferenceLike;

  kind: "segment";

  start: WavePhysicsRigKinematicPointTarget;

}

interface MutableWavePhysicsRigKinematicTransformTarget<T extends WavePhysicsRigPart> {

  body: T;

  kind: "transform";

  position?: WavePhysicsRigKinematicPointTarget;

  preserveLocalScale?: boolean;

  rotation?: Quaternion;

  scale?: Vector3;

}

interface MuzzleFlashOpts {

  anchorOffset?: Partial<Vector3Like>;

  billboard?: SpriteOpts["billboard"];

  blend?: SpriteOpts["blend"];

  color?: ColorLike;

  count?: NumLike;

  direction?: FxVelocityConeDirectionInput;

  directionSpace?: VelocityConeDirectionSpace;

  drag?: NumLike;

  fade?: [number, number][];

  glow?: SpriteOpts["glow"];

  growth?: [number, number][];

  lifetime?: NumLike;

  size?: NumLike;

  sort?: SpriteOpts["sort"];

  speed?: NumLike;

  spin?: boolean | NumLike;

  spreadAngle?: NumLike;

  style?: "tight" | "balanced" | "wide";

  texture: string;

}

interface NegateModifier {

  type: ModifierType.Negate;

}

type NetCapsuleOptions = NetPrimitiveGeometryOptions<WaveCapsulePrimitiveRecipe>;

type NetCavityOptions = NetworkOptions;

type NetConeOptions = NetPrimitiveGeometryOptions<WaveConePrimitiveRecipe>;

type NetCubeOptions = NetPrimitiveGeometryOptions<WaveBoxPrimitiveRecipe>;

type NetCylinderOptions = NetPrimitiveGeometryOptions<WaveCylinderPrimitiveRecipe>;

interface NetDecalOptions {

  albedoTexture?: string | undefined;

  albedoTint?: ColorInput | undefined;

  angleFade?: number | undefined;

  authority?: EntityAuthority | undefined;

  blendMode?: DecalBlendMode | undefined;

  emissiveIntensity?: number | undefined;

  glowColor?: ColorInput | undefined;

  height?: number | undefined;

  layerMask?: number | undefined;

  length?: number | undefined;

  mask?: DecalMaskMode | undefined;

  maskFeather?: number | undefined;

  metallicMultiplier?: number | undefined;

  name?: string | undefined;

  normalBlendMode?: DecalNormalBlendMode | undefined;

  normalTexture?: string | undefined;

  opacity?: number | undefined;

  ownerClientId?: string | null | undefined;

  priority?: number | undefined;

  properties?: Record<string, unknown> | undefined;

  replicateMode?: ReplicateMode | undefined;

  replicateTargets?: string[] | undefined;

  roughnessMultiplier?: number | undefined;

  uvOffset?: { x: number; y: number; } | undefined;

  uvRotation?: number | undefined;

  width?: number | undefined;

}

type NetDiscOptions = NetPrimitiveGeometryOptions<WaveDiscPrimitiveRecipe>;

interface NetGeometryOptions {

  authority?: EntityAuthority | undefined;

  name?: string | undefined;

  ownerClientId?: string | null | undefined;

  properties?: Record<string, unknown> | undefined;

  replicateMode?: ReplicateMode | undefined;

  replicateTargets?: string[] | undefined;

  color?: string | unknown | number;

}

interface NetInstanceMeshOptions {

  authority?: EntityAuthority | undefined;

  castShadow?: boolean | undefined;

  forceActiveWhenOffscreen?: boolean | undefined;

  glowColor?: ColorInput | null | undefined;

  glowEnabled?: boolean | undefined;

  glowIntensity?: number | undefined;

  model: string | ModelConsumerSource | AssetRef<"model"> | WaveModelInput<unknown>;

  name?: string | undefined;

  ownerClientId?: string | null | undefined;

  properties?: Record<string, unknown> | undefined;

  replicateMode?: ReplicateMode | undefined;

  replicateTargets?: string[] | undefined;

}

type NetLatheOptions = NetPrimitiveGeometryOptions<WaveLathePrimitiveRecipe>;

type NetPlaneOptions = NetPrimitiveGeometryOptions<WavePlanePrimitiveRecipe>;

type NetPolygonOptions = NetPrimitiveGeometryOptions<WavePolygonPrimitiveRecipe>;

type NetPrimitiveGeometryOptions<TRecipe> = NetGeometryOptions & Partial<Omit<TRecipe, "kind" | "version" | "shape">> & { primitiveRecipe?: TRecipe; }

type NetSphereOptions = NetPrimitiveGeometryOptions<WaveSpherePrimitiveRecipe>;

type NetTorusKnotOptions = NetPrimitiveGeometryOptions<WaveTorusKnotPrimitiveRecipe>;

type NetTorusOptions = NetPrimitiveGeometryOptions<WaveTorusPrimitiveRecipe>;

type NetWedgeOptions = NetPrimitiveGeometryOptions<WaveWedgePrimitiveRecipe>;

interface NetworkEventBridge {

  send(eventName: string, payload: unknown, options?: RemoteEventOptions): void;

}

interface NetworkHealthMetrics {

  bandwidthKbps: number;

  jitterMs: number;

  packetLoss: number;

  rttMs: number;

  snapshotJitter?: number;

  snapshotLoss?: number;

  state: NetworkHealthState;

  timestamp: number;

}

type NetworkHealthState = "excellent" | "good" | "fair" | "poor" | "critical";

interface NetworkOptions {

  authority?: EntityAuthority;

  name?: string;

  ownerClientId?: string | null;

  properties?: Record<string, unknown>;

  replicateMode?: ReplicateMode;

  replicateTargets?: string[];

}

declare enum NetworkRegion {

  China = "china",

  Global = "global",

}

interface NetworkTransform {

  position: Vector3Like_2;

  rotation: QuaternionLike_2;

  scale: Vector3Like_2;

}

type NetworkTransport = "none" | "webrtc" | "socketio";

interface NightVisionOptions {

  animatedNoise?: boolean;

  colorAmplification?: number;

  luminanceThreshold?: number;

  noiseIntensity?: number;

}

declare class NoiseBuilder {

  animate(): WaveGeometryDeformAnimationBuilder;

  apply(): MeshEditResult;

  atCenters(centers: readonly Vector3Like[], radius: number): this;

  forceMergeMesh(force?: boolean): this;

  inDirection(dir: Vector3Like): this;

  mode(mode: DeformApplyMode): this;

  randomizeSeed(randomize?: boolean): this;

  withAmplitude(amp: number): this;

  withFalloff(falloff: "smooth" | "linear" | "sharp" | "gaussian"): this;

  withFrequency(freq: number): this;

  withSeed(seed: number): this;

}

interface NoiseOptions {

  amplitude: number;

  applyMode?: DeformApplyMode;

  centers?: Vector3[];

  direction?: Vector3;

  falloff?: "smooth" | "linear" | "sharp" | "gaussian";

  frequency?: number;

  radius?: number;

  randomizeSeed?: boolean;

  seed?: number;

}

interface NormalizedAssetBody {

  readonly body: SerializableDataValue;

  readonly dependencies: readonly AssetIdentity[];

  readonly exactPins?: readonly NormalizedAssetExactPin[];

}

interface NormalizedAssetExactPin {

  readonly dependencyIndex: number;

  readonly revision: string;

}

interface NormalizedAudioPlaybackDefaults {

  readonly busName?: string;

  readonly loop: boolean;

  readonly pitchCents: number;

  readonly playbackRate: number;

  readonly volume: number;

}

interface NormalizedModelBindingIntent {

  readonly geometry: AssetIsolationMode;

  readonly hydration: ModelHydrationIntent;

  readonly materials: AssetIsolationMode;

  readonly projection: ModelBindingProjection;

  readonly topology: ModelTopologyIntent;

  readonly use: ModelUseMode;

}

interface NormalizedThinkingDecisionChoice<TTarget = unknown> {

  allowedInStates: string[] | null;

  blockedInStates: string[] | null;

  id: string;

  perform: ThinkingChoiceRunner<TTarget>;

}

type NormalizedWaveAudioFxNode = WaveInstrumentFxNode;

type NumericObservationInput<TEntity extends object> = NumericSelector<TEntity> | WaveNumericObservationSource<TEntity>;

declare class NumericObservationSource<TEntity extends BehaviorObservationRuntimeHost> implements WaveNumericObservationSource<TEntity> {

  constructor(target: ObservationSourceBuilderTarget<TEntity>, source: ObservationSourceDefinition<TEntity>);

  above(value: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  atLeast(value: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  atMost(value: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  below(value: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  between(min: number, max: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  equals(value: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  near(value: number, tolerance: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  outside(min: number, max: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

}

interface NumericPredicateDefinition {

  kind: NumericPredicateKind;

  occurrence: ObservationOccurrenceKind;

  rate?: ObservationRateOptions | null;

  secondThreshold?: number;

  threshold: number;

}

type NumericPredicateKind = "above" | "below" | "atLeast" | "atMost" | "equals" | "near" | "between" | "outside";

type NumericSelector<TEntity extends object> = BivariantCallback<[entity: TEntity], number>;

type NumLike = WaveNumberValueInput;

type ObservationAction<TEntity extends object> = BivariantCallback<[entity: TEntity], void>;

type ObservationChangeKind = ObservationChangeToken["kind"];

type ObservationChangeToken = typeof ToTrue | typeof ToFalse | typeof Flips;

interface ObservationDefinition<TEntity extends BehaviorObservationRuntimeHost> {

  action: ObservationExecutableAction<TEntity> | null;

  predicate: ObservationPredicateDefinition;

  source: ObservationSourceDefinition<TEntity>;

}

type ObservationExecutableAction<TEntity extends object> = ObservationAction<TEntity> | ObservationMethodCallAction;

interface ObservationHandle {

  dispose(): void;

}

interface ObservationMethodCallAction {

  args: readonly unknown[];

  kind: "methodCall";

  methodName: string;

}

type ObservationOccurrenceKind = ObservationOccurrenceToken["kind"];

type ObservationOccurrenceToken = typeof FirstTime | typeof EveryTime;

type ObservationPredicateDefinition = BooleanPredicateDefinition | NumericPredicateDefinition;

type ObservationRateBasisKind = ObservationRateBasisToken["kind"];

type ObservationRateBasisToken = typeof PerSecond | typeof PerTick;

interface ObservationRateOptions {

  basis: ObservationRateBasisKind;

  window: ObservationWindow | null;

}

declare class ObservationSourceBuilderTarget<TEntity extends BehaviorObservationRuntimeHost> {

  constructor(register: (definition: ObservationDefinition<TEntity>) => ObservationHandle);

  register(definition: ObservationDefinition<TEntity>): ObservationHandle;

}

interface ObservationSourceDefinition<TEntity extends BehaviorObservationRuntimeHost> {

  kind: ObservationSourceKind;

  selector: ((entity: TEntity) => boolean) | NumericSelector<TEntity>;

}

type ObservationSourceKind = "boolean" | "numeric" | "changeRate" | "growthRate" | "declineRate";

type OcclusionAlgorithm = "accurate" | "conservative";

interface OcclusionCullingOptions {

  algorithm?: OcclusionAlgorithm;

  excludeNames?: string[];

  maxDistance?: number;

  maxQueriesPerFrame?: number;

  minScreenCoverage?: number;

  minVertexCount?: number;

  retryCount?: number;

  strategy?: OcclusionStrategy;

  strictForStatic?: boolean;

}

type OcclusionStrategy = "optimistic" | "strict";

interface OilPaintingOptions {

  brushJitter?: number;

  brushRadius?: number;

  brushStretch?: number;

  canvasGrain?: number;

  colorLevels?: number;

  edgeStrength?: number;

  intensity?: number;

}

type OpaqueString<TBrand extends symbol> = string & { readonly [TKey in TBrand]: true; }

interface OrbitOptions {

  cameraPosition?: WavePointInput;

  distance?: number;

  fov?: number;

  panSensitivity?: number;

  rotateSensitivity?: number;

  target?: WavePointInput;

  zoomSpeed?: number;

}

interface OrbitTargetOptions {

  cameraPosition?: WavePointInput;

  distance?: number;

  fov?: number;

}

interface OrbitTRSSensitivity {

  readonly rotation?: number;

  readonly scale?: number;

  readonly translation?: number;

}

interface OverheadPanelOptions {

  decimals?: number | undefined;

  duration?: number | undefined;

  fontAsset?: string | undefined;

  fontSize?: number | undefined;

  labelOffset3D?: any;

  labelOffset3DSpace?: "world" | "local" | undefined;

  textColor?: any;

  updateMode?: DevToolUpdateMode | undefined;

  verticalOffset?: number;

}

type PaintBrushFalloff = "smooth" | "linear" | "hard";

type PaintBrushShape = "sphere" | "cylinder";

declare class PaintVertexColorsBuilder {

  apply(): VertexColorResult;

  at(center: WavePointInput): this;

  atCenter(center: WavePointInput): this;

  channel(ch: VertexColorChannel): this;

  falloff(falloff: PaintBrushFalloff): this;

  forceMergeMesh(force?: boolean): this;

  layer(layer: VertexColorChannel | MaterialSplatLayerId): this;

  normalize(norm?: boolean): this;

  onChannel(ch: VertexColorChannel): this;

  paint(): VertexColorResult;

  radius(r: number): this;

  shape(shape: PaintBrushShape): this;

  strength(s: number): this;

  withFalloff(falloff: PaintBrushFalloff): this;

  withRadius(r: number): this;

  withShape(shape: PaintBrushShape): this;

  withStrength(s: number): this;

}

interface PaintVertexColorsOptions {

  center: Vector3;

  channel: VertexColorChannel;

  falloff?: PaintBrushFalloff;

  normalize?: boolean;

  radius: number;

  shape?: PaintBrushShape;

  strength?: number;

}

declare class PaintVertexColorsPolygonBuilder {

  apply(): VertexColorResult;

  channel(ch: VertexColorChannel): this;

  feather(f: number): this;

  forceMergeMesh(force?: boolean): this;

  layer(layer: VertexColorChannel | MaterialSplatLayerId): this;

  maxPlaneDistance(d: number): this;

  normalize(norm?: boolean): this;

  onChannel(ch: VertexColorChannel): this;

  paint(): VertexColorResult;

  polygon(pts: readonly Vector3Like[]): this;

  strength(s: number): this;

  withFeather(f: number): this;

  withPolygon(pts: readonly Vector3Like[]): this;

  withStrength(s: number): this;

}

interface PaintVertexColorsPolygonOptions {

  channel: VertexColorChannel;

  feather?: number;

  maxPlaneDistance?: number;

  normalize?: boolean;

  polygon: Vector3[];

  strength?: number;

}

declare class PaintVertexColorsTextureBuilder {

  apply(): VertexColorResult;

  at(center: WavePointInput): this;

  atCenter(center: WavePointInput): this;

  channel(ch: VertexColorChannel): this;

  forceMergeMesh(force?: boolean): this;

  fromAsset(assetName: string): this;

  layer(layer: VertexColorChannel | MaterialSplatLayerId): this;

  maskChannel(ch: TextureStampMaskChannel): this;

  maxPlaneDistance(d: number): this;

  normalize(norm?: boolean): this;

  onChannel(ch: VertexColorChannel): this;

  paint(): VertexColorResult;

  projectAlong(normal: DirectionInput): this;

  rotate(deg: number): this;

  rotatedBy(deg: number): this;

  sized(w: number, h: number): this;

  strength(s: number): this;

  threshold(value: number): this;

  withSize(w: number, h: number): this;

  withStrength(s: number): this;

}

type PaletteColorKey = 'BLACK' | 'WHITE' | 'IVORY' | 'WARM_WHITE' | 'GRAY' | 'LIGHT_GRAY' | 'DARK_GRAY' | 'COOL_GRAY' | 'WARM_GRAY' | 'CHARCOAL' | 'SAND' | 'SOFT_TAUPE' | 'BONE' | 'RED' | 'CARMINE' | 'CRIMSON' | 'SCARLET' | 'VERMILION' | 'BRICK' | 'RUST' | 'WINE' | 'MAROON' | 'CORAL' | 'ORANGE' | 'TANGERINE' | 'PUMPKIN' | 'AMBER' | 'COPPER' | 'TERRACOTTA' | 'PERSIMMON' | 'YELLOW' | 'LEMON' | 'CANARY' | 'GOLDENROD' | 'MUSTARD' | 'MAIZE' | 'GREEN' | 'MINT' | 'SAGE' | 'OLIVE' | 'MOSS' | 'FOREST' | 'EMERALD' | 'JADE' | 'CYAN' | 'TURQUOISE' | 'BLUE' | 'SKY' | 'AZURE' | 'CERULEAN' | 'COBALT' | 'ROYAL' | 'NAVY' | 'PRUSSIAN' | 'SLATE' | 'MIDNIGHT' | 'INDIGO' | 'PURPLE' | 'MAGENTA' | 'FUCHSIA' | 'PINK' | 'LAVENDER' | 'LILAC' | 'AMETHYST' | 'VIOLET' | 'PLUM' | 'BROWN' | 'WALNUT' | 'STRAW' | 'TEAL' | 'LIME' | 'CELADON' | 'ORCHID' | 'AUBERGINE' | 'CHARTREUSE' | 'RAW_UMBER' | 'BURNT_UMBER' | 'RAW_SIENNA' | 'BURNT_SIENNA' | 'SEPIA' | 'OCHRE' | 'CHESTNUT' | 'ESPRESSO' | 'TUSCAN_TAN' | 'ESPRESSO_DARK' | 'OLIVE_DRAB' | 'SKY_DEEP' | 'CERULEAN_DARK' | 'SILVER' | 'GOLD' | 'BRASS' | 'BRONZE' | 'ROSE_GOLD' | 'PLATINUM' | 'PORCELAIN' | 'FAIR' | 'BEIGE' | 'ALMOND' | 'HONEY' | 'CARAMEL' | 'BRONZE_SKIN' | 'UMBER_DEEP' | 'KHAKI';

type PaletteColorMap = Record<PaletteColorKey, number>;

declare enum PaletteStyle {

  Designer = "designer",

  RGBClassic = "rgb-classic",

}

interface PaniniProjectionOptions {

  d?: number;

  fovCompensation?: number;

}

type ParentableWaveEntity = WaveEntity & WaveSpatial3DEntity;

type PartAutoRenameInput = WaveModelPartAutoRenameInput;

interface PartCollidersOptions {

  max?: number;

  shape?: CompoundColliderChildType;

}

type PartCreationRef = PartRef | MeshRef;

type PartCreationSelection = PartCreationRef | readonly PartCreationRef[] | null | undefined;

interface PartDeleteResult<TEntity = wave3DObject> {

  readonly mesh: unknown | null;

  readonly meshes: readonly unknown[];

  readonly mode: WaveModelPartDeleteMode;

  readonly name: string;

  readonly part: TEntity | null;

}

type PartDestructiveSelection = PartRef | readonly PartRef[];

type PartEntityCreationMode = "eager" | "lazy";

interface PartEntry<TEntity = wave3DObject> {

  readonly entity: TEntity | null;

  readonly id: VisualPartId;

  readonly includeInPhysics: boolean;

  readonly info: VisualPartInfo<TEntity>;

  readonly key: string;

  readonly mesh: unknown | null;

  readonly meshes: readonly unknown[];

  readonly metadata?: WaveModelPartMetadata;

  readonly name: string;

  readonly parentId: VisualPartId | null;

  readonly state: WaveModelPartLifecycleState;

}

interface PartMassPropertiesInput {

  readonly centerOfMass?: Vector3Like;

  readonly mass?: number;

}

type PartMaterialIsolationMode = "shared" | "private";

interface PartMutationResult<TEntity = wave3DObject> {

  readonly changed: boolean;

  readonly name: string;

  readonly part: TEntity | null;

  readonly previousName: string;

}

type PartPatch = WaveModelPartPatch<PartRef>;

type PartPatchInput = PartPatch | readonly PartPatch[] | Readonly<Record<string, PartPatchValue>> | PartAutoRenameInput;

type PartPatchValue = WaveModelPartPatchValue<PartRef>;

type PartRef = VisualPartRef;

type PartSelection = PartRef | readonly PartRef[] | null | undefined;

type PathExtrusionContourInput = Vector3[] | Array<Vector3Like>;

type PathExtrusionGeometrySourceInput = SingleContourGeometrySourceInput;

interface PathExtrusionMetadata {

  frameBinormals: Vector3[];

  frameNormals: Vector3[];

  frameTangents: Vector3[];

  isClosed: boolean;

  pathPoints: Vector3[];

  profileContours: Vector3[][];

  ringCenters: Vector3[];

  ringCount: number;

  ringProgress: number[];

  sourcePathPoints: Vector3[];

  vertsPerRing: number;

}

interface PathExtrusionOffsetProgressionSpec {

  x?: WaveValueCurveSpec;

  y?: WaveValueCurveSpec;

}

interface PathExtrusionOptions {

  capEnds?: boolean;

  closePath?: boolean;

  closeShape?: boolean;

  followPathOrientation?: boolean;

  frameMode?: WavePathExtrusionFrameMode;

  offsetProgression?: PathExtrusionOffsetProgressionSpec;

  rotationProgression?: WaveValueCurveSpec;

  scaleProgression?: WaveValueCurveSpec;

  steps?: number;

  upVector?: DirectionInput;

}

type PathExtrusionPathInput = Exclude<PathShapeInput, string | unknown>;

interface PathFollowGpuData {

  readonly data: Float32Array;

  readonly format: "rgba32f";

  readonly height: number;

  readonly pathCount: number;

  readonly pathLengths: readonly number[];

  readonly samplesPerPath: number;

  readonly width: number;

}

interface PathFollowInstanceParams {

  flags?: PathFollowFlags | number;

  offset?: number;

  pathIndex: number;

  speed: number;

}

interface PathFollowOptions {

  defaultFlags?: PathFollowFlags | number;

  defaultSpeed?: number;

  samplesPerPath?: number;

  speedByProgress?: WaveMotionSpeedInput;

}

interface PathFollowPointProvider {

  toPathPoints(): readonly Vector3[];

}

type PathFollowSource = readonly Vector3[] | readonly (readonly Vector3[])[] | WavePathSampleProvider | readonly WavePathSampleProvider[] | PathFollowPointProvider | readonly PathFollowPointProvider[] | WaveGeometryData | readonly WaveGeometryData[] | string | readonly string[];

declare class PathFollowTexture {

  constructor(texture: unknown, gpuData: PathFollowGpuData);

  commitPathUpdates(): boolean;

  get data(): Float32Array;

  dispose(): void;

  getPathLength(pathIndex: number): number;

  readonly pathCount: number;

  readonly samplesPerPath: number;

  readonly texture: unknown;

  updatePath(pathIndex: number, points: readonly Vector3[]): void;

  writePath(pathIndex: number, points: readonly Vector3[]): void;

}

interface PathFrame {

  distance: number;

  point: Vector3;

  progress: number;

  segmentIndex: number;

  segmentProgress: number;

  binormal: Vector3;

  normal: Vector3;

  rotation: Quaternion;

  tangent: Vector3;

}

interface PathFrameOptions {

  lookAheadProgress?: number;

  orientation?: PathOrientationMode;

  roll?: number;

  upVector?: DirectionInput;

}

type PathOrientationMode = "yawOnly" | "tangent3D" | "upright" | "pathNormal";

type PathPointInput = TransformPointInput;

interface PathProjection {

  distance: number;

  point: Vector3;

  progress: number;

  segmentIndex: number;

  segmentProgress: number;

  squaredDistance: number;

}

type PathRibbonCapMode = "none" | "round" | "square";

interface PathSampleCache {

  closed: boolean;

  cumulativeLengths: number[];

  points: Vector3[];

  segmentLengths: number[];

  totalLength: number;

}

interface PathSamplePoint {

  distance: number;

  point: Vector3;

  progress: number;

  segmentIndex: number;

  segmentProgress: number;

}

type PathShapeInput = Vector3[] | Array<Vector3Like> | WaveCurve2DSource | CurveResult | { curvePoints: Vector3[]; } | string | unknown;

interface PathSpawnOpts {

  forParticles?: { start: number; count: number; }

  stations: number;

  stationSequence?: { offset?: number; step?: number; phase?: number; }

}

interface PathSurfaceHeightSample {

  readonly column: number;

  readonly columnProgress: number;

  readonly distance: number;

  readonly position: Vector3;

  readonly row: number;

  readonly rowProgress: number;

  readonly width: number;

}

type PathSurfaceHeightSource = (sample: PathSurfaceHeightSample) => number | null | undefined;

type PathSurfaceInput = WavePathExtrusionPathInput;

interface PathSurfaceMetadata {

  centerPathPoints: SerializableVector3[];

  hasBody: boolean;

  isClosed: boolean;

  leftPathPoints: SerializableVector3[];

  pathDistances: number[];

  pathProgress: number[];

  rightPathPoints: SerializableVector3[];

  sampleCount: number;

  thickness: number;

  totalLength: number;

  widthSegments: number;

}

interface PathSurfaceOptions {

  capEnds?: boolean;

  closePath?: boolean;

  heightSource?: PathSurfaceHeightSource;

  invertNormals?: boolean;

  pathDistanceOffset?: number;

  sampleMode?: "uniform" | "paired";

  sideUvMode?: "normalized" | "distance";

  sideWalls?: boolean;

  steps?: number;

  thickness?: number;

  thicknessDirection?: "normal" | "down" | "up" | Vector3Like;

  updatable?: boolean;

  uScale?: number;

  uvMode?: "normalized" | "distance";

  vScale?: number;

  widthSegments?: number;

}

declare enum PatternType {

  Complex = "complex",

  Cyclical = "cyclical",

  Linear = "linear",

  Unknown = "unknown",

}

interface PbrModifierInstanceSnapshot {

  readonly enabled: boolean;

  readonly inputBindings: WavePbrModifierInputBindings;

  readonly instanceId: string;

  readonly order: number;

  readonly parameters: WavePbrModifierParameterValues;

  readonly recipe: WavePbrModifierRecipe;

  readonly target: { readonly kind: "mesh" | "part"; readonly ref: string; } | null;

}

declare class PhysicalAtmosphereConfigurator<TEngine extends unknown = unknown> {

  constructor(_sky: SkyConfigurator<TEngine>);

  additionalDiffuseSkyIrradiance(intensity: number, color?: ColorInput): this;

  aerialPerspectiveIntensity(value: number): this;

  aerialPerspectiveLut(value?: boolean): this;

  aerialPerspectiveRadianceBias(value: number): this;

  aerialPerspectiveSaturation(value: number): this;

  aerialPerspectiveTransmittanceScale(value: number): this;

  alien(patch: PhysicalAtmosphereConfig): this;

  apply(): SkyConfigurator<TEngine>;

  approximateTransmittance(value?: boolean): this;

  atmosphereThickness(valueKm: number): this;

  clearFog(): this;

  configure(patch: PhysicalAtmosphereConfig): this;

  diffuseSkyIrradiance(intensity: number, desaturationFactor?: number): this;

  diffuseSkyIrradianceLut(value?: boolean): this;

  disable(): SkyConfigurator<TEngine>;

  distantFog(config?: PhysicalAtmosphereFogConfig): this;

  earthLike(): this;

  exposure(value: number): this;

  fog(config?: PhysicalAtmosphereFogConfig): this;

  fullRayMarching(): this;

  groundAlbedo(color: ColorInput): this;

  mie(scatteringScale: number, absorptionScale?: number): this;

  mieAbsorptionScale(value: number): this;

  mieScatteringScale(value: number): this;

  minimumMultiScattering(intensity: number, color?: ColorInput): this;

  multipleScattering(value: number): this;

  multiScatteringIntensity(value: number): this;

  originHeight(valueKm: number): this;

  ozone(scale: number, peakAbsorption?: Vector3Like): this;

  ozoneAbsorptionScale(value: number): this;

  peakMieAbsorption(value: Vector3Like): this;

  peakMieScattering(value: Vector3Like): this;

  peakOzoneAbsorption(value: Vector3Like): this;

  peakRayleighScattering(value: Vector3Like): this;

  planet(radiusKm: number, atmosphereThicknessKm?: number): this;

  planetRadius(valueKm: number): this;

  planetRadiusOffset(valueKm: number): this;

  rayleigh(scale: number, peakScattering?: Vector3Like): this;

  rayleighScale(value: number): this;

  skyViewLut(value?: boolean): this;

  useLuts(value?: boolean): this;

}

interface PhysicsBodyApplicationRegionInput {

  readonly at: WavePointInput | RigidBodyInteractionHitInput;

  readonly radius?: number;

}

default abstract class PhysicsBodyComponentCore<TOwner extends WaveEntity = WaveEntity> {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: TOwner;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  typeName: string;

  get activationPolicy(): RigidBodyActivationPolicy;

  get actuationTriggerIds(): string[];

  addAngularVelocity(delta: Vector3Like | DirectionInput): this;

  addAngularVelocity(dx: number, dy: number, dz: number): this;

  addAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): this;

  addLinearVelocity(delta: Vector3Like | DirectionInput): this;

  addLinearVelocity(dx: number, dy: number, dz: number): this;

  addLinearVelocity(direction: Vector3Like | DirectionInput, speed: number): this;

  alwaysActive(enabled?: boolean): this;

  get angularDamping(): number;

  get angularInertiaConfig(): Vector3Like | null;

  get angularVelocity(): Vector3Like | null;

  applyAngularImpulse(impulse: Vector3Like | DirectionInput): this;

  applyAngularImpulse(axis: Vector3Like | DirectionInput, strength: number): this;

  applyForce(hit: RigidBodyInteractionHitInput, strength?: number): this;

  applyForce(force: Vector3Like | DirectionInput, contactPoint?: RigidBodyContactPointInput): this;

  applyForce(direction: Vector3Like | DirectionInput, strength: number, contactPoint?: RigidBodyContactPointInput): this;

  applyImpulse(hit: RigidBodyInteractionHitInput, strength?: number): this;

  applyImpulse(impulse: Vector3Like | DirectionInput, contactPoint?: RigidBodyContactPointInput): this;

  applyImpulse(direction: Vector3Like | DirectionInput, strength: number, contactPoint?: RigidBodyContactPointInput): this;

  applyTorque(torque: Vector3Like | DirectionInput): this;

  applyTorque(x: number, y: number, z: number): this;

  applyTorque(axis: Vector3Like | DirectionInput, strength: number): this;

  applyTransform(position: Vector3Like, rotation?: QuaternionLike): void;

  get autoColliderFromMeshOptions(): AutoColliderFromMeshOptions | null;

  get autoFitCenterOffset(): Vector3Like;

  get autoFitEnabled(): boolean;

  avoidCollisionByTag(tag: string, ...tags: string[]): this;

  avoidCollisionByTag(tags: readonly string[]): this;

  avoidCollisionWith(...targets: (wave3DObject | readonly wave3DObject[])[]): this;

  get bodyType(): RigidBodyType;

  get centerOfMass(): Vector3Like | null;

  get centerOfMassConfig(): Vector3Like | null;

  clearConstantForce(name?: string): this;

  clearConstantForces(): this;

  clearConstantTorque(name?: string): this;

  clearConstantTorques(): this;

  clearForces(): void;

  clearMass(): this;

  clearMassModel(): this;

  get colliderAutoRebuildEnabled(): boolean;

  get colliderStaticPositionOffset(): Vector3Like;

  get colliderStaticRotationOffset(): Vector3Like;

  get colliderStaticScaleOffset(): Vector3Like;

  get collisionGroup(): number;

  get collisionMask(): number;

  get collisionTruthPolicy(): WaveCollisionTruthPolicy;

  get compoundChildren(): CompoundColliderChildConfig[] | null;

  get compoundChildrenGeneration(): number;

  get compoundCollidersFromMeshesEnabled(): boolean;

  get compoundCollidersFromMeshesOptions(): CompoundCollidersFromMeshesOptions | null;

  configurePhysics(mutator: (body: this) => void): this;

  get constantForces(): ConstantForceEntry[];

  get constantTorques(): ConstantTorqueEntry[];

  get constraintConfigSnapshots(): ConstraintConfigSnapshot[];

  get constraintEndpointLabel(): string;

  get constraintIds(): string[];

  get constraintInstanceIndex(): undefined;

  constrainTo(target: PhysicsConstraintEndpoint): ConstraintBuilder;

  get constraintRuntimeUnitScale(): Vector3Like;

  get contactCount(): number;

  get contactEndGraceSubsteps(): number;

  get contactingBodies(): cmp_physicsBody[];

  get contactVerificationDistance(): number;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  createActuationTrigger(options: RigidBodyActuationTriggerOptions): RigidBodyActuationTrigger;

  createConstraintConfig(id: string, target: PhysicsConstraintEndpoint, config: ConstraintConfig): PhysicsConstraintProjectionResult;

  createJointTo(target: PhysicsConstraintEndpoint, config?: RigidBodyJointConfig, options?: RigidBodyJointOptions): RigidBodyJointResult;

  deferNativePhysicsBodyUntilUsed(): this;

  destroy(): void;

  get destroyPriority(): number;

  disableColliderAutoRebuild(): this;

  disableContactMonitor(): this;

  disableGravity(): this;

  disposeConstraint(id: string): boolean;

  editConstantForce(name: string): WaveRigidBodyConstantForceBuilder<this>;

  editConstantTorque(name: string): WaveRigidBodyConstantTorqueBuilder<this>;

  get effectiveScale(): Vector3Like;

  enableCollisionByTag(tag: string, ...tags: string[]): this;

  enableCollisionByTag(tags: readonly string[]): this;

  enableCollisionWith(...targets: (wave3DObject | readonly wave3DObject[])[]): this;

  enableContactMonitor(options?: ContactMonitorOptions): this;

  enableGravity(factor?: number): this;

  evaluateActuationTriggers(timestampMs: number): void;

  executePendingRebuild(): void;

  forEachContactingBody(callback: (body: cmp_physicsBody) => void): this;

  get frameAuthoredLinearVelocityIntent(): FrameAuthoredLinearVelocityIntent | null;

  get friction(): number | null;

  generateConstraintId(): string;

  getActuationTrigger(id: string): RigidBodyActuationTrigger | undefined;

  getConstraint(id: string): unknown | undefined;

  getRigidMotionToRefs(linearTarget: Vector3Like, angularTarget: Vector3Like): boolean;

  getVelocityAtWorldPoint(point: WavePointInput): Vector3Like | null;

  get gravityFactor(): number;

  hasActuationCollisionTracking(): boolean;

  hasActuationTrigger(id: string): boolean;

  hasActuationTriggers(): boolean;

  hasAngularVelocityLimit(): boolean;

  hasConstantForce(name: string): boolean;

  hasConstantTorque(name: string): boolean;

  hasConstraint(id: string): boolean;

  hasEnabledConstantForce(): boolean;

  hasEnabledConstantTorque(): boolean;

  hasLinearVelocityLimit(): boolean;

  hasNativePhysicsBodyRequested(): boolean;

  hasPendingColliderAutoRebuild(): boolean;

  hasVelocityLimit(): boolean;

  get heightfieldData(): HeightfieldData | null;

  get heightfieldGroundMesh(): unknown | null;

  get inertia(): Vector3Like | null;

  inFrameOf(target: TransformReferenceLike): WaveRigidBodyFrameScope<this>;

  get initialAngularVelocity(): Vector3Like;

  get initialLinearVelocity(): Vector3Like;

  inLocalFrame(): WaveRigidBodyFrameScope<this>;

  inParentFrame(depth?: number): WaveRigidBodyFrameScope<this>;

  inWorldFrame(): WaveRigidBodyFrameScope<this>;

  get isConstraintEndpointDisposed(): boolean;

  isContactMonitorEnabled(): boolean;

  get isDynamic(): boolean;

  isFullyRotationLocked(): boolean;

  isInContactWith(target: cmp_physicsBody | wave3DObject | null | undefined): boolean;

  get isKinematic(): boolean;

  isRotationLocked(): boolean;

  get isSensor(): boolean;

  get isStatic(): boolean;

  get linearDamping(): number;

  get linearVelocity(): Vector3Like | null;

  lockRotation(): this;

  lockRotationAxis(axis: 'x' | 'y' | 'z'): this;

  get mass(): number;

  get massIntent(): Readonly<PhysicsMassIntent>;

  get massModelConfig(): WaveModelMassModelConfig | null;

  get maxAngularVelocity(): number;

  get maxContactsReported(): number;

  get maxLinearVelocity(): number;

  get nativeConstraintBodyForConstraint(): unknown | null;

  onContact(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactBegin(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactBeginByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactBeginWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactContinue(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactContinueByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactContinueWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactEnd(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactEndByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactEndWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onMeshesChanged(): void;

  onMeshPhysicsSurfaceChanged(): void;

  onPartPhysicsChanged(removedPartIds?: readonly string[]): void;

  onScaleChanged(newScale: Vector3Like): void;

  onTransformChanged(change?: { positionChanged?: boolean; rotationChanged?: boolean; physicsMotion?: "direct" | "animated"; }): void;

  get partCompoundColliderChildType(): CompoundColliderChildType;

  get partCompoundColliderMaxChildren(): number;

  get partCompoundCollidersEnabled(): boolean;

  get physicsTimeScale(): number;

  rebuildColliderNow(): this;

  requestNativeConstraintBody(): void;

  requestNativePhysicsBody(): this;

  requestRebuild(): void;

  resetConstraint(constraintId: string): boolean;

  get restitution(): number | null;

  resumeColliderAutoRebuild(): this;

  get rotationLock(): RotationLockFlags;

  serialize(): SerializedCall[];

  setActivationPolicy(policy: RigidBodyActivationPolicy): this;

  setAngularDamping(value: number): this;

  setAngularInertia(value: number): this;

  setAngularInertia(value: Vector3Like): this;

  setAngularInertia(x: number, y: number, z: number): this;

  setAngularVelocity(velocity: Vector3Like | DirectionInput): this;

  setAngularVelocity(x: number, y: number, z: number): this;

  setAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): this;

  setAutoFitCenterOffset(value: Vector3Like): void;

  setAutoFitCenterOffset(x: number, y: number, z: number): void;

  setCenterOfMass(value: Vector3Like): this;

  setCenterOfMass(x: number, y: number, z: number): this;

  setColliderStaticPositionOffset(value: Vector3Like): this;

  setColliderStaticPositionOffset(x: number, y: number, z: number): this;

  setColliderStaticRotationOffset(value: Vector3Like): this;

  setColliderStaticRotationOffset(x: number, y: number, z: number): this;

  setColliderStaticScaleOffset(value: Vector3Like): this;

  setColliderStaticScaleOffset(x: number, y: number, z: number): this;

  setCollisionFilter(group: number, mask: number): this;

  setCollisionGroup(value: number): void;

  setCollisionMask(value: number): void;

  setConstantForce(name: string, config: ConstantForceConfig): this;

  setConstantForce(name: string, force: Vector3Like | DirectionInput, options?: ConstantForceOptions): this;

  setConstantForce(name: string, direction: Vector3Like | DirectionInput, strength: number, options?: ConstantForceOptions): this;

  setConstantTorque(name: string, config: ConstantTorqueConfig): this;

  setConstantTorque(name: string, torque: Vector3Like | DirectionInput, options?: ConstantTorqueOptions): this;

  setConstantTorque(name: string, direction: Vector3Like | DirectionInput, strength: number, options?: ConstantTorqueOptions): this;

  setConstraintBallAndSocket(target: cmp_physicsBody, ownLocalPivot: Vector3Like, targetLocalPivot: Vector3Like, enableCollisions?: boolean, constraintId?: string): string | null;

  setConstraintDistance(target: cmp_physicsBody, minDistance: number, maxDistance: number, enableCollisions?: boolean, constraintId?: string): string | null;

  setConstraintHinge(target: cmp_physicsBody, ownLocalPivot: Vector3Like, targetLocalPivot: Vector3Like, axis: DirectionInput, minAngle?: number, maxAngle?: number, enableCollisions?: boolean, constraintId?: string): string | null;

  setConstraintLock(target: cmp_physicsBody, ownLocalPivot: Vector3Like, targetLocalPivot: Vector3Like, enableCollisions?: boolean, constraintId?: string): string | null;

  setConstraintSixDoF(target: cmp_physicsBody, ownLocalPivot: Vector3Like, targetLocalPivot: Vector3Like, motorAxis?: ConstraintAxis, motorMode?: MotorMode, motorTarget?: number, motorMaxForce?: number, enableCollisions?: boolean, constraintId?: string): string | null;

  setContactEndGraceSubsteps(substeps: number): this;

  setContactVerificationDistance(distance: number): this;

  setEnabled(value: true, options?: EnablePhysicsOptions): this;

  setEnabled(value: false, options?: DisablePhysicsOptions): this;

  setFriction(value: number): this;

  setGravityFactor(value: number): this;

  setHeightfieldData(data: Float32Array, columns: number, rows: number, worldWidth: number, worldDepth: number, minHeight: number, maxHeight: number, options?: { colliderStaticPositionOffset?: Vector3Like; }): this;

  setHeightfieldGroundMesh(mesh: unknown): this;

  setInitialAngularVelocity(value: Vector3Like): void;

  setInitialAngularVelocity(x: number, y: number, z: number): void;

  setInitialLinearVelocity(value: Vector3Like): void;

  setInitialLinearVelocity(x: number, y: number, z: number): void;

  setIsSensor(value: boolean): void;

  setLinearDamping(value: number): this;

  setLinearVelocity(velocity: Vector3Like | DirectionInput): this;

  setLinearVelocity(x: number, y: number, z: number): this;

  setLinearVelocity(direction: Vector3Like | DirectionInput, speed: number): this;

  setMass(value: number): this;

  setMaxAngularVelocity(value: number): void;

  setMaxContactsReported(maxContacts: number): this;

  setMaxLinearVelocity(value: number): void;

  setPhysicsTimeScale(value: number): this;

  setRestitution(value: number): this;

  setRotationLock(flags: Partial<RotationLockFlags>): this;

  setSize(value: Vector3Like): void;

  setSize(x: number, y: number, z: number): void;

  setSizeFromAutoFit(value: Vector3Like): void;

  setSizeFromAutoFit(x: number, y: number, z: number): void;

  setTargetTransform(position: WavePointInput, rotation?: QuaternionLike): void;

  get shapeType(): RigidBodyShapeType;

  get size(): Vector3Like;

  sleep(): void;

  syncTransformFromPhysics(): void;

  teleport(position: WavePointInput, rotation?: QuaternionLike, preserveVelocity?: boolean): void;

  unlockRotation(): this;

  unlockRotationAxis(axis: 'x' | 'y' | 'z'): this;

  useActorDynamicBoxPhysicsPreset(): void;

  useAutoColliderFromMesh(options?: AutoColliderFromMeshOptions): this;

  useBoxCollider(): this;

  useBoxCollider(size: Vector3Like): this;

  useBoxCollider(x: number, y: number, z: number): this;

  useCapsuleCollider(radius?: number, height?: number): this;

  useCompoundCollider(children: CompoundColliderChildConfig[]): this;

  useConvexHullCollider(): this;

  useCylinderCollider(radius?: number, height?: number): this;

  useDynamicBody(): this;

  useHeightfieldCollider(): this;

  useKinematicBody(): this;

  useMassModel(config: WaveModelMassModelConfig): this;

  useMeshCollider(): this;

  useMeshCompoundCollider(options?: MeshCollidersOptions): this;

  usePartCompoundCollider(options?: PartCollidersOptions): this;

  useSphereCollider(radius?: number): this;

  useStaticBody(): this;

  useVisualBoundsCollider(shape: PrimitiveColliderShapeName): this;

  wakeUp(): void;

  worldPointToConstraintLocal(worldPoint: WavePointInput): Vector3Like;

}

interface PhysicsBodyDomainAdapter {

  assertBodyTypeIntentSupported?(body: PhysicsBodyComponentCore, bodyType: RigidBodyType, operation: string): void;

  assertColliderGeometryIntentSupported?(body: PhysicsBodyComponentCore, operation: string): void;

  assertColliderShapeIntentSupported?(body: PhysicsBodyComponentCore, shapeType: RigidBodyShapeType, operation: string): void;

  assertDirectMotionIntentSupported?(body: PhysicsBodyComponentCore, operation: string): void;

  assertNativePhysicsBodyParticipationSupported?(body: PhysicsBodyComponentCore, requested: boolean, operation: string): void;

  assertParticipationIntentSupported?(body: PhysicsBodyComponentCore, enabled: boolean, operation: string): void;

  shouldImplicitlyRequestNativePhysicsBody?(body: PhysicsBodyComponentCore): boolean;

}

interface PhysicsBodyIntent {

  bendResistance: number;

  compressibility: number;

  continuousCollision: boolean;

  deformationDamping: number;

  fluid: PhysicsFluidIntent;

  fluidFillLevel: number;

  fluidInteractionMode: PhysicsFluidInteractionMode;

  physicalMaterial: ResolvedPhysicsMaterial | null;

  physicalMaterialBindings: readonly ResolvedPhysicsMaterialBinding[];

  pinAttachments: PhysicsMaterialPointAttachmentRef[];

  pins: PhysicsMaterialPointRef[];

  plasticity: number;

  rigidity: number;

  selfCollision: boolean;

  stretchResistance: number;

  viscosity: number;

  volumePreservation: number;

}

interface PhysicsBodyIntentInput {

  readonly bendResistance?: number;

  readonly compressibility?: number;

  readonly continuousCollision?: boolean;

  readonly deformationDamping?: number;

  readonly fluid?: PhysicsFluidIntentInput;

  readonly fluidFillLevel?: number;

  readonly fluidInteractionMode?: PhysicsFluidInteractionMode;

  readonly physicalMaterial?: PhysicsMaterialDefinition | ResolvedPhysicsMaterial | null;

  readonly physicalMaterialBindings?: readonly PhysicsMaterialBindingInput[];

  readonly pinAttachments?: readonly PhysicsMaterialPointAttachmentRef[];

  readonly pins?: readonly PhysicsMaterialPointRef[];

  readonly plasticity?: number;

  readonly rigidity?: number;

  readonly selfCollision?: boolean;

  readonly stretchResistance?: number;

  readonly viscosity?: number;

  readonly volumePreservation?: number;

}

type PhysicsBodyIntentSnapshot = Readonly<Omit<PhysicsBodyIntent, "physicalMaterialBindings" | "fluid" | "pins" | "pinAttachments">> & { readonly physicalMaterialBindings: readonly ResolvedPhysicsMaterialBinding[]; readonly fluid: Readonly<PhysicsFluidIntent>; readonly pins: readonly PhysicsMaterialPointRef[]; readonly pinAttachments: readonly PhysicsMaterialPointAttachmentRef[]; }

type PhysicsBodyPinPathInput = WaveUniformPathSampleProvider & { readonly runtimeRef: string; }

type PhysicsBodyPinSelectionInput = DirectionInput | WavePointSource;

interface PhysicsBodyRigidRuntimeState {

  readonly capturedFixedStep: number;

  readonly format: "wave.physics-body-runtime-state";

  readonly sleeping: boolean;

  readonly angularVelocity: Readonly<Vector3Like>;

  readonly linearVelocity: Readonly<Vector3Like>;

  readonly topology: "rigid";

  readonly worldPosition: Readonly<Vector3Like>;

  readonly worldRotation: Readonly<QuaternionLike>;

}

type PhysicsBodyRuntimeState = PhysicsBodyRigidRuntimeState | PhysicsBodyStrandRuntimeState | PhysicsBodySurfaceRuntimeState | PhysicsBodyVolumeRuntimeState;

interface PhysicsBodyStrandRuntimeState {

  readonly capturedFixedStep: number;

  readonly format: "wave.physics-body-runtime-state";

  readonly geometryRevision: string;

  readonly geometryTarget: WaveModelVisualTargetKeyRef;

  readonly inverseMasses: Float32Array<ArrayBufferLike>;

  readonly lastCommittedTopologyCommandSequence?: number | undefined;

  readonly positions: Float32Array<ArrayBufferLike>;

  readonly restPositions: Float32Array<ArrayBufferLike>;

  readonly sleeping: boolean;

  readonly topologyArtifactRevision?: string | null | undefined;

  readonly topologyTransitionGeneration?: number | undefined;

  readonly velocities: Float32Array<ArrayBufferLike>;

  readonly bendRestLengths?: Float32Array;

  readonly stretchRestLengths?: Float32Array;

  readonly topology: "strand";

}

interface PhysicsBodySurfaceRuntimeState {

  readonly capturedFixedStep: number;

  readonly format: "wave.physics-body-runtime-state";

  readonly geometryRevision: string;

  readonly geometryTarget: WaveModelVisualTargetKeyRef;

  readonly inverseMasses: Float32Array<ArrayBufferLike>;

  readonly lastCommittedTopologyCommandSequence?: number | undefined;

  readonly positions: Float32Array<ArrayBufferLike>;

  readonly restPositions: Float32Array<ArrayBufferLike>;

  readonly sleeping: boolean;

  readonly topologyArtifactRevision?: string | null | undefined;

  readonly topologyTransitionGeneration?: number | undefined;

  readonly velocities: Float32Array<ArrayBufferLike>;

  readonly bendRestLengths?: Float32Array;

  readonly structuralRestLengths?: Float32Array;

  readonly topology: "surface";

}

interface PhysicsBodyVolumeRuntimeState {

  readonly capturedFixedStep: number;

  readonly format: "wave.physics-body-runtime-state";

  readonly geometryRevision: string;

  readonly geometryTarget: WaveModelVisualTargetKeyRef;

  readonly inverseMasses: Float32Array<ArrayBufferLike>;

  readonly lastCommittedTopologyCommandSequence?: number | undefined;

  readonly positions: Float32Array<ArrayBufferLike>;

  readonly restPositions: Float32Array<ArrayBufferLike>;

  readonly sleeping: boolean;

  readonly topologyArtifactRevision?: string | null | undefined;

  readonly topologyTransitionGeneration?: number | undefined;

  readonly velocities: Float32Array<ArrayBufferLike>;

  readonly topology: "volume";

}

interface PhysicsCohesiveLawInput {

  readonly criticalOpening: number;

  readonly peakTraction: number;

  readonly softening: "linear" | "exponential" | "bilinear";

}

interface PhysicsConstraintEndpoint {

  readonly constraintEndpointLabel: string;

  readonly constraintInstanceIndex?: number;

  readonly constraintRuntimeUnitScale: Vector3Like;

  createConstraintConfig(id: string, target: PhysicsConstraintEndpoint, config: ConstraintConfig): PhysicsConstraintProjectionResult;

  disposeConstraint(id: string): boolean;

  generateConstraintId(): string;

  getConstraint(id: string): unknown | unknown | undefined;

  hasConstraint(id: string): boolean;

  readonly isConstraintEndpointDisposed: boolean;

  readonly nativeConstraintBodyForConstraint: unknown | null;

  readonly owner: WaveEntity;

  requestNativeConstraintBody(): void;

  worldPointToConstraintLocal(worldPoint: WavePointInput): Vector3Like;

}

type PhysicsConstraintProjectionRejectionCode = "sourceDisposed" | "targetDisposed" | "unsupportedEndpoint" | "delegatedBodyUnsupported" | "invalidConfiguration" | "runtimeUnavailable" | "runtimeRegistrationFailed" | "nativeCreationRejected";

type PhysicsConstraintProjectionResult = { readonly accepted: true; readonly status: PhysicsConstraintProjectionStatus; readonly id: string; readonly reason?: string; } | { readonly accepted: false; readonly status: "rejected"; readonly id: string; readonly code: PhysicsConstraintProjectionRejectionCode; readonly reason: string; }

type PhysicsConstraintProjectionStatus = "created" | "pending";

interface PhysicsContactMaterialInput {

  readonly compliance?: number;

  readonly damping?: number;

  readonly dynamicFriction?: number;

  readonly friction?: number;

  readonly maximumEnergyReturnFraction?: number;

  readonly restitution?: number;

  readonly staticFriction?: number;

}

type PhysicsFailureMode = "none" | "brittle" | "quasiBrittle" | "ductile" | "fibrous" | "interface";

interface PhysicsFluidFlowIntent {

  readonly direction: PhysicsFluidLocalAxis;

  readonly enabled: boolean;

  readonly id: string;

  readonly inlet: PhysicsSceneRangeRef;

  readonly mode: "recycle";

  readonly outlet: PhysicsSceneRangeRef;

  readonly seed: number;

  readonly speed: number;

  readonly volumePerSecond: number;

}

interface PhysicsFluidIntent {

  readonly density: number | null;

  readonly flows: readonly PhysicsFluidFlowIntent[];

  readonly openBoundaries: readonly PhysicsFluidLocalAxis[];

  readonly particleCount: number | null;

}

interface PhysicsFluidIntentInput {

  readonly density?: number | null;

  readonly flows?: readonly PhysicsFluidFlowIntent[];

  readonly openBoundaries?: readonly PhysicsFluidLocalAxis[];

  readonly particleCount?: number | null;

}

type PhysicsFluidInteractionMode = "automatic" | "oneWay" | "twoWay";

type PhysicsFluidLocalAxis = "left" | "right" | "down" | "up" | "backward" | "forward";

type PhysicsImpactFidelity = "exactPointVelocityAndMass" | "pointVelocityApproximate" | "massUnavailable" | "speedOnly";

type PhysicsImpactIntegrationState = "alreadyIntegrated" | "mustApply";

interface PhysicsImpactKinematics {

  readonly fidelity: PhysicsImpactFidelity;

  readonly impactEnergy: number | null;

  readonly impactMomentum: number | null;

  readonly impactMomentumWorld: PhysicsVec3 | null;

  readonly impactSpeed: number;

  readonly normalOtherToSelf: PhysicsVec3;

  readonly reducedMass: number | null;

  readonly relativeVelocityWorld: PhysicsVec3;

  readonly solverImpulse: number;

  readonly tangentialRelativeVelocityWorld: PhysicsVec3;

  readonly tangentialSpeed: number;

}

type PhysicsMassIntent = { readonly kind: "auto"; } | { readonly kind: "explicit"; readonly mass: number; } | { readonly kind: "model"; readonly model: PhysicsMassModelIntent; }

type PhysicsMassModelIntent = WaveModelMassModelConfig;

interface PhysicsMaterialAnisotropyInput {

  readonly frame: PhysicsMaterialFrame;

  readonly toughnessPrincipal: readonly [number, number, number];

}

interface PhysicsMaterialBindingInput {

  readonly material: PhysicsMaterialDefinition | ResolvedPhysicsMaterial;

  readonly target: PhysicsMaterialBindingTarget;

}

type PhysicsMaterialBindingTarget = { readonly kind: "body"; } | { readonly kind: "part"; readonly partId: string; } | { readonly kind: "surface"; readonly surfaceId: string; readonly partId?: string; }

interface PhysicsMaterialDefinition {

  readonly contact?: PhysicsContactMaterialInput;

  readonly density: number;

  readonly elasticity: { readonly model: "isotropic" | "transverselyIsotropic" | "orthotropic"; readonly youngModulus: number; readonly poissonRatio: number; readonly frame?: PhysicsMaterialFrame; readonly directionalModuli?: readonly [number, number, number]; readonly shearModuli?: readonly [number, number, number]; }

  readonly fracture: { readonly mode: PhysicsFailureMode; readonly tensileStrength: number; readonly compressiveStrength: number; readonly shearStrength: number; readonly fractureEnergy: number; readonly cohesiveLaw?: PhysicsCohesiveLawInput; readonly anisotropy?: PhysicsMaterialAnisotropyInput; readonly heterogeneity?: PhysicsMaterialHeterogeneityInput; readonly rateDependence?: PhysicsMaterialRateDependenceInput; }

  readonly plasticity?: { readonly yieldStress: number; readonly hardeningModulus?: number; readonly hardeningExponent?: number; readonly failurePlasticStrain?: number; readonly strainRateSensitivity?: number; }

  readonly viscoelasticity?: PhysicsViscoelasticityInput;

}

interface PhysicsMaterialFrame {

  readonly x: PhysicsVec3;

  readonly y: PhysicsVec3;

  readonly z: PhysicsVec3;

}

interface PhysicsMaterialHeterogeneityInput {

  readonly correlationLength: number;

  readonly distribution: "weibull" | "gaussianField";

  readonly magnitude: number;

  readonly weibullModulus?: number;

}

type PhysicsMaterialPointAttachmentRef = PhysicsMaterialPointEntityAttachmentRef | PhysicsMaterialPointPathAttachmentRef;

interface PhysicsMaterialPointEntityAttachmentRef {

  readonly frameEntityId: string;

  readonly frameLocalPosition: Readonly<SerializableVector3>;

  readonly kind: "entityLocal";

  readonly point: PhysicsMaterialPointRef;

}

interface PhysicsMaterialPointPathAttachmentRef {

  readonly kind: "uniformPath";

  readonly pathEntityId: string;

  readonly points: readonly PhysicsMaterialPointRef[];

}

type PhysicsMaterialPointRef = PhysicsMaterialPointSurfaceUvRef | PhysicsMaterialPointSurfaceTriangleRef;

interface PhysicsMaterialPointSurfaceTriangleRef {

  readonly geometryRevision: string;

  readonly kind: "surfaceTriangle";

  readonly simplexOrdinal: number;

  readonly target: WaveModelVisualTargetKeyRef;

  readonly weights: PhysicsMaterialPointWeights;

}

interface PhysicsMaterialPointSurfaceUvRef {

  readonly u: number;

  readonly v: number;

  readonly kind: "surfaceUV";

  readonly target: WaveModelVisualTargetKeyRef;

}

type PhysicsMaterialPointWeights = readonly [number, number, number];

interface PhysicsMaterialRateDependenceInput {

  readonly referenceStrainRate: number;

  readonly toughnessExponent: number;

}

interface PhysicsMaterialResolution {

  readonly bindingKey: string | null;

  readonly material: ResolvedPhysicsMaterial;

  readonly source: PhysicsMaterialResolutionSource;

}

type PhysicsMaterialResolutionSource = "surface" | "part" | "body" | "default";

type PhysicsMotionKind = "dynamic" | "static" | "kinematic";

declare enum PhysicsParticipationDisableReason {

  Destroy = "destroy",

  Editor = "editor",

  Generic = "generic",

  Hide = "hide",

  NetworkDormant = "networkDormant",

  Pool = "pool",

}

declare enum PhysicsParticipationRestoreMotion {

  None = "none",

  Snapshot = "snapshot",

}

interface PhysicsSceneRangeRef {

  readonly kind: "sceneRange";

  readonly name: string;

}

interface PhysicsSolvedContactObservation {

  readonly a: PhysicsTruthContactParticipant;

  readonly b: PhysicsTruthContactParticipant;

  readonly fidelity: PhysicsImpactFidelity | null;

  readonly fixedStepRevision: number;

  readonly kinematics: PhysicsImpactKinematics | null;

  readonly normalOtherToAWorld: PhysicsVec3 | null;

  readonly phase: PhysicsTruthContactPhase;

  readonly pointAWorld: PhysicsVec3 | null;

  readonly pointBWorld: PhysicsVec3 | null;

  readonly separationA: number | null;

  readonly separationB: number | null;

  readonly solverImpulse: number;

  readonly substepCount: number;

  readonly substepDeltaSeconds: number;

  readonly substepIndex: number;

}

interface PhysicsTruthColliderIdentity {

  readonly colliderId: string | null;

  readonly partId: string | null;

  readonly partName: string | null;

  readonly shapePath: readonly number[];

  readonly triangleIndex: number | null;

}

interface PhysicsTruthContactParticipant {

  readonly collider: PhysicsTruthColliderIdentity;

  readonly effectiveMass: number | null;

  readonly entityId: number;

  readonly entityName: string;

  readonly motion: PhysicsMotionKind;

}

type PhysicsTruthContactPhase = "begin" | "continue" | "end";

interface PhysicsVec3 {

  readonly x: number;

  readonly y: number;

  readonly z: number;

}

interface PhysicsViscoelasticityInput {

  readonly bulkDamping: number;

  readonly lossFactor: number;

  readonly relaxationTime: number;

  readonly shearDamping: number;

}

interface PickingHit {

  componentType?: number;

  distance: number;

  entityId: number;

  faceIndex?: number;

  hitNormal: SerializableVector3;

  hitPoint: SerializableVector3;

  meshId?: string;

  meshName?: string;

  partId?: string;

  partName?: string;

  tagMask: bigint;

  thinBatchIndex?: number;

  uv?: SerializableVector2;

}

interface PickPartOptions {

  readonly maxDistance?: number;

  readonly normal?: Vector3Like | null;

}

interface PivotMarkerOptions {

  duration?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  color?: unknown | string | number;

  coordinateSpace?: ToolLocalOrWorldSpace;

  size?: number;

}

type PlacementBatchFor<T> = T extends WaveWorldTextModelHost ? waveTextBatch : waveThinBatch;

type PlacementRangeInput = WaveRange | string;

type PlacementRangeInputSet = PlacementRangeInput | readonly PlacementRangeInput[];

interface PlaneOptions {

  duration?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  color?: unknown | string | number;

  coordinateSpace?: ToolLocalOrWorldSpace;

  gridCellSize?: number;

  opacity?: number;

  showGrid?: boolean;

  size?: number;

}

interface PointCloudDissolveOptions {

  autoplay?: boolean;

  delayJitterScale?: number;

  driftDistance?: number;

  duration?: WaveTimeSpan;

  emissiveBoost?: number;

  endAlpha?: number;

  endScale?: number;

  orderDirection?: Vector3;

  preStartAlpha?: number;

  preStartScale?: number;

  sourceFadeFraction?: number;

  sourceGlowIntensity?: number;

  sourceOpacity?: number;

  spreadDistance?: number;

  staggerFraction?: number;

  startAlpha?: number;

  startScale?: number;

  targetCenter?: Vector3;

  targetSpreadRadius?: number;

  travelDirection?: Vector3;

}

interface PointCloudPathFollowOptions {

  options?: PathFollowOptions;

  params?: PathFollowInstanceParams[] | ((index: number, count: number) => PathFollowInstanceParams);

  source: PathFollowSource | PathFollowTexture;

}

interface PointCloudSourceVisual {

  disableGlow?(): unknown;

  enableGlow?(intensity?: number, color?: unknown | string | [number, number, number] | number | null): unknown;

  readonly glowEnabled?: boolean;

  readonly glowIntensity?: number;

  readonly materialEmissiveColor?: unknown;

  readonly materialOpacity?: number;

  setEmissiveColor(color: ColorInput | unknown | string | [number, number, number]): void;

  setGlowIntensity?(intensity: number): unknown;

  setOpacity(alpha: number): void;

  setSurfaceVfxProgress?(progress: number): unknown;

}

type PointCloudTurbulenceOptions = Omit<WaveGeometryDisplaceParameters, "turbulence">;

interface PointFieldMouseRepelOpts {

  mouseParam: string;

  radius?: NumLike;

  strength?: NumLike;

  swirl?: NumLike;

}

interface PointFieldOpts {

  ambientFraction?: number;

  blend?: "additive" | "alpha" | "multiply";

  bounds: Vector3Like;

  count: number;

  depthWrite?: boolean;

  glow?: FxGlowConfig;

  mouseRepel?: PointFieldMouseRepelOpts;

  palette: ColorInputAlpha[];

  pointSize?: PointFieldPointSizeOpts;

  randomSeed?: number;

  streams: PointFieldStreamOpts[];

  twinkle?: PointFieldTwinkleOpts;

}

interface PointFieldPointSizeOpts {

  base?: NumLike;

  max?: NumLike;

  min?: NumLike;

}

interface PointFieldStreamOpts {

  phase: number;

  span: number;

  spin: number;

  width: number;

  yAmp: number;

  yOffset: number;

  yWave: number;

  zAmp: number;

  zOffset: number;

}

interface PointFieldTwinkleOpts {

  amount?: NumLike;

  speed?: NumLike;

}

interface PointMarkerOptions {

  decimals?: number | undefined;

  duration?: number | undefined;

  fontAsset?: string | undefined;

  fontSize?: number | undefined;

  labelOffset3D?: any;

  labelOffset3DSpace?: "world" | "local" | undefined;

  textColor?: any;

  updateMode?: DevToolUpdateMode | undefined;

  color?: unknown | string | number;

  coordinateSpace?: WaveTransformFrameSpace;

  showCoordinate?: boolean;

  size?: number;

}

interface PortalFxOpts {

  center?: Vector3Like;

  color?: ColorLike;

  coverage?: NumLike;

  displacement?: NumLike;

  edgeColor?: ColorLike;

  edgeSoftness?: NumLike;

  emissionIntensity?: NumLike;

  flow?: number;

  glow?: FxGlowConfig;

  motes?: boolean | PortalMotesOpts;

  motesAnchor?: WaveFxAnchorBinding;

  noiseScale?: NumLike;

  normalOffset?: NumLike;

  radialScale?: NumLike;

  secondaryColor?: ColorLike;

  surface: WaveSurfaceSourceStructure;

  surfaceAnchor?: WaveFxAnchorBinding;

  swirl?: NumLike;

}

interface PortalMotesOpts {

  color?: ColorLike;

  density?: NumLike;

  glow?: SpriteOpts["glow"];

  innerRadius?: NumLike;

  lifetime?: NumLike;

  radius?: NumLike;

  size?: NumLike;

  speed?: NumLike;

  spreadAngle?: NumLike;

  texture?: string;

  thickness?: NumLike;

}

interface PoseBindingValue {

  readonly kind: "pose";

  readonly payloadKind: "pose";

  readonly pose: WaveModelRigPoseSnapshotMetadata;

  readonly ref: ExactAssetRef<"animation">;

}

type PositionFaceCenterAlias = "leftFaceCenter" | "rightFaceCenter" | "upFaceCenter" | "downFaceCenter" | "forwardFaceCenter" | "backwardFaceCenter";

type PositionFaceCenterInput = SemanticDirection | SemanticWaveSurface | PositionFaceCenterAlias;

interface PostFxCustomEffectSettings {

  [effectId: string]: CustomPostProcessOptions | false;

}

interface PostFxEffectMap {

  [PostFxEffect.BlackAndWhite]: BlackAndWhiteOptions;

  [PostFxEffect.Bloom]: BloomOptions;

  [PostFxEffect.ChromaticAberration]: ChromaticAberrationOptions;

  [PostFxEffect.DamageVignette]: DamageVignetteOptions;

  [PostFxEffect.DepthOfField]: DepthOfFieldOptions;

  [PostFxEffect.FXAA]: FXAAOptions;

  [PostFxEffect.Grain]: GrainOptions;

  [PostFxEffect.ImageProcessing]: ImageProcessingOptions;

  [PostFxEffect.MotionTrail]: MotionTrailOptions;

  [PostFxEffect.NightVision]: NightVisionOptions;

  [PostFxEffect.OilPainting]: OilPaintingOptions;

  [PostFxEffect.PaniniProjection]: PaniniProjectionOptions;

  [PostFxEffect.RadialBlur]: RadialBlurOptions;

  [PostFxEffect.Sharpen]: SharpenOptions;

  [PostFxEffect.SpeedLines]: SpeedLinesOptions;

  [PostFxEffect.ThermalVision]: ThermalVisionOptions;

  [PostFxEffect.Underwater]: UnderwaterOptions;

  [PostFxEffect.VolumetricLight]: VolumetricLightOptions;

}

type PostFxEffectName = keyof PostFxEffectMap;

type PostFxEffectRequiringOptions = PostFxEffect.Underwater | PostFxEffect.VolumetricLight;

type PostFxEffectSettings = { [K in PostFxEffectName]?: PostFxEffectMap[K] | true | false; }

type PostFxEffectWithOptionalOptions = Exclude<PostFxEffectName, PostFxEffectRequiringOptions>;

interface PredictorConfig {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  analysisIntervalMs?: number;

  bufferSize?: number;

  maxDimensions?: number;

  maxHarmonics?: number;

  minSamples?: number;

  model?: ThinkingPredictionModel;

  validationWindow?: number;

}

interface PreparedAsset<TValue = unknown> {

  readonly resources: AssetResourceOwner;

  readonly value: TValue;

}

declare class PreparedAssetPlan {

  constructor(_runtime: AssetRuntime, _arena: AssetArena, _ticket: AssetArenaTicket, candidates: readonly AssetStoreCandidate[], _resolved: readonly PreparedResolvedEntry[], _plan: SceneAssetPlan);

  commit(): SceneAssetPlanState;

  discard(): void;

  discard(primaryError: unknown): never;

}

interface PreparedResolvedEntry {

  readonly compiled: CompiledSceneAssetPlanEntry;

  readonly semantic: NormalizedAssetBody;

  readonly spec: ResolvedAssetSpec;

}

interface PresetBillboardOpts {

  billboard?: "all" | "y" | "none";

  blend?: "additive" | "alpha" | "multiply";

  color?: ColorInputAlpha;

  delayMs?: number;

  depthWrite?: boolean;

  durationMs?: number;

  glow?: FxGlowConfig;

  intensity?: NumLike;

  loop?: boolean;

  normal?: DirectionInput;

  offset?: Partial<Vector3Like>;

  preset: FxPresetBillboardPreset;

  samplerOverrides?: Record<string, string>;

  scale?: NumLike;

  uniformOverrides?: Record<string, WaveShaderUniformValue<"float" | "vec2" | "vec3" | "vec4" | "color3" | "color4">>;

  upHint?: DirectionInput;

}

type PrimitiveColliderShapeName = "box" | "sphere" | "capsule" | "cylinder";

declare enum PrimitiveMaterialType {

  PBR = "PBR",

  Standard = "Standard",

}

interface PrimitiveOptions {

  arc?: number;

  backUVs?: unknown;

  baseCapSegments?: number;

  cap?: number;

  capBase?: boolean;

  capSides?: boolean;

  capSubdivisions?: number;

  color?: ColorInput | string;

  depth?: number;

  depthSegments?: number;

  diameter?: number;

  diameterBottom?: number;

  diameterTop?: number;

  diameterX?: number;

  diameterY?: number;

  diameterZ?: number;

  enclose?: boolean;

  faceColors?: ColorInputAlpha[];

  faceUV?: unknown[];

  flat?: boolean;

  frontUVs?: unknown;

  height?: number;

  heightSegments?: number;

  horizontalArc?: number;

  innerRadius?: number;

  invertNormals?: boolean;

  materialType?: PrimitiveMaterialType;

  name?: string;

  orientation?: number;

  outerRadius?: number;

  p?: number;

  planeOrientation?: "xy" | "ground";

  q?: number;

  radialSegments?: number;

  radius?: number;

  radiusBottom?: number;

  radiusTop?: number;

  segments?: number;

  shape?: Vector3[];

  sideCapSegments?: number;

  sideOrientation?: number;

  size?: number;

  slice?: number;

  subdivisions?: number;

  subdivisionsX?: number;

  subdivisionsY?: number;

  taperX?: number;

  taperZ?: number;

  tessellation?: number;

  thickness?: number;

  topDepth?: number;

  topOffsetX?: number;

  topOffsetZ?: number;

  topology?: "uv" | "ico";

  topWidth?: number;

  updatable?: boolean;

  verticalArc?: number;

  verticalSegments?: number;

  width?: number;

  widthSegments?: number;

}

declare const PRISM_BOTTOM_FACE: Readonly<{ readonly kind: "bottom"; }>;

declare const PRISM_TOP_FACE: Readonly<{ readonly kind: "top"; }>;

interface PrismaticConfig {

  axisA?: DirectionInput | undefined;

  axisB?: DirectionInput | undefined;

  enableCollisions?: boolean | undefined;

  limits?: AxisLimit[] | undefined;

  motors?: MotorConfig[] | undefined;

  perpAxisA?: DirectionInput | undefined;

  perpAxisB?: DirectionInput | undefined;

  pivotA?: any;

  pivotB?: any;

  linearLimit?: { min: number; max: number; }

  type: ConstraintType.Prismatic;

}

type PrismBottomFaceSelector = typeof PRISM_BOTTOM_FACE;

type PrismFaceSelector = PrismTopFaceSelector | PrismBottomFaceSelector | PrismSideFaceSelector;

type PrismSideFaceSelector = { readonly kind: "side"; readonly index: number; }

type PrismTopFaceSelector = typeof PRISM_TOP_FACE;

interface ProceduralAnimationBindingValue {

  readonly kind: "procedural";

  readonly payloadKind: "procedural";

  readonly ref: ExactAssetRef<"animation">;

  readonly template: CompiledProceduralAnimationTemplate;

}

type ProceduralSkyConfig = EnabledEnvironmentPatch<ProceduralSkyState>;

declare class ProceduralSkyConfigurator<TEngine extends unknown = unknown> {

  constructor(_sky: SkyConfigurator<TEngine>);

  alpha(value: number): this;

  apply(): SkyConfigurator<TEngine>;

  configure(patch: ProceduralSkyConfig): this;

  contrast(value: number): this;

  disable(): SkyConfigurator<TEngine>;

  exposure(value: number): this;

  gradientInfluence(horizon: number, zenith: number): this;

  horizonInfluence(value: number): this;

  luminance(value: number): this;

  mie(coefficient: number, directionalG: number): this;

  mieCoefficient(value: number): this;

  mieDirectionalG(value: number): this;

  rayleigh(value: number): this;

  rotation(value: number): this;

  saturation(value: number): this;

  sunAppearance(values: { diskAngularSizeDegrees?: number; diskIntensity?: number; haloAngularSizeDegrees?: number; haloIntensity?: number; }): this;

  sunDiskIntensity(value: number): this;

  sunDiskSizeDegrees(value: number): this;

  sunHaloIntensity(value: number): this;

  sunHaloSizeDegrees(value: number): this;

  tone(values: Pick<ProceduralSkyConfig, "exposure" | "saturation" | "contrast">): this;

  turbidity(value: number): this;

  zenithInfluence(value: number): this;

}

interface ProceduralSkyState {

  alpha?: number;

  contrast: number;

  enabled: boolean;

  exposure: number;

  horizonColor: number;

  horizonInfluence: number;

  luminance: number;

  mieCoefficient: number;

  mieDirectionalG: number;

  rayleigh: number;

  rotation?: number;

  saturation: number;

  sunDiskAngularSizeDegrees: number;

  sunDiskIntensity: number;

  sunHaloAngularSizeDegrees: number;

  sunHaloIntensity: number;

  turbidity: number;

  zenithColor: number;

  zenithInfluence: number;

}

interface ProceduralTextureHandle {

  readonly context: CanvasRenderingContext2D;

  dispose(): void;

  update(): this;

}

declare class ProfileField<T extends ProfileFieldValue = number> {

  constructor(profile: cmp_profile, name: string, dataType: ProfileFieldType);

  readonly dataType: ProfileFieldType;

  get(): T;

  readonly name: string;

  get profile(): cmp_profile;

  set(value: T): void;

  get value(): number;

}

type ProfileFieldValue = number | boolean | string | SerializableVector2 | SerializableVector3;

declare const PROJECT_ASSET_ACCESS_EXPOSURES: readonly ["merged", "explicit-only"];

declare const PROJECT_ASSET_ACCESSOR_BUCKETS: readonly ["models", "gaussianSplats", "materials", "textures", "animations", "vertexAnimations", "poses", "audios", "instruments", "videos", "fonts", "serializedData", "hdr", "cubeMaps", "guis", "terrains", "fx"];

declare const PROJECT_ASSET_BAKE_MODES: readonly ["none", "onPublish", "onDemand"];

declare const PROJECT_ASSET_KIND_SPECS: { readonly model: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly gaussianSplat: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly texture: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly hdrEnvironment: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly cubeMap: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly font: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly video: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly audio: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly instrument: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly serializedData: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly svg: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly gui: { readonly sourceTypes: readonly ["raw"]; readonly inlineDefinitionSupport: "none"; }; readonly material: { readonly sourceTypes: readonly ["project", "babylonExternal"]; readonly inlineDefinitionSupport: "none"; readonly sourceModuleSuffix: `.material${string}`; readonly babylonExternalImportFormats: readonly ["nodeMaterialJson", "nodeMaterialSnippet", "materialJson"]; }; readonly shader: { readonly sourceTypes: readonly ["project", "babylonExternal"]; readonly inlineDefinitionSupport: "none"; readonly sourceModuleSuffix: `.shader${string}`; readonly babylonExternalImportFormats: readonly ["shaderSnippet"]; }; readonly fx: { readonly sourceTypes: readonly ["raw", "project"]; readonly inlineDefinitionSupport: "materializer"; readonly sourceModuleSuffix: `.fx${string}`; }; readonly terrain: { readonly sourceTypes: readonly ["project"]; readonly inlineDefinitionSupport: "none"; readonly sourceModuleSuffix: `.terrain${string}`; }; readonly generatedMesh: { readonly sourceTypes: readonly ["project", "babylonExternal"]; readonly inlineDefinitionSupport: "materializer"; readonly sourceModuleSuffix: `.generatedMesh${string}`; readonly babylonExternalImportFormats: readonly ["nodeGeometryJson", "nodeGeometrySnippet"]; }; readonly animation: { readonly sourceTypes: readonly ["raw", "project"]; readonly inlineDefinitionSupport: "none"; readonly sourceModuleSuffix: `.animation${string}`; }; readonly rig: { readonly sourceTypes: readonly ["raw", "project"]; readonly inlineDefinitionSupport: "none"; readonly sourceModuleSuffix: `.rig${string}`; }; readonly pose: { readonly sourceTypes: readonly ["raw", "project"]; readonly inlineDefinitionSupport: "none"; readonly sourceModuleSuffix: `.pose${string}`; }; readonly vertexAnimation: { readonly sourceTypes: readonly ["raw", "project"]; readonly inlineDefinitionSupport: "none"; readonly sourceModuleSuffix: `.vat${string}`; }; readonly postProcessChain: { readonly sourceTypes: readonly ["project", "babylonExternal"]; readonly inlineDefinitionSupport: "none"; readonly sourceModuleSuffix: `.postProcessChain${string}`; readonly babylonExternalImportFormats: readonly ["postProcessChainJson"]; }; };

declare const PROJECT_ASSET_SOURCE_TYPES: readonly ["raw", "project", "babylonExternal"];

declare const PROJECT_AUTHORED_MATERIAL_TYPES: readonly ["pbr", "proceduralPbr", "splat", "standard"];

interface ProjectAnimationAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly type: "animation";

  readonly clip: WaveModelSnapshotClipMetadata;

  readonly snapshots?: readonly WaveModelSnapshotMetadata[];

}

type ProjectAssetAccessorBucket = (typeof PROJECT_ASSET_ACCESSOR_BUCKETS)[number];

type ProjectAssetAccessorExposure = (typeof PROJECT_ASSET_ACCESS_EXPOSURES)[number];

interface ProjectAssetAccessorSpec {

  readonly bucket: ProjectAssetAccessorBucket;

  readonly expose?: ProjectAssetAccessorExposure;

  readonly key: string;

}

interface ProjectAssetBakeHints {

  readonly mode?: ProjectAssetBakeMode;

  readonly outputId?: string;

  readonly outputType?: string;

}

type ProjectAssetBakeMode = (typeof PROJECT_ASSET_BAKE_MODES)[number];

interface ProjectAssetCatalog<TAssets extends readonly ProjectAssetManifestEntry[] = readonly ProjectAssetManifestEntry[]> {

  readonly assets: TAssets;

  readonly version: 1;

}

type ProjectAssetKindSpecs = typeof PROJECT_ASSET_KIND_SPECS;

type ProjectAssetManifestEntry = ProjectRawAssetManifestEntry | ProjectAuthoredAssetManifestEntry | ProjectBabylonExternalAssetManifestEntry;

interface ProjectAssetMaterializeContext {

  readonly engine: unknown;

  readonly projectAssetEntry: ProjectAuthoredAssetManifestEntry;

  readonly projectAssetId: string;

  readonly projectIdentity?: ProjectAssetMaterializeProjectIdentity;

  readonly readProjectAssetFile?: (ref: string, mode?: ProjectAssetMaterializeReadMode) => Promise<string | Uint8Array | unknown | null>;

}

interface ProjectAssetMaterializeProjectIdentity {

  readonly id?: string;

  readonly kind?: "saved" | "ephemeral" | string;

  readonly savedProjectId?: string;

}

type ProjectAssetMaterializer = (context: ProjectAssetMaterializeContext) => unknown | Promise<unknown>;

type ProjectAssetMaterializeReadMode = "text" | "json" | "binary";

interface ProjectAssetMetadata {

  readonly description?: string;

  readonly editorVersion?: string;

  readonly externalTool?: string;

  readonly notes?: string;

  readonly tags?: readonly string[];

  readonly thumbnailRef?: string;

}

type ProjectAssetParameterPrimitive = boolean | number | string | null;

type ProjectAssetParameterSchema = Readonly<Record<string, ProjectAssetParameterValue>>;

type ProjectAssetParameterValue = ProjectAssetParameterPrimitive | readonly ProjectAssetParameterValue[] | { readonly [key: string]: ProjectAssetParameterValue; }

type ProjectAssetSourceType = (typeof PROJECT_ASSET_SOURCE_TYPES)[number];

type ProjectAssetType = keyof ProjectAssetKindSpecs;

type ProjectAssetTypesForSource<TSourceType extends ProjectAssetSourceType> = { [TType in ProjectAssetType]: TSourceType extends ProjectAssetKindSpecs[TType]["sourceTypes"][number] ? TType : never; }[ProjectAssetType];

type ProjectAuthoredAssetDefinition = ProjectTerrainAssetDefinition | ProjectMaterialAssetDefinition | ProjectShaderAssetDefinition | ProjectFxAssetDefinition | ProjectGeneratedMeshAssetDefinition | ProjectAnimationAssetDefinition | ProjectRigAssetDefinition | ProjectPoseAssetDefinition | ProjectVertexAnimationAssetDefinition | ProjectPostProcessChainAssetDefinition;

interface ProjectAuthoredAssetManifestEntry<TType extends ProjectAuthoredAssetType = ProjectAuthoredAssetType> {

  readonly accessor?: ProjectAssetAccessorSpec | undefined;

  readonly dependsOn?: readonly string[] | undefined;

  readonly id: string;

  readonly metadata?: ProjectAssetMetadata | undefined;

  readonly preload?: "eager" | "lazy" | undefined;

  readonly publishAs?: string | undefined;

  readonly sourceType: "project";

  readonly type: TType;

  readonly bake?: ProjectAssetBakeHints;

  readonly inlineDefinition?: TType extends ProjectInlineAuthoredAssetType ? Extract<ProjectAuthoredAssetDefinition, { readonly type: TType; }> : never;

  readonly source: string;

}

type ProjectAuthoredAssetType = ProjectAssetTypesForSource<"project">;

type ProjectAuthoredMaterialType = (typeof PROJECT_AUTHORED_MATERIAL_TYPES)[number];

interface ProjectBabylonExternalAssetManifestEntry<TType extends BabylonExternalProjectAssetType = BabylonExternalProjectAssetType> {

  readonly accessor?: ProjectAssetAccessorSpec | undefined;

  readonly dependsOn?: readonly string[] | undefined;

  readonly id: string;

  readonly metadata?: ProjectAssetMetadata | undefined;

  readonly preload?: "eager" | "lazy" | undefined;

  readonly publishAs?: string | undefined;

  readonly sourceType: "babylonExternal";

  readonly type: TType;

  readonly importFormat: BabylonExternalImportFormat;

  readonly locatorType: BabylonExternalLocatorType;

  readonly source: string;

}

type ProjectFxAssetDefinition = ProjectWaveFxSystemAssetDefinition | ProjectPluginEffectAssetDefinition;

interface ProjectGeneratedMeshAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly type: "generatedMesh";

  readonly bakeRef?: string;

  readonly generatedMeshType: "primitive" | "loft" | "hardSurface" | "path" | "proceduralModel" | "editedMesh" | "csg" | "text" | "wavePrefabModel";

  readonly hardSurfaceCompilerIdentity?: WaveHardSurfaceCompilerIdentity;

  readonly hardSurfaceRecipe?: WaveHardSurfaceGeometryRecipe;

  readonly inputRefs?: readonly string[];

  readonly loftRecipe?: WaveLoftGeometryRecipe;

  readonly materialRefs?: readonly string[];

  readonly objectModel?: ProjectGeneratedMeshObjectModelBinding;

  readonly primitiveRecipe?: WavePrimitiveGeometryRecipe;

  readonly runtimeProcedural?: boolean;

}

interface ProjectGeneratedMeshObjectModelBinding {

  readonly graph: WaveModelRigGraphMetadata;

  readonly meshIdByPartId?: Readonly<Record<WaveModelPartId, string>>;

}

type ProjectInlineAuthoredAssetType = { [TType in ProjectAssetType]: ProjectAssetKindSpecs[TType]["inlineDefinitionSupport"] extends "none" ? never : TType; }[ProjectAssetType];

type ProjectionContent = { type: "gradient"; config: ProjectionGradientConfig; } | { type: "gobo"; config: ProjectionGoboConfig; } | { type: "caustic"; config: CausticPatternConfig; } | { type: "noise"; config: ProjectionNoiseConfig; } | { type: "pattern"; config: ProjectionPatternConfig; } | { type: "video"; config: MediaContentConfig; } | { type: "image"; config: MediaContentConfig; } | { type: "spotlight"; config: ProjectionSpotlightConfig; } | { type: "custom"; config: ProjectionCustomConfig; }

interface ProjectionCustomConfig {

  fragmentShader: string;

  resolution?: number;

  uniforms?: Record<string, number | number[] | ColorInput>;

}

interface ProjectionGoboConfig {

  color?: ColorInput;

  mask: GoboPreset | string;

  resolution?: number;

  rotation?: number;

  rotationSpeed?: number;

  scale?: number;

  softness?: number;

}

interface ProjectionGradientConfig {

  animationMode?: GradientAnimationMode;

  colorStops: GradientColorStop[];

  direction?: "horizontal" | "vertical" | "radial" | "angular";

  noiseIntensity?: number;

  noiseScale?: number;

  resolution?: number;

  softEdge?: number;

  speed?: number;

}

interface ProjectionLightConfig {

  exponent: number;

  falloffType: number;

  gradientAnimationMode: "scroll" | "oscillate" | "static";

  gradientDirection: "horizontal" | "vertical" | "radial" | "angular";

  gradientNoiseIntensity: number;

  gradientNoiseScale: number;

  gradientResolution: number;

  gradientSoftEdge: number;

  gradientSpeed: number;

  innerAngle: number;

  intensity: number;

  intensityCeilingScale: number;

  intensityFloorScale: number;

  outerAngle: number;

  projectionNear: number;

}

interface ProjectionNoiseConfig {

  algorithm: "perlin" | "simplex" | "voronoi" | "worley" | "fbm";

  colorRamp: GradientColorStop[];

  frequency?: number;

  octaves?: number;

  resolution?: number;

  seed?: number;

  speed?: number;

  turbulence?: number;

}

interface ProjectionPatternConfig {

  backgroundColor?: ColorInput;

  color?: ColorInput;

  density?: number;

  pattern: "stripes" | "grid" | "dots" | "chevron" | "hexGrid" | "radialBurst" | "concentricRings";

  pulseSpeed?: number;

  resolution?: number;

  rotation?: number;

  scrollSpeed?: number;

  thickness?: number;

}

interface ProjectionSpotlightConfig {

  color?: ColorInput;

  falloff?: number;

  innerRadius?: number;

  pulseSpeed?: number;

  resolution?: number;

  rimColor?: ColorInput;

  temperatureDrift?: number;

}

type ProjectMaterialAlphaMode = "disable" | "alpha" | "additive" | "multiply" | "premultiplied";

interface ProjectMaterialAnisotropyOptions {

  readonly direction?: Vector2Like;

  readonly enabled?: boolean;

  readonly intensity?: number;

}

type ProjectMaterialAssetDefinition = ProjectPBRMaterialAssetDefinition | ProjectProceduralPBRMaterialAssetDefinition | ProjectSplatMaterialAssetDefinition | ProjectStandardMaterialAssetDefinition;

interface ProjectMaterialClearCoatOptions {

  readonly enabled?: boolean;

  readonly indexOfRefraction?: number;

  readonly intensity?: number;

  readonly roughness?: number;

}

interface ProjectMaterialIridescenceOptions {

  readonly enabled?: boolean;

  readonly indexOfRefraction?: number;

  readonly intensity?: number;

  readonly maximumThickness?: number;

  readonly minimumThickness?: number;

}

interface ProjectMaterialSheenOptions {

  readonly color?: ColorInput;

  readonly enabled?: boolean;

  readonly intensity?: number;

  readonly roughness?: number | null;

}

interface ProjectMaterialSubSurfaceOptions {

  readonly indexOfRefraction?: number;

  readonly maximumThickness?: number;

  readonly minimumThickness?: number;

  readonly refractionIntensity?: number;

  readonly tintColor?: ColorInput;

  readonly translucencyIntensity?: number;

}

type ProjectMaterialTransparencyMode = "opaque" | "alphaTest" | "alphaBlend" | "alphaTestAndBlend";

interface ProjectPBRMaterialAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly bakeRef?: string | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly materialType: "pbr";

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly textureRefs?: readonly string[] | undefined;

  readonly type: "material";

  readonly materialOptions?: ProjectPBRMaterialOptions;

  readonly textureSlots?: ProjectPBRMaterialTextureSlots;

}

interface ProjectPBRMaterialOptions {

  readonly albedoColor?: ColorInput;

  readonly alpha?: number;

  readonly alphaCutoff?: number;

  readonly alphaMode?: ProjectMaterialAlphaMode | null;

  readonly anisotropy?: ProjectMaterialAnisotropyOptions;

  readonly clearCoat?: ProjectMaterialClearCoatOptions;

  readonly directIntensity?: number;

  readonly doubleSided?: boolean;

  readonly emissiveColor?: ColorInput;

  readonly emissiveIntensity?: number;

  readonly environmentIntensity?: number;

  readonly iridescence?: ProjectMaterialIridescenceOptions;

  readonly maxSimultaneousLights?: number;

  readonly metallic?: number;

  readonly normalTextureFlipY?: boolean;

  readonly relief?: WavePBRReliefIntent;

  readonly roughness?: number;

  readonly sheen?: ProjectMaterialSheenOptions;

  readonly specularIntensity?: number;

  readonly subSurface?: ProjectMaterialSubSurfaceOptions;

  readonly transparencyMode?: ProjectMaterialTransparencyMode | null;

  readonly transparent?: boolean;

  readonly useAlbedoTextureAlpha?: boolean;

  readonly useRadianceOverAlpha?: boolean;

  readonly useSpecularOverAlpha?: boolean;

  readonly uvOffset?: Vector2Like;

  readonly uvRotation?: number;

  readonly uvScale?: Vector2Like;

  readonly wireframe?: boolean;

}

interface ProjectPBRMaterialTextureSlots {

  readonly albedoTexture?: string;

  readonly aoTexture?: string;

  readonly emissiveTexture?: string;

  readonly metallicTexture?: string;

  readonly normalTexture?: string;

  readonly opacityTexture?: string;

  readonly ormTexture?: string;

  readonly refractionIntensityTexture?: string;

  readonly roughnessTexture?: string;

  readonly thicknessTexture?: string;

  readonly translucencyColorTexture?: string;

  readonly translucencyIntensityTexture?: string;

}

interface ProjectPluginEffectAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly type: "fx";

  readonly fxType: "pluginEffect";

  readonly materialRefs?: readonly string[];

  readonly outputAssetType?: string;

  readonly params?: ProjectAssetParameterSchema;

  readonly pluginId: string;

  readonly pluginVersion?: string;

  readonly secondaryType?: string;

  readonly textureRefs?: readonly string[];

}

interface ProjectPoseAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly type: "pose";

  readonly pose: WaveModelRigPoseSnapshotMetadata;

}

interface ProjectPostProcessChainAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly type: "postProcessChain";

  readonly chainType: "wavePostFx" | "babylonChain";

  readonly effectRefs: readonly string[];

}

interface ProjectProceduralPBRMaterialAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly bakeRef?: string | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly materialType: "proceduralPbr";

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly textureRefs?: readonly string[] | undefined;

  readonly type: "material";

  readonly baked?: ProjectProceduralPBRMaterialBakedArtifact;

  readonly bakePolicy?: WaveProceduralPBRBakePolicy;

  readonly recipe: WaveProceduralPBRRecipe;

}

interface ProjectProceduralPBRMaterialBakedArtifact {

  readonly backend: Exclude<WaveProceduralPBRBakePolicy["backend"], "auto">;

  readonly channels: readonly ProjectProceduralPBRMaterialBakedChannel[];

  readonly evaluatorVersion: number;

  readonly recipeHash: string;

}

interface ProjectProceduralPBRMaterialBakedChannel {

  readonly colorSpace: "srgb" | "linear";

  readonly format: "rgba8";

  readonly height: number;

  readonly payloadRef: string;

  readonly role: WaveProceduralPBRChannel;

  readonly width: number;

}

type ProjectRawAssetGaussianSplatOptions<TType extends RawProjectAssetType> = TType extends "gaussianSplat" ? WaveGaussianSplatSerializableLoadOptions : never;

interface ProjectRawAssetManifestEntry<TType extends RawProjectAssetType = RawProjectAssetType> {

  readonly accessor?: ProjectAssetAccessorSpec | undefined;

  readonly dependsOn?: readonly string[] | undefined;

  readonly id: string;

  readonly metadata?: ProjectAssetMetadata | undefined;

  readonly preload?: "eager" | "lazy" | undefined;

  readonly publishAs?: string | undefined;

  readonly sourceType: "raw";

  readonly type: TType;

  readonly gaussianSplat?: ProjectRawAssetGaussianSplatOptions<TType>;

  readonly source: string;

  readonly sourceFormat?: ProjectRawAssetSourceFormat<TType>;

}

type ProjectRawAssetSourceFormat<TType extends RawProjectAssetType> = TType extends "gaussianSplat" ? WaveGaussianSplatSourceFormat : string;

interface ProjectRigAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly type: "rig";

  readonly graph: WaveModelRigGraphMetadata;

}

interface ProjectShaderAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly type: "shader";

  readonly shaderType: "glsl" | "preset" | "plugin";

  readonly textureRefs?: readonly string[];

  readonly uniformDefaults?: ProjectAssetParameterSchema;

}

interface ProjectSplatMaterialAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly bakeRef?: string | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly materialType: "splat";

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly textureRefs?: readonly string[] | undefined;

  readonly type: "material";

  readonly splat: MaterialSplatDefinition;

}

interface ProjectStandardMaterialAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly bakeRef?: string | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly materialType: "standard";

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly textureRefs?: readonly string[] | undefined;

  readonly type: "material";

  readonly materialOptions?: ProjectStandardMaterialOptions;

  readonly textureSlots?: ProjectStandardMaterialTextureSlots;

}

interface ProjectStandardMaterialOptions {

  readonly alpha?: number;

  readonly diffuseColor?: ColorInput;

  readonly doubleSided?: boolean;

  readonly emissiveColor?: ColorInput;

  readonly maxSimultaneousLights?: number;

  readonly specularColor?: ColorInput;

  readonly specularPower?: number;

  readonly transparent?: boolean;

  readonly uvOffset?: Vector2Like;

  readonly uvRotation?: number;

  readonly uvScale?: Vector2Like;

  readonly wireframe?: boolean;

}

interface ProjectStandardMaterialTextureSlots {

  readonly ambientTexture?: string;

  readonly bumpTexture?: string;

  readonly diffuseTexture?: string;

  readonly emissiveTexture?: string;

  readonly specularTexture?: string;

}

interface ProjectTerrainAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly type: "terrain";

  readonly bakeRef?: string;

  readonly elementRefs?: readonly string[];

  readonly materialRefs?: readonly string[];

  readonly persistenceRef?: string;

  readonly runtimeCacheRef?: string;

  readonly terrainType: "preset" | "persistentState" | "bakedMaterialMaps" | "runtimeBundle" | "streaming";

}

interface ProjectVertexAnimationAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly type: "vertexAnimation";

  readonly compatibleModelRefs?: readonly string[];

  readonly encoding?: "float32-base64" | "float16-base64";

  readonly formatVersion?: 1;

  readonly fps?: number;

  readonly meshRefs?: readonly string[];

  readonly ranges?: readonly { readonly name: string; readonly from: number; readonly to: number; }[];

  readonly sourceAnimationRef?: string;

  readonly targetMeshName?: string;

  readonly targetModelRef?: string;

  readonly textureRefs?: readonly string[];

  readonly totalFrames?: number;

  readonly vertexAnimationType: "vat" | "meshMorphVat" | "gpuPathFollow" | "procedural";

  readonly vertexCount?: number;

}

interface ProjectWaveFxSystemAssetDefinition {

  readonly assetRefs?: readonly string[] | undefined;

  readonly description?: string | undefined;

  readonly materialize?: ProjectAssetMaterializer | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly tags?: readonly string[] | undefined;

  readonly type: "fx";

  readonly fxType: "waveSystem";

  readonly materialRefs?: readonly string[];

  readonly textureRefs?: readonly string[];

  readonly userParamDefaults?: ProjectAssetParameterSchema;

}

type PromotedVisualPartSource = { sourceEntityId: number; meshKey: string; partId: VisualPartId; includeInPhysics: boolean; parentPartId: VisualPartId | null; metadata: Record<string, unknown> | null; }

interface QuaternionLike {

  w: number;

  x: number;

  y: number;

  z: number;

}

type QuaternionLike = StructuralQuaternionLike;

type QuaternionLike = MathQuaternionLike;

interface RadialBlurOptions {

  centerPosition?: { x: number; y: number; }

  decay?: number;

  density?: number;

  exposure?: number;

  samples?: number;

  weight?: number;

}

declare class RateObservationSource<TEntity extends BehaviorObservationRuntimeHost> implements WaveRateObservationSource<TEntity> {

  above(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  atLeast(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  atMost(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  below(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  between(min: number, max: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  equals(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  near(value: number, tolerance: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  outside(min: number, max: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

}

type RatePredicateArg = ObservationOccurrenceToken | ObservationRateBasisToken | ObservationWindow | undefined;

type RawDirection = Direction.X | Direction.Y | Direction.Z;

type RawProjectAssetType = ProjectAssetTypesForSource<"raw">;

type RawWaveRigChainEntry = Vector3Like | WaveModelVec3Tuple | WaveRigChainPartInput;

interface RayHit {

  distance: number;

  normal: Vector3Like;

  position: Vector3Like;

}

interface ReadonlyEntityStateApi<TEntity extends object, TState> {

  readonly current: TState | null;

  history(): readonly TState[];

  in(state: TState): boolean;

  inAny(...states: TState[]): boolean;

  offEnter(state: TState, callback: EntityStateCallback<TEntity>): boolean;

  offExit(state: TState, callback: EntityStateCallback<TEntity>): boolean;

  onEnter(state: TState, callback: EntityStateCallback<TEntity>): TEntity;

  onExit(state: TState, callback: EntityStateCallback<TEntity>): TEntity;

  readonly previous: TState | null;

  timeInCurrentState(): WaveTimeSpan;

  timesEnteredIn(state: TState, within: WaveTimeLookback): number;

  timesEnteredIn(state: TState, value: number, unit: WaveTimeUnit): number;

  timesExitedIn(state: TState, within: WaveTimeLookback): number;

  timesExitedIn(state: TState, value: number, unit: WaveTimeUnit): number;

  totalTimeIn(state: TState): number;

  whenIn(...args: [TState] | [TState, EntityStateCallback<TEntity>, WaveTimeRule?]): TEntity | WaveScopedObservationBuilder<TEntity, TState>;

}

interface RegionalScaleAccumulation {

  anchor: RegionalScaleAnchor;

  endPos: number;

  falloff: RegionalScaleFalloff;

  regionAxis: DirectionInput;

  scaleAxis: DirectionInput;

  scaleFactor: number;

  startPos: number;

}

type RegionalScaleAnchor = "min" | "center" | "max";

declare class RegionalScaleBuilder {

  anchorCenter(): this;

  anchorMax(): this;

  anchorMin(): this;

  animate(): WaveGeometryDeformAnimationBuilder;

  apply(): MeshEditResult;

  forceMergeMesh(force?: boolean): this;

  inDirection(axis: DirectionInput): this;

  inRegion(start: number, end: number): this;

  mode(mode: DeformApplyMode): this;

  regionEnd(pos: number): this;

  regionStart(pos: number): this;

  scaleAlongBy(axis: DirectionInput, factor: number): this;

  selectAlong(axis: DirectionInput): this;

  withFalloff(falloff: RegionalScaleFalloff): this;

  withScale(factor: number): this;

}

interface RegionalScaleOptions {

  anchor?: RegionalScaleAnchor;

  applyMode?: DeformApplyMode;

  endPos?: number;

  falloff?: RegionalScaleFalloff;

  regionAxis: DirectionInput;

  scaleAxis: DirectionInput;

  scaleFactor: number;

  startPos?: number;

}

type RelativePlacementTarget = TransformReferenceLike | WavePointInput;

interface RemoteEventOptions {

  includeLocal?: boolean;

  reliable?: boolean;

  targets?: "all" | "others" | "host" | string[];

}

declare enum RenderBackbufferDeviceClass {

  Desktop = "Desktop",

  Phone = "Phone",

  Tablet = "Tablet",

}

interface RenderBackbufferDiagnostics {

  readonly frameAdaptive: FrameAdaptiveBackbufferDiagnostics;

  readonly resolvedPolicy: ResolvedRenderBackbufferPolicy | null;

}

interface RenderBackbufferFrameAdaptivePolicy {

  cooldownMs?: number;

  downshiftFrameRate?: number;

  downshiftStep?: number;

  downshiftSustainFrames?: number;

  emaAlpha?: number;

  quantizationStep?: number;

  targetFrameRate?: number;

  upshiftFrameRate?: number;

  upshiftStep?: number;

  upshiftSustainFrames?: number;

}

declare enum RenderBackbufferLimiter {

  DeviceClassCap = "DeviceClassCap",

  FixedStrategy = "FixedStrategy",

  FrameAdaptive = "FrameAdaptive",

  GlobalCap = "GlobalCap",

  HostCap = "HostCap",

  MinimumFloor = "MinimumFloor",

  PixelBudget = "PixelBudget",

}

interface RenderBackbufferPolicy {

  desktopMaxPixelRatio?: number;

  fixedPixelRatio?: number;

  frameAdaptive?: RenderBackbufferFrameAdaptivePolicy;

  maxBackbufferPixels?: number;

  maxPixelRatio?: number;

  minPixelRatio?: number;

  phoneMaxPixelRatio?: number;

  strategy?: RenderBackbufferStrategy;

  tabletMaxPixelRatio?: number;

}

declare enum RenderBackbufferStrategy {

  DeviceAdaptive = "DeviceAdaptive",

  Fixed = "Fixed",

  FrameAdaptive = "FrameAdaptive",

  FullDevicePixelRatio = "FullDevicePixelRatio",

}

declare class RenderingConfigurator<TEngine extends unknown = unknown> {

  apply(): WaveScene<TEngine>;

  apply(patch: Partial<WaveSceneRenderingPlan>): WaveScene<TEngine>;

  allowResolutionScaling(range: WaveResolutionScalingRange): RenderingConfigurator<TEngine>;

  backbuffer(policy: RenderBackbufferPolicy): RenderingConfigurator<TEngine>;

  preferStableFrameRate(targetFrameRate: number): RenderingConfigurator<TEngine>;

}

declare class RepeatAction<TEntity extends object, TIndices extends readonly number[]> {

  constructor(entity: TEntity, dimensions: readonly number[]);

  do(callback: RepeatCallback<TEntity, TIndices>): TEntity;

}

declare const RepeatBreak: unique symbol;

type RepeatCallback<TEntity extends object, TIndices extends readonly number[]> = (entity: TEntity, ...indices: TIndices) => RepeatResult;

declare const RepeatContinue: unique symbol;

type RepeatControl = typeof Repeat.break | typeof Repeat.continue;

type RepeatIndices<TDimensions extends readonly number[]> = { [K in keyof TDimensions]: number; }

type RepeatResult = RepeatControl | void;

type ReplicateMode = "all" | "owner" | "targets";

interface ResolvedAssetDependencyShape {

  readonly body: SerializableDataValue;

  readonly dependencies: readonly AssetIdentity<"animation" | "material" | "texture" | "model" | "video" | "audio" | "font" | "data">[];

  readonly exactPins?: readonly NormalizedAssetExactPin[] | undefined;

  readonly dependencyKeys: readonly AssetContentKey[];

}

type ResolvedAssetDependencySource = { readonly kind: "published"; readonly ref: ExactAssetRef; } | { readonly kind: "declaredSource"; readonly ref: AssetRef; readonly source: AssetLoadRequest; } | { readonly kind: "synthesizedDefinition"; readonly ref: AssetRef; readonly definition: AssetDefinition; }

interface ResolvedAssetSpec<F extends AssetFamily = AssetFamily> {

  readonly body: SerializableDataValue;

  readonly compilerVersion: string;

  readonly dependencies: readonly AssetIdentity<"animation" | "material" | "texture" | "model" | "video" | "audio" | "font" | "data">[];

  readonly id: AssetIdentity<F>;

  readonly kind: string;

  readonly dependencyKeys: readonly AssetContentKey[];

  readonly key: AssetContentKey;

}

interface ResolvedDynamicDriveOptions {

  readonly angularDamping: number;

  readonly damping: number;

  readonly maxForce: number;

  readonly maxTorque: number;

  readonly positionStrength: number;

  readonly rotationStrength: number;

  readonly strength: number;

}

interface ResolvedPhysicsMaterial {

  readonly definition: PhysicsMaterialDefinition;

  readonly revision: string;

}

interface ResolvedPhysicsMaterialBinding {

  readonly key: string;

  readonly material: ResolvedPhysicsMaterial;

  readonly target: PhysicsMaterialBindingTarget;

}

interface ResolvedRenderBackbufferPolicy {

  cssHeight: number;

  cssWidth: number;

  deviceClass: RenderBackbufferDeviceClass;

  deviceClassCap: number | null;

  devicePixelRatio: number;

  effectivePixelRatio: number;

  globalPixelRatioCap: number | null;

  hardwareScalingLevel: number;

  hostPixelRatioCap: number | null;

  limiters: readonly RenderBackbufferLimiter[];

  maximumPixelRatio: number;

  minimumPixelRatio: number;

  pixelBudgetRatioCap: number | null;

  strategy: RenderBackbufferStrategy;

}

type ResolvedWorldTransformSnapshot = WaveTransformStateSnapshot;

interface RibbonOpts {

  blend?: "additive" | "alpha" | "multiply";

  bundle?: { strandCount?: number; spread?: number; spreadOverLength?: FxValueCurveInput; twistOverLength?: FxValueCurveInput; twist?: number; phaseSpeed?: number; jitter?: number; strandWidthScale?: number; }

  depthWrite?: boolean;

  fadeByAge?: boolean;

  glow?: FxGlowConfig;

  maxPoints?: number;

  maxSegmentLength?: number;

  smoothing?: number;

  texture?: string;

  textureMode?: "stretch" | "tile" | "distanceRepeat";

  textureRepeatDistance?: number;

  widthOverLength?: FxValueCurveInput;

  worldSpace?: boolean;

}

interface RigApplyResult {

  bone?: any;

  bones?: unknown[] | undefined;

  error?: string | undefined;

  geometryWritten?: boolean | undefined;

  localPosition?: any;

  pose?: WavePose | undefined;

  skeleton?: any;

  success: boolean;

  verticesAffected?: number | undefined;

  bonesAffected?: number;

  config?: WaveRigAuthoringConfig;

}

type RigBoneIKOptions = WaveRigIKIntent;

declare enum RigidBodyActivationPolicy {

  AlwaysActive = "alwaysActive",

  Normal = "normal",

}

interface RigidBodyActuationBuiltInMetric {

  kind: RigidBodyActuationMetricKind;

  space?: WaveSpace;

}

interface RigidBodyActuationCustomMetric {

  kind: "custom";

  label?: string;

  read: (body: cmp_physicsBody) => number;

}

interface RigidBodyActuationEvent {

  activeImpactCount: number;

  body: cmp_physicsBody;

  currentValue: number;

  hasImpactContext: boolean;

  lastImpactAtMs: number;

  lastImpactLabel: string;

  previousActuatedAtMs: number;

  previousValue: number | null;

  state: RigidBodyActuationState;

  threshold: number;

  timestampMs: number;

  trigger: RigidBodyActuationTrigger;

}

type RigidBodyActuationMetric = RigidBodyActuationBuiltInMetric | RigidBodyActuationCustomMetric;

declare enum RigidBodyActuationState {

  Actuated = "actuated",

  Armed = "armed",

}

interface RigidBodyActuationThreshold {

  crosses: RigidBodyActuationCrossing;

  value: number;

}

interface RigidBodyActuationTrigger {

  readonly activeImpactCount: number;

  readonly body: cmp_physicsBody;

  readonly currentState: RigidBodyActuationState;

  readonly currentValue: number;

  dispose(): void;

  hasImpactContext(nowMs?: number): boolean;

  readonly id: string;

  readonly lastActuatedAtMs: number;

  readonly lastImpactAtMs: number;

  readonly lastImpactLabel: string;

  noteImpact(label?: string): this;

  onActuate(callback: (event: RigidBodyActuationEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onRearm(callback: (event: RigidBodyActuationEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  readonly options: Readonly<RigidBodyActuationTriggerOptions>;

  readonly previousValue: number | null;

  reset(): this;

  readonly state: ReadonlyEntityStateApi<WaveEntity, RigidBodyActuationState>;

}

interface RigidBodyActuationTriggerOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  actuateWhen: RigidBodyActuationThreshold;

  collisionFilter?: (event: CollisionEvent) => boolean;

  id?: string;

  impactWindowMs?: number;

  metric: RigidBodyActuationMetric;

  rearmWhen: RigidBodyActuationThreshold;

  requireImpact?: boolean;

  trackCollisionImpact?: boolean;

}

type RigidBodyContactPointInput = WavePointInput | RigidBodyInteractionHitInput | PhysicsBodyApplicationRegionInput;

type RigidBodyFrameConstantForceConfig = Omit<ConstantForceConfig, "contactPoint"> & { contactPoint?: WavePointInput; }

type RigidBodyFrameConstantForceOptions = ConstantForceOptions & { contactPoint?: WavePointInput; }

type RigidBodyFrameConstantTorqueConfig = ConstantTorqueConfig;

type RigidBodyFrameConstantTorqueOptions = ConstantTorqueOptions;

interface RigidBodyInteractionHitDataInput {

  readonly hitNormal?: Vector3Like;

  readonly hitPoint?: Vector3Like;

  readonly rayDirection?: Vector3Like;

  readonly worldHitLocation?: Vector3Like;

  readonly worldHitNormal?: Vector3Like;

}

type RigidBodyInteractionHitInput = RigidBodyInteractionHitDataInput | { readonly data: RigidBodyInteractionHitDataInput; }

interface RigidBodyJointConfig {

  axis?: DirectionInput;

  axisA?: DirectionInput;

  axisB?: DirectionInput;

  enableCollisions?: boolean;

  id?: string;

  limits?: AxisLimit[];

  maxAngle?: number;

  maxDistance?: number;

  minAngle?: number;

  minDistance?: number;

  motor?: RigidBodyJointMotorInput;

  ownLocalPivot?: Vector3Like;

  ownWorldPivot?: WavePointInput;

  perpAxisA?: DirectionInput;

  perpAxisB?: DirectionInput;

  sharedWorldPivot?: WavePointInput;

  spring?: SpringConfig;

  targetLocalPivot?: Vector3Like;

  targetWorldPivot?: WavePointInput;

  type?: RigidBodyJointType;

}

interface RigidBodyJointMotorInput {

  axis: ConstraintAxis;

  damping?: number;

  maxForce?: number;

  mode: MotorMode;

  stiffness?: number;

  target: number;

}

interface RigidBodyJointOptions {

  swapPivots?: boolean;

}

interface RigidBodyJointResult {

  constraintId: string | null;

  normalizedConfig: RigidBodyJointConfig;

}

type RigidBodyJointType = "ballAndSocket" | "hinge" | "lock" | "distance" | "sixDoF";

declare enum RigidBodyShapeType {

  Box = 0,

  Capsule = 2,

  Compound = 7,

  ConvexHull = 6,

  Cylinder = 3,

  Heightfield = 4,

  Mesh = 5,

  Sphere = 1,

}

declare enum RigidBodyType {

  Dynamic = 1,

  Kinematic = 2,

  Static = 0,

}

type RigIKHandleTarget = string | BodyPart;

type RigIKOptions = Omit<WaveRigIKIntent, "steps">;

type RigIKReachMode = WaveRigIKReachMode;

interface RigIKReachResult {

  bone?: WaveBone | undefined;

  bonesAffected?: number | undefined;

  error?: string | undefined;

  pose?: WavePose | undefined;

  skeleton?: any;

  success: boolean;

  clamped?: boolean;

  desiredWorldPosition?: Vector3;

  maxReach?: number;

  minReach?: number;

  reachableWorldPosition?: Vector3;

  rootWorldPosition?: Vector3;

  targetDistance?: number;

}

interface RigIKResult {

  bone?: WaveBone | undefined;

  bonesAffected?: number | undefined;

  error?: string | undefined;

  pose?: WavePose | undefined;

  skeleton?: any;

  success: boolean;

  errorDistance?: number;

  iterations?: number;

}

type RigIKStepCount = WaveRigIKStepCount;

interface RigPoseResult {

  bone?: WaveBone;

  bonesAffected?: number;

  error?: string;

  pose?: WavePose;

  skeleton?: unknown;

  success: boolean;

}

interface RippleEffectConfig {

  frequency?: number;

  maxDisplacement?: number;

  origin?: { u: number; v: number; }

  propagationSpeed?: number;

  spatialDecay?: number;

  temporalDecay?: number;

}

interface RiverOptions {

  corridor?: TerrainRiverCorridorRecipe;

  depth?: number;

  maxWidth?: number;

  minWidth?: number;

  seed?: number;

  smoothness?: number;

}

declare const ROCKET_PARTS: Readonly<{ readonly payloadFairing: "payloadFairing"; readonly crewCapsule: "crewCapsule"; readonly serviceModule: "serviceModule"; readonly guidanceUnit: "guidanceUnit"; readonly payloadAdapter: "payloadAdapter"; readonly escapeTower: "escapeTower"; readonly stage: "stage"; readonly interstage: "interstage"; readonly boosterSkirt: "boosterSkirt"; readonly baseNozzle: "baseNozzle"; readonly fin1: "fin1"; readonly fin2: "fin2"; readonly fin3: "fin3"; readonly fin4: "fin4"; }>;

interface RopeChainOptions {

  color?: ColorInput;

  constraintSpring?: SpringConfig;

  damping?: number;

  direction?: DirectionInput;

  distanceSlackRatio?: number;

  name?: string;

  nodeMass?: number;

  nodeRadius?: number;

  path?: WaveRopePathInput;

  pinEnd?: boolean;

  pinStart?: boolean;

  ropeRadius?: number;

  segmentLength?: number;

  segments?: number;

  startPosition?: WavePointInput;

}

type RotationComponent = "pitch" | "yaw" | "roll" | "bank";

interface RotationLockFlags {

  x: boolean;

  y: boolean;

  z: boolean;

}

declare enum RotationMode {

  FollowVelocity = "followVelocity",

  Independent = "independent",

  OrbitTarget = "orbitTarget",

  Turret = "turret",

}

interface RotationPanelOptions {

  decimals?: number | undefined;

  duration?: number | undefined;

  fontAsset?: string | undefined;

  fontSize?: number | undefined;

  labelOffset3D?: any;

  labelOffset3DSpace?: "world" | "local" | undefined;

  textColor?: any;

  updateMode?: DevToolUpdateMode | undefined;

  verticalOffset?: number | undefined;

  components?: RotationComponent | RotationComponent[];

}

interface RotationParameters {

  bankAngle: number;

  gamepadSensitivity: number;

  gyroSensitivity: number;

  invertPitch: boolean;

  invertYaw: boolean;

  maxPitch: number;

  minPitch: number;

  mouseSensitivity: number;

  pitchRate: number;

  rollRate: number;

  useRadians: boolean;

  yawRate: number;

}

type RuntimeAreaLightEmissionTextureInput = AreaLightEmissionTextureInput | unknown;

type RuntimeBoneRotationAxis = "x" | "y" | "z" | Vector3Like;

interface RuntimeBoneTransform {

  position?: Vector3Like;

  rotation?: QuaternionLike;

  scaling?: Vector3Like;

}

type RuntimeDomainId = OpaqueString<typeof runtimeDomainIdBrand>;

declare const runtimeDomainIdBrand: unique symbol;

interface SampledRgbaColor {

  a: number;

  b: number;

  g: number;

  r: number;

}

interface SampledTextureAssetValue {

  readonly kind: "sample";

  readonly texture: unknown;

}

interface SaveIntoModelAssetOptions {

  fileName?: string;

  format?: ModelExportFormat;

  meshCompression?: ModelExportMeshCompression;

  skipDownload?: boolean;

  textureCompression?: boolean | ModelExportTextureCompressionOptions;

}

interface SaveIntoModelAssetResult {

  blob: Blob | null;

  error?: string;

  fileName: string;

  success: boolean;

}

interface SaveMaterialAssetOptions {

  readonly bake?: WaveMaterialBakeOptions;

  readonly fileName?: string;

  readonly id: string;

  readonly materialOptions?: SaveMaterialOptionsState;

  readonly materialType?: ProjectAuthoredMaterialType;

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly onProgress?: SaveMaterialProgressCallback;

  readonly signal?: AbortSignal;

  readonly splat?: MaterialSplatDefinition;

  readonly target?: unknown;

  readonly textureSlots?: SaveMaterialTextureSlots;

}

interface SaveMaterialAssetResult {

  readonly assetName?: string;

  readonly blob: Blob | null;

  readonly error?: string;

  readonly fileName: string;

  readonly manifest?: WaveMaterialPackageManifest;

  readonly success: boolean;

  readonly warnings?: readonly string[];

}

type SaveMaterialOptionsState = ProjectPBRMaterialOptions | ProjectStandardMaterialOptions;

type SaveMaterialProgressCallback = (event: SaveMaterialProgressEvent) => void;

interface SaveMaterialProgressEvent {

  readonly detail?: string;

  readonly label: string;

  readonly phase: "capture" | "embed-textures" | "capture-surface-state" | "package";

  readonly progress: number;

}

type SaveMaterialTextureSlots = ProjectPBRMaterialTextureSlots | ProjectStandardMaterialTextureSlots;

interface SaveVertexAnimationAssetResult {

  readonly assetName?: string;

  readonly blob?: Blob;

  readonly error?: string;

  readonly fileName?: string;

  readonly json?: string;

  readonly success: boolean;

}

declare const SCAFFOLD_PARTS: Readonly<{ readonly foundation: "foundation"; readonly footPlate: "footPlate"; readonly towerSegment: "towerSegment"; readonly towerLattice: "towerLattice"; readonly servicePlatform: "servicePlatform"; readonly serviceBridge: "serviceBridge"; readonly ladder: "ladder"; }>;

interface ScaleModifier {

  factor: number | { x?: number; y?: number; z?: number; }

  type: ModifierType.Scale;

}

interface SceneAssetAccess {

  readonly arena: AssetArena;

  readonly generation: number;

  isCurrent(): boolean;

  readonly key: string;

  readonly lifecycle: SceneAssetLifecycle;

  readonly lifetime: "setup" | "main";

  readonly sceneId: string;

}

declare class SceneAssetDeltaPlan {

  readonly critical: readonly CompiledSceneAssetPlanEntry[];

  readonly entries: readonly CompiledSceneAssetPlanEntry[];

  readonly streaming: readonly CompiledSceneAssetPlanEntry[];

  constructor(entries: readonly CompiledSceneAssetPlanEntry[], critical: readonly CompiledSceneAssetPlanEntry[], streaming: readonly CompiledSceneAssetPlanEntry[], previous: SceneAssetPlanState, removals: readonly AssetIdentity[]);

  readonly kind: "delta";

  readonly previous: SceneAssetPlanState;

  readonly removals: readonly AssetIdentity[];

}

interface SceneAssetFacadeConfiguration {

  readonly baseUrl?: string;

  readonly manifest: readonly string[];

}

declare class SceneAssetLifecycle implements AssetDeclarationLookup {

  constructor(_runtime: AssetRuntime, _sceneId: string, _runtimeDomain: RuntimeDomainId, requireRendererScene?: () => unknown);

  acceptMainGeneration(): void;

  beginMainGeneration(generation: number): SceneAssetAccess;

  beginSetupLifetime(): SceneAssetAccess;

  bindAuthoredAnimation(owner: SceneAssetAccess, ref: AssetRef<"animation"> | ExactAssetRef<"animation">, consumerId: string): WaveSceneAnimationBinding;

  bindAuthoredAudio(owner: SceneAssetAccess, ref: AssetRef<"audio">, consumerId: string): WaveSceneAudioBinding;

  bindAuthoredData(owner: SceneAssetAccess, ref: AssetRef<"data">, consumerId: string): WaveSceneDataBinding;

  bindAuthoredFont(owner: SceneAssetAccess, ref: AssetRef<"font"> | ExactAssetRef<"font">, consumerId: string): WaveSceneFontBinding;

  bindAuthoredFxDefinition(owner: SceneAssetAccess, ref: AssetRef<"data"> | ExactAssetRef<"data">, consumerId: string): WaveSceneFxDefinitionBinding;

  bindAuthoredMaterial(owner: SceneAssetAccess, ref: AssetRef<"material">, consumerId: string): WaveSceneMaterialBinding;

  bindAuthoredModel(owner: SceneAssetAccess, ref: AssetRef<"model">, consumerId: string, intent?: ModelBindingIntent): WaveSceneModelBinding;

  bindAuthoredTexture(owner: SceneAssetAccess, ref: AssetRef<"texture">, consumerId: string, intent?: TextureBindingIntent): WaveSceneTextureBinding;

  bindAuthoredVideo(owner: SceneAssetAccess, ref: AssetRef<"video"> | ExactAssetRef<"video">, consumerId: string, intent?: VideoBindingIntent): WaveSceneVideoBinding;

  bindDeclaredFont(ref: AssetRef<"font">, consumerId: string): WaveSceneFontBinding;

  bindDeclaredTexture(ref: AssetRef<"texture">, consumerId: string, intent?: TextureBindingIntent): WaveSceneTextureBinding;

  bootstrap(plan: SceneDeclaredAssetPlan): Promise<readonly ExactAssetRef<AssetFamily>[]>;

  commitAdditionalDeclaredPlan(plan: SceneDeclaredAssetPlan, contribution?: SceneDeclaredContributionNamespace): Promise<readonly ExactAssetRef<AssetFamily>[]>;

  commitAuthoredDefinitionBundle(owner: SceneAssetAccess, definitions: readonly AssetDefinition[]): readonly ExactAssetRef<AssetFamily>[];

  commitAuthoredDefinitions<F extends AssetFamily>(owner: SceneAssetAccess, definitions: readonly AssetDefinition<F>[], family: F): readonly ExactAssetRef<F>[];

  createSynchronousFacade(getConfiguration: () => SceneAssetFacadeConfiguration | undefined): WaveSceneAssetsFacade;

  deriveModelMasterBindingProjection(exactRef: ExactAssetRef<"model">, selector: ModelBindingProjection): ModelBindingProjection;

  discardMainGeneration(): void;

  dispose(): void;

  endMainGeneration(): void;

  endSetupLifetime(): void;

  expectedGeneratedModelRef(owner: SceneAssetAccess, input: WaveModelInput, dependencies?: readonly AssetRef[]): ExactAssetRef<"model">;

  getDescriptor<F extends AssetFamily>(identity: AssetIdentity<F>): AssetDescriptor<"animation" | "audio" | "data" | "font" | "material" | "model" | "texture" | "video"> | null;

  getSerialDeclaration(ref: ExactAssetRef): SerializedAssetDeclaration | null;

  hasCurrentAuthoredContribution(owner: SceneAssetAccess, identity: AssetIdentity): boolean;

  get hasMainGeneration(): boolean;

  get mainAccess(): SceneAssetAccess;

  ownsAuthoredOwner(owner: SceneAssetAccess): boolean;

  preserveMainGeneration(): void;

  publishDeclaredDefinitionsNow(definitions: readonly AssetDefinition[]): readonly ExactAssetRef<AssetFamily>[];

  publishFxDefinitionsNow(owner: SceneAssetAccess, definitions: readonly AssetDefinition[]): ExactAssetRef<"data">;

  publishGeneratedModelsNow(owner: SceneAssetAccess, inputs: readonly WaveModelInput[]): readonly ExactAssetRef<"model">[];

  readCommittedMedia<F extends "audio" | "video" | "animation" | "data">(identity: AssetIdentity<F>): CommittedMediaResolution<F> | null;

  readCommittedModel(identity: AssetIdentity<"model">): CommittedModelResolution | null;

  readCommittedObjectModel(exactRef: ExactAssetRef<"model">): WaveModelObjectModel | null;

  readModelCommitGeneration(): number;

  requireMainBinding(): SceneAssetAccess;

  requireSetupBinding(): SceneAssetAccess;

  resolveCommittedExactModelRequirement(source: ModelConsumerSource): CommittedExactModelRequirement;

  resolveCurrentRef(ref: AssetRef): ExactAssetRef | null;

  resolveOrPublishGeneratedModel(owner: SceneAssetAccess, input: WaveModelInput, dependencies?: readonly AssetRef[], expectedRef?: ExactAssetRef<"model">): ExactAssetRef<"model">;

  resolveOrPublishGeneratedModelDefinition(owner: SceneAssetAccess, definition: AssetDefinition<"model">, expectedRef?: ExactAssetRef<"model">): ExactAssetRef<"model">;

  sealMainGeneration(): void;

  get setupAccess(): SceneAssetAccess;

  videoNativeDiagnostics(): VideoFiniteRuntimePoolDiagnostics;

}

declare class SceneAssetPlan {

  constructor(entries: readonly CompiledSceneAssetPlanEntry[], critical: readonly CompiledSceneAssetPlanEntry[], streaming: readonly CompiledSceneAssetPlanEntry[]);

  readonly critical: readonly CompiledSceneAssetPlanEntry[];

  readonly entries: readonly CompiledSceneAssetPlanEntry[];

  readonly streaming: readonly CompiledSceneAssetPlanEntry[];

}

type SceneAssetPlanDeclaration = { readonly kind: "definition"; readonly definition: AssetDefinition; } | { readonly kind: "source"; readonly request: AssetLoadRequest; }

interface SceneAssetPlanDeltaInput {

  readonly removals?: readonly AssetIdentity[];

  readonly upserts: readonly SceneAssetPlanEntryInput[];

}

interface SceneAssetPlanEntryInput {

  readonly declaration: SceneAssetPlanDeclaration;

  readonly lifetime: AssetArenaKind;

  readonly priority: AssetPlanPriority;

}

declare class SceneAssetPlanState {

  constructor(entries: ReadonlyMap<AssetIdentityKey, SceneAssetPlanStateEntry>);

  get(identity: AssetIdentity): SceneAssetPlanStateEntry | null;

}

interface SceneAssetPlanStateEntry {

  readonly descriptor: AssetDescriptor;

  readonly input: SceneAssetPlanEntryInput;

  readonly lifetime: AssetArenaKind;

  readonly priority: AssetPlanPriority;

  readonly reuseToken: AssetDefinition | string;

  readonly semantic: NormalizedAssetBody;

  readonly spec: ResolvedAssetSpec;

}

interface SceneDeclaredAssetPlan {

  readonly closureValidated?: true;

  readonly definitions?: readonly AssetDefinition<AssetFamily>[];

  readonly loweredDependencies?: readonly LoweredAssetDependency[];

  readonly sources?: readonly AssetLoadRequest<AssetFamily>[];

}

type SceneDeclaredContributionNamespace = "scene" | "world-plan";

type SceneFacadeAssetFamily = "data" | "texture" | "material";

declare enum SceneLifecycle {

  COLD_MAIN = "COLD_MAIN",

  COLD_SETUP = "COLD_SETUP",

  CREATED = "CREATED",

  DISPOSED = "DISPOSED",

  HOT_MAIN = "HOT_MAIN",

  HOT_SETUP = "HOT_SETUP",

  RETIRED = "RETIRED",

  RUNNING = "RUNNING",

}

interface SceneLoadingDownloadProgress {

  readonly loadedBytes: number;

  readonly totalBytes?: number | undefined;

  readonly elapsedMs?: number;

  readonly estimatedRemainingMs?: number;

  readonly fromCache?: boolean;

  readonly path?: string;

}

interface SceneLoadingProgressEvent {

  readonly progress: Readonly<LoadingProgress>;

  readonly visible: boolean;

}

type SceneLoadingProgressListener = (event: SceneLoadingProgressEvent) => void;

type SceneMainFunction<TEngine extends unknown = unknown> = (context: SceneMainContext<TEngine>) => Promise<void> | void;

interface SceneMediaCaptureDevicePlan {

  config?: CaptureConfig;

  device: SensingDevice.Audio | SensingDevice.Vision;

}

interface SceneMediaCapturePlan {

  autoStartAfterConsent?: boolean;

  devices: SceneMediaCaptureDevicePlan[];

}

interface SceneOcclusionConfig {

  defaults: Required<Pick<OcclusionCullingOptions, "strategy" | "algorithm" | "retryCount">>;

  enabled: boolean;

  excludeNames: string[];

  maxDistance: number;

  maxQueriesPerFrame: number;

  minScreenCoverage: number;

  minVertexCount: number;

  strictForStatic: boolean;

}

type SceneSetupFunction<TEngine extends unknown = unknown> = (context: SceneSetupContext<TEngine>) => Promise<void> | void;

interface SceneTransitionOptions {

  color?: ColorInput;

  diagonalOrigin?: TransitionCorner;

  duration?: number;

  ease?: WaveEasing;

  edgeSoftness?: number;

  maskMode?: TransitionMaskMode;

  progressCurve?: WaveValueCurveInput;

}

declare class ScopedObservationBuilder<TEntity extends BehaviorObservationRuntimeHost, TState = unknown> implements WaveScopedObservationBuilder<TEntity, TState> {

  constructor(entity: TEntity, states: readonly TState[], stateScope?: ScopedObservationStateScope);

  dispose(): void;

  on(selector: NumericSelector<TEntity>): NumericObservationSource<TEntity>;

  onChangeRate(selectorOrSource: NumericObservationInput<TEntity>): RateObservationSource<TEntity>;

  onDeclineRate(selectorOrSource: NumericObservationInput<TEntity>): RateObservationSource<TEntity>;

  onGrowthRate(selectorOrSource: NumericObservationInput<TEntity>): RateObservationSource<TEntity>;

  registerDefinition(definition: ObservationDefinition<TEntity>): ObservationHandle;

  unregisterDefinition(entryId: string): void;

  when(selector: BooleanSelector<TEntity>): BooleanObservationSource<TEntity>;

}

type ScopedObservationStateScope<TLane = unknown> = { kind: "primary"; } | { kind: "system"; lane: TLane; key: string; }

interface ScreenLayerOpts {

  blend?: "additive" | "alpha" | "multiply";

  depthWrite?: boolean;

  distance?: number;

  emissiveIntensity?: number;

  flipbook?: { columns: number; rows: number; frameRate: number; startFrame?: number; playMode?: "once" | "loop"; interpolation?: "none" | "crossfade"; }

  ignoreSceneLighting?: boolean;

  opacity?: number;

  texture: string;

}

declare enum ScreenMediaFit {

  Cover = "cover",

  Stretch = "stretch",

}

interface ScreenMetrics {

  readonly pixelScaleX: number;

  readonly pixelScaleY: number;

  readonly rawDevicePixelRatio: number;

  readonly renderHeight: number;

  readonly renderWidth: number;

  readonly screenHeight: number;

  readonly screenWidth: number;

}

type ScreenPlaneDirectionInput = Direction.Left | Direction.Right | Direction.Up | Direction.Down | Direction.X | Direction.Y | Readonly<SerializableVector2>;

interface ScreenRect {

  readonly height: number;

  readonly width: number;

  readonly x: number;

  readonly y: number;

}

interface ScreenRenderView {

  readonly cameraId: string;

  readonly index: number;

  readonly isPrimary: boolean;

  readonly layoutRevision: number;

  readonly screen: CanvasPixelRect;

  readonly viewport: CanvasNormalizedViewport;

}

interface ScreenShakeOptions {

  durationSeconds?: number;

  envelope?: WaveValueCurveInput;

  frequency?: number;

  intensity?: number;

  maxOffsetPixels?: number;

  maxRotationDegrees?: number;

  maxZoom?: number;

  seed?: number;

}

interface SdfAtlasFontBindingValue {

  readonly glyphs: readonly SdfGlyphMetric[];

  readonly kerning: readonly SdfKerningPair[];

  readonly kind: "sdfAtlas";

  readonly metrics: SdfAtlasMetrics;

  readonly ref: ExactAssetRef<"font">;

  readonly sourceFontRef: ExactAssetRef<"font">;

  readonly texture: unknown;

  readonly textureRef: ExactAssetRef<"texture">;

}

interface SdfAtlasMetrics {

  readonly ascender: number;

  readonly atlasHeight: number;

  readonly atlasWidth: number;

  readonly descender: number;

  readonly distanceRange: number;

  readonly emSize: number;

  readonly lineHeight: number;

}

interface SdfBlendOptions {

  readonly label?: string | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly smoothness?: number;

}

interface SdfBoxOptions {

  readonly label?: string | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly center?: Vector3Like;

  readonly size: Vector3Like;

}

interface SdfCapsuleOptions {

  readonly label?: string | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly end: Vector3Like;

  readonly radius: number;

  readonly start: Vector3Like;

}

interface SdfClipPlaneOptions {

  readonly label?: string | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly smoothness?: number;

  readonly y: number;

}

interface SdfEllipsoidOptions {

  readonly label?: string | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly center?: Vector3Like;

  readonly radii: Vector3Like;

}

interface SdfGlyphMetric {

  readonly advance: number;

  readonly atlasBounds: { readonly left: number; readonly bottom: number; readonly right: number; readonly top: number; }

  readonly id: string;

  readonly planeBounds: { readonly left: number; readonly bottom: number; readonly right: number; readonly top: number; }

}

interface SdfImplicitAsset {

  dispose?: (() => void) | undefined;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly units: DistanceFieldUnits3D;

  readonly bounds: DistanceFieldBounds3D;

  gradient?: DistanceFieldGradientSampler3D;

  readonly isoLevel: number;

  readonly kind: "sdfImplicit";

  sample: DistanceFieldSampler3D;

}

interface SdfKerningPair {

  readonly amount: number;

  readonly left: string;

  readonly right: string;

}

interface SdfRoundedBoxOptions {

  readonly center?: any;

  readonly label?: string | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly size: any;

  readonly radius?: number;

}

interface SdfScalarField3DAsset {

  dispose?: (() => void) | undefined;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly units: DistanceFieldUnits3D;

  readonly bounds: DistanceFieldBounds3D;

  readonly cellSize: number;

  gradient?: DistanceFieldGradientSampler3D;

  readonly gridSize: Readonly<{ x: number; y: number; z: number; }>;

  readonly isoLevel: number;

  readonly kind: "sdfScalarField3D";

  sample: DistanceFieldSampler3D;

  readonly values: Float32Array;

}

interface SdfSphereOptions {

  readonly label?: string | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly center?: Vector3Like;

  readonly radius: number;

}

type SdfSurfaceBlendOptions = Pick<SdfBlendOptions, "smoothness">;

type SdfSurfaceBoxOptions = Pick<SdfBoxOptions, "center" | "size">;

interface SdfSurfaceBoxRecipe {

  readonly center?: any;

  readonly size: any;

  readonly kind: "box";

}

type SdfSurfaceCapsuleOptions = Pick<SdfCapsuleOptions, "start" | "end" | "radius">;

interface SdfSurfaceCapsuleRecipe {

  readonly end: any;

  readonly radius: number;

  readonly start: any;

  readonly kind: "capsule";

}

type SdfSurfaceClipOptions = Pick<SdfClipPlaneOptions, "y" | "smoothness">;

interface SdfSurfaceClipRecipe {

  readonly smoothness?: number | undefined;

  readonly y: number;

  readonly kind: "clipBelow" | "clipAbove" | "flattenBottom";

  readonly shape: SdfSurfaceRecipeConfig;

}

type SdfSurfaceEllipsoidOptions = Pick<SdfEllipsoidOptions, "center" | "radii">;

interface SdfSurfaceEllipsoidRecipe {

  readonly center?: any;

  readonly radii: any;

  readonly kind: "ellipsoid";

}

interface SdfSurfaceFilledPathOptions {

  readonly samples?: number | undefined;

  readonly boundarySmoothing?: number;

  readonly centerAlongNormal?: number;

  readonly cornerSmoothing?: number;

  readonly edgeRadius?: number;

  readonly edgeRadiusProgression?: WaveValueCurveInput;

  readonly height: number;

  readonly heightProgression?: WaveValueCurveInput;

  readonly normal?: DirectionInput;

  readonly smoothness?: number;

}

interface SdfSurfaceFilledPathRecipe {

  readonly smoothness?: number | undefined;

  readonly boundarySmoothing?: number;

  readonly centerAlongNormal?: number;

  readonly cornerSmoothing?: number;

  readonly edgeRadius?: number;

  readonly edgeRadiusProgression?: WaveValueCurveSpec;

  readonly height: number;

  readonly heightProgression?: WaveValueCurveSpec;

  readonly kind: "filledPath";

  readonly normal: SerializedDirectionInput;

  readonly points: readonly Vector3Like[];

}

type SdfSurfacePathCap = "round" | "flat";

type SdfSurfacePathInput = WaveProceduralPathInput;

interface SdfSurfacePathLobesOptions {

  readonly samples?: number | undefined;

  readonly radii: Vector3Like;

  readonly scaleProgression?: WaveValueCurveInput;

  readonly smoothness?: number;

}

interface SdfSurfacePathLobesRecipe {

  readonly smoothness?: number | undefined;

  readonly kind: "lobesAlong";

  readonly points: readonly Vector3Like[];

  readonly radii: Vector3Like;

  readonly scaleProgression?: WaveValueCurveSpec;

}

interface SdfSurfacePathRepeatOptions {

  readonly samples?: number | undefined;

  readonly smoothness?: number | undefined;

  readonly closed?: boolean;

}

interface SdfSurfacePathRepeatSample {

  readonly index: number;

  readonly nextPoint?: Vector3Like;

  readonly point: Vector3Like;

  readonly previousPoint?: Vector3Like;

  readonly t: number;

}

type SdfSurfaceRecipe = SdfSurfaceRecipeConfig;

interface SdfSurfaceRecipeBuilder {

  box(options: SdfSurfaceBoxOptions): SdfSurfaceBoxRecipe;

  capsule(options: SdfSurfaceCapsuleOptions): SdfSurfaceCapsuleRecipe;

  clipAbove(shape: SdfSurfaceRecipeInput, options: SdfSurfaceClipOptions): SdfSurfaceClipRecipe;

  clipBelow(shape: SdfSurfaceRecipeInput, options: SdfSurfaceClipOptions): SdfSurfaceClipRecipe;

  ellipsoid(options: SdfSurfaceEllipsoidOptions): SdfSurfaceEllipsoidRecipe;

  filledPath(path: SdfSurfacePathInput, options: SdfSurfaceFilledPathOptions): SdfSurfaceFilledPathRecipe;

  flattenBottom(shape: SdfSurfaceRecipeInput, options: SdfSurfaceClipOptions): SdfSurfaceClipRecipe;

  intersection(shapes: readonly SdfSurfaceRecipeInput[], options?: SdfSurfaceBlendOptions): SdfSurfaceUnionRecipe;

  lobesAlong(path: SdfSurfacePathInput, options: SdfSurfacePathLobesOptions): SdfSurfacePathLobesRecipe;

  puffPath(path: SdfSurfacePathInput, options: SdfSurfaceFilledPathOptions): SdfSurfaceFilledPathRecipe;

  puffyShape(path: SdfSurfacePathInput, options: SdfSurfaceFilledPathOptions): SdfSurfaceFilledPathRecipe;

  repeatAlong(path: SdfSurfacePathInput, build: (sample: SdfSurfacePathRepeatSample) => SdfSurfaceRecipeInput, options?: SdfSurfacePathRepeatOptions): SdfSurfaceUnionRecipe;

  roundedBox(options: SdfSurfaceRoundedBoxOptions): SdfSurfaceRoundedBoxRecipe;

  roundedFootprint(path: SdfSurfacePathInput, options: SdfSurfaceFilledPathOptions): SdfSurfaceFilledPathRecipe;

  smoothIntersection(shapes: readonly SdfSurfaceRecipeInput[], options?: SdfSurfaceBlendOptions): SdfSurfaceUnionRecipe;

  smoothUnion(shapes: readonly SdfSurfaceRecipeInput[], options?: SdfSurfaceBlendOptions): SdfSurfaceUnionRecipe;

  smoothUnionEllipsoids(shapes: readonly SdfSurfaceEllipsoidOptions[], options?: SdfSurfaceBlendOptions): SdfSurfaceUnionRecipe;

  softFilledPath(path: SdfSurfacePathInput, options: SdfSurfaceFilledPathOptions): SdfSurfaceFilledPathRecipe;

  sphere(options: SdfSurfaceSphereOptions): SdfSurfaceSphereRecipe;

  strokeAlong(path: SdfSurfacePathInput, options: SdfSurfaceTubeAlongOptions): SdfSurfaceTubeAlongRecipe;

  subtract(base: SdfSurfaceRecipeInput, shape: SdfSurfaceRecipeInput | readonly SdfSurfaceRecipeInput[]): SdfSurfaceSubtractionRecipe;

  tubeAlong(path: SdfSurfacePathInput, options: SdfSurfaceTubeAlongOptions): SdfSurfaceTubeAlongRecipe;

  union(shapes: readonly SdfSurfaceRecipeInput[], options?: SdfSurfaceBlendOptions): SdfSurfaceUnionRecipe;

}

type SdfSurfaceRecipeConfig = SdfSurfaceSphereRecipe | SdfSurfaceEllipsoidRecipe | SdfSurfaceBoxRecipe | SdfSurfaceRoundedBoxRecipe | SdfSurfaceCapsuleRecipe | SdfSurfaceTubeAlongRecipe | SdfSurfacePathLobesRecipe | SdfSurfaceFilledPathRecipe | SdfSurfaceUnionRecipe | SdfSurfaceSubtractionRecipe | SdfSurfaceClipRecipe;

type SdfSurfaceRecipeInput = SdfSurfaceRecipeConfig;

type SdfSurfaceRoundedBoxOptions = Pick<SdfRoundedBoxOptions, "center" | "size" | "radius">;

interface SdfSurfaceRoundedBoxRecipe {

  readonly center?: any;

  readonly radius?: number | undefined;

  readonly size: any;

  readonly kind: "roundedBox";

}

type SdfSurfaceSphereOptions = Pick<SdfSphereOptions, "center" | "radius">;

interface SdfSurfaceSphereRecipe {

  readonly center?: any;

  readonly radius: number;

  readonly kind: "sphere";

}

interface SdfSurfaceSubtractionRecipe {

  readonly base: SdfSurfaceRecipeConfig;

  readonly kind: "subtract";

  readonly shape: SdfSurfaceRecipeConfig | readonly SdfSurfaceRecipeConfig[];

}

interface SdfSurfaceTubeAlongOptions {

  readonly samples?: number | undefined;

  readonly cap?: SdfSurfacePathCap;

  readonly radius: number;

  readonly radiusProgression?: WaveValueCurveInput;

}

interface SdfSurfaceTubeAlongRecipe {

  readonly cap?: SdfSurfacePathCap;

  readonly kind: "tubeAlong";

  readonly points: readonly Vector3Like[];

  readonly radius: number;

  readonly radiusProgression?: WaveValueCurveSpec;

}

interface SdfSurfaceUnionRecipe {

  readonly smoothness?: number | undefined;

  readonly kind: "union" | "smoothUnion" | "intersection" | "smoothIntersection";

  readonly shapes: readonly SdfSurfaceRecipeConfig[];

}

declare class SegmentBuilder {

  along(axis: DirectionInput): this;

  apply(): SegmentResult;

  capCuts(cap?: boolean): this;

  cut(axis: DirectionInput, count: number): this;

  cutAt(axis: DirectionInput, ...positions: number[]): this;

  forceMergeMesh(force?: boolean): this;

  intoFree3DObjects(): this;

  intoParts(options?: CreatePartsOptions): this;

  intoPieces(count: number): this;

  withCuts(...positions: number[]): this;

  withInteriorColor(color: FragInteriorColorInput): this;

}

interface SegmentOptions {

  axis: DirectionInput;

  capCuts?: boolean;

  count: number;

  cuts?: number[];

  interiorColor?: FragInteriorColorInput;

}

interface SegmentResult {

  error?: string;

  originalMesh?: unknown;

  parts?: unknown[];

  segments: unknown[];

  success: boolean;

}

type SemanticDirection = Direction.Left | Direction.Right | Direction.Up | Direction.Down | Direction.Forward | Direction.Backward;

type SemanticWaveSurface = WaveSurface.Left | WaveSurface.Right | WaveSurface.Up | WaveSurface.Down | WaveSurface.Forward | WaveSurface.Backward;

interface SensingCallbackOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  name?: string;

  once?: boolean;

  priority?: number;

}

interface SensingInputSimulationHandle {

  cancel(): void;

  isActive(): boolean;

  release(): void;

}

interface SensingKeyboardSimulationOptions {

  readonly repeat?: boolean;

}

interface SensingPointerSimulationOptions {

  readonly pointerId?: number;

  readonly pressure?: number;

  readonly tilt?: readonly [number, number];

  readonly twist?: number;

}

type SensingSimulationPointInput = WaveScreenPointRef | { readonly x: number; readonly y: number; }

interface SensingSimulationTouchHandle {

  cancel(): void;

  isActive(): boolean;

  release(): void;

  moveTo(point: SensingSimulationPointInput, options?: SensingTouchSimulationOptions): void;

  readonly touchId: number;

}

interface SensingTouchSimulationOptions {

  readonly pressure?: number;

  readonly radius?: readonly [number, number];

  readonly tilt?: readonly [number, number];

  readonly touchId?: number;

  readonly twist?: number;

}

interface SensingWheelSimulationOptions {

  readonly deltaMode?: number;

}

type SerializableAssetRecipe = SerializableDataValue;

type SerializableDataPrimitive = string | number | boolean | null;

type SerializableDataValue = SerializableDataPrimitive | readonly SerializableDataValue[] | { readonly [key: string]: SerializableDataValue; }

interface SerializableFacetypeFontData {

  readonly ascender?: number;

  readonly boundingBox: { readonly yMin: number; readonly xMin: number; readonly yMax: number; readonly xMax: number; }

  readonly descender?: number;

  readonly familyName?: string;

  readonly glyphs: Readonly<Record<string, SerializableFacetypeGlyph>>;

  readonly original_font_information?: SerializableDataValue;

  readonly resolution: number;

  readonly underlinePosition?: number;

  readonly underlineThickness: number;

}

interface SerializableFacetypeGlyph {

  readonly [key: string]: SerializableDataValue | undefined;

  readonly ha?: number;

  readonly o?: string;

  readonly x_max?: number;

  readonly x_min?: number;

}

interface SerializableQuaternion {

  w: number;

  x: number;

  y: number;

  z: number;

}

interface SerializableVector2 {

  x: number;

  y: number;

}

interface SerializableVector3 {

  x: number;

  y: number;

  z: number;

}

type SerializedAssetDeclaration = { readonly kind: "source"; readonly descriptor: AssetDescriptor; readonly source: AssetSourceLocator; readonly sourceFormat: string; readonly decoderVersion: string; readonly decodeOptions?: SerializableDataValue; readonly expectedRef?: ExactAssetRef; readonly declaredDependencies?: readonly AssetRef[]; } | { readonly kind: "definition"; readonly definition: AssetDefinition; readonly expectedRef?: ExactAssetRef; }

interface SerializedCall {

  args: unknown[];

  method: string;

}

interface SerializedDirectionBlendTerm {

  readonly direction: SerializedDirectionInput;

  readonly weight: number;

}

type SerializedDirectionInput = Direction | SerializedDirectionVector | { readonly blend: readonly SerializedDirectionBlendTerm[]; } | { readonly randomInCone: { readonly axis: SerializedDirectionInput; readonly cosTheta: number; readonly sinTheta: number; readonly azimuthRadians: number; }; } | { readonly randomOnPlane: { readonly normal: SerializedDirectionInput; readonly cosPhi: number; readonly sinPhi: number; }; } | { readonly fan: { readonly axis: SerializedDirectionInput; readonly planeNormal: SerializedDirectionInput; readonly degrees: number; }; }

type SerializedDirectionVector = Readonly<SerializableVector3>;

interface SerializedVertexAnimationAsset {

  readonly data: SerializedVertexAnimationData;

  readonly encoding: VertexAnimationJSONEncoding;

  readonly format: typeof WAVE_VERTEX_ANIMATION_JSON_FORMAT;

  readonly fps: number;

  readonly layout?: VertexAnimationAssetLayout;

  readonly meshMorph?: MeshMorphVertexAnimationInfo;

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly name: string;

  readonly ranges: readonly VATAnimationRange[];

  readonly targetMeshName?: string;

  readonly targetModel?: string;

  readonly totalFrames: number;

  readonly version: typeof WAVE_VERTEX_ANIMATION_JSON_VERSION;

  readonly vertexCount: number;

}

interface SerializedVertexAnimationData {

  readonly height: number;

  readonly vertexData: string;

  readonly width: number;

}

interface SetBonePoseOptions {

  space?: SkeletonTransformSpace;

}

interface SetPbrModifierOptions {

  readonly enabled?: boolean;

  readonly inputBindings?: WavePbrModifierInputBindings;

  readonly order?: number;

  readonly parameters?: WavePbrModifierParameterValues;

}

type ShaderUniformTypeHelper<TType extends WaveShaderUniformType> = { (defaultValue: WaveShaderUniformValue<TType>): WaveShaderUniformSpec<TType>; (name: string, options?: WaveShaderUniformOptions<TType>): WaveShaderUniformDefinition<TType>; }

type ShadowFilterMode = "none" | "poisson" | "pcf" | "pcss" | "esm" | "closeEsm";

type SharedAnimationRigSpawnBuilder<Self> = Omit<Self, "place"> & { place(): WaveGroup<waveInstanceMesh>; }

interface SharpenOptions {

  colorAmount?: number;

  edgeAmount?: number;

}

interface ShockwaveOpts {

  anchorOffset?: Partial<Vector3Like>;

  blend?: PresetBillboardOpts["blend"];

  color?: ColorLike;

  colorNoise?: number;

  durationSeconds?: number;

  dust?: ShockwaveParticleLayerOpts | false;

  flash?: ShockwaveParticleLayerOpts | false;

  glow?: FxGlowConfig;

  intensity?: NumLike;

  normal?: DirectionInput;

  radius?: number;

  rimIntensity?: number;

  secondaryColor?: ColorLike;

  thickness?: number;

  upHint?: DirectionInput;

}

type ShockwaveParticleLayerOpts = Omit<ImpactBurstOpts, "style"> & { annulus?: AnnulusSpawnOpts | false; }

interface SimpleGeometryOwnershipDiagnostics {

  consumerCreated?(): void;

  consumerDisposed?(): void;

  geometryCopied?(): void;

  localTopologySwapped?(): void;

}

interface SimpleGeometryOwnershipFailureInjection {

  afterAttachBeforeStateCommit?(): void;

  afterCopyBeforeConsumerSwap?(): void;

  beforeConsumerSwap?(): void;

  beforeDetachedGeometryCopy?(): void;

  beforePreparedCleanup?(): void;

  beforeTopologySwap?(): void;

  duringMakeGeometryUnique?(): void;

}

type SimpleGeometryOwnershipOrigin = "resetSimple" | "resetStructuredOneMesh" | "legacyOneMesh";

type SingleContourGeometrySourceInput = wavePath | waveDisc | wavePlane | wavePolygon;

interface SixDoFConfig {

  axisA?: DirectionInput | undefined;

  axisB?: DirectionInput | undefined;

  enableCollisions?: boolean | undefined;

  limits?: AxisLimit[] | undefined;

  motors?: MotorConfig[] | undefined;

  perpAxisA?: DirectionInput | undefined;

  perpAxisB?: DirectionInput | undefined;

  pivotA?: any;

  pivotB?: any;

  axisFriction?: readonly AxisFriction[];

  type: ConstraintType.SixDoF;

}

declare enum SkeletonBoneFilterMode {

  AllIncludingHelpers = "allIncludingHelpers",

  DeformAndLeafTips = "deformAndLeafTips",

  DeformOnly = "deformOnly",

  SemanticOnly = "semanticOnly",

}

declare enum SkeletonDisplayMode {

  Lines = "lines",

  SphereAndSpurs = "sphereAndSpurs",

  Spheres = "spheres",

}

declare enum SkeletonTransformSpace {

  Local = "local",

  World = "world",

}

interface SkeletonViewerOptions {

  duration?: number | undefined;

  updateMode?: DevToolUpdateMode | undefined;

  autoUpdateBonesMatrices?: boolean;

  boneFilterMode?: SkeletonBoneFilterMode;

  color?: unknown | string | number;

  displayMode?: SkeletonDisplayMode;

  includeHelperBones?: boolean;

}

declare class SkewBuilder {

  along(axis: DirectionInput): this;

  angleDegrees(deg: number): this;

  animate(): WaveGeometryDeformAnimationBuilder;

  apply(): MeshEditResult;

  forceMergeMesh(force?: boolean): this;

  inRegion(start: number, end: number): this;

  mode(mode: DeformApplyMode): this;

  regionEnd(pos: number): this;

  regionStart(pos: number): this;

  toward(dir: DirectionInput): this;

}

interface SkewOptions {

  angleDeg: number;

  applyMode?: DeformApplyMode;

  axis: DirectionInput;

  direction: DirectionInput;

  endPos?: number;

  startPos?: number;

}

interface SkyboxState {

  alpha?: number;

  fovMultiplier: number;

  intensity: number;

  rotation?: number;

  size: number;

  texture: string;

}

declare class SkyConfigurator<TEngine extends unknown = unknown> {

  apply(): WaveScene<TEngine>;

  apply(patch: Partial<WaveSceneSkyConfig>): WaveScene<TEngine>;

  alpha(val: number): SkyConfigurator<TEngine>;

  aurora(): AuroraConfigurator<TEngine>;

  backgroundColor(color: ColorInput): SkyConfigurator<TEngine>;

  brightness(val: number): SkyConfigurator<TEngine>;

  celestialBodies(): CelestialBodiesConfigurator<TEngine>;

  clouds(): VolumetricCloudsConfigurator<TEngine>;

  getVideoPlayback(): WaveVideoPlayback | null;

  ibl(opts: NonNullable<WaveSceneSkyConfig["ibl"]>): SkyConfigurator<TEngine>;

  iblIntensity(val: number): SkyConfigurator<TEngine>;

  iblTexture(tex: string): SkyConfigurator<TEngine>;

  nightMode(skyTexture?: string, iblIntensity?: number): SkyConfigurator<TEngine>;

  physicalAtmosphere(): PhysicalAtmosphereConfigurator<TEngine>;

  procedural(): ProceduralSkyConfigurator<TEngine>;

  remove(): WaveScene<TEngine>;

  rotation(val: number): SkyConfigurator<TEngine>;

  skybox(opts: NonNullable<WaveSceneSkyConfig["skybox"]>): SkyConfigurator<TEngine>;

  skyboxFovMultiplier(val: number): SkyConfigurator<TEngine>;

  skyboxIntensity(val: number): SkyConfigurator<TEngine>;

  skyboxSize(val: number): SkyConfigurator<TEngine>;

  skyboxTexture(tex: string): SkyConfigurator<TEngine>;

  stars(): StarFieldConfigurator<TEngine>;

  timeOfDay(): TimeOfDayConfigurator<TEngine>;

  useVideo(videoAssetName: string): WaveVideoPlayback | null;

  videoPlayback(): WaveVideoPlayback | null;

}

interface SliderConfig {

  axisA?: DirectionInput | undefined;

  axisB?: DirectionInput | undefined;

  enableCollisions?: boolean | undefined;

  limits?: AxisLimit[] | undefined;

  motors?: MotorConfig[] | undefined;

  perpAxisA?: DirectionInput | undefined;

  perpAxisB?: DirectionInput | undefined;

  pivotA?: any;

  pivotB?: any;

  linearLimit?: { min: number; max: number; }

  type: ConstraintType.Slider;

}

interface SmoothModifier {

  factor: number;

  type: ModifierType.Smooth;

}

type SnapshotFactoryMap = Record<string, () => unknown>;

interface SocketOffset {

  position?: Vector3Like;

  rotation?: { x: number; y: number; z: number; w: number; }

  scale?: Vector3Like;

}

interface SparksOpts {

  anchorOffset?: Partial<Vector3Like>;

  blend?: MeshOpts["blend"];

  color?: ColorLike;

  count?: NumLike;

  depthWrite?: MeshOpts["depthWrite"];

  direction?: FxVelocityConeDirectionInput;

  directionSpace?: VelocityConeDirectionSpace;

  drag?: NumLike;

  fade?: [number, number][];

  glow?: MeshOpts["glow"];

  growth?: [number, number][];

  lifetime?: NumLike;

  meshAsset?: string;

  size?: NumLike;

  speed?: NumLike;

  spin?: boolean | NumLike;

  spreadAngle?: NumLike;

  style?: "tight" | "balanced" | "shower";

}

interface SpatialAabb {

  center: Vector3;

  halfExtents: Vector3;

  max: Vector3;

  min: Vector3;

}

interface SpatialBoundsXZ {

  maxX: number;

  maxZ: number;

  minX: number;

  minZ: number;

}

type SpawnAnimationRigOffsetSeconds = number | [number, number] | "spread" | "random";

interface SpawnAnimationRigSharingOptions {

  readonly animation?: string | undefined;

  readonly clip?: string | undefined;

  readonly fps?: number | "source" | undefined;

  readonly preferHalfFloat?: boolean | undefined;

  readonly range?: string | undefined;

  readonly ranges?: readonly VATAnimationRange[] | undefined;

  readonly rootMotion?: VertexAnimationRootMotionMode | undefined;

  readonly targetMeshName?: string | undefined;

  asset?: string;

  offsetSeconds?: SpawnAnimationRigOffsetSeconds;

  onEachInstance?: (entity: waveInstanceMesh, index: number) => void;

  source?: "hide" | "keep";

  speed?: number;

  speedRange?: [number, number];

}

interface SpawnAroundOptions<T extends WaveSpatial3DObject = WaveSpatial3DObject> {

  animationRigSharing?: SpawnAnimationRigSharingOptions | undefined;

  cloneCallbacks?: SpawnCloneCallbackPolicy | undefined;

  count?: number | undefined;

  deepClone?: boolean | undefined;

  generatedAssetReuse?: GeneratedAssetCloneReuseIntent | undefined;

  hideOriginal?: boolean | undefined;

  includingOriginal?: boolean | undefined;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachSpawned?: ((entity: SpawnGroupMember<T>, index: number) => void) | undefined;

  physics?: SpawnPhysicsOptions | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  faceCenter?: boolean;

  faceOutward?: boolean;

  heightRange?: [number, number];

  minRadius?: number;

  outerRadius?: number;

  plane?: WavePlaneFrameInput;

  positionJitter?: Vector3Like | number;

  radius: number;

  random?: boolean | "perimeter" | "area" | "outside";

  randomStrength?: number;

  target: WavePointInput | WaveSpatial3DObject;

}

type SpawnCloneCallbackPolicy = "copy" | "skip";

interface SpawnCommonOptions<T extends WaveSpatial3DObject = WaveSpatial3DObject> {

  animationRigSharing?: SpawnAnimationRigSharingOptions;

  cloneCallbacks?: SpawnCloneCallbackPolicy;

  count?: number;

  deepClone?: boolean;

  generatedAssetReuse?: GeneratedAssetCloneReuseIntent;

  hideOriginal?: boolean;

  includingOriginal?: boolean;

  inRange?: PlacementRangeInputSet;

  notInRange?: PlacementRangeInputSet;

  onEachSpawned?: (entity: SpawnGroupMember<T>, index: number) => void;

  physics?: SpawnPhysicsOptions;

  scaleRange?: [number, number];

  seed?: number;

}

interface SpawnerContext {

  create3DGrid<T extends WaveSpatial3DObject>(name?: string, controller?: NoInfer<T> | wave3DObject): Wave3DGrid<T>;

  createGroup<T extends WaveSpatial3DObject>(name?: string, controller?: NoInfer<T> | wave3DObject): WaveGroup<T>;

  disableCollisionsBetweenSpawned(entities: WaveSpatial3DObject[], groupBit?: number): void;

  readonly engine: unknown | null;

  readonly fx: FxFacade;

  getRange(name: string): WaveRange | undefined;

  readonly groupCount: number;

  hideEntities(input: WaveSpawnInput): void;

}

type SpawnGroupMember<T extends WaveSpatial3DObject> = IsWaveGeometryFamily<T> extends true ? waveGeometry : IsWaveActorFamily<T> extends true ? waveActor : IsWaveKinematicActorFamily<T> extends true ? waveKinematicActor : IsWavePropFamily<T> extends true ? waveProp : T;

interface SpawnInGridOptions<T extends WaveSpatial3DObject = WaveSpatial3DObject> {

  animationRigSharing?: SpawnAnimationRigSharingOptions | undefined;

  cloneCallbacks?: SpawnCloneCallbackPolicy | undefined;

  count?: number | undefined;

  deepClone?: boolean | undefined;

  generatedAssetReuse?: GeneratedAssetCloneReuseIntent | undefined;

  hideOriginal?: boolean | undefined;

  includingOriginal?: boolean | undefined;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachSpawned?: ((entity: SpawnGroupMember<T>, index: number) => void) | undefined;

  physics?: SpawnPhysicsOptions | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  as3DGrid?: boolean;

  cols: number;

  colSpacing?: number;

  gridTopology?: GridTopology;

  layers?: number;

  layerSpacing?: number;

  onEachSpawnedAt?: (entity: SpawnGroupMember<T>, row: number, col: number, layer: number) => void;

  origin: WavePointInput;

  plane?: WavePlaneFrameInput;

  positionJitter?: Vector3Like | number;

  randomize?: boolean;

  rows: number;

  rowSpacing?: number;

  spacing?: number;

  yawRange?: [number, number];

}

interface SpawnInlineOptions<T extends WaveSpatial3DObject = WaveSpatial3DObject> {

  alignToTangent?: boolean | undefined;

  animationRigSharing?: SpawnAnimationRigSharingOptions | undefined;

  cloneCallbacks?: SpawnCloneCallbackPolicy | undefined;

  count?: number | undefined;

  deepClone?: boolean | undefined;

  generatedAssetReuse?: GeneratedAssetCloneReuseIntent | undefined;

  hideOriginal?: boolean | undefined;

  includingOriginal?: boolean | undefined;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachSpawned?: ((entity: SpawnGroupMember<T>, index: number) => void) | undefined;

  physics?: SpawnPhysicsOptions | undefined;

  positionJitter?: any;

  randomAlongPath?: boolean | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  spacing?: number | undefined;

  end: WavePointInput;

  start: WavePointInput;

  up?: Vector3;

}

interface SpawnInRangeOptions<T extends WaveSpatial3DObject = WaveSpatial3DObject> {

  animationRigSharing?: SpawnAnimationRigSharingOptions | undefined;

  cloneCallbacks?: SpawnCloneCallbackPolicy | undefined;

  count?: number | undefined;

  deepClone?: boolean | undefined;

  generatedAssetReuse?: GeneratedAssetCloneReuseIntent | undefined;

  hideOriginal?: boolean | undefined;

  includingOriginal?: boolean | undefined;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachSpawned?: ((entity: SpawnGroupMember<T>, index: number) => void) | undefined;

  physics?: SpawnPhysicsOptions | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  facing?: TransformReferenceLike | WavePointInput;

  inset?: number;

  positionJitter?: Vector3Like | number;

  random?: boolean | "surface";

  randomStrength?: number;

  range: WaveRange | string;

}

interface SpawnOnPathOptions<T extends WaveSpatial3DObject = WaveSpatial3DObject> {

  animationRigSharing?: SpawnAnimationRigSharingOptions | undefined;

  cloneCallbacks?: SpawnCloneCallbackPolicy | undefined;

  count?: number | undefined;

  deepClone?: boolean | undefined;

  generatedAssetReuse?: GeneratedAssetCloneReuseIntent | undefined;

  hideOriginal?: boolean | undefined;

  includingOriginal?: boolean | undefined;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachSpawned?: ((entity: SpawnGroupMember<T>, index: number) => void) | undefined;

  physics?: SpawnPhysicsOptions | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  alignToTangent?: boolean;

  positionJitter?: Vector3Like | number;

  randomAlongPath?: boolean;

  spacing?: number;

  up?: Vector3;

}

interface SpawnOnSurfaceOptions<T extends WaveSpatial3DObject = WaveSpatial3DObject> {

  animationRigSharing?: SpawnAnimationRigSharingOptions | undefined;

  cloneCallbacks?: SpawnCloneCallbackPolicy | undefined;

  count?: number | undefined;

  deepClone?: boolean | undefined;

  generatedAssetReuse?: GeneratedAssetCloneReuseIntent | undefined;

  hideOriginal?: boolean | undefined;

  includingOriginal?: boolean | undefined;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachSpawned?: ((entity: SpawnGroupMember<T>, index: number) => void) | undefined;

  physics?: SpawnPhysicsOptions | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  alignToNormal?: boolean;

  positionJitter?: Vector3Like | number;

  projectFrom?: TransformReferenceLike | WavePointInput;

  surface: SpawnSurface;

  surfaceOffset?: number;

  yawRange?: [number, number];

  yOffset?: number;

}

interface SpawnPhysicsOptions {

  avoidCollisionsBetweenSpawned?: boolean;

  collisionGroupBit?: number;

}

interface SpawnPlacement {

  batchPositionResolved?: boolean;

  gridCell?: { row: number; col: number; layer: number; }

  lockDirection?: Vector3;

  lookAtTarget?: Vector3;

  position: Vector3;

  rotation?: Quaternion;

  surfaceAttachmentAnchor?: WaveMeshSurfaceAttachmentAnchor;

  surfaceNormal?: Vector3;

  tangent?: Vector3;

}

type SpawnResult<T extends WaveSpatial3DObject, I extends WaveSpawnInput<T> = WaveSpawnInput<T>> = I extends ReadonlyArray<T> ? SpawnResultForArray<T> : WaveGroup<SpawnResultMember<T, I>>;

type SpawnResultForArray<T extends WaveSpatial3DObject> = WaveGroup<SpawnGroupMember<T>>;

type SpawnResultMember<T extends WaveSpatial3DObject, I extends WaveSpawnInput<T>> = I extends ReadonlyArray<T> | WaveGroup<T> ? SpawnGroupMember<T> : T;

type SpawnSurface = WaveTerrainSurface | waveTerrainTile | wave3DAbstract;

type SpeedComponent = "scalar" | "vector" | "localForward" | "localBackward" | "localLeft" | "localRight" | "localUp" | "localDown" | "worldX" | "worldY" | "worldZ" | "worldForward" | "worldBackward" | "worldLeft" | "worldRight" | "worldUp" | "worldDown";

interface SpeedDisplayOptions {

  decimals?: number | undefined;

  duration?: number | undefined;

  fontAsset?: string | undefined;

  fontSize?: number | undefined;

  labelOffset3D?: any;

  labelOffset3DSpace?: "world" | "local" | undefined;

  textColor?: any;

  updateMode?: DevToolUpdateMode | undefined;

  verticalOffset?: number | undefined;

  components?: SpeedComponent | SpeedComponent[];

  showLabels?: boolean;

  unit?: string;

}

interface SpeedLinesOptions {

  brightnessVariation?: number;

  color?: ColorInput;

  curvature?: number;

  flickerAmount?: number;

  flickerSpeed?: number;

  focusPoint?: { x: number; y: number; }

  innerRadius?: number;

  intensity?: number;

  lengthVariation?: number;

  lineCount?: number;

  lineWidth?: number;

  outerFade?: number;

  scrollSpeed?: number;

  taper?: number;

  widthVariation?: number;

}

interface SpringConfig {

  damping: number;

  equilibrium?: number;

  stiffness: number;

}

interface SpriteOpts {

  animation?: WaveSpriteAnimationRef;

  animationSpeed?: number;

  billboard?: "all" | "y" | "none" | "stretched" | "faceAnchor";

  blend?: "additive" | "alpha" | "multiply";

  depthWrite?: boolean;

  flipbook?: { columns: number; rows: number; frameRate: number; playMode?: "once" | "loop"; driveByAge?: boolean; interpolation?: "none" | "crossfade"; }

  glow?: FxGlowConfig;

  lightmask?: FxLightmaskId;

  noMipmap?: boolean;

  particleMask?: FxParticleMaskId;

  sort?: "backToFront" | "frontToBack" | "none" | "byAge";

  sprite?: WaveSpriteAsset;

  texture?: string;

  uvInset?: number;

}

type StarFieldConfig = EnabledEnvironmentPatch<StarFieldState>;

declare class StarFieldConfigurator<TEngine extends unknown = unknown> {

  constructor(_sky: SkyConfigurator<TEngine>);

  apply(): SkyConfigurator<TEngine>;

  brightness(value: number): this;

  celestialRotation(value?: boolean): this;

  color(value: ColorInput): this;

  colorTemperature(value: number): this;

  configure(patch: StarFieldConfig): this;

  count(value: number): this;

  disable(): SkyConfigurator<TEngine>;

  formation(value: StarFieldFormation): this;

  galaxyBand(): this;

  galaxyColors(core: ColorInput, edge: ColorInput): this;

  galaxyIntensity(value: number): this;

  minElevation(value: number): this;

  scattered(): this;

  shootingStars(enabled?: boolean, options?: { interval?: number; duration?: number; length?: number; brightness?: number; }): this;

  size(value: number): this;

  sizeVariance(value: number): this;

  starCount(value: number): this;

  twinkle(value?: boolean): this;

  twinkleSpeed(value: number): this;

}

interface StreamingProvider<TChunkData = unknown, TChunkSlot = unknown, TWorkerRequest extends object = object> {

  computeActiveChunks(cameraPosition: Vector3Like): ChunkKey[];

  computeActiveChunksToRef?(cameraPosition: Vector3Like, out: ChunkKey[]): ChunkKey[];

  createChunkSlot(key: ChunkKey): TChunkSlot;

  createWorkerRequest?(key: ChunkKey): TWorkerRequest;

  dispose?(): void;

  disposeChunkSlot(slot: TChunkSlot): void;

  generateChunk(key: ChunkKey): TChunkData;

  getChunkKeysIntersectingBounds?(bounds: SpatialBoundsXZ): ChunkKey[];

  getCoverageRadius?(cameraPosition: Vector3Like, slots: readonly TChunkSlot[]): number | null;

  getGeometryBackend?(): WaveStreamingGeometryBackend | null;

  getHeightsInGridToRef?(query: SurfaceHeightGridQuery, out: Float32Array): Float32Array;

  getLodReferenceRadius?(cameraPosition: Vector3Like, slots: readonly TChunkSlot[]): number | null;

  getSeed?(): number;

  getStableSurfaceBounds?(): SpatialBoundsXZ | null;

  getSurfaceRevision?(): WaveStreamingGeometrySurfaceRevision;

  getWorkerPoolOptions?(): StreamingProviderWorkerPoolOptions;

  getWorkerSource?(): string;

  readonly id: StreamingProviderIdLike;

  initializeGrid(config: unknown): ChunkKey[];

  materializeChunk(key: ChunkKey, data: TChunkData, slot: TChunkSlot): void;

  prepareChunkSlot(slot: TChunkSlot, key: ChunkKey): void;

  querySemantic?(position: SurfaceQueryPoint): SurfaceSemanticQueryResult | null;

  querySurface?(position: SurfaceQueryPoint): SurfaceQueryResult | null;

  querySurfaceToRef?(position: SurfaceQueryPoint, out: SurfaceQueryResult): SurfaceQueryResult | null;

  recycleChunkSlot(slot: TChunkSlot): void;

  retireSceneRuntime?(): Promise<void> | void;

  readonly workerCapable: boolean;

}

type StreamingProviderId = (typeof StreamingProviderId)[keyof typeof StreamingProviderId];

declare const StreamingProviderId: { readonly Terrain: "terrain"; readonly Grid3D: "grid3d"; readonly Babylon3DTiles: "babylon3dTiles"; };

type StreamingProviderIdLike = StreamingProviderId | (string & {});

interface StreamingProviderWorkerPoolOptions {

  readonly label?: string;

  readonly poolSize?: number;

  readonly required?: boolean;

}

declare class StretchBuilder {

  along(axis: DirectionInput): this;

  anchorCenter(): this;

  anchorMax(): this;

  anchorMin(): this;

  animate(): WaveGeometryDeformAnimationBuilder;

  apply(): MeshEditResult;

  byFactor(factor: number): this;

  forceMergeMesh(force?: boolean): this;

  inRegion(start: number, end: number): this;

  regionEnd(pos: number): this;

  regionStart(pos: number): this;

  withFactor(factor: number): this;

  withFalloff(falloff: WaveGeometryRegionalFalloff): this;

}

declare class SurfaceDeformationBuilder {

  along(direction: DirectionInput): this;

  at(center: WavePointInput): this;

  expandNeighbors(rings?: number): this;

  falloff(value: SurfaceDeformationFalloff): this;

  forceMergeMesh(force?: boolean): this;

  height(value: number): this;

  onComplete(callback: SurfaceDeformationCompleteCallback, options?: WaveAuthoredCallbackOptions): this;

  onError(callback: SurfaceDeformationErrorCallback, options?: WaveAuthoredCallbackOptions): this;

  onUpdate(callback: SurfaceDeformationUpdateCallback, options?: WaveAuthoredCallbackOptions): this;

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  play(): SurfaceDeformationPlayback;

  radius(value: number): this;

  recomputeNormals(enabled?: boolean): this;

  restoreFromCachedBase(_enabled?: boolean): this;

  riseOver(duration: WaveTimeSpan): this;

  riseOver(value: number, unit: WaveTimeUnit): this;

  settleOver(duration: WaveTimeSpan): this;

  settleOver(value: number, unit: WaveTimeUnit): this;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): this;

  withRadius(value: number): this;

}

type SurfaceDeformationCompleteCallback = (playback: SurfaceDeformationPlayback) => void;

type SurfaceDeformationErrorCallback = (error: string, playback: SurfaceDeformationPlayback) => void;

type SurfaceDeformationFalloff = VertexFalloff | "none" | "linear" | "smooth" | "sharp" | "gaussian";

type SurfaceDeformationUpdateCallback = (progress: number, height: number, playback: SurfaceDeformationPlayback) => void;

type SurfaceDiscolorMode = "uvRadial" | "uvDirectional" | "worldDirectional";

interface SurfaceDiscolorOptions {

  centerUV?: Vector2Like;

  desaturate?: number;

  direction?: Vector3Like;

  endProjection?: number;

  eraseStrength?: number;

  maxRadius?: number;

  mode?: SurfaceDiscolorMode;

  progress?: number;

  softness?: number;

  startProjection?: number;

  strength?: number;

  target?: VisualModelTarget | null;

  tintColor?: unknown | string | [number, number, number] | number;

  tintStrength?: number;

  uvDirection?: Vector2Like;

}

interface SurfaceEffectOpts {

  blend?: FxSurfaceEffectRendererSpec["blendMode"];

  colorRamp: Array<[number, ColorLike]>;

  coverage?: NumLike;

  depthWrite?: boolean;

  displacement?: NumLike;

  dissolveSurface?: boolean;

  edgeColor?: ColorLike;

  edgeSoftness?: NumLike;

  emissionIntensity?: NumLike;

  glow?: FxGlowConfig;

  material?: FxSurfaceEffectRendererSpec["material"];

  noiseScale: NumLike;

  noiseType?: "simple" | "perlin" | "voronoi" | "worley";

  normalOffset?: NumLike;

  portal?: { center?: Vector3Like; swirl?: NumLike; radialScale?: NumLike; }

  scrollVelocity?: { x?: number; y?: number; z?: number; }

  source?: WaveSurfaceSourceStructure;

  triplanarSharpness?: NumLike;

  twoSided?: boolean;

  uvMode?: "meshUV" | "triplanar";

}

interface SurfaceErasureOptions {

  centerUV?: Vector2Like;

  direction?: DirectionInput | Vector3Like;

  endProjection?: number;

  eraseStrength?: number;

  fitProjectionToModel?: boolean;

  maxRadius?: number;

  mode?: SurfaceDiscolorMode;

  progress?: number;

  softness?: number;

  startProjection?: number;

  target?: VisualModelTarget | null;

  uvDirection?: Vector2Like;

}

interface SurfaceErasureWarmupOptions {

  centerUV?: any;

  direction?: any;

  endProjection?: number | undefined;

  eraseStrength?: number | undefined;

  fitProjectionToModel?: boolean | undefined;

  maxRadius?: number | undefined;

  mode?: SurfaceDiscolorMode | undefined;

  progress?: number | undefined;

  softness?: number | undefined;

  startProjection?: number | undefined;

  target?: any;

  uvDirection?: any;

  prepareOperablePBR?: boolean;

  resetProgress?: boolean;

}

interface SurfaceErasureWarmupResult {

  error?: string | undefined;

  materialsPrepared: number;

  meshesPrepared: number;

  success: boolean;

  erasurePrimed: boolean;

}

interface SurfaceHeightGridQuery {

  readonly columns: number;

  readonly originX: number;

  readonly originZ: number;

  readonly rows: number;

  readonly stepX: number;

  readonly stepZ: number;

}

interface SurfaceInfo {

  isDynamic: boolean;

  supportState: CharacterSupportState;

  surfaceAngularVelocity: SerializableVector3;

  surfaceNormal: SerializableVector3;

  surfaceVelocity: SerializableVector3;

}

type SurfacePathCenterlineOptions = SurfaceRibbonOptions & { width: number; steps?: never; sampleMode?: never; }

type SurfacePathRailsOptions = PathSurfaceOptions & { surfaceOffset?: number; width?: never; spacing?: never; centerSampleSpacing?: never; onCenterSample?: never; cap?: never; minCapSegments?: never; }

type SurfaceQueryCoordinateMode = "flatXZ" | "world3D";

interface SurfaceQueryInput {

  readonly upVector?: Vector3Like;

  readonly x: number;

  readonly y: number;

  readonly z: number;

}

interface SurfaceQueryPoint {

  readonly upVector?: any;

  readonly x: number;

  readonly y: number;

  readonly z: number;

  readonly coordinateMode?: SurfaceQueryCoordinateMode;

}

interface SurfaceQueryResult {

  normal?: { x: number; y: number; z: number; }

  position?: { x: number; y: number; z: number; }

  y: number;

}

interface SurfaceRibbonCenterSample {

  readonly distance: number;

  readonly index: number;

  readonly position: Vector3;

  readonly progress: number;

  readonly tangent: Vector3;

  readonly totalLength: number;

  readonly width: number;

}

type SurfaceRibbonCenterSampleCallback = (sample: SurfaceRibbonCenterSample) => void;

interface SurfaceRibbonMetadata {

  centerPathPoints: SerializableVector3[];

  hasBody: boolean;

  isClosed: boolean;

  leftPathPoints: SerializableVector3[];

  pathDistances: number[];

  pathProgress: number[];

  rightPathPoints: SerializableVector3[];

  sampleCount: number;

  thickness: number;

  totalLength: number;

  widthSegments: number;

  cap: PathRibbonCapMode;

  centerPathInput: SerializableVector3[];

  surfaceOffset: number;

  width: number;

}

interface SurfaceRibbonOptions {

  capEnds?: boolean | undefined;

  closePath?: boolean | undefined;

  heightSource?: PathSurfaceHeightSource | undefined;

  invertNormals?: boolean | undefined;

  pathDistanceOffset?: number | undefined;

  sideUvMode?: "normalized" | "distance" | undefined;

  sideWalls?: boolean | undefined;

  thickness?: number | undefined;

  thicknessDirection?: any;

  updatable?: boolean | undefined;

  uScale?: number | undefined;

  uvMode?: "normalized" | "distance" | undefined;

  vScale?: number | undefined;

  widthSegments?: number | undefined;

  cap?: PathRibbonCapMode;

  centerSampleSpacing?: number;

  minCapSegments?: number;

  onCenterSample?: SurfaceRibbonCenterSampleCallback;

  spacing?: number;

  surfaceOffset?: number;

  width?: number;

}

type SurfaceRiverNoPlaceOptions = WaveTerrainRiverRangeOptions;

interface SurfaceRiverNoPlaceSource {

  noPlaceZone(options?: SurfaceRiverNoPlaceOptions): WaveRange;

}

type SurfaceSelectionHost = { _captureCanonicalGeometrySource(): Visual3DModelCanonicalGeometrySource; }

interface SurfaceSemanticQueryResult {

  primaryTag: string;

  sourceName?: string;

  tags: readonly string[];

}

declare class SwayBuilder {

  animate(): WaveGeometryDeformAnimationBuilder;

  toward(direction: DirectionInput): this;

  withAttenuation(attenuation: number): this;

  withReferenceSize(referenceSize: number): this;

  withStrength(strength: number): this;

}

interface SwizzleModifier {

  order: ("x" | "y" | "z" | "-x" | "-y" | "-z")[];

  type: ModifierType.Swizzle;

}

interface SystemOpts {

  authority?: FxSystemDefinition["authority"];

  scalability?: FxSystemDefinition["scalability"];

  userParams?: FxUserParamSchema[];

}

declare class TaperBuilder {

  along(axis: DirectionInput): this;

  animate(): WaveGeometryDeformAnimationBuilder;

  apply(): MeshEditResult;

  forceMergeMesh(force?: boolean): this;

  fromScale(scale: number): this;

  inRegion(start: number, end: number): this;

  mode(mode: DeformApplyMode): this;

  regionEnd(pos: number): this;

  regionStart(pos: number): this;

  toScale(scale: number): this;

}

interface TaperOptions {

  applyMode?: DeformApplyMode;

  axis: DirectionInput;

  endPos?: number;

  endScale?: number;

  startPos?: number;

  startScale?: number;

}

interface TeleportationConfig {

  floorMeshes?: string[];

  snapAngle?: number;

}

interface TerrainAngularSliceOptions {

  edgeJitter?: number;

  fraction: number;

  noiseScale?: number;

  origin: Vector2Like;

  rotationRadians?: number;

  seed?: number;

  transitionWidth?: number;

}

interface TerrainBaseNoiseOptions {

  amplitude: number;

  baseHeight?: number;

  coordinateMode?: TerrainNoiseCoordinateMode;

  frequency: number;

  octaves?: number;

  persistence?: number;

}

interface TerrainBaseNoiseStep {

  args: [TerrainBaseNoiseOptions];

  op: "baseNoise";

}

interface TerrainBasinProfileOptions {

  bermHeight?: number;

  bermWidth?: number;

  brushFrame?: TerrainBrushFrameOptions;

  floorNoiseFrequency?: number;

  floorRadius?: number;

  floorRoughness?: number;

  rimRoughness?: number;

  seed?: number;

  slice?: TerrainAngularSliceOptions;

  wallRoughness?: number;

  wallSteepness?: number;

}

interface TerrainBasinStep {

  args: [TerrainRecipePoint, number, number, TerrainShapeFalloff, TerrainBasinProfileOptions?];

  op: "basin";

}

interface TerrainBrushFrameOptions {

  rotationRadians?: number;

  scaleX?: number;

  scaleY?: number;

}

type TerrainCanonicalRecipeStep = TerrainPeakStep | TerrainBasinStep | TerrainChannelStep | TerrainLevelStep | TerrainNoiseStep | TerrainBaseNoiseStep | TerrainRidgeNoiseStep | TerrainRadialReliefMaskStep | TerrainSampledHeightfieldStep | TerrainCoastalReliefStep | TerrainContourTerraceStep | TerrainValleyReliefStep | TerrainFlattenStampsStep | TerrainSmoothStep | TerrainOffsetHeightStep | TerrainErosionStep;

interface TerrainChannelStep {

  args: [TerrainRecipePoint[], number, number, RiverOptions];

  op: "channel";

}

interface TerrainCoastalReliefOptions {

  cliffSteepness?: number;

  cliffTopHeight: WaveValueCurveSpec;

  cliffWidth?: WaveValueCurveSpec;

  edgeFadeDistance?: number;

  edgeHeight?: number;

  inlandRidgeHeight?: WaveValueCurveSpec;

  inlandRidgeStart?: WaveValueCurveSpec;

  inlandRidgeWidth?: WaveValueCurveSpec;

  inlandSlope?: WaveValueCurveSpec;

  landwardDirection: TerrainRecipePoint;

  reliefAmplitude?: WaveValueCurveSpec;

  reliefDampingDistance?: number;

  reliefFrequency?: number;

  reliefOctaves?: number;

  reliefPersistence?: number;

  seaFloorDepth?: WaveValueCurveSpec;

  seaFloorDistance?: WaveValueCurveSpec;

  seaLevel?: number;

  shoreline: readonly TerrainRecipePoint[];

}

interface TerrainCoastalReliefStep {

  args: [TerrainCoastalReliefOptions];

  op: "coastalRelief";

}

interface TerrainContourTerraceOptions {

  maxHeight: number;

  minHeight: number;

  noiseAmplitude?: number;

  noiseFrequency?: number;

  region?: TerrainRegion;

  regionBlendRadius?: number;

  stepHeight: number;

  strength?: number;

}

interface TerrainContourTerraceStep {

  args: [TerrainContourTerraceOptions];

  op: "contourTerraces";

}

interface TerrainErosionOptions {

  aggregationDrift?: number;

  aggregationResolution?: number;

  aggregationSteps?: number;

  aggregationWalkers?: number;

  aggregationWidth?: number;

  baseFrequency?: number;

  branching?: "directional" | "diffusionLimited";

  compatibility?: "reference" | "wave";

  creaseRoundness?: number;

  deposition?: number;

  detail?: number;

  drainageThreshold?: number;

  emitDrainageMask?: boolean;

  emitRidgeMap?: boolean;

  falloff?: BrushFalloff;

  feather?: number;

  gain?: number;

  gullyWeight?: number;

  inputSlope?: number;

  lacunarity?: number;

  normalization?: number;

  octaves?: number;

  peakAltitude?: number | "auto";

  preset?: TerrainErosionPreset;

  ridgeRoundness?: number;

  straightGullies?: boolean;

  strength?: number;

  talusAngleDegrees?: number;

  thermalRelaxation?: number;

  valleyAltitude?: number | "auto";

}

type TerrainErosionPreset = "referenceAdvanced" | "alpine" | "badlands" | "incisedValleys" | "softSedimentary" | "dendriticAlpine" | "polarDesert";

type TerrainErosionSelection = { kind: "region"; region: TerrainRegion; } | { kind: "circle"; center: { x: number; y: number; }; radius: number; }

interface TerrainErosionStep {

  args: [TerrainErosionSelection, TerrainErosionOptions];

  op: "erosion";

}

interface TerrainFlattenCircleStamp {

  readonly center: TerrainRecipePoint;

  readonly feather?: number;

  readonly kind: "circle";

  readonly radius: number;

  readonly strength?: number;

  readonly targetHeight: number;

}

interface TerrainFlattenHeightBrushCommand {

  mode: "flatten";

  options?: TerrainHeightFlattenOptions;

  targetHeight: number;

}

interface TerrainFlattenRectangleStamp {

  readonly center: TerrainRecipePoint;

  readonly feather?: number;

  readonly halfSize: TerrainRecipePoint;

  readonly kind: "rectangle";

  readonly rotationRadians?: number;

  readonly strength?: number;

  readonly targetHeight: number;

}

type TerrainFlattenStamp = TerrainFlattenCircleStamp | TerrainFlattenRectangleStamp;

interface TerrainFlattenStampsOptions {

  readonly stamps: readonly TerrainFlattenStamp[];

  readonly strength?: number;

}

interface TerrainFlattenStampsStep {

  args: [TerrainFlattenStampsOptions];

  op: "flattenStamps";

}

interface TerrainHeightBrushCircleOp {

  args: [ command: TerrainHeightBrushCommand, center: Vector2Like, radius: number ];

  op: "sculptHeightCircle";

}

type TerrainHeightBrushCommand = TerrainRaiseHeightBrushCommand | TerrainLowerHeightBrushCommand | TerrainFlattenHeightBrushCommand | TerrainSmoothHeightBrushCommand | TerrainNoiseHeightBrushCommand;

interface TerrainHeightBrushNoiseFrame {

  origin: Vector2Like;

  rotationRadians?: number;

}

interface TerrainHeightBrushPathOp {

  args: [ command: TerrainHeightBrushCommand, points: Vector2Like[], width: number, pathOptions?: TerrainHeightPathOptions ];

  op: "sculptHeightPath";

}

type TerrainHeightFalloff = BrushFalloff | WaveValueCurveSpec;

interface TerrainHeightFlattenOptions {

  brushFrame?: TerrainBrushFrameOptions | undefined;

  falloff?: TerrainHeightFalloff | undefined;

  heightRange?: [ number, number ] | undefined;

  jitter?: number | undefined;

  noiseFrame?: TerrainHeightBrushNoiseFrame | undefined;

  noiseScale?: number | undefined;

  seed?: number | undefined;

  slice?: TerrainAngularSliceOptions | undefined;

  slopeRange?: [ number, number ] | undefined;

  strength?: number | undefined;

  blendRadius?: number;

}

type TerrainHeightGridQuery = SurfaceHeightGridQuery;

interface TerrainHeightNoiseOptions {

  brushFrame?: TerrainBrushFrameOptions | undefined;

  falloff?: TerrainHeightFalloff | undefined;

  heightRange?: [ number, number ] | undefined;

  jitter?: number | undefined;

  noiseFrame?: TerrainHeightBrushNoiseFrame | undefined;

  noiseScale?: number | undefined;

  seed?: number | undefined;

  slice?: TerrainAngularSliceOptions | undefined;

  slopeRange?: [ number, number ] | undefined;

  strength?: number | undefined;

  frequency?: number;

  octaves?: number;

}

interface TerrainHeightPathOptions {

  segmentSubdivisions?: number;

}

interface TerrainHeightRaiseLowerOptions {

  brushFrame?: TerrainBrushFrameOptions | undefined;

  falloff?: TerrainHeightFalloff | undefined;

  heightRange?: [ number, number ] | undefined;

  jitter?: number | undefined;

  noiseFrame?: TerrainHeightBrushNoiseFrame | undefined;

  noiseScale?: number | undefined;

  seed?: number | undefined;

  slice?: TerrainAngularSliceOptions | undefined;

  slopeRange?: [ number, number ] | undefined;

  strength?: number | undefined;

  maxDelta?: number;

}

interface TerrainHeightSmoothOptions {

  brushFrame?: TerrainBrushFrameOptions | undefined;

  falloff?: TerrainHeightFalloff | undefined;

  heightRange?: [ number, number ] | undefined;

  jitter?: number | undefined;

  noiseFrame?: TerrainHeightBrushNoiseFrame | undefined;

  noiseScale?: number | undefined;

  seed?: number | undefined;

  slice?: TerrainAngularSliceOptions | undefined;

  slopeRange?: [ number, number ] | undefined;

  strength?: number | undefined;

  iterations?: number;

}

interface TerrainLevelStep {

  args: [TerrainRegion, number, number];

  op: "level";

}

interface TerrainLowerHeightBrushCommand {

  amount: number;

  mode: "lower";

  options?: TerrainHeightRaiseLowerOptions;

}

type TerrainNoiseCoordinateMode = "local" | "world";

interface TerrainNoiseHeightBrushCommand {

  amplitude: number;

  mode: "noise";

  options?: TerrainHeightNoiseOptions;

}

interface TerrainNoiseStep {

  args: [TerrainRegion, number, number, number];

  op: "noise";

}

type TerrainNormalQueryRef = Vector3Like;

interface TerrainOffsetHeightStep {

  args: [number, TerrainRegion | null];

  op: "offsetHeight";

}

interface TerrainPeakProfileOptions {

  brushFrame?: TerrainBrushFrameOptions;

  slice?: TerrainAngularSliceOptions;

}

interface TerrainPeakStep {

  args: [TerrainRecipePoint, number, number, TerrainShapeFalloff, TerrainPeakProfileOptions?];

  op: "peak";

}

interface TerrainRadialReliefMaskOptions {

  baseHeight?: number;

  power?: number;

  worldBounds?: TerrainRegion;

}

interface TerrainRadialReliefMaskStep {

  args: [TerrainRadialReliefMaskOptions];

  op: "radialReliefMask";

}

interface TerrainRaiseHeightBrushCommand {

  amount: number;

  mode: "raise";

  options?: TerrainHeightRaiseLowerOptions;

}

interface TerrainRecipe {

  steps: TerrainRecipeStep[];

}

type TerrainRecipePoint = { x: number; y: number; }

type TerrainRecipeStep = TerrainCanonicalRecipeStep | TerrainHeightBrushCircleOp | TerrainHeightBrushPathOp;

interface TerrainRegion {

  max: { x: number; y: number; }

  min: { x: number; y: number; }

}

interface TerrainRidgeNoiseOptions {

  amplitude: number;

  baseHeight?: number | undefined;

  coordinateMode?: TerrainNoiseCoordinateMode | undefined;

  frequency: number;

  octaves?: number | undefined;

  persistence?: number | undefined;

}

interface TerrainRidgeNoiseStep {

  args: [TerrainRidgeNoiseOptions];

  op: "ridgeNoise";

}

type TerrainRiverCorridorCrossSection = "natural" | "v" | "u" | "trapezoid";

type TerrainRiverCorridorGradeKind = "followDownhill" | "sourceToMouth" | "profile";

interface TerrainRiverCorridorRecipe {

  readonly crossSection: TerrainRiverCorridorCrossSection;

  readonly foundationRevision: string;

  readonly gradeKind: TerrainRiverCorridorGradeKind;

  readonly revision: string;

  readonly samples: readonly TerrainRiverCorridorRecipeSample[];

}

interface TerrainRiverCorridorRecipeSample {

  readonly bankSlope: number;

  readonly bedElevation: number;

  readonly bedWidth: number;

  readonly blendDistance: number;

  readonly channelDepth: number;

  readonly surfaceElevation: number;

  readonly topWidth: number;

  readonly waterElevation?: number;

  readonly waterWidth?: number;

}

type TerrainRuntimeBrushKind = "paint" | "erase" | "raise" | "lower" | "level" | "smooth" | "noise" | "erosion";

interface TerrainSampledHeightfieldOptions {

  readonly blendRadius?: number;

  readonly brushFrame?: TerrainBrushFrameOptions;

  readonly origin?: TerrainRecipePoint;

  readonly preserveOutsideBounds?: boolean;

  readonly sampleColumns: number;

  readonly sampleRows: number;

  readonly samples: readonly number[];

  readonly worldMin: TerrainRecipePoint;

  readonly worldSize: TerrainRecipePoint;

}

interface TerrainSampledHeightfieldStep {

  args: [TerrainSampledHeightfieldOptions];

  op: "sampledHeightfield";

}

type TerrainShapeFalloff = "linear" | "smooth" | "exponential" | WaveValueCurveSpec;

interface TerrainSmoothHeightBrushCommand {

  mode: "smooth";

  options?: TerrainHeightSmoothOptions;

}

interface TerrainSmoothStep {

  args: [TerrainRegion, number];

  op: "smooth";

}

interface TerrainSurfaceQueryRef<TNormal extends TerrainNormalQueryRef = TerrainNormalQueryRef> {

  height: number;

  normal: TNormal;

  y?: number;

}

interface TerrainValleyReliefOptions {

  depth: WaveValueCurveSpec;

  floorWidth?: WaveValueCurveSpec;

  path: readonly TerrainRecipePoint[];

  strength?: number;

  width: WaveValueCurveSpec;

}

interface TerrainValleyReliefStep {

  args: [TerrainValleyReliefOptions];

  op: "valleyRelief";

}

interface TextParticleOpts {

  billboardMode?: "all" | "none";

  colorBinding?: string;

  fontAsset: string;

  renderingGroupId?: number;

  size?: number;

  sizeBinding?: string;

  text: string;

}

interface TextureBindingIntent {

  readonly access?: "read" | "write";

}

type TextureBindingValue = { readonly kind: "sample"; readonly ref: ExactAssetRef<"texture">; readonly texture: unknown; } | { readonly kind: "canvasRead"; readonly ref: ExactAssetRef<"texture">; readonly texture: unknown; } | { readonly kind: "canvasWrite"; readonly ref: ExactAssetRef<"texture">; readonly surface: CanvasTextureWriter; } | { readonly kind: "atlas"; readonly ref: ExactAssetRef<"texture">; readonly runtimeView: WaveTextureAtlasRuntimeView; readonly pages: readonly AtlasTexturePageBinding[]; readonly motionTextures?: AtlasMotionTextureBinding; readonly sampling?: WaveTextureAtlasSamplingPolicy; readonly manifest?: WaveTextureAtlasManifest; }

type TextureCpuPixelsCachePolicy = "lru" | "noStore";

interface TextureCpuPixelsOptions {

  readonly cachePolicy?: TextureCpuPixelsCachePolicy;

  readonly releaseDecodedCpuSource?: boolean;

}

type TextureFlipbookInterpolation = "none" | "crossfade";

type TextureFlipbookPlayMode = "once" | "loop";

interface TextureFlipbookSpec {

  columns: number;

  driveByAge?: boolean;

  frameRate: number;

  interpolation?: TextureFlipbookInterpolation;

  playMode: TextureFlipbookPlayMode;

  rows: number;

}

type TexturePixelData = Pick<WaveTextureCpuPixels, "data" | "width" | "height">;

type TextureStampMaskChannel = "r" | "g" | "b" | "a" | "luminance";

interface ThermalVisionOptions {

  coldColor?: { r: number; g: number; b: number; }

  hotColor?: { r: number; g: number; b: number; }

  mediumColor?: { r: number; g: number; b: number; }

}

declare class ThinBatchAroundBuilder {

  at(origin: WavePointInput): ThinBatchAroundBuilder;

  at(x: number, y: number, z: number): ThinBatchAroundBuilder;

  inRange(range: PlacementRangeInputSet): ThinBatchAroundBuilder;

  inTotal(n: number): ThinBatchAroundBuilder;

  notInRange(range: PlacementRangeInputSet): ThinBatchAroundBuilder;

  onEachInstance(cb: (index: number, position: Vector3) => ThinBatchPlacementOverride | void): ThinBatchAroundBuilder;

  originAt(origin: WavePointInput): ThinBatchAroundBuilder;

  snapToSurface(surface: WaveTerrainSurface): ThinBatchAroundBuilder;

  withCount(n: number): ThinBatchAroundBuilder;

  withRandomYaw(min?: number, max?: number): ThinBatchAroundBuilder;

  withScaleRange(min: number, max: number): ThinBatchAroundBuilder;

  withSeed(seed: number): ThinBatchAroundBuilder;

  withYawRange(min: number, max: number): ThinBatchAroundBuilder;

  withYOffset(offset: number): ThinBatchAroundBuilder;

  constructor(spawner: WaveSpawner, target?: WavePointInput | WaveSpatial3DObject, batch?: waveThinBatch);

  evenlySpaced(): this;

  faceCenter(face?: boolean): this;

  faceOutward(face?: boolean): this;

  inRadius(radius: number): this;

  inRadius(minRadius: number, maxRadius: number): this;

  insidePerimeter(): this;

  onPerimeter(): this;

  onPlane(plane: WavePlaneFrameInput): this;

  onXYPlane(): this;

  onXZPlane(): this;

  onYZPlane(): this;

  outsidePerimeter(outerRadius?: number): this;

  place(): waveThinBatch;

  with(batch: waveThinBatch): this;

  withHeightRange(min: number, max: number): this;

  withJitter(jitter: Vector3Like | number): this;

  withMinRadius(radius: number): this;

  withRadius(radius: number): this;

  withRandomStrength(strength: number): this;

}

interface ThinBatchAroundOptions {

  count: number;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachInstance?: ((index: number, position: Vector3) => ThinBatchPlacementOverride | void) | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  surface?: WaveTerrainSurface | undefined;

  yawRange?: [ number, number ] | undefined;

  yOffset?: number | undefined;

  faceCenter?: boolean;

  faceOutward?: boolean;

  heightRange?: [number, number];

  minRadius?: number;

  outerRadius?: number;

  plane?: WavePlaneFrameInput;

  positionJitter?: Vector3Like | number;

  radius: number;

  random?: boolean | "perimeter" | "area" | "outside";

  randomStrength?: number;

  target: WavePointInput | WaveSpatial3DObject;

}

interface ThinBatchConstantForceConfig {

  enabled?: boolean | undefined;

  excludeIndices?: Iterable<number> | undefined;

  includeIndices?: Iterable<number> | undefined;

  name?: string | undefined;

  space?: ConstantForceSpace | undefined;

  direction?: DirectionInput;

  force?: Vector3Like;

  strength?: number;

}

interface ThinBatchConstantForceEntry {

  enabled: boolean;

  excludeIndices?: readonly number[];

  force: Vector3Like;

  includeIndices?: readonly number[];

  name: string;

  space: ConstantForceSpace;

}

interface ThinBatchConstantForceOptions {

  enabled?: boolean;

  excludeIndices?: Iterable<number>;

  includeIndices?: Iterable<number>;

  name?: string;

  space?: ConstantForceSpace;

}

interface ThinBatchConstraintConfigSnapshot {

  config: ConstraintConfig;

  id: string;

  sourceIndex: number;

  target: PhysicsConstraintEndpoint;

}

type ThinBatchContactCallback = (event: ThinBatchContactEvent) => void;

interface ThinBatchContactEvent {

  readonly batch: WaveEntity;

  readonly body: unknown;

  readonly impulse: number;

  readonly index: number;

  readonly normal: Vector3 | null;

  readonly otherBody: unknown;

  readonly otherIndex: number;

  readonly phase: ThinBatchContactPhase;

  readonly physicsBody: cmp_thinBatchPhysicsBody;

  readonly point: Vector3 | null;

  readonly rawEvent: unknown | unknown;

}

type ThinBatchContactPhase = "begin" | "continue" | "end";

declare class ThinBatchInGridBuilder {

  at(origin: WavePointInput): ThinBatchInGridBuilder;

  at(x: number, y: number, z: number): ThinBatchInGridBuilder;

  inRange(range: PlacementRangeInputSet): ThinBatchInGridBuilder;

  inTotal(n: number): ThinBatchInGridBuilder;

  notInRange(range: PlacementRangeInputSet): ThinBatchInGridBuilder;

  onEachInstance(cb: (index: number, position: Vector3) => ThinBatchPlacementOverride | void): ThinBatchInGridBuilder;

  originAt(origin: WavePointInput): ThinBatchInGridBuilder;

  snapToSurface(surface: WaveTerrainSurface): ThinBatchInGridBuilder;

  withCount(n: number): ThinBatchInGridBuilder;

  withRandomYaw(min?: number, max?: number): ThinBatchInGridBuilder;

  withScaleRange(min: number, max: number): ThinBatchInGridBuilder;

  withSeed(seed: number): ThinBatchInGridBuilder;

  withYawRange(min: number, max: number): ThinBatchInGridBuilder;

  withYOffset(offset: number): ThinBatchInGridBuilder;

  onEachCell(cb: (index: number, row: number, col: number, layer: number, position: Vector3) => ThinBatchPlacementOverride | void): this;

  onPlane(plane: WavePlaneFrameInput): this;

  onXYPlane(): this;

  onXZPlane(): this;

  onYZPlane(): this;

  place(): waveThinBatch;

  randomizeCells(random?: boolean): this;

  withCols(c: number): this;

  withColSpacing(s: number): this;

  withGridTopology(topology: GridTopology): this;

  withJitter(jitter: Vector3Like | number): this;

  withLayers(l: number): this;

  withLayerSpacing(s: number): this;

  withRows(r: number): this;

  withRowSpacing(s: number): this;

  withSize(rows: number, cols: number, layers?: number): this;

  withSpacing(s: number): this;

}

interface ThinBatchInGridOptions {

  count: number;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachInstance?: ((index: number, position: Vector3) => ThinBatchPlacementOverride | void) | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  surface?: WaveTerrainSurface | undefined;

  yawRange?: [ number, number ] | undefined;

  yOffset?: number | undefined;

  cols: number;

  colSpacing?: number;

  gridTopology?: GridTopology;

  layers?: number;

  layerSpacing?: number;

  onEachCell?: (index: number, row: number, col: number, layer: number, position: Vector3) => ThinBatchPlacementOverride | void;

  origin: WavePointInput;

  plane?: WavePlaneFrameInput;

  positionJitter?: Vector3Like | number;

  randomize?: boolean;

  rows: number;

  rowSpacing?: number;

  spacing?: number;

}

declare class ThinBatchInlineBuilder {

  at(origin: WavePointInput): ThinBatchInlineBuilder;

  at(x: number, y: number, z: number): ThinBatchInlineBuilder;

  inRange(range: PlacementRangeInputSet): ThinBatchInlineBuilder;

  inTotal(n: number): ThinBatchInlineBuilder;

  notInRange(range: PlacementRangeInputSet): ThinBatchInlineBuilder;

  onEachInstance(cb: (index: number, position: Vector3) => ThinBatchPlacementOverride | void): ThinBatchInlineBuilder;

  originAt(origin: WavePointInput): ThinBatchInlineBuilder;

  snapToSurface(surface: WaveTerrainSurface): ThinBatchInlineBuilder;

  withCount(n: number): ThinBatchInlineBuilder;

  withRandomYaw(min?: number, max?: number): ThinBatchInlineBuilder;

  withScaleRange(min: number, max: number): ThinBatchInlineBuilder;

  withSeed(seed: number): ThinBatchInlineBuilder;

  withYawRange(min: number, max: number): ThinBatchInlineBuilder;

  withYOffset(offset: number): ThinBatchInlineBuilder;

  alignToPath(align?: boolean): this;

  endAt(v: WavePointInput): this;

  from(v: WavePointInput): this;

  place(): waveThinBatch;

  randomizeAlongPath(random?: boolean): this;

  startFrom(v: WavePointInput): this;

  to(v: WavePointInput): this;

  withJitter(jitter: Vector3Like | number): this;

  withSpacing(s: number): this;

  withUpVector(up: Vector3): this;

}

interface ThinBatchInlineOptions {

  count: number;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachInstance?: ((index: number, position: Vector3) => ThinBatchPlacementOverride | void) | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  surface?: WaveTerrainSurface | undefined;

  yawRange?: [ number, number ] | undefined;

  yOffset?: number | undefined;

  alignToTangent?: boolean;

  end: WavePointInput;

  positionJitter?: Vector3Like | number;

  randomAlongPath?: boolean;

  spacing?: number;

  start: WavePointInput;

  up?: Vector3;

}

declare class ThinBatchInRangeBuilder {

  at(origin: WavePointInput): ThinBatchInRangeBuilder;

  at(x: number, y: number, z: number): ThinBatchInRangeBuilder;

  inRange(range: PlacementRangeInputSet): ThinBatchInRangeBuilder;

  inTotal(n: number): ThinBatchInRangeBuilder;

  notInRange(range: PlacementRangeInputSet): ThinBatchInRangeBuilder;

  onEachInstance(cb: (index: number, position: Vector3) => ThinBatchPlacementOverride | void): ThinBatchInRangeBuilder;

  originAt(origin: WavePointInput): ThinBatchInRangeBuilder;

  snapToSurface(surface: WaveTerrainSurface): ThinBatchInRangeBuilder;

  withCount(n: number): ThinBatchInRangeBuilder;

  withRandomYaw(min?: number, max?: number): ThinBatchInRangeBuilder;

  withScaleRange(min: number, max: number): ThinBatchInRangeBuilder;

  withSeed(seed: number): ThinBatchInRangeBuilder;

  withYawRange(min: number, max: number): ThinBatchInRangeBuilder;

  withYOffset(offset: number): ThinBatchInRangeBuilder;

  constructor(spawner: WaveSpawner, range: WaveRange | string, batch?: waveThinBatch);

  evenlySpaced(): this;

  facing(target: TransformReferenceLike | WavePointInput): this;

  insideRange(): this;

  onRangeSurface(): this;

  place(): waveThinBatch;

  with(batch: waveThinBatch): this;

  withInset(inset: number): this;

  withJitter(jitter: Vector3Like | number): this;

  withRandomStrength(strength: number): this;

}

interface ThinBatchInRangeOptions {

  count: number;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachInstance?: ((index: number, position: Vector3) => ThinBatchPlacementOverride | void) | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  surface?: WaveTerrainSurface | undefined;

  yawRange?: [ number, number ] | undefined;

  yOffset?: number | undefined;

  facing?: TransformReferenceLike | WavePointInput;

  inset?: number;

  positionJitter?: Vector3Like | number;

  random?: boolean | "surface";

  randomStrength?: number;

  range: WaveRange | string;

}

interface ThinBatchKinematicMotionAxisCurves {

  x?: WaveValueCurveInput;

  y?: WaveValueCurveInput;

  z?: WaveValueCurveInput;

}

interface ThinBatchKinematicMotionConfig {

  offsetScaleByIndex?: ThinBatchKinematicMotionAxisCurves;

  phaseByIndex?: WaveValueCurveInput;

  positionOffset: ThinBatchKinematicMotionAxisCurves;

  seed?: number;

  speedByIndex?: WaveValueCurveInput;

}

type ThinBatchMotionSettleSleepCallback = (event: ThinBatchMotionSettleSleepEvent) => void;

interface ThinBatchMotionSettleSleepEvent {

  dynamicCount: number;

  settledCount: number;

  settledRatio: number;

  sleptIndices: readonly number[];

  unsettledCount: number;

  unsettledRatio: number;

}

interface ThinBatchMotionSettleSleepOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  activationPriority?: number;

  linearSpeed?: number;

  maxUnsettledCount?: number;

  onSleep?: ThinBatchMotionSettleSleepCallback;

  positionDelta?: number;

  settledRatio?: number;

  stableFrames?: number;

  unsettledRatio?: number;

}

interface ThinBatchMotionSettleSleepPolicy {

  activationPriority: number;

  linearSpeed: number;

  maxUnsettledCount: number;

  positionDelta: number;

  settledRatio: number;

  stableFrames: number;

  unsettledRatio: number;

}

declare class ThinBatchNearDetectionScope {

  constructor(_batch: waveThinBatch, _target: ThinBatchNearTarget);

  closestWithin(radius: number, tagMask?: bigint): DetectionHit | null;

  within(radius: number, tagMask?: bigint): DetectionResult;

}

type ThinBatchNearTarget = Vector3Like | WaveSpatial3DEntity | ThinBatchNearWorldPositionTarget | cmp_transform;

type ThinBatchNearWorldPositionTarget = { getWorldPosition(): Vector3; }

declare class ThinBatchOnPathBuilder {

  at(origin: WavePointInput): ThinBatchOnPathBuilder;

  at(x: number, y: number, z: number): ThinBatchOnPathBuilder;

  inRange(range: PlacementRangeInputSet): ThinBatchOnPathBuilder;

  inTotal(n: number): ThinBatchOnPathBuilder;

  notInRange(range: PlacementRangeInputSet): ThinBatchOnPathBuilder;

  onEachInstance(cb: (index: number, position: Vector3) => ThinBatchPlacementOverride | void): ThinBatchOnPathBuilder;

  originAt(origin: WavePointInput): ThinBatchOnPathBuilder;

  snapToSurface(surface: WaveTerrainSurface): ThinBatchOnPathBuilder;

  withCount(n: number): ThinBatchOnPathBuilder;

  withRandomYaw(min?: number, max?: number): ThinBatchOnPathBuilder;

  withScaleRange(min: number, max: number): ThinBatchOnPathBuilder;

  withSeed(seed: number): ThinBatchOnPathBuilder;

  withYawRange(min: number, max: number): ThinBatchOnPathBuilder;

  withYOffset(offset: number): ThinBatchOnPathBuilder;

  alignToPath(align?: boolean): this;

  along(path: WaveCurveInput): this;

  followingPath(path: WaveCurveInput): this;

  place(): waveThinBatch;

  randomizeAlongPath(random?: boolean): this;

  withJitter(jitter: Vector3Like | number): this;

  withSpacing(s: number): this;

  withUpVector(up: Vector3): this;

}

interface ThinBatchOnPathOptions {

  count: number;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachInstance?: ((index: number, position: Vector3) => ThinBatchPlacementOverride | void) | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  surface?: WaveTerrainSurface | undefined;

  yawRange?: [ number, number ] | undefined;

  yOffset?: number | undefined;

  alignToTangent?: boolean;

  path: WaveCurveInput;

  positionJitter?: Vector3Like | number;

  randomAlongPath?: boolean;

  spacing?: number;

  up?: Vector3;

}

declare class ThinBatchOnSurfaceBuilder {

  at(origin: WavePointInput): ThinBatchOnSurfaceBuilder;

  at(x: number, y: number, z: number): ThinBatchOnSurfaceBuilder;

  inRange(range: PlacementRangeInputSet): ThinBatchOnSurfaceBuilder;

  inTotal(n: number): ThinBatchOnSurfaceBuilder;

  notInRange(range: PlacementRangeInputSet): ThinBatchOnSurfaceBuilder;

  onEachInstance(cb: (index: number, position: Vector3) => ThinBatchPlacementOverride | void): ThinBatchOnSurfaceBuilder;

  originAt(origin: WavePointInput): ThinBatchOnSurfaceBuilder;

  snapToSurface(surface: WaveTerrainSurface): ThinBatchOnSurfaceBuilder;

  withCount(n: number): ThinBatchOnSurfaceBuilder;

  withScaleRange(min: number, max: number): ThinBatchOnSurfaceBuilder;

  withSeed(seed: number): ThinBatchOnSurfaceBuilder;

  withYOffset(offset: number): ThinBatchOnSurfaceBuilder;

  constructor(spawner: WaveSpawner, batch?: waveThinBatch, surface?: SpawnSurface);

  alignToNormal(align?: boolean): this;

  followSurfaceDeformation(follow?: boolean): this;

  notInRiver(river: SurfaceRiverNoPlaceSource, options?: SurfaceRiverNoPlaceOptions): this;

  onSurface(surface: SpawnSurface): this;

  onTerrain(surface: SpawnSurface): this;

  place(): waveThinBatch;

  projectFrom(point: TransformReferenceLike | WavePointInput): this;

  withJitter(jitter: Vector3Like | number): this;

  withRandomYaw(min?: number, max?: number): this;

  withSurfaceOffset(offset: number): this;

  withYawRange(min: number, max: number): this;

}

interface ThinBatchOnSurfaceOptions {

  count: number;

  inRange?: PlacementRangeInputSet | undefined;

  notInRange?: PlacementRangeInputSet | undefined;

  onEachInstance?: ((index: number, position: Vector3) => ThinBatchPlacementOverride | void) | undefined;

  scaleRange?: [ number, number ] | undefined;

  seed?: number | undefined;

  yOffset?: number | undefined;

  alignToNormal?: boolean;

  followSurfaceDeformation?: boolean;

  positionJitter?: Vector3Like | number;

  projectFrom?: TransformReferenceLike | WavePointInput;

  surface: SpawnSurface;

  surfaceOffset?: number;

  yawRange?: [number, number];

}

type ThinBatchPhysicsBodyAngularImpulseArgs = [impulse: Vector3Like | DirectionInput] | [axis: Vector3Like | DirectionInput, strength: number];

interface ThinBatchPhysicsBodyDiagnostics {

  readonly contactCallbackCount: number;

  readonly contactObserverCount: number;

  readonly denseContactAdmissionWarningIssued: boolean;

  readonly nativeBatchActive: boolean | null;

  readonly nativeBodyCount: number;

  readonly nativeChangedPoseRunCount: number;

  readonly nativeChangedPoseSpanCount: number;

  readonly settlementActiveCandidateCount: number;

  readonly settlementCandidatesScannedLastTick: number;

  readonly settlementDynamicCount: number;

  readonly settlementEnabled: boolean;

}

type ThinBatchPhysicsBodyForceArgs = [hit: RigidBodyInteractionHitInput, strength?: number] | [force: Vector3Like | DirectionInput, contactPoint?: RigidBodyContactPointInput] | [direction: Vector3Like | DirectionInput, strength: number, contactPoint?: RigidBodyContactPointInput];

type ThinBatchPhysicsBodyImpulseArgs = [hit: RigidBodyInteractionHitInput, strength?: number] | [impulse: Vector3Like | DirectionInput, contactPoint?: RigidBodyContactPointInput] | [direction: Vector3Like | DirectionInput, strength: number, contactPoint?: RigidBodyContactPointInput];

interface ThinBatchPhysicsBodyIndexBackend<TDone> {

  clearConstantForce(name?: string): TDone;

  clearForces(): TDone;

  disposeConstraint(id: string): boolean;

  getAngularVelocityAtIndex(index: number): Vector3Like | null;

  getCenterWorldAtIndex(index: number): Vector3Like | null;

  getConstraint(id: string): unknown | undefined;

  getLinearVelocityAtIndex(index: number): Vector3Like | null;

  hasConstraint(id: string): boolean;

  onContactAtIndex(index: number, callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): TDone;

  onContactBeginAtIndex(index: number, callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): TDone;

  onContactContinueAtIndex(index: number, callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): TDone;

  onContactEndAtIndex(index: number, callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): TDone;

  readonly owner: WaveEntity;

  setAngularDampingAtIndex(index: number, damping: number): TDone;

  setConstantForceAtIndex(index: number, name: string, forceOrConfig: ThinBatchConstantForceConfig | Vector3Like | DirectionInput, strengthOrOptions?: number | ThinBatchConstantForceOptions, options?: ThinBatchConstantForceOptions): TDone;

  setGravityFactorAtIndex(index: number, factor: number): TDone;

  setLinearDampingAtIndex(index: number, damping: number): TDone;

  setMassAtIndex(index: number, mass: number): TDone;

  setTargetTransformAtIndex(index: number, position: WavePointInput, rotation?: QuaternionLike): TDone;

  useDynamicBodyAtIndex(index: number): TDone;

  useKinematicBodyAtIndex(index: number): TDone;

  useStaticBodyAtIndex(index: number): TDone;

}

declare class ThinBatchPhysicsBodyIndexScope<TBackend extends ThinBatchPhysicsBodyIndexBackend<unknown> = ThinBatchPhysicsBodyIndexBackend<unknown>> implements PhysicsConstraintEndpoint {

  constructor(_physics: TBackend, _index: number, _validateIndex: ThinBatchIndexValidator);

  addAngularVelocity(delta: Vector3Like | DirectionInput): this;

  addAngularVelocity(dx: number, dy: number, dz: number): this;

  addAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): this;

  addAngularVelocityArgs(...args: ThinBatchPhysicsBodyVectorArgs): this;

  addLinearVelocity(delta: Vector3Like | DirectionInput): this;

  addLinearVelocity(dx: number, dy: number, dz: number): this;

  addLinearVelocity(direction: Vector3Like | DirectionInput, speed: number): this;

  addLinearVelocityArgs(...args: ThinBatchPhysicsBodyVectorArgs): this;

  applyAngularImpulse(impulse: Vector3Like | DirectionInput): this;

  applyAngularImpulse(axis: Vector3Like | DirectionInput, strength: number): this;

  applyAngularImpulseArgs(...args: ThinBatchPhysicsBodyAngularImpulseArgs): this;

  applyForce(hit: RigidBodyInteractionHitInput, strength?: number): this;

  applyForce(force: Vector3Like | DirectionInput, contactPoint?: RigidBodyContactPointInput): this;

  applyForce(direction: Vector3Like | DirectionInput, strength: number, contactPoint?: RigidBodyContactPointInput): this;

  applyForceArgs(...args: ThinBatchPhysicsBodyForceArgs): this;

  applyImpulse(hit: RigidBodyInteractionHitInput, strength?: number): this;

  applyImpulse(impulse: Vector3Like | DirectionInput, contactPoint?: RigidBodyContactPointInput): this;

  applyImpulse(direction: Vector3Like | DirectionInput, strength: number, contactPoint?: RigidBodyContactPointInput): this;

  applyImpulseArgs(...args: ThinBatchPhysicsBodyImpulseArgs): this;

  applyTorque(torque: Vector3Like | DirectionInput): this;

  applyTorque(x: number, y: number, z: number): this;

  applyTorque(axis: Vector3Like | DirectionInput, strength: number): this;

  applyTorqueArgs(...args: ThinBatchPhysicsBodyVectorArgs): this;

  clearConstantForce(name?: string): this;

  clearForces(): this;

  get constraintEndpointLabel(): string;

  get constraintInstanceIndex(): number;

  constrainTo(target: PhysicsConstraintEndpoint): ConstraintBuilder;

  get constraintRuntimeUnitScale(): Vector3Like;

  createConstraintConfig(id: string, target: PhysicsConstraintEndpoint, config: ConstraintConfig): PhysicsConstraintProjectionResult;

  disableGravity(): this;

  disposeConstraint(id: string): boolean;

  done(): TBackend;

  enableGravity(factor?: number): this;

  generateConstraintId(): string;

  getAngularVelocity(): Vector3Like | null;

  getCenterWorld(): Vector3Like | null;

  getConstraint(id: string): unknown | undefined;

  getLinearVelocity(): Vector3Like | null;

  hasConstraint(id: string): boolean;

  ignoreGravity(): this;

  get index(): number;

  inFrameOf(target: TransformReferenceLike): WaveRigidBodyFrameScope<this>;

  inLocalFrame(): WaveRigidBodyFrameScope<this>;

  inParentFrame(depth?: number): WaveRigidBodyFrameScope<this>;

  inWorldFrame(): WaveRigidBodyFrameScope<this>;

  get isConstraintEndpointDisposed(): boolean;

  get nativeConstraintBodyForConstraint(): unknown | null;

  onContact(callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactBegin(callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactContinue(callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactEnd(callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): this;

  get owner(): WaveEntity;

  requestNativeConstraintBody(): void;

  setAngularDamping(damping: number): this;

  setAngularVelocity(velocity: Vector3Like | DirectionInput): this;

  setAngularVelocity(x: number, y: number, z: number): this;

  setAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): this;

  setAngularVelocityArgs(...args: ThinBatchPhysicsBodyVectorArgs): this;

  setConstantForce(name: string, config: ThinBatchConstantForceConfig): this;

  setConstantForce(name: string, force: Vector3Like | DirectionInput, options?: ThinBatchConstantForceOptions): this;

  setConstantForce(name: string, direction: Vector3Like | DirectionInput, strength: number, options?: ThinBatchConstantForceOptions): this;

  setGravityFactor(factor: number): this;

  setLinearDamping(damping: number): this;

  setLinearVelocity(velocity: Vector3Like | DirectionInput): this;

  setLinearVelocity(x: number, y: number, z: number): this;

  setLinearVelocity(direction: Vector3Like | DirectionInput, speed: number): this;

  setLinearVelocityArgs(...args: ThinBatchPhysicsBodyVectorArgs): this;

  setMass(mass: number): this;

  setTargetTransform(position: WavePointInput, rotation?: QuaternionLike): this;

  useDynamicBody(): this;

  useKinematicBody(): this;

  useStaticBody(): this;

  worldPointToConstraintLocal(worldPoint: WavePointInput): Vector3Like;

}

type ThinBatchPhysicsBodyVectorArgs = [vector: Vector3Like | DirectionInput] | [x: number, y: number, z: number] | [direction: Vector3Like | DirectionInput, strength: number];

type ThinBatchPhysicsBodyVectorInput = Vector3Like | DirectionInput;

interface ThinBatchPlacementOverride {

  position?: Vector3Like;

  rotation?: Quaternion;

  scale?: Vector3Like;

}

interface ThinBatchSurfaceAttachmentContact {

  readonly normal: Vector3;

  readonly position: Vector3;

}

interface ThinBatchSurfaceAttachmentContactInput {

  readonly faceIndex?: number;

  readonly hitNormal?: Vector3Like;

  readonly hitPoint: Vector3Like;

  readonly meshId?: string;

  readonly meshName?: string;

}

interface ThinBatchTextureDepthOptions {

  readonly direction?: DirectionInput;

  readonly maxDistance: number;

  readonly randomness?: number;

  readonly seed?: number;

}

declare class ThinBatchTexturePopulationBuilder {

  along(columnDirection: DirectionInput, rowDirection: DirectionInput): this;

  apply(): ThinBatchTexturePopulationResult;

  asGrid(rows: number, cols: number, spacing: number): this;

  at(origin: WavePointInput): this;

  colorFromTexture(channel?: "rgb" | WaveTextureCpuChannel): this;

  depthFrom(channel: WaveTextureCpuChannel, options: ThinBatchTextureDepthOptions): this;

  sampling(mode: WaveTextureCpuSampling): this;

  scaleInstancesBy(scale: number): this;

  whereMask(channel: WaveTextureCpuChannel, threshold: number): this;

}

interface ThinBatchTexturePopulationIntent {

  readonly colorChannel: "rgb" | WaveTextureCpuChannel | null;

  readonly cols: number;

  readonly columnDirection: SerializableVector3;

  readonly depthChannel: WaveTextureCpuChannel | null;

  readonly depthDirection: SerializableVector3;

  readonly depthDistance: number;

  readonly depthRandomness: number;

  readonly instanceScale: number;

  readonly maskChannel: WaveTextureCpuChannel | null;

  readonly maskThreshold: number;

  readonly origin: SerializableVector3;

  readonly randomSeed: number;

  readonly rowDirection: SerializableVector3;

  readonly rows: number;

  readonly sampling: WaveTextureCpuSampling;

  readonly spacing: number;

  readonly textureAsset: string;

}

interface ThinBatchTexturePopulationResult {

  readonly error?: string;

  readonly instancesCreated: number;

  readonly success: boolean;

}

interface ThinBatchTransformAnimationBackend {

  animateInstanceTransformIntent(index: number, intent: TransformVerbIntent, config: TransformVerbAnimationConfig): TransitionLifecycleHandle<Record<string, number>>;

}

type ThinBatchTransformFrame = "world" | "parent" | "local";

declare class ThinBatchTransformFrameScope implements WaveTransformIntentAnimationExecutor {

  constructor(_transform: cmp_thinBatchTransform, _index: number, _validateIndex?: ThinBatchIndexValidator | undefined, _animationBackend?: ThinBatchTransformAnimationBackend | undefined);

  done(): cmp_thinBatchTransform;

  inLocalFrame(): this;

  inParentFrame(): this;

  inWorldFrame(): this;

  keepMoving(direction: DirectionInput): WaveTransformAnimationBuilder;

  keepRotatingAround(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingAlong(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingBy(): WaveTransformAnimationBuilder;

  keepScalingToward(axis: DirectionInput): WaveTransformAnimationBuilder;

  moveBy(axis: DirectionInput, units: number): this;

  moveX(units: number): this;

  moveY(units: number): this;

  moveZ(units: number): this;

  get root(): cmp_thinBatchTransform;

  rotateAroundBy(axis: DirectionInput, degrees: number): this;

  rotateAroundTo(axis: DirectionInput, degrees: number): this;

  rotateBy(axis: DirectionInput, degrees: number): this;

  rotateByQuaternion(delta: Quaternion): this;

  scaleAlongBy(axis: DirectionInput, factor: number): this;

  scaleAlongTo(axis: DirectionInput, value: number): this;

  scaleTowardBy(axis: DirectionInput, factor: number): this;

  scaleTowardTo(axis: DirectionInput, value: number): this;

}

type ThinBatchTransformTerms = "world" | "parent";

type ThinkingChoiceRunner<TTarget = unknown> = (target: TTarget, ...args: readonly unknown[]) => unknown;

interface ThinkingDecisionChoice<TTarget = unknown> {

  allowedInStates?: string[];

  blockedInStates?: string[];

  id?: string;

  perform: ThinkingChoiceRunner<TTarget>;

}

type ThinkingDecisionChoiceInput<TTarget = unknown> = ThinkingChoiceRunner<TTarget> | ThinkingDecisionChoice<TTarget>;

interface ThinkingDecisionChoiceStats {

  qValue: number;

  timesSelected: number;

  totalReward: number;

}

interface ThinkingDecisionPerformanceReport {

  averageChoiceValue: number;

  averageReward: number;

  bestScore: number;

  currentScore: number;

  decisionStepsToTarget: number;

  discountFactor: number;

  eligibilityLambda: number;

  exploitationCount: number;

  explorationCount: number;

  explorationEntropy: number;

  explorationRate: number;

  featureBudget: number;

  learningEfficiency: number;

  learningRate: number;

  negativeOutcomes: number;

  neutralOutcomes: number;

  positiveOutcomes: number;

  targetReached: boolean;

  targetScore: number | null;

  totalDecisionSteps: number;

  usedFeatureCount: number;

  winRate: number;

}

type ThinkingDecisionStateLabelCallback<TTarget = unknown> = (target: TTarget) => string;

type ThinkingDecisionStateValueCallback<TTarget = unknown> = (target: TTarget) => number;

interface ThinkingDecisionStats {

  accelerationMode: ThinkingAccelerationMode;

  activeFeatureCount: number;

  averageReward: number;

  bestScore: number;

  choiceStats: ThinkingDecisionChoiceStats[];

  currentDecisionState: string;

  currentScore: number;

  eligibilityLambda: number;

  featureBudget: number;

  isLearningEnabled: boolean;

  lastChoiceId: string | null;

  lastChoiceIndex: number | null;

  learningBackend: ThinkingLearningBackend;

  objectiveType: GoalType;

  targetReached: boolean;

  targetScore: number | null;

  totalDecisionSteps: number;

}

interface ThinkingDiscreteNumberEncoding {

  precision?: number;

  rangeMax?: number;

  rangeMin?: number;

  segments?: number;

  stepSize?: number;

  wrapPeriod?: number;

}

type ThinkingDiscreteSignalCallback<TTarget = unknown> = (target: TTarget) => ThinkingDiscreteSignalValue;

interface ThinkingDiscreteSignalOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  bucketSize?: number;

  falseLabel?: string;

  number?: ThinkingDiscreteNumberEncoding;

  trueLabel?: string;

}

interface ThinkingDiscreteSignalSource<TTarget = unknown> {

  callback: ThinkingDiscreteSignalCallback<TTarget>;

  name: string;

  options: ThinkingDiscreteSignalOptions;

}

type ThinkingDiscreteSignalValue = string | number | boolean | null | undefined;

declare class ThinkingDiscreteStateBuilder<TTarget = unknown, TResult = unknown> {

  constructor(apply: ThinkingDiscreteStateBuilderApply<TTarget, TResult>, _ownerName?: string | undefined);

  done(): TResult;

  entityState(enabled?: boolean): this;

  falseLabel(label: string): this;

  features(options: ThinkingFeatureOptions): this;

  flag(name: string, callback?: (target: TTarget) => boolean, options?: ThinkingDiscreteSignalOptions): this;

  label(name: string, callback?: ThinkingDiscreteSignalCallback<TTarget>, options?: ThinkingDiscreteSignalOptions): this;

  number(name: string, callback?: (target: TTarget) => number, options?: ThinkingDiscreteSignalOptions): this;

  precision(decimals: number): this;

  previousState(enabled?: boolean): this;

  primaryState(enabled?: boolean): this;

  range(min: number, max: number): this;

  read(callback: ThinkingDiscreteSignalCallback<TTarget>, options?: ThinkingDiscreteSignalOptions): this;

  segments(count: number): this;

  step(size: number): this;

  trueLabel(label: string): this;

  wrap(period: number): this;

}

type ThinkingDiscreteStateBuilderApply<TTarget, TResult> = (sources: ReadonlyArray<ThinkingDiscreteStateBuilderSource<TTarget>>, settings: ThinkingDiscreteStateBuilderSettings) => TResult;

interface ThinkingDiscreteStateBuilderSettings {

  featureOptions?: ThinkingFeatureOptions;

  includePreviousState?: boolean;

  includePrimaryState?: boolean;

}

interface ThinkingDiscreteStateBuilderSource<TTarget = unknown> {

  callback: ThinkingDiscreteSignalCallback<TTarget>;

  name: string;

  options: ThinkingDiscreteSignalOptions;

}

interface ThinkingDiscreteStateConfig<TTarget = unknown> {

  includePreviousState: boolean;

  includePrimaryState: boolean;

  signals: Array<ThinkingDiscreteSignalSource<TTarget>>;

  stateAgeBucketSeconds: number | null;

  systemStates: ThinkingObservedSystemState[];

}

interface ThinkingEligibilityOptions {

  lambda?: number;

}

interface ThinkingFeatureOptions {

  budget?: number;

  experienceCapacity?: number;

  maxActiveFeatures?: number;

  tilings?: number;

}

declare class ThinkingHttpRequestBuilder {

  constructor(_thinking: cmp_thinking, endpointId?: string);

  accessMode(mode: HttpRequestRuntimeOptions["accessMode"]): this;

  base64(dataBase64: string, mimeType?: string): this;

  delete(): this;

  endpoint(id: string): this;

  get(): this;

  header(name: string, value: string): this;

  headers(headers: Record<string, string>): this;

  json(json: unknown): this;

  method(method: HttpMethod): this;

  patch(): this;

  path(path: string): this;

  post(): this;

  put(): this;

  query(params: Record<string, string | number | boolean | undefined | null>): this;

  responseAuto(): this;

  responseBase64(): this;

  responseJson(): this;

  responseText(): this;

  retries(n: number): this;

  send(): Promise<HttpResponse>;

  sendJson<T = unknown>(): Promise<T>;

  sendText(): Promise<string>;

  text(text: string, contentType?: string): this;

  timeout(ms: number): this;

  url(urlOverride: string): this;

}

declare enum ThinkingLearningBackend {

  ExpectedSarsaLambda = "expectedSarsaLambda",

}

interface ThinkingLLMChatOptions {

  accessMode?: LLMAccessMode | undefined;

  signal?: unknown | undefined;

  targetClientId?: string | undefined;

  context?: WaveSceneDataRecord;

  maxTokens?: number;

  providerId?: string;

  system?: string;

  temperature?: number;

  timeoutMs?: number;

}

interface ThinkingLLMChoiceCall {

  args?: readonly WaveSceneDataValue[];

  confidence?: number;

  id: string;

  reason?: string;

}

type ThinkingLLMContextProvider<TTarget = unknown> = (target: TTarget) => WaveSceneDataValue;

interface ThinkingLLMContextProviderEntry<TTarget = unknown> {

  name: string;

  provider: ThinkingLLMContextProvider<TTarget>;

}

interface ThinkingLLMConversationMemoryConfig {

  enabled: boolean;

  maxTurns: number;

}

interface ThinkingLLMConversationMessage {

  requestId?: string;

  role: ThinkingLLMRole;

  text: string;

  timestamp: number;

}

type ThinkingLLMDecisionCallback<TTarget = unknown> = (result: ThinkingLLMDecisionResult<TTarget>) => void;

interface ThinkingLLMDecisionOptions {

  accessMode?: LLMAccessMode | undefined;

  signal?: unknown | undefined;

  targetClientId?: string | undefined;

  context?: WaveSceneDataRecord;

  maxTokens?: number;

  providerId?: string;

  temperature?: number;

  timeoutMs?: number;

}

interface ThinkingLLMDecisionPolicy<TTarget = unknown> {

  accessMode?: LLMAccessMode | undefined;

  signal?: unknown | undefined;

  targetClientId?: string | undefined;

  context?: ThinkingLLMContextProvider<TTarget>;

  fallbackChoice?: string;

  goal: string;

  maxChoices?: number;

  maxTokens?: number;

  providerId?: string;

  requireKnownChoice?: boolean;

  temperature?: number;

  timeoutMs?: number;

}

interface ThinkingLLMDecisionResult<TTarget = unknown> {

  choices: readonly ThinkingLLMChoiceCall[];

  owner: TTarget;

  parsed: unknown;

  providerId?: string;

  rejectedChoices: readonly ThinkingLLMRejectedChoice[];

  requestId: string;

  response: LLMResponse;

}

declare enum ThinkingLLMDecisionState {

  Cancelled = "cancelled",

  DecisionAvailable = "decisionAvailable",

  Failed = "failed",

  Idle = "idle",

  Queued = "queued",

  RequestingDecision = "requestingDecision",

}

type ThinkingLLMErrorCallback<TTarget = unknown> = (error: ThinkingLLMErrorResult<TTarget>) => void;

interface ThinkingLLMErrorResult<TTarget = unknown> {

  error: unknown;

  kind: "chat" | "decision";

  owner: TTarget;

  requestId: string;

}

interface ThinkingLLMPersonaConfig {

  bio?: string;

  instructions?: readonly string[];

  knowledge?: readonly string[];

  mood?: string;

  name?: string;

  style?: string;

}

interface ThinkingLLMRejectedChoice {

  id: string | null;

  raw: unknown;

  reason: string;

}

type ThinkingLLMReplyCallback<TTarget = unknown> = (result: ThinkingLLMReplyResult<TTarget>) => void;

type ThinkingLLMReplyPolicyConfig = WaveCharacterReplyPolicy;

interface ThinkingLLMReplyResult<TTarget = unknown> {

  input: string;

  owner: TTarget;

  providerId?: string;

  requestId: string;

  response: LLMResponse;

  text: string;

}

declare enum ThinkingLLMReplyState {

  Cancelled = "cancelled",

  Failed = "failed",

  Queued = "queued",

  Ready = "ready",

  ReplyAvailable = "replyAvailable",

  RequestingReply = "requestingReply",

  Unconfigured = "unconfigured",

}

type ThinkingLLMRole = "user" | "assistant";

interface ThinkingLLMState<TTarget = unknown> {

  contextProviders: ThinkingLLMContextProviderEntry<TTarget>[];

  conversation: ThinkingLLMConversationMessage[];

  decisionCallbacks: ThinkingLLMDecisionCallback<TTarget>[];

  decisionPolicy: ThinkingLLMDecisionPolicy<TTarget> | null;

  errorCallbacks: ThinkingLLMErrorCallback<TTarget>[];

  memory: ThinkingLLMConversationMemoryConfig;

  persona: ThinkingLLMPersonaConfig;

  prompt: string | null;

  providerId: string | null;

  replyCallbacks: ThinkingLLMReplyCallback<TTarget>[];

  replyPolicy: ThinkingLLMReplyPolicyConfig;

}

interface ThinkingObservedSystemState {

  alias: string;

  key?: string;

  lane: SystemStateLane;

}

type ThinkingPotentialCallback<TTarget = unknown> = (target: TTarget) => number;

declare enum ThinkingPredictionModel {

  Analog = "analog",

  Auto = "auto",

  Dmd = "dmd",

  Harmonic = "harmonic",

  Kinematic = "kinematic",

}

declare enum ThinkingPredictionState {

  Failed = "failed",

  Idle = "idle",

  Predicting = "predicting",

  PredictionReady = "predictionReady",

  SamplingSignals = "samplingSignals",

  UpdatingModel = "updatingModel",

}

interface ThinkingPredictorStats {

  activeModel: ThinkingPredictionModel;

  bufferSize: number;

  confidence: number;

  dominantFrequencyHz: number;

  harmonicCount: number;

  patternType: PatternType;

  recentError: number;

  signalDimensions: number;

  totalObservations: number;

}

type ThinkingScoreCallback<TTarget = unknown> = (target: TTarget) => number;

type ThinkingSignalCallback = () => ThinkingSignalValue;

interface ThinkingSignalPattern {

  confidence: number;

  type: PatternType;

}

type ThinkingSignalValue = readonly number[];

type ThinkingTargetReachedCallback<TTarget = unknown> = (target: TTarget) => void;

type TickCallback<T> = BivariantCallback<[target: T, deltaTime: number], void>;

interface TickCallbackOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  copyOnClone?: boolean;

  name?: string;

}

type TimeOfDayConfig = EnabledEnvironmentPatch<TimeOfDayState>;

declare class TimeOfDayConfigurator<TEngine extends unknown = unknown> {

  constructor(_sky: SkyConfigurator<TEngine>);

  apply(): SkyConfigurator<TEngine>;

  bindMainLight(value?: boolean): this;

  configure(patch: TimeOfDayConfig): this;

  dayLengthSeconds(value: number): this;

  disable(): SkyConfigurator<TEngine>;

  iblIntensity(night: number, day: number): this;

  maxSunElevationDegrees(value: number): this;

  pause(): this;

  paused(value?: boolean): this;

  resume(): this;

  startAt(timeHours: number): this;

  sunAzimuthOffsetDegrees(value: number): this;

  timeHours(value: number): this;

  timeScale(value: number): this;

}

interface TimeOfDayState {

  bindMainLightToSun: boolean;

  dayLengthSeconds: number;

  enabled: boolean;

  iblIntensityDay?: number;

  iblIntensityNight?: number;

  maxSunElevationDegrees: number;

  paused: boolean;

  sunAzimuthOffsetDegrees: number;

  timeHours: number;

  timeScale: number;

}

type ToolLocalOrWorldSpace = Extract<WaveTransformFrameSpace, "local" | "world">;

interface TouchControlConfig {

  doubleTapAction: string | null;

  joystickDeadZone: number;

  joystickFixed: boolean;

  joystickOpacity: number;

  joystickSize: number;

  layout: TouchControlLayout;

  lookRegionWidth: number;

  moveRegionWidth: number;

  pinchAction: string | null;

  showVirtualControls: boolean;

  swipeInterpretation: "movement" | "look" | "action";

  swipeThreshold: number;

  swipeVelocityThreshold: number;

  tiltDeadZone: number;

  tiltSensitivity: number;

  twoFingerTapAction: string | null;

  useTilt: boolean;

}

declare enum TouchControlLayout {

  Custom = "custom",

  DualJoystick = "dualJoystick",

  SingleJoystick = "singleJoystick",

  SwipeZones = "swipeZones",

  TapToMove = "tapToMove",

  TiltToMove = "tiltToMove",

}

interface TouchGestureInputData {

  center: SerializableVector2;

  rotation?: number;

  scale?: number;

  timestamp: number;

  touchCount: number;

  velocity?: SerializableVector2;

}

interface TouchInputData {

  entityId?: number;

  heldDurationMs: number;

  heldFor: WaveTimeSpan;

  heldTicks: number;

  position: SerializableVector2;

  pressure: number;

  radius: SerializableVector2;

  timestamp: number;

  touchId: number;

}

interface TouchMoveInputData {

  delta: SerializableVector2;

  position: SerializableVector2;

  pressure: number;

  timestamp: number;

  touchId: number;

}

interface TrailOpts {

  anchorOffset?: Partial<Vector3Like>;

  blend?: RibbonOpts["blend"];

  color?: ColorLike;

  density?: NumLike;

  depthWrite?: boolean;

  direction?: FxVelocityConeDirectionInput;

  directionSpace?: VelocityConeDirectionSpace;

  drag?: NumLike;

  fade?: [number, number][];

  fanOut?: number | [number, number][];

  glow?: RibbonOpts["glow"];

  lifetime?: NumLike;

  maxPoints?: number;

  maxSegmentLength?: number;

  phaseDrift?: number;

  smoothing?: number;

  speed?: NumLike;

  spreadAngle?: NumLike;

  strandCount?: number;

  strandSpread?: number;

  strandWidthScale?: number;

  turbulence?: number;

  twist?: number;

  twistProfile?: [number, number][];

  widthProfile?: [number, number][];

  worldSpace?: boolean;

}

interface TransformDirectionAccessor {

  getAngularRates(space?: WaveSpace): Vector3;

  getDirection(direction: DirectionInput, space?: WaveSpace): Vector3;

  getEulerAngles(space?: WaveSpace): Vector3;

  getPosition(space?: WaveSpace): Vector3;

  getPositionToRef?(space: WaveSpace, target: Vector3): Vector3;

  getRotation(space?: WaveSpace): Quaternion;

  getSemanticDirection(direction: Direction): Vector3;

  getSemanticDirectionToRef?(direction: Direction, target: Vector3): Vector3;

  getTransformCarrierNodeForRead(): TransformNode;

  getVelocity(space?: WaveSpace): Vector3;

}

interface TransformDomainAdapter {

  adaptTransformIntent(transform: cmp_transform, intent: TransformVerbIntent): TransformVerbIntent;

  assertChildAttachmentAllowed?(transform: cmp_transform, child: cmp_transform, operation: string): void;

  assertOriginChangeAllowed?(transform: cmp_transform, operation: string): void;

  assertParentChangeAllowed?(transform: cmp_transform, parent: cmp_transform | null, operation: string): void;

  assertScaleAllowed?(transform: cmp_transform, operation: string): void;

  assertScaleValueAllowed?(transform: cmp_transform, scale: Vector3Like, operation: string): void;

  assertTransformWriteAllowed?(transform: cmp_transform, operation: string): void;

}

interface TransformHistoryRecordingOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  depth?: number;

  every?: WaveTimeRule;

  reset?: boolean;

}

interface TransformHistorySample {

  parent: ResolvedWorldTransformSnapshot;

  recordedAtSeconds: number;

  tickNumber: number;

  world: ResolvedWorldTransformSnapshot;

}

type TransformPhysicsMotionMode = "direct" | "animated";

interface TransformPoseTransitionIntent {

  readonly from?: ResolvedWorldTransformSnapshot;

  readonly to: ResolvedWorldTransformSnapshot;

}

type TransformReferenceLike = TransformDirectionAccessor | WaveSpatial3DEntity | { controller: TransformReferenceLike | null | undefined; }

interface TransformSnapshotLike {

  position: Vector3Like;

  rotation: QuaternionLike;

  scale: Vector3Like;

}

interface TransformTurnTowardDirectionTarget {

  readonly directionInput: DirectionInput;

  readonly x: number;

  readonly y: number;

  readonly z: number;

}

interface TransformVerbAnimationConfig<State extends Record<string, number> = Record<string, number>> {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  callbacks?: TransitionLifecycleCallbacks<State>;

  delay?: TransformVerbTimeSpec;

  duration?: TransformVerbTimeSpec;

  easingEffect?: WaveEasing;

  progressCurve?: WaveValueCurveInput;

  rate?: TransformVerbRateSpec;

  runFor?: TransformVerbTimeSpec;

}

type TransformVerbIntent = { kind: "moveTo"; target: TransformReferenceLike | WavePointInput; terms: WaveTransformTermsSpace; } | { kind: "moveByDirection"; direction: DirectionInput; scope: TransformVerbScope; distance?: number; } | { kind: "turnTo"; target: TransformReferenceLike | WavePointInput | DirectionInput | TransformTurnTowardDirectionTarget; scope: TransformVerbScope; byLocking?: DirectionInput; withTolerance?: number; } | { kind: "angularControl"; axis: DirectionInput; scope: TransformVerbScope; deltaDegrees: number; } | { kind: "rotateTo"; rotation: Quaternion; terms: WaveTransformTermsSpace; } | { kind: "rotateByQuaternion"; delta: Quaternion; scope: TransformVerbScope; } | { kind: "rotateAround"; axis: DirectionInput; scope: TransformVerbScope; deltaDegrees?: number; targetDegrees?: number; } | { kind: "scaleTo"; value: number | Vector3Like; terms: WaveTransformTermsSpace; } | { kind: "scaleBy"; value?: number | Vector3Like; terms: WaveTransformTermsSpace; } | { kind: "scaleAlong"; axis: DirectionInput; scope: TransformVerbScope; target?: number; factor?: number; } | { kind: "scaleToward"; axis: DirectionInput; scope: TransformVerbScope; target?: number; factor?: number; } | { kind: "fitBetween"; start: FitBetweenTarget; end: FitBetweenTarget; options: FitBetweenOptions; }

type TransformVerbModeInput = TransformVerbMode;

type TransformVerbRateSpec = WaveRateSpec;

interface TransformVerbScope {

  frame: WaveTransformFrameSpace;

  frameOf?: TransformReferenceLike;

  parentFrameDepth: number;

}

type TransformVerbTimeSpec = WaveTimeSpanSpec;

type TransitionCancellationPolicy = "finish" | "revert" | "holdCurrent";

type TransitionChainCompleteCallback = () => void;

type TransitionChainTerminalCallback = () => void;

interface TransitionLifecycleCallbacks<State extends Record<string, number>> {

  onComplete?: (controller: WaveAnimationController, state: State) => void;

  onFailed?: () => void;

  onLoopComplete?: (loop: number, controller: WaveAnimationController, state: State) => void;

  onProgress?: (progress: number, controller: WaveAnimationController, state: State) => void;

  onStart?: (controller: WaveAnimationController, state: State) => void;

  onStopped?: () => void;

  onUpdate?: (controller: WaveAnimationController, state: State) => void;

}

declare class TransitionLifecycleChainHandle {

  constructor(first: TransitionLifecycleChainStepHandle);

  get completed(): boolean;

  get failed(): boolean;

  onComplete(callback?: TransitionChainCompleteCallback): this;

  onFailed(callback?: TransitionChainTerminalCallback): this;

  onStopped(callback?: TransitionChainTerminalCallback): this;

  stop(): void;

  get stopped(): boolean;

  thenDo(step: TransitionLifecycleThenDoStep): this;

}

interface TransitionLifecycleChainStepHandle {

  readonly completed: boolean;

  readonly failed: boolean;

  stop(): void;

  readonly stopped: boolean;

}

interface TransitionLifecycleStartOptions {

  dispatchProgress?: boolean;

}

type TransitionLifecycleTerminalReason = "completed" | "failed" | "stopped";

type TransitionLifecycleThenDoStep = () => TransitionLifecycleChainStepHandle | void;

type TriggerEventCallback = (event: KinematicTriggerEvent, controller: cmp_kinematicController) => void;

declare class TwistBuilder {

  animate(): WaveGeometryDeformAnimationBuilder;

  apply(): MeshEditResult;

  around(axis: DirectionInput): this;

  forceMergeMesh(force?: boolean): this;

  inRegion(start: number, end: number): this;

  mode(mode: DeformApplyMode): this;

  regionEnd(pos: number): this;

  regionStart(pos: number): this;

  totalDegrees(deg: number): this;

  withPhaseOffset(deg: number): this;

}

interface TwistOptions {

  applyMode?: DeformApplyMode;

  axis: DirectionInput;

  endPos?: number;

  phaseOffsetDeg?: number;

  startPos?: number;

  totalDegrees: number;

}

type TypedEventHandler<TEventData> = (event: WaveEvent<TEventData>) => void;

type UI2DCallbackOptions = BaseInteractableCallbackOptions;

type UI2DCanvasClickCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DCanvasClickData>) => void;

interface UI2DCanvasClickData {

  button: MouseButton;

  canvasX: number;

  canvasY: number;

}

type UI2DCanvasPointerCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DCanvasPointerData>) => void;

interface UI2DCanvasPointerData {

  button: MouseButton;

  canvasX: number;

  canvasY: number;

  screenPoint: WaveScreenPointRef;

  screenX: number;

  screenY: number;

}

type UI2DClickCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DClickData>) => void;

interface UI2DClickData {

  button: MouseButton;

  canvasX?: number;

  canvasY?: number;

}

type UI2DDragCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DDragData>) => void;

interface UI2DDragData {

  button: MouseButton;

  canvasX: number;

  canvasY: number;

  screenPoint: WaveScreenPointRef;

  screenX: number;

  screenY: number;

  deltaCanvasX: number;

  deltaCanvasY: number;

  deltaScreenX: number;

  deltaScreenY: number;

  heldDurationMs: number;

  heldTicks: number;

  instanceId?: string;

  phase: InputPhase;

  startCanvasX: number;

  startCanvasY: number;

  startScreenX: number;

  startScreenY: number;

  totalCanvasX: number;

  totalCanvasY: number;

  totalDistance: number;

  totalScreenDistance: number;

  totalScreenX: number;

  totalScreenY: number;

}

type UI2DDragMoveCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DDragMoveCallbackContext<TOwner>) => void;

interface UI2DDragMoveCallbackContext<TOwner extends WaveEntity = WaveEntity> {

  drag: UI2DInteractionContext<TOwner, UI2DDragData>;

  handle: UI2DDragMoveHandle<TOwner>;

  owner: TOwner;

  state: UI2DDragMoveSnapshot;

}

interface UI2DDragMoveHandle<TOwner extends WaveEntity = WaveEntity> {

  eventType: CallbackEventType;

  id: string;

  name?: string | undefined;

  off: () => void;

  clearLockedAxes(): UI2DDragMoveHandle<TOwner>;

  getState(): UI2DDragMoveSnapshot;

  lockAxes(...axes: DirectionInput[]): UI2DDragMoveHandle<TOwner>;

  lockAxis(axis: DirectionInput): UI2DDragMoveHandle<TOwner>;

  onEnd(callback: UI2DDragMoveCallback<TOwner>): CallbackHandle;

  onMove(callback: UI2DDragMoveCallback<TOwner>): CallbackHandle;

  onStart(callback: UI2DDragMoveCallback<TOwner>): CallbackHandle;

}

interface UI2DDragMoveOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  holdThreshold?: WaveTimeSpan | undefined;

  name?: string | undefined;

  priority?: number | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  button?: MouseButton;

}

interface UI2DDragMoveSnapshot {

  currentPosition: SerializableVector2 | null;

  distanceTraveled: number;

  endPosition: SerializableVector2 | null;

  isActive: boolean;

  lastEvent: UI2DDragData | null;

  startPosition: SerializableVector2 | null;

  totalDelta: SerializableVector2 | null;

}

type UI2DHoldingCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DHoldingData>) => void;

interface UI2DHoldingData {

  button: MouseButton;

  canvasX?: number | undefined;

  canvasY?: number | undefined;

  heldDurationMs: number;

  heldTicks: number;

}

type UI2DHoverCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DHoverData>) => void;

interface UI2DHoverData {

  canvasX?: number;

  canvasY?: number;

}

type UI2DInputCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DInputChangeData>) => void;

interface UI2DInputChangeData {

  value: string;

}

type UI2DInputSubmitCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DInputSubmitData>) => void;

interface UI2DInputSubmitData {

  value: string;

}

interface UI2DInteractionContext<TOwner extends WaveEntity = WaveEntity, TData = unknown> {

  clientId?: string;

  data: TData;

  owner: TOwner;

  timestamp: number;

}

type UI2DPressCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DPressData>) => void;

interface UI2DPressData {

  button: MouseButton;

  canvasX?: number;

  canvasY?: number;

}

type UI2DReleaseCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DReleaseData>) => void;

interface UI2DReleaseData {

  button: MouseButton;

  canvasX?: number | undefined;

  canvasY?: number | undefined;

}

type UI2DSliderCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DSliderChangeData>) => void;

interface UI2DSliderChangeData {

  value: number;

}

type UI2DToggleCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DToggleChangeData>) => void;

interface UI2DToggleChangeData {

  value: boolean;

}

type UI2DTouchCallback<TOwner extends WaveEntity = WaveEntity> = (ctx: UI2DInteractionContext<TOwner, UI2DTouchData>) => void;

interface UI2DTouchData {

  canvasX?: number;

  canvasY?: number;

}

type UICanvasAffine2D = readonly [number, number, number, number, number, number];

interface UICanvasCallbackOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

}

type UICanvasCompositeOperation = "source-over";

type UICanvasFillRule = "nonzero" | "evenodd";

type UICanvasLineCap = "butt" | "round" | "square";

type UICanvasLineJoin = "round" | "bevel" | "miter";

interface UICanvasMeshBindingOptions {

  channel?: UICanvasMeshTextureChannel;

  materialOwnership?: UICanvasMeshMaterialOwnership;

}

type UICanvasMeshMaterialOwnership = "private" | "current";

interface UICanvasMeshTarget {

  material?: unknown;

  name?: string;

}

type UICanvasMeshTextureChannel = "diffuse" | "emissive" | "opacity";

declare class UICanvasPathBuilder implements WaveCurve2DPointSource {

  constructor(name?: string | null);

  anchor(anchor?: UICanvasAnchor, options?: UICanvasPathToPointsOptions): [number, number];

  arc(cx: number, cy: number, r: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;

  arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;

  circle(cx: number, cy: number, radius: number): this;

  clone(name?: string | null): UICanvasPathBuilder;

  close(): this;

  cubicTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): this;

  dash(pattern: number[]): this;

  ellipse(cx: number, cy: number, rx: number, ry: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): this;

  fill(colorOrOptions?: DrawColor | UICanvasPathFillOptions): this;

  fitBox(targetBox: UICanvasBox, options?: UICanvasFitBoxOptions): this;

  getBounds(options?: UICanvasPathToPointsOptions): UICanvasBox;

  lineTo(x: number, y: number): this;

  lineWidth(width: number): this;

  mirrorX(axisX?: number): this;

  mirrorY(axisY?: number): this;

  moveTo(x: number, y: number): this;

  get name(): string | null;

  opacity(value: number): this;

  polygon(points: readonly (readonly [number, number])[]): this;

  quadTo(cpx: number, cpy: number, x: number, y: number): this;

  rect(x: number, y: number, width: number, height: number): this;

  rotate(angle: number): this;

  roundRect(x: number, y: number, width: number, height: number, radius: number): this;

  scale(sx: number, sy?: number): this;

  stroke(colorOrOptions?: DrawColor | UICanvasPathStrokeOptions, width?: number): this;

  svgPath(pathData: string): this;

  toPoints(options?: UICanvasPathToPointsOptions): [number, number][];

  toPointsToRef(options: UICanvasPathToPointsOptions, result: WaveCurve2DMutablePoint[], spare: WaveCurve2DMutablePoint[]): WaveCurve2DMutablePoint[];

  translate(dx: number, dy: number): this;

}

declare class UICanvasPointerDrawBuilder<TCanvas extends waveUICanvas = waveUICanvas> {

  clearExisting(clear?: boolean): this;

  disable(): TCanvas;

  enable(): TCanvas;

  linear(): this;

  smooth(): this;

  whenFinished(callback: UICanvasPointerDrawActionCallback<UICanvasPointerDrawFinishContext>, options?: Omit<UICanvasCallbackOptions, "elementName">): this;

  whenMoved(callback: UICanvasPointerDrawActionCallback<UICanvasPointerDrawMoveContext>, options?: Omit<UICanvasCallbackOptions, "elementName">): this;

  whenStarted(callback: UICanvasPointerDrawActionCallback<UICanvasPointerDrawStartContext>, options?: Omit<UICanvasCallbackOptions, "elementName">): this;

  withColor(color: ColorInput): this;

  withLineCap(lineCap: UICanvasLineCap): this;

  withLineJoin(lineJoin: UICanvasLineJoin): this;

  withMinDistance(minDistance: number): this;

  withOpacity(opacity: number): this;

  withSmoothing(smoothing: UICanvasCurveSmoothing): this;

  withWidth(width: number): this;

}

type UICanvasTextAlign = "left" | "right" | "center" | "start" | "end";

type UICanvasTextBaseline = "top" | "hanging" | "middle" | "alphabetic" | "ideographic" | "bottom";

type UICanvasValueCurveInput = UICanvasValueCurveEvaluator | WaveValueCurveInput;

interface UIDropdownOption {

  label: string;

  value: string;

}

type UIDropdownOptionInput = string | UIDropdownOption;

declare enum UIHAlign {

  Center = 2,

  Left = 0,

  Right = 1,

}

type UIHorizontalAlignInput = UIHAlign | "left" | "right" | "center";

interface UILogicalInsets {

  readonly bottom: number;

  readonly left: number;

  readonly right: number;

  readonly top: number;

}

declare enum UITextWrapping {

  Ellipsis = 2,

  Html = 4,

  None = 0,

  WordWrap = 1,

}

declare enum UIVAlign {

  Bottom = 1,

  Center = 2,

  Top = 0,

}

type UIVerticalAlignInput = UIVAlign | "top" | "bottom" | "center";

interface UnderwaterOptions {

  baseAbsorptionColor?: [number, number, number];

  colorBlendFactor: number;

  depthFogStrength?: number;

  depthScale?: number;

  desaturationStrength?: number;

  distortionScale?: number;

  distortionSpeed?: number;

  distortionStrength?: number;

  getSurfaceY: () => number | null;

  getWaterBounds?: () => [number, number, number, number] | null;

  waterColor: [number, number, number];

  waterVolumeDepth?: number;

}

type UniformValue = number | number[] | Float32Array | { x: number; y: number; } | Vector3Like | { x: number; y: number; z: number; w: number; } | { r: number; g: number; b: number; } | { r: number; g: number; b: number; a: number; }

interface UpdateSourceOptions {

  snapToNearest?: boolean;

  startProgress?: number;

}

interface ValidatedFxEmitter {

  binding: Readonly<FxSystemEmitterBinding>;

  def: Readonly<FxEmitterDefinition>;

}

interface ValidatedFxSystem {

  def: Readonly<FxSystemDefinition>;

  emitters: ValidatedFxEmitter[];

}

interface ValueDriveSourceState {

  input: number;

  source: number;

  value: number;

}

type ValueDriveState = ValueDriveTimeState | ValueDriveSourceState;

interface ValueDriveTimeState {

  input: number;

  progress: number;

  value: number;

}

interface VATAnimationRange {

  from: number;

  name: string;

  to: number;

}

interface VatBindingValue {

  readonly fps: number;

  readonly kind: "vat";

  readonly layout: VertexAnimationAssetLayout;

  readonly meshId?: string;

  readonly meshMorph?: MeshMorphVertexAnimationInfo;

  readonly modelContentKey: AssetContentKey;

  readonly modelRef: ExactAssetRef<"model">;

  readonly payloadKind: "vat";

  readonly ranges: readonly VATAnimationRange[];

  readonly ref: ExactAssetRef<"animation">;

  readonly serialized: SerializedVertexAnimationAsset;

  readonly targetMeshName?: string;

  readonly texture: unknown;

  readonly topologySignature: string;

  readonly totalFrames: number;

  readonly vertexCount: number;

}

interface VatModelCompatibilityFacts {

  readonly meshId?: string;

  readonly modelContentKey: AssetContentKey;

  readonly topologySignature: string;

  readonly vertexCount: number;

}

interface VatTemplateFacts {

  readonly fps: number;

  readonly meshId?: string;

  readonly meshMorph?: MeshMorphVertexAnimationInfo;

  readonly model: AnimationModelDependencyFacts;

  readonly serialized: SerializedVertexAnimationAsset;

  readonly targetMeshName?: string;

  readonly topologySignature: string;

  readonly totalFrames: number;

  readonly vertexCount: number;

}

type Vec3Like = Vector3Like;

type Vector2Like = MathVector2Like;

type Vector2Like = Vector2 | StructuralVector2Like;

interface Vector2Like {

  x: number;

  y: number;

}

interface Vector3Like {

  x: number;

  y: number;

  z: number;

}

type Vector3Like = MathVector3Like;

type Vector3Like = Vector3 | StructuralVector3Like;

interface VelocityArrowOptions {

  arrowHeadSize?: number | undefined;

  arrowShaftThickness?: number | undefined;

  color?: any;

  decimals?: number | undefined;

  duration?: number | undefined;

  fontAsset?: string | undefined;

  fontSize?: number | undefined;

  labelOffset3D?: any;

  labelOffset3DSpace?: "world" | "local" | undefined;

  length?: number | undefined;

  textColor?: any;

  updateMode?: DevToolUpdateMode | undefined;

  scale?: number;

  showMagnitude?: boolean;

}

type VelocityConeDirectionSpace = Exclude<WavePointSourceSpace, "parent">;

interface VelocityConeOpts {

  direction?: FxVelocityConeDirectionInput;

  directionSpace?: VelocityConeDirectionSpace;

  halfAngleDeg: NumLike;

  speed: NumLike;

}

interface VertexAnimationAsset {

  bakedVertexData: Float32Array | Uint16Array;

  dispose?: () => void;

  fps: number;

  isHalfFloat: boolean;

  layout: VertexAnimationAssetLayout;

  meshMorph?: MeshMorphVertexAnimationInfo;

  name: string;

  ranges: VATAnimationRange[];

  texture: unknown;

  totalFrames: number;

  vertexCount: number;

}

type VertexAnimationAssetLayout = "skinnedMatrixVat" | "meshPositionMorphVat";

interface VertexAnimationBindingOptions {

  readonly asset: string;

  readonly range?: string;

}

type VertexAnimationJSONEncoding = "float32-base64" | "float16-base64";

interface VertexAnimationPlaybackOptions {

  readonly loop?: boolean;

  readonly offsetSeconds?: number;

  readonly speed?: number;

}

type VertexAnimationPlayOptions = VertexAnimationPlaybackOptions & Partial<VertexAnimationBindingOptions>;

type VertexAnimationRootMotionMode = "lock" | "preserve";

declare enum VertexAuthoringMode {

  Absolute = "absolute",

  Incremental = "incremental",

}

interface VertexCache {

  accumulatedAttractStrength?: number;

  accumulatedBendAngle?: number;

  accumulatedExtrudeStrength?: number;

  accumulatedNoiseAmplitude?: number;

  accumulatedRegionalScale?: RegionalScaleAccumulation;

  accumulatedSkewAngle?: number;

  accumulatedTaper?: { startScale: number; endScale: number; }

  accumulatedTwistDegrees?: number;

  readonly geometryData: WaveGeometryData;

  readonly normals?: Float32Array;

  timestamp: number;

  readonly vertexData: WaveVertexDataPayload;

}

type VertexColorChannel = "r" | "g" | "b" | "a";

interface VertexColorResult {

  error?: string;

  success: boolean;

  verticesAffected?: number;

}

declare enum VertexDeleteMode {

  Collapse = "collapse",

  Dissolve = "dissolve",

}

interface VertexDeleteOptions {

  mode?: VertexDeleteMode;

  recomputeNormals?: boolean;

}

declare class VertexEditingBuilder {

  animate(): WaveVertexMotionAnimationBuilder;

  apply(): VertexSelectionResult;

  authorWithWavePoint(callback: (point: wavePoint) => void, options?: WaveAuthoredCallbackOptions): this;

  clearTransform(): this;

  deleteVertex(): this;

  deleteVertices(): this;

  expandNeighbors(rings?: number): this;

  extendInfluenceToWholeMesh(enabled?: boolean): this;

  falloff(falloff: VertexFalloff): this;

  forceMergeMesh(force?: boolean): this;

  getSelection(): VertexSelection | null;

  moveBy(direction: DirectionInput, distance: number): this;

  moveBy(vector: Vector3Like): this;

  origin(point: WavePointInput): this;

  recomputeNormals(enable?: boolean): this;

  rotateAroundBy(axis: DirectionInput, degrees: number): this;

  scaleBy(scale: number | Vector3Like): this;

  selectFace(faceIndex: number): this;

  selectInRadius(center: Vector3Like, radius: number, options?: VertexQueryOptions): this;

  selectNearest(point: Vector3Like, options?: VertexQueryOptions): this;

  selectVertex(index: number): this;

  selectVertexFrom(source: WavePointInput, options?: VertexQueryOptions): this;

  subdivide(options?: VertexSubdivideOptions): this;

  withDeleteMode(mode: VertexDeleteMode): this;

  withInfluence(curve: VertexInfluenceCurve): this;

  withMode(mode: VertexAuthoringMode): this;

  withRadius(radius: number, options?: VertexQueryOptions): this;

  withSubdivision(levelsOrOptions: number | VertexSubdivideOptions, borderRings?: number): this;

}

declare enum VertexInfluenceCurve {

  Gaussian = "gaussian",

  Linear = "linear",

  None = "none",

  Sharp = "sharp",

  Smooth = "smooth",

}

interface VertexMoveOptions {

  falloff?: VertexFalloff;

  influenceScope?: VertexInfluenceScope;

  origin?: Vector3 | Vector3Like;

  recomputeNormals?: boolean;

  space?: VertexEditSpace;

}

interface VertexQueryOptions {

  space?: VertexEditSpace;

}

interface VertexQueryResult {

  error?: string | undefined;

  geometryWritten?: boolean | undefined;

  success: boolean;

  verticesAffected?: number | undefined;

  vertex?: VertexReference;

}

interface VertexReference {

  meshName: string;

  meshUniqueId: number;

  normal: Vector3 | null;

  position: Vector3;

  topologyVersion: number;

  vertexCount: number;

  vertexIndex: number;

  worldNormal: Vector3 | null;

  worldPosition: Vector3;

}

interface VertexSelection {

  center: Vector3;

  meshName: string;

  meshUniqueId: number;

  points: Vector3[];

  topologyVersion: number;

  vertexCount: number;

  vertexIndices: number[];

  worldCenter: Vector3;

  worldPoints: Vector3[];

}

interface VertexSelectionResult {

  error?: string | undefined;

  geometryWritten?: boolean | undefined;

  success: boolean;

  verticesAffected?: number | undefined;

  selection?: VertexSelection;

  topologyVersion?: number;

}

interface VertexSubdivideOptions {

  borderRings?: number;

  levels?: number;

  recomputeNormals?: boolean;

}

interface VertexTopologyResult {

  error?: string | undefined;

  geometryWritten?: boolean | undefined;

  selection?: VertexSelection | undefined;

  success: boolean;

  topologyVersion?: number | undefined;

  verticesAffected?: number | undefined;

  addedTriangles?: number;

  addedVertices?: number;

}

interface VertexTransformOptions {

  falloff?: VertexFalloff | undefined;

  influenceScope?: VertexInfluenceScope | undefined;

  origin?: any;

  recomputeNormals?: boolean | undefined;

  space?: VertexEditSpace | undefined;

  manifoldReferencePositions?: ArrayLike<number>;

  rotationAxis?: DirectionInput;

  rotationDegrees?: number;

  scale?: number | Vector3 | Vector3Like;

  translation?: Vector3 | Vector3Like;

  translationAxis?: DirectionInput;

  translationDistance?: number;

}

interface VideoBindingIntent {

  readonly timeline?: "shared" | "independent";

}

interface VideoFacts {

  readonly durationSeconds?: number;

  readonly hasAudio?: boolean;

  readonly height?: number;

  readonly width?: number;

}

type VideoFiniteDomEventType = "playing" | "pause" | "ended" | "seeking" | "seeked" | "timeupdate";

interface VideoFiniteEventHub {

  dispose(): void;

  subscribe(listener: VideoFiniteEventListener): () => void;

}

type VideoFiniteEventListener = (type: VideoFiniteDomEventType, event: Event) => void;

interface VideoFiniteRuntimePoolDiagnostics {

  readonly activeDomListenerHubs: number;

  readonly activeIndependentNativeRuntimes: number;

  readonly activeSharedNativeRuntimes: number;

  readonly activeVideoUpdatePumps: number;

}

type ViewNdcPoint = Vector2 & { readonly [WAVE_SCREEN_COORDINATE_SPACE]: "viewNdc"; }

type ViewNormalizedPoint = Vector2 & { readonly [WAVE_SCREEN_COORDINATE_SPACE]: "viewNormalized"; }

type ViewPixelPoint = Vector2 & { readonly [WAVE_SCREEN_COORDINATE_SPACE]: "viewPixel"; }

interface VisionInputData {

  confidence?: number;

  handIndex?: number;

  name?: VisionGestureName;

  side?: "left" | "right";

  timestamp: number;

  type: "gesture" | "hand";

}

interface VisionLandmarksTapData {

  face?: { landmarks?: SerializableVector3[]; expressions: Record<string, number>; } | undefined;

  gestures?: { name: VisionGestureName; confidence: number; handIndex: number; }[] | undefined;

  hands?: { side: "left" | "right"; score: number; landmarks: SerializableVector3[]; worldLandmarks?: SerializableVector3[]; }[] | undefined;

  pose?: { landmarks: SerializableVector3[]; worldLandmarks?: SerializableVector3[]; } | undefined;

  timestamp: number;

}

interface VisionSnapshot {

  face?: { landmarks?: SerializableVector3[]; expressions: Record<string, number>; }

  gestures?: Array<{ name: VisionGestureName; confidence: number; handIndex: number; }>;

  hands?: Array<{ side: "left" | "right"; score: number; landmarks: SerializableVector3[]; worldLandmarks?: SerializableVector3[]; }>;

  pose?: { landmarks: SerializableVector3[]; worldLandmarks?: SerializableVector3[]; }

}

type Visual3DModelAuthoringInput = string | WaveModelInput | Visual3DModelInput;

interface Visual3DModelDomainAdapter {

  assertStructureMutationAllowed(model: cmp_visual3DModel, operation: string): void;

  isStructureOwnerManaged(model: cmp_visual3DModel): boolean;

  runAttachmentTransformAuthority<TResult>(model: cmp_visual3DModel, operation: () => TResult): TResult;

}

interface Visual3DModelGeneratedAttachmentInput {

  readonly disposeMaterial?: boolean;

  readonly mesh: unknown;

  readonly name: string;

  readonly updatable?: boolean;

}

type Visual3DModelInput = AssetRef<"model"> | AssetDefinition<"model">;

interface Visual3DModelUseOptions {

  readonly geometry?: "shared" | "private" | "copyOnWrite" | undefined;

  readonly hydration?: ModelHydrationIntent | undefined;

  readonly materials?: "shared" | "private" | "copyOnWrite" | undefined;

  readonly projection?: ModelBindingProjection | undefined;

  readonly topology?: ModelTopologyIntent | undefined;

  readonly use?: "copy" | "direct" | "instance" | undefined;

  readonly part?: WaveModelPartRef;

}

declare class Visual3DModelVoxelizingBuilder<TOwner extends wave3DObject = wave3DObject, TExecution extends VoxelExecutionThread = "mainThread"> {

  constructor(model: module_visual3DModelVoxelFacade<TOwner>);

  apply(): TExecution extends "workerThread" ? VoxelGridResultAsync : VoxelGridResult;

  asMesh(): Visual3DModelVoxelizingOutputBuilder<TOwner, TExecution, unknown>;

  asModel(name?: string): Visual3DModelVoxelizingOutputBuilder<TOwner, TExecution, string>;

  asObjects(options?: VoxelEntityOutputOptions): Visual3DModelVoxelizingOutputBuilder<TOwner, TExecution, WaveGroup<wave3DObject>>;

  asPointCloud(options?: VoxelPointCloudOptions): Visual3DModelVoxelizingOutputBuilder<TOwner, TExecution, wavePointCloudBatch>;

  asProps(options?: VoxelEntityOutputOptions): Visual3DModelVoxelizingOutputBuilder<TOwner, TExecution, WaveGroup<waveProp>>;

  asThinBatch(): Visual3DModelVoxelizingOutputBuilder<TOwner, TExecution, waveThinBatch>;

  executeTerminal<TResult>(syncTerminal: VoxelSyncTerminal<TResult>, asyncTerminal: VoxelAsyncTerminal<TResult>): TResult | Promise<TResult>;

  executeTerminalAsync<TResult>(syncTerminal: VoxelSyncTerminal<TResult>, asyncTerminal: VoxelAsyncTerminal<TResult>): Promise<TResult>;

  includeDisabled(enabled?: boolean): this;

  includeTextures(enabled?: boolean): this;

  onMainThread(): Visual3DModelVoxelizingBuilder<TOwner, "mainThread">;

  onWorkerThread(): Visual3DModelVoxelizingBuilder<TOwner, "workerThread">;

  relativeSize(ratio: number): this;

  sampling(value: number): this;

  samplingResolution(value: number): this;

  shape(shape: VoxelShape): this;

  size(value: number): this;

  surfaceOnly(enabled?: boolean): this;

  usingCapsules(): this;

  usingCubes(): this;

  usingCylinders(): this;

  usingMeshShape(asset: string, options?: VoxelMeshShapeOptions): this;

  usingSpheres(): this;

}

declare class Visual3DModelVoxelizingOutputBuilder<TOwner extends wave3DObject = wave3DObject, TExecution extends VoxelExecutionThread = "mainThread", TResult = unknown> {

  constructor(builder: Visual3DModelVoxelizingBuilder<TOwner, TExecution>, syncTerminal: VoxelSyncTerminal<TResult>, asyncTerminal: VoxelAsyncTerminal<TResult>);

  apply(): VoxelApplyResult<TResult, TExecution>;

  applyAsync(): Promise<TResult>;

}

interface VisualEmissiveDistortionHost {

  clearEmissiveDistortionInput(): void;

  setEmissiveDistortion(config: EmissiveDistortionConfig): void;

  setEmissiveWobbleInput(x: number, y: number): void;

  triggerEmissiveRipple(u?: number, v?: number, strength?: number): void;

}

declare enum VisualLayer {

  Debug = 3,

  Gameplay = 1,

  Ui3D = 2,

  World = 0,

}

interface VisualModelBooleanBatchStep {

  inputs: readonly VisualModelBooleanInput[];

  op: WaveBooleanOperation;

  strategy?: WaveBooleanBatchStrategy;

}

type VisualModelBooleanInput = CutToolLike | unknown | readonly unknown[] | cmp_visual3DModel | WaveGeometryData | WaveVertexDataInput;

interface VisualModelBooleanOptions {

  readonly degeneracyEpsilon?: number | undefined;

  readonly removeCoincidentFaces?: boolean | undefined;

  closeBoundaryLoops?: boolean;

  destroyTool?: boolean;

  forceMergeMesh?: boolean;

  preserveMaterials?: boolean;

  recomputeNormals?: boolean;

  removeDegenerateFaces?: boolean;

  strategy?: WaveBooleanBatchStrategy;

  weldEpsilon?: number;

  weldVertices?: boolean;

}

interface VisualModelMeshTarget {

  readonly entry?: MeshEntry;

  readonly id?: string;

  readonly kind: "mesh";

  readonly mesh?: MeshRef;

  readonly name?: string;

  readonly ref?: MeshRef;

  readonly slot?: number;

}

interface VisualModelPartTarget {

  readonly entity?: wave3DObject | null;

  readonly entry?: PartEntry;

  readonly id?: string;

  readonly info?: VisualPartInfo;

  readonly kind: "part";

  readonly name?: string;

  readonly part?: PartRef;

  readonly ref?: PartRef;

  readonly slot?: number;

}

interface VisualModelPoseApplyOptions {

  readonly allowMimicOverrides?: boolean;

  readonly clamp?: boolean;

  readonly createParts?: boolean;

}

interface VisualModelPosePreviewOptions {

  readonly allowMimicOverrides?: boolean | undefined;

  readonly clamp?: boolean | undefined;

  readonly createParts?: boolean | undefined;

  readonly apply?: boolean;

}

type VisualModelTarget = VisualModelMeshTarget | VisualModelPartTarget | VisualModelTargetPayload | WaveModelVisualTargetMetadata | MeshEntry | unknown | WaveModelMeshReferenceMetadata | PartEntry | VisualPartInfo | VisualPartId | wave3DObject;

interface VisualModelTargetPayload {

  readonly kind: "mesh" | "part";

  readonly mesh?: VisualModelMeshTarget | MeshEntry | unknown | WaveModelMeshReferenceMetadata;

  readonly part?: VisualModelPartTarget | PartEntry | VisualPartInfo | VisualPartId | wave3DObject;

  readonly primary?: VisualModelMeshTarget | VisualModelPartTarget | MeshEntry | unknown | WaveModelMeshReferenceMetadata | PartEntry | VisualPartInfo | VisualPartId | wave3DObject;

}

interface VisualPartId {

  uid: string;

}

type VisualPartId = { uid: string; }

interface VisualPartInfo<TEntity = WaveEntity> {

  entity?: TEntity | null;

  id: VisualPartId;

  includeInPhysics: boolean;

  lifecycleState?: WaveModelPartLifecycleState;

  meshes: unknown[];

  metadata?: WaveModelPartMetadata;

  name: string;

  parentPartId: VisualPartId | null;

  promoted: boolean;

}

type VisualPartRef = string | WaveModelPartRef | VisualPartId | VisualPartInfo | wave3DObject;

type VisualVideoSource = string | AssetRef<"video"> | ExactAssetRef<"video">;

interface VolumeShellOpts {

  fresnel?: { power?: NumLike; color?: ColorLike; }

  impactRipple?: { maxConcurrent?: number; speed?: NumLike; width?: NumLike; fadeTime?: number; color?: ColorLike; }

  length?: NumLike;

  material: string;

  normalOffset?: NumLike;

  radius?: NumLike;

  structure?: WaveRangeShape | WaveSurfaceSourceStructure;

  twoSided?: boolean;

}

declare class VolumetricCloudsConfigurator<TEngine extends unknown = unknown> {

  constructor(_sky: SkyConfigurator<TEngine>);

  altitude(value: number): this;

  apply(): SkyConfigurator<TEngine>;

  bodyColor(value: ColorInput): this;

  bottomColor(value: ColorInput): this;

  cirrus(): this;

  colors(body: ColorInput, bottom: ColorInput): this;

  configure(patch: VolumetricCloudConfig): this;

  coverage(value: number): this;

  cumulus(): this;

  density(value: number): this;

  disable(): SkyConfigurator<TEngine>;

  enable(): this;

  evolveShapeEvery(seconds: number): this;

  formation(value: WaveCloudFormation): this;

  freezeShape(): this;

  layers(value: NonNullable<VolumetricCloudConfig["layers"]>): this;

  lightAbsorption(value: number): this;

  quality(value: WaveCloudQuality): this;

  scale(value: number): this;

  steps(value: number): this;

  storm(): this;

  stratus(): this;

  thickness(value: number): this;

  untinted(): this;

  wind(speed: number, direction?: { x: number; z: number; }): this;

  windDirection(direction: { x: number; z: number; }): this;

  windSpeed(value: number): this;

}

declare class VolumetricFogConfigurator<TEngine extends unknown = unknown> {

  apply(): WaveScene<TEngine>;

  apply(patch: Partial<VolumetricFogState>): WaveScene<TEngine>;

  color(hexColor: number): VolumetricFogConfigurator<TEngine>;

  density(val: number): VolumetricFogConfigurator<TEngine>;

  deriveColorFromAtmosphere(): VolumetricFogConfigurator<TEngine>;

  disable(): VolumetricFogConfigurator<TEngine>;

  enable(): VolumetricFogConfigurator<TEngine>;

  fadeInOver(val: number): VolumetricFogConfigurator<TEngine>;

  heightFalloff(val: number): VolumetricFogConfigurator<TEngine>;

  heightOffset(val: number): VolumetricFogConfigurator<TEngine>;

  maxDistance(val: number): VolumetricFogConfigurator<TEngine>;

  noiseIntensity(val: number): VolumetricFogConfigurator<TEngine>;

  noiseScale(val: number): VolumetricFogConfigurator<TEngine>;

  renderScale(val: number): VolumetricFogConfigurator<TEngine>;

  startAtDistance(val: number): VolumetricFogConfigurator<TEngine>;

  steps(val: number): VolumetricFogConfigurator<TEngine>;

  useAtmosphereColor(): VolumetricFogConfigurator<TEngine>;

  useCustomColor(): VolumetricFogConfigurator<TEngine>;

  windSpeed(x: number, y: number, z: number): VolumetricFogConfigurator<TEngine>;

  windSpeed(speed: { x: number; y: number; z: number; }): VolumetricFogConfigurator<TEngine>;

}

interface VolumetricFogState {

  fadeInDistance: number;

  maxDistance: number;

  startDistance: number;

  color: number;

  colorSource?: "custom" | "atmosphere";

  density: number;

  enabled: boolean;

  heightFalloff: number;

  heightOffset: number;

  noiseIntensity: number;

  noiseScale: number;

  renderScale: number;

  steps: number;

  windSpeed: { x: number; y: number; z: number; }

}

interface VolumetricLightOptions {

  color?: ColorInput;

  decay?: number;

  density?: number;

  exposure?: number;

  lightMesh: unknown;

  passRatio?: number;

  samples?: number;

  weight?: number;

}

interface VoxelAbsoluteSizeSpec {

  readonly mode: "absolute";

  readonly value: number;

}

type VoxelApplyResult<TResult, TExecution extends VoxelExecutionThread> = TExecution extends "workerThread" ? Promise<TResult> : TResult;

type VoxelAsyncTerminal<TResult> = (result: VoxelGridResultAsync) => Promise<TResult>;

interface VoxelData {

  color: number;

  position: Vector3;

}

type VoxelEntityAssetReuseMode = "sharedVoxelShape";

type VoxelEntityMaterialIsolationMode = "private";

type VoxelEntityMaterialReuseMode = "byColor" | "perVoxel";

type VoxelEntityMaterialStyle = "sourceStyled" | "plain";

interface VoxelEntityOutputOptions {

  readonly assetReuse?: VoxelEntityAssetReuseMode;

  readonly includeInPhysics?: boolean;

  readonly materialIsolation?: VoxelEntityMaterialIsolationMode;

  readonly materialReuse?: VoxelEntityMaterialReuseMode;

  readonly materialStyle?: VoxelEntityMaterialStyle;

}

type VoxelExecutionThread = "mainThread" | "workerThread";

interface VoxelGridResult {

  asMesh(): unknown;

  asModel(name?: string): string;

  asObjects(options?: VoxelEntityOutputOptions): WaveGroup<wave3DObject>;

  asPointCloud(options?: VoxelPointCloudOptions): wavePointCloudBatch;

  asProps(options?: VoxelEntityOutputOptions): WaveGroup<waveProp>;

  asThinBatch(): waveThinBatch;

  readonly voxels: readonly VoxelData[];

}

interface VoxelGridResultAsync {

  asMesh(): Promise<unknown>;

  asModel(name?: string): Promise<string>;

  asObjects(options?: VoxelEntityOutputOptions): Promise<WaveGroup<wave3DObject>>;

  asPointCloud(options?: VoxelPointCloudOptions): Promise<wavePointCloudBatch>;

  asProps(options?: VoxelEntityOutputOptions): Promise<WaveGroup<waveProp>>;

  asThinBatch(): Promise<waveThinBatch>;

  readonly voxels: Promise<readonly VoxelData[]>;

}

interface VoxelizationOptions {

  execution?: VoxelExecutionThread;

  includeDisabled?: boolean;

  includeTextures?: boolean;

  samplingResolution?: number;

  shape?: VoxelShape;

  size?: VoxelSizeInput;

  surfaceOnly?: boolean;

}

type VoxelMeshShapeCollider = VoxelPrimitiveShape | "none";

interface VoxelMeshShapeDescriptor {

  readonly asset: string;

  readonly collider?: VoxelMeshShapeCollider;

  readonly fit?: VoxelMeshShapeFit;

  readonly kind: "mesh";

}

type VoxelMeshShapeFit = "contain" | "cover";

interface VoxelMeshShapeOptions {

  readonly collider?: VoxelMeshShapeCollider;

  readonly fit?: VoxelMeshShapeFit;

}

interface VoxelPointCloud {

  color: ColorInputAlpha;

  position: Vector3;

}

interface VoxelPointCloudOptions {

  baseAlpha?: number;

  dissolve?: false | PointCloudDissolveOptions;

  emissiveColor?: ColorInput | unknown;

  maxPoints?: number;

  pathFollow?: PointCloudPathFollowOptions;

  pointScale?: number;

  pointScaleJitter?: number;

  positionJitter?: number;

  randomSeed?: number;

  turbulence?: boolean | PointCloudTurbulenceOptions;

}

type VoxelPrimitiveShape = "cube" | "sphere" | "cylinder" | "capsule";

interface VoxelPrimitiveShapeDescriptor {

  readonly kind: "primitive";

  readonly primitive: VoxelPrimitiveShape;

}

interface VoxelRelativeSizeSpec {

  readonly basis?: VoxelSizeBasis;

  readonly mode: "relative";

  readonly ratio: number;

}

type VoxelShape = VoxelPrimitiveShape | VoxelPrimitiveShapeDescriptor | VoxelMeshShapeDescriptor;

type VoxelSizeBasis = "longestAabbEdge";

type VoxelSizeInput = VoxelAbsoluteSizeSpec | VoxelRelativeSizeSpec;

type VoxelSyncTerminal<TResult> = (result: VoxelGridResult) => TResult;

interface WakeOpts {

  anchorOffset?: Partial<Vector3Like_2> | undefined;

  blend?: "multiply" | "alpha" | "additive" | undefined;

  color?: WaveColorValueInput | undefined;

  density?: WaveNumberValueInput | undefined;

  depthWrite?: boolean | undefined;

  direction?: FxVelocityConeDirectionInput | undefined;

  directionSpace?: VelocityConeDirectionSpace | undefined;

  drag?: WaveNumberValueInput | undefined;

  fade?: [ number, number ][] | undefined;

  fanOut?: number | [ number, number ][] | undefined;

  glow?: FxGlowConfig | undefined;

  lifetime?: WaveNumberValueInput | undefined;

  maxPoints?: number | undefined;

  maxSegmentLength?: number | undefined;

  phaseDrift?: number | undefined;

  smoothing?: number | undefined;

  speed?: WaveNumberValueInput | undefined;

  spreadAngle?: WaveNumberValueInput | undefined;

  strandCount?: number | undefined;

  strandSpread?: number | undefined;

  strandWidthScale?: number | undefined;

  turbulence?: number | undefined;

  twist?: number | undefined;

  twistProfile?: [ number, number ][] | undefined;

  widthProfile?: [ number, number ][] | undefined;

  worldSpace?: boolean | undefined;

  softness?: "tight" | "balanced" | "loose";

}

type WalkablePredicate<T extends WaveSpatial3DObject> = (step: Wave3DGridPathStep<T>) => boolean;

declare enum WaterBodyPreset {

  Cinematic = "cinematic",

  High = "high",

  Low = "low",

  Medium = "medium",

  Minimal = "minimal",

  Ultra = "ultra",

}

type WaterSurfaceMaterialInput = string | WaveMaterialInput<"water">;

declare const WAVE_ACTIVE_PHYSICS_HUMANOID_JOINTS: Readonly<{ readonly spineBase: "pelvis_lowerSpine"; readonly spineUpper: "lowerSpine_upperSpine"; readonly neck: "upperSpine_neck"; readonly head: "neck_head"; readonly leftShoulder: "upperSpine_leftUpperArm"; readonly leftElbow: "leftUpperArm_leftLowerArm"; readonly leftWrist: "leftLowerArm_leftHand"; readonly rightShoulder: "upperSpine_rightUpperArm"; readonly rightElbow: "rightUpperArm_rightLowerArm"; readonly rightWrist: "rightLowerArm_rightHand"; readonly leftHip: "pelvis_leftUpperLeg"; readonly leftKnee: "leftUpperLeg_leftLowerLeg"; readonly leftAnkle: "leftLowerLeg_leftFoot"; readonly rightHip: "pelvis_rightUpperLeg"; readonly rightKnee: "rightUpperLeg_rightLowerLeg"; readonly rightAnkle: "rightLowerLeg_rightFoot"; }>;

declare const WAVE_ASSEMBLY_RECIPE_VERSION: 1;

declare const WAVE_BOUND_AUTHORED_CALLBACK: unique symbol;

declare const WAVE_CAPABILITY_ID_BRAND: unique symbol;

declare const WAVE_COMPILED_ASSEMBLY_TERMINAL_VERSION: 1;

declare const WAVE_GAUSSIAN_SPLAT_LOD_MODES: readonly ["off", "adaptive"];

declare const WAVE_GAUSSIAN_SPLAT_PICKING_MODES: readonly ["off", "bounds", "gpu"];

declare const WAVE_GAUSSIAN_SPLAT_QUALITY_MODES: readonly ["full", "balanced", "adaptive", "performance"];

declare const WAVE_GAUSSIAN_SPLAT_RENDER_MODES: readonly ["splat", "triangle", "auto"];

declare const WAVE_GAUSSIAN_SPLAT_SH_MODES: readonly ["off", "base", "full", "adaptive"];

declare const WAVE_GAUSSIAN_SPLAT_SHADOW_MODES: readonly ["off", "scene", "ibl"];

declare const WAVE_GAUSSIAN_SPLAT_SOURCE_FORMATS: readonly ["splat", "ply-splat", "spz", "spz4", "sog", "sog-json"];

declare const WAVE_GEOMETRY_DATA_INSTANCE: unique symbol;

declare const WAVE_GEOMETRY_INFLUENCE_FIELD_KIND = "wave-geometry-influence-field";

declare const WAVE_GEOMETRY_INFLUENCE_FIELD_VERSION = 1;

declare const WAVE_GPU_CONTACT_EVENT_FIELDS: Readonly<{ readonly point: "vec3"; readonly normal: "vec3"; readonly relativeVelocityWorld: "vec3"; readonly tangentialRelativeVelocityWorld: "vec3"; readonly impactSpeed: "number"; readonly tangentialSpeed: "number"; readonly solverImpulse: "number"; readonly impactEnergy: "number"; readonly fidelity: "u32"; readonly sourceSample: "u32"; readonly receiverSlot: "u32"; }>;

declare const WAVE_GPU_CONTACT_EVENT_SCHEMA: "wave.gpuContactEvent.v1";

declare const WAVE_GPU_DATA_SOURCE_BINDING_PLAN_SCHEMA: "wave.gpuDataSourceBindings.v1";

declare const WAVE_GPU_DRIVEN_MODEL_INPUT_KIND: "waveGpuDrivenModel";

declare const WAVE_GPU_DRIVEN_MODEL_RECIPE_VERSION: 3;

declare const WAVE_GPU_DRIVEN_MODEL_SCHEMA: "wave.gpuDrivenModel.v3";

declare const WAVE_GPU_DRIVEN_TECHNIQUE_SCHEMA: "wave.gpuDrivenTechnique.v2";

declare const WAVE_GPU_EVENT_STREAM_REF_SCHEMA: "wave.gpuEventStreamRef.v1";

declare const WAVE_HEIGHTFIELD_KIND = "waveHeightfield";

declare const WAVE_HEIGHTFIELD_VERSION = 1;

declare const WAVE_LLM_PROVIDERS: readonly ["gemini", "deepseek", "openai", "anthropic", "compatible"];

declare const WAVE_MATERIAL_INPUT_SCHEMA: "wave.materialInput.v1";

declare const WAVE_MATERIAL_PACKAGE_VERSION = 2;

declare const WAVE_MODEL_INPUT_KIND: "wave::model";

declare const WAVE_MODEL_INPUT_VERSION: 3;

declare const WAVE_MODEL_OBJECT_MODEL_VERSION: 2;

declare const WAVE_MODEL_SURFACE_SELECTION_SCHEMA: "wave.modelSurfaceSelection.v1";

declare const WAVE_NATIVE_2D_CONSTRUCTION: unique symbol;

declare const WAVE_OFFICIAL_PREFABS_PLUGIN_ID: "wave.official-prefabs";

declare const WAVE_PHYSICAL_HUMANOID_MODEL_PARTS: Readonly<{ readonly pelvis: "pelvis"; readonly lowerSpine: "lowerSpine"; readonly upperSpine: "upperSpine"; readonly neck: "neck"; readonly head: "head"; readonly face: "face"; readonly leftUpperArm: "leftUpperArm"; readonly leftLowerArm: "leftLowerArm"; readonly leftHand: "leftHand"; readonly rightUpperArm: "rightUpperArm"; readonly rightLowerArm: "rightLowerArm"; readonly rightHand: "rightHand"; readonly leftUpperLeg: "leftUpperLeg"; readonly leftLowerLeg: "leftLowerLeg"; readonly leftFoot: "leftFoot"; readonly rightUpperLeg: "rightUpperLeg"; readonly rightLowerLeg: "rightLowerLeg"; readonly rightFoot: "rightFoot"; }>;

declare const WAVE_PHYSICAL_QUADRUPED_MODEL_PARTS: Readonly<{ readonly body: "body"; readonly head: "head"; readonly frontLeftLeg: "frontLeftLeg"; readonly frontRightLeg: "frontRightLeg"; readonly backLeftLeg: "backLeftLeg"; readonly backRightLeg: "backRightLeg"; readonly neck1: "neck1"; readonly neck2: "neck2"; readonly neck3: "neck3"; readonly tail1: "tail1"; readonly tail2: "tail2"; readonly tail3: "tail3"; readonly tail4: "tail4"; readonly tail5: "tail5"; }>;

declare const WAVE_REFLECTION_POLICY_SCHEMA: "wave.reflectionPolicy.v1";

declare const WAVE_REFLECTION_SOURCE_REF_SCHEMA: "wave.reflectionSourceRef.v1";

declare const WAVE_REFLECTION_SOURCE_SCHEMA: "wave.reflectionSource.v2";

declare const WAVE_RELATIVE_COVERAGE_PLAN_SCHEMA: "wave.relativeCoverage.v2";

declare const WAVE_RESPONSE_SCHEMA: "wave.response.v1";

declare const WAVE_SCAFFOLD_LATTICE_PATTERN: Readonly<{ readonly XBrace: "xBrace"; readonly Horizontal: "horizontal"; readonly Vertical: "vertical"; readonly Grid: "grid"; readonly Empty: "empty"; }>;

declare const WAVE_SCALAR_SURFACE_STATE_REF_SCHEMA: "wave.scalarSurfaceStateRef.v1";

declare const WAVE_SCALAR_SURFACE_STATE_SCHEMA: "wave.scalarSurfaceState.v2";

declare const WAVE_SCENE_PRESENTATION_PLAN_KIND: "waveScenePresentationPlan";

declare const WAVE_SCENE_PRESENTATION_PLAN_VERSION: 1;

declare const WAVE_SCREEN_COORDINATE_SPACE: unique symbol;

declare const WAVE_SCREEN_DIRECTION_SPACE: unique symbol;

declare const WAVE_SPATIAL_DOMAIN: unique symbol;

declare const WAVE_TERRAIN_HEIGHTFIELD_MODEL_RECIPE_VERSION: 1;

declare const WAVE_TERRAIN_LAYER_KIND: "waveTerrainLayer";

declare const WAVE_TERRAIN_LAYER_VERSION: 4;

declare const WAVE_TERRAIN_MATERIAL_VERSION: 4;

declare const WAVE_TERRAIN_RELIEF_DATA_SCHEMA: "wave.terrainReliefData.v1";

declare const WAVE_TERRAIN_RUNTIME_CHECKPOINT_KIND: "waveTerrainRuntimeCheckpoint";

declare const WAVE_TERRAIN_RUNTIME_CHECKPOINT_VERSION: 1;

declare const WAVE_TERRAIN_RUNTIME_DELTA_KIND: "waveTerrainRuntimeDeltaSet";

declare const WAVE_TERRAIN_RUNTIME_DELTA_VERSION: 3;

declare const WAVE_TEXT_MODEL_RECIPE_VERSION: 1;

declare const WAVE_TREE_LEAF_PALETTE: Readonly<{ readonly Natural: "natural"; readonly Spring: "spring"; readonly Summer: "summer"; readonly Autumn: "autumn"; readonly Fall: "fall"; readonly GoldenAutumn: "goldenAutumn"; readonly CopperAutumn: "copperAutumn"; readonly Evergreen: "evergreen"; }>;

declare const WAVE_TREE_MODEL_PARTS: Readonly<{ readonly trunk: "trunk"; readonly foliage: "foliage"; readonly mediumTrunk: "mediumTrunk"; readonly mediumFoliage: "mediumFoliage"; readonly lowTrunk: "lowTrunk"; readonly lowFoliage: "lowFoliage"; readonly billboardTrunk: "billboardTrunk"; readonly billboardFoliage: "billboardFoliage"; }>;

declare const WAVE_TREE_OPTIMIZATION: Readonly<{ readonly Hero: "hero"; readonly Balanced: "balanced"; readonly SmallScene: "smallScene"; }>;

declare const WAVE_TREE_SPECIES: Readonly<{ readonly WhiteOak: "whiteOak"; readonly RedMaple: "redMaple"; readonly TulipPoplar: "tulipPoplar"; readonly Sweetgum: "sweetgum"; readonly AmericanBeech: "americanBeech"; readonly PonderosaPine: "ponderosaPine"; readonly LoblollyPine: "loblollyPine"; readonly DouglasFir: "douglasFir"; readonly JoshuaTree: "joshuaTree"; readonly Saguaro: "saguaro"; }>;

declare const WAVE_UI_SKIN_ASSET_BINDING_KIND: "asset";

declare const WAVE_UI_SKIN_SCOPE_BINDING_KIND: "scope";

declare const WAVE_VERTEX_ANIMATION_JSON_FORMAT: "wave3d.vat";

declare const WAVE_VERTEX_ANIMATION_JSON_VERSION: 1;

declare const WAVE_WORLD_PLAN_KIND: "waveWorldPlan";

declare const WAVE_WORLD_PLAN_VERSION: 1;

declare const WAVE_WORLD_TEXT_MODEL_HOST: unique symbol;

declare const WAVE_WORLD_TEXT_MODEL_KIND: "wave::worldText";

declare abstract class wave2DAbstract<TState = void> extends WaveObject<TState, SerializableVector2, WaveTransform2DFrameSnapshotPatch, "2d"> {

  constructor();

  alignDirectionWith(target: Wave2DLayoutTarget): this;

  alignDirectionWith(target: Wave2DLayoutTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  alignDirectionWith(target: Wave2DLayoutTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  applyAuthoredPoseSnapshot(snapshot: WaveTransform2DPoseSnapshot): this;

  applyParentSnapshot(snapshot: WaveTransform2DFrameSnapshotPatch): this;

  applySnapshot(snapshot: WaveTransform2DFrameSnapshotPatch): this;

  applyTransformStateSnapshot(snapshot: WaveTransform2DStateSnapshot): this;

  attachTo(parent: Wave2DLayoutTarget): Wave2DReparentBuilder<this>;

  authoredPoseSnapshot(): WaveTransform2DPoseSnapshot;

  get bodyBounds(): WaveLayoutBodyBox;

  cancelTransformAnimations(policy: TransitionCancellationPolicy): this;

  clearHistory(): this;

  detachTo(point: WaveScreenPointRef): Wave2DReparentBuilder<this>;

  distanceTo(target: WaveTransform2DTurnTarget): number;

  get down(): Vector2;

  get downExtent(): number;

  get downFaceCenter(): Vector2;

  faceCenter(side: WaveBodySide2D): WaveLocator2DRef;

  fitBetween(): Wave2DFitBetweenBuilder<this>;

  fitBetween(start: Wave2DFitPoint, end: Wave2DFitPoint, mode: TransformVerbMode.Snapshot): WaveTransform2DFitBetweenBuilder;

  fitBetween(start: Wave2DFitPoint, end: Wave2DFitPoint, mode: TransformVerbMode.Animate): WaveTransform2DFitBetweenAnimationBuilder;

  fitBetween(start: Wave2DFitPoint, end: Wave2DFitPoint, options?: WaveTransform2DFitOptions): this;

  getAcceleration(): Vector2;

  getAccelerationMagnitude(): number;

  getAngularRate(): number;

  getHistorySample(when: WaveTimeLookback): WaveTransform2DHistorySample | null;

  getHistorySamples(): readonly WaveTransform2DHistorySample[];

  getLocalPosition(): SerializableVector2;

  getLocalRotation(): number;

  getParent2D(): Wave2DLayoutTarget | null;

  getPosition(): SerializableVector2;

  getPosition(when: WaveTimeLookback): SerializableVector2 | null;

  getRotation(): number;

  getRotation(when: WaveTimeLookback): number | null;

  getScale(): SerializableVector2;

  getScale(when: WaveTimeLookback): SerializableVector2 | null;

  getSpeed(): number;

  getSpeedDeclineRate(): number;

  getSpeedGrowthRate(): number;

  getVelocity(): Vector2;

  getWorldPosition(): SerializableVector2;

  getWorldRotation(): number;

  get historyDepth(): number;

  get historySampleCount(): number;

  inFrameOf(target: WaveTransform2DEntityTarget): WaveTransform2DFrameScope;

  inLocalFrame(): WaveTransform2DFrameScope;

  inLocalTerms(): WaveTransform2DTermsScope;

  inParentFrame(depth?: number): WaveTransform2DFrameScope;

  inParentTerms(): WaveTransform2DTermsScope;

  inView(cameraId: string): WaveTransform2DViewScope;

  inWorldFrame(): WaveTransform2DFrameScope;

  inWorldTerms(): WaveTransform2DTermsScope;

  isFacing(target: WaveTransform2DTurnTarget, options?: WaveOrient2DOptions): boolean;

  get isMotionReady(): boolean;

  get isRecordingHistory(): boolean;

  keepMoving(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepMovingDown(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepMovingLeft(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepMovingRight(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepMovingUp(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlong(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepScalingAlongBy(direction: WaveDirection2DInput, factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongDownBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongLeftBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongRightBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongUpBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingToward(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepScalingTowardBy(direction: WaveDirection2DInput, factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardDownBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardLeftBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardRightBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardUpBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepTurningLeft(degreesPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepTurningRight(degreesPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  get layer(): number;

  layout(): WaveUILayoutBuilder<this>;

  get left(): Vector2;

  get leftExtent(): number;

  get leftFaceCenter(): Vector2;

  get localPosition(): SerializableVector2;

  get localRotationDegrees(): number;

  get localX(): number;

  get localY(): number;

  locator(): WaveLocator2DBuilder;

  markMotionDiscontinuous(): this;

  get motionReadiness(): WaveTransform2DMotionReadiness;

  moveBy(delta: Vector2Like): this;

  moveBy(x: number, y: number): this;

  moveBy(direction: WaveDirection2DInput, distance: number): this;

  moveBy(delta: Vector2Like, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveBy(delta: Vector2Like, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveBy(direction: WaveDirection2DInput, distance: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveBy(direction: WaveDirection2DInput, distance: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveDown(units: number): this;

  moveDown(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveDown(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveLeft(units: number): this;

  moveLeft(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveLeft(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveRight(units: number): this;

  moveRight(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveRight(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveTo(target: WaveTransform2DMoveTarget): this;

  moveTo(x: number, y: number): this;

  moveTo(target: WaveTransform2DMoveTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveTo(target: WaveTransform2DMoveTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveTo(x: number, y: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveTo(x: number, y: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveUp(units: number): this;

  moveUp(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveUp(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveX(units: number): this;

  moveX(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveX(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveY(units: number): this;

  moveY(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveY(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  onDrag(callback: UI2DDragCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  onDragMove(options?: UI2DDragMoveOptions): UI2DDragMoveHandle<this>;

  onDragMove(callback: UI2DDragMoveCallback<this>, options?: UI2DDragMoveOptions): UI2DDragMoveHandle<this>;

  parentSnapshot(): WaveTransform2DFrameSnapshot;

  parentSnapshot(when: WaveTimeLookback): WaveTransform2DFrameSnapshot | null;

  pivotAt(value: Vector2Like): this;

  pivotAt(value: Vector2Like, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  pivotAt(value: Vector2Like, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  get position(): SerializableVector2;

  recordHistory(options?: TransformHistoryRecordingOptions): this;

  resetLayout(): this;

  resetPivot(): this;

  get right(): Vector2;

  get rightExtent(): number;

  get rightFaceCenter(): Vector2;

  rotateBy(degrees: number): this;

  rotateBy(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  rotateBy(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  rotateTo(degrees: number): this;

  rotateTo(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  rotateTo(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  get rotationDegrees(): number;

  get scale2D(): SerializableVector2;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number): this;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleAlongTo(direction: WaveDirection2DInput, value: number): this;

  scaleAlongTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleAlongTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleBy(value: number | Vector2Like): this;

  scaleBy(x: number, y: number): this;

  scaleBy(value: number | Vector2Like, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleBy(value: number | Vector2Like, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleBy(x: number, y: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleBy(x: number, y: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTo(value: number | Vector2Like): this;

  scaleTo(x: number, y: number): this;

  scaleTo(value: number | Vector2Like, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTo(value: number | Vector2Like, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTo(x: number, y: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTo(x: number, y: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number): this;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTowardTo(direction: WaveDirection2DInput, value: number): this;

  scaleTowardTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTowardTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  setHistoryDepth(depth: number): this;

  setLayer(layer: number): this;

  stopRecordingHistory(options?: { clear?: boolean; }): this;

  takeTransformStateSnapshot(): WaveTransform2DStateSnapshot;

  transition(): WaveTransform2DPoseTransitionBuilder;

  transitionTo(pose: WaveTransform2DPoseSnapshot): WaveTransform2DPoseTransitionBuilder;

  turnLeft(degrees: number): this;

  turnLeft(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnLeft(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnRight(degrees: number): this;

  turnRight(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnRight(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnTo(target: Vector2Like | WaveScreenPointRef | Wave2DLayoutTarget): this;

  turnTo(target: Vector2Like | WaveScreenPointRef | Wave2DLayoutTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnTo(target: Vector2Like | WaveScreenPointRef | Wave2DLayoutTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnToward(direction: WaveDirection2DInput): this;

  turnToward(direction: WaveDirection2DInput, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnToward(direction: WaveDirection2DInput, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  get up(): Vector2;

  get upExtent(): number;

  get upFaceCenter(): Vector2;

  vectorFrom(source: WaveTransform2DTurnTarget): Vector2;

  vectorTo(target: WaveTransform2DTurnTarget): Vector2;

  whenClickedOn(callback: UI2DClickCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenHoverEnteredOn(callback: UI2DHoverCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenHoverExitedOn(callback: UI2DHoverCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenHoveringOn(callback: UI2DHoverCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenPressedOn(callback: UI2DPressCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenReleasedOn(callback: UI2DReleaseCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  worldSnapshot(): WaveTransform2DFrameSnapshot;

  worldSnapshot(when: WaveTimeLookback): WaveTransform2DFrameSnapshot | null;

  get x(): number;

  get y(): number;

}

declare class Wave2DFitBetweenBuilder<TOwner extends wave2DAbstract<unknown> = wave2DAbstract<unknown>> {

  along(axis: WaveTransform2DFitAxis): this;

  apply(): TOwner;

  autoResize(enable?: boolean): this;

  between(start: Wave2DFitPoint, end: Wave2DFitPoint): this;

  centered(): this;

  from(start: Wave2DFitPoint): this;

  fromEnd(): this;

  fromStart(): this;

  to(end: Wave2DFitPoint): this;

  withoutResize(): this;

}

type Wave2DFitPoint = WaveTransform2DFitTarget;

interface Wave2DLayoutTarget {

  readonly networkID?: number;

  readonly runtimeRef: string;

  readonly scene: wave2DAbstract<unknown>["scene"];

}

type Wave2DPlacementBasis = { readonly kind: "screen"; readonly point: WaveScreenPointRef; } | { readonly kind: "parentOrigin"; } | { readonly kind: "layoutRelation"; readonly relation: WaveUILayoutRelation; } | { readonly kind: "worldProjection"; readonly binding: WaveUIWorldProjectionBinding; }

type Wave2DPlacementChange = Wave2DPlacementBasis;

declare class Wave2DReparentBuilder<TOwner extends Wave2DLayoutTarget> {

  preservingLocalPose(): TOwner;

  preservingRootPose(viewId: string): TOwner;

}

declare class Wave2DTransformExecutor implements WaveTransformDomainExecutor<cmp_transform2D, WaveTransform2DIntent, WaveTransform2DPoseSnapshot, WaveResolved2DFramePose> {

  apply(root: cmp_transform2D, intent: WaveTransform2DIntent): cmp_transform2D;

  distanceTo(root: cmp_transform2D, target: WaveTransform2DTurnTarget, viewId: string | null): number;

  plan(root: cmp_transform2D, intent: WaveTransform2DIntent): { readonly from: WaveTransform2DPoseSnapshot; readonly to: WaveTransform2DPoseSnapshot; }

  snapshot(root: cmp_transform2D, intent: WaveTransform2DIntent): WaveTransform2DPoseSnapshot;

  vectorTo(root: cmp_transform2D, target: WaveTransform2DTurnTarget, viewId: string | null): Vector2;

}

type Wave3DGridInfo = GridLayout;

interface Wave3DGridPathStep<T extends WaveSpatial3DObject = WaveSpatial3DObject> {

  col: number;

  layer: number;

  row: number;

  entity: T | null;

  worldPosition: Vector3;

}

type Wave3DObjectAnimationOptions = Pick<ModelAnimationPlayOptions, "loop" | "crossFadeDuration" | "speed">;

interface Wave3DObjectHideOptions {

  keepToolVisuals?: boolean;

}

type Wave3DTextFontInput = string | AssetRef<"font"> | ExactAssetRef<"font"> | FacetypeFontDefinitionInput;

interface Wave3DTextOptions {

  readonly align?: "left" | "center" | "right";

  readonly color?: ColorInput;

  readonly depth?: number;

  readonly faceColors?: { readonly front?: ColorInput; readonly back?: ColorInput; readonly side?: ColorInput; }

  readonly glyphOrder?: "waveFront" | "literal";

  readonly name?: string;

  readonly resolution?: number;

  readonly size?: number;

  readonly updatable?: boolean;

}

interface Wave3DTextPathInput {

  readonly closed?: boolean;

  readonly localSampledPoints?: readonly Vector3Like[];

  readonly sampledPoints?: readonly Vector3Like[];

  uniformSamples?(sampleCount: number, options?: { readonly space?: "local" | "world"; }): readonly Vector3Like[];

}

interface WaveAbcHumanizeOptions {

  chordStrumMs?: number;

  noteGapMs?: number;

  seed?: number;

  tempoJitterRatio?: number;

  timingJitterMs?: number;

  velocityJitter?: number;

}

interface WaveAbcKeySignature {

  accidentalCount: number;

  accidentalsByLetter: Record<"A" | "B" | "C" | "D" | "E" | "F" | "G", number>;

  mode: WaveAbcMode;

  source: string;

  tonic: string;

}

interface WaveAbcMeter {

  denominator: number;

  numerator: number;

  source: string;

}

type WaveAbcMode = "major" | "minor" | "dorian" | "phrygian" | "lydian" | "mixolydian" | "locrian";

type WaveAbcPerformanceStyle = "straight" | "human" | "laidBack" | "casualWithPassion";

interface WaveAbcPlaybackOptions {

  bpm?: number | undefined;

  humanize?: WaveAbcHumanizeOptions | undefined;

  startDelayMs?: number | undefined;

  style?: WaveAbcPerformanceStyle | undefined;

  transposeSemitones?: number | undefined;

  velocity?: number | undefined;

  busName?: string;

  onNoteEnd?: (note: WaveScheduledAbcNote) => void;

  onNoteStart?: (note: WaveScheduledAbcNote) => void;

  releaseMode?: WaveAbcPlaybackReleaseMode;

  spatial?: boolean;

}

type WaveAbcPlaybackReleaseMode = "scheduledStop" | "naturalDecay";

interface WaveAbcScore {

  events: WaveAbcScoreEvent[];

  format: "abc";

  key: string;

  keySignature: WaveAbcKeySignature;

  meter: WaveAbcMeter;

  nativeBaseBpm?: number;

  nativeScheduledNotes?: WaveScheduledAbcNote[];

  rawText: string;

  referenceNumber?: number;

  tempo: WaveAbcTempo;

  title?: string;

  unitNoteLengthWhole: number;

  warnings: string[];

}

interface WaveAbcScoreEvent {

  barIndex: number;

  durationWhole: number;

  kind: "notes" | "rest";

  notes: WaveAbcScoreNote[];

  source: string;

}

interface WaveAbcScoreNote {

  midiNote: number;

  token: string;

}

interface WaveAbcTempo {

  bpm: number;

  noteLengthWhole: number;

  quarterNoteBpm: number;

  source: string;

}

type WaveActionName = typeof WaveAction[keyof typeof WaveAction];

declare class WaveActivePhysicsEquipmentMount {

  get active(): boolean;

  readonly entity: waveProp;

  readonly name: string;

  release(options?: WaveActivePhysicsEquipmentReleaseOptions): void;

}

interface WaveActivePhysicsEquipmentReleaseOptions {

  readonly destroy?: boolean;

}

declare class WaveActivePhysicsMotionPlaybackBuilder<TEntityId extends string = string, TJointName extends string = string, TEngine extends unknown = unknown> {

  constructor(_rig: WaveActivePhysicsRig<TEntityId, TJointName, TEngine>, _motionName: string);

  play(): WaveAnimationPlaybackHandle;

  withTimeScale(timeScale: number): this;

}

interface WaveActivePhysicsPoseApplyOptions {

  readonly skipMissingEntities?: boolean;

}

interface WaveActivePhysicsPoseBuilder<TEntityId extends string = string> {

  apply(operations: readonly WaveActivePhysicsPoseOperation<TEntityId>[], options?: WaveActivePhysicsPoseApplyOptions): this;

  chain(prefix: string): WaveActivePhysicsPoseChainBuilder<this>;

  entity(entity: TEntityId): WaveActivePhysicsPoseEntityBuilder<this>;

  fromPose(pose: WaveRigPoseInput): this;

  save(): WaveModelRigPoseSnapshotMetadata;

  solveIK(entity: TEntityId): WaveActivePhysicsPoseIKBuilder<this>;

}

interface WaveActivePhysicsPoseChainBuilder<TRoot> {

  entities(suffixes: readonly string[]): WaveActivePhysicsPoseChainEntityBuilder<TRoot>;

}

interface WaveActivePhysicsPoseChainEntityBuilder<TRoot> {

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  moveBy(direction: DirectionInput, distance: number | readonly number[]): TRoot;

  rotateAroundBy(axis: DirectionInput, degrees: number | readonly number[]): TRoot;

  rotateAroundTo(axis: DirectionInput, degrees: number | readonly number[]): TRoot;

}

interface WaveActivePhysicsPoseEntityBuilder<TRoot> {

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  moveBackward(distance: number): TRoot;

  moveBy(direction: DirectionInput, distance: number): TRoot;

  moveDown(distance: number): TRoot;

  moveForward(distance: number): TRoot;

  moveLeft(distance: number): TRoot;

  moveRight(distance: number): TRoot;

  moveUp(distance: number): TRoot;

  rotateAroundBy(axis: DirectionInput, degrees: number): TRoot;

  rotateAroundTo(axis: DirectionInput, degrees: number): TRoot;

}

type WaveActivePhysicsPoseFrameState = WaveRigPoseFrameState;

interface WaveActivePhysicsPoseIKBuilder<TRoot> {

  allowOutOfReach(): this;

  boundedByReach(): this;

  IKstep(steps: number, options?: RigIKOptions): this;

  IKtoRoot(options?: RigIKOptions): this;

  moveTo(target: WaveActivePhysicsPoseIKTarget): TRoot;

  withIK(options: RigIKOptions): this;

}

type WaveActivePhysicsPoseIKTarget = WaveRigPoseIKTarget;

type WaveActivePhysicsPoseOperation<TEntityId extends string = string> = { readonly kind: "rotateAroundBy"; readonly entity: TEntityId; readonly frame: WaveActivePhysicsPoseFrameState; readonly axis: DirectionInput; readonly degrees: number; } | { readonly kind: "rotateAroundTo"; readonly entity: TEntityId; readonly frame: WaveActivePhysicsPoseFrameState; readonly axis: DirectionInput; readonly degrees: number; } | { readonly kind: "moveBy"; readonly entity: TEntityId; readonly frame: WaveActivePhysicsPoseFrameState; readonly direction: DirectionInput; readonly distance: number; } | { readonly kind: "solveIKTo"; readonly entity: TEntityId; readonly target: WaveActivePhysicsPoseIKTarget; readonly ik: RigBoneIKOptions; }

interface WaveActivePhysicsPoseRecipeIKTargetV1 {

  readonly worldPosition: readonly [number, number, number];

}

type WaveActivePhysicsPoseRecipeOperationV1<TEntityId extends string = string> = { readonly kind: "rotateAroundBy"; readonly entity: TEntityId; readonly frame: WaveActivePhysicsPoseFrameState; readonly axis: SerializedDirectionInput; readonly degrees: number; } | { readonly kind: "rotateAroundTo"; readonly entity: TEntityId; readonly frame: WaveActivePhysicsPoseFrameState; readonly axis: SerializedDirectionInput; readonly degrees: number; } | { readonly kind: "moveBy"; readonly entity: TEntityId; readonly frame: WaveActivePhysicsPoseFrameState; readonly direction: SerializedDirectionInput; readonly distance: number; } | { readonly kind: "solveIKTo"; readonly entity: TEntityId; readonly target: WaveActivePhysicsPoseRecipeIKTargetV1; readonly ik: RigBoneIKOptions; }

interface WaveActivePhysicsPoseRecipeV1<TEntityId extends string = string> {

  readonly fromPose?: string;

  readonly name: string;

  readonly operations: readonly WaveActivePhysicsPoseRecipeOperationV1<TEntityId>[];

  readonly skipMissingEntities?: boolean;

  readonly version: 1;

}

declare class WaveActivePhysicsRig<TEntityId extends string = string, TJointName extends string = string, TEngine extends unknown = unknown> {

  constructor(_scene: WaveScene<TEngine>, name: string, owner: waveProp, _physicsRig: WavePhysicsRig<WaveActivePhysicsRigEntity>, graph: WaveModelRigGraphMetadata, definition: WaveActivePhysicsRigModelDefinition<TEntityId, TJointName>, entityMap: WaveActivePhysicsRigEntityMap<TEntityId>, bindWorldPoseByEntityId: Readonly<Record<string, WaveModelRigTransformSnapshot>>, spawnWorldPosition: Vector3);

  readonly bodies: WaveActivePhysicsRigBodyMap<TEntityId>;

  body(id: TEntityId): cmp_physicsBody;

  branchEntityIds(rootEntityId: TEntityId): readonly TEntityId[];

  breakAt(jointOrName: WaveActivePhysicsRigJoint | TJointName | string): boolean;

  breakBefore(entityId: TEntityId): boolean;

  captureRestPose(): this;

  detach(entityOrId: TEntityId | WaveActivePhysicsRigEntity): boolean;

  dispose(): void;

  readonly entities: WaveActivePhysicsRigEntityMap<TEntityId>;

  entity(id: TEntityId): WaveActivePhysicsRigEntity;

  readonly equipment: WaveActivePhysicsRigEquipmentFacade<TEntityId, TEngine>;

  followLocomotion(): this;

  joint(nameOrId: TJointName | string): WaveActivePhysicsRigJoint;

  readonly joints: WaveActivePhysicsRigJointMap<TJointName>;

  readonly locomotionDriver: WaveActivePhysicsRigLocomotionDriver<TEngine>;

  motion(name: string): WaveRigAnimationTimelineBuilder;

  readonly name: string;

  readonly owner: waveProp;

  playMotion(name: string): WaveActivePhysicsMotionPlaybackBuilder<TEntityId, TJointName, TEngine>;

  pose(name: string): WaveActivePhysicsPoseBuilder<TEntityId>;

  pullBodyTo(entityId: TEntityId, target: WavePointInput, options?: WaveActivePhysicsRigBodyPullOptions): this;

  releaseAllBodyPulls(): this;

  releaseBodyPull(entityId: TEntityId): boolean;

  releaseDependentsOf(entityId: TEntityId): readonly TEntityId[];

  resetToRest(options?: { readonly clearMotion?: boolean; readonly wake?: boolean; }): this;

  savePoseRecipe(recipe: WaveActivePhysicsPoseRecipeV1<TEntityId>): WaveModelRigPoseSnapshotMetadata;

  savePoseRecipes(recipes: readonly WaveActivePhysicsPoseRecipeV1<TEntityId>[]): WaveModelRigPoseSnapshotMetadata[];

}

interface WaveActivePhysicsRigBodyDriveTuning<TEntityId extends string = string> {

  readonly angularDamping?: number | undefined;

  readonly damping?: number | undefined;

  readonly maxForce?: number | undefined;

  readonly maxTorque?: number | undefined;

  readonly positionStrength?: number | undefined;

  readonly rotationStrength?: number | undefined;

  readonly strength?: number | undefined;

  readonly entityId: TEntityId;

}

type WaveActivePhysicsRigBodyMap<TEntityId extends string> = Readonly<{ [TKey in TEntityId]: cmp_physicsBody; }>;

interface WaveActivePhysicsRigBodyPullOptions {

  readonly angularDamping?: number | undefined;

  readonly maxTorque?: number | undefined;

  readonly rotationStrength?: number | undefined;

  readonly damping?: number;

  readonly maxForce?: number;

  readonly positionStrength?: number;

  readonly strength?: number;

}

interface WaveActivePhysicsRigBodyTuning<TEntityId extends string = string> {

  readonly angularDamping?: number;

  readonly angularInertia?: number;

  readonly entityId: TEntityId;

  readonly friction?: number;

  readonly linearDamping?: number;

  readonly restitution?: number;

}

declare class WaveActivePhysicsRigBuilder<TEngine extends unknown = unknown> {

  constructor(_scene: WaveScene<TEngine>, _name: string);

  fromModel<TEntityId extends string = string, TJointName extends string = string>(model: WaveModelInput): WaveActivePhysicsRigModelBuilder<TEntityId, TJointName, TEngine>;

}

interface WaveActivePhysicsRigCollisionDefinition<TEntityId extends string = string> {

  readonly equipment?: { readonly ownerRig?: WaveActiveRigCollisionRelationship; readonly foreignRigs?: WaveActiveRigCollisionRelationship; }

  readonly interRig?: WaveActivePhysicsRigInterRigCollisionMode;

  readonly locomotionProxy?: WaveActiveRigCollisionRelationship;

  readonly self?: { readonly mode?: WaveActivePhysicsRigSelfCollisionMode; readonly ignorePairs?: readonly WaveActivePhysicsRigCollisionPair<TEntityId>[]; readonly poseValidation?: WaveActiveRigPoseCollisionValidationMode; readonly driveYield?: WaveActivePhysicsRigDriveYieldDefinition; }

}

interface WaveActivePhysicsRigCollisionPair<TEntityId extends string = string> {

  readonly a: TEntityId;

  readonly b: TEntityId;

}

interface WaveActivePhysicsRigDriveDefinition<TEntityId extends string = string> {

  readonly angularDamping?: number | undefined;

  readonly damping?: number | undefined;

  readonly maxForce?: number | undefined;

  readonly maxTorque?: number | undefined;

  readonly positionStrength?: number | undefined;

  readonly rotationStrength?: number | undefined;

  readonly strength?: number | undefined;

  readonly bodies?: readonly WaveActivePhysicsRigBodyDriveTuning<TEntityId>[];

}

interface WaveActivePhysicsRigDriveYieldDefinition {

  readonly angularDriveScale?: number;

  readonly enabled?: boolean;

  readonly inwardForceScale?: number;

  readonly releaseHysteresisSubsteps?: number;

}

type WaveActivePhysicsRigEntity = waveProp;

type WaveActivePhysicsRigEntityMap<TEntityId extends string> = Readonly<{ [TKey in TEntityId]: WaveActivePhysicsRigEntity; }>;

declare class WaveActivePhysicsRigEquipmentFacade<TEntityId extends string = string, TEngine extends unknown = unknown> {

  get(name: string): WaveActivePhysicsEquipmentMount | null;

  list(): readonly WaveActivePhysicsEquipmentMount[];

  require(name: string): WaveActivePhysicsEquipmentMount;

}

type WaveActivePhysicsRigInterRigCollisionMode = "collide" | "ignore";

type WaveActivePhysicsRigJoint = WaveJointRecord<WaveActivePhysicsRigEntity>;

type WaveActivePhysicsRigJointMap<TJointName extends string> = Readonly<{ [TKey in TJointName]: WaveActivePhysicsRigJoint; }>;

interface WaveActivePhysicsRigLocomotionDefinition {

  readonly anchorPosition?: readonly [number, number, number];

  readonly defaultTransitionDuration?: WaveTimeSpanSpec;

  readonly idleMotion?: string;

  readonly jumpMotion?: string;

  readonly maximumTimeScale?: number;

  readonly minimumTimeScale?: number;

  readonly referenceStrideDuration?: WaveTimeSpanSpec;

  readonly strideLength?: number;

  readonly walkMotion?: string;

}

declare class WaveActivePhysicsRigLocomotionDriver<TEngine extends unknown = unknown> {

  constructor(_rig: WaveActivePhysicsRig<string, string, TEngine>);

  activate(driver: wave3DObject): this;

  activate(): this;

  get current(): wave3DObject | null;

  remove(): this;

  get state(): WaveActivePhysicsRigLocomotionDriverState;

  suspend(): this;

}

type WaveActivePhysicsRigLocomotionDriverState = "active" | "suspended" | "removed";

declare class WaveActivePhysicsRigModelBuilder<TEntityId extends string, TJointName extends string, TEngine extends unknown = unknown> {

  constructor(_scene: WaveScene<TEngine>, _name: string, model: WaveModelInput);

  apply(): WaveActivePhysicsRig<TEntityId, TJointName, TEngine>;

  at(target: TransformReferenceLike | WavePointInput): this;

}

interface WaveActivePhysicsRigModelDefinition<TEntityId extends string = string, TJointName extends string = string> {

  readonly collision?: WaveActivePhysicsRigCollisionDefinition<TEntityId>;

  readonly drive?: WaveActivePhysicsRigDriveDefinition<TEntityId>;

  readonly entityIds: readonly TEntityId[];

  readonly equipmentMounts?: readonly WavePhysicalEquipmentMountDefinition<TEntityId>[];

  readonly locomotion?: WaveActivePhysicsRigLocomotionDefinition;

  readonly motionClips?: readonly WaveModelRigPoseClipMetadata[];

  readonly physics?: WavePhysicsRigOptions;

  readonly poseRecipes?: readonly WaveActivePhysicsPoseRecipeV1<TEntityId>[];

  readonly ragdoll?: WaveActivePhysicsRigRagdollDefinition;

  readonly rootEntityId: TEntityId;

  readonly semanticJoints: Readonly<Record<TJointName, string>>;

  readonly stability?: WaveActivePhysicsRigStabilityDefinition<TEntityId>;

  readonly version: 1;

}

interface WaveActivePhysicsRigRagdollDefinition {

  readonly bodyAngularDamping?: number;

  readonly bodyAngularInertia?: number;

  readonly bodyGravityFactor?: number;

  readonly bodyLinearDamping?: number;

  readonly jointDamping?: number;

  readonly jointEffort?: number;

}

type WaveActivePhysicsRigSelfCollisionMode = "none" | "nonAdjacent" | "all";

interface WaveActivePhysicsRigStabilityDefinition<TEntityId extends string = string> {

  readonly avoidCollisionWithinRig?: boolean;

  readonly bodies?: readonly WaveActivePhysicsRigBodyTuning<TEntityId>[];

}

interface WaveActiveRigCollisionDomainSnapshot {

  readonly bodyPartCount: number;

  readonly equipmentCount: number;

  readonly locomotionProxyCount: number;

  readonly managedRuleCount: number;

  readonly rigCount: number;

}

declare class WaveActiveRigCollisionFacade {

  identityOf(entityId: number): WaveActiveRigCollisionIdentity | null;

  resolveContact<TContact extends WaveActiveRigContactInput>(contact: TContact): WaveActiveRigSemanticContact<TContact>;

  get snapshot(): WaveActiveRigCollisionDomainSnapshot;

}

interface WaveActiveRigCollisionIdentity {

  readonly entityId: number;

  readonly equipmentName: string | null;

  readonly partId: string | null;

  readonly rigId: string;

  readonly role: WaveActiveRigCollisionRole;

  readonly rootEntityId: number;

}

type WaveActiveRigCollisionRelationship = "collide" | "ignore";

type WaveActiveRigCollisionRole = "bodyPart" | "equipment" | "locomotionProxy";

interface WaveActiveRigContactInput {

  readonly impulse: number;

  readonly normal: Readonly<{ x: number; y: number; z: number; }> | null;

  readonly other: { readonly owner: { readonly id: number; }; }

  readonly phase: "begin" | "continue" | "end";

  readonly point: Readonly<{ x: number; y: number; z: number; }> | null;

  readonly relativeImpactSpeed: number;

  readonly self: { readonly owner: { readonly id: number; }; }

}

interface WaveActiveRigContactParticipant {

  readonly entityId: number;

  readonly identity: WaveActiveRigCollisionIdentity | null;

}

type WaveActiveRigPoseCollisionValidationMode = "off" | "warn" | "error";

interface WaveActiveRigSemanticContact<TContact extends WaveActiveRigContactInput = WaveActiveRigContactInput> {

  readonly contact: TContact;

  readonly other: WaveActiveRigContactParticipant;

  readonly sameRig: boolean;

  readonly self: WaveActiveRigContactParticipant;

}

interface WaveActorCapabilityBuilder<TActor extends WaveActorDecisionActor, TParameters extends WaveChoiceParameters = WaveChoiceParameters> {

  describedAs(description: string): this;

  expects(expectation: string): this;

  observeOutcome(observer: WaveActorOutcomeObserver<TActor, TParameters>, policy?: WaveActorOutcomePolicy): this;

  observeOutcome(policy?: WaveActorOutcomePolicy): this;

  run(runner: WaveActorCapabilityRunner<TActor, TParameters>): this;

  when(predicate: (actor: TActor) => boolean): this;

  withParameters<TSchema extends WaveParamSchemaInput>(schema: TSchema): WaveActorCapabilityBuilder<TActor, WaveParamsFor<TSchema>>;

}

interface WaveActorCapabilityCompletion {

  readonly completed: boolean;

  readonly failed: boolean;

  onComplete(callback?: () => void): unknown;

  onFailed(callback?: () => void): unknown;

  onStopped(callback?: () => void): unknown;

  stop(): void;

  readonly stopped: boolean;

}

type WaveActorCapabilityResult = void | string | WaveActorOutcome | WaveActorCapabilityCompletion;

type WaveActorCapabilityRunner<TActor extends WaveActorDecisionActor, TParameters extends WaveChoiceParameters = WaveChoiceParameters> = (actor: TActor, context: WaveActorChoiceRunContext<TActor, TParameters>) => WaveActorCapabilityResult;

interface WaveActorCapabilityShortcutOptions<TActor extends WaveActorDecisionActor, TParameters extends WaveChoiceParameters = WaveChoiceParameters> {

  description?: string;

  expects?: string;

  observeOutcome?: WaveActorOutcomeObserver<TActor, TParameters>;

  outcome?: WaveActorOutcomePolicy;

  parameters?: WaveParamSchemaInput;

  run: WaveActorCapabilityRunner<TActor, TParameters>;

  when?: (actor: TActor) => boolean;

}

type WaveActorCapabilityUse = WaveActorChoiceUse;

interface WaveActorChoiceRunContext<TActor extends WaveActorDecisionActor, TParameters extends WaveChoiceParameters = WaveChoiceParameters> {

  readonly actor: TActor;

  readonly choice: WaveActorDecisionChoice<TParameters>;

  readonly decision: WaveActorDecision<TActor>;

  readonly parameters: TParameters;

  readonly use: WaveActorCapabilityUse;

}

interface WaveActorChoiceUse {

  readonly choiceId: string;

  readonly parameters: WaveChoiceParameters;

  readonly capabilityId: string;

  readonly decisionId: string;

  readonly description?: string;

  readonly sequence: number;

  readonly situation?: WaveActorLearningStateSnapshot;

  readonly usedAtMs: number;

}

interface WaveActorDecisionActor {

  readonly audio?: unknown;

  readonly hasAudio?: boolean;

  readonly id: number;

  readonly name?: string;

  readonly thinking: unknown;

}

interface WaveActorDecisionBaseEvent<TActor extends WaveActorDecisionActor> {

  readonly actor: TActor;

  readonly decision: WaveActorDecision<TActor>;

  readonly input: string;

  readonly source: WaveActorDecisionSource;

  readonly state: ActorDecisionState;

}

interface WaveActorDecisionBuilder<TActor extends WaveActorDecisionActor> {

  chooseFrom(...capabilityIds: string[]): this;

  chooseFrom(menu: WaveActorDecisionMenu): this;

  runChosen(): WaveActorDecision<TActor>;

  useLearning(mode?: WaveActorDecisionLearningMode): this;

  withReply(options?: WaveActorDecisionReplyOptions): this;

}

type WaveActorDecisionCallback<TActor extends WaveActorDecisionActor = WaveActorDecisionActor> = (event: WaveActorDecisionBaseEvent<TActor>) => void;

type WaveActorDecisionCapabilityCallback<TActor extends WaveActorDecisionActor = WaveActorDecisionActor> = (event: WaveActorDecisionCapabilityEvent<TActor>) => void;

interface WaveActorDecisionCapabilityEvent<TActor extends WaveActorDecisionActor> {

  readonly actor: TActor;

  readonly decision: WaveActorDecision<TActor>;

  readonly input: string;

  readonly source: WaveActorDecisionSource;

  readonly state: ActorDecisionState;

  readonly choice: WaveActorDecisionChoice;

  readonly use: WaveActorCapabilityUse;

}

interface WaveActorDecisionChoice<TParameters extends WaveChoiceParameters = WaveChoiceParameters> {

  readonly capabilityId: string;

  readonly choiceId: string;

  readonly description?: string;

  readonly id: string;

  readonly parameters?: WaveParamSpecRecord;

}

type WaveActorDecisionChoiceCallback<TActor extends WaveActorDecisionActor = WaveActorDecisionActor> = (event: WaveActorDecisionChoiceEvent<TActor>) => void;

interface WaveActorDecisionChoiceEvent<TActor extends WaveActorDecisionActor> {

  readonly actor: TActor;

  readonly decision: WaveActorDecision<TActor>;

  readonly input: string;

  readonly source: WaveActorDecisionSource;

  readonly state: ActorDecisionState;

  readonly choice: WaveActorDecisionChoice;

  readonly parameters: WaveChoiceParameters;

  readonly reason: string | null;

  readonly response?: LLMResponse;

}

type WaveActorDecisionCompleteCallback<TActor extends WaveActorDecisionActor = WaveActorDecisionActor> = (event: WaveActorDecisionCompleteEvent<TActor>) => void;

interface WaveActorDecisionCompleteEvent<TActor extends WaveActorDecisionActor = WaveActorDecisionActor> {

  readonly actor: TActor;

  readonly decision: WaveActorDecision<TActor>;

  readonly input: string;

  readonly source: WaveActorDecisionSource;

  readonly state: ActorDecisionState;

  readonly chosen: WaveActorDecisionChoice | null;

  readonly chosenReason: string | null;

  readonly outcomes: readonly WaveActorOutcomeRecord[];

  readonly replyText: string | null;

  readonly timedOutCapabilities: readonly WaveActorCapabilityUse[];

  readonly usedCapabilities: readonly WaveActorCapabilityUse[];

}

type WaveActorDecisionErrorCallback<TActor extends WaveActorDecisionActor = WaveActorDecisionActor> = (event: WaveActorDecisionErrorEvent<TActor>) => void;

interface WaveActorDecisionErrorEvent<TActor extends WaveActorDecisionActor> {

  readonly actor: TActor;

  readonly decision: WaveActorDecision<TActor>;

  readonly input: string;

  readonly source: WaveActorDecisionSource;

  readonly state: ActorDecisionState;

  readonly error: unknown;

  readonly stage: WaveActorDecisionStage;

}

type WaveActorDecisionLearningMode = "off" | "preferLearned" | "learningOnly";

type WaveActorDecisionLLMRequestCallback<TActor extends WaveActorDecisionActor = WaveActorDecisionActor> = (event: WaveActorDecisionLLMRequestEvent<TActor>) => void;

interface WaveActorDecisionLLMRequestEvent<TActor extends WaveActorDecisionActor> {

  readonly actor: TActor;

  readonly decision: WaveActorDecision<TActor>;

  readonly input: string;

  readonly source: WaveActorDecisionSource;

  readonly state: ActorDecisionState;

  readonly messages: readonly LLMMessage[];

  readonly requestId: string;

}

interface WaveActorDecisionMenu {

  readonly [capabilityId: string]: string;

}

interface WaveActorDecisionOptions {

  thinking?: ThinkingLLMDecisionOptions;

}

type WaveActorDecisionOutcomeCallback<TActor extends WaveActorDecisionActor = WaveActorDecisionActor> = (event: WaveActorDecisionOutcomeEvent<TActor>) => void;

interface WaveActorDecisionOutcomeEvent<TActor extends WaveActorDecisionActor> {

  readonly actor: TActor;

  readonly decision: WaveActorDecision<TActor>;

  readonly input: string;

  readonly source: WaveActorDecisionSource;

  readonly state: ActorDecisionState;

  readonly outcome: WaveActorOutcomeRecord;

}

type WaveActorDecisionReplyCallback<TActor extends WaveActorDecisionActor = WaveActorDecisionActor> = (event: WaveActorDecisionReplyEvent<TActor>) => void;

interface WaveActorDecisionReplyEvent<TActor extends WaveActorDecisionActor> {

  readonly actor: TActor;

  readonly decision: WaveActorDecision<TActor>;

  readonly input: string;

  readonly source: WaveActorDecisionSource;

  readonly state: ActorDecisionState;

  readonly replyText: string;

  readonly response?: LLMResponse;

}

interface WaveActorDecisionReplyOptions {

  maxWords?: number;

  speak?: boolean;

}

type WaveActorDecisionSource = "chat" | "prompt";

type WaveActorDecisionSpeechCallback<TActor extends WaveActorDecisionActor = WaveActorDecisionActor> = (event: WaveActorDecisionSpeechEvent<TActor>) => void;

interface WaveActorDecisionSpeechEvent<TActor extends WaveActorDecisionActor> {

  readonly actor: TActor;

  readonly decision: WaveActorDecision<TActor>;

  readonly input: string;

  readonly source: WaveActorDecisionSource;

  readonly state: ActorDecisionState;

  readonly text: string;

}

type WaveActorDecisionStage = "turn" | "llm" | "reply" | "decision" | "capability" | "outcome" | "speech";

interface WaveActorLearningBuilder<TActor extends WaveActorDecisionActor> {

  readSituation(read: (actor: TActor) => WaveActorLearningStateSnapshot): this;

  scoreOutcome(score: WaveActorOutcomeScorer): this;

  whenChoosing(...capabilityIds: string[]): this;

}

interface WaveActorLearningOptions {

  enabled?: boolean;

}

interface WaveActorLearningStateSnapshot {

}

interface WaveActorOutcome {

  facts?: WaveSceneDataRecord;

  reward?: number;

  summary: string;

}

type WaveActorOutcomeLearningPolicy = "ifLearningEnabled" | "always" | "never";

type WaveActorOutcomeMemoryKind = "forCharacter" | "doNotRemember";

type WaveActorOutcomeObserver<TActor extends WaveActorDecisionActor, TParameters extends WaveChoiceParameters = WaveChoiceParameters> = (actor: TActor, context: WaveActorChoiceRunContext<TActor, TParameters>) => WaveActorOutcomeObserverResult;

type WaveActorOutcomeObserverResult = void | string | WaveActorOutcome;

interface WaveActorOutcomePolicy {

  awaitMs?: number;

  includeInNextThinking?: boolean;

  learn?: WaveActorOutcomeLearningPolicy;

  onTimeout?: WaveActorOutcomeTimeoutPolicy;

  remember?: WaveActorOutcomeMemoryKind;

}

interface WaveActorOutcomeRecord {

  facts?: WaveSceneDataRecord | undefined;

  reward?: number | undefined;

  summary: string;

  readonly createdAtMs: number;

  readonly id: string;

  readonly policy?: WaveActorOutcomePolicy;

  readonly source: "reportedByAuthor" | "observedByCapability";

  readonly target: WaveActorCapabilityUse;

}

type WaveActorOutcomeScorer = (outcome: WaveActorOutcome) => number;

type WaveActorOutcomeTimeoutPolicy = "failDecision" | "continueDecision";

interface WaveActorReportOutcomeOptions {

  for?: WaveActorDecision<WaveActorDecisionActor> | WaveActorCapabilityUse;

  maxAgeMs?: number;

  outcome?: WaveActorOutcomePolicy;

}

interface WaveAffine2D {

  m00: number;

  m01: number;

  m10: number;

  m11: number;

  tx: number;

  ty: number;

}

declare class WaveAnchorBuilder<TTransform extends cmp_transform = cmp_transform> {

  constructor(_executor: WaveTransformVerbExecutor<TTransform>);

  originAt(point: WavePointInput): TTransform;

  originAt(x: number, y: number, z: number): TTransform;

  pivotLocal(point: WavePointInput): TTransform;

  pivotLocal(x: number, y: number, z: number): TTransform;

  pivotWorld(point: WavePointInput): TTransform;

  pivotWorld(x: number, y: number, z: number): TTransform;

  resetPivot(): TTransform;

}

declare class WaveAnimationClip {

  constructor(name?: string);

  addEvent(event: AnimationEvent): void;

  get animationRef(): AssetRef<"animation"> | null; set animationRef(ref: AssetRef<"animation"> | null);

  get animationType(): AnimationType; set animationType(type: AnimationType);

  applyPartPoseConfig(config: WavePartPoseClipConfig, loop?: boolean): void;

  applyTransformSnapshotConfig(config: WaveTransformSnapshotClipConfig, loop?: boolean): void;

  get clipName(): string; set clipName(name: string);

  clone(): WaveAnimationClip;

  get duration(): number; set duration(value: number);

  getEvents(): AnimationEvent[];

  getEventsInRange(previousTime: number, currentTime: number): AnimationEvent[];

  get isBabylonClip(): boolean;

  get isPartPoseClip(): boolean;

  get isTransformSnapshotClip(): boolean;

  get isVATClip(): boolean;

  loadFromPartPoseMetadata(metadata: WaveModelRigPoseClipMetadata, snapshots?: readonly WaveModelSnapshotMetadata[], fixedDelta?: number | null): void;

  loadFromPose(pose: WaveModelRigPoseSnapshotMetadata): void;

  loadFromTransformSnapshotMetadata(metadata: WaveModelSnapshotClipMetadata<"transform">, snapshots?: readonly WaveModelSnapshotMetadata[], fixedDelta?: number | null): void;

  get loop(): boolean; set loop(value: boolean);

  get partPoseConfig(): WavePartPoseClipConfig | null;

  toAnimationDefinition(): AssetDefinition<"animation"> | null;

  get transformSnapshotConfig(): WaveTransformSnapshotClipConfig | null;

  get vatRange(): VATAnimationRange | null;

  get vatRangeName(): string | undefined; set vatRangeName(name: string | undefined);

}

interface WaveAnimationController {

  readonly animationName: string;

  readonly currentLoopCount: number;

  readonly currentTime: number;

  readonly duration: number;

  getAbsoluteSpeed(): number | null;

  getBaseSpeed(): number | null;

  getSpeed(): number;

  readonly isPaused: boolean;

  readonly isPlaying: boolean;

  readonly isStopped: boolean;

  pause(): void;

  readonly progress: number;

  restart(): void;

  resume(): void;

  setAbsoluteSpeed(speed: number): void;

  setSpeed(speed: number): void;

  stop(): void;

}

type WaveAnimationEventDefinition = WaveModelSnapshotClipEventMetadata;

interface WaveAnimationPlaybackHandle {

  readonly animationName: string;

  readonly currentLoopCount: number;

  readonly currentTime: number;

  readonly duration: number;

  getAbsoluteSpeed(): number | null;

  getBaseSpeed(): number | null;

  getSpeed(): number;

  readonly isPaused: boolean;

  readonly isPlaying: boolean;

  readonly isStopped: boolean;

  pause(): void;

  readonly progress: number;

  restart(): void;

  resume(): void;

  setAbsoluteSpeed(speed: number): void;

  setSpeed(speed: number): void;

  stop(): void;

  readonly completed: boolean;

  readonly failed: boolean;

  onComplete(callback?: (handle: this) => void): this;

  onFailed(callback?: (handle: this) => void): this;

  onStopped(callback?: (handle: this) => void): this;

  readonly stopped: boolean;

  readonly terminalReason: TransitionLifecycleTerminalReason | null;

  thenDo(step: TransitionLifecycleThenDoStep): TransitionLifecycleChainHandle;

}

type WaveAnimationTimeInput = WaveTimeSpan | number;

interface WaveArticulatedActuationChannelHandle {

  readonly active: boolean;

  disable(): this;

  enable(): this;

  readonly id: string;

  readonly lastIKResult: WaveModelIKSolveResult | null;

  release(): boolean;

}

interface WaveArticulatedActuationChannelOptions {

  readonly enabled?: boolean;

  readonly priority?: number;

  readonly weight?: number;

}

interface WaveArticulatedActuationOptions<TPartId extends WaveModelPartId = WaveModelPartId> {

  readonly bodyDrive?: WavePhysicsRigDynamicDriveOptions;

  readonly jointDrive?: WavePhysicsRigDynamicDriveOptions;

  readonly partDrive?: Readonly<Partial<Record<TPartId, WavePhysicsRigDynamicDriveOptions>>>;

  readonly projection?: WaveArticulatedActuationProjection;

  readonly respectJointVelocityLimits?: boolean;

  readonly stepping?: WaveArticulatedActuationStepping;

}

type WaveArticulatedActuationProjection = "dynamic" | "kinematic";

type WaveArticulatedActuationStepping = "manual" | "physics";

interface WaveArticulatedAppliedCommandBuffers {

  readonly commandedAccelerations: Float64Array;

  readonly commandedTargets: Float64Array;

  readonly commandedVelocities: Float64Array;

  readonly dampings: Float64Array;

  readonly maximumEfforts: Float64Array;

  readonly resolvedTargets: Float64Array;

  readonly stiffnesses: Float64Array;

}

interface WaveArticulatedBodyDriveOptions {

  readonly angularDamping?: number | undefined;

  readonly damping?: number | undefined;

  readonly maxForce?: number | undefined;

  readonly maxTorque?: number | undefined;

  readonly positionStrength?: number | undefined;

  readonly rotationStrength?: number | undefined;

  readonly strength?: number | undefined;

}

declare class WaveArticulatedEndEffectorActuationBuilder<T extends WavePhysicsRigPart, TPartId extends WaveModelPartId> {

  inFrameOf(target: TransformReferenceLike): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  constructor(actuation: WaveArticulatedActuation<T, TPartId>, _endEffector: string);

  moveTo(target: WavePointInput): this;

  retain(channelId: string, options?: WaveArticulatedActuationChannelOptions): WaveArticulatedActuationChannelHandle;

  rotateTo(rotation: Quaternion): this;

  withIK(options: WaveArticulatedIKOptions): this;

  withStableMotion(options?: WaveArticulatedStableMotionOptions): this;

}

interface WaveArticulatedIKOptions {

  readonly allowMimicOverrides?: boolean | undefined;

  readonly bindWorldPoseByPartId?: Readonly<Record<string, WaveModelRigTransformSnapshot>> | undefined;

  readonly clamp?: boolean | undefined;

  readonly createParts?: boolean | undefined;

  readonly damping?: number | undefined;

  readonly defaultRootPose?: WaveModelRigTransformSnapshot | undefined;

  readonly includeTopologyLeafEndEffectors?: boolean | undefined;

  readonly maxIterations?: number | undefined;

  readonly rootPoseByPartId?: Readonly<Record<string, WaveModelRigTransformSnapshot>> | undefined;

  readonly rotationTolerance?: number | undefined;

  readonly tolerance?: number | undefined;

  readonly allowUnreachable?: boolean;

  readonly chainId?: string;

  readonly motionProfile?: WaveArticulatedMotionProfile;

  readonly retargetEveryStep?: boolean;

  readonly retargetIntervalSeconds?: number;

  readonly stableMotionVelocityScale?: number;

}

type WaveArticulatedMotionProfile = "direct" | "stable";

declare class WaveArticulatedPartActuationBuilder<T extends WavePhysicsRigPart, TPartId extends WaveModelPartId> {

  inFrameOf(target: TransformReferenceLike): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  constructor(actuation: WaveArticulatedActuation<T, TPartId>, _partId: TPartId);

  followRotation(rotation: Quaternion): this;

  followTransform(target: WavePointInput, rotation: Quaternion): this;

  pullTo(target: WavePointInput): this;

  retain(channelId: string, options?: WaveArticulatedActuationChannelOptions): WaveArticulatedActuationChannelHandle;

  usingCartesianSpring(options: WaveArticulatedBodyDriveOptions): this;

}

interface WaveArticulatedPhysicalPoseSample {

  readonly endEffectorPose: WaveModelEndEffectorPoseSnapshot | null;

  readonly jointValues: Readonly<Record<string, WaveModelPoseValue>>;

}

interface WaveArticulatedPhysicalSettlementOptions {

  readonly maximumAngularVelocity?: number;

  readonly maximumJointVelocity?: number;

  readonly maximumLinearVelocity?: number;

  readonly positionTolerance?: number;

  readonly requiredStableSeconds?: number;

  readonly rotationToleranceRadians?: number;

}

interface WaveArticulatedPhysicalSettlementSnapshot {

  readonly angularVelocity: number;

  readonly channelActive: boolean;

  readonly ikSucceeded: boolean;

  readonly linearVelocity: number;

  readonly maximumJointVelocity: number;

  readonly positionError: number;

  readonly rotationError: number;

  readonly holding: boolean;

  readonly ikErrorAngle: number | null;

  readonly ikErrorDistance: number | null;

  readonly settled: boolean;

  readonly stableSeconds: number;

}

interface WaveArticulatedPhysicalSettlementTarget {

  readonly endEffector: string;

  readonly rotation?: QuaternionLike;

  readonly target: WavePointInput;

}

declare class WaveArticulatedPoseActuationBuilder<T extends WavePhysicsRigPart, TPartId extends WaveModelPartId> {

  constructor(_actuation: WaveArticulatedActuation<T, TPartId>, _values: Readonly<Record<string, WaveModelPoseValue>>);

  retain(channelId: string, options?: WaveArticulatedActuationChannelOptions): WaveArticulatedActuationChannelHandle;

}

interface WaveArticulatedStableMotionOptions {

  readonly velocityScale?: number;

}

interface WaveAssemblyAnchorSlot {

  readonly id: string;

  readonly kind: "anchor";

  readonly position?: readonly [number, number, number];

  readonly rotation?: readonly [number, number, number, number];

}

interface WaveAssemblyAppliedPhysicsRigSource<TPart extends WavePhysicsRigPart> {

}

interface WaveAssemblyCompiledRigLayout {

  readonly partIds: readonly WaveModelPartId[];

  readonly partIndexById: ReadonlyMap<WaveModelPartId, number>;

  readonly recipe: WaveModelPhysicsRigCompiledRecipe;

  readonly revision: string;

  readonly slotId: string;

}

interface WaveAssemblyCompiledRigSnapshot {

  readonly partIds: readonly WaveModelPartId[];

  readonly revision: string;

  readonly slotId: string;

}

interface WaveAssemblyControllerDisposeContext<TInput, TController, TServices> {

  readonly controller: TController;

  readonly input: TInput;

  readonly instance: WaveCompiledAssemblyInstance;

  readonly services: TServices;

}

interface WaveAssemblyControllerResidencyContext<TInput, TController, TServices> {

  readonly controller: TController;

  readonly input: TInput;

  readonly instance: WaveCompiledAssemblyInstance;

  readonly next: WaveAssemblyResidency;

  readonly previous: WaveAssemblyResidency;

  readonly services: TServices;

}

interface WaveAssemblyControllerUpdateContext<TInput, TController, TServices> {

  readonly controller: TController;

  readonly elapsedSeconds: number;

  readonly input: TInput;

  readonly instance: WaveCompiledAssemblyInstance;

  readonly residency: WaveAssemblyResidency;

  readonly services: TServices;

}

interface WaveAssemblyDenseLayout {

  readonly entityCapacity: number;

  readonly fixedStructure: boolean;

  readonly slots: readonly WaveAssemblySlotLayout[];

  readonly slotsById: ReadonlyMap<string, WaveAssemblySlotLayout>;

}

interface WaveAssemblyDisposable {

  dispose(): void;

}

interface WaveAssemblyEntityAddress {

  readonly assemblyIndex: number;

  readonly assemblyKey: string;

  readonly elementIndex: number;

  readonly partId: string | null;

  readonly slotId: string;

}

interface WaveAssemblyEntitySlot {

  readonly cardinality?: number;

  readonly id: string;

  readonly kind: "entity";

  readonly structure?: "fixed" | "dynamic";

}

declare class WaveAssemblyInstance {

  constructor(_owner: WaveAssemblyInstances, index: number, key: string);

  anchor(id: string): WaveAssemblyAnchor;

  bind<T extends wave3DObject>(slotId: string, entity: T): T;

  bindPart<T extends wave3DObject>(slotId: string, partId: string, entity: T): T;

  entities(slotId: string): readonly wave3DObject[];

  readonly index: number;

  readonly key: string;

  part(slotId: string, partId: string): wave3DObject | undefined;

  realizeJoints(): WaveJointAssembly<waveProp> | null;

  useModel<T extends waveProp>(slotId: string, entity: T): T;

}

declare class WaveAssemblyInstances extends WaveGroup<wave3DObject> {

  constructor(name: string, recipe: WaveAssemblyRecipe | WaveAssemblyRealizationPlan, _assemblyScene: WaveAssemblySceneBridge);

  dispose(): void;

  instance(index: number): WaveAssemblyInstance;

  get instances(): readonly WaveAssemblyInstance[];

  readonly plan: WaveAssemblyRealizationPlan;

  realize<T>(inputs: readonly T[], realize: (instance: WaveAssemblyInstance, input: T, index: number) => void): readonly WaveAssemblyInstance[];

  requireSlot(id: string): WaveAssemblySlot;

  resolve(entity: wave3DObject | number): WaveAssemblyEntityAddress | null;

}

interface WaveAssemblyJointRecipe {

  readonly childSlotId: string;

  readonly config: WaveJointConfig;

  readonly id: string;

  readonly parentSlotId: string;

}

interface WaveAssemblyModelSlot {

  readonly cardinality?: number;

  readonly id: string;

  readonly kind: "model";

  readonly materials?: "shared" | "private";

  readonly modelRef: AssetRef<"model">;

  readonly render?: "entity" | "thinParts";

  readonly simulationState?: "private";

  readonly structure?: "fixed" | "dynamic";

  readonly topology?: "fixed" | "dynamic";

}

interface WaveAssemblyRealizationContext<TInput, TServices> {

  readonly index: number;

  readonly input: TInput;

  readonly instance: WaveCompiledAssemblyInstance;

  readonly services: TServices;

}

interface WaveAssemblyRealizationPlan {

  readonly anchors: readonly WaveAssemblyAnchorSlot[];

  readonly joints: readonly WaveAssemblyJointRecipe[];

  readonly recipe: WaveAssemblyRecipe;

  readonly revision: string;

  readonly slotsById: ReadonlyMap<string, WaveAssemblySlot>;

}

interface WaveAssemblyRealizationProgram<TInput, TController, TServices> {

  readonly controller?: WaveAssemblySharedControllerProgram<TInput, TController, TServices>;

  readonly id: string;

  readonly initialResidency?: WaveAssemblyResidency;

  realize(context: WaveAssemblyRealizationContext<TInput, TServices>): TController;

  readonly revision: string;

}

interface WaveAssemblyRecipe {

  readonly id: string;

  readonly joints: readonly WaveAssemblyJointRecipe[];

  readonly slots: readonly WaveAssemblySlot[];

  readonly version: typeof WAVE_ASSEMBLY_RECIPE_VERSION;

}

declare class WaveAssemblyRecipeBuilder {

  constructor(_id: string);

  anchor(id: string, pose?: { readonly position?: readonly [number, number, number]; readonly rotation?: readonly [number, number, number, number]; }): this;

  compile(): WaveAssemblyRealizationPlan;

  entity(id: string, options?: Pick<WaveAssemblyEntitySlot, "cardinality" | "structure">): this;

  joint(id: string, parentSlotId: string, childSlotId: string, config: WaveJointConfig): this;

  model(id: string, model: string | AssetRef<"model"> | ExactAssetRef<"model">, options?: Pick<WaveAssemblyModelSlot, "materials" | "topology" | "cardinality" | "structure" | "simulationState" | "render">): this;

  toConfig(): WaveAssemblyRecipe;

}

type WaveAssemblyResidency = "dormant" | "resident" | "active";

interface WaveAssemblySceneBridge {

  readonly engine: unknown;

  createJointAssembly<T extends waveProp>(name?: string, controller?: NoInfer<T> | wave3DObject): WaveJointAssembly<T>;

}

interface WaveAssemblySharedControllerProgram<TInput, TController, TServices> {

  dispose?(context: WaveAssemblyControllerDisposeContext<TInput, TController, TServices>): void;

  readonly fixedIntervalSeconds?: number;

  readonly id: string;

  residency?(context: WaveAssemblyControllerResidencyContext<TInput, TController, TServices>): void;

  readonly revision: string;

  update?(context: WaveAssemblyControllerUpdateContext<TInput, TController, TServices>): void;

}

type WaveAssemblySlot = WaveAssemblyModelSlot | WaveAssemblyEntitySlot | WaveAssemblyAnchorSlot;

interface WaveAssemblySlotLayout {

  readonly cardinality: number;

  readonly kind: Exclude<WaveAssemblySlot["kind"], "anchor">;

  readonly offset: number;

  readonly slotId: string;

  readonly slotIndex: number;

}

type WaveAssetLoaderDeclaration = WaveGaussianSplatLoaderDeclaration;

type WaveAttachmentSocket = wavePoint & { readonly socketName: string; readonly parentNode: TransformNode; readonly offset: Readonly<SocketOffset>; readonly scaleMode: BoneSocketScaleMode; setOffset(offset: SocketOffset): WaveAttachmentSocket; setScaleMode(scaleMode: WaveAttachmentSocketScaleMode): WaveAttachmentSocket; useSphere(options?: WaveAttachmentSocketSphereVisualOptions): WaveAttachmentSocket; setVisualScale(scale: Vector3Like | number, y?: number, z?: number): WaveAttachmentSocket; attach(child: wave3DObject, options?: WaveAttachmentSocketAttachOptions): WaveAttachmentSocket; detach(child: wave3DObject): WaveAttachmentSocket; }

type WaveAttachmentSocketAttachOptions = BoneSocketAttachOptions;

type WaveAttachmentSocketScaleMode = BoneSocketScaleMode;

type WaveAttachmentSocketSphereVisualOptions = BoneSocketSphereVisualOptions;

type WaveAudioAnalysisFftSize = 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096 | 8192 | 16384 | 32768;

interface WaveAudioAnalysisFrame {

  bands: WaveAudioFrequencyBands;

  energy: number;

  energyDelta: number;

  fftSize: WaveAudioAnalysisFftSize;

  frequencyBinCount: number;

  frequencyData: Uint8Array<ArrayBuffer>;

  sampleRate: number;

  source: WaveAudioAnalysisSource;

  spectralCentroid: number;

  timestamp: number;

}

type WaveAudioAnalysisFrameCallback = (frame: WaveAudioAnalysisFrame) => void;

interface WaveAudioAnalysisHandle {

  readonly error: unknown;

  id: string;

  isActive(): boolean;

  isAnalyzing(): boolean;

  onError(callback?: (handle: this) => void): this;

  onStarted(callback?: (handle: this) => void): this;

  readonly state: WaveAudioAnalysisState;

  stop(): void;

  stopAnalyzing(): void;

}

interface WaveAudioAnalysisOptions {

  fftSize?: WaveAudioAnalysisFftSize;

  fps?: number;

  maxDecibels?: number;

  minDecibels?: number;

  smoothing?: number;

}

interface WaveAudioAnalysisSource {

  busName?: string;

  clipName?: string;

  entityId?: number;

  kind: WaveAudioAnalysisSourceKind;

}

declare enum WaveAudioAnalysisSourceKind {

  Bus = "bus",

  Clip = "clip",

  Microphone = "microphone",

}

type WaveAudioAnalysisStarter = (options: WaveBoundAudioAnalysisSubscriptionOptions, startPolicy: WaveAuthoredCallbackPolicy) => WaveAudioAnalysisHandle;

declare enum WaveAudioAnalysisState {

  Active = "active",

  Error = "error",

  Starting = "starting",

  Stopped = "stopped",

}

interface WaveAudioAnalysisSubscriptionOptions {

  fftSize?: WaveAudioAnalysisFftSize | undefined;

  fps?: number | undefined;

  maxDecibels?: number | undefined;

  minDecibels?: number | undefined;

  smoothing?: number | undefined;

  bandPeaks?: WaveAudioBandPeakRegistration[];

  onFrame?: WaveAudioAnalysisFrameCallback[];

  onSnap?: WaveAudioSnapCallback[];

  snap?: WaveAudioSnapDetectionOptions;

  source: WaveAudioAnalysisSource;

}

type WaveAudioBandPeakCallback = (event: WaveAudioBandPeakEvent) => void;

interface WaveAudioBandPeakEvent {

  band: AudioAnalysisBandName;

  source: WaveAudioAnalysisSource;

  threshold: number;

  timestamp: number;

  value: number;

}

interface WaveAudioBandPeakRegistration {

  band: AudioAnalysisBandName;

  callback?: WaveAudioBandPeakCallback;

  threshold: number;

}

type WaveAudioBeatAnalysisCallback = (result: WaveAudioBeatAnalysisResult) => void;

interface WaveAudioBeatAnalysisOptions {

  maxTempo?: number | undefined;

  minTempo?: number | undefined;

  duration?: number;

  offset?: number;

}

interface WaveAudioBeatAnalysisResult {

  bpm: number;

  clipName: string;

  offset: number;

  tempo: number;

}

type WaveAudioBeatAnalysisStarter = (options: WaveAudioBeatAnalysisOptions, startPolicy: WaveAuthoredCallbackPolicy, callbacks: readonly WaveBoundAudioBeatAnalysisCallback[]) => Promise<WaveAudioBeatAnalysisResult>;

interface WaveAudioCallbackAdmission {

  <TArgs extends readonly unknown[], TReturn>(callback: (...args: TArgs) => TReturn, options?: WaveAuthoredCallbackOptions): WaveBoundAuthoredCallback<TArgs, TReturn | undefined>;

}

type WaveAudioCallbackPolicyCapture = (options?: WaveAuthoredCallbackOptions) => WaveAuthoredCallbackPolicy;

declare class WaveAudioClip {

  constructor(name: string, path: string, options?: AudioOptions);

  get audioRef(): AssetRef<"audio"> | null; set audioRef(ref: AssetRef<"audio"> | null);

  get busName(): string | undefined; set busName(value: string | undefined);

  get duration(): number; set duration(value: number);

  get loop(): boolean; set loop(value: boolean);

  get name(): string;

  get path(): string;

  get pitchCents(): number; set pitchCents(value: number);

  get playbackRate(): number; set playbackRate(value: number);

  get ref(): AssetRef<"audio"> | null; set ref(ref: AssetRef<"audio"> | null);

  get volume(): number; set volume(value: number);

}

interface WaveAudioFrequencyBands {

  bass: number;

  brilliance: number;

  highMid: number;

  lowMid: number;

  mid: number;

  presence: number;

  subBass: number;

}

type WaveAudioImpactCanonicalCurve = number | WaveValueCurveSpec | WaveAudioImpactCanonicalCurveModulation;

interface WaveAudioImpactCanonicalCurveModulation {

  curve: WaveValueCurveSpec;

  input?: "impactIntensity" | "impactSpeed" | "relativeImpactSpeed";

  random?: number;

}

type WaveAudioImpactCurve = WaveAudioImpactCanonicalCurve | WaveAudioImpactCurveModulation;

interface WaveAudioImpactCurveModulation {

  curve: number | WaveValueCurveSpec;

  input?: "impactIntensity" | "impactSpeed" | "relativeImpactSpeed";

  random?: number;

}

interface WaveAudioImpactInput {

  brightnessOffset?: number;

  clipName?: string;

  cooldownKey?: string;

  energy?: number;

  impactEnergy?: number;

  impactSpeed?: number;

  materialPair?: string;

  normal?: Vector3Like;

  nowMs?: number;

  part?: string;

  pitchCentsOffset?: number;

  playbackSpeedScale?: number;

  point?: Vector3Like;

  reducedMass?: number;

  relativeImpactSpeed?: number;

  volumeScale?: number;

}

interface WaveAudioImpactLayer {

  brightness?: WaveAudioImpactCurve;

  clipName?: string;

  maxSpeed: number;

  pitchCents?: WaveAudioImpactCurve;

  playbackSpeed?: WaveAudioImpactCurve;

  resonanceGain?: number;

  volume?: WaveAudioImpactCurve;

}

interface WaveAudioImpactProfile {

  brightness?: WaveAudioImpactCurve;

  busName?: string;

  cooldownMs?: number;

  defaultClipName?: string;

  id: string;

  layers?: readonly WaveAudioImpactLayer[];

  minSpeed?: number;

  oneShot?: boolean;

  pitchCents?: WaveAudioImpactCurve;

  playbackSpeed?: WaveAudioImpactCurve;

  resonance?: WaveAudioModalResonanceProfile;

  spatialSound?: boolean;

  speedAtMax?: number;

  volume?: WaveAudioImpactCurve;

}

interface WaveAudioModalResonanceMode {

  decayMs?: number;

  detuneCents?: number;

  frequency: number;

  gain?: number;

}

interface WaveAudioModalResonanceProfile {

  attackMs?: number;

  durationMs?: number;

  gain?: number;

  highPassHz?: number;

  lowPassHz?: number;

  modes: readonly WaveAudioModalResonanceMode[];

}

type WaveAudioPlaybackCommit = (options: WaveAudioPlaybackOptions) => void;

interface WaveAudioPlaybackOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  onComplete?: (() => void) | undefined;

  onLoop?: (() => void) | undefined;

  onPause?: (() => void) | undefined;

  onResume?: (() => void) | undefined;

  onStart?: (() => void) | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  brightness?: number;

  busName?: string;

  distanceModel?: AudioDistanceModel;

  endAt?: number;

  loop?: boolean;

  maxDistance?: number;

  mode?: "exclusive" | "oneShot";

  oneShot?: boolean;

  panningModel?: AudioPanningModel;

  pitchCents?: number;

  position?: Vector3Like;

  refDistance?: number;

  rolloffFactor?: number;

  spatialPreset?: AudioSpatialPreset;

  spatialSound?: boolean;

  speed?: number;

  startFrom?: number;

  volume?: number;

}

type WaveAudioSnapCallback = (event: WaveAudioSnapEvent) => void;

interface WaveAudioSnapDetectionOptions {

  cooldownMs?: number;

  minEnergy?: number;

  minEnergyRise?: number;

  minHighFrequencyRatio?: number;

}

interface WaveAudioSnapEvent {

  energy: number;

  energyRise: number;

  highFrequencyRatio: number;

  source: WaveAudioAnalysisSource;

  strength: number;

  timestamp: number;

}

type WaveAuthoredCallback<TArgs extends readonly unknown[] = readonly unknown[], TReturn = void> = (...args: TArgs) => TReturn;

interface WaveAuthoredCallbackLease {

  readonly id: WaveAuthoredCallbackRegistrationId | null;

  unregister(): void;

}

interface WaveAuthoredCallbackOptions {

  clone?: WaveCallbackClonePolicy;

  reload?: WaveCallbackReloadPolicy;

}

interface WaveAuthoredCallbackPolicy {

  mainExecutionEpoch: number | null;

  sourceExecutionEpoch: number | null;

  sourceModulePath: string | null;

  sourceRootPath: string | null;

  clonePolicy: WaveCallbackClonePolicy;

  reloadPolicy: WaveCallbackReloadPolicy;

}

interface WaveAuthoredCallbackRegisterScopeOptions {

  readonly dispose: () => void;

  readonly name?: string | undefined;

  readonly policy: WaveAuthoredCallbackPolicy;

  readonly family: string;

}

type WaveAuthoredCallbackRegistrationId = string;

declare class WaveAuthoredCallbackScope {

  static forComponent(component: WaveComponent): WaveAuthoredCallbackScope;

  static forEntity(owner: WaveEntity<unknown>): WaveAuthoredCallbackScope;

  static forScene(scene: WaveScene): WaveAuthoredCallbackScope;

  bind<TArgs extends readonly unknown[], TReturn>(callback: WaveAuthoredCallback<TArgs, TReturn>, options?: WaveAuthoredCallbackOptions, defaultClonePolicy?: WaveCallbackClonePolicy): WaveBoundAuthoredCallback<TArgs, TReturn | undefined>;

  bindOr<TArgs extends readonly unknown[], TReturn>(callback: WaveAuthoredCallback<TArgs, TReturn>, retiredValue: TReturn, options?: WaveAuthoredCallbackOptions, defaultClonePolicy?: WaveCallbackClonePolicy): WaveBoundAuthoredCallback<TArgs, TReturn>;

  capture(options?: WaveAuthoredCallbackOptions, defaultClonePolicy?: WaveCallbackClonePolicy): WaveAuthoredCallbackPolicy;

  copyPolicy(policy: WaveAuthoredCallbackPolicy, sourceScope?: WaveAuthoredCallbackScope): WaveAuthoredCallbackPolicy;

  dispose(): void;

  isPolicyLive(policy: WaveAuthoredCallbackPolicy): boolean;

  matchesMain(policy: WaveAuthoredCallbackPolicy, epoch: number): boolean;

  matchesSource(policy: WaveAuthoredCallbackPolicy, rootPath: string, epoch: number): boolean;

  register(options: WaveAuthoredCallbackRegisterScopeOptions): WaveAuthoredCallbackLease;

  removeBoundEntriesWhere<TArgs extends readonly unknown[], TReturn>(entries: Array<WaveBoundAuthoredCallback<TArgs, TReturn>>, predicate: (policy: WaveAuthoredCallbackPolicy) => boolean): void;

  shouldCopy(policy: WaveAuthoredCallbackPolicy): boolean;

  slot<TArgs extends readonly unknown[] = readonly unknown[], TReturn = void>(family: string, options?: WaveAuthoredCallbackSlotOptions): WaveAuthoredCallbackSlot<TArgs, TReturn>;

  track<TTarget extends object>(target: TTarget, options: WaveAuthoredCallbackRegisterScopeOptions): WaveAuthoredCallbackLease;

  untrack(target: object): void;

}

declare class WaveAuthoredCallbackSlot<TArgs extends readonly unknown[] = readonly unknown[], TReturn = void> {

  constructor(scope: WaveAuthoredCallbackScope, family: string, options?: WaveAuthoredCallbackSlotOptions);

  bind(callback: WaveAuthoredCallback<TArgs, TReturn>, options?: WaveAuthoredCallbackOptions, defaultClonePolicy?: WaveCallbackClonePolicy): WaveBoundAuthoredCallback<TArgs, TReturn | undefined>;

  bindOr(callback: WaveAuthoredCallback<TArgs, TReturn>, retiredValue: TReturn, options?: WaveAuthoredCallbackOptions, defaultClonePolicy?: WaveCallbackClonePolicy): WaveBoundAuthoredCallback<TArgs, TReturn>;

  capture(options?: WaveAuthoredCallbackOptions, defaultClonePolicy?: WaveCallbackClonePolicy): WaveAuthoredCallbackPolicy;

  register(options: WaveAuthoredCallbackTrackOptions): WaveAuthoredCallbackLease;

  track<TTarget extends object>(target: TTarget, options: WaveAuthoredCallbackTrackOptions): WaveAuthoredCallbackLease;

  untrack(target: object): void;

}

interface WaveAuthoredCallbackSlotOptions {

  readonly name?: string;

}

interface WaveAuthoredCallbackTrackOptions {

  readonly dispose: () => void;

  readonly name?: string;

  readonly policy: WaveAuthoredCallbackPolicy;

}

type WaveAuthoredPoint = CoreWaveAuthoredPoint<TransformReferenceLike>;

interface WaveAuthoringQuaternionLike {

  readonly w: number;

  readonly x: number;

  readonly y: number;

  readonly z: number;

}

interface WaveAuthoringVector2Like {

  readonly x: number;

  readonly y: number;

}

interface WaveAuthoringVector3Like {

  readonly x: number;

  readonly y: number;

  readonly z: number;

}

type WaveAxialFace = "side" | "top" | "bottom";

interface WaveBabylonSceneGraphOptimizationConfig {

  readonly enabled?: boolean;

}

type WaveBabylonSceneGraphOptimizationConfigInput = boolean | WaveBabylonSceneGraphOptimizationConfig;

declare class WaveBabylonSceneGraphOptimizer {

  constructor(_scene: unknown);

  dispose(): void;

  freezeStaticRoom(options?: { readonly skipEvaluateActiveMeshes?: boolean; readonly freezeMeshes?: boolean; readonly keepFrustumCulling?: boolean; }): WaveBabylonStaticRoomFreezeHandle;

  freezeStaticSubtree(root: TransformNode, options?: WaveBabylonStaticSubtreeFreezeOptions): WaveBabylonStaticSubtreeFreezeHandle;

  get scene(): unknown;

  unfreezeStaticRoom(): void;

  unfreezeStaticSubtree(root: TransformNode): void;

}

interface WaveBabylonStaticRoomFreezeHandle {

  readonly scene: unknown;

  unfreeze(): void;

}

interface WaveBabylonStaticSubtreeFreezeHandle {

  readonly frozenNodes: readonly TransformNode[];

  readonly report: WaveBabylonStaticSubtreeFreezeReport;

  readonly root: TransformNode;

  unfreeze(): void;

}

interface WaveBabylonStaticSubtreeFreezeOptions {

  readonly allowUnfrozenParent?: boolean;

  readonly includeDescendants?: boolean;

  readonly shouldFreezeNode?: (node: TransformNode) => boolean;

  readonly skipDynamicNodes?: boolean;

}

interface WaveBabylonStaticSubtreeFreezeReport {

  readonly frozenCount: number;

  readonly requestedRootName: string;

  readonly skippedCount: number;

  readonly skipReasons: readonly string[];

}

interface WaveBindingSet {

  readonly id: string;

  readonly pipelineId: string;

  readonly schema: "wave.bindingSet.v1";

  readonly values: readonly WaveShaderBindingValue[];

}

type WaveBodySide2D = Direction.Left | Direction.Right | Direction.Up | Direction.Down;

interface WaveBone {

  readonly bodyPart: BodyPart | null;

  readonly exactName: string;

  getWorldPosition(): Vector3;

  getWorldRotation(): Quaternion;

  readonly name: string;

  readonly node: TransformNode;

}

interface WaveBoneHandleNetworkProperties {

  readonly boneExactName: string;

  readonly boneRef: string;

  readonly ownerNetworkId: number;

}

interface WaveBoneHandleOptions {

  readonly bone: WaveBone;

  readonly boneRef: string | BodyPart;

  readonly rig: cmp_rig;

  readonly sourceEntity: WaveEntity<unknown>;

}

type WaveBooleanBatchStrategy = typeof WaveBooleanStrategy[keyof typeof WaveBooleanStrategy];

interface WaveBooleanObservationSource<TEntity extends object> {

  changes(change: ObservationChangeToken, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  do(action: ObservationAction<TEntity>): ObservationHandle;

  enterState(state: unknown): ObservationHandle;

}

declare const WaveBooleanOp: Readonly<{ readonly Union: "union"; readonly Subtract: "subtract"; readonly Intersect: "intersect"; }>;

type WaveBooleanOperation = typeof WaveBooleanOp[keyof typeof WaveBooleanOp];

declare class WaveBooleanParamBuilder<TValue extends boolean | null = boolean> implements WaveParamBuilder<TValue> {

  constructor(spec?: WaveParamSpec<TValue>);

  default(value: boolean): WaveBooleanParamBuilder<boolean>;

  describedAs(description: string): WaveBooleanParamBuilder<TValue>;

  optional(): WaveBooleanParamBuilder<boolean | null>;

  toSpec(): WaveParamSpec<TValue>;

}

declare const WaveBooleanStrategy: Readonly<{ readonly Sequential: "sequential"; readonly BalancedUnion: "balancedUnion"; }>;

type WaveBoolExpr = { readonly type: "bool"; readonly value: boolean; } | { readonly type: "compare"; readonly op: WaveValueCompareOp; readonly a: WaveValueExpr; readonly b: WaveValueExpr; } | { readonly type: "and"; readonly a: WaveBoolExpr; readonly b: WaveBoolExpr; } | { readonly type: "or"; readonly a: WaveBoolExpr; readonly b: WaveBoolExpr; } | { readonly type: "not"; readonly a: WaveBoolExpr; }

interface WaveBoolRef {

  readonly kind: "bool";

  toExpr(): WaveValueExpr;

  toJSON(): WaveValueExpr;

}

interface WaveBoundAudioAnalysisSubscriptionOptions {

  fftSize?: WaveAudioAnalysisFftSize | undefined;

  fps?: number | undefined;

  maxDecibels?: number | undefined;

  minDecibels?: number | undefined;

  smoothing?: number | undefined;

  snap?: WaveAudioSnapDetectionOptions | undefined;

  source: WaveAudioAnalysisSource;

  readonly bandPeaks?: WaveBoundAudioBandPeakRegistration[];

  readonly onFrame?: Array<WaveBoundAuthoredCallback<Parameters<WaveAudioAnalysisFrameCallback>, void>>;

  readonly onSnap?: Array<WaveBoundAuthoredCallback<Parameters<WaveAudioSnapCallback>, void>>;

}

interface WaveBoundAudioBandPeakRegistration {

  band: AudioAnalysisBandName;

  threshold: number;

  readonly callback?: WaveBoundAuthoredCallback<Parameters<WaveAudioBandPeakCallback>, void>;

}

type WaveBoundAudioBeatAnalysisCallback = WaveBoundAuthoredCallback<Parameters<WaveAudioBeatAnalysisCallback>, void>;

type WaveBoundAuthoredCallback<TArgs extends readonly unknown[] = readonly unknown[], TReturn = void> = WaveAuthoredCallback<TArgs, TReturn> & WaveBoundAuthoredCallbackIdentity & { readonly original: WaveAuthoredCallback<TArgs, unknown>; }

interface WaveBoundAuthoredCallbackIdentity {

  readonly [WAVE_BOUND_AUTHORED_CALLBACK]: WaveAuthoredCallbackScope;

  readonly policy: WaveAuthoredCallbackPolicy;

}

type WaveBoxFace = "front" | "back" | "left" | "right" | "top" | "bottom";

interface WaveBoxPrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "box";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly faces?: Partial<Readonly<Record<WaveBoxFace, WavePrimitiveFaceLayout>>>;

  readonly segments?: { readonly width?: number; readonly height?: number; readonly depth?: number; }

  readonly size: { readonly width: number; readonly height: number; readonly depth: number; }

  readonly top?: { readonly width?: number; readonly depth?: number; readonly offsetX?: number; readonly offsetZ?: number; }

}

type WaveBrandedId<TKind extends string> = string & { readonly [WAVE_CAPABILITY_ID_BRAND]: TKind; }

type WaveBrowserActivationAction = "pointer-lock" | "fullscreen";

interface WaveBrowserInputCapabilities {

  readonly coarsePointer: boolean;

  readonly gamepad: boolean;

  readonly maxTouchPoints: number;

}

type WaveBrowserShellGatewayKind = "window-direct" | "window-port" | "none";

interface WaveBrowserShellGateways {

  blurTextInput(): void;

  exitActivationAction(action: WaveBrowserActivationAction): void;

  focusTextInput(accessibleLabel?: string): void;

  readonly kind: WaveBrowserShellGatewayKind;

  onTextInput(listener: (event: WaveBrowserTextInputEvent) => void): () => void;

  onVisibilityChange(listener: (state: WaveBrowserVisibilityState) => void): () => void;

  reportRuntimeFault(fault: WaveBrowserRuntimeFault): void;

  reportRuntimeStatus(status: WaveBrowserRuntimeStatus): void;

  requestActivationAction(action: WaveBrowserActivationAction): void;

  setGamepadPolling(enabled: boolean): void;

  setTextInputSelection(selectedText: string | null): void;

  snapshot(): WaveBrowserShellSnapshot;

  visibility(): WaveBrowserVisibilityState;

}

interface WaveBrowserShellServiceCapabilities {

  readonly clipboard: boolean;

  readonly directAudio: boolean;

  readonly fullscreen: boolean;

  readonly mediaCapture: boolean;

  readonly pointerLock: boolean;

  readonly textInput: boolean;

  readonly xr: boolean;

}

interface WaveBrowserShellSnapshot {

  readonly input: WaveBrowserInputCapabilities;

  readonly services: WaveBrowserShellServiceCapabilities;

  readonly surface: WaveRenderSurfaceMetrics;

  readonly visibility: WaveBrowserVisibilityState;

}

type WaveBrowserTextInputEvent = { readonly kind: "key"; readonly key: string; readonly shiftKey: boolean; readonly ctrlKey: boolean; readonly altKey: boolean; readonly metaKey: boolean; readonly repeat: boolean; } | { readonly kind: "before-input"; readonly inputType: string; readonly data: string | null; readonly isComposing: boolean; } | { readonly kind: "blur"; }

type WaveBrowserVisibilityState = "visible" | "hidden" | "prerender" | "unknown";

interface WaveBumpValueCurveSpec {

  readonly baseValue: number;

  readonly centerInput: number;

  readonly height: number;

  readonly kind: "bump";

  readonly width: number;

}

type WaveCallbackClonePolicy = "copy" | "skip" | "replay";

type WaveCallbackReloadPolicy = "source" | "main" | "manual" | "persistent";

interface WaveCameraCaptureBuilder {

  onError(callback: (error: WaveCameraCaptureError) => void): this;

  onStarted(callback: (handle: WaveCameraCaptureHandle) => void): this;

  startCapture(): WaveCameraCaptureHandle;

  withCaptureMode(mode: MediaCaptureMode): this;

  withFacingMode(facingMode: "user" | "environment"): this;

  withFrameRate(frameRate: number): this;

  withResolution(width: number, height: number): this;

}

interface WaveCameraCaptureError {

  error: unknown;

  message: string;

}

interface WaveCameraCaptureHandle {

  dispose(): void;

  readonly error: unknown;

  isCapturing(): boolean;

  readonly state: CaptureState;

  stopCapture(): void;

}

interface WaveCameraData {

  fov: number;

  lookDirection: Vector3;

  position: Vector3;

  zoom: number;

}

declare class WaveCameraPostFx {

  clear(): this;

  disable(effect: PostFxEffectName): this;

  disableCustom(id: string): this;

  enable<K extends PostFxEffectRequiringOptions>(effect: K, options: PostFxEffectMap[K]): this;

  enable<K extends PostFxEffectWithOptionalOptions>(effect: K, options?: PostFxEffectMap[K]): this;

  enableCustom(id: string, options: CustomPostProcessOptions): this;

  replaceWith(plan: PostFxPlan): this;

  replaceWithNoir(options?: WaveNoirProfileOptions): this;

  replaceWithOilPainting(options?: OilPaintingOptions): this;

  replaceWithProfile(profile: PostFxProfile | `${PostFxProfile}`): this;

}

interface WaveCameraSetData {

  fov: number;

  lookDirection: Vector3;

  position?: Vector3;

  zoom?: number;

}

type WaveCanvasNormalizedPoint = CanvasNormalizedPoint;

type WaveCanvasNormalizedViewport = CanvasNormalizedViewport;

type WaveCanvasPixelPoint = CanvasPixelPoint;

type WaveCapMode = "none" | "start" | "end" | "both";

interface WaveCapsulePrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "capsule";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly bottomRadius?: number;

  readonly capSegments?: number;

  readonly height: number;

  readonly heightSegments?: number;

  readonly orientation?: "x" | "y" | "z";

  readonly radialSegments?: number;

  readonly radius: number;

  readonly topRadius?: number;

}

interface WaveCavityLightingPolicyConfig {

  affectContents?: boolean;

  enabled?: boolean;

  external?: WaveLightingZoneExternalPolicy;

  internal?: WaveLightingZoneInternalPolicy;

  internalLightEntityIds?: readonly number[];

  membership?: WaveLightingZoneMembershipMode;

  priority?: number;

}

declare class WaveCavityLightingPolicyConfigurator<TOwner extends WaveCavityLightingPolicyOwner = WaveCavityLightingPolicyOwner> {

  constructor(_owner: TOwner);

  addInternalLight(...lights: waveLight[]): this;

  affectContents(enabled?: boolean): this;

  allowExternalLighting(enabled?: boolean): this;

  apply(): TOwner;

  blockExternalLighting(): this;

  clearInternalAmbient(): this;

  clearInternalLights(): this;

  configure(config: WaveCavityLightingPolicyConfig): this;

  externalDirectIntensity(value: number): this;

  externalEnvironmentIntensity(value: number): this;

  internalAmbient(color: ColorInput, intensity: number): this;

  internalLight(...lights: waveLight[]): this;

  maxExternalLights(value: number | null): this;

  maxInternalLights(value: number | null): this;

  membership(mode: WaveLightingZoneMembershipMode): this;

  patch(config: WaveCavityLightingPolicyConfig): this;

  priority(value: number): this;

  removeInternalLight(...lights: waveLight[]): this;

}

interface WaveCavityLightingPolicyOwner {

}

interface WaveCavityVolumetricNode {

  blendK: number;

  center: WaveSpatialPoint3;

  depth: number;

  floorDamping: number;

  height: number;

  id: string;

  maxX: number;

  maxY: number;

  maxZ: number;

  minX: number;

  minY: number;

  minZ: number;

  noiseAmp: number;

  noiseFreq: number;

  noiseSeed: number;

  path: readonly WaveSpatialPoint3[] | undefined;

  pathLength: number;

  profile: WaveCavityVolumetricProfile | undefined;

  rotation: { x: number; y: number; z: number; w: number; } | undefined;

  shape: WaveCavityVolumetricShape | undefined;

  stations: readonly WaveCavityVolumetricStation[] | undefined;

  surfaceStyle: "rough" | "layered" | "eroded" | undefined;

  width: number;

}

type WaveCavityVolumetricProfile = "tunnel" | "cavern" | "crevice" | "grotto" | "lavaTube" | "overhang" | "corridor";

type WaveCavityVolumetricShape = "box" | "natural";

interface WaveCavityVolumetricStation {

  halfHeight: number;

  halfWidth: number;

  t: number;

}

interface WaveCavityVolumetricSurface {

  amount?: number;

  amplitude?: number;

  floorDamping?: number;

  frequency?: number;

  seed?: number;

  style?: "rough" | "layered" | "eroded";

}

declare class WaveCavityZone {

  constructor(_owner: waveCavity, id: string);

  readonly id: string;

  get nodeIds(): readonly string[];

}

interface WaveCharacterReplyPolicy {

  completeThought?: boolean;

  fallbackText?: string;

  maxTokens?: number;

  maxWords?: number;

  stripMarkdown?: boolean;

  temperature?: number;

}

interface WaveCharacterSnapshot {

  bio?: string;

  instructions: readonly string[];

  knowledge: readonly string[];

  mood?: string;

  name?: string;

  replyPolicy: WaveCharacterReplyPolicy;

  style?: string;

}

declare class WaveChoiceBuilder<TParameters extends WaveChoiceParameters = WaveChoiceParameters> {

  constructor(id: string, spec?: Omit<WaveChoiceSpec<TParameters>, "id">);

  describedAs(description: string): WaveChoiceBuilder<TParameters>;

  toSpec(): WaveChoiceSpec<TParameters>;

  withParameters<TSchema extends WaveParamSchemaInput>(schema: TSchema): WaveChoiceBuilder<WaveParamsFor<TSchema>>;

}

type WaveChoiceInput<TParameters extends WaveChoiceParameters = WaveChoiceParameters> = WaveChoiceSpec<TParameters> | WaveChoiceBuilder<TParameters>;

declare class WaveChoiceParamBuilder<TValue extends string | null> implements WaveParamBuilder<TValue> {

  constructor(spec: WaveParamSpec<TValue>);

  default(value: Exclude<TValue, null>): WaveChoiceParamBuilder<Exclude<TValue, null>>;

  describedAs(description: string): WaveChoiceParamBuilder<TValue>;

  optional(): WaveChoiceParamBuilder<Exclude<TValue, null> | null>;

  toSpec(): WaveParamSpec<TValue>;

}

interface WaveChoiceParameters {

  readonly [key: string]: WaveParamValue;

}

interface WaveChoiceSpec<TParameters extends WaveChoiceParameters = WaveChoiceParameters> {

  readonly description?: string;

  readonly id: string;

  readonly parameters?: WaveParamSpecRecord;

}

interface WaveClampValueCurveSpec {

  readonly curve: WaveValueCurveSpec;

  readonly kind: "clamp";

  readonly max: number | null;

  readonly min: number | null;

}

declare class WaveClothBuilder {

  avoidCollisionWith(...targets: WaveSoftBodyCollisionTarget[]): this;

  avoidCollisionWithinGroup(): this;

  captureRestState(): this;

  constructor(_scene: WaveSoftBodyBuilderScene);

  anchorCorner(corner: WaveClothCorner, target: Parameters<WaveCloth["anchorCorner"]>[1], options?: WaveSoftBodyAttachmentOptions): this;

  apply(): WaveCloth;

  at(position: WavePointInput): this;

  build(): WaveCloth;

  color(color: ColorInput): this;

  cols(count: number): this;

  damping(value: number): this;

  foldAwareSelfCollisions(options?: Partial<WaveSoftBodyParticleCollisionPolicy>): this;

  fromOptions(options: Partial<ClothGridOptions>): this;

  grid(rows: number, cols: number): this;

  horizontal(enabled?: boolean): this;

  material(materialId: string, uvScale?: number): this;

  named(name: string): this;

  nodeColliderShape(shape: WaveSoftBodyNodeColliderShape): this;

  nodeMass(mass: number): this;

  nodeRadius(radius: number): this;

  particleCollisionPolicy(policy: WaveSoftBodyParticleCollisionPolicyInput): this;

  pinCorner(corner: WaveClothCorner): this;

  pinCorners(enabled?: boolean): this;

  pinTopRow(enabled?: boolean): this;

  rows(count: number): this;

  selfCollisions(enabled?: boolean): this;

  showNodes(enabled?: boolean): this;

  spacing(value: number): this;

  sphereNodes(): this;

  thinBoxNodes(): this;

  unpinCorner(corner: WaveClothCorner): this;

  withoutSelfCollisions(): this;

  withShearConstraints(enabled?: boolean): this;

}

interface WaveClothConfig {

  attachments: WaveSoftBodyAttachmentConfig[];

  constraints: WaveSoftBodyDistanceConstraintConfig[];

  name: string;

  nodeCount: number;

  nodes: WaveSoftBodyNodeConfig[];

  pins: number[];

  restStates: WaveSoftBodyNodeConfig[];

  visuals: WaveSoftBodyVisualConfig;

  cols: number;

  kind: "cloth";

  options: { rows: number; cols: number; spacing: number; position: WavePathExtrusionSerializedPoint; nodeMass: number; nodeRadius: number; nodeColliderShape: WaveSoftBodyNodeColliderShape; damping: number; pinTopRow: boolean; particleCollision: WaveSoftBodyParticleCollisionPolicy; includeShear: boolean; horizontal: boolean; pinCorners: boolean; }

  rows: number;

}

type WaveClothCorner = "topLeft" | "topRight" | "bottomLeft" | "bottomRight";

interface WaveClusteredLightsConfigSnapshot {

  depthSlices: number;

  horizontalTiles: number;

  maxRange: number;

  unsupportedLightPolicy: WaveClusteredLightUnsupportedPolicy;

  verticalTiles: number;

}

type WaveClusteredLightUnsupportedPolicy = "throw" | "ignore";

interface WaveColliderMassModelConfig {

  readonly density: number;

  readonly source: "collider";

  readonly strict?: boolean;

  readonly volume: WaveModelMassVolumeSource;

}

type WaveCollisionTruthPolicy = "bindPose" | "conservativeProxy" | "explicitCpuSnapshot";

interface WaveColorCallbackBuilder {

  darken(color: ColorCallbackColorInput, percentage: number): ColorCallbackInput;

  fromHexNumber(hexNumber: number): ColorCallbackInput;

  fromHexString(hexString: string): ColorCallbackInput;

  fromNormalizedRGB(r: number, g: number, b: number): ColorCallbackInput;

  hsv(h: number, s: number, v: number): ColorCallbackInput;

  lighten(color: ColorCallbackColorInput, percentage: number): ColorCallbackInput;

  mix(from: ColorCallbackColorInput, to: ColorCallbackColorInput, t: number): ColorCallbackInput;

  random(...colors: ColorCallbackColorInput[]): ColorCallbackInput;

  randomFrom(colors: readonly ColorCallbackColorInput[], seed?: number): ColorCallbackInput;

  randomSeeded(seed: number): ColorCallbackInput;

  randomVibrant(seed?: number, saturation?: number, value?: number): ColorCallbackInput;

  rgb(r: number, g: number, b: number): ColorCallbackInput;

  rgba(r: number, g: number, b: number, a: number): ColorCallbackInput;

  rgbaNormalized(r: number, g: number, b: number, a: number): ColorCallbackInput;

  rgbNormalized(r: number, g: number, b: number): ColorCallbackInput;

  sampleGradient(input: ColorCallbackGradientInput, position: number): ColorCallbackInput;

  scaleAlpha(color: ColorCallbackColorInput, percentage: number): ColorCallbackInput;

  scaleBlue(color: ColorCallbackColorInput, percentage: number): ColorCallbackInput;

  scaleGreen(color: ColorCallbackColorInput, percentage: number): ColorCallbackInput;

  scaleRed(color: ColorCallbackColorInput, percentage: number): ColorCallbackInput;

  withAlpha(color: ColorCallbackColorInput, alpha: number): ColorCallbackInput;

}

interface WaveColorRef {

  readonly kind: "color";

  toExpr(): WaveValueExpr;

  toJSON(): WaveValueExpr;

  readonly a: WaveNumberRef;

  readonly b: WaveNumberRef;

  readonly g: WaveNumberRef;

  readonly r: WaveNumberRef;

  readonly rgb: WaveVec3Ref;

}

interface WaveColorSemanticDebug {

  physicsActive: number;

  physicsDisabled: number;

}

interface WaveColorSemanticNamespaces {

  debug: WaveColorSemanticDebug;

  ui: WaveColorSemanticUi;

}

interface WaveColorSemanticUi {

  background: number;

  error: number;

  text: number;

  warning: number;

}

type WaveColorSingleton = PaletteColorMap & WaveColorSemanticNamespaces & { rgb: (r: number, g: number, b: number) => number; rgba: (r: number, g: number, b: number, a: number) => number; rgbNormalized: (r: number, g: number, b: number) => number; rgbaNormalized: (r: number, g: number, b: number, a: number) => number; asCallback: (seed?: number) => WaveColorCallbackBuilder; random: (...colors: number[]) => number; hsv: (h: number, s: number, v: number) => number; fromHexNumber: (hexNumber: number) => number; fromHexString: (hexString: string) => number; fromNormalizedRGB: (r: number, g: number, b: number) => number; scaleRed: (color: number, percentage: number) => number; scaleGreen: (color: number, percentage: number) => number; scaleBlue: (color: number, percentage: number) => number; scaleAlpha: (color: number, percentage: number) => number; lighten: (color: number, percentage: number) => number; darken: (color: number, percentage: number) => number; mix: (from: ColorInput, to: ColorInput, t: number) => number; withAlpha: (color: ColorInput, alpha: number) => number; toRGB: (color: ColorInput) => { r: number; g: number; b: number; }; toRGBA: (color: ColorInputAlpha) => { r: number; g: number; b: number; a: number; }; toNormalizedRGB: (color: ColorInput) => { r: number; g: number; b: number; }; toNormalizedRGBA: (color: ColorInputAlpha, defaultAlpha?: number) => { r: number; g: number; b: number; a: number; }; toHexNumber: (color: ColorInput) => number; toHexString: (color: ColorInputAlpha) => string; toCss: (color: ColorInputAlpha | string, alpha?: number) => string; toColor3: (color: ColorInput) => unknown; toColor4: (color: ColorInputAlpha, defaultAlpha?: number) => unknown; randomSeeded: (seed: number) => number; randomVibrant: (seed?: number, saturation?: number, value?: number) => number; randomFrom: (colors: number[], seed?: number) => number; gradient: (input: number[] | ColorGradientOptions) => FluentPalette; gradientStops: (colors: { r: number; g: number; b: number; }[]) => ColorGradientStop[]; sampleGradient: (input: number[] | ColorGradientOptions | ColorPalette | readonly ColorGradientStop[], position: number) => number; setGlobalPaletteStyle: (style: PaletteStyle) => void; readonly activeStyle: PaletteStyle; }

interface WaveColorValueInput {

  readonly a?: WaveNumberValueInput;

  readonly b?: WaveNumberValueInput;

  readonly g?: WaveNumberValueInput;

  readonly r?: WaveNumberValueInput;

}

declare class WaveCompiledAssemblyInstances<TInput, TController, TServices> extends WaveGroup<wave3DObject> {

  constructor(name: string, terminal: WaveCompiledAssemblyTerminal<TInput, TController, TServices>, scene: WaveGroupSceneBridge);

  activate(index: number): this;

  activateAll(): this;

  get controllers(): readonly TController[];

  dispose(): void;

  instance(index: number): WaveCompiledAssemblyInstance;

  get instances(): readonly WaveCompiledAssemblyInstance[];

  makeDormant(index: number): this;

  makeResident(index: number): this;

  realize(inputs: readonly TInput[], services: TServices): readonly TController[];

  residency(index: number): WaveAssemblyResidency;

  resolve(entity: wave3DObject | number): WaveAssemblyEntityAddress | null;

  setAllResidency(residency: WaveAssemblyResidency): this;

  setResidency(index: number, next: WaveAssemblyResidency): this;

  readonly terminal: WaveCompiledAssemblyTerminal<TInput, TController, TServices>;

}

declare class WaveCompiledAssemblyTerminal<TInput, TController, TServices> {

  constructor(recipe: WaveAssemblyRecipe | WaveAssemblyRealizationPlan, program: WaveAssemblyRealizationProgram<TInput, TController, TServices>);

  getPhysicsRigLayout(slotId: string): WaveAssemblyCompiledRigLayout | null;

  readonly layout: WaveAssemblyDenseLayout;

  readonly plan: WaveAssemblyRealizationPlan;

  readonly program: WaveAssemblyRealizationProgram<TInput, TController, TServices>;

  requireSlot(id: string): WaveAssemblySlot;

  requireSlotLayout(id: string): WaveAssemblySlotLayout;

  resolvePhysicsRig<TPart extends WavePhysicsRigPart>(slotId: string, rig: WavePhysicsRig<TPart>, options: WaveModelPhysicsRigOptions): WaveAssemblyCompiledRigLayout;

  get revision(): string;

  get snapshot(): WaveCompiledAssemblyTerminalSnapshot;

  get structureSealed(): boolean;

}

interface WaveCompiledAssemblyTerminalSnapshot {

  readonly controllerId: string | null;

  readonly controllerRevision: string | null;

  readonly entityCapacity: number;

  readonly programId: string;

  readonly programRevision: string;

  readonly recipeRevision: string;

  readonly rigLayouts: readonly WaveAssemblyCompiledRigSnapshot[];

  readonly slotCardinalities: readonly (readonly [string, number])[];

  readonly version: typeof WAVE_COMPILED_ASSEMBLY_TERMINAL_VERSION;

}

interface WaveCompiledSkinWeightChannels {

  readonly joints0: Uint16Array | Uint32Array;

  readonly joints1?: Uint16Array | Uint32Array;

  readonly weights0: Float32Array;

  readonly weights1?: Float32Array;

}

declare abstract class WaveComponent<TOwner extends WaveEntity<unknown> = WaveEntity<unknown>> {

  constructor(owner: TOwner, componentName?: string);

  static readonly isSingleton: boolean;

  static readonly typeName: string;

  get canPlayAudio(): boolean;

  get canRender(): boolean;

  get canSimulatePhysics(): boolean;

  readonly componentName: string;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  destroy(): void;

  get destroyPriority(): number;

  disable(): this;

  dispose(): void;

  enable(): this;

  get enabled(): boolean;

  get engine(): unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  get isCapable(): boolean;

  get isComponentActive(): boolean;

  get isDestroyed(): boolean;

  get isDisposing(): boolean;

  get isUnbound(): boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  get owner(): TOwner;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  get scene(): WaveScene | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  get typeName(): string;

}

interface WaveComposeValueExpr {

  readonly components: readonly WaveValueExpr[];

  readonly kind: "vec2" | "vec3" | "vec4" | "color";

  readonly type: "compose";

}

interface WaveCompositeValueCurveSpec {

  readonly curves: readonly WaveValueCurveSpec[];

  readonly kind: "add" | "multiply";

}

interface WaveConePrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "cone";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly arcFraction?: number;

  readonly bottomRadius: number;

  readonly cap?: WaveCapMode;

  readonly encloseArc?: boolean;

  readonly faces?: Partial<Readonly<Record<WaveAxialFace, WavePrimitiveFaceLayout>>>;

  readonly height: number;

  readonly heightSegments?: number;

  readonly radialSegments?: number;

  readonly topRadius?: number;

}

interface WaveConstantValueCurveSpec {

  readonly kind: "constant";

  readonly value: number;

}

interface WaveConstantValueExpr {

  readonly kind?: WaveValueKind;

  readonly type: "const";

  readonly value: WaveValue;

}

interface WaveCurve2DInput {

  readonly points: readonly WaveCurve2DPointInput[];

  readonly smoothing?: WaveCurve2DSmoothing;

}

type WaveCurve2DMutablePoint = SerializableVector2;

type WaveCurve2DPoint = Readonly<SerializableVector2>;

type WaveCurve2DPointInput = WaveCurve2DPoint | readonly [x: number, y: number];

interface WaveCurve2DPointSource {

  toPointsToRef(options: WaveCurve2DSamplingOptions, result: WaveCurve2DMutablePoint[], spare: WaveCurve2DMutablePoint[]): WaveCurve2DMutablePoint[];

}

interface WaveCurve2DSamplingOptions {

  readonly arcSegments?: number;

  readonly close?: boolean;

  readonly curveSegments?: number;

  readonly maxPoints?: number;

  readonly requireContinuous?: boolean;

}

type WaveCurve2DSmoothing = "linear" | "quadratic";

type WaveCurve2DSource = WaveCurve2DInput | WaveCurve2DPointSource;

type WaveCurveInput = ReadonlyArray<Vector3> | WaveCurvePathPoints | WaveCurveLineSegment | WaveCurvePathEntity;

interface WaveCurveLineSegment {

  end: WavePointInput;

  start: WavePointInput;

}

interface WaveCurvePathEntity {

  readonly sampledPoints: ReadonlyArray<Vector3>;

}

interface WaveCurvePathPoints {

  readonly closed?: boolean;

  readonly curveType?: WavePathCurveType;

  readonly points: ReadonlyArray<Vector3>;

  readonly segments?: number;

}

interface WaveCurveRef {

  at(input: WaveNumberAuthoringInput): WaveNumberRef;

  readonly curve: WaveValueCurve;

  toConfig(): ReturnType<WaveValueCurve["toConfig"]>;

}

interface WaveCurveValueExpr {

  readonly curve: WaveValueCurveSpec;

  readonly input: WaveValueExpr;

  readonly type: "curve";

}

interface WaveCylinderPrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "cylinder";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly arcFraction?: number;

  readonly bottomRadius: number;

  readonly cap?: WaveCapMode;

  readonly encloseArc?: boolean;

  readonly faces?: Partial<Readonly<Record<WaveAxialFace, WavePrimitiveFaceLayout>>>;

  readonly height: number;

  readonly heightSegments?: number;

  readonly radialSegments?: number;

  readonly topRadius: number;

}

type WaveDirection2DInput = ScreenPlaneDirectionInput;

interface WaveDiscPrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "disc";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly arcFraction?: number;

  readonly faces?: Partial<Readonly<Record<WavePlanarFace, WavePrimitiveFaceLayout>>>;

  readonly innerRadius?: number;

  readonly outerRadius: number;

  readonly radialSegments?: number;

}

interface WaveEffectBaseDescriptor<THelpers extends WaveEffectHelpers = {}> {

  readonly defaultAsset: string;

  readonly effectId: string;

  with(params: WaveEffectParams): WaveEffectVariantDescriptor<THelpers>;

}

type WaveEffectDescriptor<THelpers extends WaveEffectHelpers = {}> = Readonly<WaveEffectBaseDescriptor<THelpers> & THelpers>;

type WaveEffectHelpers = object;

type WaveEffectInput<THelpers extends WaveEffectHelpers = {}> = string | WaveEffectDescriptor<THelpers> | WaveEffectVariantDescriptor<THelpers>;

type WaveEffectParamPrimitive = string | number | boolean | null;

type WaveEffectParams = Readonly<Record<string, WaveEffectParamValue>>;

type WaveEffectParamValue = WaveEffectParamPrimitive | readonly WaveEffectParamValue[] | { readonly [key: string]: WaveEffectParamValue; }

type WaveEffectVariantDescriptor<THelpers extends WaveEffectHelpers = {}> = Readonly<WaveEffectBaseDescriptor<THelpers> & THelpers & { readonly params: WaveEffectParams; }>;

declare class WaveEndEffectorAnimationBuilder {

  constructor(_host: WavePartIKAnimationHost, _intent: EndEffectorIntent, _solveOptions?: WaveModelIKRuntimeSolveOptions);

  after(duration: WaveTimeSpan): this;

  after(value: number, unit: WaveTimeUnit): this;

  atRateOf(rate: WaveRate): this;

  atRateOf(value: number, unit: WaveRateUnit): this;

  for(duration: WaveTimeSpan): this;

  for(value: number, unit: WaveTimeUnit): this;

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  play(): TransitionLifecycleHandle<Record<string, number>>;

  withCallbacks(callbacks: TransitionLifecycleCallbacks<Record<string, number>>): this;

  withEasingEffect(ease: WaveEasing): this;

  withProgressCurve(curve: WaveValueCurveInput): this;

}

declare class WaveEndEffectorScope {

  constructor(_host: WavePartIKAnimationHost, _endEffector: string, _frame?: WaveTransformFrameSpace, _terms?: WaveTransformTermsSpace, _frameOf?: TransformReferenceLike | undefined, _parentFrameDepth?: number, _solveOptions?: WaveModelIKRuntimeSolveOptions);

  inFrameOf(target: TransformReferenceLike): WaveEndEffectorScope;

  inLocalFrame(): WaveEndEffectorScope;

  inLocalTerms(): WaveEndEffectorScope;

  inParentFrame(depth?: number): WaveEndEffectorScope;

  inParentTerms(): WaveEndEffectorScope;

  inWorldFrame(): WaveEndEffectorScope;

  inWorldTerms(): WaveEndEffectorScope;

  keepRotatingAround(axis: DirectionInput): WaveEndEffectorAnimationBuilder;

  moveBy(axis: DirectionInput, distance: number, mode: typeof Animate): WaveEndEffectorAnimationBuilder;

  moveBy(axis: Direction, mode: typeof Animate): WaveEndEffectorAnimationBuilder;

  moveBy(axis: DirectionInput, distance: number): WaveModelIKSolveResult;

  moveBy(delta: Vector3Like, mode: typeof Animate): WaveEndEffectorAnimationBuilder;

  moveBy(x: number, y: number, z: number, mode: typeof Animate): WaveEndEffectorAnimationBuilder;

  moveBy(delta: Vector3Like): WaveModelIKSolveResult;

  moveBy(x: number, y: number, z: number): WaveModelIKSolveResult;

  moveTo(target: TransformReferenceLike | WavePointInput, mode: typeof Animate): WaveEndEffectorAnimationBuilder;

  moveTo(target: TransformReferenceLike | WavePointInput): WaveModelIKSolveResult;

  rotateAroundBy(axis: DirectionInput, degrees: number, mode: typeof Animate): WaveEndEffectorAnimationBuilder;

  rotateAroundBy(axis: DirectionInput, degrees: number): WaveModelIKSolveResult;

  rotateTo(rotation: Quaternion, mode: typeof Animate): WaveEndEffectorAnimationBuilder;

  rotateTo(rotation: Quaternion): WaveModelIKSolveResult;

}

type WaveEngineProfileId = WaveBrandedId<"engine-profile">;

type WaveEngineProfileName = "Local" | "P2PHost" | "P2PHostHeadless" | "ThinClient";

type WaveEngineSystemMap = { readonly [K in WaveInstalledSystemKey]: EngineSystemType<(typeof ENGINE_SYSTEM_CONTRACTS)[K]>; }

type WaveEntityIdentityInput = WaveEntityIdentityRef | WaveEntityIdentitySource;

type WaveEntityIdentityRef = `net:${number}` | `runtime:${string}`;

interface WaveEntityIdentitySource {

  readonly networkID?: number;

  readonly runtimeRef: string;

}

type WaveEntityRuntimeRef = string;

type WaveEquipmentSlotCallback<TOwner extends wave3DObject = wave3DObject> = (event: WaveEquipmentSlotEvent<TOwner>) => void;

interface WaveEquipmentSlotEvent<TOwner extends wave3DObject = wave3DObject> {

  readonly item: wave3DObject | null;

  readonly owner: TOwner;

  readonly slot: WaveEquipmentSlotHandle<TOwner>;

  readonly slotName: string;

  readonly socket: BoneSocket | null;

}

type WaveEventChannel = "animation" | "gameplay" | "sound" | "vfx" | "input" | "network" | "system" | "custom";

declare class WaveEventDefinition<TEventData = unknown> {

  constructor(nameOrMetadata: string | WaveEventDefinitionMetadata<TEventData>);

  channel(channel: WaveEventChannel): this;

  get id(): string;

  get name(): string;

  payloadSchema(payloadSchema: WaveModelSerializableValue): this;

  replication(replication: WaveEventReplicationPolicy): this;

  toMetadata(): WaveEventDefinitionMetadata<TEventData>;

  toString(): string;

}

interface WaveEventDefinitionMetadata<TEventData = unknown> {

  readonly channel?: WaveEventChannel;

  readonly id: string;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly name: string;

  readonly payloadSchema?: WaveModelSerializableValue;

  readonly replication?: WaveEventReplicationPolicy;

}

type WaveEventInput<TEventData = unknown> = string | WaveEventDefinition<TEventData> | WaveEventDefinitionMetadata<TEventData>;

type WaveEventReplicationPolicy = "local" | "deterministic" | "remote" | "host-authoritative";

type WaveFaceSelector = WaveSurface | string | WaveModelSurfaceSelectorDescriptor | WaveModelSurfaceQuery;

interface WaveFalloffValueCurveSpec {

  readonly kind: "falloff";

  readonly mode: WaveValueCurveFalloffMode;

}

interface WaveFieldBuoyancyInfluence {

  application?: WaveFieldInfluenceApplication | undefined;

  enabled?: boolean | undefined;

  forceLimit?: number | undefined;

  id?: string | undefined;

  direction?: Direction;

  drag?: number;

  kind: typeof WaveFieldInfluenceKind.Buoyancy;

  strength?: number;

}

type WaveFieldBuoyancyInfluence = ModelWaveFieldBuoyancyInfluence;

interface WaveFieldBuoyancySourceConfig {

  application?: WaveFieldInfluenceApplication;

  direction?: Direction;

  drag?: number;

  limit?: number;

  strength?: number;

}

type WaveFieldCompositionMode = "sum";

type WaveFieldCompositionMode = ModelWaveFieldCompositionMode;

interface WaveFieldConfig<TPoint = unknown> {

  composition?: WaveFieldCompositionMode;

  defaultGravity?: WaveFieldDefaultGravityMode;

  influences?: readonly WaveFieldInfluence<TPoint>[];

  name?: string;

  shape?: WaveRangeShape;

  targetEntityIds?: readonly number[];

  targetTags?: readonly string[];

}

type WaveFieldConfig = ModelWaveFieldConfig<WaveFieldPointInput>;

type WaveFieldDefaultGravityMode = "preserve" | "ignore";

type WaveFieldDefaultGravityMode = ModelWaveFieldDefaultGravityMode;

interface WaveFieldDenseVectorVolumeSource {

  boundary?: WaveFieldVectorFieldBoundary;

  data: WaveFieldVectorVolumeData;

  kind: "vectorVolume";

  resolution: readonly [number, number, number];

}

type WaveFieldForceVectorHelperSync = (field: WaveField, options: WaveFieldForceVectorOptions | null) => void;

interface WaveFieldForceVectorOptions {

  targetMass?: number | undefined;

  velocity?: any;

  color?: ColorInput;

  maxArrows?: number;

  minMagnitude?: number;

  normalized?: boolean;

  opacity?: number;

  refreshIntervalSeconds?: number;

  scale?: number;

  voxelSize?: number;

}

interface WaveFieldGravityInfluence<TPoint = unknown> {

  application?: WaveFieldInfluenceApplication | undefined;

  enabled?: boolean | undefined;

  forceLimit?: number | undefined;

  id?: string | undefined;

  collisionRadius?: number;

  damping?: number;

  gravityConstant?: number;

  kind: typeof WaveFieldInfluenceKind.Gravity;

  source?: TPoint;

  sourceMass?: number;

}

type WaveFieldGravityInfluence = ModelWaveFieldGravityInfluence<WaveFieldPointInput>;

interface WaveFieldGravityWellConfig {

  application?: WaveFieldInfluenceApplication;

  center?: WaveFieldPointInput;

  damping?: number;

  gravityConstant?: number;

  limit?: number;

  mass?: number;

  softCore?: number;

  source?: WaveFieldPointInput;

}

interface WaveFieldHeightGradientConfig {

  application?: WaveFieldInfluenceApplication;

  curve?: WaveValueCurveInput;

  curveInput?: WaveSampledFieldCurveCoordinate;

  height: number;

  heights?: WaveFieldScalarData;

  heightScale?: number;

  interpolation?: WaveFieldVectorFieldSampling;

  limit?: number;

  mapping?: WaveFieldVectorFieldMapping;

  mode?: WaveFieldHeightmapGradientMode;

  strength?: number;

  width: number;

}

type WaveFieldHeightmapGradientMode = ModelWaveFieldHeightmapGradientMode;

type WaveFieldHeightmapGradientMode = "downhill" | "uphill";

interface WaveFieldHeightmapVectorSource {

  height: number;

  heights: WaveFieldScalarData;

  heightScale?: number;

  kind: "heightmap";

  mode?: WaveFieldHeightmapGradientMode;

  width: number;

}

interface WaveFieldHelperOptions {

  boxSegments?: number | undefined;

  color?: ColorInput | undefined;

  opacity?: number | undefined;

  segments?: number | undefined;

  sphereSegments?: number | undefined;

  volume?: boolean;

}

type WaveFieldInfluence<TPoint = unknown> = WaveFieldGravityInfluence<TPoint> | WaveFieldWindInfluence | WaveFieldVectorFieldInfluence | WaveFieldVortexInfluence<TPoint> | WaveFieldBuoyancyInfluence | WaveFieldRadialInfluence<TPoint>;

type WaveFieldInfluence = WaveFieldGravityInfluence | WaveFieldWindInfluence | WaveFieldVectorFieldInfluence | WaveFieldVortexInfluence | WaveFieldBuoyancyInfluence | WaveFieldRadialInfluence;

type WaveFieldInfluenceApplication = ModelWaveFieldInfluenceApplication;

type WaveFieldInfluenceApplication = "force" | "acceleration";

type WaveFieldInfluenceKindValue = (typeof WaveFieldInfluenceKind)[keyof typeof WaveFieldInfluenceKind];

interface WaveFieldInfluenceSample {

  direction: Vector3;

  force: Vector3;

  id: string;

  kind: WaveFieldInfluenceKindValue;

  strength: number;

}

type WaveFieldPointInput = WavePointInput | WaveSpatial3DObject;

interface WaveFieldRadialInfluence<TPoint = unknown> {

  application?: WaveFieldInfluenceApplication | undefined;

  enabled?: boolean | undefined;

  forceLimit?: number | undefined;

  id?: string | undefined;

  coreRadius?: number;

  falloff?: WaveFieldVortexFalloff;

  kind: typeof WaveFieldInfluenceKind.Radial;

  mode: WaveFieldRadialMode;

  source?: TPoint;

  strength: number;

}

type WaveFieldRadialInfluence = ModelWaveFieldRadialInfluence<WaveFieldPointInput>;

type WaveFieldRadialMode = "push" | "pull";

interface WaveFieldRadialSourceConfig {

  application?: WaveFieldInfluenceApplication;

  center?: WaveFieldPointInput;

  coreRadius?: number;

  falloff?: WaveFieldVortexFalloff;

  limit?: number;

  source?: WaveFieldPointInput;

  strength: number;

}

interface WaveFieldSample {

  component(idOrKind: string): WaveFieldInfluenceSample | undefined;

  components: readonly WaveFieldInfluenceSample[];

  netDirection: Vector3;

  netForce: Vector3;

  perpendicular(options?: WaveFieldTangentOptions): Vector3;

  position: Vector3;

  strength: number;

  tangent(options?: WaveFieldTangentOptions): Vector3;

}

type WaveFieldSample = ModelWaveFieldSample;

interface WaveFieldSampleOptions {

  targetMass?: number;

  velocity?: WaveFieldVectorInput | null;

}

type WaveFieldSampleOptions = ModelWaveFieldSampleOptions;

type WaveFieldScalarData = ModelWaveFieldScalarData;

type WaveFieldScalarData = ArrayLike<number>;

type WaveFieldTangentOptions = ModelWaveFieldTangentOptions;

interface WaveFieldTangentOptions {

  axis?: Direction;

}

type WaveFieldTextureChannel = "r" | "g" | "b" | "a";

interface WaveFieldTextureFlowConfig {

  application?: WaveFieldInfluenceApplication;

  channels?: WaveFieldTextureVectorSource["channels"];

  interpolation?: WaveFieldVectorFieldSampling;

  limit?: number;

  mapping?: WaveFieldVectorFieldMapping;

  strength?: number;

  texture: string;

  valueRange?: WaveFieldTextureValueRange;

}

type WaveFieldTexturePixels = WaveTextureCpuPixels;

type WaveFieldTextureResolver = (assetName: string) => WaveFieldTexturePixels | null;

type WaveFieldTextureResolver = ModelWaveFieldTextureResolver;

type WaveFieldTextureValueRange = ModelWaveFieldTextureValueRange;

type WaveFieldTextureValueRange = "unsigned" | "signed";

type WaveFieldTextureVectorSource = ModelWaveFieldTextureVectorSource;

interface WaveFieldTextureVectorSource {

  channels?: { x?: WaveFieldTextureChannel; y?: WaveFieldTextureChannel; z?: WaveFieldTextureChannel; }

  kind: "texture";

  texture: string;

  valueRange?: WaveFieldTextureValueRange;

}

type WaveFieldVector3Like = SerializableVector3;

type WaveFieldVectorFieldBoundary = ModelWaveFieldVectorFieldBoundary;

type WaveFieldVectorFieldBoundary = WaveSampledFieldBoundary;

interface WaveFieldVectorFieldInfluence {

  application?: WaveFieldInfluenceApplication | undefined;

  enabled?: boolean | undefined;

  forceLimit?: number | undefined;

  id?: string | undefined;

  kind: typeof WaveFieldInfluenceKind.VectorField;

  mapping?: WaveFieldVectorFieldMapping;

  sampling?: WaveFieldVectorFieldSampling;

  source: WaveFieldVectorFieldSource;

  strength?: number;

}

type WaveFieldVectorFieldInfluence = ModelWaveFieldVectorFieldInfluence;

type WaveFieldVectorFieldMapping = ModelWaveFieldVectorFieldMapping;

type WaveFieldVectorFieldMapping = WavePlaneFrameIntent;

type WaveFieldVectorFieldSampling = ModelWaveFieldVectorFieldSampling;

type WaveFieldVectorFieldSampling = WaveSampledFieldSampling;

type WaveFieldVectorFieldSource = WaveFieldVectorGridSource | WaveFieldVectorVolumeSource | WaveFieldDenseVectorVolumeSource | WaveFieldTextureVectorSource | WaveFieldHeightmapVectorSource;

interface WaveFieldVectorGridConfig {

  application?: WaveFieldInfluenceApplication;

  curves?: WaveSampledFieldVectorCurveConfig;

  height: number;

  interpolation?: WaveFieldVectorFieldSampling;

  limit?: number;

  mapping?: WaveFieldVectorFieldMapping;

  strength?: number;

  vectors?: readonly WaveFieldVectorInput[];

  width: number;

}

interface WaveFieldVectorGridSource {

  height: number;

  kind: "samples";

  vectors: readonly WaveFieldVectorInput[];

  width: number;

}

type WaveFieldVectorInput = ModelWaveFieldVectorInput;

type WaveFieldVectorInput = Vector3 | WaveFieldVector3Like;

interface WaveFieldVectorVolumeConfig {

  application?: WaveFieldInfluenceApplication;

  boundary?: WaveFieldVectorFieldBoundary;

  curves?: WaveSampledFieldVectorCurveConfig;

  data?: WaveFieldVectorVolumeData;

  interpolation?: WaveFieldVectorFieldSampling;

  limit?: number;

  resolution: readonly [number, number, number];

  strength?: number;

}

type WaveFieldVectorVolumeData = ModelWaveFieldVectorVolumeData;

type WaveFieldVectorVolumeData = ArrayLike<number>;

interface WaveFieldVectorVolumeSource {

  depth: number;

  height: number;

  kind: "volumeSamples";

  vectors: readonly WaveFieldVectorInput[];

  width: number;

}

type WaveFieldVortexFalloff = ModelWaveFieldVortexFalloff;

type WaveFieldVortexFalloff = "none" | "inverseDistance";

interface WaveFieldVortexInfluence<TPoint = unknown> {

  application?: WaveFieldInfluenceApplication | undefined;

  enabled?: boolean | undefined;

  forceLimit?: number | undefined;

  id?: string | undefined;

  axis?: Direction;

  center?: TPoint;

  coreRadius?: number;

  falloff?: WaveFieldVortexFalloff;

  kind: typeof WaveFieldInfluenceKind.Vortex;

  strength: number;

}

type WaveFieldVortexInfluence = ModelWaveFieldVortexInfluence<WaveFieldPointInput>;

interface WaveFieldVortexSourceConfig {

  application?: WaveFieldInfluenceApplication;

  axis?: Direction;

  center?: WaveFieldPointInput;

  coreRadius?: number;

  falloff?: WaveFieldVortexFalloff;

  limit?: number;

  strength: number;

}

interface WaveFieldWindInfluence {

  application?: WaveFieldInfluenceApplication | undefined;

  enabled?: boolean | undefined;

  forceLimit?: number | undefined;

  id?: string | undefined;

  direction: Direction;

  kind: typeof WaveFieldInfluenceKind.Wind;

  strength: number;

}

type WaveFieldWindInfluence = ModelWaveFieldWindInfluence;

interface WaveFieldWindSourceConfig {

  application?: WaveFieldInfluenceApplication;

  direction: Direction;

  limit?: number;

  strength: number;

}

type WaveFractureFailureReason = "cancelled" | "sourceUnavailable" | "sourceRetired" | "materialNotBreakable" | "impactBelowThreshold" | "unsupportedSourceTopology" | "unsupportedSourceChannels" | "budgetExceeded" | "workerUnavailable" | "topologyFailure" | "commitFailure";

interface WaveFractureHandle {

  cancel(): void;

  readonly id: string;

  readonly state: WaveFractureHandleState;

  whenCommitted(callback: (result: WaveImpactFractureResult) => void): this;

  whenFailed(callback: (result: WaveImpactFractureResult) => void): this;

}

type WaveFractureHandleState = "queued" | "running" | "committed" | "rejected" | "cancelled";

type WaveFractureInteriorColorInput = unknown | string | number;

type WaveFractureMode = "simple" | "realistic";

declare const waveFx: { emitter(id: string): FxEmitterBuilder; retainedVolume(id: string, options: WaveFxRetainedVolumeOptions): WaveFxRetainedVolume; contactEvents(emitterId: string): WaveGpuEventStreamRef; screenLayer(id: string, opts: ScreenLayerOpts): WaveFxSystemAsset; trail(id: string, opts?: TrailOpts): FxEmitterBuilder; coneTrail(id: string, opts?: ConeTrailFxOpts): FxEmitterBuilder; weaponSwoosh(id: string, opts: WeaponSwooshOpts): FxEmitterBuilder; shockwave(id: string, opts?: ShockwaveOpts): WaveFxSystemAsset; portal(id: string, opts: PortalFxOpts): WaveFxSystemAsset; warningState<T extends Record<string, FxValue>>(normal: T, warning: T): { normal: T; warning: T; }; surface: { heightfield(heightfield: WaveHeightfield, opts?: HeightfieldSurfaceOpts): WaveSurfaceHeightfieldStructure; geometry(geometry: WaveSurfaceGeometrySource): WaveSurfaceMeshAssetStructure; ground(opts?: FxGroundCollisionSurfaceOpts): FxCollisionPlaneSurface; plane(opts: FxPlaneCollisionSurfaceOpts): FxCollisionPlaneSurface; terrain(source: wave3DObject, opts?: FxTerrainCollisionSurfaceOpts): FxCollisionTerrainSurface; table(opts: FxTableCollisionSurfaceOpts): FxCollisionPlaneSurface; }; wake(id: string, opts?: WakeOpts): FxEmitterBuilder; exhaust(id: string, opts: ExhaustOpts): FxEmitterBuilder; impactBurst(id: string, opts: ImpactBurstOpts): FxEmitterBuilder; muzzleFlash(id: string, opts: MuzzleFlashOpts): FxEmitterBuilder; sparks(id: string, opts?: SparksOpts): FxEmitterBuilder; system(id: string, emitters: (FxEmitterBuilder | FxEmitterDefinition | [FxEmitterBuilder | FxEmitterDefinition, EmitterBindingOpts])[], opts?: SystemOpts): WaveFxSystemAsset; exposed: { number(name: string, defaultValue: number, opts?: ExposedParamOpts): FxUserParamSchema; bool(name: string, defaultValue: boolean, opts?: ExposedParamOpts): FxUserParamSchema; vec2(name: string, defaultValue: FxValue & { x: number; y: number; }, opts?: ExposedParamOpts): FxUserParamSchema; vec3(name: string, defaultValue: FxValue & { x: number; y: number; z: number; }, opts?: ExposedParamOpts): FxUserParamSchema; vec4(name: string, defaultValue: FxValue & { x: number; y: number; z: number; w: number; }, opts?: ExposedParamOpts): FxUserParamSchema; color(name: string, defaultValue: ColorInputAlpha, opts?: ExposedParamOpts): FxUserParamSchema; }; target: { world(position: Vector3Like): FxExpr; user(name: string): FxExpr; systemAnchor(field?: FxTransformExpr["field"]): FxExpr; systemAnchorVelocity(): FxExpr; systemAnchorSpeed(): FxExpr; controllerThrottle(): FxExpr; emitterAnchor(field?: FxTransformExpr["field"]): FxExpr; emitterAnchorVelocity(): FxExpr; emitterAnchorSpeed(): FxExpr; }; val(n: number): FxExpr; rand(min: number, max: number): FxExpr; curve(...args: FxCurveInputArgs): FxExpr; valueCurve(curve: FxValueCurveInput, options?: FxValueCurveSamplingOptions): FxExpr; attr(name: string): FxExpr; user(name: string): FxExpr; time(): FxExpr; math(op: string, a: FxExpr, b?: FxExpr, c?: FxExpr, d?: FxExpr): FxExpr; };

interface WaveFxAnchorBinding {

  readonly orphanFade?: WaveTimeSpanSpec;

  readonly orphanPolicy?: FxOrphanPolicy;

  readonly target: WaveSpatialAnchorRef;

}

declare class WaveFxParametricPathBuilder {

  constructor(_id: string, source: WaveFxParametricPathSource);

  ribbon(opts?: WaveFxParametricRibbonOptions): FxEmitterDefinition;

  tube(opts?: WaveFxParametricTubeOptions): FxEmitterDefinition;

}

interface WaveFxParametricPathFacade {

  parametricPath(id: string, path: WaveFxParametricPathSource): WaveFxParametricPathBuilder;

}

type WaveFxParametricPathSource = WavePathSampleProvider | readonly Vector3Like[];

interface WaveFxParametricRibbonOptions {

  blend?: "multiply" | "alpha" | "additive" | undefined;

  bundle?: { strandCount?: number; spread?: number; spreadOverLength?: FxValueCurveInput; twistOverLength?: FxValueCurveInput; twist?: number; phaseSpeed?: number; jitter?: number; strandWidthScale?: number; } | undefined;

  color?: ColorInputAlpha | undefined;

  conservativeBounds?: { minimum: Vector3Like; maximum: Vector3Like; } | undefined;

  depthWrite?: boolean | undefined;

  glow?: FxGlowConfig | undefined;

  maxPoints?: number | undefined;

  noise?: FxParametricPathNoiseSpec | undefined;

  opacity?: number | undefined;

  pathSamples?: number | undefined;

  seed?: number | undefined;

  texture?: string | undefined;

  textureMode?: "stretch" | "tile" | "distanceRepeat" | undefined;

  textureRepeatDistance?: number | undefined;

  widthOverLength?: FxValueCurveInput | undefined;

  segments?: number;

}

interface WaveFxParametricTubeOptions {

  blend?: "multiply" | "alpha" | "additive" | undefined;

  color?: ColorInputAlpha | undefined;

  conservativeBounds?: { minimum: Vector3Like; maximum: Vector3Like; } | undefined;

  depthWrite?: boolean | undefined;

  diameterOverLength?: FxValueCurveInput | undefined;

  glow?: FxGlowConfig | undefined;

  maxPoints?: number | undefined;

  noise?: FxParametricPathNoiseSpec | undefined;

  opacity?: number | undefined;

  pathSamples?: number | undefined;

  radialSegments?: number | undefined;

  seed?: number | undefined;

  texture?: string | undefined;

  textureMode?: "stretch" | "tile" | "distanceRepeat" | undefined;

  textureRepeatDistance?: number | undefined;

  segments?: number;

}

type WaveFxRetainedVolumeOptions = Omit<FxRetainedVolumeDefinition, "id">;

type WaveFxSpriteDependency = WaveSpriteAsset | WaveSpriteAnimationAsset;

declare class WaveFxSystemAsset {

  constructor(definition: FxSystemDefinition, spriteDependencies?: readonly WaveFxSpriteDependency[]);

  readonly definition: Readonly<FxSystemDefinition>;

  get id(): string;

  spriteDependencies(): readonly WaveFxSpriteDependency[];

  toBundle(): AuthoredDefinitionBundle;

  toDefinition(): AssetDefinition<"data">;

  toJSON(): Readonly<FxSystemDefinition>;

}

type WaveFxWithParametricPath = typeof baseWaveFx & WaveFxParametricPathFacade;

type WaveGaussianSplatCameraLimitsMode = "fromAsset" | "ignore";

interface WaveGaussianSplatClippingBoxConfig {

  readonly max: WaveGaussianSplatVector3Config;

  readonly min: WaveGaussianSplatVector3Config;

}

interface WaveGaussianSplatCullingConfig {

  readonly clippingBox?: WaveGaussianSplatClippingBoxConfig | null;

  readonly opacity?: WaveGaussianSplatRangeConfig | null;

  readonly opacitySaturate?: boolean;

  readonly opacityScale?: number;

  readonly size?: WaveGaussianSplatRangeConfig | null;

}

type WaveGaussianSplatGpuTexturePreference = boolean | "auto";

declare class WaveGaussianSplatLoaderConfigBuilder {

  constructor(_asset: string);

  cameraLimits(mode: WaveGaussianSplatCameraLimitsMode): this;

  configure(options: WaveGaussianSplatSerializableLoadOptions): this;

  define(): WaveGaussianSplatLoaderDeclaration;

  flipY(enabled?: boolean): this;

  forIblShadows(enabled?: boolean): this;

  format(sourceFormat: WaveGaussianSplatSourceFormat): this;

  ignoreCameraLimits(): this;

  keepEditableData(enabled?: boolean): this;

  keepInRam(enabled?: boolean): this;

  preferGpuTextures(enabled?: boolean): this;

  readAsSpz4(): this;

  readCameraLimitsFromAsset(): this;

  useSpzLibrary(spzLibraryUrl?: string): this;

}

interface WaveGaussianSplatLoaderDeclaration {

  readonly asset: string;

  readonly options: WaveGaussianSplatSerializableLoadOptions;

  readonly type: "gaussianSplat";

}

interface WaveGaussianSplatLoadOptions {

  readonly alias?: string;

  readonly cameraLimits?: WaveGaussianSplatCameraLimitsMode;

  readonly deflateURL?: string;

  readonly disableAutoCameraLimits?: boolean;

  readonly editable?: boolean;

  readonly fflate?: unknown;

  readonly flipY?: boolean;

  readonly gaussianSplattingMesh?: unknown;

  readonly keepInRam?: boolean;

  readonly needsRotationScaleTextures?: boolean;

  readonly sourceFormat?: WaveGaussianSplatSourceFormat;

  readonly spzLibraryUrl?: string | null;

  readonly useSogTextures?: WaveGaussianSplatGpuTexturePreference;

}

interface WaveGaussianSplatLODConfig {

  readonly cullDistance?: number;

  readonly farSphericalHarmonics?: WaveGaussianSplatSphericalHarmonicsInput;

  readonly mode?: WaveGaussianSplatLODMode;

  readonly nearSphericalHarmonics?: WaveGaussianSplatSphericalHarmonicsInput;

}

type WaveGaussianSplatLODInput = WaveGaussianSplatLODMode | WaveGaussianSplatLODConfig | false;

type WaveGaussianSplatLODMode = (typeof WAVE_GAUSSIAN_SPLAT_LOD_MODES)[number];

type WaveGaussianSplatPickingMode = (typeof WAVE_GAUSSIAN_SPLAT_PICKING_MODES)[number];

type WaveGaussianSplatQualityMode = (typeof WAVE_GAUSSIAN_SPLAT_QUALITY_MODES)[number];

interface WaveGaussianSplatRangeConfig {

  readonly max: number;

  readonly min: number;

}

type WaveGaussianSplatRenderMode = (typeof WAVE_GAUSSIAN_SPLAT_RENDER_MODES)[number];

interface WaveGaussianSplatRuntimeCapabilities {

  readonly adaptiveLOD: boolean;

  readonly boundsPicking: boolean;

  readonly compoundParts: boolean;

  readonly distanceCulling: boolean;

  readonly gpuPicking: boolean;

  readonly iblShadows: boolean;

  readonly iblShadowTexturesAvailable: boolean;

  readonly runtimeCulling: boolean;

  readonly serialization: boolean;

  readonly sphericalHarmonics: boolean;

  readonly triangleSplatting: boolean;

}

interface WaveGaussianSplatRuntimeConfig {

  readonly culling?: WaveGaussianSplatCullingConfig | null;

  readonly lod?: WaveGaussianSplatLODInput;

  readonly picking?: WaveGaussianSplatPickingMode;

  readonly quality?: WaveGaussianSplatQualityMode;

  readonly renderMode?: WaveGaussianSplatRenderMode;

  readonly shadows?: WaveGaussianSplatShadowMode;

  readonly sphericalHarmonics?: WaveGaussianSplatSphericalHarmonicsInput;

}

declare class WaveGaussianSplatRuntimeHandle<THost extends module_visual3DModelGaussianSplat = module_visual3DModelGaussianSplat> {

  constructor(_host: THost, initialConfig: WaveGaussianSplatRuntimeConfig | null);

  apply(): THost;

  capabilities(): WaveGaussianSplatRuntimeCapabilities | null;

  culling(config: WaveGaussianSplatCullingConfig | null): this;

  info(): WaveGaussianSplatRuntimeInfo | null;

  lod(lod?: WaveGaussianSplatLODInput): this;

  picking(mode: WaveGaussianSplatPickingMode): this;

  quality(mode: WaveGaussianSplatQualityMode): this;

  renderMode(mode: WaveGaussianSplatRenderMode): this;

  shadows(mode: WaveGaussianSplatShadowMode): this;

  sphericalHarmonics(mode: WaveGaussianSplatSphericalHarmonicsInput): this;

}

interface WaveGaussianSplatRuntimeInfo {

  readonly authoredConfig: WaveGaussianSplatRuntimeConfig | null;

  readonly capabilities: WaveGaussianSplatRuntimeCapabilities;

  readonly compressionFormat?: string;

  readonly editableRawDataAvailable: boolean;

  readonly effectiveConfig: WaveGaussianSplatRuntimeConfig | null;

  readonly maxShDegree: number;

  readonly meshCount: number;

  readonly partCount: number;

  readonly shDegree: number;

  readonly sourceFormat?: string;

  readonly sphericalHarmonicsDataAvailable: boolean;

  readonly splatCount?: number;

  readonly splatSizeRange?: WaveGaussianSplatRangeConfig;

  readonly usesSogTextures: boolean;

}

type WaveGaussianSplatSerializableLoadOptions = Omit<WaveGaussianSplatLoadOptions, "alias" | "fflate" | "gaussianSplattingMesh">;

type WaveGaussianSplatShadowMode = (typeof WAVE_GAUSSIAN_SPLAT_SHADOW_MODES)[number];

type WaveGaussianSplatSourceFormat = (typeof WAVE_GAUSSIAN_SPLAT_SOURCE_FORMATS)[number];

type WaveGaussianSplatSphericalHarmonicsInput = WaveGaussianSplatSphericalHarmonicsMode | number;

type WaveGaussianSplatSphericalHarmonicsMode = (typeof WAVE_GAUSSIAN_SPLAT_SH_MODES)[number];

type WaveGaussianSplatVector3Config = Readonly<SerializableVector3>;

interface WaveGeometryAssetBacking {

  readonly bakeRef?: string | null;

  readonly mode: WaveGeometryAssetMode;

  readonly recipeKind?: string | null;

  readonly runtimeKind: WaveGeometryAssetRuntimeKind;

  readonly viewStrategy: WaveGeometryAssetViewStrategy;

}

interface WaveGeometryAssetContractOverrides {

  readonly backing?: Partial<WaveGeometryAssetBacking>;

  readonly dependencies?: readonly WaveGeometryAssetDependency[];

  readonly fidelity?: Partial<WaveGeometryAssetFidelity>;

  readonly provenance?: Partial<WaveGeometryAssetProvenance>;

  readonly serializedGeometry?: Readonly<Record<string, unknown>>;

}

interface WaveGeometryAssetDependency {

  readonly kind: WaveGeometryAssetDependencyKind;

  readonly optional?: boolean;

  readonly ref: string;

  readonly role?: string;

}

type WaveGeometryAssetDependencyKind = "input" | "material" | "bake" | "sourceAsset" | "sourceProjectAsset";

interface WaveGeometryAssetFidelity {

  readonly hasMorphTargets: boolean;

  readonly hasSkinningChannels: boolean;

  readonly hasSubMeshes: boolean;

  readonly hasVertexColors: boolean;

  readonly materialBindingCount: number;

  readonly maxSkinInfluences: 0 | 4 | 8;

  readonly morphTargetCount: number;

  readonly partCount: number;

  readonly partNames: readonly string[];

  readonly preserveParts: boolean;

  readonly triangleCount: number;

  readonly vertexChannels: readonly { readonly semantic: WaveVertexAttributeSemantic; readonly components: 1 | 2 | 3 | 4; readonly format: WaveVertexAttributeFormat; readonly interpolation: WaveVertexAttributeInterpolation; }[];

  readonly vertexCount: number;

}

type WaveGeometryAssetMode = "snapshot" | "recipe";

interface WaveGeometryAssetOptions {

  readonly contract?: WaveGeometryAssetContractOverrides;

  readonly materialAssetId?: string;

  readonly materialAssetIds?: readonly string[];

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly preserveParts?: boolean;

  readonly rebuildNormals?: boolean;

  readonly updatable?: boolean;

}

interface WaveGeometryAssetProvenance {

  readonly coordinateSpace?: WaveGeometryCoordinateSpace;

  readonly creationMethod?: string | null;

  readonly generatedMeshType?: string | null;

  readonly sourceAssetName?: string | null;

  readonly sourcePath?: string | null;

  readonly sourceProjectAssetId?: string | null;

  readonly sourceTag?: string | null;

}

type WaveGeometryAssetRuntimeKind = "singleMesh" | "multiPartSnapshot";

type WaveGeometryAssetViewStrategy = "serializedWaveGeometry" | "reconstructFromModelAsset";

interface WaveGeometryAttractParameters {

  readonly applyMode?: WaveGeometryDeformApplyMode;

  readonly falloff?: number;

  readonly radius?: number;

  readonly strength: number;

  readonly targetPoint: Vector3Like;

  readonly targetPoints?: readonly Vector3Like[];

}

interface WaveGeometryBendParameters {

  readonly angleDeg: number;

  readonly applyMode?: WaveGeometryDeformApplyMode;

  readonly axis: DirectionInput;

  readonly direction: DirectionInput;

  readonly endPos?: number;

  readonly startPos?: number;

}

type WaveGeometryCoordinateSpace = DistanceFieldUnits3D;

interface WaveGeometryDataOptions {

  readonly coordinateSpace?: WaveGeometryCoordinateSpace;

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly pointSetKind?: WaveGeometryPointSetKind;

  readonly shadowCaster?: WaveShadowCasterIntent;

  readonly sourceTag?: string;

  readonly voxelSize?: number;

}

interface WaveGeometryDataSerializable {

  readonly [WAVE_GEOMETRY_DATA_INSTANCE]: true;

  serialize(): Readonly<Record<string, unknown>>;

}

declare class WaveGeometryDeformAnimationBuilder {

  affectsPhysics(): this;

  after(duration: WaveTimeSpan): this;

  after(value: number, unit: WaveTimeUnit): this;

  for(duration: WaveTimeSpan): this;

  for(value: number, unit: WaveTimeUnit): this;

  geometryMutable(): this;

  loop(enabled?: boolean): this;

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  physicsAccurate(): this;

  pingPong(enabled?: boolean): this;

  syncColliderEvery(frames: number): this;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): this;

  withCallbacks(callbacks: TransitionLifecycleCallbacks<WaveGeometryDeformAnimationState>, options?: WaveAuthoredCallbackOptions): this;

  withEasingEffect(ease: WaveEasing): this;

  withProgressCurve(curve: WaveValueCurveInput): this;

  fromAmount(amount: number): this;

  play(): TransitionLifecycleHandle<WaveGeometryDeformAnimationState>;

  preferCpu(): this;

  preferGpu(): this;

  requireCpu(): this;

  requireGpu(): this;

  toAmount(amount: number): this;

  visualOnly(): this;

}

interface WaveGeometryDeformAnimationConfig {

  callbacks?: TransitionLifecycleCallbacks<WaveGeometryDeformAnimationState> | undefined;

  clone?: WaveCallbackClonePolicy | undefined;

  delay?: WaveTimeSpanSpec | undefined;

  duration?: WaveTimeSpanSpec | undefined;

  easingEffect?: WaveEasing | undefined;

  progressCurve?: WaveValueCurveInput | undefined;

  rate?: WaveRateSpec | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  runFor?: WaveTimeSpanSpec | undefined;

  colliderSyncEveryFrames?: number;

  execution?: WaveGeometryDeformExecution;

  forceMergeMesh?: boolean;

  fromAmount?: number;

  loopMode?: WaveLoopMode;

  toAmount?: number;

  truth?: WaveGeometryDeformTruth;

}

interface WaveGeometryDeformAnimationState {

  amount: number;

}

type WaveGeometryDeformApplyMode = "delta" | "accumulate" | "absolute";

type WaveGeometryDeformExecution = "automatic" | "preferCpu" | "preferGpu" | "requireCpu" | "requireGpu";

type WaveGeometryDeformIntent = { readonly verb: "bend"; readonly parameters: WaveGeometryBendParameters; } | { readonly verb: "twist"; readonly parameters: WaveGeometryTwistParameters; } | { readonly verb: "skew"; readonly parameters: WaveGeometrySkewParameters; } | { readonly verb: "taper"; readonly parameters: WaveGeometryTaperParameters; } | { readonly verb: "scaleRegion"; readonly parameters: WaveGeometryScaleRegionParameters; } | { readonly verb: "stretch"; readonly parameters: WaveGeometryStretchParameters; } | { readonly verb: "displace"; readonly parameters: WaveGeometryDisplaceParameters; } | { readonly verb: "attract"; readonly parameters: WaveGeometryAttractParameters; } | { readonly verb: "extrude"; readonly parameters: WaveGeometryExtrudeParameters; } | { readonly verb: "sway"; readonly parameters: WaveGeometrySwayParameters; } | { readonly verb: "flex"; readonly parameters: WaveGeometryFlexParameters; } | { readonly verb: "morphTo"; readonly parameters: WaveGeometryMorphToParameters; }

type WaveGeometryDeformTruth = "visualOnly" | "geometryMutable" | "physicsAccurate";

interface WaveGeometryDisplaceParameters {

  readonly amplitude: number;

  readonly applyMode?: WaveGeometryDeformApplyMode;

  readonly centers?: readonly Vector3Like[];

  readonly direction?: DirectionInput;

  readonly falloff?: "smooth" | "linear" | "sharp" | "gaussian";

  readonly flow?: DirectionInput;

  readonly frequency?: number;

  readonly radius?: number;

  readonly randomizeSeed?: boolean;

  readonly seed?: number;

  readonly turbulence?: boolean;

}

interface WaveGeometryExtrudeParameters {

  readonly applyMode?: WaveGeometryDeformApplyMode;

  readonly axis?: DirectionInput;

  readonly center?: Vector3Like;

  readonly direction?: DirectionInput;

  readonly endPos?: number;

  readonly falloff?: WaveGeometrySurfaceFalloff;

  readonly mode?: "point" | "axis";

  readonly radius?: number;

  readonly startPos?: number;

  readonly strength: number;

}

interface WaveGeometryFlexParameters {

  readonly attenuation?: number;

  readonly direction?: DirectionInput;

  readonly referenceSize?: number;

  readonly rootPosition?: number;

  readonly space?: "model" | "world";

  readonly strength: number;

}

interface WaveGeometryGpuDeformABI {

  readonly bounds: "conservativeCpuEnvelope";

  readonly compositionOrder: readonly [ "canonicalGeometry", "geometryDeform", "instanceTransform", "worldTransform", "worldGeometryDeform" ];

  readonly motionVectors: "deformationUnavailable";

  readonly positionInput: "canonicalModel";

  readonly positionOutput: "posedModel";

  readonly schema: "wave.geometryGpuDeformABI.v1";

  readonly topology: "fixed";

}

type WaveGeometryGpuDeformOperator = { readonly operation: "axialTwist"; readonly parameters: WaveGeometryTwistParameters; } | { readonly operation: "directionalOscillation"; readonly parameters: WaveGeometrySwayParameters; } | { readonly operation: "directionalFlex"; readonly parameters: WaveGeometryFlexParameters; } | { readonly operation: "targetBlend"; readonly parameters: WaveGeometryMorphToParameters; } | { readonly operation: "curlNoiseDisplacement"; readonly parameters: WaveGeometryDisplaceParameters; }

interface WaveGeometryGpuDeformPlan {

  readonly abi: WaveGeometryGpuDeformABI;

  readonly amount: number;

  readonly attenuation: number;

  readonly direction: readonly [number, number, number];

  readonly maximumAmount: number;

  readonly normalRealization: "analytic" | "targetBlend" | "restApproximation";

  readonly operation: WaveGeometryGpuDeformOperator["operation"];

  readonly parameters: readonly [number, number, number];

  readonly referenceAmount: number;

  readonly referenceSize: number;

  readonly schema: "wave.geometryGpuDeformPlan.v1";

  readonly seed: number;

}

interface WaveGeometryIndexRange {

  readonly indexCount: number;

  readonly indexStart: number;

}

declare enum WaveGeometryInfluenceDomain {

  Part = "part",

  Point = "point",

  Triangle = "triangle",

  Vertex = "vertex",

  Voxel = "voxel",

}

interface WaveGeometryInfluenceDominantSource {

  readonly elementIndex: number;

  readonly source: WaveGeometryInfluenceSource | null;

  readonly sourceIndex: number;

  readonly value: number;

}

declare class WaveGeometryInfluenceField {

  static canDeserialize(payload: unknown): payload is WaveGeometryInfluenceSerializedPayload;

  static deserialize(payload: unknown): WaveGeometryInfluenceField;

  static fromDenseBuffer(options: WaveGeometryInfluenceFieldOptions): WaveGeometryInfluenceField;

  static fromGeometryData(geometry: WaveGeometryInfluenceGeometryView, options: WaveGeometryInfluenceFromGeometryOptions): WaveGeometryInfluenceField;

  clone(): WaveGeometryInfluenceField;

  get coordinateSpace(): WaveGeometryCoordinateSpace | undefined;

  copyValueBuffer(target: Float32Array, targetOffset?: number): void;

  get domain(): WaveGeometryInfluenceDomain;

  get elementCount(): number;

  extractSource(source: WaveGeometryInfluenceSourceRef): Float32Array;

  fillSource(source: WaveGeometryInfluenceSourceRef, value: number): void;

  getAffectedElementIndices(options?: WaveGeometryInfluenceMaskOptions): Uint32Array;

  getDominantSource(elementIndex: number): WaveGeometryInfluenceDominantSource;

  getValue(elementIndex: number, source: WaveGeometryInfluenceSourceRef): number;

  getValueBuffer(): Float32Array;

  get metadata(): Readonly<Record<string, unknown>> | undefined;

  get name(): string | undefined;

  normalizeElement(elementIndex: number): void;

  normalizeElements(): void;

  get partRanges(): readonly WaveGeometryInfluencePartRange[];

  resolveSourceIndex(source: WaveGeometryInfluenceSourceRef): number;

  serialize(): WaveGeometryInfluenceSerializedPayload;

  setValue(elementIndex: number, source: WaveGeometryInfluenceSourceRef, value: number): void;

  get sourceCount(): number;

  get sources(): readonly WaveGeometryInfluenceSource[];

  get sourceTag(): string | undefined;

  summarizeParts(options?: WaveGeometryInfluenceMaskOptions): WaveGeometryInfluencePartSummary[];

  summarizeSource(source: WaveGeometryInfluenceSourceRef, threshold?: number): WaveGeometryInfluenceSourceSummary;

  toMask(options?: WaveGeometryInfluenceMaskOptions): Uint8Array;

}

interface WaveGeometryInfluenceFieldOptions {

  readonly coordinateSpace?: WaveGeometryCoordinateSpace;

  readonly domain: WaveGeometryInfluenceDomain;

  readonly elementCount: number;

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly partRanges?: readonly WaveGeometryInfluencePartRange[];

  readonly sources: readonly WaveGeometryInfluenceSource[];

  readonly sourceTag?: string;

  readonly values?: Float32Array | readonly number[];

}

interface WaveGeometryInfluenceFromGeometryOptions {

  readonly domain: WaveGeometryInfluenceDomain;

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly sources: readonly WaveGeometryInfluenceSource[];

  readonly sourceTag?: string;

  readonly values?: Float32Array | readonly number[];

}

interface WaveGeometryInfluenceGeometryView {

  readonly coordinateSpace?: WaveGeometryCoordinateSpace;

  readonly metadata?: Readonly<Record<string, unknown>>;

  partAt?(index: number): Readonly<WaveGeometryPartData> | undefined;

  readonly partCount?: number;

  readonly parts: readonly WaveGeometryPartData[];

  readonly sourceTag?: string;

}

interface WaveGeometryInfluenceMaskOptions {

  readonly source?: WaveGeometryInfluenceSourceRef;

  readonly threshold?: number;

}

interface WaveGeometryInfluencePartRange {

  readonly elementCount: number;

  readonly elementStart: number;

  readonly partIndex: number;

  readonly partName: string;

  readonly sourceRef?: string;

}

interface WaveGeometryInfluencePartSummary {

  readonly affectedElementCount: number;

  readonly average: number;

  readonly elementCount: number;

  readonly elementStart: number;

  readonly max: number;

  readonly partIndex: number;

  readonly partName: string;

  readonly sum: number;

}

interface WaveGeometryInfluenceSerializedPayload {

  readonly coordinateSpace?: WaveGeometryCoordinateSpace;

  readonly domain: WaveGeometryInfluenceDomain;

  readonly elementCount: number;

  readonly kind: typeof WAVE_GEOMETRY_INFLUENCE_FIELD_KIND;

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly partRanges?: readonly WaveGeometryInfluencePartRange[];

  readonly sources: readonly WaveGeometryInfluenceSource[];

  readonly sourceTag?: string;

  readonly values: readonly number[];

  readonly version: typeof WAVE_GEOMETRY_INFLUENCE_FIELD_VERSION;

}

interface WaveGeometryInfluenceSource {

  readonly id: string;

  readonly label?: string;

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly sourceKind?: WaveGeometryInfluenceSourceKind;

  readonly sourceRef?: string;

}

declare enum WaveGeometryInfluenceSourceKind {

  Bone = "bone",

  Brush = "brush",

  Custom = "custom",

  Deform = "deform",

  Selection = "selection",

}

type WaveGeometryInfluenceSourceRef = number | string;

interface WaveGeometryInfluenceSourceSummary {

  readonly affectedElementCount: number;

  readonly average: number;

  readonly max: number;

  readonly maxElementIndex: number;

  readonly source: WaveGeometryInfluenceSource;

  readonly sourceIndex: number;

  readonly sum: number;

}

interface WaveGeometryMorphEntityTarget {

  getComponent(componentName: string): object | undefined;

  readonly id: number;

  readonly name?: string;

}

interface WaveGeometryMorphGeometryDataTarget {

  readonly name?: string;

  toVertexData(options?: WaveGeometryToVertexDataOptions): WaveVertexDataPayload;

}

interface WaveGeometryMorphMeshTarget {

  getIndices(): ArrayLike<number> | null | undefined;

  getVerticesData(kind: string): ArrayLike<number> | null | undefined;

  readonly name?: string;

}

interface WaveGeometryMorphOptions {

  readonly strict?: boolean;

}

type WaveGeometryMorphTarget = WaveGeometryMorphEntityTarget | WaveGeometryMorphMeshTarget | WaveGeometryMorphGeometryDataTarget;

type WaveGeometryMorphTargetInput = unknown | WaveGeometryData;

interface WaveGeometryMorphToParameters {

  readonly factor: number;

  readonly target: WaveGeometryMorphTarget;

}

interface WaveGeometryMotionAnimationState {

  progress: number;

}

interface WaveGeometryPartData {

  readonly materialBindings?: readonly WaveMaterialBinding[];

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly name: string;

  readonly pointSet?: Float32Array;

  readonly regionTable?: WaveGeometryRegionTable;

  readonly sourceRef?: string;

  readonly subMeshes?: readonly WaveSubMeshRange[];

  readonly transform?: unknown | null;

  readonly vertexData?: WaveVertexDataPayload;

  readonly voxels?: readonly WaveGeometryVoxelData[];

  readonly voxelSize?: number;

}

interface WaveGeometryPathOptions {

  readonly allowVertexPositions?: boolean;

  readonly closed?: boolean;

  readonly partIndex?: number;

}

type WaveGeometryPointSetKind = "curve" | "pointSet";

type WaveGeometryRegionalFalloff = "hard" | "linear" | "smooth" | "sharp";

interface WaveGeometryRegionRecord {

  readonly id: string;

  readonly ranges: readonly WaveGeometryIndexRange[];

}

interface WaveGeometryRegionTable {

  readonly coverage: "complete" | "sparse";

  readonly indexCount: number;

  readonly overlap: "disallow" | "allow";

  readonly regions: readonly WaveGeometryRegionRecord[];

  readonly revision: string | number;

  readonly topologyRevision: WaveGeometryTopologyRevision;

}

interface WaveGeometryScaleRegionParameters {

  readonly anchor?: "min" | "center" | "max";

  readonly applyMode?: WaveGeometryDeformApplyMode;

  readonly endPos?: number;

  readonly falloff?: WaveGeometryRegionalFalloff;

  readonly regionAxis: DirectionInput;

  readonly scaleAxis: DirectionInput;

  readonly scaleFactor: number;

  readonly startPos?: number;

}

interface WaveGeometrySkewParameters {

  readonly angleDeg: number;

  readonly applyMode?: WaveGeometryDeformApplyMode;

  readonly axis: DirectionInput;

  readonly direction: DirectionInput;

  readonly endPos?: number;

  readonly startPos?: number;

}

interface WaveGeometryStretchParameters {

  readonly anchor?: "min" | "center" | "max";

  readonly applyMode?: WaveGeometryDeformApplyMode;

  readonly axis: DirectionInput;

  readonly endPos?: number;

  readonly factor: number;

  readonly falloff?: WaveGeometryRegionalFalloff;

  readonly startPos?: number;

}

type WaveGeometrySurfaceFalloff = "linear" | "smooth" | "sharp" | "flat" | "gaussian";

interface WaveGeometrySurfaceHandle<TMaterialView> {

  readonly id: WaveModelSurfaceId;

  material(): TMaterialView;

  readonly meshId: WaveModelMeshId;

}

interface WaveGeometrySwayParameters {

  readonly attenuation?: number;

  readonly direction?: DirectionInput;

  readonly referenceSize?: number;

  readonly strength: number;

}

interface WaveGeometryTaperParameters {

  readonly applyMode?: WaveGeometryDeformApplyMode;

  readonly axis: DirectionInput;

  readonly endPos?: number;

  readonly endScale?: number;

  readonly startPos?: number;

  readonly startScale?: number;

}

type WaveGeometryTopologyRevision = string;

interface WaveGeometryToVertexDataOptions {

  readonly rebuildNormals?: boolean;

}

interface WaveGeometryTwistParameters {

  readonly applyMode?: WaveGeometryDeformApplyMode;

  readonly axis: DirectionInput;

  readonly endPos?: number;

  readonly phaseOffsetDeg?: number;

  readonly startPos?: number;

  readonly totalDegrees: number;

}

interface WaveGeometryVoxelData {

  readonly color: number;

  readonly position: Vector3Like;

}

interface WaveGpuCollisionProxyDataSourceBinding {

  readonly channelId: string;

  readonly entityRefs: readonly WaveEntityIdentityRef[];

  readonly kind: "collisionProxies";

  readonly margin: number;

}

interface WaveGpuCollisionProxySourceOptions {

  readonly margin?: number;

}

interface WaveGpuContactEventSchema {

  readonly fields: typeof WAVE_GPU_CONTACT_EVENT_FIELDS;

  readonly schema: typeof WAVE_GPU_CONTACT_EVENT_SCHEMA;

}

type WaveGpuDataSourceBinding = WaveGpuTerrainSurfaceDataSourceBinding | WaveGpuRangeFieldDataSourceBinding | WaveGpuEntitySpatialDataSourceBinding | WaveGpuCollisionProxyDataSourceBinding | WaveGpuSkinnedSurfaceAnchorsDataSourceBinding | WaveGpuSkinnedSurfacePoseDataSourceBinding | WaveGpuRelativeCoverageDataSourceBinding;

declare class WaveGpuDataSourceBindingBuilder<TTerminal> {

  constructor(initial: WaveGpuDataSourceBindingPlan | null, _commit: (plan: WaveGpuDataSourceBindingPlan) => TTerminal);

  apply(): TTerminal;

  collisionProxies(channelId: string, entities: readonly WaveEntityIdentityInput[], options?: WaveGpuCollisionProxySourceOptions): this;

  entitySpatialState(channelId: string, entity: WaveEntityIdentityInput, options?: WaveGpuEntitySpatialSourceOptions): this;

  relativeCoverage(channelId: string, coverage: WaveRelativeCoveragePlan): this;

  remove(channelId: string): this;

  skinnedSurfaceAnchors(channelId: string, entity: WaveEntityIdentityInput, options?: WaveGpuSkinnedSurfaceAnchorsSourceOptions): this;

  skinnedSurfacePose(channelId: string, entity: WaveEntityIdentityInput, options?: WaveGpuSkinnedSurfacePoseSourceOptions): this;

  terrainSurface(channelId: string, options: WaveGpuTerrainSurfaceSourceOptions): this;

  waveRange(channelId: string, range: string | WaveNamedRangeLike, options: WaveGpuRangeFieldSourceOptions): this;

  withCollisionProxies(entities: readonly WaveEntityIdentityInput[], options?: WaveGpuCollisionProxySourceOptions): this;

  withEntitySpatialState(entity: WaveEntityIdentityInput, options?: WaveGpuEntitySpatialSourceOptions): this;

  withRelativeCoverage(coverage: WaveRelativeCoveragePlan): this;

}

interface WaveGpuDataSourceBindingDiagnostic {

  readonly activeSampleCount?: number;

  readonly channelId: string;

  readonly coverageFrame?: Readonly<WaveRelativeCoverageFrame>;

  readonly kind: WaveGpuDataSourceBinding["kind"];

  readonly lastError?: string;

  readonly sampleCount?: number;

  readonly skippedFrameCount: number;

  readonly status: "waitingForModel" | "waitingForSource" | "waitingForChange" | "ready" | "failed";

  readonly writeCount: number;

}

interface WaveGpuDataSourceBindingPlan {

  readonly bindings: readonly WaveGpuDataSourceBinding[];

  readonly schema: typeof WAVE_GPU_DATA_SOURCE_BINDING_PLAN_SCHEMA;

}

type WaveGpuDataSourceBindingPlanInput = WaveGpuDataSourceBindingPlan | readonly WaveGpuDataSourceBinding[];

interface WaveGpuDataSourceDebugTexel {

  readonly channelId: string;

  readonly values: readonly number[];

  readonly x: number;

  readonly y: number;

}

interface WaveGpuDataSourceDiagnostics {

  readonly bindings: readonly WaveGpuDataSourceBindingDiagnostic[];

  readonly schema: typeof WAVE_GPU_DATA_SOURCE_BINDING_PLAN_SCHEMA;

}

interface WaveGpuDrivenBeautyDrawBindingDiagnostics {

  readonly activeUniformValue: readonly number[] | null;

  readonly expectedValue: readonly number[];

  readonly matchesExpectedValue: boolean | null;

  readonly name: string;

  readonly type: WaveShaderBindingType;

}

interface WaveGpuDrivenBeautyDrawVariantDiagnostics {

  readonly activeBindingUniforms: readonly WaveGpuDrivenBeautyDrawBindingDiagnostics[];

  readonly activeBindingUniformsMatch: boolean | null;

  readonly activeUniformBufferId: number | null;

  readonly activeUniformBufferSynchronizedBeforeDraw: boolean | null;

  readonly bindCount: number;

  readonly colorWriteEnabled: boolean;

  readonly effectId: number | null;

  readonly effectReady: boolean;

  readonly firstBindFrame: number;

  readonly fragmentProgramSignature: string | null;

  readonly fragmentReferencesAuthoredColors: boolean;

  readonly lastBindFrame: number;

  readonly matchesBeautyEffect: boolean;

  readonly meshId: number;

  readonly meshName: string;

  readonly mismatchedActiveBindingUniformNames: readonly string[];

  readonly missingActiveBindingUniformNames: readonly string[];

  readonly missingBeautyBindingUniformNames: readonly string[];

  readonly renderPassId: number;

  readonly renderPassName: string | null;

  readonly targetKind: "screen" | "offscreen";

  readonly targetLabel: string | null;

  readonly vertexProgramSignature: string | null;

}

interface WaveGpuDrivenBeautyMaterialDiagnostics {

  readonly bindCount: number;

  readonly drawVariants: readonly WaveGpuDrivenBeautyDrawVariantDiagnostics[];

  readonly droppedDrawVariantCount: number;

  readonly effectId: number | null;

  readonly effectReady: boolean;

  readonly lastBindFrame: number | null;

  readonly materialId: number;

  readonly materialName: string;

  readonly mismatchedBindingNames: readonly string[];

  readonly nativeBindingsMatch: boolean;

  readonly sampledChannels: readonly WaveGpuDrivenBeautySampledChannelDiagnostics[];

  readonly techniqueSignature: string;

}

interface WaveGpuDrivenBeautySampledChannelDiagnostics {

  readonly channelId: string;

  readonly expectedResourceId: number;

  readonly matchesExpectedResource: boolean;

  readonly retainedResourceId: number | null;

  readonly sampler: string;

}

interface WaveGpuDrivenBindingDiagnostics {

  readonly name: string;

  readonly revision: number;

  readonly type: WaveShaderBindingType;

  readonly value: WaveShaderBindingValueByType[WaveShaderBindingType];

  readonly writeCount: number;

}

interface WaveGpuDrivenBindingHandle<TType extends WaveShaderBindingType = WaveShaderBindingType> {

  diagnostics(): WaveGpuDrivenBindingDiagnostics;

  readonly generation: number;

  readonly isDisposed: boolean;

  readonly name: string;

  readonly revision: number;

  set(value: WaveShaderBindingValueByType[TType]): void;

  readonly type: TType;

}

type WaveGpuDrivenClonePolicy = "shareImmutable" | "resetToSeed" | "producerDelegated" | "forbidden";

type WaveGpuDrivenCollisionPolicy = "none" | "cpuRestGeometry";

type WaveGpuDrivenContextRestorePolicy = "resetToSeed" | "producerRebuild" | "checkpointedReadback" | "notRestorable";

type WaveGpuDrivenDataAccess = "sampled" | "sampledStorage";

type WaveGpuDrivenDataArray = Float32Array | Uint16Array | Uint8Array | Uint8ClampedArray;

type WaveGpuDrivenDataAuthority = "cpuRetained" | "gpuAuthoritative";

type WaveGpuDrivenDataBuffering = "single" | "pingPong";

type WaveGpuDrivenDataChannelCount = 1 | 2 | 4;

interface WaveGpuDrivenDataChannelDiagnostics {

  readonly access: WaveGpuDrivenDataAccess;

  readonly attributedPhysicalByteLength: number;

  readonly authority: WaveGpuDrivenDataAuthority;

  readonly buffering: WaveGpuDrivenDataBuffering;

  readonly checkpointCount: number;

  readonly clonePolicy: WaveGpuDrivenClonePolicy;

  readonly contextRestore: WaveGpuDrivenContextRestorePolicy;

  readonly contextRestoreCount: number;

  readonly contextRestoreStatus: "ready" | "pendingProducer" | "failed";

  readonly flushCount: number;

  readonly id: string;

  readonly lastContextRestoreError?: string;

  readonly lastFlushedRevision: number;

  readonly lastUploadCpuDurationMs: number;

  readonly maxUploadCpuDurationMs: number;

  readonly nativeUploadBytes: number;

  readonly nativeUploadSynchronized: boolean;

  readonly readback: WaveGpuDrivenDataReadback;

  readonly readbackBytes: number;

  readonly readbackCount: number;

  readonly regionWriteCount: number;

  readonly requestedUploadBytes: number;

  readonly revision: number;

  readonly scope: WaveGpuDrivenDataScope;

  readonly sharedReferenceCount: number;

  readonly stagingByteLength: number;

  readonly totalUploadCpuDurationMs: number;

  readonly uniquePhysicalByteLength: number;

  readonly uploadMode: "pending" | "wholeResource" | "wholeResourceCoalesced";

  readonly uploadTimingSampleCount: number;

  readonly writeCount: number;

}

interface WaveGpuDrivenDataChannelHandle {

  readonly access: WaveGpuDrivenDataAccess;

  readonly authority: WaveGpuDrivenDataAuthority;

  readonly buffering: WaveGpuDrivenDataBuffering;

  readonly byteLength: number;

  readonly channels: WaveGpuDrivenDataChannelCount;

  checkpoint(): Promise<void>;

  readonly clonePolicy: WaveGpuDrivenClonePolicy;

  readonly contextRestore: WaveGpuDrivenContextRestorePolicy;

  diagnostics(): WaveGpuDrivenDataChannelDiagnostics;

  readonly generation: number;

  readonly height: number;

  readonly id: string;

  readonly isDisposed: boolean;

  readonly isReadableByAuthor: boolean;

  readonly isWritableByAuthor: boolean;

  readonly physicalByteLength: number;

  read(): Promise<WaveGpuDrivenDataArray>;

  readonly readback: WaveGpuDrivenDataReadback;

  readonly revision: number;

  readonly scope: WaveGpuDrivenDataScope;

  readonly valueType: WaveGpuDrivenDataValueType;

  readonly width: number;

  write(data: WaveGpuDrivenDataArray): void;

  writeRegion(region: WaveGpuDrivenDataWriteRegion): void;

}

type WaveGpuDrivenDataReadback = "disabled" | "explicit";

type WaveGpuDrivenDataSampling = "nearest" | "bilinear";

type WaveGpuDrivenDataScope = "definitionShared" | "instancePrivate";

type WaveGpuDrivenDataValueType = "float32" | "float16" | "uint8";

type WaveGpuDrivenDataWrap = "clamp" | "repeat" | "mirror";

interface WaveGpuDrivenDataWriteRegion {

  readonly data: WaveGpuDrivenDataArray;

  readonly height: number;

  readonly width: number;

  readonly x: number;

  readonly y: number;

}

interface WaveGpuDrivenFlexibleResponseOptions {

  readonly inputs?: Readonly<Record<string, WaveGpuDrivenResponseValueBinding>>;

  readonly previousState?: Readonly<Record<string, WaveGpuDrivenResponseValueBinding>>;

  readonly skinnedSurface?: WaveGpuDrivenSkinnedSurfaceResponseSource;

  readonly stateChannelId: string;

  readonly updatePolicy?: "everyFrame" | "manual";

  readonly workgroupSize?: readonly [number, number];

}

interface WaveGpuDrivenFrameDiagnostics {

  readonly frameId: number;

  readonly framesPerSecond: number;

  readonly frameTimeMs: number;

  readonly mainPassGpuDurationMs: number | null;

  readonly mainPassGpuTimingSampleCount: number;

  readonly mainPassMaxGpuDurationMs: number | null;

  readonly mainPassTotalGpuDurationMs: number | null;

  readonly modelMaterialBindCount: number;

  readonly sceneDrawCalls: number;

}

type WaveGpuDrivenGeometryRole = "rest" | "logical";

interface WaveGpuDrivenManualBounds {

  readonly maximum: readonly [number, number, number];

  readonly minimum: readonly [number, number, number];

  readonly mode: "manual";

  readonly parts?: readonly WaveGpuDrivenManualPartBounds[];

}

interface WaveGpuDrivenManualPartBounds {

  readonly maximum: readonly [number, number, number];

  readonly minimum: readonly [number, number, number];

  readonly partIndex: number;

}

interface WaveGpuDrivenModelDefinition {

  readonly bounds: WaveGpuDrivenManualBounds;

  readonly collision: WaveGpuDrivenCollisionPolicy;

  readonly coordinateSpace: "model";

  readonly dataChannels: readonly WaveGpuDrivenSampledDataChannelDefinition[];

  readonly definitionSignature: string;

  readonly geometryRole: WaveGpuDrivenGeometryRole;

  readonly id: string;

  readonly picking: WaveGpuDrivenPickingPolicy;

  readonly requiresWebGpu: true;

  readonly revision: number;

  readonly schema: typeof WAVE_GPU_DRIVEN_MODEL_SCHEMA;

  readonly stateKernels: readonly WaveRetainedComputeKernelDefinition[];

  readonly technique: WaveGpuDrivenTechniqueContract;

}

interface WaveGpuDrivenModelProjectionFacts {

  readonly boundsPolicy: "manualConservative";

  readonly collision: WaveGpuDrivenCollisionPolicy;

  readonly customVertexStreamCount: number;

  readonly definitionSignature: string;

  readonly explicitReadbackChannelCount: number;

  readonly finalVertexAuthority: "gpuVertexStage";

  readonly geometryPartCount: number;

  readonly geometryRole: WaveGpuDrivenGeometryRole;

  readonly instanceDataChannelCount: number;

  readonly physicalDataByteCapacity: number;

  readonly picking: WaveGpuDrivenPickingPolicy;

  readonly requiresWebGpu: true;

  readonly retainedDataByteCapacity: number;

  readonly retainedDataChannelCount: number;

  readonly schema: "wave.gpuDrivenProjection.v2";

  readonly sharedDataChannelCount: number;

  readonly stateKernelCount: number;

  readonly techniqueVariants: readonly ["beauty", "cameraDepth", "shadowCaster"];

  readonly topologySignature: string;

  readonly warmup: "actualGeometryAndPrivateGraphRequired";

}

interface WaveGpuDrivenModelReadinessDiagnostics {

  readonly beauty: WaveGpuDrivenReadinessStageDiagnostics;

  readonly cameraDepth: WaveGpuDrivenReadinessStageDiagnostics;

  readonly computeCompilation: WaveGpuDrivenReadinessStageDiagnostics;

  readonly computeExecution: WaveGpuDrivenReadinessStageDiagnostics;

  readonly contextRestoration: WaveGpuDrivenReadinessStageDiagnostics;

  readonly generation: number;

  readonly graphGeneration: number;

  readonly shadow: WaveGpuDrivenReadinessStageDiagnostics;

}

interface WaveGpuDrivenModelRuntimeDiagnostics {

  readonly attributedPhysicalGpuBytes: number;

  readonly beautyBindings: readonly WaveGpuDrivenBindingDiagnostics[];

  readonly beautyMaterials: readonly WaveGpuDrivenBeautyMaterialDiagnostics[];

  readonly channels: readonly WaveGpuDrivenDataChannelDiagnostics[];

  readonly cpuStagingBytes: number;

  readonly disposed: boolean;

  readonly frame: WaveGpuDrivenFrameDiagnostics;

  readonly generation: number;

  readonly indexCount: number;

  readonly materialCount: number;

  readonly meshCount: number;

  readonly modelId: string;

  readonly readiness: WaveGpuDrivenModelReadinessDiagnostics;

  readonly seedSignature: string;

  readonly stateKernels: readonly WaveGpuDrivenStateKernelDiagnostics[];

  readonly topologySignature: string;

  readonly uniquePhysicalGpuBytes: number;

  readonly vertexCount: number;

}

type WaveGpuDrivenPickingPolicy = "disabled" | "cpuRestGeometry";

interface WaveGpuDrivenReadinessStageDiagnostics {

  readonly error?: string;

  readonly status: WaveGpuDrivenReadinessStatus;

}

type WaveGpuDrivenReadinessStatus = "pending" | "ready" | "failed" | "unproven" | "notRequired";

type WaveGpuDrivenResponseValueBinding = WaveValueRef | WaveValueProgram;

interface WaveGpuDrivenRuntimeModelInput {

  readonly definition: WaveGpuDrivenModelDefinition;

  readonly geometry: WaveGeometryData;

  readonly kind: typeof WAVE_GPU_DRIVEN_MODEL_INPUT_KIND;

  readonly projection: WaveGpuDrivenModelProjectionFacts;

  readonly topologySignature: string;

}

interface WaveGpuDrivenSampledDataChannelDefinition {

  readonly access: WaveGpuDrivenDataAccess;

  readonly authority: WaveGpuDrivenDataAuthority;

  readonly buffering: WaveGpuDrivenDataBuffering;

  readonly channels: WaveGpuDrivenDataChannelCount;

  readonly clonePolicy: WaveGpuDrivenClonePolicy;

  readonly contextRestore: WaveGpuDrivenContextRestorePolicy;

  readonly height: number;

  readonly id: string;

  readonly readback: WaveGpuDrivenDataReadback;

  readonly sampler: string;

  readonly sampling: WaveGpuDrivenDataSampling;

  readonly scope: WaveGpuDrivenDataScope;

  readonly valueType: WaveGpuDrivenDataValueType;

  readonly width: number;

  readonly wrapU: WaveGpuDrivenDataWrap;

  readonly wrapV: WaveGpuDrivenDataWrap;

}

interface WaveGpuDrivenSemanticKernelInput {

  readonly id: string;

  readonly locals?: readonly WaveGpuDrivenSemanticKernelLocal[];

  readonly outputChannelId: string;

  readonly sampledChannels?: readonly { readonly textureId: string; readonly channelId: string; }[];

  readonly updatePolicy?: "everyFrame" | "manual";

  readonly value: WaveValueExpr;

  readonly workgroupSize?: readonly [number, number];

}

type WaveGpuDrivenSemanticKernelLocal = WaveValueProgramLocal;

type WaveGpuDrivenShaderModule = WaveWGSLModuleInput | WaveWGSLModule;

interface WaveGpuDrivenSkinnedSurfaceResponseSource {

  readonly anchorsChannelId: string;

  readonly poseChannelId: string;

  readonly source?: string;

}

interface WaveGpuDrivenStateKernelDiagnostics {

  readonly compilation: WaveGpuDrivenReadinessStageDiagnostics;

  readonly dispatchCount: number;

  readonly dispatchTimingSampleCount: number;

  readonly execution: WaveGpuDrivenReadinessStageDiagnostics;

  readonly failedDispatches: number;

  readonly gpuTimingSampleCount: number;

  readonly id: string;

  readonly lastDispatchCpuDurationMs: number;

  readonly lastError?: string;

  readonly lastGpuDurationMs: number | null;

  readonly maxDispatchCpuDurationMs: number;

  readonly maxGpuDurationMs: number | null;

  readonly pendingManualDispatches: number;

  readonly totalDispatchCpuDurationMs: number;

  readonly totalGpuDurationMs: number | null;

  readonly updatePolicy: "everyFrame" | "manual";

}

interface WaveGpuDrivenStateKernelHandle {

  diagnostics(): WaveGpuDrivenStateKernelDiagnostics;

  dispatch(count?: number): void;

  readonly id: string;

  readonly isDisposed: boolean;

  readonly updatePolicy: "everyFrame" | "manual";

}

interface WaveGpuDrivenTechniqueContract {

  readonly beauty: WaveShaderMaterialDescriptor;

  readonly beautyMaterialSlot: "default";

  readonly cameraDepth: "deriveBeautyVertex";

  readonly moduleGraphIdentity: string;

  readonly modules: readonly WaveWGSLModule[];

  readonly motionVectors: "disabled";

  readonly schema: typeof WAVE_GPU_DRIVEN_TECHNIQUE_SCHEMA;

  readonly shadowCaster: "deriveBeautyVertex";

  readonly techniqueSignature: string;

  readonly worldPositionVariable: "worldPos";

}

interface WaveGpuEntitySpatialDataSourceBinding {

  readonly channelId: string;

  readonly entityRef: WaveEntityIdentityRef;

  readonly fields: readonly WaveGpuEntitySpatialField[];

  readonly kind: "entitySpatialState";

}

type WaveGpuEntitySpatialField = "position" | "previousPosition" | "rotation" | "scale" | "linearVelocity" | "angularVelocity";

interface WaveGpuEntitySpatialSourceOptions {

  readonly fields?: readonly WaveGpuEntitySpatialField[];

}

interface WaveGpuEventStreamRef {

  readonly eventSchema: typeof WAVE_GPU_CONTACT_EVENT.schema;

  readonly producerId: string;

  readonly schema: typeof WAVE_GPU_EVENT_STREAM_REF_SCHEMA;

  readonly streamId: string;

}

interface WaveGpuFeatureAuthorityDescriptor {

  readonly authority: WaveGpuNetworkAuthorityDeclaration;

  readonly featureId: string;

  readonly gameplayRelevance: "cosmetic" | "gameplay-relevant";

}

type WaveGpuNetworkAuthorityDeclaration = { readonly policy: "cosmetic-only"; } | { readonly policy: "server-validated-outcome"; readonly validationProtocolId: string; readonly implementation: "declared" | "implemented"; } | { readonly policy: "unsupported-authoritative-multiplayer"; }

declare class WaveGpuNetworkAuthorityRegistry {

  constructor(runtimeMode: WaveGpuNetworkRuntimeMode);

  assertAdmitted(descriptor: WaveGpuFeatureAuthorityDescriptor): void;

  descriptor(featureId: string): WaveGpuFeatureAuthorityDescriptor | null;

  diagnostics(): WaveGpuNetworkAuthorityRegistryDiagnostics;

  register(descriptor: WaveGpuFeatureAuthorityDescriptor): void;

  readonly runtimeMode: WaveGpuNetworkRuntimeMode;

}

interface WaveGpuNetworkAuthorityRegistryDiagnostics {

  readonly admittedFeatures: number;

  readonly registeredFeatures: number;

  readonly rejectedAdmissions: number;

  readonly runtimeMode: WaveGpuNetworkRuntimeMode;

}

type WaveGpuNetworkRuntimeMode = "local" | "authoritative-host" | "authoritative-client";

interface WaveGpuRangeFieldDataSourceBinding {

  readonly channelId: string;

  readonly coverage: WaveRelativeCoveragePlan;

  readonly heightSource: WaveGpuRangeFieldHeightSource;

  readonly inset: number;

  readonly insideValue: number;

  readonly kind: "waveRangeField";

  readonly minimumUpdateIntervalSeconds: number;

  readonly outsideValue: number;

  readonly rangeName: string;

}

type WaveGpuRangeFieldHeightSource = { readonly kind: "constant"; readonly y: number; } | { readonly kind: "terrainSurface"; readonly offset: number; }

interface WaveGpuRangeFieldSourceOptions {

  readonly coverage: WaveRelativeCoveragePlan;

  readonly heightSource?: WaveGpuRangeFieldHeightSource;

  readonly inset?: number;

  readonly insideValue?: number;

  readonly minimumUpdateIntervalSeconds?: number;

  readonly outsideValue?: number;

}

interface WaveGpuRelativeCoverageDataSourceBinding {

  readonly channelId: string;

  readonly coverage: WaveRelativeCoveragePlan;

  readonly kind: "relativeCoverage";

}

interface WaveGpuSkinnedSurfaceAnchorsDataSourceBinding {

  readonly channelId: string;

  readonly entityRef: WaveEntityIdentityRef;

  readonly kind: "skinnedSurfaceAnchors";

  readonly positionJitter: number;

  readonly seed: number;

  readonly sourceMeshName: string | null;

  readonly surfaceOffset: number;

  readonly surfaceSelection: WaveModelSurfaceSelectionDefinition | null;

}

interface WaveGpuSkinnedSurfaceAnchorsSourceOptions {

  readonly positionJitter?: number;

  readonly seed?: number;

  readonly sourceMeshName?: string;

  readonly surfaceOffset?: number;

  readonly surfaceSelection?: WaveModelSurfaceSelectionDefinition;

}

interface WaveGpuSkinnedSurfacePoseDataSourceBinding {

  readonly channelId: string;

  readonly entityRef: WaveEntityIdentityRef;

  readonly kind: "skinnedSurfacePose";

  readonly sourceMeshName: string | null;

}

interface WaveGpuSkinnedSurfacePoseSourceOptions {

  readonly sourceMeshName?: string;

}

type WaveGpuSurfaceSourceOptions = WaveTerrainGpuSurfaceSourceOptions | WaveSkinnedGpuSurfaceSourceOptions;

interface WaveGpuTerrainSurfaceAvailabilityBinding {

  readonly excludedRangeNames: readonly string[];

  readonly falloff: number;

}

interface WaveGpuTerrainSurfaceAvailabilityOptions {

  readonly falloff?: number;

  readonly notInRange: readonly (string | WaveNamedRangeLike)[];

}

interface WaveGpuTerrainSurfaceDataSourceBinding {

  readonly channelId: string;

  readonly coverage: WaveRelativeCoveragePlan;

  readonly availability: WaveGpuTerrainSurfaceAvailabilityBinding | null;

  readonly heightOffset: number;

  readonly kind: "terrainSurface";

  readonly maximumElevation: number | null;

  readonly minimumElevation: number | null;

  readonly minimumUpdateIntervalSeconds: number;

}

interface WaveGpuTerrainSurfaceSourceOptions {

  readonly availability?: WaveGpuTerrainSurfaceAvailabilityOptions;

  readonly coverage: WaveRelativeCoveragePlan;

  readonly heightOffset?: number;

  readonly maximumElevation?: number;

  readonly minimumElevation?: number;

  readonly minimumUpdateIntervalSeconds?: number;

}

type WaveGraphicsBackendCapability = "frameGraph" | "canonicalWGSL" | "compute" | "storageResources" | "sogGpuTextures";

type WaveGraphicsBackendKind = "webgpu";

interface WaveGraphicsBackendRuntime {

  readonly adapterId: string;

  readonly capabilities: readonly WaveGraphicsBackendCapability[];

  readonly kind: WaveGraphicsBackendRuntimeKind;

  readonly limits: { readonly maxTextureSize: number; readonly maxBufferSize: number; readonly maxStorageBufferBindingSize: number; readonly maxStorageBuffersPerShaderStage: number; }

}

type WaveGraphicsBackendRuntimeKind = WaveGraphicsBackendKind | "headless";

type WaveGraphShadowFilteringQuality = "high" | "medium" | "low";

interface WaveGrid3DSourceOptions {

  readonly gridInfo: GridLayout;

  readonly surfaceY?: number;

}

interface WaveGrid3DWorldLayerOptions {

  readonly activeRadius?: number | WaveWorldRadius;

  readonly endless?: boolean;

  readonly id?: string;

  readonly physics?: WorldStreamingPhysicsConfig;

  readonly queryPriority?: number;

  readonly required?: boolean;

  readonly workers?: WaveWorldWorkerPolicy;

}

interface WaveGridPinPoint extends WavePointSource {

  resolveGridVertexIndex(rows: number, cols: number): number;

}

interface WaveGroupSceneBridge {

  readonly engine: unknown;

}

type WaveHardSurfaceAssemblyMode = "preserveChildren" | "mergeCompatible" | "coordinatedGroups";

interface WaveHardSurfaceAssemblyNode {

  readonly id: string;

  readonly kind: "assembly";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly children: readonly string[];

  readonly mode: WaveHardSurfaceAssemblyMode;

}

interface WaveHardSurfaceBevelSpec {

  readonly generatedFaceRegion: WaveHardSurfaceGeneratedBevelRegionPolicy;

  readonly segments: number;

  readonly selection: WaveHardSurfaceEdgeSelection;

  readonly width: number;

}

interface WaveHardSurfaceBooleanNode {

  readonly id: string;

  readonly kind: "boolean";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly children: readonly string[];

  readonly operation: WaveHardSurfaceBooleanOperation;

}

type WaveHardSurfaceBooleanOperation = "union" | "subtract" | "intersection";

interface WaveHardSurfaceBounds {

  readonly max: Readonly<Vector3Like>;

  readonly min: Readonly<Vector3Like>;

}

interface WaveHardSurfaceCompilerIdentity {

  readonly compilerVersion: number;

  readonly finishVersion: number;

  readonly geometryBinaryVersion: number;

  readonly provider: Exclude<WaveHardSurfaceProviderIntent, "auto">;

  readonly providerDependencyHash?: `sha256:${string}`;

  readonly providerImplementationHash?: `sha256:${string}`;

  readonly providerProtocolVersion?: number;

  readonly solidKernelVersion: string;

}

type WaveHardSurfaceEdgeSelection = { readonly kind: "all"; } | { readonly kind: "boundary"; } | { readonly kind: "minimumDihedralDegrees"; readonly degrees: number; } | { readonly kind: "maximumDihedralDegrees"; readonly degrees: number; } | { readonly kind: "regionBoundary"; } | { readonly kind: "explicitRegionPairs"; readonly pairs: readonly (readonly [string, string])[]; }

interface WaveHardSurfaceExternalNode {

  readonly id: string;

  readonly kind: "external";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly bounds: WaveHardSurfaceBounds;

  readonly estimatedTriangles: number;

  readonly estimatedVertices: number;

  readonly operator: string;

  readonly parameters: Readonly<Record<string, SerializableDataValue>>;

  readonly provider: "articraftMechanical";

}

interface WaveHardSurfaceFinishSpec {

  readonly bevel?: WaveHardSurfaceBevelSpec;

  readonly normals: WaveHardSurfaceNormalSpec;

  readonly tangents: "generate" | "preserve" | "discard";

}

type WaveHardSurfaceGeneratedBevelRegionPolicy = "inheritWhenUnambiguous" | "separateBoundaryRegion" | { readonly regionId: string; }

interface WaveHardSurfaceGeometryRecipe {

  readonly defaultRegionId: string;

  readonly finish: WaveHardSurfaceFinishSpec;

  readonly kind: "hardSurface";

  readonly metadata?: SerializableDataValue;

  readonly nodes: readonly WaveHardSurfaceNode[];

  readonly optimize: WaveHardSurfaceOptimizeSpec;

  readonly provider: WaveHardSurfaceProviderIntent;

  readonly rootNodeId: string;

  readonly version: 1;

}

interface WaveHardSurfaceLatheNode {

  readonly id: string;

  readonly kind: "lathe";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly along?: SerializedDirectionInput;

  readonly recipe: Extract<WavePrimitiveGeometryRecipe, { readonly shape: "lathe"; }>;

}

interface WaveHardSurfaceLinearPattern {

  readonly along: SerializedDirectionInput;

  readonly count: number;

  readonly kind: "linear";

  readonly spacing?: number;

  readonly spacingCurve?: WaveValueCurveSpec;

}

interface WaveHardSurfaceLoftNode {

  readonly id: string;

  readonly kind: "loft";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly recipe: WaveLoftGeometryRecipe;

}

interface WaveHardSurfaceMirrorNode {

  readonly id: string;

  readonly kind: "mirror";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly normal: SerializedDirectionInput;

  readonly offset: number;

  readonly source: string;

}

type WaveHardSurfaceNode = WaveHardSurfacePrimitiveNode | WaveHardSurfaceProfileExtrusionNode | WaveHardSurfacePrismNode | WaveHardSurfaceLatheNode | WaveHardSurfaceSweepNode | WaveHardSurfaceLoftNode | WaveHardSurfaceTransformNode | WaveHardSurfaceMirrorNode | WaveHardSurfaceBooleanNode | WaveHardSurfacePatternNode | WaveHardSurfaceAssemblyNode | WaveHardSurfaceExternalNode;

interface WaveHardSurfaceNodeRef {

  readonly nodeId: string;

}

interface WaveHardSurfaceNormalSpec {

  readonly creaseDegrees: number;

  readonly mode: "weighted" | "areaWeighted" | "angleWeighted";

}

interface WaveHardSurfaceOptimizeSpec {

  readonly merge: "none" | "byCompatibleMaterial";

  readonly preserveSurfaceRegions: boolean;

}

interface WaveHardSurfacePathPattern {

  readonly coordinateSpace: WaveGeometryCoordinateSpace;

  readonly count?: number;

  readonly facing: "path" | "fixed";

  readonly kind: "path";

  readonly path: readonly Readonly<Vector3Like>[];

  readonly pathClosed: boolean;

  readonly spacing?: number;

}

interface WaveHardSurfacePatternNode {

  readonly id: string;

  readonly kind: "pattern";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly pattern: WaveHardSurfacePatternSpec;

  readonly source: string;

}

type WaveHardSurfacePatternSpec = WaveHardSurfaceLinearPattern | WaveHardSurfaceRadialPattern | WaveHardSurfacePathPattern;

interface WaveHardSurfacePrimitiveNode {

  readonly id: string;

  readonly kind: "primitive";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly along?: SerializedDirectionInput;

  readonly edgeTreatment?: WaveHardSurfaceBevelSpec;

  readonly recipe: WavePrimitiveGeometryRecipe;

}

interface WaveHardSurfacePrismCornerSpec {

  readonly bottomLeft?: WaveHardSurfacePrismTreatmentSpec;

  readonly bottomRight?: WaveHardSurfacePrismTreatmentSpec;

  readonly topLeft?: WaveHardSurfacePrismTreatmentSpec;

  readonly topRight?: WaveHardSurfacePrismTreatmentSpec;

}

interface WaveHardSurfacePrismNode {

  readonly id: string;

  readonly kind: "prism";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly back?: WaveHardSurfacePrismTreatmentSpec;

  readonly corners: WaveHardSurfacePrismCornerSpec;

  readonly front?: WaveHardSurfacePrismTreatmentSpec;

  readonly holes?: readonly WaveProfile2DRecipe[];

  readonly regions: WaveHardSurfacePrismRegionSpec;

  readonly size: Readonly<Vector3Like>;

}

interface WaveHardSurfacePrismRegionSpec {

  readonly back: string;

  readonly edges: string;

  readonly front: string;

  readonly holes: string;

  readonly sides: string;

}

interface WaveHardSurfacePrismTreatmentSpec {

  readonly kind: "chamfer" | "fillet";

  readonly segments: 1 | 2;

  readonly width: number;

}

interface WaveHardSurfaceProfileExtrusionNode {

  readonly id: string;

  readonly kind: "profileExtrusion";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly along: SerializedDirectionInput;

  readonly center: Readonly<Vector3Like>;

  readonly depth: number;

  readonly holes?: readonly WaveProfile2DRecipe[];

  readonly profile: WaveProfile2DRecipe;

}

type WaveHardSurfaceProviderIntent = "native" | "articraftMechanical" | "auto";

interface WaveHardSurfaceRadialPattern {

  readonly angleRadians: number;

  readonly around: SerializedDirectionInput;

  readonly count: number;

  readonly kind: "radial";

  readonly radius: number;

}

interface WaveHardSurfaceSemanticOptions {

  readonly regionId?: string;

  readonly role?: string;

}

interface WaveHardSurfaceSweepNode {

  readonly id: string;

  readonly kind: "sweep";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly recipe: WaveLoftGeometryRecipe;

}

interface WaveHardSurfaceTransformNode {

  readonly id: string;

  readonly kind: "transform";

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly source: string;

  readonly transform: WaveHardSurfaceTransformSnapshot;

}

interface WaveHardSurfaceTransformSnapshot {

  readonly position: Readonly<Vector3Like>;

  readonly rotation: { readonly x: number; readonly y: number; readonly z: number; readonly w: number; }

  readonly scale: Readonly<Vector3Like>;

}

interface WaveHardwareBuilder {

  connect(): Promise<WaveHardwareConnection | null>;

  onConnected(callback: (connection: WaveHardwareConnection) => void): this;

  onData(callback: (packet: WaveHardwareDataPacket) => void): this;

  onDisconnected(callback: (device: WaveHardwareDeviceInfo) => void): this;

  onError(callback: (error: WaveHardwareConnectionError) => void): this;

  onJson(callback: (packet: WaveHardwareJsonPacket) => void): this;

  onLine(callback: (packet: WaveHardwareLinePacket) => void): this;

  withBluetoothServices(services: readonly string[], optionalServices?: readonly string[]): this;

  withDataFormat(format: WaveHardwareDataFormat): this;

  withFilter(filter: WaveHardwareDeviceFilter): this;

  withLabel(label: string): this;

  withName(name: string): this;

  withNamePrefix(prefix: string): this;

  withSerialBaudRate(baudRate: number): this;

  withTransport(transport: WaveHardwareTransport): this;

  withTransports(transports: readonly WaveHardwareTransport[]): this;

  withUsbIds(vendorId: number, productId?: number): this;

}

interface WaveHardwareConnection {

  readonly device: WaveHardwareDeviceInfo;

  disconnect(): void;

  dispose(): void;

  isConnected(): boolean;

  onData(callback: (packet: WaveHardwareDataPacket) => void): WaveHardwareSubscription;

  onDisconnected(callback: (device: WaveHardwareDeviceInfo) => void): WaveHardwareSubscription;

  onError(callback: (error: WaveHardwareConnectionError) => void): WaveHardwareSubscription;

  onJson(callback: (packet: WaveHardwareJsonPacket) => void): WaveHardwareSubscription;

  onLine(callback: (packet: WaveHardwareLinePacket) => void): WaveHardwareSubscription;

  send(data: ArrayBuffer | Uint8Array | string | WaveHardwareJsonValue): Promise<void>;

  sendJson(data: WaveHardwareJsonValue): Promise<void>;

  sendLine(line: string): Promise<void>;

  readonly state: WaveHardwareConnectionState;

}

interface WaveHardwareConnectionError {

  device?: WaveHardwareDeviceInfo;

  error: unknown;

  message: string;

}

declare enum WaveHardwareConnectionState {

  Connected = "connected",

  Connecting = "connecting",

  Disconnected = "disconnected",

  Error = "error",

}

declare enum WaveHardwareDataFormat {

  Bytes = "bytes",

  Json = "json",

  Text = "text",

}

interface WaveHardwareDataPacket<TData = unknown> {

  data: TData;

  device: WaveHardwareDeviceInfo;

  format: WaveHardwareDataFormat;

  timestamp: number;

}

interface WaveHardwareDeviceFilter {

  name?: string;

  namePrefix?: string;

  productId?: number;

  services?: readonly string[];

  transport?: WaveHardwareTransport;

  url?: string;

  vendorId?: number;

}

interface WaveHardwareDeviceInfo {

  id: string;

  name?: string;

  transport: WaveHardwareTransport;

}

interface WaveHardwareJsonPacket {

  data: WaveHardwareJsonValue;

  device: WaveHardwareDeviceInfo;

  raw: string;

  timestamp: number;

}

type WaveHardwareJsonPrimitive = string | number | boolean | null;

type WaveHardwareJsonValue = WaveHardwareJsonPrimitive | readonly WaveHardwareJsonValue[] | { readonly [key: string]: WaveHardwareJsonValue; }

interface WaveHardwareLinePacket {

  device: WaveHardwareDeviceInfo;

  line: string;

  timestamp: number;

}

interface WaveHardwareSubscription {

  off(): void;

}

declare enum WaveHardwareTransport {

  BluetoothLowEnergy = "bluetooth-low-energy",

  Hid = "hid",

  Network = "network",

  Serial = "serial",

  Usb = "usb",

}

interface WaveHeightfield {

  readonly defaultLayerId?: string;

  readonly domain: WaveHeightfieldDomain;

  readonly kind: typeof WAVE_HEIGHTFIELD_KIND;

  readonly layers: readonly WaveHeightfieldLayer[];

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly version: typeof WAVE_HEIGHTFIELD_VERSION;

}

interface WaveHeightfieldDomain {

  readonly columns: number;

  readonly coordinateSpace?: WaveGeometryCoordinateSpace;

  readonly rows: number;

  readonly worldDepth: number;

  readonly worldWidth: number;

  readonly zDirection?: WaveHeightfieldZDirection;

}

interface WaveHeightfieldLayer {

  readonly data: Float32Array;

  readonly id: string;

  readonly maxValue: number;

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly minValue: number;

  readonly physicsRole?: WaveHeightfieldPhysicsRole;

  readonly role?: WaveHeightfieldLayerRole;

  readonly surfaceDirection?: WaveHeightfieldSurfaceDirection;

}

type WaveHeightfieldLayerRole = "surface" | "topSurface" | "bottomSurface" | "collision" | "control" | "mask" | "flow";

type WaveHeightfieldPhysicsRole = "heightfield" | "none";

type WaveHeightfieldSurfaceDirection = "up" | "down";

type WaveHeightfieldZDirection = "negativeToPositive" | "positiveToNegative";

type WaveHeightSurfaceInput = WaveHeightSurfaceProvider | ((x: number, z: number) => number | null | undefined);

interface WaveHeightSurfaceProvider {

  heightAt(x: number, z: number): number | null | undefined;

}

type WaveHotReloadIntent = "program-main-replay" | "program-rebuild-request" | "shared-editor-request" | "developer-reload" | "networked-reload";

interface WaveImpactFractureDiagnostics {

  readonly attemptedPieceCounts: readonly number[];

  readonly elapsedMilliseconds: number;

  readonly executedMode: WaveFractureMode | null;

  readonly physicalClusterCount: number;

  readonly requestedMode: WaveFractureMode;

  readonly visualComponentCount: number;

  readonly workerUsed: boolean;

}

interface WaveImpactFractureEnableOptions {

  readonly failureExtent?: WaveImpactFractureFailureExtent | undefined;

  readonly minimumImpactEnergy?: number | undefined;

  readonly mode?: WaveFractureMode | undefined;

  readonly pieceCountHint?: number | undefined;

  readonly scope?: WaveImpactFractureScope | undefined;

  readonly seed?: number | undefined;

  readonly cooldownFixedSteps?: number;

  readonly minimumImpactMomentum?: number;

  readonly minimumImpactSpeed?: number;

}

type WaveImpactFractureFailureExtent = "impactDriven" | "complete";

interface WaveImpactFractureObservation {

  readonly fixedDeltaSeconds?: number;

  readonly fixedStep?: number;

  readonly impactEnergy?: number | null;

  readonly impactMomentum?: number | null;

  readonly impactMomentumWorld?: PhysicsVec3 | null;

  readonly impactSpeed?: number;

  readonly impulse?: number;

  readonly integrationState?: PhysicsImpactIntegrationState;

  readonly kinematics?: PhysicsImpactKinematics;

  readonly normal?: PhysicsVec3 | null;

  readonly normalWorld?: PhysicsVec3;

  readonly point?: PhysicsVec3 | null;

  readonly pointWorld?: PhysicsVec3;

  readonly reducedMass?: number | null;

  readonly relativeImpactSpeed?: number;

  readonly selfPartId?: string;

  readonly selfPartInfo?: unknown;

  readonly selfSurfaceId?: string;

  readonly solverImpulse?: number;

  readonly tangentialSpeed?: number;

}

interface WaveImpactFractureOptions {

  readonly failureExtent?: WaveImpactFractureFailureExtent;

  readonly force?: boolean;

  readonly minimumImpactEnergy?: number;

  readonly mode?: WaveFractureMode;

  readonly pieceCountHint?: number;

  readonly scope?: WaveImpactFractureScope;

  readonly seed?: number;

}

interface WaveImpactFractureResult {

  readonly diagnostics: WaveImpactFractureDiagnostics;

  readonly error?: string;

  readonly fragments: readonly unknown[];

  readonly reason?: WaveFractureFailureReason;

  readonly sourceEntityId: number;

  readonly state: Extract<WaveFractureHandleState, "committed" | "rejected" | "cancelled">;

  readonly success: boolean;

}

type WaveImpactFractureScope = "hitPart" | "body" | "wholeModel";

type WaveInstalledSystemKey = keyof typeof ENGINE_SYSTEM_CONTRACTS;

interface WaveInstanceSource {

  readonly ref: AssetRef<"model">;

}

interface WaveInstrumentAliasOptions {

  as?: string;

  label?: string;

  prepare?: boolean;

}

interface WaveInstrumentConfig {

  attackMs?: number;

  defaultBusName?: string;

  fxChain?: WaveInstrumentFxNode[];

  gain?: number;

  harmonicReinforcement?: { minMidiNote?: number; maxMidiNote?: number; maxBlend?: number; fundamentalGain?: number; secondHarmonicGain?: number; thirdHarmonicGain?: number; lowPassFrequency?: number; attackMs?: number; decayMs?: number; releaseMs?: number; }

  id: string;

  kind: WaveInstrumentKind;

  label?: string;

  maxPolyphony?: number;

  midiNoteRange?: { min: number; max: number; }

  playbackRateToneCompensation?: { lowRateHighShelfGainDb?: number; lowRateHighShelfFrequency?: number; lowRatePresenceGainDb?: number; lowRatePresenceFrequency?: number; lowRatePresenceQ?: number; }

  playbackRateVolumeCompensation?: { exponent?: number; minGain?: number; maxGain?: number; lowRateExponent?: number; lowRateMinGain?: number; lowRateMaxGain?: number; highRateExponent?: number; highRateMinGain?: number; highRateMaxGain?: number; }

  releaseMs?: number;

  zones: WaveInstrumentZone[];

}

interface WaveInstrumentFxChorus {

  depth?: number;

  mix?: number;

  rate?: number;

  type: "chorus";

}

interface WaveInstrumentFxCompressor {

  attack?: number;

  knee?: number;

  ratio?: number;

  release?: number;

  threshold?: number;

  type: "compressor";

}

interface WaveInstrumentFxConvolver {

  compressWet?: boolean;

  highPassCutoff?: number;

  impulseResponsePath?: string;

  lowPassCutoff?: number;

  mix?: number;

  preDelay?: number;

  syntheticIrDuration?: number;

  type: "convolver";

}

interface WaveInstrumentFxDelay {

  delayTime?: number;

  feedback?: number;

  feedbackLowPass?: number;

  mix?: number;

  type: "delay";

}

interface WaveInstrumentFxDistortion {

  drive?: number;

  mix?: number;

  tone?: number;

  type: "distortion";

}

interface WaveInstrumentFxEQ {

  filterType: BiquadFilterType;

  frequency: number;

  gain?: number;

  q?: number;

  type: "eq";

}

type WaveInstrumentFxNode = WaveInstrumentFxSimpleRoom | WaveInstrumentFxConvolver | WaveInstrumentFxEQ | WaveInstrumentFxDelay | WaveInstrumentFxChorus | WaveInstrumentFxTremolo | WaveInstrumentFxCompressor | WaveInstrumentFxDistortion | WaveInstrumentFxPanner;

interface WaveInstrumentFxPanner {

  pan?: number;

  type: "panner";

}

interface WaveInstrumentFxSimpleRoom {

  mix?: number;

  type: "simpleRoom";

}

interface WaveInstrumentFxTremolo {

  depth?: number;

  rate?: number;

  type: "tremolo";

}

type WaveInstrumentKind = "sampleZones";

declare enum WaveInstrumentPreset {

}

interface WaveInstrumentZone {

  loudnessCompensationDb?: number;

  maxMidiNote: number;

  maxVelocity?: number;

  minMidiNote: number;

  minVelocity?: number;

  pan?: number;

  rootMidiNote: number;

  samplePath: string;

  tuneCents?: number;

  volumeDb?: number;

}

interface WaveJointAnchorPoint {

  name: string;

  position?: Vector3Like;

  target?: waveProp | wave3DObject;

}

declare class WaveJointAssembly<T extends waveProp = waveProp> extends WaveGroup<T> {

  constructor(name: string, controller?: NoInfer<T> | wave3DObject, scene?: WaveGroupSceneBridge);

  get anchorPoints(): readonly WaveJointAnchorPoint[];

  captureRestState(): this;

  clearJoints(): this;

  connect(parent: T, child: T, config?: WaveJointConfig): string | null;

  createJointId(prefix?: string): string;

  dispose(): void;

  getAnchorPoint(name: string): WaveJointAnchorPoint | undefined;

  getJoint(id: string): WaveJointRecord<T> | undefined;

  hasJoint(id: string): boolean;

  joint(parent: T, child: T): WaveJointBuilder<string | null>;

  get jointCount(): number;

  get joints(): readonly WaveJointRecord<T>[];

  rebuild(): this;

  registerExistingJoint(id: string, type: WaveJointType, parent: T, child: T, config?: WaveJointConfig, projectionStatus?: "created" | "pending"): this;

  remove(member: T): boolean;

  removeAnchorPoint(name: string): boolean;

  removeJoint(id: string): boolean;

  resetToRest(): this;

  servo(id: string, axis?: ConstraintAxis): WaveJointServoBuilder;

  setAnchorPoint(name: string, anchor: Vector3Like | waveProp | wave3DObject): this;

  setRebuildHandler(handler: (() => void) | null): this;

}

declare class WaveJointBuilder<TResult, TConfig extends WaveJointConfig = WaveJointConfig> {

  constructor(applyConfig: (config: TConfig) => TResult, initialConfig?: TConfig);

  apply(): TResult;

  around(axis: DirectionInput): this;

  asBallAndSocket(): this;

  asDistance(): this;

  asHinge(): this;

  asLock(): this;

  asPrismatic(): this;

  asSixDoF(): this;

  asSlider(): this;

  atLocalPivots(ownLocalPivot: Vector3Like, targetLocalPivot: Vector3Like): this;

  atOwnLocalPivot(pivot: Vector3Like): this;

  atOwnWorldPivot(pivot: WavePointInput): this;

  atSharedWorldPivot(pivot: WavePointInput): this;

  atTargetLocalPivot(pivot: Vector3Like): this;

  atTargetWorldPivot(pivot: WavePointInput): this;

  atWorldPivots(ownWorldPivot: WavePointInput, targetWorldPivot: WavePointInput): this;

  build(): TResult;

  named(id: string): this;

  withAngleRangeDegrees(minAngle: number, maxAngle: number): this;

  withAngleRangeRadians(minAngle: number, maxAngle: number): this;

  withAngularLimits(axis: ConstraintAxis, minLimit: number, maxLimit: number): this;

  withAxes(axisA: DirectionInput, axisB: DirectionInput): this;

  withCollisions(enabled?: boolean): this;

  withDistanceRange(minDistance: number, maxDistance: number): this;

  withFixedDistance(distance: number): this;

  withHingePositionMotor(targetDegrees: number, maxForce?: number, spring?: SpringConfig): this;

  withLinearLimits(axis: ConstraintAxis, minLimit: number, maxLimit: number): this;

  withMotor(axis: ConstraintAxis, mode: MotorMode, target: number, maxForce?: number, spring?: SpringConfig): this;

  withOptions(options: Partial<TConfig>): this;

  withPerpAxes(perpAxisA: DirectionInput, perpAxisB: DirectionInput): this;

  withReturnMotor(maxForce?: number, targetDegrees?: number, spring?: SpringConfig): this;

}

interface WaveJointConfig {

  axis?: DirectionInput | undefined;

  axisA?: DirectionInput | undefined;

  axisB?: DirectionInput | undefined;

  enableCollisions?: boolean | undefined;

  id?: string | undefined;

  limits?: AxisLimit[] | undefined;

  maxAngle?: number | undefined;

  maxDistance?: number | undefined;

  minAngle?: number | undefined;

  minDistance?: number | undefined;

  ownLocalPivot?: any;

  ownWorldPivot?: any;

  perpAxisA?: DirectionInput | undefined;

  perpAxisB?: DirectionInput | undefined;

  sharedWorldPivot?: any;

  spring?: SpringConfig | undefined;

  targetLocalPivot?: any;

  targetWorldPivot?: any;

  motors?: WaveJointMotorInput[];

  type?: WaveJointType;

}

type WaveJointMotorInput = RigidBodyJointMotorInput;

interface WaveJointRecord<T extends waveProp = waveProp> {

  child: T;

  config: WaveJointConfig;

  id: string;

  parent: T;

  projectionStatus: "created" | "pending";

  type: WaveJointType;

}

declare class WaveJointServo {

  constructor(_owner: cmp_physicsBody, jointId: string, _motorState: MotorConfig, _onInvalidated?: ((servo: WaveJointServo) => void) | undefined);

  get axis(): ConstraintAxis;

  get isRemoved(): boolean;

  get isSuspended(): boolean;

  readonly jointId: string;

  remove(): boolean;

  resume(): this;

  suspend(options?: WaveJointServoSuspendOptions): this;

  get target(): number;

  toward(target: number): this;

}

declare class WaveJointServoBuilder {

  constructor(_owner: cmp_physicsBody, _jointId: string, defaultAxis: ConstraintAxis, initial?: MotorConfig, _resolveRetainedServo?: ((axis: ConstraintAxis) => WaveJointServo | undefined) | undefined, _retainServo?: ((axis: ConstraintAxis, servo: WaveJointServo) => void) | undefined, _releaseServo?: ((axis: ConstraintAxis, servo: WaveJointServo) => void) | undefined);

  apply(): WaveJointServo;

  asAccelerationSpring(): this;

  asForceSpring(): this;

  matchVelocity(target: number): this;

  onAxis(axis: ConstraintAxis): this;

  towardAngleDegrees(target: number): this;

  towardAngleRadians(target: number): this;

  towardPosition(target: number): this;

  withMaximumEffort(maximum: number): this;

  withResponse(stiffness: number, damping: number): this;

}

interface WaveJointServoSuspendOptions {

  readonly damping?: number;

  readonly maximumEffort?: number;

}

type WaveJointType = RigidBodyJointType | "prismatic" | "slider";

interface WaveKeyframedValueCurve extends WaveValueCurve {

  easeInTo(input: number): WaveValueCurveValueSetter<this>;

  easeOutTo(input: number): WaveValueCurveValueSetter<this>;

  holdTo(input: number): WaveValueCurveValueSetter<this>;

  lineTo(input: number): WaveValueCurveValueSetter<this>;

  smoothStepTo(input: number): WaveValueCurveValueSetter<this>;

  withInitialValue(value: number): this;

}

interface WaveKeyframedValueCurveSpec {

  readonly base: number;

  readonly kind: "keyframes";

  readonly stops: readonly WaveKeyframedValueCurveStopSpec[];

}

interface WaveKeyframedValueCurveStopSpec {

  readonly input: number;

  readonly interpolation: WaveValueCurveInterpolation;

  readonly value: number;

}

declare class WaveKinematicConstantForceBuilder<TController = unknown> {

  constructor(_executor: WaveKinematicFrameExecutor<TController>, _name: string, frame: WaveTransformFrameSpace, frameOf?: TransformReferenceLike, parentFrameDepth?: number);

  clear(): this;

  done(): TController;

  inFrameOf(target: TransformReferenceLike): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  get name(): string;

  setDirection(direction: DirectionInput, strength?: number): this;

  setEnabled(enabled: boolean): this;

  setForce(force: Vector3Like): this;

  setMagnitude(strength: number): this;

}

declare class WaveKinematicConstantTorqueBuilder<TController = unknown> {

  constructor(_executor: WaveKinematicFrameExecutor<TController>, _name: string, frame: WaveTransformFrameSpace, frameOf?: TransformReferenceLike, parentFrameDepth?: number);

  clear(): this;

  done(): TController;

  inFrameOf(target: TransformReferenceLike): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  get name(): string;

  setAxis(axis: DirectionInput, strength?: number): this;

  setEnabled(enabled: boolean): this;

  setMagnitude(strength: number): this;

  setTorque(torque: Vector3Like): this;

}

interface WaveKinematicFrameExecutor<TController> {

  addExternalAngularVelocity(delta: Vector3Like): TController;

  addExternalVelocity(delta: Vector3Like): TController;

  applyAngularImpulse(impulse: Vector3Like): TController;

  applyForce(force: Vector3Like): TController;

  applyImpulse(impulse: Vector3Like): TController;

  applyTorque(torque: Vector3Like): TController;

  clearConstantForce(name: string): TController;

  clearConstantTorque(name: string): TController;

  readonly controller: TController;

  moveWithCollisions(displacement: Vector3Like): TController;

  setConstantForce(config: KinematicConstantForceConfig): TController;

  setConstantTorque(config: KinematicConstantTorqueConfig): TController;

  setExternalAngularVelocity(velocity: Vector3Like): TController;

  setExternalVelocity(velocity: Vector3Like): TController;

  readonly transform: TransformDirectionAccessor;

}

declare class WaveKinematicFrameScope<TController = unknown> {

  inFrameOf(target: TransformReferenceLike): WaveKinematicFrameScope<TController>;

  inLocalFrame(): WaveKinematicFrameScope<TController>;

  inParentFrame(depth?: number): WaveKinematicFrameScope<TController>;

  inWorldFrame(): WaveKinematicFrameScope<TController>;

  constructor(_executor: WaveKinematicFrameExecutor<TController>, frame: WaveTransformFrameSpace, frameOf?: TransformReferenceLike, parentFrameDepth?: number);

  addExternalAngularVelocity(delta: Vector3Like | DirectionInput): TController;

  addExternalAngularVelocity(x: number, y: number, z: number): TController;

  addExternalAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): TController;

  addExternalVelocity(delta: Vector3Like | DirectionInput): TController;

  addExternalVelocity(x: number, y: number, z: number): TController;

  addExternalVelocity(direction: Vector3Like | DirectionInput, speed: number): TController;

  applyAngularImpulse(impulse: Vector3Like | DirectionInput): TController;

  applyAngularImpulse(axis: Vector3Like | DirectionInput, strength: number): TController;

  applyForce(force: Vector3Like | DirectionInput): TController;

  applyForce(direction: Vector3Like | DirectionInput, strength: number): TController;

  applyImpulse(impulse: Vector3Like | DirectionInput): TController;

  applyImpulse(direction: Vector3Like | DirectionInput, strength: number): TController;

  applyTorque(torque: Vector3Like | DirectionInput): TController;

  applyTorque(x: number, y: number, z: number): TController;

  applyTorque(axis: Vector3Like | DirectionInput, strength: number): TController;

  done(): TController;

  editConstantForce(name: string): WaveKinematicConstantForceBuilder<TController>;

  editConstantTorque(name: string): WaveKinematicConstantTorqueBuilder<TController>;

  moveWithCollisions(displacement: Vector3Like | DirectionInput): TController;

  moveWithCollisions(x: number, y: number, z: number): TController;

  moveWithCollisions(direction: Vector3Like | DirectionInput, distance: number): TController;

  get root(): TController;

  setConstantForce(name: string, config: KinematicConstantForceConfig): TController;

  setConstantForce(name: string, force: Vector3Like | DirectionInput, options?: KinematicConstantInfluenceOptions): TController;

  setConstantForce(name: string, direction: Vector3Like | DirectionInput, strength: number, options?: KinematicConstantInfluenceOptions): TController;

  setConstantTorque(name: string, config: KinematicConstantTorqueConfig): TController;

  setConstantTorque(name: string, torque: Vector3Like | DirectionInput, options?: KinematicConstantInfluenceOptions): TController;

  setConstantTorque(name: string, axis: Vector3Like | DirectionInput, strength: number, options?: KinematicConstantInfluenceOptions): TController;

  setExternalAngularVelocity(velocity: Vector3Like | DirectionInput): TController;

  setExternalAngularVelocity(x: number, y: number, z: number): TController;

  setExternalAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): TController;

  setExternalVelocity(velocity: Vector3Like | DirectionInput): TController;

  setExternalVelocity(x: number, y: number, z: number): TController;

  setExternalVelocity(direction: Vector3Like | DirectionInput, speed: number): TController;

}

type WaveLatheConfig = WaveLathePrimitiveRecipe;

interface WaveLathePrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "lathe";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly arcFraction?: number;

  readonly cap?: WaveCapMode;

  readonly profile: readonly WavePrimitiveProfilePoint[];

  readonly radialSegments?: number;

  readonly radius?: number;

}

interface WaveLayoutBodyBox {

  height: number;

  width: number;

  x: number;

  y: number;

}

interface WaveLightingZoneConfig {

  internalLightEntityIds?: readonly number[];

  name?: string;

  policy?: WaveLightingZonePolicy;

  shape?: WaveRangeShape;

  sourceEntityId?: number | null;

}

interface WaveLightingZoneExternalPolicy {

  directIntensity?: number;

  enabled?: boolean;

  environmentIntensity?: number;

  maxLights?: number | null;

}

interface WaveLightingZoneInternalPolicy {

  ambientColor?: ColorInput;

  ambientIntensity?: number;

  maxLights?: number | null;

}

type WaveLightingZoneMembershipMode = "centerInside" | "intersects" | "fullyInside";

interface WaveLightingZonePolicy {

  affectContents?: boolean;

  enabled?: boolean;

  external?: WaveLightingZoneExternalPolicy;

  internal?: WaveLightingZoneInternalPolicy;

  membership?: WaveLightingZoneMembershipMode;

  priority?: number;

}

interface WaveLightingZoneResolvedExternalPolicy {

  directIntensity: number;

  enabled: boolean;

  environmentIntensity: number;

  maxLights: number | null;

}

interface WaveLightingZoneResolvedInternalPolicy {

  ambientColor: ColorInput;

  ambientIntensity: number;

  maxLights: number | null;

}

interface WaveLightingZoneResolvedPolicy {

  affectContents: boolean;

  enabled: boolean;

  external: WaveLightingZoneResolvedExternalPolicy;

  internal: WaveLightingZoneResolvedInternalPolicy;

  membership: WaveLightingZoneMembershipMode;

  priority: number;

}

interface WaveLinearValueCurveSpec {

  readonly kind: "linear";

  readonly multiplier: number;

  readonly offset: number;

}

interface WaveLLMBackend {

  readonly config: LLMConfig;

  readonly endpointId: string;

  readonly kind: "externalLLM";

  readonly provider: WaveLLMProvider;

}

interface WaveLLMBackendOptions {

  allowClientDirect?: boolean;

  apiKey?: string;

  clientAccessMode?: LLMAccessMode;

  endpointId?: string;

  endpointUrl?: string;

  maxPayloadBytes?: number;

  retries?: number;

  timeoutMs?: number;

}

type WaveLLMProvider = (typeof WAVE_LLM_PROVIDERS)[number];

interface WaveLocalNeuralTTSConfig {

  device?: WaveLocalNeuralTTSDevice;

  dtype?: WaveLocalNeuralTTSDType;

  enabled?: boolean;

  modelId?: string;

  speed?: number;

  voice?: string;

}

type WaveLocalNeuralTTSDevice = "wasm" | "webgpu" | "cpu" | null;

type WaveLocalNeuralTTSDownloadConsent = "prompt" | "granted" | "notRequired";

type WaveLocalNeuralTTSDType = "fp32" | "fp16" | "q8" | "q4" | "q4f16";

type WaveLocalNeuralTTSOptions = WaveLocalNeuralTTSPreloadConfig & WaveTTSBackendVoiceSlotOptions & { fallbackProviders?: readonly WaveStandardTTSProvider[]; speechConcurrency?: WaveTTSSpeechConcurrency; speechFx?: WaveSpeechFxConfig | null; elevenLabs?: ElevenLabsTTSConfig | null; browserSpeechSynthesis?: BrowserSpeechSynthesisTTSConfig | null; }

interface WaveLocalNeuralTTSPreloadConfig {

  device?: WaveLocalNeuralTTSDevice | undefined;

  dtype?: WaveLocalNeuralTTSDType | undefined;

  enabled?: boolean | undefined;

  modelId?: string | undefined;

  speed?: number | undefined;

  voice?: string | undefined;

  downloadConsent?: WaveLocalNeuralTTSDownloadConsent;

  id?: string;

  voices?: readonly string[];

  warmupText?: string;

  warmVoices?: boolean;

}

declare class WaveLocator2DBuilder {

  constructor(_entityId: string);

  at(anchor: WaveUIAnchor): this;

  offsetBy(x: number, y: number): this;

  take(): WaveLocator2DRef;

}

interface WaveLocator2DRef {

  readonly anchor: WaveUIAnchor;

  readonly entityId: string;

  readonly kind: "locator2d";

  readonly offset: Readonly<SerializableVector2>;

}

interface WaveLocator3DRef {

  readonly entity: WaveEntityIdentityRef;

  readonly kind: "locator3dRef";

  readonly locator: WaveSerializable3DLocator;

}

declare class WaveLocatorBuilder<TRef extends WaveTransformAccessor = WaveTransformAccessor> {

  alongBy(direction: DirectionInput, distance: number): this;

  inLocalTerms(): this;

  inParentTerms(): this;

  inWorldTerms(): this;

  moveBackward(distance: number): this;

  moveBy(direction: DirectionInput, distance: number): this;

  moveDown(distance: number): this;

  moveForward(distance: number): this;

  moveLeft(distance: number): this;

  moveRight(distance: number): this;

  moveUp(distance: number): this;

  moveX(distance: number): this;

  moveY(distance: number): this;

  moveZ(distance: number): this;

  toVector(space?: WavePointSourceSpace): Vector3;

  toVector3(): Vector3;

  constructor(refObj: TRef, startPos: Vector3, boundsCenterLocal: Vector3, halfExtentsLocal: Vector3, _entityIdentity: WaveEntityIdentityRef, _sceneToken: WaveLocatorSceneToken, _replayFactory?: (() => WaveLocatorBuilder<TRef>) | undefined, frame?: WaveTransformFrameSpace, frameOf?: TransformReferenceLike, parentFrameDepth?: number);

  atBoundsCenter(): this;

  atFaceCenter(direction: SemanticDirection): this;

  atOrigin(): this;

  evaluateCurrentWorldPosition(): Vector3;

  getReferenceTarget(): TRef;

  inFrameOf(target: TransformReferenceLike): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  resolveRetainedFrameOf(identityRef: WaveEntityIdentityRef): TransformReferenceLike;

  take(): WaveLocator3DRef;

}

type WaveLocatorSceneToken = object;

interface WaveLoftGeometryInput {

  readonly cap?: WaveCapMode;

  readonly coordinateSpace?: WaveGeometryCoordinateSpace;

  readonly frame?: WaveProceduralFrameInput | WaveProceduralFrameSpec;

  readonly kind: "loft";

  readonly metadata?: SerializableDataValue;

  readonly path?: readonly Vector3Like[];

  readonly pathClosed?: boolean;

  readonly profileSamples?: number;

  readonly progressions?: WaveSectionProgressionsInput | WaveSectionProgressions;

  readonly sections: readonly (WaveLoftSectionInput | WaveLoftSectionRecipe)[];

  readonly surfaceRegionId?: string;

  readonly uv?: WaveLoftUvOptions;

  readonly version?: 1;

}

interface WaveLoftGeometryRecipe {

  readonly cap: WaveCapMode;

  readonly coordinateSpace: WaveGeometryCoordinateSpace;

  readonly frame: WaveProceduralFrameSpec;

  readonly kind: "loft";

  readonly metadata?: SerializableDataValue;

  readonly path?: readonly Readonly<Vector3Like>[];

  readonly pathClosed: boolean;

  readonly profileSamples: number;

  readonly progressions?: WaveSectionProgressions;

  readonly sections: readonly WaveLoftSectionRecipe[];

  readonly surfaceRegionId?: string;

  readonly uv: WaveLoftUvSpec;

  readonly version: 1;

}

interface WaveLoftSectionInput {

  readonly at?: Vector3Like;

  readonly profile: WaveProfile2DRecipe;

  readonly progress?: number;

  readonly regionId?: string;

  readonly scale?: { readonly x: number; readonly y: number; }

  readonly seamDirection?: DirectionInput;

  readonly twistRadians?: number;

}

interface WaveLoftSectionRecipe {

  readonly at?: Readonly<Vector3Like>;

  readonly profile: WaveProfile2DRecipe;

  readonly progress?: number;

  readonly regionId?: string;

  readonly scale?: { readonly x: number; readonly y: number; }

  readonly seamDirection?: SerializedDirectionInput;

  readonly twistRadians?: number;

}

interface WaveLoftUvOptions {

  readonly along?: "pathDistance" | "normalized";

  readonly alongScale?: number;

  readonly around?: "profileDistance" | "normalized";

  readonly aroundScale?: number;

}

interface WaveLoftUvSpec {

  readonly along: "pathDistance" | "normalized";

  readonly alongScale?: number;

  readonly around: "profileDistance" | "normalized";

  readonly aroundScale?: number;

}

interface WaveLookAtOptions {

  byLocking?: DirectionInput | undefined;

  withTolerance?: number | undefined;

  frame?: WaveTransformFrameSpace;

  frameOf?: TransformReferenceLike;

  parentFrameDepth?: number;

}

type WaveLoopMode = "once" | "loop" | "pingPong";

interface WaveMarkerFollowOptions {

  modelScale?: number;

  worldSize?: number;

}

interface WaveMarkerHandle {

  asMarker(model?: string): WaveMarkerHandle;

  followFxAnchor(target: WaveMarkerTarget, anchor: WaveFxAnchorBinding, options?: WaveMarkerFollowOptions): WaveMarkerHandle;

  followLocalPoint(target: WaveMarkerTarget, name: string, options?: WaveMarkerFollowOptions): WaveMarkerHandle;

  followLocator(builder: WaveLocatorBuilder, options?: WaveMarkerFollowOptions): WaveMarkerHandle;

  followWorldPosition(position: WavePointInput, options?: WaveMarkerFollowOptions): WaveMarkerHandle;

  freezeLocator(): WaveMarkerHandle;

  readonly name: string;

  setModelScale(scale: number): WaveMarkerHandle;

  setName(name: string): WaveMarkerHandle;

  setScaleFromBase(scale?: number): WaveMarkerHandle;

  setWorldSize(size: number): WaveMarkerHandle;

}

type WaveMarkerTarget = cmp_transform | WaveSpatial3DEntity;

interface WaveMaterialBakeIncludeOptions {

  readonly decals?: boolean;

  readonly materialState?: boolean;

  readonly textureMaps?: boolean;

  readonly vertexPaint?: boolean;

}

type WaveMaterialBakeMode = "package" | "flatten";

interface WaveMaterialBakeOptions {

  readonly allowExternalTextureRefs?: boolean;

  readonly format?: WaveMaterialBakeTextureFormat;

  readonly include?: WaveMaterialBakeIncludeOptions;

  readonly mode?: WaveMaterialBakeMode;

  readonly quality?: number;

  readonly resolution?: number | WaveMaterialBakeResolution;

}

interface WaveMaterialBakeResolution {

  readonly height: number;

  readonly width: number;

}

type WaveMaterialBakeTextureFormat = "png" | "webp";

interface WaveMaterialBinding {

  readonly materialIndex: number;

  readonly materialName?: string | null;

  readonly materialRef?: string | null;

}

interface WaveMaterialBrickNode {

  readonly id: string;

  readonly op: "brick";

  readonly valueType: "scalar";

  readonly columns: number;

  readonly coordinates: string;

  readonly mortar: number;

  readonly rows: number;

  readonly softness: number;

  readonly stagger: number;

}

interface WaveMaterialCavityFromHeightNode {

  readonly id: string;

  readonly op: "cavityFromHeight";

  readonly valueType: "scalar";

  readonly height: string;

  readonly radius: number;

  readonly strength: number;

}

interface WaveMaterialCheckerNode {

  readonly id: string;

  readonly op: "checker";

  readonly valueType: "scalar";

  readonly coordinates: string;

  readonly scaleX: number;

  readonly scaleY: number;

}

type WaveMaterialCloneStrategy = "sharePublicAsset" | "cloneRuntimeMaterial" | "rebuildFromSerializableRecipe";

interface WaveMaterialColorAddNode {

  readonly id: string;

  readonly op: "addColor";

  readonly valueType: "color";

  readonly left: string;

  readonly right: string;

}

interface WaveMaterialColorChannelNode {

  readonly id: string;

  readonly op: "colorChannel";

  readonly valueType: "scalar";

  readonly channel: "r" | "g" | "b" | "a" | "luminance";

  readonly color: string;

}

interface WaveMaterialColorConstantNode {

  readonly id: string;

  readonly op: "colorConstant";

  readonly valueType: "color";

  readonly value: WaveMaterialFieldColorValue;

}

interface WaveMaterialColorMixNode {

  readonly id: string;

  readonly op: "mixColor";

  readonly valueType: "color";

  readonly amount: string;

  readonly from: string;

  readonly to: string;

}

interface WaveMaterialColorParameterNode {

  readonly id: string;

  readonly op: "colorParameter";

  readonly valueType: "color";

  readonly defaultValue: WaveMaterialFieldColorValue;

  readonly parameterId: string;

}

interface WaveMaterialColorRampStop {

  readonly color: ColorInputAlpha;

  readonly position: number;

}

interface WaveMaterialColorScaleNode {

  readonly id: string;

  readonly op: "scaleColor";

  readonly valueType: "color";

  readonly color: string;

  readonly scale: string;

}

interface WaveMaterialCoordinateNode {

  readonly id: string;

  readonly op: "coordinate";

  readonly valueType: "vector2" | "vector3" | "normal";

  readonly source: "projection" | "uv" | "objectPosition" | "worldPosition" | "objectNormal" | "worldNormal";

}

interface WaveMaterialCurveNode {

  readonly id: string;

  readonly op: "curve";

  readonly valueType: "scalar";

  readonly curve: WaveValueCurveSpec;

  readonly input: string;

}

type WaveMaterialEditAuthoring = typeof editWaveMaterial;

interface WaveMaterialExternalInputSampleNode {

  readonly id: string;

  readonly op: "externalInputSample";

  readonly valueType: "color" | "scalar";

  readonly channel: "rgba" | "r" | "g" | "b" | "a";

  readonly coordinates: string;

  readonly inputId: string;

}

interface WaveMaterialFbmNode {

  readonly id: string;

  readonly op: "fbm";

  readonly valueType: "scalar";

  readonly coordinates: string;

  readonly gain: number;

  readonly lacunarity: number;

  readonly noise: "value" | "gradient" | "ridged";

  readonly octaves: number;

  readonly scale: number;

  readonly seed: number;

}

interface WaveMaterialGridNode {

  readonly id: string;

  readonly op: "grid";

  readonly valueType: "scalar";

  readonly coordinates: string;

  readonly lineWidth: number;

  readonly scaleX: number;

  readonly scaleY: number;

  readonly softness: number;

}

interface WaveMaterialIncomingBaseColorNode {

  readonly id: string;

  readonly op: "incomingBaseColor";

  readonly valueType: "color";

}

interface WaveMaterialNoiseNode {

  readonly id: string;

  readonly op: "valueNoise" | "gradientNoise" | "cellularNoise" | "ridgedNoise";

  readonly valueType: "scalar";

  readonly coordinates: string;

  readonly scale: number;

  readonly seed: number;

}

interface WaveMaterialNormalBlendNode {

  readonly id: string;

  readonly op: "blendNormals";

  readonly valueType: "normal";

  readonly amount: string;

  readonly base: string;

  readonly detail: string;

}

interface WaveMaterialNormalFromHeightNode {

  readonly id: string;

  readonly op: "normalFromHeight";

  readonly valueType: "normal";

  readonly height: string;

  readonly strength: number;

}

interface WaveMaterialNormalMapNode {

  readonly id: string;

  readonly op: "normalMap";

  readonly valueType: "normal";

  readonly color: string;

  readonly strength: number;

}

interface WaveMaterialPackageDecalSnapshot {

  readonly albedoTexture?: string;

  readonly albedoTint?: string;

  readonly angleFade?: number;

  readonly blendMode?: string;

  readonly emissiveIntensity?: number;

  readonly glowColor?: string;

  readonly height?: number;

  readonly layerMask?: number;

  readonly length?: number;

  readonly mask?: string;

  readonly maskFeather?: number;

  readonly metallicMultiplier?: number;

  readonly name?: string;

  readonly normalBlendMode?: string;

  readonly normalTexture?: string;

  readonly opacity?: number;

  readonly priority?: number;

  readonly roughnessMultiplier?: number;

  readonly uvOffset?: { readonly x: number; readonly y: number; }

  readonly uvRotation?: number;

  readonly width?: number;

}

interface WaveMaterialPackageManifest {

  readonly assetName: string;

  readonly bake: { readonly mode: WaveMaterialBakeMode; readonly textureFormat: WaveMaterialBakeTextureFormat; readonly include: Required<WaveMaterialBakeIncludeOptions>; readonly resolution?: WaveMaterialBakeResolution; }

  readonly createdAt: string;

  readonly decals: readonly WaveMaterialPackageDecalSnapshot[];

  readonly definition: ProjectMaterialAssetDefinition;

  readonly kind: "wave-material-package";

  readonly metadata?: Record<string, unknown>;

  readonly textures: readonly WaveMaterialPackageTextureEntry[];

  readonly version: typeof WAVE_MATERIAL_PACKAGE_VERSION;

  readonly vertexColors: readonly WaveMaterialPackageVertexColorPayload[];

  readonly warnings?: readonly string[];

}

interface WaveMaterialPackageTextureEntry {

  readonly byteLength: number;

  readonly height: number;

  readonly mimeType: string;

  readonly path: string;

  readonly slot: string;

  readonly sourceRef?: string;

  readonly width: number;

}

interface WaveMaterialPackageVertexColorPayload {

  readonly byteLength: number;

  readonly componentCount: 4;

  readonly encoding: "float32-le-base64";

  readonly meshName: string;

  readonly path: string;

  readonly vertexCount: number;

}

declare class WaveMaterialPropertySnapshot {

  constructor(_applyImpl: () => void, _animateImpl: () => WaveMaterialPropertyAnimationBuilder);

  animate(): WaveMaterialPropertyAnimationBuilder;

  apply(): void;

}

type WaveMaterialResolvedUseMode = "public" | "private";

interface WaveMaterialScalarBinaryNode {

  readonly id: string;

  readonly op: "add" | "subtract" | "multiply" | "safeDivide" | "min" | "max" | "power" | "atan2";

  readonly valueType: "scalar";

  readonly epsilon?: number;

  readonly fallback?: number;

  readonly left: string;

  readonly right: string;

}

interface WaveMaterialScalarClampNode {

  readonly id: string;

  readonly op: "clamp";

  readonly valueType: "scalar";

  readonly input: string;

  readonly max: number;

  readonly min: number;

}

interface WaveMaterialScalarConstantNode {

  readonly id: string;

  readonly op: "scalarConstant";

  readonly valueType: "scalar";

  readonly value: number;

}

interface WaveMaterialScalarMixNode {

  readonly id: string;

  readonly op: "mixScalar";

  readonly valueType: "scalar";

  readonly amount: string;

  readonly from: string;

  readonly to: string;

}

interface WaveMaterialScalarParameterNode {

  readonly id: string;

  readonly op: "scalarParameter";

  readonly valueType: "scalar";

  readonly defaultValue: number;

  readonly parameterId: string;

}

interface WaveMaterialScalarRemapNode {

  readonly id: string;

  readonly op: "remap";

  readonly valueType: "scalar";

  readonly clamp: boolean;

  readonly input: string;

  readonly inputMax: number;

  readonly inputMin: number;

  readonly outputMax: number;

  readonly outputMin: number;

}

interface WaveMaterialScalarSmoothStepNode {

  readonly id: string;

  readonly op: "smoothStep";

  readonly valueType: "scalar";

  readonly edge0: number;

  readonly edge1: number;

  readonly input: string;

}

interface WaveMaterialScalarUnaryNode {

  readonly id: string;

  readonly op: "abs" | "negate" | "saturate" | "sqrt" | "sine" | "fract";

  readonly valueType: "scalar";

  readonly input: string;

}

interface WaveMaterialSimplexFbm3DNode {

  readonly id: string;

  readonly op: "simplexFbm3D";

  readonly valueType: "scalar";

  readonly coordinates: string;

  readonly gain: number;

  readonly lacunarity: number;

  readonly octaves: number;

  readonly scale: number;

  readonly seed: number;

}

interface WaveMaterialSimplexFbm3DOptions {

  readonly coordinates: WaveVector3FieldInput;

  readonly gain?: number;

  readonly lacunarity?: number;

  readonly octaves?: number;

  readonly scale?: number;

  readonly seed?: number;

}

type WaveMaterialStateDomain = "materialAsset" | "materialBinding" | "meshPaintData" | "surfaceOverride" | "visualEffect";

interface WaveMaterialStripesNode {

  readonly id: string;

  readonly op: "stripes";

  readonly valueType: "scalar";

  readonly coordinates: string;

  readonly frequency: number;

  readonly rotationRadians: number;

  readonly softness: number;

  readonly width: number;

}

interface WaveMaterialTextureSampleNode {

  readonly id: string;

  readonly op: "textureSample";

  readonly valueType: "color" | "scalar";

  readonly coordinates: string;

  readonly options: Required<WaveMaterialFieldTextureSampleOptions>;

  readonly textureRef: string;

}

interface WaveMaterialTimeNode {

  readonly id: string;

  readonly op: "time";

  readonly valueType: "scalar";

}

interface WaveMaterialVector2OffsetNode {

  readonly id: string;

  readonly op: "offsetVector2";

  readonly valueType: "vector2";

  readonly vector: string;

  readonly x: string;

  readonly y: string;

}

interface WaveMaterialVector2ScaleNode {

  readonly id: string;

  readonly op: "scaleVector2";

  readonly valueType: "vector2";

  readonly scale: string;

  readonly vector: string;

}

interface WaveMaterialVector3OffsetNode {

  readonly id: string;

  readonly op: "offsetVector3";

  readonly valueType: "vector3";

  readonly vector: string;

  readonly x: string;

  readonly y: string;

  readonly z: string;

}

interface WaveMaterialVector3ScaleNode {

  readonly id: string;

  readonly op: "scaleVector3";

  readonly valueType: "vector3";

  readonly scale: string;

  readonly vector: string;

}

interface WaveMaterialVectorComponentNode {

  readonly id: string;

  readonly op: "vectorComponent";

  readonly valueType: "scalar";

  readonly component: "x" | "y" | "z";

  readonly vector: string;

}

interface WaveMathValueExpr {

  readonly a: WaveValueExpr;

  readonly b?: WaveValueExpr;

  readonly c?: WaveValueExpr;

  readonly d?: WaveValueExpr;

  readonly kind?: WaveValueKind;

  readonly op: WaveValueMathOp;

  readonly type: "math";

}

type WaveMeshScope = "owned" | "inventory" | "part" | "createdPart";

interface WaveMeshSurfaceAttachmentAnchor {

  readonly barycentricWeights: readonly [number, number, number];

  readonly sourceMesh: unknown;

  readonly sourceVertexIndices: readonly [number, number, number];

}

interface WaveMeshSurfaceProvider {

  getMeshes?(scope?: WaveMeshScope): readonly unknown[];

  getParts?(scope?: PartScope): readonly unknown[];

  getSurfaceSourceMeshes?(): readonly unknown[];

  getVisualPivotNode?(): TransformNode;

}

type WaveMeshSurfaceSource = WaveMeshSurfaceProvider | TransformNode | readonly unknown[];

type WaveModelAffineMatrixValue = readonly [ number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number ];

type WaveModelAnchorId = string;

interface WaveModelAnchorMetadata {

  readonly id: WaveModelAnchorId;

  readonly jointId?: WaveModelJointId;

  readonly kind?: "jointOrigin" | "visualOrigin" | "collisionOrigin" | "socket" | "grip" | "custom";

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly origin: WaveModelOriginMetadata;

  readonly partId?: WaveModelPartId;

  readonly source?: WaveModelSourceInfo;

}

interface WaveModelAnchorPoseSnapshot {

  readonly anchorId: string;

  readonly anchorName?: string;

  readonly local: WaveModelRigTransformSnapshot;

  readonly partId: WaveModelPartId;

  readonly partPose: WaveModelRigPartPoseSnapshot;

  readonly world: WaveModelRigTransformSnapshot;

}

interface WaveModelBonePhysicsBindingMetadata {

  readonly bodyFromBone?: WaveModelTransformSnapshotValue;

  readonly exactBoneName: string;

  readonly partId: WaveModelPartId;

}

type WaveModelCarrierPolicy = { readonly kind: "adoptSingleRoot"; readonly rootId: string; } | { readonly kind: "useImportedSharedRoot"; readonly rootId: string; } | { readonly kind: "requiresSharedFrame"; readonly reason: WaveModelFrameReason; }

interface WaveModelCarrierProjection {

  readonly liveRootInspectionRequired: boolean;

  readonly policy?: WaveModelCarrierPolicy;

  readonly reasons: readonly WaveModelFrameReason[];

  readonly stableFrameRequired: boolean | "unknown";

}

interface WaveModelCompilerIdentity {

  readonly id: string;

  readonly revision: number;

}

interface WaveModelDetachableRegionRecord {

  readonly detachedCapSurfaceRegionId?: string;

  readonly detachedFallbackPartId?: WaveModelPartId;

  readonly detachedRootPartId?: WaveModelPartId;

  readonly detachJointId?: WaveModelJointId;

  readonly id: string;

  readonly meshId: WaveModelMeshId;

  readonly meta?: Readonly<Record<string, WaveModelSerializableValue>>;

  readonly partId: WaveModelPartId;

  readonly partitionPolicy: WaveModelSkinPartitionPolicy;

  readonly retainedCapSurfaceRegionId?: string;

  readonly retainedFallbackPartId?: WaveModelPartId;

  readonly source?: WaveModelSourceInfo;

  readonly surfaceRegionId: string;

}

type WaveModelDirectionInput = Direction | SerializedDirectionVector;

interface WaveModelDirectionMetadata {

  readonly frame: WaveTransformFrameSpace;

  readonly frameOfPartId?: string | undefined;

  readonly parentFrameDepth?: number | undefined;

  readonly direction?: WaveModelDirectionInput;

  readonly vector?: readonly [number, number, number];

}

type WaveModelEndEffectorId = string;

interface WaveModelEndEffectorMetadata {

  readonly anchorId?: WaveModelAnchorId;

  readonly id: WaveModelEndEffectorId;

  readonly localPosition?: WaveModelVec3Tuple;

  readonly localRotation?: WaveModelVec3Tuple;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly partId: WaveModelPartId;

  readonly source?: WaveModelSourceInfo;

}

interface WaveModelEndEffectorPoseSnapshot {

  readonly endEffectorId: WaveModelEndEffectorId;

  readonly endEffectorName?: string;

  readonly local: WaveModelRigTransformSnapshot;

  readonly partId: WaveModelPartId;

  readonly partPose: WaveModelRigPartPoseSnapshot;

  readonly world: WaveModelRigTransformSnapshot;

}

type WaveModelFrame = "world" | "model" | "modelRoot" | "parentPart" | "childPart" | "partLocal" | "meshLocal" | "joint" | "frameOfPart";

type WaveModelFrameReason = "visual:noRoot" | "visual:multiRoot" | "visual:rootLocalTransform" | "geometry:stableFrame" | "parts:stableFrame" | "rig:stableFrame";

interface WaveModelFrameScopeMetadata {

  readonly frame: WaveModelTransformFrameSpace;

  readonly frameOfPartId?: string;

  readonly parentFrameDepth?: number;

}

type WaveModelGeometryArtifactCoverage = "none" | "partial" | "complete";

interface WaveModelGeometryArtifactRef {

  readonly artifactId: string;

  readonly revision: string;

}

interface WaveModelGeometryMetadata {

  readonly filename?: string;

  readonly kind: "box" | "cylinder" | "sphere" | "mesh";

  readonly length?: number;

  readonly materialId?: string;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly origin?: WaveModelOriginMetadata;

  readonly radius?: number;

  readonly scale?: WaveModelVec3Tuple;

  readonly size?: WaveModelVec3Tuple;

}

type WaveModelIKChainId = string;

interface WaveModelIKChainMetadata {

  readonly endEffectorId: WaveModelEndEffectorId;

  readonly id: WaveModelIKChainId;

  readonly jointIds?: readonly WaveModelJointId[];

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly poleHint?: WaveModelOriginMetadata;

  readonly rootPartId?: WaveModelPartId;

  readonly source?: WaveModelSourceInfo;

}

interface WaveModelIKRuntimeSolveOptions {

  readonly allowMimicOverrides?: boolean | undefined;

  readonly bindWorldPoseByPartId?: Readonly<Record<string, WaveModelRigTransformSnapshot>> | undefined;

  readonly clamp?: boolean | undefined;

  readonly damping?: number | undefined;

  readonly defaultRootPose?: WaveModelRigTransformSnapshot | undefined;

  readonly includeTopologyLeafEndEffectors?: boolean | undefined;

  readonly maxIterations?: number | undefined;

  readonly rootPoseByPartId?: Readonly<Record<string, WaveModelRigTransformSnapshot>> | undefined;

  readonly rotationTolerance?: number | undefined;

  readonly tolerance?: number | undefined;

  readonly createParts?: boolean;

}

interface WaveModelIKSolveResult {

  readonly chain: WaveModelIKChainMetadata;

  readonly endEffector: WaveModelEndEffectorMetadata;

  readonly errorAngle: number;

  readonly errorDistance: number;

  readonly iterations: number;

  readonly success: boolean;

  readonly values: Readonly<Record<string, WaveModelPoseValue>>;

  readonly warning?: string;

}

interface WaveModelInertialMetadata {

  readonly inertia?: WaveModelInertiaTensorMetadata;

  readonly mass: number;

  readonly origin?: WaveModelOriginMetadata;

}

interface WaveModelInertiaTensorMetadata {

  readonly ixx: number;

  readonly ixy: number;

  readonly ixz: number;

  readonly iyy: number;

  readonly iyz: number;

  readonly izz: number;

}

interface WaveModelInverseBindArtifactRef {

  readonly artifactId: string;

  readonly hash: string;

  readonly matrixCount: number;

}

type WaveModelJointAxisFrame = "joint" | "parentPart" | "childPart" | "partLocal" | "meshLocal" | "model" | "modelRoot" | "world";

interface WaveModelJointControlInfo {

  readonly childPartId: WaveModelPartId;

  readonly childPartName?: string;

  readonly controllable: boolean;

  readonly id: WaveModelJointId;

  readonly isMimic: boolean;

  readonly mimicJointId?: WaveModelJointId;

  readonly name: string;

  readonly parentPartId: WaveModelPartId;

  readonly parentPartName?: string;

  readonly resolvedValue: WaveModelPoseValue;

  readonly restValue: WaveModelPoseValue;

  readonly sampleValues: readonly WaveModelPoseValue[];

  readonly slider: WaveModelJointSliderRange | null;

  readonly type: WaveModelJointMetadata["type"];

  readonly unit: WaveModelPoseValueUnit | "none";

  readonly value: WaveModelPoseValue;

}

type WaveModelJointId = string;

interface WaveModelJointMetadata {

  readonly anchorId?: WaveModelAnchorId;

  readonly axis?: WaveModelVec3Tuple;

  readonly axisDirection?: WaveModelDirectionInput | WaveModelDirectionMetadata;

  readonly axisFrame?: WaveModelJointAxisFrame;

  readonly childPartId: WaveModelPartId;

  readonly childPartName?: string;

  readonly convention?: WaveModelKinematicConvention;

  readonly dynamics?: WaveModelMotionPropertiesMetadata;

  readonly id: WaveModelJointId;

  readonly limits?: WaveModelMotionLimitsMetadata;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly mimic?: WaveModelMimicMetadata;

  readonly name?: string;

  readonly origin?: WaveModelOriginMetadata;

  readonly originFrame?: WaveModelFrame;

  readonly parentPartId: WaveModelPartId;

  readonly parentPartName?: string;

  readonly poseValueUnit?: WaveModelPoseValueUnit;

  readonly restValue?: WaveModelPoseValue;

  readonly sampleValues?: readonly WaveModelPoseValue[];

  readonly source?: WaveModelSourceInfo;

  readonly transformOrder?: WaveModelJointTransformOrder;

  readonly type: WaveModelJointType;

}

interface WaveModelJointSliderRange {

  readonly max: number;

  readonly min: number;

  readonly step: number;

}

type WaveModelJointTransformOrder = "parentJointOriginJointMotionChild";

type WaveModelJointType = "fixed" | "revolute" | "continuous" | "prismatic" | "floating";

type WaveModelJsonObject = { readonly [key: string]: WaveModelSerializableValue; }

type WaveModelKinematicConvention = "urdf" | "wave" | "source";

type WaveModelKnownCount = number | "unknown";

interface WaveModelLODGraphMetadata {

  readonly defaultLevelId?: WaveModelLODLevelId;

  readonly levels: readonly WaveModelLODLevelMetadata[];

  readonly meta?: Readonly<Record<string, unknown>>;

}

type WaveModelLODLevelId = string;

interface WaveModelLODLevelMetadata {

  readonly id: WaveModelLODLevelId;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly partIds: readonly WaveModelPartId[];

}

interface WaveModelLODProjection {

  readonly controllerRequired: boolean;

  readonly graphPresent: boolean;

  readonly issues: readonly WaveModelProjectionIssue[];

  readonly levelCount: number;

  readonly partIds: readonly WaveModelPartId[];

  readonly policyPresent: boolean;

}

type WaveModelMassModelConfig = WaveColliderMassModelConfig | WavePartMassModelConfig;

type WaveModelMassPartSource = "parts";

type WaveModelMassVolumeSource = "collider";

interface WaveModelMaterialBindingMetadata {

  readonly materialId: string;

  readonly materialIndex?: number;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly slotName?: string;

  readonly targetPartId?: WaveModelPartId;

}

interface WaveModelMaterialBindingRecord {

  readonly id: string;

  readonly materialContentHash?: string;

  readonly materialId: string;

  readonly materialRevision?: string;

  readonly meta?: WaveModelJsonObject;

  readonly slotId: string;

  readonly source?: WaveModelSourceInfo;

}

interface WaveModelMaterialProjection {

  readonly actualizationCanDefer: boolean;

  readonly bindingCount: number;

  readonly cloneStrategy: WaveMaterialCloneStrategy;

  readonly defaultUseMode: WaveMaterialResolvedUseMode;

  readonly hasMeshBindings: boolean;

  readonly hasPartBindings: boolean;

  readonly hasSubmeshSlots: boolean;

  readonly level: WaveModelMaterialProjectionLevel;

  readonly stateDomains: readonly WaveMaterialStateDomain[];

}

type WaveModelMaterialProjectionLevel = "none" | "meshBindings" | "partBindings" | "surfaceOverrides" | "effectState";

interface WaveModelMaterialSlotDeclaration {

  readonly defaultMaterialId?: string;

  readonly id: string;

  readonly materialIndex?: number;

  readonly meta?: WaveModelJsonObject;

  readonly name: string;

  readonly targetId: WaveModelObjectModelId | WaveModelPartId | WaveModelMeshId | WaveModelSurfaceId;

  readonly targetKind: WaveModelMaterialSlotTargetKind;

}

interface WaveModelMaterialSlotMetadata {

  readonly materialId: string;

  readonly materialIndex?: number | undefined;

  readonly meta?: Readonly<Record<string, unknown>> | undefined;

  readonly slotName?: string | undefined;

  readonly targetPartId?: string | undefined;

  readonly defaultMaterialId?: string;

  readonly id: string;

}

type WaveModelMaterialSlotTargetKind = "model" | "part" | "mesh" | "surface";

type WaveModelMaterialStatePatch = { readonly textures?: { readonly base?: string | null; readonly normal?: string | null; readonly metallic?: string | null; readonly roughness?: string | null; readonly ao?: string | null; readonly emissive?: string | null; readonly thickness?: string | null; readonly transmission?: string | null; readonly translucencyColor?: string | null; readonly translucencyIntensity?: string | null; }; readonly color?: string; readonly colorExplicitOverride?: boolean; readonly opacity?: number; readonly roughness?: number; readonly metalness?: number; readonly specularIntensity?: number | null; readonly environmentIntensity?: number | null; readonly directIntensity?: number | null; readonly emissiveColor?: string; readonly emissiveIntensity?: number; readonly albedoEmissiveFill?: { readonly color?: string; readonly intensity?: number; } | null; readonly maxSimultaneousLights?: number | null; readonly useRadianceOverAlpha?: boolean | null; readonly useSpecularOverAlpha?: boolean | null; readonly transparencyMode?: "opaque" | "alphaTest" | "alphaBlend" | "alphaTestAndBlend" | null; readonly alphaMode?: "disable" | "alpha" | "additive" | "multiply" | "premultiplied" | null; readonly subSurface?: { readonly refractionIntensity?: number; readonly translucencyIntensity?: number; readonly indexOfRefraction?: number; readonly tintColor?: string | null; readonly minimumThickness?: number; readonly maximumThickness?: number; }; readonly clearCoat?: { readonly enabled?: boolean; readonly intensity?: number; readonly roughness?: number; readonly indexOfRefraction?: number; }; readonly sheen?: { readonly enabled?: boolean; readonly intensity?: number; readonly color?: string; readonly roughness?: number | null; }; readonly iridescence?: { readonly enabled?: boolean; readonly intensity?: number; readonly minimumThickness?: number; readonly maximumThickness?: number; readonly indexOfRefraction?: number; }; readonly anisotropy?: { readonly enabled?: boolean; readonly intensity?: number; readonly direction?: [number, number]; }; readonly doubleSided?: boolean; readonly wireframe?: boolean; readonly antiTiling?: { readonly mode?: "noiseBlend" | "hexTiling" | "tileRandomization" | "voronoiBombing"; readonly hexTiling?: { readonly rotationStrength?: number; readonly fallOffContrast?: number; readonly exponent?: number; readonly contrast?: number; }; } | null; readonly depthBias?: number; readonly uvScale?: [number, number]; readonly uvOffset?: [number, number]; readonly uvRotation?: number; readonly materialRemoved?: boolean; }

interface WaveModelMaterialStateRecord {

  readonly id: string;

  readonly meta?: WaveModelJsonObject;

  readonly slotId: string;

  readonly source?: WaveModelSourceInfo;

  readonly state: WaveModelMaterialStatePatch;

}

type WaveModelMeshId = string;

interface WaveModelMeshIdentityMetadata {

  readonly id: string;

  readonly index?: number | undefined;

  readonly name?: string | undefined;

  readonly originalName?: string | undefined;

  readonly source?: WaveModelMeshSourceMetadata | undefined;

  readonly displayName: string;

  readonly materialBindings?: readonly WaveModelMaterialBindingMetadata[];

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly qualifiedPartId?: WaveModelPartId;

}

interface WaveModelMeshInventoryProjection {

  readonly canUseSidecarOnly: boolean;

  readonly displayNamesAvailable: boolean;

  readonly geometryArtifactCoverage: WaveModelGeometryArtifactCoverage;

  readonly identitySource: "generated" | "imported" | "prefab" | "runtime" | "unknown" | "mixed";

  readonly meshIds: readonly string[];

  readonly metadataProjectionRequiredReasons: readonly string[];

  readonly stableMeshIdsAvailable: boolean;

}

interface WaveModelMeshPartBindingRecord {

  readonly id: string;

  readonly meshId: WaveModelMeshId;

  readonly meta?: WaveModelJsonObject;

  readonly order?: number;

  readonly partId: WaveModelPartId;

  readonly role: WaveModelMeshPartBindingRole;

  readonly source?: WaveModelSourceInfo;

}

type WaveModelMeshPartBindingRole = "visual" | "collision" | "inertialProxy" | "anchorProxy";

interface WaveModelMeshRecord {

  readonly displayName: string;

  readonly geometryArtifact?: WaveModelGeometryArtifactRef;

  readonly id: WaveModelMeshId;

  readonly localMatrix?: WaveModelAffineMatrixValue;

  readonly localTransform?: WaveModelTransformSnapshotValue;

  readonly meta?: WaveModelJsonObject;

  readonly name?: string;

  readonly order?: number;

  readonly source?: WaveModelMeshSourceMetadata;

}

interface WaveModelMeshReferenceMetadata {

  readonly id: WaveModelMeshId;

  readonly index?: number;

  readonly name?: string;

  readonly originalName?: string;

  readonly source?: WaveModelMeshSourceMetadata;

}

type WaveModelMeshSourceKind = "imported" | "generated" | "prefab" | "urdf" | "runtime" | "unknown";

interface WaveModelMeshSourceMetadata {

  readonly assetName?: string;

  readonly assetPath?: string;

  readonly assetType?: string;

  readonly kind?: WaveModelMeshSourceKind;

  readonly meshIndex?: number;

  readonly meshName?: string;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly modelName?: string;

  readonly nodeIndex?: number;

  readonly nodeName?: string;

  readonly primitiveIndex?: number;

  readonly source?: WaveModelSourceInfo;

}

interface WaveModelMimicMetadata {

  readonly jointId: WaveModelJointId;

  readonly multiplier?: number;

  readonly offset?: number;

}

interface WaveModelMotionLimitsMetadata {

  readonly effort?: number;

  readonly frame?: WaveModelFrame;

  readonly lower?: number;

  readonly unit?: WaveModelPoseValueUnit;

  readonly upper?: number;

  readonly velocity?: number;

}

interface WaveModelMotionPropertiesMetadata {

  readonly damping?: number;

  readonly friction?: number;

}

interface WaveModelObjectModel {

  readonly detachableRegions?: readonly WaveModelDetachableRegionRecord[];

  readonly diagnostics?: readonly WaveModelObjectModelIssue[];

  readonly lodGraph?: WaveModelLODGraphMetadata;

  readonly materialBindings?: readonly WaveModelMaterialBindingRecord[];

  readonly materialSlots?: readonly WaveModelMaterialSlotDeclaration[];

  readonly materialStates?: readonly WaveModelMaterialStateRecord[];

  readonly meshes: readonly WaveModelMeshRecord[];

  readonly meshPartBindings?: readonly WaveModelMeshPartBindingRecord[];

  readonly modelId: WaveModelObjectModelId;

  readonly parts?: readonly WaveModelPartRecord[];

  readonly producerIntent?: WaveModelProducerIntent;

  readonly revision: string;

  readonly skinBindings?: readonly WaveModelSkinBindingRecord[];

  readonly source?: WaveModelSourceInfo;

  readonly surfaceRegions?: readonly WaveModelSurfaceRegionRecord[];

  readonly topology?: WaveModelTopologyRecord;

  readonly version: WaveModelObjectModelVersion;

}

type WaveModelObjectModelId = string;

interface WaveModelObjectModelIssue {

  readonly code: string;

  readonly message: string;

  readonly path?: string;

  readonly severity: WaveModelObjectModelIssueSeverity;

}

type WaveModelObjectModelIssueSeverity = "info" | "warning" | "error";

type WaveModelObjectModelVersion = typeof WAVE_MODEL_OBJECT_MODEL_VERSION;

interface WaveModelOriginMetadata {

  readonly frame?: WaveModelFrame;

  readonly frameOfPartId?: WaveModelPartId;

  readonly frameScope?: WaveModelFrameScopeMetadata;

  readonly rpy?: WaveModelVec3Tuple;

  readonly scale?: WaveModelVec3Tuple;

  readonly terms?: WaveModelTransformTermsSpace;

  readonly xyz?: WaveModelVec3Tuple;

}

interface WaveModelPartAutoRenameInput {

  readonly autoRename: true;

}

interface WaveModelPartEditMetadata {

  readonly editable?: boolean;

  readonly geometryEditable?: boolean;

  readonly includeInAggregatePhysics?: boolean;

  readonly materialEditable?: boolean;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly physicsPromotable?: boolean;

  readonly removable?: boolean;

  readonly renameable?: boolean;

  readonly reparentable?: boolean;

}

type WaveModelPartId = string;

type WaveModelPartLifecycleEventKind = "import" | "register" | "create" | "promote" | "detach" | "remove" | "destroy" | "rename" | "reparent" | "materialChange" | "physicsParticipationChange";

interface WaveModelPartLifecycleEventMetadata {

  readonly atMs?: number;

  readonly kind: WaveModelPartLifecycleEventKind;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly nextState?: WaveModelPartLifecycleState;

  readonly previousState?: WaveModelPartLifecycleState;

  readonly source?: WaveModelSourceInfo;

}

interface WaveModelPartLifecycleMetadata {

  readonly detachedFromPartId?: WaveModelPartId;

  readonly events?: readonly WaveModelPartLifecycleEventMetadata[];

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly state: WaveModelPartLifecycleState;

  readonly updatedAtMs?: number;

}

interface WaveModelPartMetadata {

  readonly anchors?: readonly WaveModelAnchorMetadata[];

  readonly collisions?: readonly WaveModelGeometryMetadata[];

  readonly edit?: WaveModelPartEditMetadata;

  readonly id?: WaveModelPartId;

  readonly incomingJoint?: WaveModelJointMetadata | null;

  readonly incomingJointId?: WaveModelJointId | null;

  readonly inertial?: WaveModelInertialMetadata | null;

  readonly jointIds?: readonly WaveModelJointId[];

  readonly lifecycle?: WaveModelPartLifecycleMetadata;

  readonly materialBindings?: readonly WaveModelMaterialBindingMetadata[];

  readonly materialSlots?: readonly WaveModelMaterialSlotMetadata[];

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly outgoingJointIds?: readonly WaveModelJointId[];

  readonly parentPartId?: WaveModelPartId | null;

  readonly rotationPivot?: WaveModelOriginMetadata | null;

  readonly source?: WaveModelSourceInfo;

  readonly sourceMesh?: WaveModelMeshReferenceMetadata;

  readonly visualFrame?: WaveModelTransformSnapshotValue | null;

  readonly visuals?: readonly WaveModelGeometryMetadata[];

}

interface WaveModelPartPatch<TPartRef = WaveModelPartId> {

  readonly includeInPhysics?: boolean | undefined;

  readonly metadata?: WaveModelPartMetadata | null | undefined;

  readonly name?: string | undefined;

  readonly parent?: TPartRef | null | undefined;

  readonly ref: TPartRef;

}

interface WaveModelPartPatchFields<TPartRef = WaveModelPartId> {

  readonly includeInPhysics?: boolean;

  readonly metadata?: WaveModelPartMetadata | null;

  readonly name?: string;

  readonly parent?: TPartRef | null;

}

type WaveModelPartPatchValue<TPartRef = WaveModelPartId> = string | WaveModelPartPatchFields<TPartRef>;

interface WaveModelPartProjection {

  readonly autoCreateEntityPartIds: readonly WaveModelPartId[];

  readonly level: WaveModelSemanticPartLevel;

  readonly partIds: readonly WaveModelPartId[];

  readonly registryCanDefer: boolean;

  readonly registryRequiredReasons: readonly string[];

  readonly rootPartId?: WaveModelPartId;

  readonly source: WaveModelPartProjectionSource;

}

type WaveModelPartProjectionSource = "objectModel" | "none";

interface WaveModelPartRecord {

  readonly aliases?: readonly string[];

  readonly anchors?: readonly WaveModelAnchorMetadata[];

  readonly collisions?: readonly WaveModelGeometryMetadata[];

  readonly edit?: WaveModelPartEditMetadata;

  readonly id: WaveModelPartId;

  readonly inertial?: WaveModelInertialMetadata | null;

  readonly lifecycle?: WaveModelPartLifecycleMetadata;

  readonly meta?: WaveModelJsonObject;

  readonly name: string;

  readonly order?: number;

  readonly parentPartId?: WaveModelPartId | null;

  readonly rotationPivot?: WaveModelOriginMetadata | null;

  readonly source?: WaveModelSourceInfo;

  readonly visualFrame?: WaveModelTransformSnapshotValue | null;

  readonly visuals?: readonly WaveModelGeometryMetadata[];

}

type WaveModelPhysicsChildBodyMode = "dynamic" | "kinematic";

interface WaveModelPhysicsJointApplyRecord {

  readonly childPartId: WaveModelPartId;

  readonly code?: PhysicsConstraintProjectionRejectionCode | WaveModelPhysicsJointSkipReason;

  readonly constraintId: string | null;

  readonly jointId: WaveModelJointId;

  readonly parentPartId: WaveModelPartId;

  readonly reason?: string;

  readonly status: WaveModelPhysicsJointApplyStatus;

}

type WaveModelPhysicsJointApplyStatus = "created" | "pending" | "rejected" | "skipped";

interface WaveModelPhysicsJointPlan {

  readonly child: WaveModelPhysicsPartEntity | null;

  readonly childPartId: WaveModelPartId;

  readonly config: WaveJointConfig | null;

  readonly joint: WaveModelJointMetadata;

  readonly jointId: WaveModelJointId;

  readonly message?: string;

  readonly parent: WaveModelPhysicsPartEntity | null;

  readonly parentPartId: WaveModelPartId;

  readonly skipReason?: WaveModelPhysicsJointSkipReason;

  readonly status: WaveModelPhysicsJointPlanStatus;

}

type WaveModelPhysicsJointPlanStatus = "planned" | "skipped";

type WaveModelPhysicsJointSkipReason = "missingParentPart" | "missingChildPart" | "unsupportedJointType" | "invalidPoseEvaluation" | "nonScalarMotorTarget";

type WaveModelPhysicsJointUnsupportedPolicy = "skip" | "error";

type WaveModelPhysicsPartEntity = waveProp & { readonly physicsBody: cmp_physicsBody; }

interface WaveModelPhysicsRig {

  readonly applyReport: WaveModelPhysicsRigApplyReport;

  readonly assembly: WaveJointAssembly<WaveModelPhysicsPartEntity>;

  readonly graph: WaveModelRigGraphMetadata;

  readonly partsById: ReadonlyMap<WaveModelPartId, WaveModelPhysicsPartEntity>;

  readonly plan: WaveModelPhysicsRigPlan;

}

interface WaveModelPhysicsRigApplyReport {

  readonly acceptedJointCount: number;

  readonly createdJointCount: number;

  readonly joints: readonly WaveModelPhysicsJointApplyRecord[];

  readonly pendingJointCount: number;

  readonly plannedJointCount: number;

  readonly rejectedJointCount: number;

  readonly skippedJointCount: number;

  readonly sourceJointCount: number;

}

interface WaveModelPhysicsRigCompiledRecipe {

  readonly graph: WaveModelRigGraphMetadata;

  readonly joints: readonly CompiledWaveModelPhysicsJointRecipe[];

  readonly partsById: ReadonlyMap<WaveModelPartId, WaveModelPhysicsPartRealizationRecipe>;

  readonly revision: string;

  readonly topology: WaveModelRigTopology;

  readonly valid: boolean;

}

interface WaveModelPhysicsRigOptions {

  readonly childBodyMode?: WaveModelPhysicsChildBodyMode;

  readonly debugLog?: boolean;

  readonly defaultAngularDamping?: number;

  readonly defaultEnableCollisions?: boolean;

  readonly defaultLinearDamping?: number;

  readonly defaultMass?: number;

  readonly detachFromHierarchy?: boolean;

  readonly enableMotors?: boolean;

  readonly includeFloatingJoints?: boolean;

  readonly name?: string;

  readonly rootBodyMode?: WaveModelPhysicsRootBodyMode;

  readonly unsupportedJointPolicy?: WaveModelPhysicsJointUnsupportedPolicy;

}

interface WaveModelPhysicsRigPlan {

  readonly graph: WaveModelRigGraphMetadata;

  readonly joints: readonly WaveModelPhysicsJointPlan[];

  readonly options: Required<Pick<WaveModelPhysicsRigOptions, "rootBodyMode" | "childBodyMode" | "defaultMass" | "defaultLinearDamping" | "defaultAngularDamping" | "defaultEnableCollisions" | "unsupportedJointPolicy" | "includeFloatingJoints" | "enableMotors" | "detachFromHierarchy" | "debugLog">> & Pick<WaveModelPhysicsRigOptions, "name">;

  readonly plannedJoints: readonly WaveModelPhysicsJointPlan[];

  readonly skippedJoints: readonly WaveModelPhysicsJointPlan[];

}

type WaveModelPhysicsRootBodyMode = "static" | "kinematic" | "dynamic";

type WaveModelPoseInput = string | WaveModelRigPoseSnapshotMetadata;

declare class WaveModelPoseTransitionBuilder implements WaveModelPoseTransitionControls<WaveAnimationPlaybackHandle> {

  constructor(_playTransition: (startPose: WaveModelRigPoseSnapshotMetadata, endPose: WaveModelRigPoseSnapshotMetadata, durationSeconds: number, options: WaveModelPoseTransitionOptions) => WaveAnimationPlaybackHandle, _startPose: WaveModelRigPoseSnapshotMetadata, _endPose: WaveModelRigPoseSnapshotMetadata);

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  play(): WaveAnimationPlaybackHandle;

  withOptions(options: WaveModelPoseTransitionOptions): this;

}

interface WaveModelPoseTransitionControls<TResult> {

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  play(): TResult;

  withEasingEffect?(ease: WaveEasing): this;

  withOptions?(options: WaveModelPoseTransitionOptions): this;

}

interface WaveModelPoseTransitionOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  readonly allowMimicOverrides?: boolean;

  readonly clamp?: boolean;

  readonly createParts?: boolean;

  readonly ease?: WaveEasing;

  readonly loopMode?: WaveLoopMode;

  readonly speed?: number;

}

type WaveModelPoseValue = number | WaveModelOriginMetadata;

type WaveModelPoseValueUnit = "radian" | "meter" | "origin";

interface WaveModelProducerIntent {

  readonly runtimeRealization: WaveModelRuntimeRealizationIntent;

  readonly semanticParts: "none" | "explicit";

  readonly sourceKind: WaveModelProducerSourceKind;

  readonly topology: "none" | "explicit";

}

type WaveModelProducerSourceKind = "rawImport" | "waveAuthored" | "generatedGeometry" | "prefab" | "articulated" | "authoringMutation" | "destructiveGeometry" | "thinBatch" | "voxel" | "worldStreaming" | "runtimeRestore" | "externalTool";

interface WaveModelProjectionCapabilities {

  readonly fixedFastPathEligible: boolean | "unknown";

  readonly geometryCopyOnWriteCapable: boolean | "unknown";

  readonly geometryEditable: boolean | "unknown";

  readonly lazyMaterialProjectionSafe: boolean;

  readonly lazyPartProjectionSafe: boolean;

  readonly materialCopyOnWriteCapable: boolean;

  readonly partEntityCreatable: boolean | "unknown";

  readonly partPromotable: boolean | "unknown";

  readonly topologyDefault: WaveModelTopologyIntent;

}

interface WaveModelProjectionDiagnostics {

  readonly estimatedEagerDomainCount: number;

  readonly fallbackReasons: readonly string[];

  readonly issues: readonly WaveModelProjectionIssue[];

  readonly sourceFieldsUsed: readonly string[];

}

interface WaveModelProjectionIssue {

  readonly code: string;

  readonly message: string;

  readonly severity: "info" | "warning" | "error";

}

interface WaveModelProjectionManifest {

  readonly capabilities: WaveModelProjectionCapabilities;

  readonly carrier: WaveModelCarrierProjection;

  readonly diagnostics: WaveModelProjectionDiagnostics;

  readonly lod: WaveModelLODProjection;

  readonly manifestHash: string;

  readonly materials: WaveModelMaterialProjection;

  readonly meshInventory: WaveModelMeshInventoryProjection;

  readonly parts: WaveModelPartProjection;

  readonly rig: WaveModelRigProjection;

  readonly sourceRevision: string;

  readonly structure: WaveModelStructureProjection;

  readonly surfaces: WaveModelSurfaceProjection;

  readonly version: WaveModelProjectionManifestVersion;

}

type WaveModelProjectionManifestVersion = 1;

type WaveModelQuaternionTuple = readonly [number, number, number, number];

interface WaveModelResolvedEndEffectorMetadata {

  readonly anchorId?: string | undefined;

  readonly id: string;

  readonly localPosition?: WaveModelVec3Tuple | undefined;

  readonly localRotation?: WaveModelVec3Tuple | undefined;

  readonly meta?: Readonly<Record<string, unknown>> | undefined;

  readonly name?: string | undefined;

  readonly partId: string;

  readonly source?: WaveModelSourceInfo | undefined;

  readonly localPositionTuple: WaveModelVec3Tuple;

}

interface WaveModelRigGraphMetadata {

  readonly articulations?: readonly WaveModelJointMetadata[];

  readonly endEffectors?: readonly WaveModelEndEffectorMetadata[];

  readonly ikChains?: readonly WaveModelIKChainMetadata[];

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly parts?: readonly WaveModelPartMetadata[];

  readonly rootPartId?: WaveModelPartId | null;

  readonly skeletalPhysics?: WaveModelSkeletalPhysicsMetadata;

  readonly snapshotClips?: readonly WaveModelSnapshotClipMetadata[];

  readonly snapshots?: readonly WaveModelSnapshotMetadata[];

  readonly source?: WaveModelSourceInfo;

}

interface WaveModelRigPartPoseSnapshot {

  readonly local: WaveModelRigTransformSnapshot;

  readonly parentPartId: WaveModelPartId | null;

  readonly partId: WaveModelPartId;

  readonly sourceJointId: WaveModelJointId | null;

  readonly world: WaveModelRigTransformSnapshot;

}

type WaveModelRigPoseClipMetadata = WaveModelSnapshotClipMetadata<"rigPose">;

interface WaveModelRigPoseSnapshotMetadata {

  readonly id: string;

  readonly kind: "rigPose";

  readonly meta?: Readonly<Record<string, unknown>> | undefined;

  readonly name?: string | undefined;

  readonly source?: WaveModelSourceInfo | undefined;

  readonly values: Readonly<Record<string, WaveModelPoseValue>>;

}

interface WaveModelRigProjection {

  readonly controllerRequired: boolean;

  readonly graphPresent: boolean;

  readonly graphValid: boolean;

  readonly issues: readonly WaveModelProjectionIssue[];

  readonly partIds: readonly WaveModelPartId[];

  readonly rootPartIds: readonly WaveModelPartId[];

}

interface WaveModelRigQuaternionSnapshot {

  readonly w: number;

  readonly x: number;

  readonly y: number;

  readonly z: number;

}

interface WaveModelRigTopology {

  readonly jointByChildPartId: ReadonlyMap<WaveModelPartId, WaveModelJointMetadata>;

  readonly jointById: ReadonlyMap<WaveModelJointId, WaveModelJointMetadata>;

  readonly jointsByParentPartId: ReadonlyMap<WaveModelPartId, readonly WaveModelJointMetadata[]>;

  readonly leafPartIds: readonly WaveModelPartId[];

  readonly parentPartIdByChildPartId: ReadonlyMap<WaveModelPartId, WaveModelPartId>;

  readonly partIds: readonly WaveModelPartId[];

  readonly rootPartIds: readonly WaveModelPartId[];

}

interface WaveModelRigTransformSnapshot {

  readonly position: WaveModelRigVector3Snapshot;

  readonly rotation: WaveModelRigQuaternionSnapshot;

  readonly scale: WaveModelRigVector3Snapshot;

}

type WaveModelRigVector3Snapshot = Readonly<SerializableVector3>;

interface WaveModelRuntimeRealizationIntent {

  readonly maxEntities?: number;

  readonly partIds?: readonly WaveModelPartId[];

  readonly policy: WaveModelRuntimeRealizationPolicy;

  readonly reason?: string;

  readonly scope?: WaveModelRuntimeRealizationScope;

}

type WaveModelRuntimeRealizationPolicy = "declarativeOnly" | "lazyEntities" | "entitiesOnLoad";

type WaveModelRuntimeRealizationScope = "selectedParts" | "allDeclaredParts";

type WaveModelSemanticPartLevel = "none" | "meshIdentityOnly" | "declaredParts" | "rigGraphParts";

type WaveModelSerializableValue = SerializableDataValue;

type WaveModelSerializedTargetKind = WaveModelTargetKind | "auto";

interface WaveModelSerializedVisualTarget {

  readonly kind: WaveModelSerializedTargetKind;

  readonly ref?: string | number;

}

interface WaveModelSkeletalPhysicsMetadata {

  readonly bindings: readonly WaveModelBonePhysicsBindingMetadata[];

  readonly rootPartId?: WaveModelPartId;

  readonly version: 1;

}

interface WaveModelSkinBindingDependencies {

  readonly bindPoseRevision: string;

  readonly meshTopologyRevision: string;

  readonly rigTopologyRevision: string;

  readonly weightPayloadRevision: string;

}

interface WaveModelSkinBindingProvenance {

  readonly compilerVersion: number;

  readonly method: WaveModelSkinWeightMethod;

  readonly parametersHash?: string;

}

interface WaveModelSkinBindingRecord {

  readonly bindPoseSnapshotId: string;

  readonly channelCapacity: 4 | 8;

  readonly dependencies?: WaveModelSkinBindingDependencies;

  readonly id: string;

  readonly inverseBindArtifact?: WaveModelInverseBindArtifactRef;

  readonly jointPartIds: readonly WaveModelPartId[];

  readonly maxActiveInfluences?: number;

  readonly meshId: WaveModelMeshId;

  readonly meta?: WaveModelJsonObject;

  readonly provenance?: WaveModelSkinBindingProvenance;

  readonly rigBindingId?: string;

  readonly source?: WaveModelSourceInfo;

}

type WaveModelSkinPartitionPolicy = "strict" | "trimAndNormalize" | "transferToFallback" | "repairBoundary";

type WaveModelSkinWeightMethod = "authored" | "nearest-segment" | "distance-field" | "geodesic-heat" | "transferred";

type WaveModelSnapshotClipEasing = "none" | "linear" | "power1.in" | "power1.out" | "power1.inOut" | "power2.in" | "power2.out" | "power2.inOut" | "power3.in" | "power3.out" | "power3.inOut" | "sine.in" | "sine.out" | "sine.inOut" | "expo.in" | "expo.out" | "expo.inOut" | "back.in" | "back.out" | "back.inOut" | "elastic.in" | "elastic.out" | "elastic.inOut" | "bounce.in" | "bounce.out" | "bounce.inOut";

interface WaveModelSnapshotClipEventMetadata {

  readonly at: WaveModelTimeSpanMetadata;

  readonly event: WaveEventDefinitionMetadata;

  readonly id?: string;

  readonly payload?: WaveModelSerializableValue;

}

type WaveModelSnapshotClipId = string;

interface WaveModelSnapshotClipMetadata<TKind extends WaveModelSnapshotKind = WaveModelSnapshotKind> {

  readonly duration?: WaveModelTimeSpanMetadata;

  readonly events?: readonly WaveModelSnapshotClipEventMetadata[];

  readonly id: WaveModelSnapshotClipId;

  readonly keyframes: readonly WaveModelSnapshotKeyframeMetadata[];

  readonly kind: TKind;

  readonly loopMode?: WaveLoopMode;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly source?: WaveModelSourceInfo;

}

type WaveModelSnapshotId = string;

interface WaveModelSnapshotKeyframeMetadata {

  readonly at: WaveModelTimeSpanMetadata;

  readonly easing?: WaveModelSnapshotClipEasing;

  readonly snapshotId: WaveModelSnapshotId;

}

type WaveModelSnapshotKind = "rigPose" | "transform";

type WaveModelSnapshotMetadata = WaveModelRigPoseSnapshotMetadata | WaveModelTransformSnapshotMetadata;

interface WaveModelSourceInfo {

  readonly categorySlug?: string;

  readonly format: string;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly recordId?: string;

  readonly revisionId?: string;

  readonly sdkPackage?: string;

  readonly sourceJointName?: string;

  readonly sourcePartName?: string;

  readonly sourcePath?: string;

}

type WaveModelStructuredSurfaceRole = "panelReveal" | "cavityShell" | "text";

interface WaveModelStructureProjection {

  readonly childMeshCount: WaveModelKnownCount;

  readonly hasAnimation: boolean | "unknown";

  readonly hasChildMeshes: boolean | "unknown";

  readonly hasLocalRootTransform: boolean | "unknown";

  readonly hasMorphTargets: boolean | "unknown";

  readonly hasSkeleton: boolean | "unknown";

  readonly renderableMeshCount: WaveModelKnownCount;

  readonly requiresStableFrame: boolean | "unknown";

  readonly rootCount: WaveModelKnownCount;

  readonly rootMeshCount: WaveModelKnownCount;

}

type WaveModelSurfaceAvailability = "none" | "authored";

type WaveModelSurfaceId = string;

interface WaveModelSurfaceIdentityInvalidation {

  readonly reason: string;

  readonly sourceGeometryRevisions: readonly (string | number)[];

  readonly sourceObjectModelRevision: string;

  readonly sourceSurfaceIds: readonly WaveModelSurfaceId[];

}

interface WaveModelSurfaceProjection {

  readonly availability: WaveModelSurfaceAvailability;

  readonly materialProjectionCanDefer: boolean;

  readonly regionCount: number | "unknown";

  readonly semanticIndexCanDefer: boolean;

}

type WaveModelSurfaceQuery = { readonly kind: "idOrName"; readonly value: string; } | { readonly kind: "role"; readonly role: WaveModelSurfaceRole; } | { readonly kind: "indexedRole"; readonly role: "side"; readonly index: number; } | { readonly kind: "structuredRole"; readonly role: WaveModelStructuredSurfaceRole; readonly value: string | number; } | { readonly kind: "direction"; readonly localDirection: readonly [number, number, number]; }

interface WaveModelSurfaceRegionRecord {

  readonly aliases?: readonly string[];

  readonly geometryGroupId: string;

  readonly id: WaveModelSurfaceId;

  readonly localNormalHint?: readonly [number, number, number];

  readonly meshId: WaveModelMeshId;

  readonly meta?: WaveModelJsonObject;

  readonly name: string;

  readonly order?: number;

  readonly selectors?: readonly WaveModelSurfaceSelectorDescriptor[];

  readonly source?: WaveModelSourceInfo;

}

type WaveModelSurfaceRole = "front" | "back" | "left" | "right" | "top" | "bottom" | "slope" | "side" | "inner" | "outer" | "startCap" | "endCap" | "up" | "down";

interface WaveModelSurfaceSelectionDefinition {

  readonly baseWeight: number;

  readonly id: string;

  readonly operations: readonly WaveModelSurfaceSelectionOperation[];

  readonly schema: typeof WAVE_MODEL_SURFACE_SELECTION_SCHEMA;

  readonly sourceModelId: string;

  readonly sourceObjectModelRevision: string;

}

type WaveModelSurfaceSelectionMode = "include" | "exclude";

type WaveModelSurfaceSelectionOperation = { readonly kind: "surfaces"; readonly mode: WaveModelSurfaceSelectionMode; readonly surfaceIds: readonly WaveModelSurfaceId[]; } | { readonly kind: "surfaceProximity"; readonly mode: WaveModelSurfaceSelectionMode; readonly surfaceIds: readonly WaveModelSurfaceId[]; readonly radius: number; readonly falloff: WaveValueCurveSpec; } | { readonly kind: "radial"; readonly mode: WaveModelSurfaceSelectionMode; readonly center: readonly [number, number, number]; readonly radius: number; readonly falloff: WaveValueCurveSpec; }

type WaveModelSurfaceSelectorDescriptor = { readonly kind: "role"; readonly role: WaveModelSurfaceRole; } | { readonly kind: "indexedRole"; readonly role: "side"; readonly index: number; } | { readonly kind: "structuredRole"; readonly role: WaveModelStructuredSurfaceRole; readonly value: string | number; }

type WaveModelTargetKind = "owner" | "part" | "mesh";

type WaveModelTimeSpanMetadata = WaveTimeSpanSpec;

type WaveModelTopologyIntent = "auto" | "dynamic" | "fixed";

interface WaveModelTopologyRecord {

  readonly endEffectors?: readonly WaveModelEndEffectorMetadata[];

  readonly ikChains?: readonly WaveModelIKChainMetadata[];

  readonly joints: readonly WaveModelJointMetadata[];

  readonly meta?: WaveModelJsonObject;

  readonly rootPartIds: readonly WaveModelPartId[];

  readonly snapshotClips?: readonly WaveModelSnapshotClipMetadata[];

  readonly snapshots?: readonly WaveModelSnapshotMetadata[];

}

type WaveModelTransformFrameSpace = WaveTransformFrameSpace;

interface WaveModelTransformSnapshotMetadata {

  readonly id: string;

  readonly kind: "transform";

  readonly meta?: Readonly<Record<string, unknown>> | undefined;

  readonly name?: string | undefined;

  readonly source?: WaveModelSourceInfo | undefined;

  readonly transform: WaveModelTransformSnapshotValue;

}

interface WaveModelTransformSnapshotValue {

  readonly frame?: WaveModelFrame;

  readonly position: WaveModelVec3Tuple;

  readonly rotation: WaveModelQuaternionTuple;

  readonly scale: WaveModelVec3Tuple;

  readonly terms?: WaveModelTransformTermsSpace;

}

type WaveModelTransformTermsSpace = WaveTransformTermsSpace;

type WaveModelVec3Tuple = readonly [number, number, number];

interface WaveModelVisualTargetKeyRef {

  readonly id: string;

  readonly kind: WaveModelVisualTargetKind;

}

type WaveModelVisualTargetKind = "mesh" | "part";

interface WaveModelVisualTargetMetadata {

  readonly id: string;

  readonly kind: WaveModelVisualTargetKind;

  readonly materialIndex?: number;

  readonly meshId?: WaveModelMeshId;

  readonly meta?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly partId?: WaveModelPartId;

  readonly slotName?: string;

}

interface WaveMorphTargetInput {

  readonly id: string;

  readonly normalDeltas?: ArrayLike<number>;

  readonly positionDeltas?: ArrayLike<number>;

  readonly tangentDeltas?: ArrayLike<number>;

}

interface WaveMorphTargetPayload {

  readonly id: string;

  readonly normalDeltas?: Float32Array;

  readonly positionDeltas?: Float32Array;

  readonly tangentDeltas?: Float32Array;

}

interface WaveMotionRateIntentActionSurface<TEntity extends object> {

  above(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  atLeast(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  atMost(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  below(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  between(min: number, max: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  do(action: ObservationAction<TEntity>): ObservationHandle;

  enterState(state: unknown): ObservationHandle;

  equals(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  near(value: number, tolerance: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  outside(min: number, max: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

}

type WaveMotionRateIntentBuilder<TEntity extends object> = WaveMotionRateIntentActionSurface<TEntity> & WaveObservationTerminalMethodActions<TEntity>;

interface WaveMotionRateIntentOptions {

  occurrence?: ObservationOccurrenceToken;

  threshold?: number;

  window?: ObservationWindow | null;

}

type WaveMotionSpeedEvaluator = (progress: number) => number;

type WaveMotionSpeedInput = WaveMotionSpeedEvaluator | WaveValueCurveInput;

interface WaveMutableTransform2DMaterializedPose {

  pivot: SerializableVector2;

  placement: Wave2DPlacementBasis;

  position: SerializableVector2;

  rotationDegrees: number;

  scale: SerializableVector2;

}

interface WaveMutableVector2 {

  x: number;

  y: number;

}

interface WaveNamedRangeLike {

  readonly name: string;

}

interface WaveNative2DConstructionOptions {

  readonly [WAVE_NATIVE_2D_CONSTRUCTION]: true;

  readonly headless?: boolean;

}

interface WaveNativeSpeechRecognitionErrorEvent {

  readonly AT_TARGET: 2;

  readonly bubbles: boolean;

  readonly BUBBLING_PHASE: 3;

  readonly cancelable: boolean;

  cancelBubble: boolean;

  readonly CAPTURING_PHASE: 1;

  readonly composed: boolean;

  composedPath(): unknown[];

  readonly currentTarget: unknown | null;

  readonly defaultPrevented: boolean;

  readonly eventPhase: number;

  initEvent(type: string, bubbles?: boolean, cancelable?: boolean): void;

  readonly isTrusted: boolean;

  readonly NONE: 0;

  preventDefault(): void;

  returnValue: boolean;

  readonly srcElement: unknown | null;

  stopImmediatePropagation(): void;

  stopPropagation(): void;

  readonly target: unknown | null;

  readonly timeStamp: number;

  readonly type: string;

  error: string;

}

type WaveNavClearanceInput = WaveSpatial3DObject | WaveNavClearanceSpec;

interface WaveNavClearanceSpec {

  readonly height?: number;

  readonly maxSlopeDegrees?: number;

  readonly maxStepHeight?: number;

  readonly radius?: number;

}

interface WaveNavCompiledRoute {

  readonly bindings: WaveNavRouteBindings;

  readonly recipe: WaveNavRouteRecipe;

}

interface WaveNavObstacleGroupInput {

  getAABB?(): { min: Vector3; max: Vector3; }

  readonly members?: readonly WaveSpatial3DObject[];

  toArray?(): readonly WaveSpatial3DObject[];

}

type WaveNavObstacleInput = WaveSpatial3DObject | WaveNavObstacleGroupInput | readonly WaveNavObstacleInput[];

type WaveNavPathBatchConfigure = (path: WaveNavSpaceHandle, index: number) => void;

declare class WaveNavPathBatchHandle {

  add(name: string, configure: WaveNavPathBatchConfigure): this;

  dispose(): void;

  readonly id: string;

  outputPaths(): readonly waveNavPath[];

  refreshSurface(): this;

}

type WaveNavPathFailureReason = "missingStart" | "missingEnd" | "surfaceProjectionFailed" | "unsupportedBackend" | "recastRuntimeMissing" | "babylonSceneMissing" | "surfaceMeshUnavailable" | "navmeshBuildFailed" | "pathNotFound" | "obstacleShapeUnsupported" | "rangeShapeUnsupported" | "clearanceRequiresNavmeshBackend";

interface WaveNavPathMetadata {

  readonly computedAtMs: number;

  readonly failureReason: WaveNavPathFailureReason | undefined;

  readonly navHandleId: string;

  readonly sourceSignature: string | undefined;

  readonly status: WaveNavPathStatus;

  readonly version: number;

}

type WaveNavPathPointProvider = WavePathSampleProvider;

type WaveNavPathStatus = "ready" | "unreachable" | "invalid";

type WaveNavPointInput = WaveSpatial3DObject | WavePointInput;

type WaveNavRangeInput = WaveRange | string;

interface WaveNavRecastRuntime {

  readonly NavMesh: new () => object;

  readonly rcConfig: new () => object;

  readonly Vec3: new (...values: number[]) => { x: number; y: number; z: number; }

}

interface WaveNavRouteBindings {

  readonly clearances?: Readonly<Record<string, WaveSpatial3DObject>>;

  readonly obstacles?: Readonly<Record<string, WaveNavObstacleInput>>;

  readonly paths?: Readonly<Record<string, WaveNavPathPointProvider>>;

  readonly points?: Readonly<Record<string, WaveNavPointInput>>;

  readonly ranges?: Readonly<Record<string, WaveRange>>;

  readonly surface?: WaveNavSurfaceInput;

}

type WaveNavRouteClearanceRecipe = ({ readonly kind: "spec"; } & WaveNavClearanceSpec) | { readonly kind: "binding"; readonly key: string; }

type WaveNavRoutePointRecipe = { readonly kind: "literal"; readonly x: number; readonly y: number; readonly z: number; } | { readonly kind: "binding"; readonly key: string; }

type WaveNavRouteRangeRecipe = { readonly kind: "namedRange"; readonly name: string; } | { readonly kind: "binding"; readonly key: string; }

interface WaveNavRouteRecipe {

  readonly clearance?: WaveNavRouteClearanceRecipe;

  readonly directOnly?: boolean;

  readonly maximalSlopeDegrees?: number;

  readonly obstacleBindings?: readonly string[];

  readonly ranges?: readonly WaveNavRouteRangeRecipe[];

  readonly route: WaveNavRouteSourceRecipe;

  readonly smooth?: WaveNavSmoothOptions;

}

type WaveNavRouteSourceRecipe = { readonly kind: "points"; readonly points: readonly WaveNavRoutePointRecipe[]; } | { readonly kind: "pathBinding"; readonly key: string; }

interface WaveNavSmoothOptions {

  readonly samples?: number;

  readonly tension?: number;

}

declare class WaveNavSpaceHandle {

  addWaypoint(point: WaveNavPointInput): this;

  avoidObstacle(source: WaveNavObstacleInput): this;

  avoidRange(range: WaveNavRangeInput): this;

  clearWaypoints(): this;

  compileRoute(): WaveNavCompiledRoute;

  dispose(): void;

  from(source: WaveNavPointInput): this;

  heightClearance(sourceOrSpec: WaveNavClearanceInput): this;

  readonly id: string;

  insertWaypoint(index: number, point: WaveNavPointInput): this;

  get isDisposed(): boolean;

  maximalSlope(degrees: number): this;

  navOnSurface(surface: WaveNavSurfaceInput): this;

  onlyIfDirectlyReachable(): this;

  outputPath(): waveNavPath;

  refreshSurface(): this;

  removeObstacle(source: WaveNavObstacleInput): this;

  removeRange(range: WaveNavRangeInput): this;

  removeWaypoint(pointOrIndex: WaveNavPointInput | number): this;

  setRoute(recipe: WaveNavRouteRecipe, bindings?: WaveNavRouteBindings): this;

  smooth(options?: WaveNavSmoothOptions): this;

  straight(): this;

  throughPath(path: WaveNavPathPointProvider): this;

  throughPoints(points: readonly WaveNavPointInput[]): this;

  to(target: WaveNavPointInput): this;

}

type WaveNavSurfaceInput = WaveTerrainSurface | WaveMeshSurfaceSource;

interface WaveNoirProfileOptions {

  blackAndWhite?: number;

  contrast?: number;

  exposure?: number;

  grainAnimated?: boolean;

  grainIntensity?: number;

  sharpenColorAmount?: number;

  sharpenEdgeAmount?: number;

  vignetteBlendMode?: ImageProcessingOptions["vignetteBlendMode"];

  vignetteColor?: ImageProcessingOptions["vignetteColor"];

  vignetteWeight?: number;

}

interface WaveNoiseValueExpr {

  readonly amplitude?: WaveValueExpr;

  readonly frequency?: WaveValueExpr;

  readonly input: WaveValueExpr;

  readonly seed?: WaveValueExpr;

  readonly type: "noise";

}

interface WaveNoteOnOptions {

  busName?: string;

  durationMs?: number;

  onComplete?: () => void;

  onStart?: () => void;

  spatial?: boolean;

  velocity?: number;

}

type WaveNumberAuthoringInput = number | WaveValueExpr | WaveNumberRef;

declare class WaveNumberParamBuilder<TValue extends number | null = number> implements WaveParamBuilder<TValue> {

  constructor(spec?: WaveParamSpec<TValue>);

  atLeast(min: number): WaveNumberParamBuilder<TValue>;

  atMost(max: number): WaveNumberParamBuilder<TValue>;

  between(min: number, max: number): WaveNumberParamBuilder<TValue>;

  default(value: number): WaveNumberParamBuilder<number>;

  describedAs(description: string): WaveNumberParamBuilder<TValue>;

  integer(enabled?: boolean): WaveNumberParamBuilder<TValue>;

  optional(): WaveNumberParamBuilder<number | null>;

  toSpec(): WaveParamSpec<TValue>;

}

interface WaveNumberRef {

  readonly kind: "number";

  toExpr(): WaveValueExpr;

  toJSON(): WaveValueExpr;

  abs(): WaveNumberRef;

  add(value: WaveNumberAuthoringInput): WaveNumberRef;

  clamp(min: WaveNumberAuthoringInput, max: WaveNumberAuthoringInput): WaveNumberRef;

  cos(): WaveNumberRef;

  decay(deltaSeconds: WaveNumberAuthoringInput, rate: WaveNumberAuthoringInput): WaveNumberRef;

  div(value: WaveNumberAuthoringInput): WaveNumberRef;

  exp(): WaveNumberRef;

  falloff(options: WaveValueFalloffOptions): WaveNumberRef;

  frac(): WaveNumberRef;

  lerp(to: WaveNumberAuthoringInput, amount: WaveNumberAuthoringInput): WaveNumberRef;

  max(value: WaveNumberAuthoringInput): WaveNumberRef;

  min(value: WaveNumberAuthoringInput): WaveNumberRef;

  mul(value: WaveNumberAuthoringInput): WaveNumberRef;

  negate(): WaveNumberRef;

  noise(options?: WaveValueNoiseOptions): WaveNumberRef;

  noise01(options?: Omit<WaveValueNoiseOptions, "amplitude">): WaveNumberRef;

  oneMinus(): WaveNumberRef;

  pow(exponent: WaveNumberAuthoringInput): WaveNumberRef;

  remap(inputMin: WaveNumberAuthoringInput, inputMax: WaveNumberAuthoringInput, outputMin?: WaveNumberAuthoringInput, outputMax?: WaveNumberAuthoringInput): WaveNumberRef;

  round(): WaveNumberRef;

  saturate(): WaveNumberRef;

  sin(): WaveNumberRef;

  smoothstep(edge0: WaveNumberAuthoringInput, edge1: WaveNumberAuthoringInput): WaveNumberRef;

  sqrt(): WaveNumberRef;

  step(edge: WaveNumberAuthoringInput): WaveNumberRef;

  sub(value: WaveNumberAuthoringInput): WaveNumberRef;

  through(curve: WaveValueCurveInput): WaveNumberRef;

}

type WaveNumberValueInput = number | readonly [number, number] | WaveValueExpr;

interface WaveNumericObservationSource<TEntity extends object> {

  above(value: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  atLeast(value: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  atMost(value: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  below(value: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  between(min: number, max: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  equals(value: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  near(value: number, tolerance: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

  outside(min: number, max: number, occurrence?: ObservationOccurrenceToken): WaveObservationTerminalBuilder<TEntity>;

}

type WaveObjectConstructionArgs<TDomain extends WaveSpatialDomain> = [ TDomain ] extends ["2d"] ? [options: WaveNative2DConstructionOptions] : [options?: { readonly headless?: boolean; }];

type WaveObjectSnapshotInput<TDomain extends WaveSpatialDomain, TSnapshot extends object> = [TDomain] extends ["3d"] ? TSnapshot : never;

type WaveObjectTransform<TDomain extends WaveSpatialDomain> = [ TDomain ] extends ["3d"] ? cmp_transform : undefined;

interface WaveObservationTerminalActionSurface<TEntity extends object> {

  do(action: ObservationAction<TEntity>): ObservationHandle;

  enterState(state: unknown): ObservationHandle;

}

type WaveObservationTerminalBuilder<TEntity extends object> = WaveObservationTerminalActionSurface<TEntity> & WaveObservationTerminalMethodActions<TEntity>;

type WaveObservationTerminalMethodActions<TEntity extends object> = { [methodName: string]: (...args: unknown[]) => ObservationHandle; }

declare class WaveOcclusionCulling {

  applyToEntity(entity: WaveEntity, options?: OcclusionCullingOptions): this;

  disable(): this;

  enable(options?: OcclusionCullingOptions): this;

  get enabled(): boolean;

  excludeByName(...names: string[]): this;

  getConfig(): Readonly<SceneOcclusionConfig> | null;

  maxDistance(distance: number): this;

  maxQueriesPerFrame(limit: number): this;

  minVertexCount(count: number): this;

  removeFromEntity(entity: WaveEntity): this;

  strictForStatic(enabled?: boolean): this;

}

interface WaveOrient2DOptions {

  readonly withTolerance?: number;

}

interface WaveOrientOptions {

  byLocking?: DirectionInput;

  withTolerance?: number;

}

interface WaveOutcomeMemoryOptions {

  includeInDecisionChoice?: boolean;

  includeInReplies?: boolean;

  maxOutcomes?: number;

}

interface WaveParamBuilder<TValue extends WaveParamValue = WaveParamValue> {

  toSpec(): WaveParamSpec<TValue>;

}

type WaveParamInput<TValue extends WaveParamValue = WaveParamValue> = WaveParamSpec<TValue> | WaveParamBuilder<TValue>;

type WaveParamKind = "text" | "number" | "boolean" | "choice";

type WaveParamSchemaInput = Record<string, WaveParamInput>;

type WaveParamsFor<TSchema extends WaveParamSchemaInput> = { readonly [TKey in keyof TSchema]: TSchema[TKey] extends WaveParamInput<infer TValue> ? TValue : never; }

interface WaveParamSpec<TValue extends WaveParamValue = WaveParamValue> {

  readonly choices?: readonly string[];

  readonly default?: Exclude<TValue, null>;

  readonly description?: string;

  readonly integer?: boolean;

  readonly kind: WaveParamKind;

  readonly max?: number;

  readonly maxLength?: number;

  readonly min?: number;

  readonly minLength?: number;

  readonly required?: boolean;

}

type WaveParamSpecRecord = Record<string, WaveParamSpec>;

type WaveParamValue = string | number | boolean | null;

interface WavePartGraphPoseController {

  applyCurrentPose(options?: VisualModelPoseApplyOptions): this;

  applyPoseValues(values: Readonly<Record<string, WaveModelPoseValue>>, options?: VisualModelPoseApplyOptions): this;

  applyScalarJointBuffer(jointIds: readonly string[], values: Float64Array, options?: VisualModelPoseApplyOptions): this;

  applySnapshot(presetIdOrName: string, options?: VisualModelPoseApplyOptions): this;

  capturePoseSnapshot(name?: string, options?: VisualModelPoseApplyOptions): WaveModelRigPoseSnapshotMetadata;

  clearCache(): void;

  createPreviewPoseValues(elapsedMs: number): Readonly<Record<string, WaveModelPoseValue>>;

  evaluateAnchorPose(anchorRef: string, options?: VisualModelPoseApplyOptions): WaveModelAnchorPoseSnapshot | null;

  getBindWorldPoseByPartId(options?: VisualModelPoseApplyOptions): Readonly<Record<string, WaveModelRigTransformSnapshot>>;

  getEvaluationGraph(options?: VisualModelPoseApplyOptions): WaveModelRigGraphMetadata;

  getExplicitPoseValues(): Readonly<Record<string, WaveModelPoseValue>>;

  getPoseSnapshotClips(): readonly WaveModelRigPoseClipMetadata[];

  getPoseSnapshots(): readonly WaveModelRigPoseSnapshotMetadata[];

  readonly graphMetadata: WaveModelRigGraphMetadata | undefined;

  listJointControls(query?: string): readonly WaveModelJointControlInfo[];

  listJoints(query?: string): readonly WaveModelJointMetadata[];

  preview(elapsedMs: number, options?: VisualModelPosePreviewOptions): Readonly<Record<string, WaveModelPoseValue>>;

  refresh(options?: VisualModelPoseApplyOptions): this;

  resetPose(options?: VisualModelPoseApplyOptions): this;

  resolvePoseValues(options?: VisualModelPoseApplyOptions): Readonly<Record<string, WaveModelPoseValue>>;

  samplePoseClip(clip: WaveModelRigPoseClipMetadata, elapsedMs: number): Readonly<Record<string, WaveModelPoseValue>>;

  setJointValue(jointIdOrName: string, value: WaveModelPoseValue, options?: VisualModelPoseApplyOptions): this;

}

interface WavePartIKAnimationHost {

  readonly owner: WavePartIKOwner;

  transitionAnimation<State extends Record<string, number>>(gameObject: WaveEntity | { name: string; }, initialState: State, targetState: State, applyState: (state: State) => void, options: { duration: number; ease?: WaveEasing; progressCurve?: WaveValueCurveInput; animationName?: string; startDelay?: number; onStart?: (controller: WaveAnimationController) => void; onComplete?: (controller: WaveAnimationController) => void; onUpdate?: (controller: WaveAnimationController, state: State) => void; onLoopComplete?: (loopCount: number, controller: WaveAnimationController) => void; }): TransitionLifecycleHandle<State>;

  readonly visual: cmp_visual3DModel;

}

type WavePartIKOwner = WaveEntity & { readonly transform: cmp_transform; }

interface WavePartMassModelConfig {

  readonly autoCenterOfMass?: boolean;

  readonly autoInertia?: boolean;

  readonly defaultDensity?: number;

  readonly partDensities?: Readonly<Record<string, number>>;

  readonly source: WaveModelMassPartSource;

  readonly strict?: boolean;

  readonly volume: WaveModelMassVolumeSource;

}

interface WavePartPoseClipConfig {

  readonly allowMimicOverrides?: boolean;

  readonly clamp?: boolean;

  readonly createParts?: boolean;

  readonly duration: number;

  readonly keyframes: readonly WavePartPoseClipKeyframe[];

}

interface WavePartPoseClipKeyframe {

  readonly easing?: WaveModelSnapshotClipEasing;

  readonly time: number;

  readonly values: Readonly<Record<string, WaveModelPoseValue>>;

}

type WavePathArcOptions = WavePathPlanarShapeOptions & { readonly radius: number; readonly startAngleRadians?: number; readonly endAngleRadians?: number; readonly sampleSegments?: number; }

interface WavePathArcSegmentDefinition {

  center: Vector3Like;

  clockwise?: boolean;

  kind: "arc";

  normal?: Vector3Like;

  samples?: number;

  to: Vector3Like;

}

interface WavePathAvoidOptions {

  readonly clearance?: number | undefined;

}

declare class WavePathBlendAnimationBuilder {

  after(duration: WaveTimeSpan): this;

  after(value: number, unit: WaveTimeUnit): this;

  closed(): this;

  loop(enabled?: boolean): this;

  open(): this;

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  pingPong(enabled?: boolean): this;

  play(): TransitionLifecycleHandle<ValueDriveState>;

  toInput(): WavePathBlendAnimationInput;

  toRuntimeBindings(): WavePathBlendAnimationRuntimeBindings;

  withProgressCurve(curve: WaveValueCurveInput): this;

  withSampleCount(sampleCount: number): this;

}

interface WavePathBlendAnimationInput {

  readonly closed?: boolean | undefined;

  readonly sampleCount?: number | undefined;

  readonly delay?: WaveTimeSpanSpec;

  readonly duration: WaveTimeSpanSpec;

  readonly loopMode?: WaveLoopMode;

  readonly progressCurve?: WaveValueCurveSpec;

}

interface WavePathBlendAnimationRuntimeBindings {

  readonly target: wavePath;

}

interface WavePathBlendToOptions {

  readonly closed?: boolean;

  readonly sampleCount?: number;

}

interface WavePathCatmullRomModeOptions {

  readonly closed?: boolean;

  readonly sampleSegments?: number;

  readonly tension?: number;

}

type WavePathCircleOptions = WavePathPlanarShapeOptions & { readonly radius: number; readonly sampleSegments?: number; }

interface WavePathConstructionOptions {

  readonly visualize?: boolean;

}

interface WavePathCreateCommonOptions {

  readonly closed?: boolean;

  readonly coordinateSpace?: WaveGeometryCoordinateSpace;

  readonly renderPointCapacity?: number;

}

type WavePathCreateOptions = WavePathCreateCommonOptions & WavePathCurveAuthoringOptions;

interface WavePathCubicBezierSegmentDefinition {

  control1: Vector3Like;

  control2: Vector3Like;

  kind: "cubicBezier";

  samples?: number;

  to: Vector3Like;

}

type WavePathCurveAuthoringOptions = { readonly curveType?: WavePathCurveType.Linear; readonly sampleSegments?: never; readonly tension?: never; } | { readonly curveType: WavePathCurveType.CatmullRom; readonly sampleSegments?: number; readonly tension?: number; }

type WavePathDefinition = CoreWavePathDefinition;

interface WavePathDefinition {

  closed?: boolean;

  samplesPerSegment?: number;

  segments: WavePathDefinitionSegment[];

  start: Vector3Like;

}

type WavePathDefinitionSegment = WavePathLineSegmentDefinition | WavePathCubicBezierSegmentDefinition | WavePathArcSegmentDefinition;

interface WavePathDrawBetweenBindingSlot {

  readonly bindingSlot: number;

}

interface WavePathDrawBetweenInput {

  readonly options?: DrawBetweenOptions;

  readonly pointA: WavePathDrawBetweenPointRecipe;

  readonly pointB: WavePathDrawBetweenPointRecipe;

}

type WavePathDrawBetweenPointRecipe = Vector3Like | WavePathDrawBetweenBindingSlot;

interface WavePathDrawBetweenRangeRecipe {

  readonly clearance?: number | undefined;

  readonly range: WavePathDrawBetweenBindingSlot;

}

interface WavePathDrawBetweenRuntimeBindings {

  readonly paths?: ReadonlyArray<wavePath>;

  readonly points?: ReadonlyArray<PathPointInput>;

  readonly ranges?: ReadonlyArray<WaveRange>;

}

type WavePathEllipseOptions = WavePathPlanarShapeOptions & { readonly radiusX: number; readonly radiusY: number; readonly sampleSegments?: number; }

interface WavePathExtrusionConfig {

  kind: "wavePathExtrusion";

  options?: PathExtrusionOptions;

  path: WavePathExtrusionSerializedPoint[];

  profile: WavePathExtrusionSerializedProfile;

}

type WavePathExtrusionFrameMode = PathOrientationMode;

interface WavePathExtrusionOffsetProgressionInput {

  x?: WavePathExtrusionProgressionInput;

  y?: WavePathExtrusionProgressionInput;

}

type WavePathExtrusionPathInput = CorePathExtrusionPathInput | unknown | PathExtrusionGeometrySourceInput;

type WavePathExtrusionProfileInput = CorePathExtrusionPathInput | unknown | CompoundPathExtrusionProfileInput | PathExtrusionGeometrySourceInput;

type WavePathExtrusionProgressionInput = WaveValueCurve | WaveValueCurveSpec;

interface WavePathExtrusionSerializedPoint {

  x: number;

  y: number;

  z: number;

}

type WavePathExtrusionSerializedProfile = WavePathExtrusionSerializedPoint[] | { outer: WavePathExtrusionSerializedPoint[]; holes?: WavePathExtrusionSerializedPoint[][]; }

type WavePathFixedClosureCreateOptions = Omit<WavePathCreateCommonOptions, "closed">;

type WavePathFromValueCurvesInput = (WavePathValueCurvesInputBase & { readonly kind: "cartesian"; readonly x: WavePathSerializableValueCurve; readonly y: WavePathSerializableValueCurve; readonly z?: WavePathSerializableValueCurve; }) | (WavePathValueCurvesInputBase & { readonly kind: "planar"; readonly plane: WavePathPlaneInput; readonly u: WavePathSerializableValueCurve; readonly v: WavePathSerializableValueCurve; });

type WavePathJoinInput = { readonly path: wavePath; readonly points?: never; readonly coordinateSpace?: never; readonly output: "exact" | "sampled"; readonly closed?: boolean; } | { readonly path?: never; readonly points: ReadonlyArray<PathPointInput>; readonly coordinateSpace: WaveGeometryCoordinateSpace; readonly output: "sampled"; readonly closed?: boolean; }

interface WavePathLinearModeOptions {

  readonly closed?: boolean;

}

type WavePathLineOptions = WavePathFixedClosureCreateOptions;

interface WavePathLineSegmentDefinition {

  kind: "line";

  to: Vector3Like;

}

interface WavePathMarker {

  direction?: WaveValueCurveEvent["direction"];

  distance: number;

  label?: string;

  metric?: WavePathValueCurveMetric;

  point: Vector3;

  progress: number;

  source: WaveValueCurveEvent["source"] | "path";

  tangent: Vector3;

  threshold?: number;

  type: WavePathMarkerType;

  value?: number;

  valueCurveEvent?: WaveValueCurveEvent;

}

interface WavePathMarkerOptions {

  readonly sampleCount?: number | undefined;

  readonly space?: DistanceFieldUnits3D | undefined;

  readonly curvatureThresholds?: readonly number[];

  readonly distanceEvery?: number;

  readonly heightThresholds?: readonly number[];

  readonly includeCurvaturePeaks?: boolean;

  readonly progress?: readonly number[];

  readonly valueCurves?: readonly WavePathValueEventOptions[];

}

interface WavePathMarkerTable {

  domain: "pathProgress";

  format: "wavePath.markers.v1";

  kind: "pathMarkers";

  markers: WavePathMarker[];

  sampleCount: number;

}

type WavePathMarkerType = "progress" | "distance" | "valueCurve";

type WavePathPlanarPlaneOptions = { readonly plane?: WavePathPlaneAxis; readonly normal?: never; } | { readonly plane?: never; readonly normal: DirectionInput; }

type WavePathPlanarShapeOptions = WavePathFixedClosureCreateOptions & WavePathPlanarPlaneOptions & { readonly center?: Vector3Like; }

type WavePathPlaneAxis = WavePlaneValue;

type WavePathPlaneInput = WavePathPlaneAxis | DirectionInput;

type WavePathPolygonOptions = WavePathFixedClosureCreateOptions;

type WavePathPolylineOptions = WavePathCreateOptions;

declare class WavePathProjectedCurveBuilder {

  catmullRom(options?: WavePathCatmullRomModeOptions): this;

  closed(closed?: boolean): this;

  create(): wavePath;

  flipY(sourceHeight?: number): this;

  inLocalSpace(): this;

  inWorldSpace(): this;

  keepY(): this;

  linear(options?: WavePathLinearModeOptions): this;

  open(): this;

  orientXAlong(direction: DirectionInput): this;

  originAt(origin: Vector3Like): this;

  originAt(x: number, y: number, z: number): this;

  projectOnto(normal: DirectionInput): this;

  reserveRenderPointCapacity(renderPointCapacity: number): this;

  toInput(): WavePathProjectedCurveInput;

  withArcSegments(arcSegments: number): this;

  withCurveSegments(curveSegments: number): this;

  withMaxPoints(maxPoints: number): this;

  withSampleSegments(sampleSegments: number): this;

  withScale(scale: number): this;

}

type WavePathProjectedCurveInput = WavePathCreateOptions & { readonly curve: WaveCurve2DInput; readonly normal: DirectionInput; readonly xDirection?: DirectionInput; readonly origin?: Vector3Like; readonly scale?: number; readonly flipY?: boolean; readonly sourceHeight?: number; readonly curveSegments?: number; readonly maxPoints?: number; }

interface WavePathQueryOptions {

  readonly space?: WaveGeometryCoordinateSpace;

}

type WavePathRadialPolygonOptions = WavePathPlanarShapeOptions & { readonly radii: readonly number[]; readonly rotationTurns?: number; }

interface WavePathRangeConstraintInput {

  readonly clearance?: number | undefined;

  readonly range: WaveRange;

}

interface WavePathRangeConstraintOptions {

  readonly clearance?: number;

}

type WavePathRangeInput = WaveRange | WavePathRangeConstraintInput;

type WavePathRangeInputSet = WavePathRangeInput | readonly WavePathRangeInput[];

type WavePathRectangleOptions = WavePathPlanarShapeOptions & { readonly width: number; readonly height: number; }

interface WavePathReference {

  readonly contentHash: string;

  readonly definition: WavePathDefinition;

  readonly id: string;

  readonly sourceRevision?: number;

}

type WavePathRegularPolygonOptions = WavePathPlanarShapeOptions & { readonly sides: number; readonly radius: number; readonly rotationTurns?: number; }

type WavePathSampleProvider = WavePathSampleProviderMetadata & ({ readonly sampledPoints: readonly Vector3[]; sampledPointsToRef?: WavePathSamplesToRef; } | { readonly sampledPoints?: readonly Vector3[]; sampledPointsToRef: WavePathSamplesToRef; });

interface WavePathSampleProviderMetadata {

  readonly pathProviderState?: WavePathSampleProviderState;

  readonly pathRevision?: number;

}

type WavePathSampleProviderState = "active" | "disposed";

type WavePathSamplesToRef = (result: Vector3[], options?: WavePathQueryOptions, spare?: Vector3[]) => Vector3[];

type WavePathSerializableValueCurve = number | WaveValueCurveSpec;

type WavePathSerialized = { readonly kind: "empty"; } | { readonly kind: "definition"; readonly definition: WavePathDefinition; } | { readonly kind: "controlPoints"; readonly points: readonly Vector3Like[]; readonly options: WavePathCreateOptions; }

interface WavePathSnapToOptions {

  readonly space?: DistanceFieldUnits3D | undefined;

  readonly offset?: number;

  readonly sampleCount?: number;

}

interface WavePathSourceHandle {

  readonly current: WavePathSourceProduct;

  dispose(): void;

  readonly disposed: boolean;

  readonly id: string;

  readonly provider: WavePathSampleProvider;

  refresh(): WavePathSourceProduct;

  subscribe(listener: (product: WavePathSourceProduct) => void): () => void;

}

interface WavePathSourceProduct {

  readonly compiled: CompiledWavePathTable;

  readonly reference: WavePathReference;

  readonly revisionKey: string;

}

type WavePathSplitOptions = { readonly progress: number; readonly output: "exact"; readonly sampleCountPerSide?: never; } | { readonly progress: number; readonly output: "sampled"; readonly sampleCountPerSide: number; }

type WavePathSquareOptions = WavePathPlanarShapeOptions & { readonly size: number; }

type WavePathSurfaceAlongAdditionalOptions = Omit<WavePathSurfaceCenterlineOptions, "width">;

type WavePathSurfaceAlongOptions = WavePathSurfaceCenterlineOptions;

interface WavePathSurfaceAuthoringInput {

  toConfig(): WavePathSurfaceConfig;

}

type WavePathSurfaceCapMode = SurfaceRibbonMetadata["cap"];

type WavePathSurfaceCenterlineOptions = SurfacePathCenterlineOptions;

type WavePathSurfaceCenterlineSerializableOptions = Omit<WavePathSurfaceAlongOptions, "heightSource" | "onCenterSample">;

interface WavePathSurfaceCenterlineSourceInput {

  kind: "centerline";

  path: PathSurfaceInput;

}

type WavePathSurfaceConfig = { kind: "wavePathSurface"; source: Extract<WavePathSurfaceSerializedSource, { kind: "rails"; }>; options?: WavePathSurfaceRailsSerializableOptions; } | { kind: "wavePathSurface"; source: Extract<WavePathSurfaceSerializedSource, { kind: "centerline"; }>; options: WavePathSurfaceCenterlineSerializableOptions; }

interface WavePathSurfaceCreateOptions {

  name?: string;

}

interface WavePathSurfaceNoPlaceZoneOptions {

  readonly height?: number | undefined;

  readonly margin?: number | undefined;

  readonly pathPlane?: "xy" | "xz" | "yz" | undefined;

  readonly y?: number | undefined;

  name?: string;

  width?: number;

}

type WavePathSurfaceOptions = WavePathSurfaceRailsOptions | WavePathSurfaceCenterlineOptions;

type WavePathSurfaceOptionsUpdate = Partial<WavePathSurfaceOptions>;

type WavePathSurfaceRailsOptions = SurfacePathRailsOptions;

type WavePathSurfaceRailsSerializableOptions = Omit<WavePathSurfaceRailsOptions, "heightSource">;

interface WavePathSurfaceRailsSourceInput {

  kind: "rails";

  leftPath: PathSurfaceInput;

  rightPath: PathSurfaceInput;

}

type WavePathSurfaceSerializedSource = { kind: "rails"; leftPath: WavePathExtrusionSerializedPoint[]; rightPath: WavePathExtrusionSerializedPoint[]; } | { kind: "centerline"; path: WavePathExtrusionSerializedPoint[]; }

interface WavePathSurfaceSnapOptions {

  offset?: number;

}

type WavePathSurfaceSourceInput = WavePathSurfaceRailsSourceInput | WavePathSurfaceCenterlineSourceInput;

type WavePathTrimOptions = { readonly start: number; readonly end: number; readonly output: "exact"; readonly sampleCount?: never; } | { readonly start: number; readonly end: number; readonly output: "sampled"; readonly sampleCount: number; }

interface WavePathValueCurveBundleOptions {

  readonly sampleCount?: number | undefined;

  readonly space?: DistanceFieldUnits3D | undefined;

  readonly id?: string;

  readonly metrics?: readonly WavePathValueCurveMetric[];

}

type WavePathValueCurveMetric = "x" | "y" | "z" | "distance" | "height" | "curvature" | "slope" | "verticality";

interface WavePathValueCurveOptions {

  readonly space?: DistanceFieldUnits3D | undefined;

  readonly sampleCount?: number;

}

type WavePathValueCurvesInputBase = WavePathCreateOptions & { readonly sampleCount?: number; readonly origin?: Vector3Like; }

interface WavePathValueEventOptions {

  readonly events: WaveValueCurveEventOptions;

  readonly metric: WavePathValueCurveMetric;

}

interface WavePbrModifierApplicationOptions {

  readonly enabled?: boolean;

  readonly id?: string;

  readonly inputs?: WavePbrModifierInputBindings;

  readonly order?: number;

  readonly parameters?: WavePbrModifierParameterValues;

}

interface WavePbrModifierColorOutput {

  readonly blend: Exclude<WavePbrModifierBlend, "normalBlend">;

  readonly channel: "baseColor" | "emissive";

  readonly value: WaveColorFieldRef;

}

interface WavePbrModifierNormalOutput {

  readonly blend: "replace" | "mix" | "normalBlend";

  readonly channel: "normal";

  readonly value: WaveNormalFieldRef;

}

interface WavePbrModifierScalarOutput {

  readonly blend: Exclude<WavePbrModifierBlend, "normalBlend">;

  readonly channel: "roughness" | "metallic" | "ao" | "opacity" | "coverage";

  readonly value: WaveScalarFieldRef;

}

interface WavePbrModifierSurfaceStateInputBinding {

  readonly kind: "surfaceState";

  readonly state: WaveScalarSurfaceStateRef;

}

interface WavePBRReliefIntent {

  readonly addressMode?: "clamp" | "repeat";

  readonly heightTexture: string;

  readonly quality?: WavePBRReliefQuality;

  readonly scale: number;

  readonly selfShadow?: boolean;

  readonly silhouette?: boolean;

}

type WavePBRReliefQuality = "low" | "balanced" | "high" | "adaptive";

interface WavePhysicalEquipmentAttachPose {

  readonly rotations?: readonly WavePhysicalEquipmentAttachRotation[];

  readonly translations?: readonly WavePhysicalEquipmentAttachTranslation[];

}

interface WavePhysicalEquipmentAttachRotation {

  readonly axis: SerializedDirectionInput;

  readonly degrees: number;

}

interface WavePhysicalEquipmentAttachTranslation {

  readonly direction: SerializedDirectionInput;

  readonly distance: number;

}

interface WavePhysicalEquipmentBodyDefinition {

  readonly angularDamping?: number;

  readonly friction?: number;

  readonly linearDamping?: number;

  readonly mass?: number;

  readonly restitution?: number;

}

type WavePhysicalEquipmentColliderKind = "box" | "sphere" | "capsule" | "cylinder";

interface WavePhysicalEquipmentCollisionDefinition {

  readonly foreignRigs?: "collide" | "ignore";

  readonly ownerRig?: "collide" | "ignore";

}

interface WavePhysicalEquipmentConstraintDefinition {

  readonly perpendicularAxis: SerializedDirectionInput;

  readonly primaryAxis: SerializedDirectionInput;

  readonly targetPerpendicularAxis: SerializedDirectionInput;

  readonly targetPrimaryAxis: SerializedDirectionInput;

}

interface WavePhysicalEquipmentMountDefinition<TEntityId extends string = string> {

  readonly attachPose?: WavePhysicalEquipmentAttachPose;

  readonly body?: WavePhysicalEquipmentBodyDefinition;

  readonly bodyEntityId: TEntityId;

  readonly collider?: WavePhysicalEquipmentColliderKind;

  readonly collision?: WavePhysicalEquipmentCollisionDefinition;

  readonly constraint: WavePhysicalEquipmentConstraintDefinition;

  readonly model: string;

  readonly name: string;

  readonly scale?: number;

}

type WavePhysicsBackendForOwner<TOwner> = TOwner extends { readonly physicsBody: cmp_physicsBody; } ? "rigidBody" : TOwner extends { readonly kinematicController: cmp_kinematicController; } ? "kinematicController" : "auto";

type WavePhysicsBackendKind = "none" | "rigidBody" | "kinematicController";

type WavePhysicsBackendSelection = "auto" | "rigidBody" | "kinematicController";

declare class WavePhysicsBodyFluidDomainBuilder<TBody extends cmp_physicsBody = cmp_physicsBody> {

  constructor(_body: TBody);

  apply(): TBody;

  openBoundary(...directions: readonly DirectionInput[]): this;

}

declare class WavePhysicsBodyFluidFlowBuilder<TBody extends cmp_physicsBody = cmp_physicsBody> {

  constructor(body: TBody, id: string);

  apply(): WavePhysicsBodyFluidFlowHandle<TBody>;

  atFlowRate(volumePerSecond: number): this;

  atSpeed(unitsPerSecond: number): this;

  drainInto(range: WaveRange): this;

  from(range: WaveRange): this;

  recycle(): this;

  toward(direction: DirectionInput): this;

  withSeed(seed: number): this;

}

declare class WavePhysicsBodyFluidFlowHandle<TBody extends cmp_physicsBody = cmp_physicsBody> {

  constructor(body: TBody, id: string);

  get enabled(): boolean;

  readonly id: string;

  pause(): this;

  remove(): TBody;

  reset(): this;

  resume(): this;

  toggle(): this;

}

declare class WavePhysicsBodyPathPinBuilder<TBody> {

  constructor(_executor: PhysicsBodyPinAuthoringExecutor<TBody>, _path: PhysicsBodyPinPathInput);

  evenly(sampleCount: number): TBody;

}

declare class WavePhysicsBodyPinBuilder<TBody> {

  constructor(_executor: PhysicsBodyPinAuthoringExecutor<TBody>, _selections: readonly PhysicsBodyPinSelectionInput[]);

  inFrameOf(target: TransformReferenceLike): TBody;

  inLocalFrame(): TBody;

}

interface WavePhysicsBodyProperties {

  angularDamping: number | null;

  angularInertia: Vector3Like | null;

  backendKind: WavePhysicsBackendKind;

  collisionGroup: number | null;

  collisionMask: number | null;

  density: number | null;

  gravityFactor: number | null;

  linearDamping: number | null;

  mass: number | null;

  motionKind: WavePhysicsMotionKind;

  spatialVolume: number | null;

}

interface WavePhysicsBodyPropertyInput {

  angularDamping?: number;

  angularInertia?: Vector3Like | number;

  collisionGroup?: number;

  collisionMask?: number;

  gravityFactor?: number;

  linearDamping?: number;

  mass?: number;

}

type WavePhysicsConstantForceBuilder = WaveRigidBodyConstantForceBuilder<cmp_physicsBody> | WaveKinematicConstantForceBuilder<cmp_kinematicController>;

type WavePhysicsConstantForceBuilderFor<TBackend extends WavePhysicsBackendSelection> = TBackend extends "rigidBody" ? WaveRigidBodyConstantForceBuilder<cmp_physicsBody> : TBackend extends "kinematicController" ? WaveKinematicConstantForceBuilder<cmp_kinematicController> : WavePhysicsConstantForceBuilder;

type WavePhysicsConstantForceConfig = ConstantForceConfig | KinematicConstantForceConfig;

type WavePhysicsConstantForceConfigFor<TBackend extends WavePhysicsBackendSelection> = TBackend extends "rigidBody" ? ConstantForceConfig : TBackend extends "kinematicController" ? KinematicConstantForceConfig : WavePhysicsConstantForceConfig;

type WavePhysicsConstantForceEntry = ConstantForceEntry | KinematicConstantForceEntry;

type WavePhysicsConstantForceEntryFor<TBackend extends WavePhysicsBackendSelection> = TBackend extends "rigidBody" ? ConstantForceEntry : TBackend extends "kinematicController" ? KinematicConstantForceEntry : WavePhysicsConstantForceEntry;

type WavePhysicsConstantForceOptions = ConstantForceOptions | KinematicConstantInfluenceOptions;

type WavePhysicsConstantForceOptionsFor<TBackend extends WavePhysicsBackendSelection> = TBackend extends "rigidBody" ? ConstantForceOptions : TBackend extends "kinematicController" ? KinematicConstantInfluenceOptions : WavePhysicsConstantForceOptions;

type WavePhysicsConstantTorqueBuilder = WaveRigidBodyConstantTorqueBuilder<cmp_physicsBody> | WaveKinematicConstantTorqueBuilder<cmp_kinematicController>;

type WavePhysicsConstantTorqueBuilderFor<TBackend extends WavePhysicsBackendSelection> = TBackend extends "rigidBody" ? WaveRigidBodyConstantTorqueBuilder<cmp_physicsBody> : TBackend extends "kinematicController" ? WaveKinematicConstantTorqueBuilder<cmp_kinematicController> : WavePhysicsConstantTorqueBuilder;

type WavePhysicsConstantTorqueConfig = ConstantTorqueConfig | KinematicConstantTorqueConfig;

type WavePhysicsConstantTorqueConfigFor<TBackend extends WavePhysicsBackendSelection> = TBackend extends "rigidBody" ? ConstantTorqueConfig : TBackend extends "kinematicController" ? KinematicConstantTorqueConfig : WavePhysicsConstantTorqueConfig;

type WavePhysicsConstantTorqueEntry = ConstantTorqueEntry | KinematicConstantTorqueEntry;

type WavePhysicsConstantTorqueEntryFor<TBackend extends WavePhysicsBackendSelection> = TBackend extends "rigidBody" ? ConstantTorqueEntry : TBackend extends "kinematicController" ? KinematicConstantTorqueEntry : WavePhysicsConstantTorqueEntry;

type WavePhysicsConstantTorqueOptions = ConstantTorqueOptions | KinematicConstantInfluenceOptions;

type WavePhysicsConstantTorqueOptionsFor<TBackend extends WavePhysicsBackendSelection> = TBackend extends "rigidBody" ? ConstantTorqueOptions : TBackend extends "kinematicController" ? KinematicConstantInfluenceOptions : WavePhysicsConstantTorqueOptions;

type WavePhysicsContactPointInput = RigidBodyContactPointInput;

interface WavePhysicsContactStatus {

  bodies: wave3DObject[];

  contactCount: number;

  maxContacts: number;

  monitorEnabled: boolean;

}

interface WavePhysicsKinematicTuning {

  acceleration: number;

  dynamicFriction: number;

  externalAirDamping: number;

  externalAngularDamping: number;

  externalGroundDamping: number;

  gravityMultiplier: number;

  keepContactTolerance: number;

  keepDistance: number;

  mass: number;

  maxAcceleration: number;

  maxCastIterations: number;

  maxSlopeAngle: number;

  penetrationRecoverySpeed: number;

  pushStrength: number;

  staticFriction: number;

}

type WavePhysicsKinematicTuningInput = Partial<WavePhysicsKinematicTuning>;

interface WavePhysicsMaterialInput {

  dynamicFriction?: number;

  friction?: number;

  restitution?: number;

  staticFriction?: number;

}

interface WavePhysicsMaterialProperties {

  dynamicFriction: number | null;

  friction: number | null;

  restitution: number | null;

  restitutionSupported: boolean;

  staticFriction: number | null;

}

type WavePhysicsMotionKind = "none" | "dynamicRigidBody" | "kinematicRigidBody" | "staticRigidBody" | "kinematicController";

declare class WavePhysicsRigChainBuilder<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  constructor(_batch: WavePhysicsRigJointBatch<T>, _children: readonly T[], _parent: T);

  apply(options?: WavePhysicsRigOptions): WaveModelPhysicsRig;

  around(axis: DirectionInput): this;

  asHingeChain(): this;

  asLockChain(): this;

  asLooseTail(): this;

  asSliderChain(): this;

  at(location: WavePhysicsRigJointLocation): this;

  chain(firstChild: T, ...moreChildren: T[]): WavePhysicsRigChainTargetBuilder<T>;

  fromCurrentPose(): WavePhysicsRigJointBatch<T>;

  joint(child: T, ...moreChildren: T[]): WavePhysicsRigJointTargetBuilder<T>;

  limitAngleDegrees(lower: number, upper: number): this;

  limitAngleRadians(lower: number, upper: number): this;

  limitLinearTravel(lower: number, upper: number): this;

  withDamping(damping: number): this;

  withEffort(effort: number): this;

}

declare class WavePhysicsRigChainTargetBuilder<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  constructor(_batch: WavePhysicsRigJointBatch<T>, _children: readonly T[]);

  to(parent: T): WavePhysicsRigChainBuilder<T>;

}

interface WavePhysicsRigDisablePhysicsOptions {

  clearDeferredOps?: boolean | undefined;

  clearPendingRebuild?: boolean | undefined;

  preserveConstraintConfig?: boolean | undefined;

  reason?: PhysicsParticipationDisableReason | undefined;

  snapshotMotion?: boolean | undefined;

}

declare class WavePhysicsRigDynamicBodyTargetBuilder<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  constructor(_driver: WavePhysicsRigDynamicDriveBuilder<T>, _body: T);

  apply(deltaTime?: number): WavePhysicsRig<T>;

  between(start: WavePhysicsRigKinematicPointTarget, end: WavePhysicsRigKinematicPointTarget): WavePhysicsRigDynamicSegmentTargetBuilder<T>;

  body(body: T): WavePhysicsRigDynamicBodyTargetBuilder<T>;

  followRotation(rotation: Quaternion): this;

  moveTo(target: WavePhysicsRigKinematicPointTarget): this;

  moveTo(x: number, y: number, z: number): this;

  rotateTo(rotation: Quaternion): this;

  withAngularDamping(angularDamping: number): this;

  withDamping(damping: number): this;

  withMaxForce(maxForce: number): this;

  withMaxTorque(maxTorque: number): this;

  withPositionStrength(positionStrength: number): this;

  withRotationStrength(rotationStrength: number): this;

  withStrength(strength: number): this;

}

declare class WavePhysicsRigDynamicDriveBuilder<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  constructor(_rig: WavePhysicsRig<T>, options?: WavePhysicsRigDynamicDriveOptions);

  apply(deltaTime?: number): WavePhysicsRig<T>;

  body(body: T): WavePhysicsRigDynamicBodyTargetBuilder<T>;

  clear(): this;

  dispose(): void;

  ensureTransformTarget(body: T): MutableWavePhysicsRigDynamicTransformTarget<T>;

  inFrameOf(target: TransformReferenceLike): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inParentTerms(depth?: number): this;

  inRigFrame(): this;

  inRigTerms(): this;

  inWorldFrame(): this;

  inWorldTerms(): this;

  resetHistory(): this;

  setSegmentTarget(body: T, start: WavePhysicsRigKinematicPointTarget, end: WavePhysicsRigKinematicPointTarget): WavePhysicsRigDynamicSegmentTargetBuilder<T>;

  stopDriving(body: T): boolean;

  withAngularDamping(angularDamping: number): this;

  withDamping(damping: number): this;

  withMaxForce(maxForce: number): this;

  withMaxTorque(maxTorque: number): this;

  withOutputFilter(filter: WavePhysicsRigDynamicDriveFilter<T> | null): this;

  withPositionStrength(positionStrength: number): this;

  withRotationStrength(rotationStrength: number): this;

  withStrength(strength: number): this;

}

type WavePhysicsRigDynamicDriveFilter<T extends WavePhysicsRigPart = WavePhysicsRigPart> = (body: T, force: Vector3, angularAcceleration: Vector3, deltaTime: number) => void;

interface WavePhysicsRigDynamicDriveOptions {

  readonly angularDamping?: number;

  readonly damping?: number;

  readonly maxForce?: number;

  readonly maxTorque?: number;

  readonly positionStrength?: number;

  readonly rotationStrength?: number;

  readonly strength?: number;

}

interface WavePhysicsRigDynamicDriveTargetMemory {

  hasPosition: boolean;

  hasRotation: boolean;

  readonly position: Vector3;

  readonly rotation: Quaternion;

}

declare class WavePhysicsRigDynamicSegmentTargetBuilder<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  constructor(_driver: WavePhysicsRigDynamicDriveBuilder<T>, _target: MutableWavePhysicsRigDynamicSegmentTarget<T>);

  along(axis: DirectionInput): this;

  apply(deltaTime?: number): WavePhysicsRig<T>;

  body(body: T): WavePhysicsRigDynamicBodyTargetBuilder<T>;

  withAngularDamping(angularDamping: number): this;

  withDamping(damping: number): this;

  withHeading(reference: TransformReferenceLike, axis?: DirectionInput): this;

  withHeadingDirection(axis: DirectionInput): this;

  withMaxForce(maxForce: number): this;

  withMaxTorque(maxTorque: number): this;

  withPositionStrength(positionStrength: number): this;

  withRotationStrength(rotationStrength: number): this;

  withStrength(strength: number): this;

}

interface WavePhysicsRigEnablePhysicsOptions {

  readonly childBodyMode?: WaveModelPhysicsChildBodyMode | undefined;

  readonly debugLog?: boolean | undefined;

  readonly defaultAngularDamping?: number | undefined;

  readonly defaultEnableCollisions?: boolean | undefined;

  readonly defaultLinearDamping?: number | undefined;

  readonly defaultMass?: number | undefined;

  readonly detachFromHierarchy?: boolean | undefined;

  readonly enableMotors?: boolean | undefined;

  forceImmediateMaterialization?: boolean | undefined;

  readonly includeFloatingJoints?: boolean | undefined;

  readonly name?: string | undefined;

  restoreMotion?: PhysicsParticipationRestoreMotion | undefined;

  readonly rootBodyMode?: WaveModelPhysicsRootBodyMode | undefined;

  readonly unsupportedJointPolicy?: WaveModelPhysicsJointUnsupportedPolicy | undefined;

  wakeUp?: boolean | undefined;

}

type WavePhysicsRigidBodyTypeFor<TBackend extends WavePhysicsBackendSelection> = TBackend extends "rigidBody" ? RigidBodyType : TBackend extends "kinematicController" ? null : RigidBodyType | null;

declare class WavePhysicsRigJointBatch<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  constructor(_rig: WavePhysicsRig<T>);

  apply(options?: WavePhysicsRigOptions): WaveModelPhysicsRig;

  chain(firstChild: T, ...moreChildren: T[]): WavePhysicsRigChainTargetBuilder<T>;

  consumeDrafts(): readonly WavePhysicsRigJointDraftConfig<T>[];

  createJoint(children: readonly T[], parent: T): WavePhysicsRigJointBuilder<T>;

  fromCurrentPose(): this;

  joint(child: T, ...moreChildren: T[]): WavePhysicsRigJointTargetBuilder<T>;

}

declare class WavePhysicsRigJointBuilder<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  constructor(_batch: WavePhysicsRigJointBatch<T>, _draft: WavePhysicsRigJointDraftConfig<T>);

  apply(options?: WavePhysicsRigOptions): WaveModelPhysicsRig;

  around(axis: DirectionInput): this;

  asHinge(): this;

  asLock(): this;

  asLoose(): this;

  asSlider(): this;

  at(location: WavePhysicsRigJointLocation): this;

  chain(firstChild: T, ...moreChildren: T[]): WavePhysicsRigChainTargetBuilder<T>;

  fromCurrentPose(): WavePhysicsRigJointBatch<T>;

  joint(child: T, ...moreChildren: T[]): WavePhysicsRigJointTargetBuilder<T>;

  limitAngleDegrees(lower: number, upper: number): this;

  limitAngleRadians(lower: number, upper: number): this;

  limitLinearTravel(lower: number, upper: number): this;

  named(id: string): this;

  withDamping(damping: number): this;

  withEffort(effort: number): this;

}

interface WavePhysicsRigJointDraftConfig<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  axis?: DirectionInput;

  children: readonly T[];

  damping?: number;

  effort?: number;

  hingeLocation?: WavePhysicsRigJointLocation;

  kind: WavePhysicsRigJointKind;

  lowerLimit?: number;

  parent: T;

  requestedId?: string;

  upperLimit?: number;

}

type WavePhysicsRigJointKind = "hinge" | "loose" | "lock" | "slider";

type WavePhysicsRigJointLocation = WavePointInput | WavePhysicsRigPart;

interface WavePhysicsRigJointRecord<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  readonly axis?: DirectionInput;

  readonly child: T;

  readonly damping?: number;

  readonly effort?: number;

  readonly hingeLocation?: WavePhysicsRigJointLocation;

  readonly id: string;

  readonly kind: WavePhysicsRigJointKind;

  readonly lowerLimit?: number;

  readonly parent: T;

  readonly upperLimit?: number;

}

declare class WavePhysicsRigJointTargetBuilder<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  constructor(_batch: WavePhysicsRigJointBatch<T>, _children: readonly T[]);

  to(parent: T): WavePhysicsRigJointBuilder<T>;

}

declare class WavePhysicsRigKinematicBodyTargetBuilder<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  constructor(_driver: WavePhysicsRigKinematicDriveBuilder<T>, _body: T);

  apply(): WavePhysicsRig<T>;

  between(start: WavePhysicsRigKinematicPointTarget, end: WavePhysicsRigKinematicPointTarget): WavePhysicsRigKinematicSegmentTargetBuilder<T>;

  body(body: T): WavePhysicsRigKinematicBodyTargetBuilder<T>;

  followRotation(rotation: Quaternion): this;

  moveTo(target: WavePhysicsRigKinematicPointTarget): this;

  moveTo(x: number, y: number, z: number): this;

  preserveLocalScale(): this;

  rotateTo(rotation: Quaternion): this;

  scaleTo(scale: Vector3Like): this;

}

declare class WavePhysicsRigKinematicDriveBuilder<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  constructor(_rig: WavePhysicsRig<T>);

  apply(): WavePhysicsRig<T>;

  body(body: T): WavePhysicsRigKinematicBodyTargetBuilder<T>;

  clear(): this;

  ensureTransformTarget(body: T): MutableWavePhysicsRigKinematicTransformTarget<T>;

  inFrameOf(target: TransformReferenceLike): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inParentTerms(): this;

  inRigFrame(): this;

  inRigTerms(): this;

  inWorldFrame(): this;

  inWorldTerms(): this;

  setSegmentTarget(body: T, start: WavePhysicsRigKinematicPointTarget, end: WavePhysicsRigKinematicPointTarget): WavePhysicsRigKinematicSegmentTargetBuilder<T>;

  stopDriving(body: T): boolean;

}

type WavePhysicsRigKinematicPointTarget = WavePointInput | TransformReferenceLike;

declare class WavePhysicsRigKinematicSegmentTargetBuilder<T extends WavePhysicsRigPart = WavePhysicsRigPart> {

  constructor(_driver: WavePhysicsRigKinematicDriveBuilder<T>, _target: MutableWavePhysicsRigKinematicSegmentTarget<T>);

  along(axis: DirectionInput): this;

  apply(): WavePhysicsRig<T>;

  body(body: T): WavePhysicsRigKinematicBodyTargetBuilder<T>;

  keepScale(): this;

  resizeToSpan(): this;

  withHeading(reference: TransformReferenceLike, axis?: DirectionInput): this;

  withHeadingDirection(axis: DirectionInput): this;

}

interface WavePhysicsRigObjectModelBindingOptions {

  readonly retainAggregateOwner?: boolean;

}

type WavePhysicsRigObjectModelPartBindings<T extends WavePhysicsRigPart = WavePhysicsRigPart> = ReadonlyMap<WaveModelPartId, T> | Readonly<Record<WaveModelPartId, T | undefined>>;

interface WavePhysicsRigOptions {

  readonly childBodyMode?: WaveModelPhysicsChildBodyMode | undefined;

  readonly debugLog?: boolean | undefined;

  readonly defaultAngularDamping?: number | undefined;

  readonly defaultEnableCollisions?: boolean | undefined;

  readonly defaultLinearDamping?: number | undefined;

  readonly defaultMass?: number | undefined;

  readonly detachFromHierarchy?: boolean | undefined;

  readonly enableMotors?: boolean | undefined;

  readonly includeFloatingJoints?: boolean | undefined;

  readonly name?: string | undefined;

  readonly rootBodyMode?: WaveModelPhysicsRootBodyMode | undefined;

  readonly unsupportedJointPolicy?: WaveModelPhysicsJointUnsupportedPolicy | undefined;

}

type WavePhysicsRigPart = WaveSpatial3DObject & { readonly physicsBody: cmp_physicsBody; readonly transform: cmp_transform; getPivotWorld(): Vector3; worldToLocal(worldPoint: Vector3Like): Vector3; }

interface WavePipelineDescriptor {

  readonly blend: "opaque" | "alpha" | "additive";

  readonly defines?: Readonly<Record<string, boolean | number>>;

  readonly depth: { readonly write: boolean; readonly compare: "closer" | "always"; }

  readonly id: string;

  readonly module: { readonly id: string; readonly revision: number; }

  readonly primitive: { readonly topology: "triangle-list"; readonly cullMode: "none" | "back"; }

  readonly schema: "wave.pipeline.v2";

}

type WavePlanarFace = "front" | "back";

interface WavePlanarReflectionDistanceFadeOptions {

  readonly farDistance?: number;

  readonly maxBlurKernel?: number;

  readonly maxSpread?: number;

  readonly minLevel?: number;

  readonly nearDistance?: number;

}

interface WavePlanarReflectionSource {

  readonly capture: { readonly objectPolicy: WaveSceneSubviewObjectPolicy; readonly environment: WaveSceneSubviewEnvironment; readonly recursion: "excludeReceivers"; }

  readonly id: string;

  readonly kind: "planar";

  readonly output: { readonly size: WaveSceneSubviewTextureSizePolicy; readonly blur: WaveSceneSubviewBlurPolicy | null; readonly resolve: WaveSceneSubviewResolvePolicy | null; readonly generateMipMaps: boolean; }

  readonly parameters: Readonly<Record<string, unknown>>;

  readonly plane: WavePlaneFrame;

  readonly schema: typeof WAVE_REFLECTION_SOURCE_SCHEMA;

  readonly sourceView: WaveSceneSubviewSourceView;

  readonly updatePolicy: WaveRenderGraphUpdatePolicy;

}

declare class WavePlanarReflectionSourceBuilder {

  constructor(_runtime: () => WaveSceneReflectionRuntime, _id: string);

  apply(): WaveReflectionSourceRef;

  blurred(kernel: number): this;

  captures(targets: readonly WaveReflectionCaptureTarget[]): this;

  capturesScene(): this;

  distanceFade(options?: WavePlanarReflectionDistanceFadeOptions): this;

  everyFrame(): this;

  everyNFrames(interval: number, phase?: number): this;

  horizontalAt(height: number): this;

  objectsOnly(): this;

  once(): this;

  onInvalidation(...keys: readonly string[]): this;

  onPlane(normal: SerializedDirectionInput, origin?: Vector3Like): this;

  onResize(): this;

  resolution(size: number): this;

  scaleWithView(scale: number): this;

  withBackground(): this;

  withBackgroundAndClouds(): this;

  withMipMaps(enabled?: boolean): this;

}

interface WavePlanePrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "plane";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly faces?: Partial<Readonly<Record<WavePlanarFace, WavePrimitiveFaceLayout>>>;

  readonly orientation?: "xy" | "xz";

  readonly segments?: { readonly width?: number; readonly height?: number; }

  readonly size: { readonly width: number; readonly height: number; }

}

declare class WavePlaneUvPointSource implements PhysicsBodyPinUvSelectionSource {

  constructor(_plane: wavePlane, _u: number, _v: number);

  [WAVE_PHYSICS_BODY_PIN_UV_SELECTION](owner: object): this | null;

  resolveGridVertexIndex(rows: number, cols: number): number;

  toVector(space?: WavePointSourceSpace): Vector3;

  toVector3(): Vector3;

  get u(): number;

  get v(): number;

}

type WavePlaneValue = `${WavePlane}`;

type WavePointNetOptions = WavePointNetSdfSkinOptions | WavePointNetOuterShellOptions;

interface WavePointNetOuterShellOptions {

  castShadows?: boolean | undefined;

  color?: any;

  readonly linkMode?: WavePointNetLinkMode | undefined;

  receiveShadows?: boolean | undefined;

  updatable?: boolean | undefined;

  readonly uvScale?: number | undefined;

  readonly gridColumns?: number;

  readonly gridRows?: number;

  readonly mode: WavePointNetMode.OuterShell;

  readonly ringLattice?: boolean;

}

type WavePointNetPathBindingOptions = { readonly followPathEdits?: boolean; } & ({ readonly sampling?: WavePointNetPathSamplingMode.RenderedPath; readonly sampleCount?: never; } | { readonly sampling: WavePointNetPathSamplingMode.ControlPoints; readonly sampleCount?: never; } | { readonly sampling: WavePointNetPathSamplingMode.Uniform; readonly sampleCount?: number; });

type WavePointNetPathOptions = (Omit<WavePointNetSdfSkinOptions, "linkMode"> | Omit<WavePointNetOuterShellOptions, "linkMode">) & WavePointNetPathBindingOptions;

type WavePointNetPathSource = WaveUniformPathSampleProvider & { readonly uniqueSampledPointCount: number; readonly pathRevision: number; readonly sampledPointsToRef: WavePathSamplesToRef; controlPointsToRef(result: Vector3[], options?: WavePathQueryOptions, spare?: Vector3[]): Vector3[]; uniformSamplesToRef(sampleCount: number, result: Vector3[], options?: WavePathQueryOptions, spare?: Vector3[]): Vector3[]; }

type WavePointNetPointInput = TransformPointInput;

interface WavePointNetSdfSkinOptions {

  castShadows?: boolean | undefined;

  color?: any;

  readonly linkMode?: WavePointNetLinkMode | undefined;

  receiveShadows?: boolean | undefined;

  updatable?: boolean | undefined;

  readonly uvScale?: number | undefined;

  readonly cellSize?: number;

  readonly closed?: boolean;

  readonly connectSequential?: boolean;

  readonly mode?: WavePointNetMode.SdfSkin;

  readonly padding?: number;

  readonly radius?: number;

  readonly smoothness?: number;

}

type WavePointSourceSpace = "world" | "parent" | "local";

interface WavePolygonPrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "polygon";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly cap?: "none" | "top" | "bottom" | "both";

  readonly capSegments?: number;

  readonly height: number;

  readonly heightSegments?: number;

  readonly radius: number;

  readonly regular?: boolean;

  readonly seed?: number;

  readonly sides: number;

  readonly topRadius?: number;

}

interface WavePose {

  bones: Map<string, WavePoseBoneState>;

  name: string;

  referenceEntityId?: number;

  referenceWorldPosition?: Vector3Like;

  referenceWorldRotation?: { x: number; y: number; z: number; w: number; }

  timestamp: number;

}

interface WavePoseBoneState {

  jointRotation?: Vector3Like;

  localPosition: Vector3Like;

  localRotation: { x: number; y: number; z: number; w: number; }

  localScale?: Vector3Like;

}

declare class WavePostFx {

  clear(): this;

  disable(effect: PostFxEffectName): this;

  disableCustom(id: string): this;

  enable<K extends PostFxEffectRequiringOptions>(effect: K, options: PostFxEffectMap[K]): this;

  enable<K extends PostFxEffectWithOptionalOptions>(effect: K, options?: PostFxEffectMap[K]): this;

  enableCustom(id: string, options: CustomPostProcessOptions): this;

  fadeIn(options?: SceneTransitionOptions): Promise<void>;

  fadeOut(options?: SceneTransitionOptions): Promise<void>;

  forCamera(cameraId: string): WaveCameraPostFx;

  replaceWith(plan: PostFxPlan): this;

  replaceWithNoir(options?: WaveNoirProfileOptions): this;

  replaceWithOilPainting(options?: OilPaintingOptions): this;

  replaceWithProfile(profile: PostFxProfile | `${PostFxProfile}`): this;

  shake(options?: ScreenShakeOptions): this;

  stop(event: PostFxEvent.ScreenShake): this;

  trigger(event: PostFxEvent.ScreenShake, options?: ScreenShakeOptions): this;

}

interface WavePowerValueCurveSpec {

  readonly exponent: number;

  readonly kind: "power";

}

interface WavePresentationCaptureOptions {

  readonly format?: "png" | "jpeg" | "webp";

  readonly height?: number;

  readonly width?: number;

}

interface WavePresentationPickOptions {

  readonly mask?: number;

  readonly viewId?: string;

}

interface WavePrimitiveDoubleSideUv {

  readonly back?: WaveUvRect;

  readonly front?: WaveUvRect;

}

interface WavePrimitiveFaceLayout {

  readonly regionId?: string;

  readonly uv?: WaveUvRect;

  readonly vertexColor?: ColorInputAlpha;

}

type WavePrimitiveGeometryConfiguration<TRecipe extends WavePrimitiveGeometryRecipe> = Omit<TRecipe, "kind" | "version" | "shape"> & { readonly kind?: "primitive"; readonly version?: 1; readonly shape?: TRecipe["shape"]; }

type WavePrimitiveGeometryInput = WavePrimitiveGeometryRecipe extends infer TRecipe ? TRecipe extends WavePrimitiveGeometryRecipe ? Omit<TRecipe, "kind" | "version"> & { readonly kind?: "primitive"; readonly version?: 1; } : never : never;

type WavePrimitiveGeometryRecipe = WaveBoxPrimitiveRecipe | WaveSpherePrimitiveRecipe | WaveCylinderPrimitiveRecipe | WaveConePrimitiveRecipe | WaveCapsulePrimitiveRecipe | WavePlanePrimitiveRecipe | WaveDiscPrimitiveRecipe | WaveTorusPrimitiveRecipe | WaveTorusKnotPrimitiveRecipe | WavePolygonPrimitiveRecipe | WaveLathePrimitiveRecipe | WaveWedgePrimitiveRecipe;

interface WavePrimitiveProfilePoint {

  readonly x: number;

  readonly y: number;

}

type WavePrimitiveShape = WavePrimitiveGeometryRecipe["shape"];

interface WaveProceduralFrameInput {

  readonly mode: "parallelTransport" | "fixedUp";

  readonly seamDirection?: DirectionInput;

  readonly up?: DirectionInput;

}

interface WaveProceduralFrameSpec {

  readonly mode: "parallelTransport" | "fixedUp";

  readonly seamDirection?: SerializedDirectionInput;

  readonly up?: SerializedDirectionInput;

}

type WaveProceduralModelInput = WaveModelInput<WaveProceduralModelInputRecipe>;

type WaveProceduralModelInputRecipe = Omit<WaveProceduralModelRecipe, "id">;

type WaveProceduralPathInput = readonly Vector3Like[] | { readonly path: WavePathSampleProvider; readonly space: WaveGeometryCoordinateSpace; readonly samples?: number; }

type WaveProceduralPBRBakeBackend = "auto" | "cpu" | "webgpu";

interface WaveProceduralPBRBakedChannel {

  readonly colorSpace: "srgb" | "linear";

  readonly data: Uint8Array;

  readonly format: "rgba8";

  readonly height: number;

  readonly role: WaveProceduralPBRChannel;

  readonly width: number;

}

interface WaveProceduralPBRBakeDiagnostics {

  readonly backend: Exclude<WaveProceduralPBRBakeBackend, "auto">;

  readonly durationMs: number;

  readonly evaluationCost: number;

  readonly evaluatorVersion: number;

  readonly height: number;

  readonly nodeCount: number;

  readonly recipeHash: string;

  readonly textureRefs: readonly string[];

  readonly warnings: readonly string[];

  readonly width: number;

}

type WaveProceduralPBRBakeMode = "live" | "onDemand" | "onPublish" | "bakedOnly";

interface WaveProceduralPBRBakeOptions {

  readonly backend?: WaveProceduralPBRBakeBackend;

  readonly channels?: readonly WaveProceduralPBRChannel[];

  readonly edgePadding?: number;

  readonly heightRange?: { readonly min: number; readonly max: number; }

  readonly onProgress?: (progress: number) => void;

  readonly resolution?: number | { readonly width: number; readonly height: number; }

  readonly signal?: AbortSignal;

  readonly textureResolver?: WaveProceduralPBRTextureResolver;

}

interface WaveProceduralPBRBakePolicy {

  readonly backend: WaveProceduralPBRBakeBackend;

  readonly channels: readonly WaveProceduralPBRChannel[];

  readonly edgePadding: number;

  readonly heightRange: { readonly min: number; readonly max: number; }

  readonly mode: WaveProceduralPBRBakeMode;

  readonly resolution: { readonly width: number; readonly height: number; }

}

type WaveProceduralPBRBakePolicyInput = Omit<Partial<WaveProceduralPBRBakePolicy>, "resolution"> & { readonly resolution?: number | { readonly width: number; readonly height: number; }; }

interface WaveProceduralPBRBakeResult {

  readonly backend: Exclude<WaveProceduralPBRBakeBackend, "auto">;

  readonly channels: readonly WaveProceduralPBRBakedChannel[];

  readonly diagnostics: WaveProceduralPBRBakeDiagnostics;

  readonly evaluatorVersion: number;

  readonly recipe: WaveProceduralPBRRecipe;

  readonly recipeHash: string;

}

type WaveProceduralPBRChannel = "baseColor" | "normal" | "orm" | "height" | "emissive" | "opacity";

interface WaveProceduralPBRMaterialSerializedConfig {

  readonly bakePolicy: WaveProceduralPBRBakePolicy;

  readonly name: string;

  readonly recipe: WaveProceduralPBRRecipe;

}

interface WaveProceduralPBRTexturePixels {

  readonly colorSpace: "srgb" | "linear";

  readonly data: Uint8Array;

  readonly height: number;

  readonly width: number;

}

type WaveProceduralPBRTextureResolver = (textureRef: string) => WaveProceduralPBRTexturePixels | null | Promise<WaveProceduralPBRTexturePixels | null>;

interface WaveProfile2DBuilder {

  chamferedRectangle(options: WaveProfile2DChamferedRectangleOptions): WaveProfile2DRecipe;

  circle(radius: number, segments?: number): WaveProfile2DRecipe;

  ellipse(radiusX: number, radiusY: number, segments?: number): WaveProfile2DRecipe;

  mirrorHalf(half: WaveProfile2DRecipe, options: WaveProfile2DMirrorHalfOptions): WaveProfile2DRecipe;

  offset(profile: WaveProfile2DRecipe, distance: number): WaveProfile2DRecipe;

  points(points: readonly Vector2Like[], options: WaveProfile2DPointsOptions): WaveProfile2DRecipe;

  polygon(points: readonly Vector2Like[]): WaveProfile2DRecipe;

  rectangle(options: WaveProfile2DRectangleOptions): WaveProfile2DRecipe;

  roundedRectangle(options: WaveProfile2DRoundedRectangleOptions): WaveProfile2DRecipe;

  stepEdge(profile: WaveProfile2DRecipe, options: WaveProfile2DStepEdgeOptions): WaveProfile2DRecipe;

  superellipse(options: WaveProfile2DSuperellipseOptions): WaveProfile2DRecipe;

}

interface WaveProfile2DChamferedRectangleOptions {

  readonly height: number;

  readonly width: number;

  readonly chamfer: number;

}

interface WaveProfile2DChamferedRectangleSource {

  readonly chamfer: number;

  readonly height: number;

  readonly kind: "chamferedRectangle";

  readonly width: number;

}

type WaveProfile2DMirrorAxis = "x" | "y";

interface WaveProfile2DMirrorHalfOptions {

  readonly axis: WaveProfile2DMirrorAxis;

}

interface WaveProfile2DMirrorHalfSource {

  readonly axis: WaveProfile2DMirrorAxis;

  readonly half: WaveProfile2DSource;

  readonly kind: "mirrorHalf";

}

interface WaveProfile2DOffsetSource {

  readonly distance: number;

  readonly kind: "offset";

  readonly profile: WaveProfile2DSource;

}

interface WaveProfile2DPoint {

  readonly x: number;

  readonly y: number;

}

interface WaveProfile2DPointsOptions {

  readonly closed: boolean;

}

interface WaveProfile2DPointsSource {

  readonly closed: boolean;

  readonly kind: "points";

  readonly points: readonly WaveProfile2DPoint[];

}

interface WaveProfile2DRecipe {

  readonly kind: "profile2D";

  readonly source: WaveProfile2DSource;

  readonly version: 2;

}

interface WaveProfile2DRectangleOptions {

  readonly height: number;

  readonly width: number;

}

interface WaveProfile2DRectangleSource {

  readonly height: number;

  readonly kind: "rectangle";

  readonly width: number;

}

interface WaveProfile2DRoundedRectangleOptions {

  readonly cornerRadius: number;

  readonly height: number;

  readonly segments?: number;

  readonly width: number;

}

type WaveProfile2DSource = WaveProfile2DPointsSource | WaveProfile2DRectangleSource | WaveProfile2DChamferedRectangleSource | WaveProfile2DMirrorHalfSource | WaveProfile2DStepEdgeSource | WaveProfile2DOffsetSource;

interface WaveProfile2DStepEdgeOptions {

  readonly halfSpan: number;

  readonly rise: number;

  readonly side: WaveProfile2DStepSide;

}

interface WaveProfile2DStepEdgeSource {

  readonly halfSpan: number;

  readonly kind: "stepEdge";

  readonly profile: WaveProfile2DSource;

  readonly rise: number;

  readonly side: WaveProfile2DStepSide;

}

type WaveProfile2DStepSide = "top" | "bottom" | "left" | "right";

interface WaveProfile2DSuperellipseOptions {

  readonly exponent: number;

  readonly radiusX: number;

  readonly radiusY: number;

  readonly segments?: number;

}

interface WaveRandomValueExpr {

  readonly max: WaveValueExpr;

  readonly min: WaveValueExpr;

  readonly perSample?: boolean;

  readonly salt?: number;

  readonly seed?: WaveValueExpr;

  readonly type: "random";

}

interface WaveRangeAabb {

  center: Vector3;

  halfExtents: Vector3;

  max: Vector3;

  min: Vector3;

}

interface WaveRangeAabbShape {

  center: Vector3;

  halfExtents: Vector3;

  kind: typeof WaveRangeShapeKind.Aabb;

  voxelGrid?: WaveRangeVoxelGrid | null;

}

type WaveRangeAnchorInput = WavePointInput | WaveSpatial3DObject;

type WaveRangeAuthoringModelSource = string | AssetRef<"model"> | ExactAssetRef<"model"> | wave3DObject;

type WaveRangeEntityMatcher = (range: WaveRange, entity: WaveSpatial3DObject, match: WaveRangeMatch, options: WaveRangeEntityMatchOptions) => boolean;

interface WaveRangeEntityMatchOptions {

  borderEpsilon?: number;

  sample?: "bounds" | "center";

}

interface WaveRangeEntityModelProvider {

  model: { getMeshes(scope?: MeshScope): readonly unknown[]; }

}

interface WaveRangeGroundPathBandPoint {

  readonly x: number;

  readonly y?: number;

  readonly z: number;

}

interface WaveRangeHelperOptions {

  boxSegments?: number;

  color?: ColorInput;

  opacity?: number;

  segments?: number;

  sphereSegments?: number;

}

type WaveRangeHelperSync = (range: WaveRange, options: WaveRangeHelperOptions | null) => void;

interface WaveRangeLiveTransform {

  bounds: WaveRangeAabb;

  directionMatrix: unknown;

  inverseMatrix: unknown;

  matrix: unknown;

}

interface WaveRangeMappedValueCurveSpec {

  readonly curve: WaveValueCurveSpec;

  readonly inputRange?: WaveValueCurveRangeSpec;

  readonly kind: "rangeMap";

  readonly outputRange?: WaveValueCurveRangeSpec;

}

type WaveRangeMatch = (typeof WaveRangeMatchMode)[keyof typeof WaveRangeMatchMode];

interface WaveRangeMeshProvider {

  getRangeSourceMeshes(): readonly unknown[];

}

type WaveRangeMeshSurfaceBackend = "closedMesh" | "surfaceOnly";

interface WaveRangeMeshSurfacePart {

  bounds: WaveRangeAabb;

  indices: Uint32Array;

  positions: Float32Array;

}

interface WaveRangeMeshSurfaceShape {

  backend: WaveRangeMeshSurfaceBackend;

  bounds: WaveRangeAabb;

  center: Vector3;

  helperGeometry: WaveGeometryData;

  kind: typeof WaveRangeShapeKind.MeshSurface;

  liveTransform?: WaveRangeLiveTransform | null;

  mergedPart: WaveRangeMeshSurfacePart;

  parts: readonly WaveRangeMeshSurfacePart[];

  sourceLabel: string | null;

  sourceMeshCount?: number;

}

type WaveRangeModelBackend = WaveRangeMeshSurfaceBackend | "voxel";

interface WaveRangeModelOptions {

  readonly closeBoundaryLoops?: boolean | undefined;

  readonly degeneracyEpsilon?: number | undefined;

  readonly recomputeNormals?: boolean | undefined;

  readonly removeCoincidentFaces?: boolean | undefined;

  readonly removeDegenerateFaces?: boolean | undefined;

  readonly weldEpsilon?: number | undefined;

  readonly weldVertices?: boolean | undefined;

  backend?: WaveRangeModelBackend | "auto";

  includeDisabledMeshes?: boolean;

  voxelSize?: number;

}

type WaveRangeModelResolver = (range: WaveRange, source: WaveRangeModelSource, options: WaveRangeModelOptions) => WaveRangeShape;

type WaveRangeModelSource = string | AssetRef<"model"> | ExactAssetRef<"model"> | unknown | readonly unknown[] | wave3DObject | WaveRangeMeshProvider | WaveRangeEntityModelProvider;

interface WaveRangePathBandCurveSource {

  readonly curvePoints: readonly Vector3Like[];

}

type WaveRangePathBandInput = readonly WaveRangePathBandPoint[] | WaveCurve2DSource | WaveRangePathBandSampledSource | WaveRangePathBandCurveSource;

interface WaveRangePathBandOptions {

  readonly height?: number;

  readonly margin?: number;

  readonly pathPlane?: WaveRangePathBandPlane;

  readonly sourceLabel?: string;

  readonly width: number;

  readonly y?: number;

}

type WaveRangePathBandPlane = WavePathPlaneAxis;

type WaveRangePathBandPoint = Vector3Like | WaveRangeGroundPathBandPoint;

interface WaveRangePathBandSampledSource {

  readonly sampledPoints: readonly Vector3Like[];

}

type WaveRangeShape = WaveRangeAabbShape | WaveRangeSphereShape | WaveRangeMeshSurfaceShape | WaveRangeVoxelGridShape | WaveRangeVolumetricFieldShape;

interface WaveRangeSphereShape {

  center: Vector3;

  kind: typeof WaveRangeShapeKind.Sphere;

  radius: number;

  voxelGrid?: WaveRangeVoxelGrid | null;

}

interface WaveRangeVolumetricFieldShape {

  bounds: WaveRangeAabb;

  center: Vector3;

  field: WaveVolumetricField;

  helperGeometry?: WaveGeometryData;

  kind: typeof WaveRangeShapeKind.VolumetricField;

  liveTransform?: WaveRangeLiveTransform | null;

  sourceLabel: string | null;

}

type WaveRangeVoxelFillModeValue = (typeof WaveRangeVoxelFillMode)[keyof typeof WaveRangeVoxelFillMode];

interface WaveRangeVoxelGrid {

  gridMin: Vector3;

  gridSize: Vector3;

  mode: WaveRangeVoxelFillModeValue | "filledMesh";

  occupancy: Uint8Array;

  occupiedCount: number;

  voxelSize: number;

}

interface WaveRangeVoxelGridOptions {

  maxCells?: number;

  mode?: WaveRangeVoxelFillModeValue;

  voxelSize?: number;

}

interface WaveRangeVoxelGridShape {

  bounds: WaveRangeAabb;

  center: Vector3;

  helperGeometry?: WaveGeometryData;

  kind: typeof WaveRangeShapeKind.VoxelGrid;

  liveTransform?: WaveRangeLiveTransform | null;

  sourceLabel: string | null;

  sourceMeshCount?: number;

  voxelGrid: WaveRangeVoxelGrid;

}

interface WaveRateObservationSource<TEntity extends object> {

  above(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  atLeast(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  atMost(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  below(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  between(min: number, max: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  equals(value: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  near(value: number, tolerance: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

  outside(min: number, max: number, ...args: RatePredicateArg[]): WaveObservationTerminalBuilder<TEntity>;

}

interface WaveRateSpec {

  readonly unit: WaveRateUnitKind;

  readonly value: number;

}

interface WaveRateUnit {

  (value: number): WaveRate;

  readonly kind: WaveRateUnitKind;

}

type WaveRateUnitKind = "unitsPerSecond" | "degreesPerSecond" | "scaleFactorPerSecond";

type WaveReflectionCaptureTarget = wave3DObject | WaveGroup<wave3DObject>;

interface WaveReflectionPolicyTerminal {

  setReflectionPolicy(policy: WaveReflectionReceiverPolicy): unknown;

}

interface WaveReflectionReceiverPolicy {

  readonly candidates: readonly WaveReflectionSourceRef[];

  readonly fallback: "intrinsic" | "none";

  readonly intensity: number;

  readonly schema: typeof WAVE_REFLECTION_POLICY_SCHEMA;

  readonly target?: WaveVisualTargetRef;

}

type WaveReflectionSourceDefinition = WaveSceneEnvironmentReflectionSource | WavePlanarReflectionSource;

interface WaveReflectionSourceRef {

  readonly id: string;

  readonly schema: typeof WAVE_REFLECTION_SOURCE_REF_SCHEMA;

}

type WaveRelativeCoverageAnchor = { readonly kind: "primaryCamera"; } | { readonly kind: "fixed"; readonly u: number; readonly v: number; } | { readonly kind: "entity"; readonly entityRef: WaveEntityIdentityRef; }

declare class WaveRelativeCoverageBuilder {

  constructor(_anchor: WaveRelativeCoverageAnchor);

  apply(): WaveRelativeCoveragePlan;

  layer(id: string, options?: WaveRelativeCoverageLayerOptions): this;

  size(size: number): this;

  size(extentU: number, extentV: number): this;

  snapEvery(distance: number): this;

  snapEvery(distanceU: number, distanceV: number): this;

  withoutSnapping(): this;

}

interface WaveRelativeCoverageFrame {

  centerU: number;

  centerV: number;

  extentU: number;

  extentV: number;

  originU: number;

  originV: number;

}

interface WaveRelativeCoverageLayer {

  readonly densityScale: number;

  readonly extentScale: number;

  readonly fadeEnd: number;

  readonly fadeStart: number;

  readonly id: string;

}

interface WaveRelativeCoverageLayerOptions {

  readonly densityScale?: number;

  readonly extentScale?: number;

  readonly fadeEnd?: number;

  readonly fadeStart?: number;

}

interface WaveRelativeCoveragePlan {

  readonly anchor: WaveRelativeCoverageAnchor;

  readonly extentU: number;

  readonly extentV: number;

  readonly layers: readonly WaveRelativeCoverageLayer[];

  readonly schema: typeof WAVE_RELATIVE_COVERAGE_PLAN_SCHEMA;

  readonly snapU: number;

  readonly snapV: number;

}

type WaveRenderCameraKind = "perspective" | "orthographic" | "geospatial" | (string & {});

interface WaveRenderEngineProfile {

  readonly antialias?: boolean;

  readonly highPrecisionMatrix?: boolean;

  readonly largeWorldRendering?: boolean;

  readonly stencil?: boolean;

}

type WaveRenderGraphRuntimeBindingKind = "view" | "sceneSubview" | "shadowSource" | "postProcess" | "volumetricFog" | "vfx" | "physicalAtmosphere" | "proceduralSky" | "fullscreenGui" | "sceneTransition" | "offscreenSurface" | "globalIllumination" | "clusteredLights" | "waterSpectrum" | "externalCompute" | "externalRaster" | "gpuSurfaceDynamics" | "gpuFluid" | "gpuEventStream" | "sampledTexture" | "textureOutput";

interface WaveRenderGraphRuntimeBindingRef<TKind extends WaveRenderGraphRuntimeBindingKind = WaveRenderGraphRuntimeBindingKind> {

  readonly id: string;

  readonly kind: TKind;

}

type WaveRenderGraphSceneSubviewEnvironment = "none" | "background" | "backgroundAndClouds";

type WaveRenderGraphTextureSizePolicy = { readonly kind: "absolute"; readonly width: number; readonly height: number; readonly layers?: number; } | { readonly kind: "viewScale"; readonly scale: number; readonly minWidth?: number; readonly minHeight?: number; readonly maxWidth?: number; readonly maxHeight?: number; } | { readonly kind: "match"; readonly resourceId: string; } | { readonly kind: "backbuffer"; } | { readonly kind: "runtimeBound"; }

type WaveRenderGraphUpdatePolicy = { readonly kind: "everyFrame"; } | { readonly kind: "everyNFrames"; readonly interval: number; readonly phase: number; } | { readonly kind: "once"; } | { readonly kind: "onInvalidation"; readonly keys: readonly string[]; } | { readonly kind: "onResize"; } | { readonly kind: "manual"; }

type WaveRenderGraphViewSource = { readonly kind: "primary"; } | { readonly kind: "binding"; readonly binding: WaveRenderGraphRuntimeBindingRef<"view">; }

type WaveRenderGraphWorldGlowSpread = "tight" | "soft";

interface WaveRenderProfile {

  readonly engine?: WaveRenderEngineProfile;

  readonly runtime?: WaveRenderRuntimeProfile;

  readonly scene?: WaveRenderSceneProfile;

}

interface WaveRenderRuntimeProfile {

  readonly cameraKinds?: readonly WaveRenderCameraKind[];

  readonly defaultCameraKind?: WaveRenderCameraKind;

}

type WaveRenderSceneHandedness = "left" | "right";

interface WaveRenderSceneProfile {

  readonly floatingOrigin?: boolean;

  readonly handedness?: WaveRenderSceneHandedness;

}

type WaveRenderSurface = HTMLCanvasElement | OffscreenCanvas;

interface WaveRenderSurfaceMetrics {

  readonly cssHeight: number;

  readonly cssWidth: number;

  readonly devicePixelRatio: number;

  readonly pixelHeight: number;

  readonly pixelWidth: number;

  readonly revision: number;

}

interface WaveRequestContextPolicy {

  readonly query: Readonly<Record<string, string>>;

  readonly sameOriginPathPrefixes: readonly string[];

}

interface WaveResolutionScalingRange {

  maximum: number;

  minimum: number;

}

interface WaveResolved2DBodyGeometry {

  readonly bounds: WaveLayoutBodyBox;

  height: number;

  readonly matrix: WaveAffine2D;

  width: number;

}

interface WaveResolved2DFramePose {

  readonly bodyBounds: WaveLayoutBodyBox;

  readonly clipResult: "visible" | "clipped" | "missingBasis";

  readonly instanceId: string;

  readonly matrix: WaveAffine2D;

  readonly renderBounds: WaveLayoutBodyBox;

}

declare class WaveResponseBuilder {

  constructor(_id: string);

  apply(): WaveResponseDefinition;

  readonly deltaSeconds: WaveNumberRef;

  outputs<TKind extends WaveValueKind>(id: string, value: WaveValueRef<TKind>): this;

  outputs(id: string, kind: WaveValueKind, value: WaveValueProgram): this;

  reads<TKind extends WaveValueKind>(id: string, kind: TKind): WaveValueRefByKind<TKind>;

  remembers<TKind extends WaveValueKind>(id: string, initial: WaveValueRef<TKind>): WaveResponseStateHandle<TKind>;

  remembers<TKind extends WaveValueKind>(id: string, kind: TKind, initial: WaveValueProgram): WaveResponseStateHandle<TKind>;

  updates<TKind extends WaveValueKind>(state: WaveResponseStateHandle<TKind>, next: WaveValueRef<TKind> | WaveValueProgram): this;

}

interface WaveResponseDefinition {

  readonly id: string;

  readonly inputs: readonly WaveResponseInputDefinition[];

  readonly outputs: readonly WaveResponseOutputDefinition[];

  readonly schema: typeof WAVE_RESPONSE_SCHEMA;

  readonly state: readonly WaveResponseStateDefinition[];

}

interface WaveResponseInputDefinition {

  readonly id: string;

  readonly kind: WaveValueKind;

}

interface WaveResponseOutputDefinition {

  readonly id: string;

  readonly kind: WaveValueKind;

  readonly value: WaveValueProgram;

}

interface WaveResponseStateDefinition {

  readonly id: string;

  readonly initial: WaveValueProgram;

  readonly kind: WaveValueKind;

  readonly next: WaveValueProgram;

}

interface WaveResponseStateHandle<TKind extends WaveValueKind = WaveValueKind> {

  readonly id: string;

  readonly kind: TKind;

  readonly next: WaveValueRefByKind<TKind>;

  readonly previous: WaveValueRefByKind<TKind>;

}

type WaveRetainedComputeKernelBinding = (WaveRetainedComputeKernelBindingBase & { readonly channelId: string; readonly access: "sampledRead" | "storageWrite"; }) | (WaveRetainedComputeKernelBindingBase & { readonly access: "frameUniform"; }) | (WaveRetainedComputeKernelBindingBase & { readonly externalId: string; readonly access: "externalStorageRead" | "externalStorageReadWrite"; });

interface WaveRetainedComputeKernelBindingBase {

  readonly binding: number;

  readonly group: number;

  readonly name: string;

}

interface WaveRetainedComputeKernelDefinition {

  readonly bindings: readonly WaveRetainedComputeKernelBinding[];

  readonly dispatch: readonly [number, number, number];

  readonly entryPoint: "main";

  readonly id: string;

  readonly updatePolicy: "everyFrame" | "manual";

  readonly wgsl: string;

}

interface WaveRgbChannels {

  b: number;

  g: number;

  r: number;

}

interface WaveRigAnimationClipHandle {

  addEvent(event: WaveEventInput, options: WaveRigAnimationEventOptions): this;

  clearEvents(): this;

  readonly clipName: string;

  listEvents(): readonly WaveModelSnapshotClipEventMetadata[];

  readonly metadata: WaveModelRigPoseClipMetadata;

  play(options?: WaveRigAnimationPlayOptions): WaveAnimationPlaybackHandle;

  register(options?: WaveRigAnimationRegisterOptions): this;

  removeEvent(event: WaveEventInput | string): this;

  readonly snapshots: readonly WaveModelRigPoseSnapshotMetadata[];

}

interface WaveRigAnimationEventOptions {

  readonly at: WaveAnimationTimeInput;

  readonly id?: string;

  readonly payload?: WaveModelSerializableValue;

  readonly unit?: WaveTimeUnit;

}

interface WaveRigAnimationPlayOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  readonly crossFadeDuration?: number;

  readonly speed?: number;

}

interface WaveRigAnimationRegisterOptions {

  readonly clipName?: string;

  readonly frameRate?: number;

  readonly includeScale?: boolean;

}

declare class WaveRigAnimationTimelineBuilder {

  constructor(_host: WaveRigAnimationTimelineHost, _name: string);

  addKeyframe(poseIdOrSnapshot: string | WaveModelRigPoseSnapshotMetadata, at: WaveModelSnapshotKeyframeMetadata["at"], easing?: WaveModelSnapshotClipEasing): this;

  at(time: WaveAnimationTimeInput, unit?: WaveTimeUnit): WaveRigAnimationTimelineTimeScope;

  create(): WaveRigAnimationClipHandle;

  loop(): this;

  loopOnce(): this;

  pingPong(): this;

  play(options?: WaveRigAnimationPlayOptions): WaveAnimationPlaybackHandle;

  register(options?: WaveRigAnimationRegisterOptions): WaveRigAnimationClipHandle;

}

interface WaveRigAnimationTimelineHost {

  commitObjectModelRigPoseCatalog(snapshots: readonly WaveModelRigPoseSnapshotMetadata[], clip: WaveModelRigPoseClipMetadata): { readonly snapshots: readonly WaveModelRigPoseSnapshotMetadata[]; readonly clip: WaveModelRigPoseClipMetadata; }

  commitObjectModelRigPoseClip(clip: WaveModelRigPoseClipMetadata): WaveModelRigPoseClipMetadata;

  commitObjectModelRigPoseSnapshot(preset: WaveModelRigPoseSnapshotMetadata): WaveModelRigPoseSnapshotMetadata;

  getObjectModelRigPoseSnapshot(idOrName: string): WaveModelRigPoseSnapshotMetadata | null;

  listObjectModelRigPoseSnapshots(): WaveModelRigPoseSnapshotMetadata[];

  readonly ownerName: string;

  readonly fixedDelta: number;

  playRigPoseClip(clipIdOrName: string, options?: WaveRigAnimationPlayOptions, registration?: WaveRigAnimationRegisterOptions): WaveAnimationPlaybackHandle;

  registerRigPoseClip(clipIdOrName: string, options?: WaveRigAnimationRegisterOptions): void;

}

declare class WaveRigAnimationTimelineTimeScope {

  constructor(_builder: WaveRigAnimationTimelineBuilder, _at: WaveModelSnapshotKeyframeMetadata["at"]);

  use(poseIdOrSnapshot: string | WaveModelRigPoseSnapshotMetadata, easing?: WaveModelSnapshotClipEasing): WaveRigAnimationTimelineBuilder;

}

interface WaveRigAuthoringConfig {

  readonly graph: WaveModelRigGraphMetadata;

  readonly ikHandles?: readonly WaveRigIKHandleIntent[];

  readonly name?: string;

  readonly skin?: WaveRigSkinIntent;

  readonly sockets?: readonly WaveRigSocketIntent[];

}

declare class WaveRigAuthoringHandle {

  constructor(name?: string);

  addIKHandle(): WaveRigIKHandleBuilder;

  addSocket(): WaveRigSocketBuilder;

  chain(prefix: string): WaveRigChainPlacementBuilder;

  endEffector(id: string, options: WaveRigEndEffectorOptions): this;

  ik(id: string, options: WaveRigIKOptions): this;

  paint(part: WaveModelPartId, options: Omit<WaveRigPaintIntent, "part">): this;

  part(name: string): WaveRigPartPlacementBuilder;

  part(name: string, options: WaveRigPartOptions): this;

  root(name: string): WaveRigPartPlacementBuilder;

  skin(options?: WaveRigSkinIntent): this;

  toConfig(): WaveRigAuthoringConfig;

  toJSON(): WaveRigAuthoringConfig;

}

type WaveRigChainLengthInput<TEntry> = readonly number[] | ((entry: TEntry, index: number) => number | undefined);

type WaveRigChainNameInput<TEntry> = readonly string[] | ((entry: TEntry, index: number) => string);

interface WaveRigChainPartInput {

  readonly length?: number | undefined;

  readonly parent?: string | null | undefined;

  readonly at: Vector3Like | WaveModelVec3Tuple;

  readonly id?: WaveModelPartId;

  readonly name?: string;

}

declare class WaveRigChainPlacementBuilder {

  constructor(_prefix: string, _commit: WaveRigPartCommit, _lookupPartOrigin: WaveRigPartOriginLookup);

  create(): WaveRigAuthoringHandle;

  from(part: WaveModelPartId): this;

  segments(entries: readonly RawWaveRigChainEntry[], options?: WaveRigChainSegmentsOptions<RawWaveRigChainEntry>): this;

  segments<TEntry>(entries: readonly TEntry[], options: WaveRigChainSegmentsOptions<TEntry> & { readonly point: (entry: TEntry, index: number) => Vector3Like | WaveModelVec3Tuple; }): this;

}

interface WaveRigChainSegmentsOptions<TEntry> {

  readonly lengths?: WaveRigChainLengthInput<TEntry>;

  readonly names?: WaveRigChainNameInput<TEntry>;

  readonly point?: (entry: TEntry, index: number) => Vector3Like | WaveModelVec3Tuple;

  readonly suffixes?: readonly string[];

}

interface WaveRigEndEffectorOptions {

  readonly anchor?: WaveModelAnchorId;

  readonly at?: Vector3Like | WaveModelVec3Tuple;

  readonly name?: string;

  readonly part: WaveModelPartId;

  readonly rotation?: Vector3Like | WaveModelVec3Tuple;

}

interface WaveRigHeatMapSkinOptions {

  readonly minWeight?: number;

  readonly radius?: number;

}

declare class WaveRigidBodyConstantTorqueBuilder<TBody = unknown> {

  constructor(_executor: WaveRigidBodyFrameExecutor<TBody>, _name: string, frame: WaveTransformFrameSpace, frameOf?: TransformReferenceLike, parentFrameDepth?: number);

  clear(): this;

  done(): TBody;

  inFrameOf(target: TransformReferenceLike): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  get name(): string;

  setAxis(axis: DirectionInput, strength?: number): this;

  setEnabled(enabled: boolean): this;

  setMagnitude(strength: number): this;

  setTorque(torque: Vector3Like): this;

}

interface WaveRigidBodyFrameExecutor<TBody> {

  addAngularVelocity(delta: Vector3Like): TBody;

  addLinearVelocity(delta: Vector3Like): TBody;

  applyAngularAcceleration(acceleration: Vector3Like): TBody;

  applyAngularImpulse(impulse: Vector3Like): TBody;

  applyForce(force: Vector3Like, contactPoint?: Vector3Like, radius?: number): TBody;

  applyImpulse(impulse: Vector3Like, contactPoint?: Vector3Like, radius?: number): TBody;

  applyTorque(torque: Vector3Like): TBody;

  readonly body: TBody;

  clearConstantForce(name: string): TBody;

  clearConstantTorque(name: string): TBody;

  setAngularVelocity(velocity: Vector3Like): TBody;

  setConstantForceInFrame(frame: WaveTransformFrameSpace, frameOf: TransformReferenceLike | undefined, parentFrameDepth: number, contactPoint: WavePointInput | undefined, forceOrConfig: RigidBodyFrameConstantForceConfig | Vector3Like | DirectionInput, strengthOrOptions?: number | RigidBodyFrameConstantForceOptions, options?: RigidBodyFrameConstantForceOptions): TBody;

  setConstantTorqueInFrame(frame: WaveTransformFrameSpace, frameOf: TransformReferenceLike | undefined, parentFrameDepth: number, torqueOrConfig: RigidBodyFrameConstantTorqueConfig | Vector3Like | DirectionInput, strengthOrOptions?: number | RigidBodyFrameConstantTorqueOptions, options?: RigidBodyFrameConstantTorqueOptions): TBody;

  setFrameLinearVelocity(frame: WaveTransformFrameSpace, frameOf: TransformReferenceLike | undefined, parentFrameDepth: number, localVelocity: Vector3Like): TBody;

  setLinearVelocity(velocity: Vector3Like): TBody;

  readonly transform: TransformDirectionAccessor;

}

declare class WaveRigidBodyFrameScope<TBody = unknown> {

  inFrameOf(target: TransformReferenceLike): WaveRigidBodyFrameScope<TBody>;

  inLocalFrame(): WaveRigidBodyFrameScope<TBody>;

  inParentFrame(depth?: number): WaveRigidBodyFrameScope<TBody>;

  inWorldFrame(): WaveRigidBodyFrameScope<TBody>;

  constructor(_executor: WaveRigidBodyFrameExecutor<TBody>, frame: WaveTransformFrameSpace, frameOf?: TransformReferenceLike, parentFrameDepth?: number);

  addAngularVelocity(delta: Vector3Like | DirectionInput): TBody;

  addAngularVelocity(x: number, y: number, z: number): TBody;

  addAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): TBody;

  addLinearVelocity(delta: Vector3Like | DirectionInput): TBody;

  addLinearVelocity(x: number, y: number, z: number): TBody;

  addLinearVelocity(direction: Vector3Like | DirectionInput, speed: number): TBody;

  applyAngularImpulse(impulse: Vector3Like | DirectionInput): TBody;

  applyAngularImpulse(axis: Vector3Like | DirectionInput, strength: number): TBody;

  applyForce(hit: RigidBodyInteractionHitInput, strength?: number): TBody;

  applyForce(force: Vector3Like | DirectionInput, contactPoint?: RigidBodyContactPointInput): TBody;

  applyForce(direction: Vector3Like | DirectionInput, strength: number, contactPoint?: RigidBodyContactPointInput): TBody;

  applyImpulse(hit: RigidBodyInteractionHitInput, strength?: number): TBody;

  applyImpulse(impulse: Vector3Like | DirectionInput, contactPoint?: RigidBodyContactPointInput): TBody;

  applyImpulse(direction: Vector3Like | DirectionInput, strength: number, contactPoint?: RigidBodyContactPointInput): TBody;

  applyTorque(torque: Vector3Like | DirectionInput): TBody;

  applyTorque(x: number, y: number, z: number): TBody;

  applyTorque(axis: Vector3Like | DirectionInput, strength: number): TBody;

  at(contactPoint: WavePointInput): this;

  done(): TBody;

  editConstantForce(name: string): WaveRigidBodyConstantForceBuilder<TBody>;

  editConstantTorque(name: string): WaveRigidBodyConstantTorqueBuilder<TBody>;

  get root(): TBody;

  setAngularVelocity(velocity: Vector3Like | DirectionInput): TBody;

  setAngularVelocity(x: number, y: number, z: number): TBody;

  setAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): TBody;

  setConstantForce(name: string, config: RigidBodyFrameConstantForceConfig): TBody;

  setConstantForce(name: string, force: Vector3Like | DirectionInput, options?: RigidBodyFrameConstantForceOptions): TBody;

  setConstantForce(name: string, direction: Vector3Like | DirectionInput, strength: number, options?: RigidBodyFrameConstantForceOptions): TBody;

  setConstantTorque(name: string, config: RigidBodyFrameConstantTorqueConfig): TBody;

  setConstantTorque(name: string, torque: Vector3Like | DirectionInput, options?: RigidBodyFrameConstantTorqueOptions): TBody;

  setConstantTorque(name: string, axis: Vector3Like | DirectionInput, strength: number, options?: RigidBodyFrameConstantTorqueOptions): TBody;

  setLinearVelocity(velocity: Vector3Like | DirectionInput): TBody;

  setLinearVelocity(x: number, y: number, z: number): TBody;

  setLinearVelocity(direction: Vector3Like | DirectionInput, speed: number): TBody;

}

declare class WaveRigidObjectModelPhysicsBuilder {

  constructor(_rig: cmp_rig);

  apply(): cmp_rig;

  skipUnsupportedJoints(enabled?: boolean): this;

  withDefaultDamping(linear: number, angular: number): this;

  withDefaultMass(mass: number): this;

  withDynamicLinks(): this;

  withDynamicRoot(): this;

  withFloatingJoints(enabled?: boolean): this;

  withKinematicLinks(): this;

  withKinematicRoot(): this;

  withLinkCollisions(enabled?: boolean): this;

  withMotors(enabled?: boolean): this;

  withStaticRoot(): this;

}

type WaveRigidObjectModelPhysicsIntent = Readonly<Pick<WaveModelPhysicsRigOptions, "rootBodyMode" | "childBodyMode" | "defaultMass" | "defaultLinearDamping" | "defaultAngularDamping" | "defaultEnableCollisions" | "unsupportedJointPolicy" | "includeFloatingJoints" | "enableMotors">>;

type WaveRigIKHandle<THandle extends waveProp = waveProp> = THandle & WaveRigIKHandleBinding;

interface WaveRigIKHandleBinding {

  readonly authoredIKTargetWorldPosition: Vector3 | null;

  clearAuthoredIKTarget(): this;

  disableIK(): this;

  enableIK(): this;

  readonly ikOptions: RigBoneIKOptions;

  readonly ikReach: RigIKReachMode;

  readonly ikSteps: RigIKStepCount;

  readonly lastIKResult: RigIKResult | null;

  snapToSocket(): this;

  readonly socket: BoneSocket;

  readonly socketName: string;

  readonly sourceRig: cmp_rig;

  readonly targetBone: RigIKHandleTarget;

}

declare class WaveRigIKHandleBuilder {

  constructor(_commit: WaveRigIKHandleIntentCommit);

  allowOutOfReach(): this;

  at(part: WaveModelPartId): this;

  boundedByReach(): this;

  create(): WaveRigIKHandleIntent;

  IKstep(steps: number, options?: Omit<WaveRigIKIntent, "steps">): this;

  IKtoRoot(options?: Omit<WaveRigIKIntent, "steps">): this;

  inheritScale(): this;

  offset(offset: WaveRigSocketOffset): this;

  preserveWorldScale(): this;

  toIntent(): WaveRigIKHandleIntent;

  withIK(options: Omit<WaveRigIKIntent, "steps">): this;

  withOffset(offset: WaveRigSocketOffset): this;

}

interface WaveRigIKHandleIntent {

  readonly ik: WaveRigIKIntent;

  readonly offset?: WaveRigSocketOffset | undefined;

  readonly part: string;

  readonly scaleMode?: WaveRigSocketScaleMode | undefined;

  readonly sphere?: boolean | undefined;

  readonly name: string;

}

type WaveRigIKHandleIntentCommit = (intent: WaveRigIKHandleIntent) => WaveRigIKHandleIntent;

interface WaveRigIKHandleTargetPoseOptions {

  readonly onlyMovedHandles?: boolean;

  readonly skipUnavailableHandles?: boolean;

}

interface WaveRigIKIntent {

  readonly damping?: number;

  readonly maxIterations?: number;

  readonly reach?: WaveRigIKReachMode;

  readonly steps: WaveRigIKStepCount;

  readonly tolerance?: number;

}

interface WaveRigIKOptions {

  readonly end?: WaveModelEndEffectorId;

  readonly endEffector?: WaveModelEndEffectorId;

  readonly joints?: readonly WaveModelJointId[];

  readonly pole?: WaveModelOriginMetadata;

  readonly root?: WaveModelPartId;

}

type WaveRigIKReachMode = "reachable" | "free";

type WaveRigIKStepCount = number | "root";

type WaveRigInput = WaveRigAuthoringHandle | WaveRigAuthoringConfig;

interface WaveRigNamedPoseRecipe {

  readonly fromPose?: WaveRigPoseInput | undefined;

  readonly operations?: readonly WaveRigPoseOperation[] | undefined;

  readonly parts?: readonly WaveRigPosePartRecipe[] | undefined;

  readonly skipMissingParts?: boolean | undefined;

  readonly name: string;

}

type WaveRigPaintFalloff = "smooth" | "linear" | "hard";

interface WaveRigPaintIntent {

  readonly center: Vector3Like | WaveModelVec3Tuple;

  readonly falloff?: WaveRigPaintFalloff;

  readonly maxInfluences?: number;

  readonly maxPlaneDistance?: number;

  readonly mode?: WaveRigPaintMode;

  readonly normal?: DirectionInput;

  readonly part: WaveModelPartId;

  readonly radius: number;

  readonly space?: WaveRigPaintSpace;

  readonly strength?: number;

}

type WaveRigPaintMode = "add" | "replace" | "subtract";

type WaveRigPaintSpace = "world" | "parent" | "mesh";

type WaveRigPartCommit = (name: string, options: WaveRigPartOptions) => WaveRigAuthoringHandle;

interface WaveRigPartOptions {

  readonly at?: Vector3Like | WaveModelVec3Tuple;

  readonly length?: number;

  readonly parent?: WaveModelPartId | null;

}

type WaveRigPartOriginLookup = (part: WaveModelPartId) => WaveModelVec3Tuple;

declare class WaveRigPartPlacementBuilder {

  constructor(_name: string, _commit: WaveRigPartCommit, _lookupPartOrigin: WaveRigPartOriginLookup);

  asRoot(): this;

  at(point: Vector3Like | WaveModelVec3Tuple): this;

  create(): WaveRigAuthoringHandle;

  from(part: WaveModelPartId): this;

  length(length: number): this;

  moveBackward(distance: number): this;

  moveBy(direction: DirectionInput, distance: number): this;

  moveDown(distance: number): this;

  moveForward(distance: number): this;

  moveLeft(distance: number): this;

  moveRight(distance: number): this;

  moveUp(distance: number): this;

  moveX(distance: number): this;

  moveY(distance: number): this;

  moveZ(distance: number): this;

}

declare class WaveRigPoseAuthoringBuilder {

  constructor(_rig: cmp_rig, _name: string, _onSaved?: ((snapshot: WaveModelRigPoseSnapshotMetadata) => void) | undefined, _applyBasePoseSnapshot?: ((snapshot: WaveModelRigPoseSnapshotMetadata) => void) | undefined, _capturePoseSnapshot?: ((name: string) => WaveModelRigPoseSnapshotMetadata) | undefined, _operationHost?: WaveRigPoseOperationHost | undefined, _saveTransaction?: ((save: () => WaveModelRigPoseSnapshotMetadata) => WaveModelRigPoseSnapshotMetadata) | undefined);

  apply(operations: readonly WaveRigPoseOperation[], options?: WaveRigPoseRecipeOptions): this;

  chain(prefix: string): WaveRigPoseChainBuilder;

  entity(entity: WaveRigPosePartRef): WaveRigPosePartBuilder<this>;

  fromPose(pose: WaveRigPoseInput): this;

  part(part: WaveRigPosePartRef): WaveRigPosePartBuilder<this>;

  save(): WaveModelRigPoseSnapshotMetadata;

  solveIK(part: WaveRigPosePartRef): WaveRigPoseIKBuilder;

}

declare class WaveRigPoseChainBuilder {

  constructor(_pose: WaveRigPoseAuthoringBuilder, _prefix: string);

  segments(suffixes: readonly string[]): WaveRigPoseChainSegmentsBuilder;

}

declare class WaveRigPoseChainSegmentsBuilder {

  constructor(_pose: WaveRigPoseAuthoringBuilder, _parts: readonly WaveRigPosePartRef[]);

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  moveBy(direction: DirectionInput, distance: number | readonly number[]): WaveRigPoseAuthoringBuilder;

  rotateAroundBy(axis: DirectionInput, degrees: number | readonly number[]): WaveRigPoseAuthoringBuilder;

  rotateAroundTo(axis: DirectionInput, degrees: number | readonly number[]): WaveRigPoseAuthoringBuilder;

}

type WaveRigPoseDirectionAmount = readonly [DirectionInput, number] | { readonly direction: DirectionInput; readonly amount: number; }

type WaveRigPoseFrameInput = WaveRigPoseFrameKind | WaveRigPoseFrameState;

type WaveRigPoseFrameKind = "local" | "world" | "parent";

interface WaveRigPoseFrameState {

  readonly kind: WaveRigPoseFrameKind;

  readonly parentDepth: number;

}

declare class WaveRigPoseIKBuilder {

  constructor(_pose: WaveRigPoseAuthoringBuilder, _part: WaveRigPosePartRef);

  allowOutOfReach(): this;

  boundedByReach(): this;

  IKstep(steps: number, options?: RigIKOptions): this;

  IKtoRoot(options?: RigIKOptions): this;

  moveTo(target: WaveRigPoseIKTarget): WaveRigPoseAuthoringBuilder;

  withIK(options: RigIKOptions): this;

}

type WaveRigPoseIKTarget = TransformReferenceLike | WavePointInput;

type WaveRigPoseInput = string | WaveModelRigPoseSnapshotMetadata;

type WaveRigPoseOperation = { readonly kind: "rotateAroundBy"; readonly part: WaveRigPosePartRef; readonly frame: WaveRigPoseFrameState; readonly axis: DirectionInput; readonly degrees: number; } | { readonly kind: "rotateAroundTo"; readonly part: WaveRigPosePartRef; readonly frame: WaveRigPoseFrameState; readonly axis: DirectionInput; readonly degrees: number; } | { readonly kind: "moveBy"; readonly part: WaveRigPosePartRef; readonly frame: WaveRigPoseFrameState; readonly direction: DirectionInput; readonly distance: number; } | { readonly kind: "solveIKTo"; readonly part: WaveRigPosePartRef; readonly target: WaveRigPoseIKTarget; readonly ik: RigBoneIKOptions; }

declare class WaveRigPosePartBuilder<TRoot extends WaveRigPoseOperationSink = WaveRigPoseAuthoringBuilder> {

  constructor(_pose: TRoot, _part: WaveRigPosePartRef);

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  moveBackward(distance: number): TRoot;

  moveBy(direction: DirectionInput, distance: number): TRoot;

  moveDown(distance: number): TRoot;

  moveForward(distance: number): TRoot;

  moveLeft(distance: number): TRoot;

  moveRight(distance: number): TRoot;

  moveUp(distance: number): TRoot;

  rotateAroundBy(axis: DirectionInput, degrees: number): TRoot;

  rotateAroundTo(axis: DirectionInput, degrees: number): TRoot;

}

interface WaveRigPosePartRecipe {

  readonly frame?: WaveRigPoseFrameInput;

  readonly moveBy?: readonly WaveRigPoseDirectionAmount[];

  readonly part: WaveRigPosePartRef;

  readonly rotateAroundBy?: readonly WaveRigPoseDirectionAmount[];

  readonly rotateAroundTo?: readonly WaveRigPoseDirectionAmount[];

}

type WaveRigPosePartRef = string | BodyPart;

interface WaveRigPoseRecipe {

  readonly skipMissingParts?: boolean | undefined;

  readonly fromPose?: WaveRigPoseInput;

  readonly operations?: readonly WaveRigPoseOperation[];

  readonly parts?: readonly WaveRigPosePartRecipe[];

}

interface WaveRigPoseRecipeOptions {

  readonly skipMissingParts?: boolean;

}

interface WaveRigSkinAuthoringCommitResult {

  readonly changedVertexCount: number;

  readonly channels: WaveCompiledSkinWeightChannels;

  readonly delta: WaveSkinWeightEditDelta;

  readonly diagnostics: WaveSkinWeightDiagnostics;

  readonly dirtyVertexRanges: readonly WaveSkinWeightDirtyRange[];

}

interface WaveRigSkinAuthoringOptions {

  readonly currentPosePositions?: Float32Array;

  readonly maxActiveInfluences?: number;

  readonly mesh?: string | unknown;

  readonly selectionSurface?: WaveSkinSelectionSurface;

  readonly spatialCellSize?: number;

}

declare class WaveRigSkinAuthoringSession {

  constructor(rig: cmp_rig, options?: WaveRigSkinAuthoringOptions);

  cancel(): void;

  commit(): WaveRigSkinAuthoringCommitResult;

  flood(part: WaveRigPosePartRef, weight: number, mask?: WaveRigSkinBrushMask): this;

  gradient(part: WaveRigPosePartRef, operation: Omit<WaveSkinWeightGradientEdit, "jointIndex">): this;

  inspect(vertexIndex: number): WaveSkinWeightVertexInspection;

  readonly mesh: unknown;

  normalize(mask?: WaveRigSkinBrushMask): this;

  paint(part: WaveRigPosePartRef): WaveRigSkinPaintBuilder;

  pruneBelow(threshold: number, mask?: WaveRigSkinBrushMask): this;

  readonly rawSession: WaveSkinWeightEditSession;

  readonly rig: cmp_rig;

  smooth(mask?: WaveRigSkinBrushMask, strength?: number, iterations?: number): this;

}

interface WaveRigSkinBrushMask {

  readonly center?: Vector3Like;

  readonly maxPlaneDistance?: number;

  readonly normal?: Vector3Like;

  readonly radius?: number;

  readonly vertexIndices?: ArrayLike<number>;

}

interface WaveRigSkinIntent {

  readonly channelCapacity?: 4 | 8;

  readonly distanceField?: WaveRigHeatMapSkinOptions;

  readonly heatMap?: WaveRigHeatMapSkinOptions;

  readonly maxInfluences?: number;

  readonly paint?: readonly WaveRigPaintIntent[];

  readonly preserveExistingWeights?: boolean;

  readonly target?: "currentModel";

  readonly weights?: WaveRigSkinWeightMode;

}

declare class WaveRigSkinPaintBuilder {

  constructor(_session: WaveRigSkinAuthoringSession, _jointIndex: number);

  add(amount: number): this;

  apply(): WaveRigSkinAuthoringSession;

  at(center: Vector3Like): this;

  falloff(falloff: WaveSkinWeightPaintFalloff): this;

  opacity(opacity: number): this;

  preserve(part: WaveRigPosePartRef): this;

  radius(radius: number): this;

  remove(amount: number): this;

  setWeight(weight: number): this;

  vertices(vertexIndices: ArrayLike<number>): this;

  withinPlane(normal: Vector3Like, maxDistance: number): this;

}

type WaveRigSkinWeightMode = "empty" | "nearest-bone" | "distance-field" /** @deprecated Compatibility alias for distance-field. */ | "heat-map";

declare class WaveRigSocketBuilder {

  constructor(_commit: WaveRigSocketIntentCommit);

  at(part: WaveModelPartId): this;

  create(): WaveRigSocketIntent;

  inheritScale(): this;

  offset(offset: WaveRigSocketOffset): this;

  preserveWorldScale(): this;

  toIntent(): WaveRigSocketIntent;

  withOffset(offset: WaveRigSocketOffset): this;

}

interface WaveRigSocketIntent {

  readonly offset?: WaveRigSocketOffset | undefined;

  readonly part: string;

  readonly scaleMode?: WaveRigSocketScaleMode | undefined;

  readonly sphere?: boolean | undefined;

  readonly name: string;

}

type WaveRigSocketIntentCommit = (intent: WaveRigSocketIntent) => WaveRigSocketIntent;

interface WaveRigSocketOffset {

  readonly position?: Vector3Like | WaveModelVec3Tuple;

  readonly rotation?: { readonly x: number; readonly y: number; readonly z: number; readonly w: number; }

}

type WaveRigSocketScaleMode = "inherit" | "preserve-world";

declare class WaveRope extends WaveGroup<waveThinBatch> {

  anchorNode(nodeIndex: number, target: WaveSoftBodyAttachmentTarget, options?: WaveSoftBodyAttachmentOptions): this;

  captureRestState(): this;

  destroy(): void;

  getNode(index: number): WaveSoftBodyNodeHandle;

  getNodeWorldPositionsToRef(targets: readonly Vector3[]): readonly Vector3[];

  isDestroyed: boolean;

  nodeCount: number;

  nodes: readonly WaveSoftBodyNodeHandle[];

  physicsBatch: waveThinBatch | undefined;

  pinAllNodes(): this;

  pinNode(nodeIndex: number): this;

  relaxToRest(): this;

  resetToRest(): this;

  surface: wavePlane | undefined;

  unanchorNode(nodeIndex: number): boolean;

  unpinAllNodes(): this;

  unpinNode(nodeIndex: number): this;

  visualBatch: waveThinBatch | undefined;

  constructor(options: RopeChainOptions, scene?: WaveGroupSceneBridge);

  attachEndTo(target: WaveSoftBodyAttachmentTarget, options?: WaveSoftBodyAttachmentOptions): this;

  attachStartTo(target: WaveSoftBodyAttachmentTarget, options?: WaveSoftBodyAttachmentOptions): this;

  getEndNode(): WaveSoftBodyNodeHandle;

  getStartNode(): WaveSoftBodyNodeHandle;

  get segments(): number;

  toConfig(): WaveRopeConfig;

}

declare class WaveRopeBuilder {

  avoidCollisionWith(...targets: WaveSoftBodyCollisionTarget[]): this;

  avoidCollisionWithinGroup(): this;

  captureRestState(): this;

  constructor(_scene: WaveSoftBodyBuilderScene);

  along(path: WaveRopePathInput): this;

  apply(): WaveRope;

  attachEndTo(target: Parameters<WaveRope["attachEndTo"]>[0], options?: WaveSoftBodyAttachmentOptions): this;

  attachStartTo(target: Parameters<WaveRope["attachStartTo"]>[0], options?: WaveSoftBodyAttachmentOptions): this;

  build(): WaveRope;

  color(color: ColorInput): this;

  damping(value: number): this;

  distanceSlack(ratio: number): this;

  distanceSlackRatio(ratio: number): this;

  from(position: WavePointInput): this;

  fromOptions(options: Partial<RopeChainOptions>): this;

  inDirection(direction: DirectionInput): this;

  named(name: string): this;

  nodeMass(mass: number): this;

  nodeRadius(radius: number): this;

  pinEnd(enabled?: boolean): this;

  pinStart(enabled?: boolean): this;

  ropeRadius(radius: number): this;

  segmentLength(length: number): this;

  segments(count: number): this;

  springConstraints(config: SpringConfig): this;

}

interface WaveRopeConfig {

  attachments: WaveSoftBodyAttachmentConfig[];

  constraints: WaveSoftBodyDistanceConstraintConfig[];

  name: string;

  nodeCount: number;

  nodes: WaveSoftBodyNodeConfig[];

  pins: number[];

  restStates: WaveSoftBodyNodeConfig[];

  visuals: WaveSoftBodyVisualConfig;

  bakedPoints: WavePathExtrusionSerializedPoint[];

  kind: "rope";

  options: { segments: number; segmentLength: number; startPosition?: WavePathExtrusionSerializedPoint; direction?: DirectionInput; nodeMass: number; nodeRadius: number; damping: number; distanceSlackRatio: number; constraintSpring?: SpringConfig; pinStart: boolean; pinEnd: boolean; }

  segmentLengths: number[];

  segments: number;

  sourcePath?: WaveRopeSourcePathConfig;

}

interface WaveRopePathInput {

  length(options?: { space?: "world" | "local"; }): number;

  toDefinition?(): WavePathDefinition;

  uniformSamples(sampleCount: number, options?: { space?: "world" | "local"; }): Vector3[];

}

interface WaveRopeSourcePathConfig {

  definition?: WavePathDefinition;

  kind: "wavePathDefinition" | "sampledPath";

  length?: number;

  sampleCount: number;

}

interface WaveRuntimeCapabilities {

  readonly canPlayDirectAudio: boolean;

  readonly canRender: boolean;

  readonly canSimulatePhysics: boolean;

  readonly canUseWebGpu: boolean;

  readonly canUseWorkerWebGpu: boolean;

  readonly hasBrowserShell: boolean;

  readonly hasDom: boolean;

  readonly hasWebXR: boolean;

  readonly isCrossOriginIsolated: boolean;

  readonly placement: WaveRuntimePlacement;

}

type WaveRuntimePlacement = "window" | "realtime-worker" | "headless";

interface WaveSafeDivideValueCurveOptions {

  epsilon?: number;

  fallback?: number;

}

interface WaveSafeDivideValueCurveSpec {

  readonly denominator: WaveValueCurveSpec;

  readonly epsilon: number;

  readonly fallback: number;

  readonly kind: "safeDivide";

  readonly numerator: WaveValueCurveSpec;

}

type WaveSampledFieldBoundary = "clamp" | "zero";

type WaveSampledFieldCurveCoordinate = "x" | "y" | "z" | "radius" | "height" | "index";

type WaveSampledFieldSampling = "nearest" | "linear" | "bilinear" | "trilinear";

interface WaveSampledFieldVectorCurveConfig {

  readonly direction?: Direction;

  readonly input?: WaveSampledFieldCurveCoordinate;

  readonly maxSamples?: number;

  readonly strength?: WaveValueCurveInput;

  readonly x?: WaveValueCurveInput;

  readonly y?: WaveValueCurveInput;

  readonly z?: WaveValueCurveInput;

}

type WaveSampledValueCurveInterpolation = "stage" | "linear" | "smooth";

interface WaveSampledValueCurveSpec {

  readonly interpolation: WaveSampledValueCurveInterpolation;

  readonly kind: "sampled";

  readonly samples: readonly WaveValueCurveSample[];

}

declare class WaveScalarSurfaceStateBuilder<TOwner extends wave3DObject = wave3DObject> {

  constructor(_model: module_visual3DModelSurfaceState<TOwner>, _id: string);

  acceptsWrites(options?: WaveSurfaceStateWriteAcceptanceOptions): this;

  apply(): WaveScalarSurfaceStateHandle;

  decay(options: WaveSurfaceStateDecayOptions): this;

  evolvesWith(evolution: WaveResponseDefinition): this;

  onMeshUv0(target: WaveVisualTargetRef): this;

  onWorldPlane(frame: WavePlaneFrameIntent, coverage: WaveRelativeCoveragePlan): this;

  resolution(size: number): this;

  resolution(width: number, height: number): this;

}

interface WaveScalarSurfaceStateDefinition {

  readonly evolution: WaveResponseDefinition;

  readonly id: string;

  readonly mapping: WaveSurfaceStateMapping;

  readonly resolution: WaveSurfaceStateResolution;

  readonly schema: typeof WAVE_SCALAR_SURFACE_STATE_SCHEMA;

  readonly writes: WaveSurfaceStateWritePlan;

}

interface WaveScalarSurfaceStateHandle {

  acceptGpuContacts(stream: WaveGpuEventStreamRef, options: WaveSurfaceStateGpuContactOptions): WaveScalarSurfaceStateHandle;

  clearGpuContactWrites(): WaveScalarSurfaceStateHandle;

  readonly definition: WaveScalarSurfaceStateDefinition;

  point(point: WaveSurfaceStatePoint, options: WaveSurfaceStateWriteOptions): WaveSurfaceStateWriteResult;

  readonly ref: WaveScalarSurfaceStateRef;

  reset(): WaveSurfaceStateWriteResult;

  stroke(start: WaveSurfaceStatePoint, end: WaveSurfaceStatePoint, options: WaveSurfaceStateWriteOptions): WaveSurfaceStateWriteResult;

  writeFromHit(hit: WaveSurfaceStateHit, options: WaveSurfaceStateWriteOptions): WaveSurfaceStateWriteResult;

}

interface WaveScalarSurfaceStateRef {

  readonly owner: WaveEntityIdentityRef;

  readonly schema: typeof WAVE_SCALAR_SURFACE_STATE_REF_SCHEMA;

  readonly stateId: string;

}

type WaveScaleChangedCallback<TTarget = WaveObject, TScale = Vector3> = (target: TTarget, newScale: TScale) => void;

interface WaveSceneAnimatedCursorOptions {

  readonly height?: number | undefined;

  readonly hideNative?: boolean | undefined;

  readonly hotspot?: WaveSceneCursorHotspot | undefined;

  readonly name?: string | undefined;

  readonly offset?: WaveSceneCursorOffset | undefined;

  readonly size?: number | WaveSceneCursorSize | undefined;

  readonly touchMode?: WaveSceneCursorTouchMode | undefined;

  readonly width?: number | undefined;

  readonly flipbook: WaveSceneCursorFlipbookSpec;

}

interface WaveSceneAnimationBinding {

  readonly ref: ExactAssetRef<"animation">;

  release(): void;

  readonly value: AnimationSceneTemplateValue;

}

interface WaveSceneAssetInfo {

  readonly descriptor: AssetDescriptor<SceneFacadeAssetFamily>;

  readonly identity: AssetIdentity<SceneFacadeAssetFamily>;

  readonly revision: ExactAssetRef<SceneFacadeAssetFamily>;

}

interface WaveSceneAssets {

  baseUrl?: string;

  loaders?: readonly WaveAssetLoaderDeclaration[];

  manifest: readonly string[];

  pixelReadbackTextures?: string[];

  projectCatalog?: ProjectAssetCatalog;

  usedAssets?: string[];

}

interface WaveSceneAssetsFacade {

  readonly baseUrl?: string;

  bindData(assetId: string, consumerId: string): WaveSceneDataBinding;

  bindMaterial(assetId: string, consumerId: string): WaveSceneMaterialBinding;

  bindTexture(assetId: string, consumerId: string, intent?: TextureBindingIntent): WaveSceneTextureBinding;

  get(family: SceneFacadeAssetFamily, assetId: string): WaveSceneAssetInfo | null;

  has(family: SceneFacadeAssetFamily, assetId: string): boolean;

  readonly manifest: readonly string[];

}

interface WaveSceneAudioBinding {

  readonly ref: ExactAssetRef<"audio">;

  release(): void;

  readonly value: AudioSceneAssetValue;

}

interface WaveSceneCameraConfig {

  constraints?: readonly CameraConstraintConfig[];

  far?: number;

  fov?: number;

  gestureOrbit?: { enabled: boolean; rotateSensitivity?: number; panSensitivity?: number; zoomSensitivity?: number; }

  near?: CameraNearPlaneInput;

  orbit?: OrbitOptions | null;

  target?: WavePointInput | WaveSpatial3DEntity | WaveGroup;

  targetOptions?: OrbitTargetOptions;

}

declare class WaveSceneCameraOrbitConfigurator<TEngine extends unknown = unknown> {

  constructor(_camera: CameraConfigurator<TEngine>);

  apply(): WaveScene<TEngine>;

  cameraPosition(cameraPosition: WavePointInput): this;

  distance(distance: number): this;

  fov(fov: number): this;

  panSensitivity(panSensitivity: number): this;

  rotateSensitivity(rotateSensitivity: number): this;

  sensitivity(sensitivity: OrbitTRSSensitivity): this;

  target(target: WavePointInput): this;

  zoomSpeed(zoomSpeed: number): this;

}

interface WaveSceneCanvasScreenScope {

  normalized(screenX: number, screenY: number): WaveScreenPointRef;

  pixel(screenX: number, screenY: number): WaveScreenPointRef;

  projectWorldToNormalized(worldPos: Vector3Like): WaveCanvasNormalizedPoint;

  projectWorldToPixel(worldPos: Vector3Like): WaveCanvasPixelPoint;

  viewportNormalized(x: number, y: number, width: number, height: number): WaveCanvasNormalizedViewport;

  viewportPixels(x: number, y: number, width: number, height: number): WaveCanvasNormalizedViewport;

}

interface WaveSceneControlOptions {

  readonly profileId?: string;

  readonly targetClientId?: string | string[];

}

declare class WaveSceneControls<TEngine extends unknown = unknown> {

  constructor(_scene: WaveScene<TEngine>);

  clearBindings(actionName: string, options?: WaveSceneControlOptions): this;

  disableSchema(schemaName: ControlSchemaName, options?: WaveSceneControlOptions): this;

  enableSchema(schemaName: ControlSchemaName, options?: WaveSceneControlOptions): this;

  getBindings(actionName: string, profileId?: string): ActionBindingsInfo;

  rebind(actionName: string, keys: Keyboard | readonly Keyboard[], options?: WaveSceneControlOptions): this;

  rebindAxis(actionName: string, directions: KeyboardAxis2DBindings, options?: WaveSceneControlOptions): this;

  resetAllBindings(options?: WaveSceneControlOptions): this;

  setBindings(actionName: string, bindings: readonly ActionMapBinding[], options?: WaveSceneControlOptions): this;

}

declare class WaveSceneCursorFacade<TEngine extends unknown = unknown> {

  flipbook(flipbook: WaveSceneCursorFlipbookSpec, options?: Omit<WaveSceneCursorOptions, "flipbook">): this;

  followTouch(): this;

  fps(framesPerSecond: number): this;

  frameRate(frameRate: number): this;

  hideNative(): this;

  hotspot(hotspot: WaveSceneCursorHotspot): this;

  hotspotAt(x: number, y: number): this;

  ignoreTouch(): this;

  get isDisposed(): boolean;

  loop(enabled?: boolean): this;

  offset(x: number, y: number): this;

  once(): this;

  pause(): this;

  play(): this;

  restart(): this;

  restoreNative(): this;

  showNative(): this;

  showWhileTouching(): this;

  size(width: CursorDimension | WaveSceneCursorSize, height?: CursorDimension): this;

  touchMode(mode: WaveSceneCursorTouchMode): this;

  useAnimatedMaterial(material: WaveSceneCursorMaterialInput, options: WaveSceneAnimatedCursorOptions): this;

  useAnimatedSprite(sprite: WaveSceneCursorMaterialInput, options: WaveSceneAnimatedCursorOptions): this;

  useAnimatedTexture(texture: WaveSceneCursorMaterialInput, options: WaveSceneAnimatedCursorOptions): this;

  useMaterial(material: WaveSceneCursorMaterialInput, options?: WaveSceneCursorOptions): this;

  useSprite(sprite: WaveSceneCursorMaterialInput, options?: WaveSceneCursorOptions): this;

  useTexture(texture: WaveSceneCursorMaterialInput, options?: WaveSceneCursorOptions): this;

}

type WaveSceneCursorFlipbookSpec = Omit<TextureFlipbookSpec, "playMode"> & { readonly startFrame?: number; readonly playMode?: TextureFlipbookSpec["playMode"]; }

type WaveSceneCursorHotspot = WaveUIAnchor | { readonly x: number; readonly y: number; }

type WaveSceneCursorMaterialInput = string;

interface WaveSceneCursorOffset {

  readonly x: number;

  readonly y: number;

}

interface WaveSceneCursorOptions {

  readonly flipbook?: WaveSceneCursorFlipbookSpec;

  readonly height?: CursorDimension;

  readonly hideNative?: boolean;

  readonly hotspot?: WaveSceneCursorHotspot;

  readonly name?: string;

  readonly offset?: WaveSceneCursorOffset;

  readonly size?: CursorDimension | WaveSceneCursorSize;

  readonly touchMode?: WaveSceneCursorTouchMode;

  readonly width?: CursorDimension;

}

interface WaveSceneCursorSize {

  readonly height: CursorDimension;

  readonly width: CursorDimension;

}

type WaveSceneCursorTouchMode = "auto" | "ignore" | "while-touching" | "always";

interface WaveSceneDataBinding {

  release(): void;

  readonly value: DataPayload;

}

interface WaveSceneDataJsonOps {

  addField(record: WaveSceneDataRecord, path: string | string[], value: WaveSceneDataValue): void;

  del(record: WaveSceneDataRecord, path: string | string[]): boolean;

  get(record: WaveSceneDataRecord, path: string | string[]): WaveSceneDataValue | undefined;

  inc(record: WaveSceneDataRecord, path: string | string[], delta?: number): number;

  push(record: WaveSceneDataRecord, path: string | string[], value: WaveSceneDataValue): number;

  set(record: WaveSceneDataRecord, path: string | string[], value: WaveSceneDataValue): void;

}

type WaveSceneDataPrimitive = string | number | boolean | null;

interface WaveSceneDataRecord {

  [key: string]: WaveSceneDataValue;

}

interface WaveSceneDataStore {

  readonly available: boolean;

  getRecord(name: string): Promise<WaveSceneDataRecord | null>;

  readonly json: WaveSceneDataJsonOps;

  readonly maxRecordBytes: number;

  openRecord(name: string): Promise<WaveSceneDataRecord>;

  readonly reason?: string;

  removeRecord(name: string): Promise<{ ok: boolean; }>;

  requireRecord(name: string): Promise<WaveSceneDataRecord>;

  saveRecord(name: string, record?: WaveSceneDataRecord): Promise<{ ok: boolean; bytes?: number; maxBytes?: number; }>;

}

type WaveSceneDataValue = WaveSceneDataPrimitive | WaveSceneDataRecord | WaveSceneDataValue[];

type WaveSceneDragCallback<TTarget extends wave3DObject = wave3DObject> = (context: WaveSceneDragCallbackContext<TTarget>) => void;

interface WaveSceneDragCallbackContext<TTarget extends wave3DObject = wave3DObject> {

  readonly currentPosition: Vector3;

  readonly delta: Vector3;

  readonly distanceDragged: number;

  readonly dragStartedAt: number;

  readonly endPosition: Vector3 | null;

  readonly mesh: unknown;

  readonly phase: WaveSceneDragPhase;

  readonly startPosition: Vector3;

  readonly target: TTarget;

  readonly timestamp: number;

  readonly totalDelta: Vector3;

  readonly totalDistanceDragged: number;

}

interface WaveSceneDraggableCameraConfig {

  readonly lockWhileDragging: boolean;

}

interface WaveSceneDraggableConfig {

  readonly camera: WaveSceneDraggableCameraConfig;

  readonly dragDeltaRatio: number;

  readonly meshScope: MeshScope;

  readonly pointer: WaveSceneDraggablePointerConfig;

  readonly projection: WaveSceneDraggableProjection;

}

interface WaveSceneDraggableEngine {

  tryGetSystem(key: "rendering"): WaveSceneDraggableRenderingSystem | null;

}

interface WaveSceneDraggableHandle<TTarget extends wave3DObject = wave3DObject> {

  getConfig(): WaveSceneDraggableConfig;

  getIntent(): WaveSceneDraggableIntent;

  readonly kind: "waveScene.draggable";

  off(): void;

  onDrag(callback: WaveSceneDragCallback<TTarget>): this;

  onDragEnd(callback: WaveSceneDragCallback<TTarget>): this;

  onDragMove(callback: WaveSceneDragCallback<TTarget>): this;

  onDragStart(callback: WaveSceneDragCallback<TTarget>): this;

  setEnabled(enabled: boolean): this;

  sync(): void;

  readonly target: TTarget;

}

interface WaveSceneDraggableIntent {

  readonly config: WaveSceneDraggableConfig;

  readonly driver: "babylon.pointerDragBehavior";

  readonly kind: "interaction.dragMove";

  readonly target: { readonly id: number; readonly name: string; readonly runtimeRef: string; }

}

interface WaveSceneDraggablePointerConfig {

  readonly mouseButton: MouseButton;

}

type WaveSceneDraggableProjection = { readonly kind: "screen"; } | { readonly kind: "plane"; readonly normal: DirectionInput; } | { readonly kind: "axis"; readonly axis: DirectionInput; }

interface WaveSceneDraggableRenderingSystem {

  lockCameraControls(caller: string): void;

  unlockCameraControls(caller: string): void;

}

interface WaveSceneDraggableScene {

  add(entity: WaveEntity): unknown;

  readonly engine?: WaveSceneDraggableEngine | null;

}

type WaveSceneDragPhase = "start" | "move" | "end";

interface WaveSceneEngineAuthoringContext {

  readonly canvas: HTMLCanvasElement | OffscreenCanvas | null;

  readonly capabilities: { readonly canRender: boolean; }

  readonly tickNumber: number;

}

interface WaveSceneEnvironmentReflectionSource {

  readonly id: string;

  readonly kind: "sceneEnvironment";

  readonly schema: typeof WAVE_REFLECTION_SOURCE_SCHEMA;

}

interface WaveSceneFogConfig {

  color?: ColorInput;

  density?: number;

  end?: number;

  mode?: FogMode;

  start?: number;

  streaming?: WaveStreamingFogPolicy | null;

}

interface WaveSceneFontBinding {

  readonly ref: ExactAssetRef<"font">;

  release(): void;

  readonly value: FontBindingValue;

}

interface WaveSceneFxDefinitionBinding {

  readonly ref: ExactAssetRef<"data">;

  release(): void;

  readonly value: FxDefinitionAssetValue;

}

declare class WaveSceneGeometryInfluenceTooling {

  fromSkinWeights(target: WaveSceneInfluenceViewTarget, options?: MeshSkinInfluenceFieldOptions): WaveGeometryInfluenceField;

  fromSurfaceSelection(target: WaveSceneInfluenceViewTarget, selection: WaveModelSurfaceSelectionDefinition): WaveGeometryInfluenceField;

}

declare class WaveSceneHostFacade {

  constructor(_resolveRuntime: () => WaveSceneHostRuntime | null);

  reload(): boolean;

}

interface WaveSceneHostRuntime {

  reloadHostRuntime(): boolean;

}

interface WaveSceneHotReloadClassification {

  entityCount: number;

  forceFullReload: boolean;

  hasAssets: boolean;

  hasBootstrapScaffold: boolean;

  hasInstruments: boolean;

  hasMediaCapture: boolean;

  hasNetworking: boolean;

  hasRequiredConsents: boolean;

  hasSetup: boolean;

  hasTerrain: boolean;

  hasTTS: boolean;

  hasWorldStreaming: boolean;

  hasXR: boolean;

  plan?: WaveSceneHotReloadPlan;

  policy?: HotReloadSurfacePolicy;

  preserveBootstrapScaffold: boolean;

  reasons: string[];

  systemAdmissions?: HotReloadSystemAdmission[];

  tier: WaveSceneHotReloadTier;

}

interface WaveSceneHotReloadDiff {

  addedAssets: string[];

  baseUrlChanged: boolean;

  consentsChanged: boolean;

  instrumentsChanged: boolean;

  mediaCaptureChanged: boolean;

  pixelReadbackTexturesChanged: boolean;

  projectCatalogChanged: boolean;

  removedAssets: string[];

  terrainChanged: boolean;

  ttsChanged: boolean;

  unusedAddedAssets: string[];

  unusedRemovedAssets: string[];

  usedAddedAssets: string[];

  usedRemovedAssets: string[];

  worldStreamingChanged: boolean;

  xrChanged: boolean;

}

interface WaveSceneHotReloadOptions {

  activeFilePath?: string | null;

  activeSceneId?: string | null;

  changedFilePaths?: readonly string[];

  forceFullReload?: boolean;

  intent?: WaveHotReloadIntent;

  patchMainOnly?: boolean;

  preferredMode?: "patchMain" | "preserveScene" | "rebuildScene";

  preserveBootstrapScaffold?: boolean;

  preserveCamera?: boolean;

  preserveHmrEntities?: boolean;

  verbose?: boolean;

}

interface WaveSceneHotReloadPlan {

  coordinated: boolean;

  diff: WaveSceneHotReloadDiff;

  preloadAssets: string[];

  preserveBabylonScene: boolean;

  preserveBootstrapSystems: boolean;

  rerunMain: boolean;

  rerunSetup: boolean;

  runInstrumentBootstrap: boolean;

  runTTSBootstrap: boolean;

  runWorldPlanBootstrap: boolean;

  runXRBootstrap: boolean;

}

interface WaveSceneHotReloadResult {

  gpuReset: HotReloadGpuResetLevel;

  policy?: HotReloadSurfacePolicy;

  reasons: string[];

  reloadTier: string;

  runtimeReset: HotReloadRuntimeResetLevel;

  tier: WaveSceneHotReloadTier;

}

interface WaveSceneHotReloadStateBuilder {

  withDefault<TState extends object>(createDefaultState: TState | (() => TState)): WaveSceneHotReloadStateReaderBuilder<TState>;

}

interface WaveSceneHotReloadStateHandle<TState extends object> {

  capture(capture: () => TState): WaveSceneHotReloadStateHandle<TState>;

  clear(): void;

  readonly value: TState;

}

interface WaveSceneHotReloadStateReaderBuilder<TState extends object> {

  restoreWith(reader: (value: unknown) => TState | null): WaveSceneHotReloadStateHandle<TState>;

}

declare enum WaveSceneHotReloadTier {

  COORDINATED = "COORDINATED",

  FULL = "FULL",

  SELECTIVE = "SELECTIVE",

  SIMPLE = "SIMPLE",

}

interface WaveSceneInfluenceViewHandle {

  readonly affectedElementCount: number;

  clear(): void;

  readonly meshCount: number;

  refresh(): boolean;

  readonly source?: WaveGeometryInfluenceSourceRef;

}

interface WaveSceneInfluenceViewModel {

  clearGeometryInfluenceView(): unknown;

  getMeshes(): readonly unknown[];

  setGeometryInfluenceView(state: GeometryInfluenceViewModelState): unknown;

}

type WaveSceneInfluenceViewTarget = WaveSceneInfluenceViewModel | { readonly model?: WaveSceneInfluenceViewModel; }

declare class WaveSceneInteractionsFacade {

  constructor(_scene: WaveSceneDraggableScene);

  makeDraggable<TTarget extends wave3DObject>(target: TTarget): WaveSceneDraggableBuilder<TTarget>;

}

interface WaveSceneLightingConfig {

  ambient?: { color: ColorInput; intensity?: number; }

  environmentIntensity?: number;

  globalIllumination?: GlobalIlluminationConfig | null;

  ibl?: { texture?: string; intensity?: number; }

  indirectLighting?: GlobalIlluminationConfig;

  worldLight?: { direction?: Vector3Like; color?: ColorInput; intensity?: number; shadowEnabled?: boolean; shadowIntensity?: number; shadowDistance?: number; shadowCascades?: WaveShadowCascadeOptions | false; shadowUpdate?: WaveShadowUpdatePolicy; }

}

interface WaveSceneLoadingPlan {

  enabled?: boolean;

  overlay?: LoadingProgressConfig;

  warmup?: WaveSceneWarmupGate;

}

interface WaveSceneMaterialBinding {

  readonly ref: ExactAssetRef<"material">;

  release(): void;

  readonly value: MaterialBindingValue;

}

interface WaveSceneModelBinding {

  readonly ref: ExactAssetRef<"model">;

  release(): void;

  readonly value: WaveSceneModelValue;

}

interface WaveSceneModelReusableFacts {

  readonly objectModel: WaveModelObjectModel;

  readonly policy: ModelRevisionPolicy;

  readonly projectionManifest?: WaveModelProjectionManifest;

}

interface WaveSceneModelValue {

  readonly animationGroups: readonly AnimationGroup[];

  concreteMesh: unknown | null;

  consumer: unknown | unknown | null;

  diagnostics: SimpleGeometryOwnershipDiagnostics;

  failureInjection: SimpleGeometryOwnershipFailureInjection | null;

  geometryOwned: boolean;

  readonly intent: NormalizedModelBindingIntent;

  materialsOwned: boolean;

  meshes: readonly unknown[];

  readonly objectModel: WaveModelObjectModel;

  origin: SimpleGeometryOwnershipOrigin | null;

  ownedMaterials: unknown[];

  readonly policy: ModelRevisionPolicy;

  readonly projection: ModelBindingProjectionFacts;

  readonly projectionManifest?: WaveModelProjectionManifest;

  readonly ref: ExactAssetRef<"model">;

  replaceConsumer: ((previous: unknown | unknown, replacement: unknown | unknown) => void) | null;

  rootNodes: readonly TransformNode[];

  readonly skeletons: readonly unknown[];

  sourceConsumer: unknown | unknown | null;

  readonly template: WaveSceneModelReusableFacts;

  topologyRevision: number;

}

type WaveSceneObjectClass<T extends AnyWaveObject> = Function & { readonly prototype: T; readonly name: string; }

interface WaveSceneOptions {

  hasTerrain?: boolean;

  loading?: WaveSceneLoadingPlan;

  renderingPlan?: WaveSceneRenderingPlan;

  renderProfile?: WaveRenderProfile;

}

interface WaveScenePresentationCameraConfig {

  readonly far?: number;

  readonly fov?: number;

  readonly gestureOrbit?: { readonly enabled: boolean; readonly rotateSensitivity?: number; readonly panSensitivity?: number; readonly zoomSensitivity?: number; }

  readonly near?: number;

  readonly orbit?: WaveScenePresentationOrbitConfig | null;

  readonly target?: WaveScenePresentationPoint;

  readonly targetOptions?: WaveScenePresentationOrbitTargetConfig;

}

interface WaveScenePresentationOrbitConfig {

  readonly cameraPosition?: WaveScenePresentationPoint;

  readonly distance?: number;

  readonly fov?: number;

  readonly panSensitivity?: number;

  readonly rotateSensitivity?: number;

  readonly target?: WaveScenePresentationPoint;

  readonly zoomSpeed?: number;

}

interface WaveScenePresentationOrbitTargetConfig {

  readonly cameraPosition?: WaveScenePresentationPoint;

  readonly distance?: number;

  readonly fov?: number;

}

interface WaveScenePresentationPlan {

  readonly camera?: WaveScenePresentationCameraConfig | undefined;

  readonly fog?: WaveSceneFogConfig | undefined;

  readonly id?: string | undefined;

  readonly lighting?: WaveSceneLightingConfig | undefined;

  readonly postFx?: PostFxPlan | undefined;

  readonly sky?: WaveSceneSkyConfig | undefined;

  readonly assets: readonly string[];

  readonly kind: typeof WAVE_SCENE_PRESENTATION_PLAN_KIND;

  readonly revision: string;

  readonly version: typeof WAVE_SCENE_PRESENTATION_PLAN_VERSION;

}

interface WaveScenePresentationPlanDraft {

  readonly camera?: WaveScenePresentationCameraConfig;

  readonly fog?: WaveSceneFogConfig;

  readonly id?: string;

  readonly lighting?: WaveSceneLightingConfig;

  readonly postFx?: PostFxPlan;

  readonly sky?: WaveSceneSkyConfig;

}

type WaveScenePresentationPlanInput = WaveScenePresentationPlan | WaveScenePresentationPlanLike | WaveScenePresentationPlanDraft;

interface WaveScenePresentationPlanLike {

  toPresentationPlan(): WaveScenePresentationPlan;

}

type WaveScenePresentationPoint = Readonly<SerializableVector3>;

interface WaveScenePrintOptions {

  selectableByMouse?: boolean;

}

declare class WaveSceneReflectionFacade {

  constructor(_runtime: () => WaveSceneReflectionRuntime);

  get environment(): WaveReflectionSourceRef;

  planar(id: string): WavePlanarReflectionSourceBuilder;

  remove(source: string | WaveReflectionSourceRef): void;

  use(source: WaveReflectionSourceDefinition): WaveReflectionSourceRef;

}

interface WaveSceneReflectionRuntime {

  removeReflectionSource(sourceId: string): void;

  upsertReflectionSource(input: { readonly definition: WaveReflectionSourceDefinition; readonly explicitObjects?: readonly unknown[] | null; }): WaveReflectionSourceRef;

}

interface WaveSceneRenderingPlan {

  backbuffer?: RenderBackbufferPolicy;

}

declare enum WaveSceneScreenScope {

  Canvas = "canvas",

  View = "view",

}

declare enum WaveSceneScreenUnit {

  Normalized = "normalized",

  Pixel = "pixel",

}

interface WaveSceneShowInfluenceViewOptions {

  readonly mode?: GeometryInfluenceViewMode;

  readonly source?: WaveGeometryInfluenceSourceRef;

  readonly threshold?: number;

}

interface WaveSceneShowSkinWeightsOptions {

  readonly meshNames?: readonly string[] | undefined;

  readonly metadata?: Readonly<Record<string, unknown>> | undefined;

  readonly name?: string | undefined;

  readonly skeleton?: any;

  readonly sourceTag?: string | undefined;

  readonly mode?: GeometryInfluenceViewMode;

  readonly source?: WaveGeometryInfluenceSourceRef;

  readonly threshold?: number;

}

interface WaveSceneSkyConfig {

  aurora?: AuroraConfig | null;

  backgroundColor?: ColorInput;

  celestialBodies?: CelestialBodiesConfig | null;

  cubeBackground?: Partial<CubeBackgroundState> | null;

  cubeSkybox?: Partial<CubeSkyboxState> | null;

  ibl?: { texture?: string; intensity?: number; }

  physicalAtmosphere?: PhysicalAtmosphereConfig | null;

  proceduralSky?: ProceduralSkyConfig | null;

  skybox?: { texture?: string; fovMultiplier?: number; intensity?: number; size?: number; alpha?: number; rotation?: number; }

  starField?: StarFieldConfig | null;

  timeOfDay?: TimeOfDayConfig | null;

  volumetricClouds?: VolumetricCloudConfig | null;

}

interface WaveSceneSubviewBlurPolicy {

  readonly kernelParameter: string;

  readonly kind: "separableGaussian";

}

type WaveSceneSubviewEnvironment = WaveRenderGraphSceneSubviewEnvironment;

type WaveSceneSubviewObjectPolicy = { readonly kind: "scene"; readonly excludeReceiver: boolean; readonly excludeInternalSurfaces: boolean; } | { readonly kind: "runtime"; readonly emptyExplicitSet: "scene" | "empty"; readonly excludeReceiver: boolean; readonly excludeInternalSurfaces: boolean; }

interface WaveSceneSubviewResolvePolicy {

  readonly effectId: string;

  readonly samplesDepth: boolean;

  readonly sourceMipMaps: boolean;

}

type WaveSceneSubviewSourceView = WaveRenderGraphViewSource;

type WaveSceneSubviewTextureSizePolicy = Extract<WaveRenderGraphTextureSizePolicy, { readonly kind: "absolute"; } | { readonly kind: "viewScale"; }>;

interface WaveSceneTextureBinding {

  readonly ref: ExactAssetRef<"texture">;

  release(): void;

  readonly value: TextureBindingValue;

}

interface WaveSceneToolingTreeNode {

  readonly children: readonly WaveSceneToolingTreeNode[];

  readonly id: number;

  readonly name: string;

  readonly typeName: string;

}

interface WaveSceneToolingTreeSnapshot {

  readonly entityCount: number;

  readonly roots: readonly WaveSceneToolingTreeNode[];

  readonly sceneName: string | null;

  readonly truncated: boolean;

}

interface WaveSceneTransformAuthoringCommitContext {

  reason: WaveSceneTransformAuthoringReason;

  snapshot: ResolvedWorldTransformSnapshot | null;

  tool: WaveSceneTransformAuthoringTool;

}

type WaveSceneTransformAuthoringReason = "select" | "tool" | "drag" | "dragEnd" | "update" | string;

interface WaveSceneTransformAuthoringRegistration {

  allowedTools?: readonly WaveSceneTransformAuthoringTool[];

  commit?: (context: WaveSceneTransformAuthoringCommitContext) => void;

  node?: TransformNode | (() => TransformNode | null);

  onSelect?: (tool: WaveSceneTransformAuthoringTool) => void;

  snapshot?: () => ResolvedWorldTransformSnapshot | null;

}

interface WaveSceneTransformAuthoringRegistrationHandle {

  dispose(): void;

}

interface WaveSceneTransformAuthoringResolveOptions {

  tool?: WaveSceneTransformAuthoringTool | null;

}

interface WaveSceneTransformAuthoringTarget {

  allowedTools: readonly WaveSceneTransformAuthoringTool[];

  commit(context: WaveSceneTransformAuthoringCommitContext): void;

  node: TransformNode;

  snapshot(): ResolvedWorldTransformSnapshot | null;

}

type WaveSceneTransformAuthoringTool = typeof WaveSceneTransformAuthoringTools[keyof typeof WaveSceneTransformAuthoringTools];

interface WaveSceneVideoBinding {

  readonly ref: ExactAssetRef<"video">;

  release(): void;

  readonly timeline: "shared" | "independent";

  readonly value: { readonly texture: unknown; readonly element: HTMLVideoElement; readonly facts: VideoFacts; readonly eventHub: VideoFiniteEventHub; }

}

interface WaveSceneViewScreenScope {

  readonly cameraId: string;

  normalized(screenX: number, screenY: number): WaveScreenPointRef;

  pixel(screenX: number, screenY: number): WaveScreenPointRef;

  projectWorldToNormalized(worldPos: Vector3Like): WaveViewNormalizedPoint;

  projectWorldToPixel(worldPos: Vector3Like): WaveViewPixelPoint;

}

interface WaveSceneWarmupGate {

  enabled?: boolean;

  maxStableFrameTimeMs?: number;

  maxWaitMs?: number;

  stableFrames?: number;

  ticks?: number;

}

declare class WaveSceneWaterFacade {

  constructor(_resolveRuntime: () => WaveSceneWaterRuntime | null, _registerCleanup: (cleanup: () => void) => void);

  latestSamples(modelOrId: WaveWaterBodyModel | string): WaveWaterSurfaceSampleFrame | null;

  remove(modelOrId: WaveWaterBodyModel | string): this;

  render(options: WaveSceneWaterRenderOptions): this;

}

interface WaveSceneWaterRenderOptions {

  readonly model: WaveWaterBodyModel;

  readonly sampleAt?: readonly WaveWaterSurfaceQueryPoint[];

  readonly surface: wave3DObject;

}

interface WaveSceneWaterRuntime {

  getWaterSurfaceSampleFrame(waterBodyId: string): WaveWaterSurfaceSampleFrame | null;

  isWaterFrameGraphAvailable(): boolean;

  removeWaterSceneSubviews(waterBodyId: string): void;

  setWaterSurfaceQueryPoints(waterBodyId: string, points: readonly WaveWaterSurfaceQueryPoint[]): void;

  upsertWaterSceneSubviews(input: { readonly model: WaveWaterBodyModel; readonly receiverMeshes: readonly unknown[]; }): void;

}

interface WaveSceneWeatherConfig {

  intensity?: number;

  type?: "none" | "rain" | "snow";

}

interface WaveSceneWorldGeometryFacade {

  readonly backend: WaveStreamingGeometryBackend | null;

  captureSnapshot(options?: WaveStreamingGeometrySnapshotOptions, layerId?: string): WaveGeometryData | null;

  getBackend(layerId?: string): WaveStreamingGeometryBackend | null;

  getMeshView(layerId?: string): WaveStreamingGeometryMeshView | null;

}

interface WaveSceneWorldRuntimeFacade<TEngine extends unknown = unknown> {

  custom(layerId: string, name: string): WorldCustomElementWorkspaceBuilder<WaveScene<TEngine>>;

  entity(layerId: string, name: string): WorldEntityElementWorkspaceBuilder<WaveScene<TEngine>>;

  grass(layerId: string, name: string): WorldGrassElementWorkspaceBuilder<WaveScene<TEngine>>;

  populate(layerId: string): WorldPopulateWorkspaceBuilder<WaveScene<TEngine>>;

  remove(layerId: string, name: string): WaveScene<TEngine>;

  scatter(layerId: string, name: string): WorldScatterElementWorkspaceBuilder<WaveScene<TEngine>>;

  water(layerId: string, name: string): WorldWaterElementWorkspaceBuilder<WaveScene<TEngine>>;

}

interface WaveSceneWorldSurfaceFacade {

  heightAt(x: number, z: number, layerId?: string): number | null;

  normalAt(x: number, z: number, layerId?: string): WaveSceneWorldSurfaceNormal | null;

  query(position: SurfaceQueryInput, layerId?: string): SurfaceQueryResult | null;

  query(x: number, z: number, layerId?: string): SurfaceQueryResult | null;

  queryAt(position: SurfaceQueryInput, layerId?: string): SurfaceQueryResult | null;

}

type WaveSceneWorldSurfaceNormal = NonNullable<SurfaceQueryResult["normal"]>;

declare class WaveSceneXRFacade {

  constructor(_resolveXRRuntime: () => WaveSceneXRRuntime | null, _resolveVisionRuntime: () => WaveSceneXRVisionRuntime | null, _registerCleanup: (cleanup: () => void) => void);

  disableVisionHands(): boolean;

  enableVisionHands(options?: WaveSceneXRVisionHandsOptions): boolean;

  enter(config?: Partial<XRSessionConfig>): Promise<WaveSceneXRSessionResult | null>;

  exit(): Promise<void>;

  isSupported(mode?: XRSessionConfig["mode"]): Promise<boolean>;

}

interface WaveSceneXRRuntime {

  enterXRMode(config?: Partial<XRSessionConfig>): Promise<WaveSceneXRSessionResult | null>;

  exitXRMode(): Promise<void>;

}

interface WaveSceneXRSessionResult {

  readonly state: WaveSceneXRState;

}

type WaveSceneXRState = "inactive" | "entering" | "active" | "exiting";

interface WaveSceneXRVisionHandsOptions {

  readonly depthEstimation?: boolean;

  readonly mirror?: boolean;

  readonly smoothing?: number;

}

interface WaveSceneXRVisionRuntime {

  disableVisionToXRBridge(): void;

  enableVisionToXRBridge(options?: WaveSceneXRVisionHandsOptions): void;

}

interface WaveScheduledAbcNote {

  atMs: number;

  chordSize: number;

  durationMs: number;

  midiNote: number;

  noteIndex: number;

  source: string;

  sourceEventIndex: number;

  velocity: number;

}

interface WaveScopedObservationBuilder<TEntity extends object, TState = unknown> {

  dispose(): void;

  on(selector: NumericSelector<TEntity>): WaveNumericObservationSource<TEntity>;

  onChangeRate(selectorOrSource: NumericObservationInput<TEntity>): WaveRateObservationSource<TEntity>;

  onDeclineRate(selectorOrSource: NumericObservationInput<TEntity>): WaveRateObservationSource<TEntity>;

  onGrowthRate(selectorOrSource: NumericObservationInput<TEntity>): WaveRateObservationSource<TEntity>;

  when(selector: BooleanSelector<TEntity>): WaveBooleanObservationSource<TEntity>;

}

declare class WaveScreenMedia {

  clear(): this;

  cover(): this;

  disable(): this;

  get distance(): number;

  get editor(): MaterialEditorView;

  enable(): this;

  get enabled(): boolean;

  get fitMode(): ScreenMediaFit;

  hide(): this;

  ignoreSceneLighting(enabled?: boolean): this;

  get ignoresSceneLighting(): boolean;

  get material(): this;

  meshMaterial(name?: string): MaterialEditorView;

  get model(): cmp_visual3DModel;

  setAlphaMode(mode: Parameters<cmp_visual3DModel["setAlphaMode"]>[0]): this;

  setBaseTexture(textureAssetName: string): this;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0]): this;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0], mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0], mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setDepthBias(value: number): this;

  setDistance(distance: number): this;

  setDoubleSided(enabled?: boolean): this;

  setEmissiveColor(color: Parameters<cmp_visual3DModel["setEmissiveColor"]>[0]): this;

  setEmissiveColor(color: Parameters<cmp_visual3DModel["setEmissiveColor"]>[0], mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveColor(color: Parameters<cmp_visual3DModel["setEmissiveColor"]>[0], mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveIntensity(intensity: number): this;

  setEmissiveIntensity(intensity: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveIntensity(intensity: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveTexture(textureAssetName: string): this;

  setEnvironmentIntensity(value: Parameters<cmp_visual3DModel["setEnvironmentIntensity"]>[0]): this;

  setFit(fit: ScreenMediaFit): this;

  setHeightTexture(textureAssetName: string): this;

  setMetalness(value: number): this;

  setMetalness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setMetalness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setMetalnessTexture(textureAssetName: string): this;

  setNormalTexture(textureAssetName: string): this;

  setOpacity(value: number): this;

  setOpacity(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setOpacity(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setRoughness(value: number): this;

  setRoughness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setRoughness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setRoughnessTexture(textureAssetName: string): this;

  setSpecularIntensity(value: number): this;

  setUVOffset(uOffset: number, vOffset: number): this;

  setUVRotation(degrees: number): this;

  setUVRotationRadians(rotation: number): this;

  setUVScale(uScale: number, vScale: number): this;

  show(): this;

  stretch(): this;

  use(assetName: string): this;

  useSceneLighting(): this;

  useTexture(textureAssetName: string): this;

  useVideo(videoAssetName: string): WaveVideoPlayback | null;

  videoMaterial(videoAssetName?: string): WaveVideoPlayback | null;

}

type WaveScreenPointRef = { readonly kind: "screenPoint"; readonly scope: WaveSceneScreenScope.Canvas; readonly unit: WaveSceneScreenUnit; readonly x: number; readonly y: number; } | { readonly kind: "screenPoint"; readonly scope: WaveSceneScreenScope.View; readonly cameraId: string; readonly unit: WaveSceneScreenUnit; readonly x: number; readonly y: number; }

interface WaveScreenSpaceSnapshot {

  readonly layoutRevision: number;

  readonly metrics: Readonly<ScreenMetrics>;

  readonly views: readonly Readonly<ScreenRenderView>[];

}

type WaveScreenWorldDirection = Vector3 & { readonly [WAVE_SCREEN_DIRECTION_SPACE]: "worldDirection"; }

type WaveScreenWorldPoint = WorldPoint;

type WaveSdfSurfaceStructure = WaveSurfaceSdfRecipeStructure | WaveSurfaceDistanceFieldStructure | WaveSurfacePointSetStructure | WaveSurfaceGeometryDataStructure;

interface WaveSectionProgressions {

  readonly offsetBinormal?: WaveValueCurveSpec;

  readonly offsetNormal?: WaveValueCurveSpec;

  readonly profileMorph?: WaveValueCurveSpec;

  readonly scaleX?: WaveValueCurveSpec;

  readonly scaleY?: WaveValueCurveSpec;

  readonly twist?: WaveValueCurveSpec;

}

interface WaveSectionProgressionsInput {

  readonly offsetBinormal?: WaveValueCurveInput;

  readonly offsetNormal?: WaveValueCurveInput;

  readonly profileMorph?: WaveValueCurveInput;

  readonly scaleX?: WaveValueCurveInput;

  readonly scaleY?: WaveValueCurveInput;

  readonly twist?: WaveValueCurveInput;

}

interface WaveSemanticValueCurveSpec {

  readonly curve: WaveValueCurveSpec;

  readonly description?: string;

  readonly domain: WaveValueCurveDomain;

  readonly eventHints?: readonly WaveValueCurveEventHint[];

  readonly kind: "semantic";

  readonly label?: string;

  readonly role?: string;

  readonly tags?: readonly string[];

  readonly unit?: string;

}

type WaveSensingSpatialEntity = WaveEntity & WaveSpatial3DEntity;

interface WaveSerializable3DLocator {

  readonly basis: WaveSerializable3DLocatorBasis;

  readonly kind: "locator3d";

  readonly operations: readonly WaveSerializable3DLocatorOp[];

}

type WaveSerializable3DLocatorBasis = { readonly kind: "origin"; } | { readonly kind: "localPoint"; readonly point: SerializableVector3; } | { readonly kind: "boundsCenter"; } | { readonly kind: "boundsFaceCenter"; readonly direction: WaveSerializedLocateDirection; }

type WaveSerializable3DLocatorOp = WaveSerializedLocateOp;

interface WaveSerializableTransitionTiming {

  readonly delaySeconds: number;

  readonly durationSeconds: number | null;

}

type WaveSerializedLocateDirection = SerializedDirectionInput;

type WaveSerializedLocateOp = { readonly op: "alongBy"; readonly direction: WaveSerializedLocateDirection; readonly value: number; readonly space?: WaveSerializedLocateSpace; readonly frameOf?: WaveEntityIdentityRef; readonly parentFrameDepth?: number; }

type WaveSerializedLocateSpace = "world" | "local" | "parent";

type WaveShaderBindingFrequency = "scene" | "view" | "material" | "object" | "draw";

type WaveShaderBindingMat4 = readonly [ number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number ];

type WaveShaderBindingType = "float" | "vec2" | "vec3" | "vec4" | "mat4";

type WaveShaderBindingValue = { readonly [TType in WaveShaderBindingType]: { readonly name: string; readonly type: TType; readonly value: WaveShaderBindingValueByType[TType]; }; }[WaveShaderBindingType];

interface WaveShaderBindingValueByType {

  readonly float: number;

  readonly mat4: WaveShaderBindingMat4;

  readonly vec2: WaveShaderBindingVec2;

  readonly vec3: WaveShaderBindingVec3;

  readonly vec4: WaveShaderBindingVec4;

}

type WaveShaderBindingVec2 = readonly [number, number];

type WaveShaderBindingVec3 = readonly [number, number, number];

type WaveShaderBindingVec4 = readonly [number, number, number, number];

interface WaveShaderMaterialDescriptor {

  readonly bindingSet: WaveBindingSet;

  readonly module: WaveShaderModuleDescriptor;

  readonly pipeline: WavePipelineDescriptor;

  readonly schema: "wave.shaderMaterial.v3";

}

interface WaveShaderUniformBindingDescriptor {

  readonly frequency: WaveShaderBindingFrequency;

  readonly kind: "uniform";

  readonly name: string;

  readonly source: "renderer" | "bindingSet";

  readonly type: WaveShaderBindingType;

}

interface WaveShaderVertexAttributeDescriptor {

  readonly bufferSlot: number;

  readonly byteOffset: number;

  readonly byteStride: number;

  readonly format: WaveShaderVertexAttributeFormat;

  readonly name: WaveShaderVertexAttributeName;

  readonly shaderLocation: number;

}

type WaveShaderVertexAttributeFormat = "float32" | "float32x2" | "float32x3" | "float32x4" | "uint32" | "uint32x2" | "uint32x3" | "uint32x4" | "uint16x2" | "uint16x4" | "uint8x4" | "unorm16x2" | "unorm16x4" | "unorm8x4";

type WaveShaderVertexAttributeName = string;

interface WaveShadowCascadeOptions {

  readonly blend?: number;

  readonly count?: number;

  readonly lambda?: number;

  readonly maxDistance?: number;

  readonly stabilize?: boolean;

}

type WaveShadowCasterIntent = { readonly topology: "closedSolid"; readonly sides?: WaveShadowCasterSides; } | { readonly topology: "openSurface"; readonly sides?: Exclude<WaveShadowCasterSides, "back">; }

type WaveShadowCasterSides = "front" | "back" | "twoSided";

type WaveShadowUpdatePolicy = "dynamic" | "once" | { readonly mode: "periodic"; readonly interval: number; readonly phase?: number; } | { readonly mode: "invalidated"; readonly keys: readonly string[]; }

type WaveSideOrientation = "front" | "back" | "double";

declare class WaveSimpleFractureBuilder {

  constructor(_model: cmp_visual3DModel);

  apply(): WaveSimpleFractureResult;

  applyAsync(): Promise<WaveSimpleFractureResult>;

  atLocalPosition(x: number, y: number, z: number): this;

  atPosition(position: WavePointInput): this;

  atPosition(x: number, y: number, z: number): this;

  cancelWith(signal: AbortSignal): this;

  forceMergeMesh(force?: boolean): this;

  intoFree3DObject(): this;

  intoFree3DObjects(): this;

  intoParts(_options?: CreatePartsOptions): this;

  intoPieces(count: number): this;

  withInteriorColor(color: FragInteriorColorInput): this;

  withPhysicalClusterBudget(maxPhysicalClusters: number): this;

  withPhysicalClusters(maxPhysicalClusters: number): this;

  withSeed(seed: number): this;

}

type WaveSimpleFractureFailureCode = "invalidIntent" | "sourceUnavailable" | "sourceTooLarge" | "asyncRequired" | "budgetExceeded" | "staleSource" | "topologyFailure" | "unreachableWithinBudget" | "artifactFailure" | "materializationFailure" | "commitFailure" | "cancelled";

interface WaveSimpleFractureResult {

  readonly error?: string;

  readonly failureCode?: WaveSimpleFractureFailureCode;

  readonly fragments: readonly wave3DObject[];

  readonly simple?: { readonly visualComponentCount: number; readonly physicalClusterCount: number; readonly workerUsed: boolean; readonly objectModelRevision?: string; }

  readonly success: boolean;

}

interface WaveSimulationGravity {

  readonly x: number;

  readonly y: number;

  readonly z: number;

}

type WaveSimulationQuality = "favorThroughput" | "balanced" | "favorStability";

interface WaveSimulationQualityIntent {

  readonly quality: WaveSimulationQuality;

}

interface WaveSineValueCurveSpec {

  readonly amplitude: number;

  readonly baseline: number;

  readonly cycles: number;

  readonly kind: "sine";

  readonly phaseTurns: number;

}

interface WaveSkeletalPhysicalAnimationOptions {

  readonly angularDamping?: number;

  readonly damping?: number;

  readonly maxForce?: number;

  readonly maxTorque?: number;

  readonly positionStrength?: number;

  readonly rotationStrength?: number;

  readonly strength?: number;

}

type WaveSkeletalPhysicsState = "animated" | "physicalAnimation" | "ragdoll";

interface WaveSkeletalRagdollOptions {

  readonly bodyAngularDamping?: number;

  readonly bodyLinearDamping?: number;

  readonly debugLog?: boolean;

  readonly followOwner?: boolean;

  readonly hitPart?: string;

  readonly impulse?: Vector3Like;

  readonly impulsePoint?: Vector3Like;

  readonly initialLinearVelocity?: Vector3Like;

  readonly jointDamping?: number;

  readonly jointEffort?: number;

}

interface WaveSkeletalRecoveryOptions {

  readonly recoveryLift?: number;

}

interface WaveSkeletalRecoveryResult {

  readonly linearVelocity: Vector3Like;

  readonly ownerWorldPosition: Vector3Like;

  readonly rootPartId: string;

  readonly rootWorldPosition: Vector3Like;

  readonly rootWorldRotation: QuaternionLike;

}

interface WaveSkinJointSegment {

  readonly end: Vector3Like;

  readonly jointIndex: number;

  readonly start: Vector3Like;

}

interface WaveSkinnedGpuSurfaceSourceOptions {

  readonly sourceMeshName?: string;

}

type WaveSkinSelectionSurface = "bind" | "currentPose";

interface WaveSkinWeightDiagnostics {

  readonly changedVertexCount: number;

  readonly maximumObservedInfluenceCount: number;

  readonly maximumWeight: number;

  readonly minimumWeight: number;

  readonly unweightedVertexCount: number;

  readonly vertexCount: number;

  readonly verticesAtInfluenceLimit: number;

}

interface WaveSkinWeightDirtyRange {

  readonly vertexCount: number;

  readonly vertexStart: number;

}

interface WaveSkinWeightEditDelta {

  readonly afterJoints: Uint32Array;

  readonly afterWeights: Float32Array;

  readonly beforeJoints: Uint32Array;

  readonly beforeWeights: Float32Array;

  readonly channelCapacity: 4 | 8;

  readonly vertexIndices: Uint32Array;

}

interface WaveSkinWeightEditResult {

  readonly changedVertexCount: number;

  readonly channels: WaveCompiledSkinWeightChannels;

  readonly delta: WaveSkinWeightEditDelta;

  readonly diagnostics: WaveSkinWeightDiagnostics;

  readonly dirtyVertexRanges: readonly WaveSkinWeightDirtyRange[];

}

declare class WaveSkinWeightEditSession {

  static begin(options: WaveSkinWeightEditSessionOptions): WaveSkinWeightEditSession;

  cancel(): void;

  get changedVertexCount(): number;

  get channelCapacity(): 4 | 8;

  commit(): WaveSkinWeightEditResult;

  flood(operation: WaveSkinWeightFloodEdit): this;

  gradient(operation: WaveSkinWeightGradientEdit): this;

  inspect(vertexIndex: number): WaveSkinWeightVertexInspection;

  get maxActiveInfluences(): number;

  normalize(mask?: WaveSkinWeightSpatialMask): this;

  paint(operation: WaveSkinWeightPaintEdit): this;

  prune(operation?: WaveSkinWeightPruneEdit): this;

  smooth(operation?: WaveSkinWeightSmoothEdit): this;

  get vertexCount(): number;

}

interface WaveSkinWeightEditSessionOptions {

  readonly bindPositions: Float32Array;

  readonly channels: WaveCompiledSkinWeightChannels;

  readonly currentPosePositions?: Float32Array;

  readonly indices?: Uint32Array;

  readonly jointSegments: readonly WaveSkinJointSegment[];

  readonly maxActiveInfluences: number;

  readonly selectionSurface?: WaveSkinSelectionSurface;

  readonly spatialCellSize?: number;

}

interface WaveSkinWeightFloodEdit {

  readonly center?: any;

  readonly maxPlaneDistance?: number | undefined;

  readonly normal?: any;

  readonly radius?: number | undefined;

  readonly vertexIndices?: unknown | undefined;

  readonly jointIndex: number;

  readonly lockedJointIndices?: ArrayLike<number>;

  readonly weight: number;

}

interface WaveSkinWeightGradientEdit {

  readonly center?: any;

  readonly maxPlaneDistance?: number | undefined;

  readonly normal?: any;

  readonly radius?: number | undefined;

  readonly vertexIndices?: unknown | undefined;

  readonly from: Vector3Like;

  readonly fromWeight: number;

  readonly jointIndex: number;

  readonly lockedJointIndices?: ArrayLike<number>;

  readonly to: Vector3Like;

  readonly toWeight: number;

}

interface WaveSkinWeightPaintEdit {

  readonly center?: any;

  readonly maxPlaneDistance?: number | undefined;

  readonly normal?: any;

  readonly radius?: number | undefined;

  readonly vertexIndices?: unknown | undefined;

  readonly falloff?: WaveSkinWeightPaintFalloff;

  readonly jointIndex: number;

  readonly lockedJointIndices?: ArrayLike<number>;

  readonly opacity?: number;

  readonly value: number;

  readonly verb: WaveSkinWeightPaintVerb;

}

type WaveSkinWeightPaintFalloff = "smooth" | "linear" | "hard";

type WaveSkinWeightPaintVerb = "add" | "remove" | "set";

interface WaveSkinWeightPruneEdit {

  readonly center?: any;

  readonly maxPlaneDistance?: number | undefined;

  readonly normal?: any;

  readonly radius?: number | undefined;

  readonly vertexIndices?: unknown | undefined;

  readonly below?: number;

  readonly lockedJointIndices?: ArrayLike<number>;

}

interface WaveSkinWeightSmoothEdit {

  readonly center?: any;

  readonly maxPlaneDistance?: number | undefined;

  readonly normal?: any;

  readonly radius?: number | undefined;

  readonly vertexIndices?: unknown | undefined;

  readonly iterations?: number;

  readonly lockedJointIndices?: ArrayLike<number>;

  readonly strength?: number;

}

interface WaveSkinWeightSpatialMask {

  readonly center?: Vector3Like;

  readonly maxPlaneDistance?: number;

  readonly normal?: Vector3Like;

  readonly radius?: number;

  readonly vertexIndices?: ArrayLike<number>;

}

interface WaveSkinWeightVertexInspection {

  readonly influences: readonly { readonly jointIndex: number; readonly weight: number; }[];

  readonly vertexIndex: number;

}

interface WaveSmoothStepValueCurveSpec {

  readonly endInput: number;

  readonly endValue: number;

  readonly kind: "smoothStep";

  readonly startInput: number;

  readonly startValue: number;

}

interface WaveSoftBodyAttachmentConfig {

  constraintId: string;

  enableCollisions: boolean;

  nodeIndex: number;

  nodeLocalPivot?: WavePathExtrusionSerializedPoint;

  nodeWorldPivot?: WavePathExtrusionSerializedPoint;

  sharedWorldPivot?: WavePathExtrusionSerializedPoint;

  targetEntityId: number;

  targetLocalPivot?: WavePathExtrusionSerializedPoint;

  targetName?: string;

  targetWorldPivot?: WavePathExtrusionSerializedPoint;

  type: "lock" | "ballAndSocket";

}

interface WaveSoftBodyAttachmentOptions {

  enableCollisions?: boolean;

  nodeLocalPivot?: Vector3Like;

  nodeWorldPivot?: WavePointInput;

  sharedWorldPivot?: WavePointInput;

  targetLocalPivot?: Vector3Like;

  targetWorldPivot?: WavePointInput;

  type?: "lock" | "ballAndSocket";

}

type WaveSoftBodyAttachmentTarget = wave3DObject;

interface WaveSoftBodyBuilderScene {

  readonly engine: unknown;

  createCloth(options: ClothGridOptions): WaveCloth;

  createRope(options: RopeChainOptions): WaveRope;

}

type WaveSoftBodyCollisionTarget = Parameters<WaveCloth["avoidCollisionWith"]>[0];

type WaveSoftBodyConstraintRole = "structural" | "shear" | "bend" | "tetherGuard";

interface WaveSoftBodyDistanceConstraintConfig {

  enableCollisions: boolean;

  kind: "distance";

  maxDistance: number;

  minDistance: number;

  nodeA: number;

  nodeB: number;

  role: WaveSoftBodyConstraintRole;

  spring?: SpringConfig;

}

type WaveSoftBodyNodeColliderShape = "sphere" | "thinBox";

interface WaveSoftBodyNodeConfig {

  bodyType: RigidBodyType;

  entityId: number;

  index: number;

  name?: string;

  position: WavePathExtrusionSerializedPoint;

  rotation: WaveSoftBodySerializedQuaternion;

}

declare class WaveSoftBodyNodeHandle implements WavePointSource {

  constructor(_batch: waveThinBatch, index: number, id: number, name: string, initialBodyType: RigidBodyType);

  destroy(): void;

  readonly id: number;

  readonly index: number;

  isDestroyed: boolean;

  name: string;

  readonly rigidBody: WaveSoftBodyNodeRigidBodyHandle;

  setName(name: string): this;

  setWorldPosition(position: Vector3): this;

  setWorldRotation(rotation: Quaternion): this;

  toVector(space?: WavePointSourceSpace): Vector3;

  toVector3(): Vector3;

  toVectorToRef(space: WavePointSourceSpace, result: Vector3): Vector3;

  readonly transform: WaveSoftBodyNodeTransformHandle;

}

declare class WaveSoftBodyNodeRigidBodyHandle {

  constructor(_batch: waveThinBatch, _index: number, initialBodyType: RigidBodyType);

  get bodyType(): RigidBodyType;

  get constraintEndpoint(): PhysicsConstraintEndpoint;

  createJointTo(target: PhysicsConstraintEndpoint | WaveSoftBodyNodeRigidBodyHandle, config?: RigidBodyJointConfig, nativeParentEndpoint?: "owner" | "target"): RigidBodyJointResult;

  disposeConstraint(id: string): boolean;

  get isDynamic(): boolean;

  setAngularDamping(damping: number): this;

  setAngularVelocity(x: number, y: number, z: number): this;

  setLinearDamping(damping: number): this;

  setLinearVelocity(x: number, y: number, z: number): this;

  setMass(mass: number): this;

  useDynamicBody(): this;

  useKinematicBody(): this;

  useSphereCollider(radius: number): this;

  useStaticBody(): this;

}

declare class WaveSoftBodyNodeTermsHandle {

  constructor(_batch: waveThinBatch, _index: number);

  position(): Vector3;

  rotation(): Quaternion;

}

declare class WaveSoftBodyNodeTransformHandle {

  constructor(_batch: waveThinBatch, _index: number);

  inWorldTerms(): WaveSoftBodyNodeTermsHandle;

  setScale(x: number, y: number, z: number): this;

}

type WaveSoftBodyParticleCollisionMode = "disabled" | "remoteSpatialHash";

interface WaveSoftBodyParticleCollisionPolicy {

  cellSize: number;

  contactRadius: number;

  maxContactsPerNode: number;

  maxPairs: number;

  mode: WaveSoftBodyParticleCollisionMode;

  skipNeighborRings: number;

}

type WaveSoftBodyParticleCollisionPolicyInput = boolean | WaveSoftBodyParticleCollisionMode | Partial<WaveSoftBodyParticleCollisionPolicy>;

interface WaveSoftBodySerializedColor {

  b: number;

  g: number;

  r: number;

}

interface WaveSoftBodySerializedQuaternion {

  w: number;

  x: number;

  y: number;

  z: number;

}

interface WaveSoftBodyVisualConfig {

  color?: WaveSoftBodySerializedColor;

  material?: string;

  materialUVScale?: number;

  nodeColliderShape?: WaveSoftBodyNodeColliderShape;

  nodeRadius?: number;

  ropeRadius?: number;

  showNodes?: boolean;

}

interface WaveSourceValueDriveOptions {

  apply: (value: number) => void;

  callbacks?: TransitionLifecycleCallbacks<ValueDriveState> | undefined;

  clone?: WaveCallbackClonePolicy | undefined;

  curve: WaveValueCurveInput;

  name?: string | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  startPaused?: boolean | undefined;

  source: () => number;

}

type WaveSpatial2DObject<TState = unknown> = wave2DAbstract<TState>;

interface WaveSpatial3DEntity {

  getComponent<TComponent extends WaveComponent>(componentName: string): TComponent | undefined;

  readonly id: number;

  readonly transform: cmp_transform;

}

type WaveSpatial3DObject<TState = unknown> = WaveObject<TState, Vector3, Partial<ResolvedWorldTransformSnapshot>, "3d">;

type WaveSpatialAnchorRef = { readonly kind: "owner"; } | { readonly kind: "primaryRenderCamera"; } | { readonly kind: "visualPivot"; } | { readonly kind: "namedPoint"; readonly name: string; } | { readonly kind: "point"; readonly space: WavePointSourceSpace; readonly position: Vector3Like; } | { readonly kind: "transform"; readonly space: WavePointSourceSpace; readonly position: Vector3Like; readonly forward?: Vector3Like; readonly up?: Vector3Like; } | { readonly kind: "locator"; readonly ops: readonly WaveSerializedLocateOp[]; } | { readonly kind: "entity"; readonly entity: WaveEntityIdentityRef; readonly target?: WaveSpatialAnchorRef; } | { readonly kind: "rigSocket"; readonly socketId: string; } | { readonly kind: "modelPart"; readonly partId: string; } | { readonly kind: "modelAnchor"; readonly anchorId: string; readonly partId?: string; }

type WaveSpatialCallbackNameOrOptions = string | WaveSpatialCallbackOptions;

type WaveSpatialCallbackOptions = WaveAuthoredCallbackOptions & { readonly name?: string; }

type WaveSpatialDomain = "2d" | "3d";

declare class WaveSpatialGrid3D<T> {

  clear(): void;

  delete(x: number, y: number, z: number): boolean;

  findHighestY(x: number, z: number, minY: number, maxY: number): number | null;

  forEach(fn: (x: number, y: number, z: number, value: T) => void): void;

  get(x: number, y: number, z: number): T | undefined;

  getColumn(x: number, z: number): Array<WaveSpatialGridEntry<T>>;

  hasBlockAt(x: number, y: number, z: number): boolean;

  set(x: number, y: number, z: number, value: T): void;

  get size(): number;

}

interface WaveSpatialGridEntry<T> {

  value: T;

  y: number;

}

type WaveSpatialPoint3 = SerializableVector3;

interface WaveSpatialValueExpr {

  readonly field: "position" | "forward" | "up" | "right" | "velocity";

  readonly source: string;

  readonly type: "spatial";

}

interface WaveSpatialVolumeContract {

  readonly spatialVolume: number | null;

}

type WaveSpawnInput<T extends WaveSpatial3DObject = WaveSpatial3DObject> = T | ReadonlyArray<T> | WaveGroup<T>;

interface WaveSpeakTextOptions {

  busName?: string | undefined;

  cancelQueued?: boolean | undefined;

  clone?: WaveCallbackClonePolicy | undefined;

  device?: WaveLocalNeuralTTSDevice | undefined;

  distanceModel?: AudioDistanceModel | undefined;

  dtype?: WaveLocalNeuralTTSDType | undefined;

  fallbackProviders?: readonly WaveStandardTTSProvider[] | undefined;

  lang?: string | undefined;

  loop?: boolean | undefined;

  maxDistance?: number | undefined;

  modelId?: string | undefined;

  optimizeStreamingLatency?: number | undefined;

  outputFormat?: string | undefined;

  panningModel?: AudioPanningModel | undefined;

  pitch?: number | undefined;

  position?: any;

  preferLocalService?: boolean | undefined;

  provider?: WaveStandardTTSProvider | undefined;

  rate?: number | undefined;

  refDistance?: number | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  rolloffFactor?: number | undefined;

  spatialPreset?: AudioSpatialPreset | undefined;

  spatialSound?: boolean | undefined;

  speechConcurrency?: WaveTTSSpeechConcurrency | undefined;

  speed?: number | undefined;

  voice?: string | undefined;

  voiceId?: string | undefined;

  voiceName?: string | undefined;

  voicePreference?: BrowserSpeechSynthesisVoicePreference | undefined;

  voiceSettings?: ElevenLabsVoiceSettings | undefined;

  voiceURI?: string | undefined;

  volume?: number | undefined;

  waitForVoicesMs?: number | undefined;

}

type WaveSpeechCallback = (event: WaveSpeechEvent) => void;

interface WaveSpeechCommandMatch<TCommand extends string = string> {

  command: TCommand;

  confidence?: number;

  isFinal: boolean;

  matchedAlias: string;

  score: number;

  transcript: string;

}

interface WaveSpeechCommandSession<TCommand extends string = string> {

  dispose(): void;

  isListening(): boolean;

  stopListening(): void;

}

interface WaveSpeechCommandSessionError {

  code: string;

  event: WaveNativeSpeechRecognitionErrorEvent;

  fatal: boolean;

}

interface WaveSpeechCommandSpec<TCommand extends string = string> {

  aliases: readonly string[];

  minScore?: number;

  name: TCommand;

}

type WaveSpeechErrorCallback = (event: WaveSpeechErrorEvent) => void;

interface WaveSpeechErrorEvent {

  provider?: WaveTTSProvider | undefined;

  text: string;

  error: unknown;

}

interface WaveSpeechEvent {

  provider?: WaveTTSProvider;

  text: string;

}

interface WaveSpeechFxConfig {

  fxChain?: WaveInstrumentFxNode[] | undefined;

  enabled?: boolean;

  preset?: WaveSpeechFxPreset;

}

type WaveSpeechFxNodeOptions<TType extends WaveInstrumentFxNode["type"]> = Omit<Extract<WaveInstrumentFxNode, { type: TType; }>, "type">;

type WaveSpeechFxPreset = "none" | "radio" | "megaphone" | "robot" | "softRoom";

type WaveSpeechLoadProgressCallback = (event: WaveSpeechLoadProgressEvent) => void;

interface WaveSpeechLoadProgressEvent {

  provider?: WaveTTSProvider | undefined;

  text: string;

  file?: string;

  loadedBytes?: number;

  modelId?: string;

  progressPercent?: number;

  status: WaveSpeechLoadProgressStatus;

  task?: string;

  totalBytes?: number;

}

type WaveSpeechLoadProgressStatus = "initiate" | "download" | "progress" | "progressTotal" | "done" | "ready" | "generating";

interface WaveSpeechPlaybackHandle {

  readonly completed: boolean;

  readonly error: unknown;

  readonly failed: boolean;

  onComplete(callback?: (handle: this) => void): this;

  onFailed(callback?: (handle: this) => void): this;

  onStopped(callback?: (handle: this) => void): this;

  readonly requestId: string;

  stop(): void;

  readonly stopped: boolean;

  readonly terminalReason: WaveSpeechTerminalReason | null;

  readonly text: string;

}

type WaveSpeechTerminalReason = "completed" | "failed" | "stopped";

interface WaveSpeechTranscriptAlternative {

  confidence?: number;

  transcript: string;

}

interface WaveSpherePrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "sphere";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly arcFraction?: number;

  readonly caps?: { readonly base?: boolean; readonly sides?: boolean; readonly baseSegments?: number; readonly sideSegments?: number; }

  readonly flat?: boolean;

  readonly radialSegments?: number;

  readonly radii: { readonly x: number; readonly y: number; readonly z: number; }

  readonly sliceFraction?: number;

  readonly subdivisions?: number;

  readonly topology?: "uv" | "ico";

  readonly verticalSegments?: number;

}

type WaveSpriteAnimationFrames = readonly number[] | readonly string[] | { readonly start: number; readonly count: number; }

interface WaveSpriteAnimationSerializedConfig {

  readonly name: string;

  readonly options: WaveSpriteAnimationOptions;

}

declare class WaveSpriteAsset {

  constructor(name: string, options?: WaveSpriteOptions);

  animation(): WaveSpriteAnimationRef;

  configure(options: WaveSpriteOptions): this;

  readonly name: string;

  toConfig(): WaveSpriteSerializedConfig;

  toDefinition(facts: WaveSpriteSheetFacts): AssetDefinition<"texture">;

}

interface WaveSpriteOptions {

  readonly pivot?: WaveTextureAtlasPoint;

  readonly sampling?: WaveSpriteSamplingInput;

  readonly textureAsset: string;

}

interface WaveSpriteSerializedConfig {

  readonly name: string;

  readonly options: WaveSpriteOptions;

}

interface WaveSpriteSheetFacts {

  readonly contentHash?: string;

  readonly height: number;

  readonly width: number;

}

type WaveStandardTTSBackendProviderName = WaveStandardTTSProvider | "elevenlabs" | "browser" | "browser-speech" | "browserSpeech";

type WaveStandardTTSConfig = Omit<WaveTTSConfig, "provider" | "fallbackProviders" | "localNeural"> & { provider?: WaveStandardTTSProvider; fallbackProviders?: readonly WaveStandardTTSProvider[]; localNeural?: never; }

type WaveStandardTTSProvider = Exclude<WaveTTSProvider, "localNeural">;

interface WaveStreamingFogPolicy {

  readonly applyToSceneFog?: boolean;

  readonly applyToVolumetricFog?: boolean;

  readonly enabled: boolean;

  readonly endRatio?: number;

  readonly maxEnd?: number;

  readonly minEnd?: number;

  readonly minStart?: number;

  readonly startRatio?: number;

  readonly volumetricFadeInDistanceRatio?: number;

  readonly volumetricMaxDistanceRatio?: number;

  readonly volumetricStartDistanceRatio?: number;

}

interface WaveStreamingGeometryBackend<TMesh = unknown> {

  readonly capabilities: readonly WaveStreamingGeometryCapability[];

  captureSnapshot?(options?: WaveStreamingGeometrySnapshotOptions): WaveGeometryData | null;

  dispose?(): void;

  getMeshView?(): WaveStreamingGeometryMeshView<TMesh> | null;

  getSurfaceRevision?(): WaveStreamingGeometrySurfaceRevision;

  readonly id: string;

  invalidate?(): void;

  readonly kind: WaveStreamingGeometryBackendKind;

  readonly provenance: WaveStreamingGeometryProvenance;

  querySurface?(position: WaveStreamingGeometrySurfaceQueryPoint): WaveStreamingGeometrySurfaceSample | null;

}

type WaveStreamingGeometryBackendKind = "tile3d" | "meshStream" | "heightfield" | "analyticSurface" | (string & {});

type WaveStreamingGeometryCapability = (typeof WaveStreamingGeometryCapability)[keyof typeof WaveStreamingGeometryCapability];

declare const WaveStreamingGeometryCapability: { readonly LiveSurfaceQuery: "liveSurfaceQuery"; readonly MeshView: "meshView"; readonly SnapshotGeometry: "snapshotGeometry"; readonly ProviderManagedLod: "providerManagedLod"; readonly ProviderManagedMaterials: "providerManagedMaterials"; readonly ProviderManagedLifecycle: "providerManagedLifecycle"; readonly GeospatialCoordinates: "geospatialCoordinates"; readonly SemanticParts: "semanticParts"; };

interface WaveStreamingGeometryMeshView<TMesh = unknown> {

  readonly coordinateSpace: WaveGeometryCoordinateSpace;

  readonly meshes: readonly TMesh[];

  readonly providerOwned: boolean;

  readonly version: number;

}

interface WaveStreamingGeometryProvenance {

  readonly chunkKey?: string;

  readonly coordinateSpace?: WaveGeometryCoordinateSpace;

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly precisionProfile?: string;

  readonly providerId: string;

  readonly sourceProvider?: string;

  readonly sourceUri?: string;

}

interface WaveStreamingGeometrySnapshotOptions {

  readonly coordinateSpace?: WaveGeometryCoordinateSpace;

  readonly includeDisabledMeshes?: boolean;

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly name?: string;

}

interface WaveStreamingGeometrySurfaceQueryPoint {

  readonly upVector?: WaveStreamingGeometryVector3;

  readonly x: number;

  readonly y?: number;

  readonly z: number;

}

type WaveStreamingGeometrySurfaceRevision = string | number;

interface WaveStreamingGeometrySurfaceSample {

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly normal?: WaveStreamingGeometryVector3;

  readonly position: WaveStreamingGeometryVector3;

}

type WaveStreamingGeometryVector3 = Readonly<SerializableVector3>;

interface WaveSubMeshRange {

  readonly indexCount: number;

  readonly indexStart: number;

  readonly materialIndex: number;

  readonly verticesCount: number;

  readonly verticesStart: number;

}

interface WaveSubtractValueCurveSpec {

  readonly kind: "subtract";

  readonly minuend: WaveValueCurveSpec;

  readonly subtrahends: readonly WaveValueCurveSpec[];

}

type WaveSurfaceDistanceFieldAsset = SdfImplicitAsset | SdfScalarField3DAsset;

interface WaveSurfaceDistanceFieldStructure {

  readonly field: WaveSurfaceDistanceFieldAsset;

  readonly kind: "distanceField";

}

interface WaveSurfaceDynamicsMaterial {

  readonly bendStiffness?: number;

  readonly damping?: number;

  readonly shearStiffness?: number;

  readonly structuralStiffness?: number;

}

interface WaveSurfaceGeometryDataStructure {

  readonly geometry: WaveGeometryData;

  readonly kind: "geometryData";

}

interface WaveSurfaceGeometrySource {

  asSurfaceSource(): WaveSurfaceMeshAssetStructure;

}

interface WaveSurfaceHeightfieldStructure {

  readonly heightfield: WaveHeightfield;

  readonly kind: "heightfield";

  readonly layerId?: string;

  readonly surfaceDirection?: WaveHeightfieldSurfaceDirection;

}

interface WaveSurfaceMeshAssetStructure {

  readonly kind: "meshAsset";

  readonly meshAssetId: string;

}

interface WaveSurfaceOwnerMeshStructure {

  readonly kind: "ownerMesh";

}

interface WaveSurfacePointSetStructure {

  readonly kind: "pointSet";

  readonly points: readonly Vector3Like[] | Float32Array;

}

interface WaveSurfaceSdfRecipeStructure {

  readonly bounds?: DistanceFieldBounds3D;

  readonly fieldId?: string;

  readonly isoLevel?: number;

  readonly kind: "sdfRecipe";

  readonly recipe: SdfSurfaceRecipe;

  readonly units?: DistanceFieldUnits3D;

}

type WaveSurfaceSourceStructure = WaveSdfSurfaceStructure | WaveSurfaceHeightfieldStructure | WaveSurfaceOwnerMeshStructure | WaveSurfaceMeshAssetStructure;

interface WaveSurfaceStateDecayOptions {

  readonly halfLifeSeconds: number;

  readonly maxDeltaSeconds?: number;

}

interface WaveSurfaceStateGpuContactOptions {

  readonly amount: WaveNumberAuthoringInput;

  readonly condition?: WaveBoolExpr;

  readonly operation?: "add" | "max";

  readonly radius: WaveNumberAuthoringInput;

}

interface WaveSurfaceStateHit {

  readonly entityId: number;

  readonly meshId?: string;

  readonly meshName?: string;

  readonly partId?: string;

  readonly partName?: string;

  readonly uv?: { readonly x: number; readonly y: number; }

}

type WaveSurfaceStateMapping = { readonly kind: "meshUv0"; readonly target: WaveVisualTargetRef; } | { readonly kind: "worldPlane"; readonly frame: WavePlaneFrameIntent; readonly coverage: WaveRelativeCoveragePlan; }

type WaveSurfaceStatePoint = WaveSurfaceStateUvPoint | WaveSurfaceStateWorldPoint;

interface WaveSurfaceStateResolution {

  readonly height: number;

  readonly width: number;

}

interface WaveSurfaceStateUvPoint {

  readonly u: number;

  readonly v: number;

}

interface WaveSurfaceStateWorldPoint {

  readonly x: number;

  readonly y: number;

  readonly z: number;

}

interface WaveSurfaceStateWriteAcceptanceOptions {

  readonly capacity?: number;

  readonly falloff?: WaveValueCurveSpec;

}

type WaveSurfaceStateWriteOperation = "add" | "max";

interface WaveSurfaceStateWriteOptions {

  readonly amount: number;

  readonly operation?: WaveSurfaceStateWriteOperation;

  readonly radius: number;

}

interface WaveSurfaceStateWritePlan {

  readonly capacity: number;

  readonly falloff: WaveValueCurveSpec;

}

interface WaveSurfaceStateWriteResult {

  readonly accepted: boolean;

  readonly capacity: number;

  readonly pendingCount: number;

  readonly ref: WaveScalarSurfaceStateRef;

  readonly status: WaveSurfaceStateWriteStatus;

}

type WaveSurfaceStateWriteStatus = "accepted" | "capacityExceeded" | "staleHandle" | "mappingMismatch" | "ownerMismatch" | "targetMismatch" | "missingUv";

interface WaveSwizzleValueExpr {

  readonly components: readonly WaveValueSwizzleComponent[];

  readonly input: WaveValueExpr;

  readonly type: "swizzle";

}

interface WaveSystemAccessContext {

  readonly componentType?: string;

  readonly entityId?: number;

  readonly operation?: string;

}

type WaveSystemErrorMode = "isolated" | "failFast";

interface WaveTerrainAngularSliceIntent {

  readonly directionDegrees: number;

  readonly edgeJitter: number;

  readonly fraction: number;

  readonly noiseScale: number;

  readonly seed?: number;

  readonly transitionWidth: number;

}

interface WaveTerrainAuthoredSculptNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly bounds: WaveTerrainBounds;

  readonly kind: "authoredSculpt";

  readonly recipeSteps: readonly SerializableDataValue[];

}

interface WaveTerrainBaseDefinition {

  readonly cameraLODCorrection: number;

  readonly generator: WaveTerrainGeneratorDefinition | null;

  readonly lodLimits: readonly number[];

  readonly physicsEnabled: boolean;

  readonly physicsTileGridSideLength: number;

  readonly preset: TerrainPreset;

  readonly seed: number;

}

interface WaveTerrainBaseDefinitionInput {

  readonly cameraLODCorrection?: number;

  readonly generator?: WaveTerrainGeneratorDefinition | null;

  readonly lodLimits?: readonly number[];

  readonly physicsEnabled?: boolean;

  readonly physicsTileGridSideLength?: number;

  readonly preset?: TerrainPreset;

  readonly seed?: number;

}

interface WaveTerrainBasinChainIntent {

  readonly count: number;

  readonly layout: WaveTerrainBasinChainLayout;

  readonly path: readonly WaveTerrainPoint2[];

}

type WaveTerrainBasinChainLayout = "centralDeep" | "evenDepths" | "randomDepths";

interface WaveTerrainBasinNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly chain?: WaveTerrainBasinChainIntent;

  readonly depth: number;

  readonly floorNoiseFrequency?: number;

  readonly floorRadius?: number;

  readonly floorRoughness?: number;

  readonly kind: "basin";

  readonly preset: BasinPreset;

  readonly radius: number;

  readonly rimHeight?: number;

  readonly rimRoughness?: number;

  readonly rimWidth?: number;

  readonly slice?: WaveTerrainAngularSliceIntent;

  readonly wallRoughness?: number;

  readonly wallSteepness?: number;

  readonly water?: WaveTerrainBasinWater;

}

interface WaveTerrainBasinWater {

  readonly bodyModel: WaveWaterBodyModel;

  readonly edgeJitter: number;

  readonly inset: number;

  readonly resolution: number;

  readonly uScale: number;

  readonly vScale: number;

}

type WaveTerrainBounds = { readonly minX: number; readonly maxX: number; readonly minZ: number; readonly maxZ: number; }

interface WaveTerrainBrushApplicationHost<TTerminal> {

  applyBrush(operation: WaveTerrainRuntimeDeltaInput): TTerminal;

  terminal(): TTerminal;

}

declare class WaveTerrainBrushBuilder<TTerminal> {

  constructor(_owner: WaveTerrainBrushApplicationHost<TTerminal>, _kind: TerrainRuntimeBrushKind);

  along(values: readonly WaveTerrainRuntimePoint[]): this;

  amount(value: number): this;

  apply(): TTerminal;

  at(value: WaveTerrainRuntimePoint): this;

  at(x: number, z: number): this;

  begin(value: WaveTerrainRuntimePoint): WaveTerrainRuntimeStroke<TTerminal>;

  begin(x: number, z: number): WaveTerrainRuntimeStroke<TTerminal>;

  between(a: WaveTerrainRuntimePoint, b: WaveTerrainRuntimePoint): this;

  falloff(value: WaveTerrainRuntimeFalloff): this;

  feather(value: number): this;

  frequency(value: number): this;

  height(value: number): this;

  iterations(value: number): this;

  material(materialId: string): this;

  octaves(value: number): this;

  preset(value: TerrainErosionPreset): this;

  radius(value: number): this;

  strength(value: number): this;

  terminal(): TTerminal;

  width(value: number): this;

}

declare class WaveTerrainContourReliefFeatureHandle extends WaveTerrainFeatureHandle<WaveTerrainContourReliefNode> {

  constructor(target: WaveTerrainFeatureEditorTarget, id: string);

  blendDistance(value: number): this;

  fromElevationContours(value: readonly WaveTerrainElevationContour[]): this;

  fromElevationGrid(value: WaveTerrainElevationGrid): this;

  region(region: "footprint"): WaveTerrainFeatureRegionReference;

  samplingResolution(columns: number, rows: number): this;

  within(value: WaveTerrainBounds): this;

}

interface WaveTerrainContourReliefNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly blendDistance: number;

  readonly bounds: WaveTerrainBounds;

  readonly kind: "contourRelief";

  readonly sampleColumns: number;

  readonly sampleRows: number;

  readonly source: WaveTerrainContourReliefSource;

}

type WaveTerrainContourReliefSource = { readonly kind: "longitudinalContours"; readonly contours: readonly WaveTerrainElevationContour[]; } | { readonly kind: "quantizedElevationGrid"; readonly encoding: WaveTerrainElevationGrid["encoding"]; readonly dataBase64: string; readonly elevationScale: number; readonly elevationOffset: number; }

interface WaveTerrainElevationContour {

  readonly elevation: number;

  readonly path: readonly WaveTerrainPoint2[];

}

interface WaveTerrainElevationGrid {

  readonly columns: number;

  readonly dataBase64: string;

  readonly elevationOffset: number;

  readonly elevationScale: number;

  readonly encoding: "int16-le-base64";

  readonly rows: number;

}

declare class WaveTerrainErosionFeatureHandle extends WaveTerrainFeatureHandle<WaveTerrainErosionNode> {

  constructor(target: WaveTerrainFeatureEditorTarget, id: string);

  preset(value: TerrainErosionPreset): this;

  strength(value: number): this;

  within(value: WaveTerrainBounds): this;

}

interface WaveTerrainErosionNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly bounds: WaveTerrainBounds;

  readonly kind: "erosion";

  readonly preset: TerrainErosionPreset;

  readonly strength: number;

}

interface WaveTerrainFacadeHost<TTerminal> {

  heightsInGridToRef(query: TerrainHeightGridQuery, out: Float32Array): Float32Array;

  isReady(): boolean;

  normalAtToRef<TOut extends SerializableVector3>(x: number, z: number, out: TOut): TOut | null;

  observeHeightfieldChanges(callback: (bounds: WaveTerrainBounds | null) => void): () => void;

  querySurface(position: SurfaceQueryInput): SurfaceQueryResult | null;

  querySurface(x: number, z: number): SurfaceQueryResult | null;

  rayIntersection(origin: Vector3, direction: Vector3, length: number): RayHit | null;

  surfaceAtToRef<TOut extends TerrainSurfaceQueryRef>(x: number, z: number, out: TOut): TOut | null;

  whenReady(callback: () => void): () => void;

  flushPrimaryTerrainLayer(): void;

  prepareTerrainMaterial(material: WaveTerrainMaterialInput): void;

  readPrimaryTerrainLayer(): WaveTerrainLayerDefinition | null;

  removePrimaryTerrainLayer(): TTerminal;

  runtimeContext(): WaveTerrainRuntimeDeltaContext | null;

  runtimeTarget(): WaveTerrainRuntimeTarget | null;

  writePrimaryTerrainLayer(definition: WaveTerrainLayerDefinition): void;

}

interface WaveTerrainFeatureEditorTarget {

  flush(): void;

  readNode(id: string): WaveTerrainNode | null;

  removeNode(id: string): void;

  writeNode(node: WaveTerrainNode): void;

}

type WaveTerrainFeaturePatch<TNode extends WaveTerrainNode> = TNode extends WaveTerrainNode ? Partial<Omit<TNode, "id" | "kind" | "revision">> : never;

interface WaveTerrainFeatureRegionReference {

  readonly id: string;

  readonly region: string;

}

interface WaveTerrainGeneratorDefinition {

  readonly kind: WaveTerrainGeneratorKind;

  readonly parameters?: Readonly<Record<string, number>>;

}

type WaveTerrainGeneratorKind = "perlinNoise" | "sineWaveRoad";

interface WaveTerrainGpuSurfaceSourceOptions {

  readonly coverage: WaveRelativeCoveragePlan;

  readonly exclusionFalloff?: number;

  readonly maximumElevation?: number;

  readonly minimumElevation?: number;

  readonly minimumUpdateIntervalSeconds?: number;

}

interface WaveTerrainGridDefinition {

  readonly authoredWorldSize?: WaveTerrainTileSize;

  readonly extent: WaveTerrainGridExtent;

  readonly residency: WaveTerrainGridResidency;

  readonly subdivisionsPerTile: number;

  readonly tileSize: WaveTerrainTileSize;

}

interface WaveTerrainGridDefinitionInput {

  readonly authoredWorldSize?: Partial<WaveTerrainTileSize>;

  readonly extent?: { readonly kind: "finite"; readonly columns?: number; readonly rows?: number; readonly origin?: { readonly x?: number; readonly z?: number; }; } | { readonly kind: "endless"; }

  readonly residency?: { readonly kind: "all"; } | { readonly kind: "cameraWindow"; readonly columns?: number; readonly rows?: number; readonly prefetch?: number; }

  readonly subdivisionsPerTile?: number;

  readonly tileSize?: Partial<WaveTerrainTileSize>;

}

type WaveTerrainGridExtent = { readonly kind: "finite"; readonly columns: number; readonly rows: number; readonly origin?: { readonly x: number; readonly z: number; }; } | { readonly kind: "endless"; }

type WaveTerrainGridResidency = { readonly kind: "all"; } | { readonly kind: "cameraWindow"; readonly columns: number; readonly rows: number; readonly prefetch: number; }

interface WaveTerrainLayerBuilderTarget<TTerminal> {

  flush(): void;

  prepareMaterial?(material: WaveTerrainMaterialInput): void;

  read(): WaveTerrainLayerDefinition | null;

  terminal(): TTerminal;

  write(definition: WaveTerrainLayerDefinition): void;

}

interface WaveTerrainLayerDefinition {

  readonly base: WaveTerrainBaseDefinition;

  readonly grid: WaveTerrainGridDefinition;

  readonly kind: typeof WAVE_TERRAIN_LAYER_KIND;

  readonly materials?: WaveTerrainMaterialDefinition;

  readonly nodes: readonly WaveTerrainNode[];

  readonly profile?: WaveTerrainProfileSelection;

  readonly provenance?: WaveTerrainProfileProvenance;

  readonly revision: string;

  readonly version: typeof WAVE_TERRAIN_LAYER_VERSION;

}

interface WaveTerrainLayerDefinitionInput {

  readonly base?: WaveTerrainBaseDefinitionInput;

  readonly grid?: WaveTerrainGridDefinitionInput;

  readonly kind?: typeof WAVE_TERRAIN_LAYER_KIND;

  readonly materials?: WaveTerrainMaterialDefinition | WaveTerrainMaterialDefinitionInput;

  readonly nodes?: readonly (WaveTerrainNode | WaveTerrainNodeInput)[];

  readonly profile?: WaveTerrainProfileSelection;

  readonly provenance?: WaveTerrainProfileProvenance;

  readonly revision?: string;

  readonly version?: typeof WAVE_TERRAIN_LAYER_VERSION;

}

type WaveTerrainLayerDefinitionLike = WaveTerrainLayerDefinition | WaveTerrainLayerDefinitionInput;

interface WaveTerrainLevelAreaNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly blendDistance: number;

  readonly bounds: WaveTerrainBounds;

  readonly height: number;

  readonly kind: "levelArea";

}

interface WaveTerrainLodStylePolicy {

  readonly farMaterialTier: "flat" | "macro" | "pbr";

  readonly geometricErrorScale: number;

  readonly preserveSilhouette: boolean;

}

interface WaveTerrainMaterialBuilderTarget {

  flush(): void;

  prepareMaterial(material: WaveTerrainMaterialInput): void;

  read(): WaveTerrainMaterialDefinition | undefined;

  write(definition: WaveTerrainMaterialDefinition): void;

}

interface WaveTerrainMaterialDefinition {

  readonly kind: "waveTerrainMaterialDefinition";

  readonly pages: WaveTerrainMaterialPagePolicy;

  readonly roles: readonly WaveTerrainMaterialRoleBinding[];

  readonly spatialBindings: readonly WaveTerrainMaterialSpatialBinding[];

  readonly splat: MaterialSplatDefinition | null;

  readonly version: typeof WAVE_TERRAIN_MATERIAL_VERSION;

}

interface WaveTerrainMaterialDefinitionInput {

  readonly kind?: "waveTerrainMaterialDefinition";

  readonly pages?: Partial<WaveTerrainMaterialPagePolicy> & { readonly pageResolution?: Partial<WaveTerrainMaterialPagePolicy["pageResolution"]>; }

  readonly roles?: readonly WaveTerrainMaterialRoleBinding[];

  readonly spatialBindings?: readonly WaveTerrainMaterialSpatialBinding[];

  readonly splat?: MaterialSplatDefinition | null;

  readonly version?: typeof WAVE_TERRAIN_MATERIAL_VERSION;

}

type WaveTerrainMaterialHeightBlendInput = Partial<MaterialSplatHeightBlendDefinition>;

type WaveTerrainMaterialInput = string | WaveMaterialInput;

interface WaveTerrainMaterialLayerSnapshot {

  readonly layer: MaterialSplatLayerDefinition;

  readonly role?: TerrainMaterialRole;

}

interface WaveTerrainMaterialPagePolicy {

  readonly gutter: number;

  readonly maxResidentPages: number;

  readonly pageResolution: { readonly width: number; readonly depth: number; }

}

interface WaveTerrainMaterialProjectionInput {

  readonly blendSharpness?: number;

  readonly kind?: NonNullable<MaterialSplatLayerDefinition["projection"]>;

  readonly tileEvery?: number;

}

interface WaveTerrainMaterialRoleBinding {

  readonly layer: MaterialSplatLayerId;

  readonly role: TerrainMaterialRole;

}

interface WaveTerrainMaterialSpatialBinding {

  readonly blendDistance: number;

  readonly ruleId: string;

  readonly target: WaveTerrainMaterialSpatialTarget;

}

type WaveTerrainMaterialSpatialTarget = { readonly kind: "featureRegion"; readonly featureId: string; readonly region: string; } | { readonly kind: "semanticMask"; readonly maskId: string; }

interface WaveTerrainMaterialStylePolicy {

  readonly broadRegions: boolean;

  readonly heightBlend: boolean;

  readonly macroTint: number;

  readonly stochasticBreakup: number;

}

type WaveTerrainMountainGeometryStyle = "realistic" | "lowPoly";

interface WaveTerrainMountainNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly baseRadius: number;

  readonly craterDepth?: number;

  readonly footprintJitter?: number;

  readonly footprintNoiseScale?: number;

  readonly geometryStyle: WaveTerrainMountainGeometryStyle;

  readonly height: number;

  readonly kind: "mountain";

  readonly preset: MountainPreset;

  readonly ridge?: WaveTerrainMountainRidgeIntent;

  readonly roughness?: number;

  readonly secondaryPeaks?: number;

  readonly slice?: WaveTerrainAngularSliceIntent;

  readonly topBlendFactor?: number;

  readonly topHeightFactor?: number;

  readonly topRadiusFactor?: number;

}

interface WaveTerrainMountainRidgeIntent {

  readonly count: number;

  readonly layout: WaveTerrainMountainRidgeLayout;

  readonly path: readonly WaveTerrainPoint2[];

}

type WaveTerrainMountainRidgeLayout = "centralPeak" | "evenPeaks" | "randomPeaks";

type WaveTerrainNode = WaveTerrainMountainNode | WaveTerrainBasinNode | WaveTerrainRidgeNode | WaveTerrainRiverNode | WaveTerrainTerracesNode | WaveTerrainContourReliefNode | WaveTerrainLevelAreaNode | WaveTerrainTrailNode | WaveTerrainNoiseNode | WaveTerrainErosionNode | WaveTerrainSmoothNode | WaveTerrainAuthoredSculptNode;

type WaveTerrainNodeBlendPolicy = { readonly mode: "add"; readonly strength?: number; } | { readonly mode: "subtract"; readonly strength?: number; } | { readonly mode: "replace"; readonly strength?: number; } | { readonly mode: "min" | "max"; readonly strength?: number; }

type WaveTerrainNodeInput = WaveTerrainNode extends infer TNode ? TNode extends WaveTerrainNode ? Omit<TNode, "revision" | "enabled" | "transform"> & { readonly revision?: string; readonly enabled?: boolean; readonly transform?: Partial<TransformSnapshotLike>; } : never : never;

interface WaveTerrainNoiseNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly amplitude: number;

  readonly bounds: WaveTerrainBounds;

  readonly frequency: number;

  readonly kind: "noise";

  readonly octaves: number;

}

interface WaveTerrainNormalPolicy {

  readonly detailStrength: number;

  readonly mode: "faceted" | "weightedSmooth" | "smooth";

}

type WaveTerrainPoint2 = { readonly x: number; readonly z: number; }

interface WaveTerrainProfileExplanation {

  readonly explicitOverridePaths: readonly string[];

  readonly generatedNodeIds: readonly string[];

  readonly qualityPolicy: WaveTerrainQualityPolicy;

  readonly selection: WaveTerrainProfileSelection;

  readonly stages: readonly string[];

  readonly stylePolicy: WaveTerrainStylePolicy;

  readonly versions: { readonly preset: number; readonly style: number; readonly quality: number; }

  readonly warnings: readonly string[];

}

interface WaveTerrainProfileProvenance {

  readonly explicitOverridePaths: readonly string[];

  readonly generatedNodeIds: readonly string[];

  readonly preset: WaveTerrainProfileVersion;

  readonly quality: WaveTerrainProfileVersion;

  readonly style: WaveTerrainProfileVersion;

}

interface WaveTerrainProfileSelection {

  readonly preset: TerrainPreset;

  readonly quality: TerrainQuality;

  readonly style: TerrainStyle;

}

interface WaveTerrainProfileVersion {

  readonly id: string;

  readonly version: number;

}

interface WaveTerrainQualityPolicy {

  readonly erosionIterations: number;

  readonly erosionResolutionScale: number;

  readonly generationWorkerBudget: number;

  readonly materialPageResolution: number;

  readonly maxDetailBands: number;

  readonly retainedTileBudget: number;

  readonly subdivisionsPerTile: number;

}

interface WaveTerrainQueryHost {

  heightsInGridToRef(query: TerrainHeightGridQuery, out: Float32Array): Float32Array;

  isReady(): boolean;

  normalAtToRef<TOut extends SerializableVector3>(x: number, z: number, out: TOut): TOut | null;

  observeHeightfieldChanges(callback: (bounds: WaveTerrainBounds | null) => void): () => void;

  querySurface(position: SurfaceQueryInput): SurfaceQueryResult | null;

  querySurface(x: number, z: number): SurfaceQueryResult | null;

  rayIntersection(origin: Vector3, direction: Vector3, length: number): RayHit | null;

  surfaceAtToRef<TOut extends TerrainSurfaceQueryRef>(x: number, z: number, out: TOut): TOut | null;

  whenReady(callback: () => void): () => void;

}

interface WaveTerrainReliefGeographicReference {

  readonly crs: string;

  readonly eastLongitudeDegrees: number;

  readonly kind: "geographic";

  readonly northLatitudeDegrees: number;

  readonly southLatitudeDegrees: number;

  readonly westLongitudeDegrees: number;

}

interface WaveTerrainReliefProjectedReference {

  readonly crs: string;

  readonly kind: "projected";

  readonly maxX: number;

  readonly maxY: number;

  readonly minX: number;

  readonly minY: number;

  readonly units: "meters";

}

interface WaveTerrainReliefSource {

  readonly attribution: string;

  readonly doi?: string;

  readonly license: string;

  readonly name: string;

  readonly publisher: string;

  readonly url: string;

}

type WaveTerrainReliefSpatialReference = WaveTerrainReliefGeographicReference | WaveTerrainReliefProjectedReference;

interface WaveTerrainRidgeNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly height: number;

  readonly kind: "ridge";

  readonly path: readonly WaveTerrainPoint2[];

  readonly spacing: number;

  readonly width: number;

}

interface WaveTerrainRiverChannel {

  readonly bankSlope: number;

  readonly bedWidth: number;

  readonly blendDistance: number;

  readonly crossSection: WaveTerrainRiverCrossSection;

  readonly depth: number;

  readonly topWidth: number;

}

type WaveTerrainRiverCourse = { readonly kind: "followPath"; } | { readonly kind: "meander"; readonly amplitude: number; readonly wavelength: number; readonly roughness: number; readonly preserveWaypoints: true; }

type WaveTerrainRiverCrossSection = "natural" | "v" | "u" | "trapezoid";

interface WaveTerrainRiverElevationControlPoint {

  readonly distance: number;

  readonly elevation: number;

}

type WaveTerrainRiverGrade = { readonly kind: "followDownhill"; readonly minimumSlope: number; readonly maximumSlope: number; } | { readonly kind: "sourceToMouth"; readonly sourceElevation: number; readonly mouthElevation: number; } | { readonly kind: "profile"; readonly points: readonly WaveTerrainRiverElevationControlPoint[]; }

interface WaveTerrainRiverMaterialRoles {

  readonly banks?: TerrainMaterialRole | string;

  readonly bed?: TerrainMaterialRole | string;

  readonly floodplain?: TerrainMaterialRole | string;

  readonly shoreline?: TerrainMaterialRole | string;

}

interface WaveTerrainRiverNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly channel: WaveTerrainRiverChannel;

  readonly course: WaveTerrainRiverCourse;

  readonly grade: WaveTerrainRiverGrade;

  readonly kind: "river";

  readonly materialRoles?: WaveTerrainRiverMaterialRoles;

  readonly path: readonly WaveTerrainPoint2[];

  readonly preset: RiverPreset;

  readonly water?: WaveTerrainRiverWater;

}

interface WaveTerrainRiverRangeOptions {

  readonly height?: number;

  readonly margin?: number;

  readonly name?: string;

  readonly pathPlane?: "xy" | "xz" | "yz";

  readonly width?: number;

  readonly y?: number;

}

interface WaveTerrainRiverWater {

  readonly bodyModel: WaveWaterBodyModel;

  readonly clearance: number;

  readonly depth: number;

  readonly uScale: number;

  readonly vScale: number;

}

interface WaveTerrainRuntimeBounds {

  readonly maxX: number;

  readonly maxZ: number;

  readonly minX: number;

  readonly minZ: number;

}

interface WaveTerrainRuntimeCheckpoint {

  readonly createdAtSequence: number;

  readonly deltaSet: WaveTerrainRuntimeDeltaSet;

  readonly kind: typeof WAVE_TERRAIN_RUNTIME_CHECKPOINT_KIND;

  readonly version: typeof WAVE_TERRAIN_RUNTIME_CHECKPOINT_VERSION;

}

type WaveTerrainRuntimeDelta = WaveTerrainRuntimeMaterialCircleDelta | WaveTerrainRuntimeMaterialPathDelta | WaveTerrainRuntimeHeightCircleDelta | WaveTerrainRuntimeHeightPathDelta | WaveTerrainRuntimeErosionDelta | WaveTerrainRuntimeRestoreMaterialPageDelta;

interface WaveTerrainRuntimeDeltaContext {

  readonly baseTerrainLayerRevision: string;

  readonly baseWorldPlanRevision: string;

  readonly terrainLayerId: string;

  readonly worldId: string;

}

interface WaveTerrainRuntimeDeltaDiagnostics {

  readonly affectedBounds: WaveTerrainRuntimeBounds | null;

  readonly compatibilityReason: string | null;

  readonly compatible: boolean;

  readonly estimatedBytes: number;

  readonly operationCount: number;

  readonly revision: string;

  readonly transactionCount: number;

}

type WaveTerrainRuntimeDeltaInput = WaveTerrainRuntimeDelta extends infer TDelta ? TDelta extends WaveTerrainRuntimeDelta ? Omit<TDelta, "id" | "transactionId" | "sequence"> : never : never;

interface WaveTerrainRuntimeDeltaSet {

  readonly baseTerrainLayerRevision: string;

  readonly baseWorldPlanRevision: string;

  readonly kind: typeof WAVE_TERRAIN_RUNTIME_DELTA_KIND;

  readonly operations: readonly WaveTerrainRuntimeDelta[];

  readonly revision: string;

  readonly terrainLayerId: string;

  readonly version: typeof WAVE_TERRAIN_RUNTIME_DELTA_VERSION;

  readonly worldId: string;

}

interface WaveTerrainRuntimeErosionDelta {

  readonly bounds: WaveTerrainRuntimeBounds;

  readonly id: string;

  readonly sequence: number;

  readonly source?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly transactionId: string;

  readonly center: WaveTerrainRuntimePoint;

  readonly falloff: WaveTerrainRuntimeFalloff;

  readonly feather: number;

  readonly kind: "erosion";

  readonly preset: TerrainErosionPreset;

  readonly radius: number;

  readonly strength: number;

}

interface WaveTerrainRuntimeFacadeHost<TTerminal> {

  context(): WaveTerrainRuntimeDeltaContext;

  resolveMaterialLayer(materialId: string): number;

  target(): WaveTerrainRuntimeTarget | null;

  terminal(): TTerminal;

}

type WaveTerrainRuntimeFalloff = "smooth" | "linear" | "hard";

interface WaveTerrainRuntimeHeightCircleDelta {

  readonly bounds: WaveTerrainRuntimeBounds;

  readonly id: string;

  readonly sequence: number;

  readonly source?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly transactionId: string;

  readonly amount?: number;

  readonly center: WaveTerrainRuntimePoint;

  readonly falloff: WaveTerrainRuntimeFalloff;

  readonly frequency?: number;

  readonly iterations?: number;

  readonly kind: "heightCircle";

  readonly mode: "raise" | "lower" | "level" | "smooth" | "noise";

  readonly octaves?: number;

  readonly radius: number;

  readonly targetHeight?: number;

}

interface WaveTerrainRuntimeHeightPathDelta {

  readonly bounds: WaveTerrainRuntimeBounds;

  readonly id: string;

  readonly sequence: number;

  readonly source?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly transactionId: string;

  readonly amount?: number;

  readonly falloff: WaveTerrainRuntimeFalloff;

  readonly frequency?: number;

  readonly iterations?: number;

  readonly kind: "heightPath";

  readonly mode: "raise" | "lower" | "level" | "smooth" | "noise";

  readonly octaves?: number;

  readonly path: readonly WaveTerrainRuntimePoint[];

  readonly targetHeight?: number;

  readonly width: number;

}

interface WaveTerrainRuntimeMaterialCircleDelta {

  readonly bounds: WaveTerrainRuntimeBounds;

  readonly id: string;

  readonly sequence: number;

  readonly source?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly transactionId: string;

  readonly center: WaveTerrainRuntimePoint;

  readonly falloff: WaveTerrainRuntimeFalloff;

  readonly kind: "materialCircle";

  readonly materialId: string;

  readonly mode: "paint" | "erase";

  readonly radius: number;

  readonly strength: number;

}

interface WaveTerrainRuntimeMaterialPageKey {

  readonly terrainLayerId: string;

  readonly terrainLayerRevision: string;

  readonly tier: WaveTerrainRuntimeMaterialPageTier;

  readonly tileX: number;

  readonly tileZ: number;

}

type WaveTerrainRuntimeMaterialPageTier = "near" | "mid" | "far" | "horizon";

interface WaveTerrainRuntimeMaterialPathDelta {

  readonly bounds: WaveTerrainRuntimeBounds;

  readonly id: string;

  readonly sequence: number;

  readonly source?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly transactionId: string;

  readonly falloff: WaveTerrainRuntimeFalloff;

  readonly kind: "materialPath";

  readonly materialId: string;

  readonly mode: "paint" | "erase";

  readonly path: readonly WaveTerrainRuntimePoint[];

  readonly strength: number;

  readonly width: number;

}

interface WaveTerrainRuntimePoint {

  readonly x: number;

  readonly z: number;

}

interface WaveTerrainRuntimeRestoreMaterialPageDelta {

  readonly bounds: WaveTerrainRuntimeBounds;

  readonly id: string;

  readonly sequence: number;

  readonly source?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly transactionId: string;

  readonly gutter: number;

  readonly height: number;

  readonly kind: "restoreMaterialPage";

  readonly pageKey: WaveTerrainRuntimeMaterialPageKey;

  readonly pageRevision: string;

  readonly paletteRevision: string;

  readonly weightPixelsBase64: string;

  readonly width: number;

}

declare class WaveTerrainRuntimeStroke<TTerminal> {

  constructor(_builder: WaveTerrainBrushBuilder<TTerminal>, start: WaveTerrainRuntimePoint);

  cancel(): TTerminal;

  continueAt(value: WaveTerrainRuntimePoint): this;

  continueAt(x: number, z: number): this;

  end(): TTerminal;

}

interface WaveTerrainRuntimeTarget {

  appendRecipeStep(step: TerrainRecipeStep, bounds: WaveTerrainRuntimeBounds): boolean;

  eraseMaterialCircle(layer: number, center: { readonly x: number; readonly y: number; }, radius: number, strength: number, falloff: WaveTerrainRuntimeFalloff): boolean;

  eraseMaterialPath(layer: number, path: Array<{ readonly x: number; readonly y: number; }>, width: number, strength: number, falloff: WaveTerrainRuntimeFalloff): boolean;

  paintMaterialCircle(layer: number, center: { readonly x: number; readonly y: number; }, radius: number, strength: number, falloff: WaveTerrainRuntimeFalloff): boolean;

  paintMaterialPath(layer: number, path: Array<{ readonly x: number; readonly y: number; }>, width: number, strength: number, falloff: WaveTerrainRuntimeFalloff): boolean;

  projectWorldSurfacePointToAuthoringToRef(worldX: number, worldZ: number, out: { x: number; z: number; }): { x: number; z: number; } | null;

  readRecipe(): TerrainRecipe | null;

  replaceRecipe(recipe: TerrainRecipe, bounds?: WaveTerrainRuntimeBounds | null): boolean;

  restoreMaterialPage(operation: WaveTerrainRuntimeRestoreMaterialPageDelta, context: WaveTerrainRuntimeDeltaContext): boolean;

}

interface WaveTerrainShapingPolicy {

  readonly contourQuantization: number;

  readonly detailBands: number;

  readonly domainWarp: number;

  readonly largeFeatureSize: number;

  readonly ridgeSharpness: number;

}

interface WaveTerrainSmoothNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly bounds: WaveTerrainBounds;

  readonly iterations: number;

  readonly kind: "smooth";

}

interface WaveTerrainStylePolicy {

  readonly lod: WaveTerrainLodStylePolicy;

  readonly materials: WaveTerrainMaterialStylePolicy;

  readonly normals: WaveTerrainNormalPolicy;

  readonly shaping: WaveTerrainShapingPolicy;

  readonly weathering: WaveTerrainWeatheringPolicy;

}

interface WaveTerrainSurface {

  heightAt(x: number, z: number): number | null;

  normalAt(x: number, z: number): SurfaceQueryResult["normal"] | null;

  query(): WaveTerrainQueryFacade;

}

interface WaveTerrainTerracesNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly bounds: WaveTerrainBounds;

  readonly kind: "terraces";

  readonly maxHeight: number;

  readonly minHeight: number;

  readonly preset: TerracePreset;

  readonly stepHeight: number;

  readonly strength: number;

}

interface WaveTerrainTileSize {

  readonly depth: number;

  readonly width: number;

}

interface WaveTerrainTrailNode {

  readonly blend?: WaveTerrainNodeBlendPolicy | undefined;

  readonly enabled: boolean;

  readonly id: string;

  readonly metadata?: Readonly<Record<string, SerializableDataValue>> | undefined;

  readonly revision: string;

  readonly seed?: number | undefined;

  readonly transform: TransformSnapshotLike;

  readonly blendDistance: number;

  readonly height: number;

  readonly kind: "trail";

  readonly path: readonly WaveTerrainPoint2[];

  readonly width: number;

}

interface WaveTerrainWeatheringPolicy {

  readonly drainageEvidence: boolean;

  readonly hydraulicErosion: number;

  readonly paddedHaloMeters: number;

  readonly sedimentDeposition: number;

  readonly thermalErosion: number;

}

interface WaveTerrainWorldBounds {

  readonly max: { readonly x: number; readonly y: number; readonly z: number; }

  readonly min: { readonly x: number; readonly y: number; readonly z: number; }

}

interface WaveTextBatchLabel {

  readonly color?: ColorInputAlpha;

  readonly position: Vector3Like;

  readonly size?: number;

  readonly text?: string;

}

declare class WaveTextParamBuilder<TValue extends string | null = string> implements WaveParamBuilder<TValue> {

  constructor(spec?: WaveParamSpec<TValue>);

  default(value: string): WaveTextParamBuilder<string>;

  describedAs(description: string): WaveTextParamBuilder<TValue>;

  maxLength(length: number): WaveTextParamBuilder<TValue>;

  minLength(length: number): WaveTextParamBuilder<TValue>;

  optional(): WaveTextParamBuilder<string | null>;

  toSpec(): WaveParamSpec<TValue>;

}

type WaveTextureAtlasAlphaMode = "straight" | "opaque";

interface WaveTextureAtlasAnimationRecord {

  readonly driveByAge: boolean;

  readonly durationsMs: readonly number[];

  readonly frameIds: readonly string[];

  readonly interpolation: WaveTextureAtlasInterpolation;

  readonly name: string;

  readonly playMode: WaveTextureAtlasPlayMode;

  readonly seamlessLoop?: boolean;

}

type WaveTextureAtlasColorSpace = "srgb" | "linear";

type WaveTextureAtlasFilter = "nearest" | "linear";

interface WaveTextureAtlasFrameRecord {

  readonly cellIndex?: number;

  readonly id: string;

  readonly pageId: string;

  readonly pivot: WaveTextureAtlasPoint;

  readonly rect: WaveTextureAtlasRect;

  readonly sourceSize: WaveTextureAtlasSize;

  readonly trimOffset: WaveTextureAtlasPoint;

}

interface WaveTextureAtlasGrid {

  readonly cellHeight: number;

  readonly cellWidth: number;

  readonly columns: number;

  readonly rows: number;

}

type WaveTextureAtlasInterpolation = "none" | "crossfade" | "motion";

interface WaveTextureAtlasManifest {

  readonly animations: readonly WaveTextureAtlasAnimationRecord[];

  readonly frames: Readonly<Record<string, WaveTextureAtlasFrameRecord>>;

  readonly motion?: WaveTextureAtlasMotionSet;

  readonly pages: readonly WaveTextureAtlasPageRecord[];

  readonly profile: WaveTextureAtlasProfile;

  readonly sampling: WaveTextureAtlasSamplingPolicy;

  readonly schema: "wave.textureAtlas.v1";

  readonly version: 1;

}

type WaveTextureAtlasMipMode = "none" | "runtimeGenerated";

interface WaveTextureAtlasMotionEstimatorRecord {

  readonly blockStride: number;

  readonly cellHeight: number;

  readonly cellWidth: number;

  readonly id: string;

  readonly patchRadius: number;

  readonly searchRadius: number;

}

interface WaveTextureAtlasMotionSet {

  readonly backward: WaveTextureAtlasMotionTextureRecord;

  readonly confidenceChannel: "b";

  readonly coordinateSpace: "sourceCanvasNormalized";

  readonly estimator: WaveTextureAtlasMotionEstimatorRecord;

  readonly forward: WaveTextureAtlasMotionTextureRecord;

  readonly maxDisplacementNormalized: number;

  readonly sampling: Readonly<{ readonly filter: "linear"; readonly mipMode: "none"; readonly wrap: "clamp"; }>;

  readonly schema: "wave.textureAtlas.motion.v1";

  readonly transitions: readonly WaveTextureAtlasMotionTransitionRecord[];

  readonly vectorEncoding: WaveTextureAtlasMotionVectorEncoding;

}

interface WaveTextureAtlasMotionTextureRecord {

  readonly contentHash?: string;

  readonly grid: WaveTextureAtlasGrid;

  readonly height: number;

  readonly id: string;

  readonly textureAssetRef: string;

  readonly width: number;

}

interface WaveTextureAtlasMotionTransitionRecord {

  readonly averageConfidence?: number;

  readonly cellIndex: number;

  readonly fromFrameId: string;

  readonly toFrameId: string;

}

type WaveTextureAtlasMotionVectorEncoding = "rg8unormSigned";

interface WaveTextureAtlasPageRecord {

  readonly alphaMode: WaveTextureAtlasAlphaMode;

  readonly colorSpace: WaveTextureAtlasColorSpace;

  readonly contentHash?: string;

  readonly grid?: WaveTextureAtlasGrid;

  readonly height: number;

  readonly id: string;

  readonly textureAssetRef: string;

  readonly width: number;

}

type WaveTextureAtlasPlayMode = "once" | "loop";

interface WaveTextureAtlasPoint {

  readonly x: number;

  readonly y: number;

}

type WaveTextureAtlasProfile = "sprite" | "spriteAnimation" | "vfxFlipbook" | "uiSkin" | "foliageCards" | "staticMaskAtlas" | "materialChannels";

interface WaveTextureAtlasRect {

  readonly height: number;

  readonly width: number;

  readonly x: number;

  readonly y: number;

}

interface WaveTextureAtlasRuntimeAnimation {

  readonly cumulativeEndMs: readonly number[];

  readonly driveByAge: boolean;

  readonly durationsMs: readonly number[];

  readonly frameIndexes: readonly number[];

  readonly index: number;

  readonly interpolation: WaveTextureAtlasInterpolation;

  readonly name: string;

  readonly playMode: WaveTextureAtlasPlayMode;

  readonly seamlessLoop: boolean;

  readonly totalDurationMs: number;

}

interface WaveTextureAtlasRuntimeFrame {

  readonly cellIndex?: number | undefined;

  readonly id: string;

  readonly pageId: string;

  readonly pivot: WaveTextureAtlasPoint;

  readonly rect: WaveTextureAtlasRect;

  readonly sourceSize: WaveTextureAtlasSize;

  readonly trimOffset: WaveTextureAtlasPoint;

  readonly index: number;

  readonly pageIndex: number;

  readonly uv: Readonly<{ u0: number; v0: number; u1: number; v1: number; }>;

}

interface WaveTextureAtlasRuntimeMotionSet {

  readonly backward: WaveTextureAtlasMotionTextureRecord;

  readonly confidenceChannel: "b";

  readonly coordinateSpace: "sourceCanvasNormalized";

  readonly estimator: WaveTextureAtlasMotionEstimatorRecord;

  readonly forward: WaveTextureAtlasMotionTextureRecord;

  readonly maxDisplacementNormalized: number;

  readonly sampling: Readonly<{ readonly filter: "linear"; readonly mipMode: "none"; readonly wrap: "clamp"; }>;

  readonly schema: "wave.textureAtlas.motion.v1";

  readonly vectorEncoding: "rg8unormSigned";

  readonly transitionIndexByFramePair: ReadonlyMap<string, number>;

  readonly transitions: readonly WaveTextureAtlasRuntimeMotionTransition[];

}

interface WaveTextureAtlasRuntimeMotionTransition {

  readonly averageConfidence?: number | undefined;

  readonly cellIndex: number;

  readonly fromFrameId: string;

  readonly toFrameId: string;

  readonly fromFrameIndex: number;

  readonly index: number;

  readonly toFrameIndex: number;

}

interface WaveTextureAtlasRuntimePage {

  readonly alphaMode: WaveTextureAtlasAlphaMode;

  readonly colorSpace: WaveTextureAtlasColorSpace;

  readonly contentHash?: string | undefined;

  readonly grid?: WaveTextureAtlasGrid | undefined;

  readonly height: number;

  readonly id: string;

  readonly textureAssetRef: string;

  readonly width: number;

  readonly index: number;

}

interface WaveTextureAtlasRuntimeView {

  readonly animationIndexByName: ReadonlyMap<string, number>;

  readonly animations: readonly WaveTextureAtlasRuntimeAnimation[];

  readonly frameIndexById: ReadonlyMap<string, number>;

  readonly frames: readonly WaveTextureAtlasRuntimeFrame[];

  readonly motion?: WaveTextureAtlasRuntimeMotionSet;

  readonly pages: readonly WaveTextureAtlasRuntimePage[];

  readonly revision: string;

}

interface WaveTextureAtlasSamplingPolicy {

  readonly alphaMode: WaveTextureAtlasAlphaMode;

  readonly filter: WaveTextureAtlasFilter;

  readonly mipMode: WaveTextureAtlasMipMode;

  readonly uvInset?: number;

  readonly wrap: "clamp";

}

interface WaveTextureAtlasSize {

  readonly height: number;

  readonly width: number;

}

type WaveTextureCpuChannel = "r" | "g" | "b" | "a" | "luminance";

interface WaveTextureCpuPixels {

  readonly data: Uint8Array | Uint8ClampedArray;

  readonly height: number;

  readonly invertY?: boolean;

  readonly width: number;

}

type WaveTextureCpuSampling = "nearest" | "bilinear";

interface WaveTextureEffectHandle {

  applyPlayback(config: WaveTextureEffectPlaybackConfig): this;

  dispose(): void;

  readonly isPlaying: boolean;

  playEvery(value: number, unit: WaveTimeUnit): this;

  stop(): this;

  readonly texture: unknown | null;

  update(time: number, wobbleX?: number, wobbleY?: number): void;

}

interface WaveTextureEffectPlaybackConfig {

  readonly updateEvery: WaveTimeSpanSpec;

}

interface WaveTextureSampleValueExpr {

  readonly kind?: "vec4" | "color";

  readonly outOfBounds?: "clamp" | "zero";

  readonly textureId: string;

  readonly type: "textureSample";

  readonly uv: WaveValueExpr;

}

interface WaveThinBatchColorSample {

  readonly a: number;

  readonly b: number;

  readonly g: number;

  readonly r: number;

}

interface WaveThinBatchModelOptions {

  readonly part?: WaveModelPartRef;

}

interface WaveTilemapComboConfig {

  readonly enabled?: boolean;

  readonly maxCoverFraction?: number;

  readonly overlapPolicy?: "forbid" | "priority" | "weighted";

}

interface WaveTilemapGridConfig {

  readonly cellDepth?: number;

  readonly cellSize?: number;

  readonly cellWidth?: number;

  readonly cols?: number;

  readonly layerHeight?: number;

  readonly layers?: number;

  readonly origin?: Readonly<SerializableVector3>;

  readonly rows?: number;

}

interface WaveTilemapLayerConfig {

  readonly combos: WaveTilemapComboConfig;

  readonly grammarId?: string;

  readonly grid: WaveTilemapGridConfig;

  readonly renderer: WaveTilemapRendererConfig;

  readonly solver: WaveTilemapSolverConfig;

}

interface WaveTilemapRendererConfig {

  readonly batching?: "thinInstances" | "mergedMeshes";

  readonly billboards?: "cardSprites" | "none";

  readonly chunkBake?: "lazy" | "eager";

  readonly chunkCols?: number;

  readonly chunkRows?: number;

  readonly maxMaterialVariantsPerChunk?: number;

  readonly surfaceStamps?: "flatCards" | "projectedDecals" | "none";

}

interface WaveTilemapSolverConfig {

  readonly contradictionPolicy?: "retry" | "backtrack" | "fail";

  readonly kind: WaveTilemapSolverKind;

  readonly retryLimit?: number;

}

type WaveTilemapSolverKind = "wfc" | "macroThenWfc" | "authoredPlan" | (string & {});

interface WaveTilemapWorldLayerOptions {

  readonly activeRadius?: number | WaveWorldRadius;

  readonly combos?: WaveTilemapComboConfig;

  readonly endless?: boolean;

  readonly grammarId?: string;

  readonly grid?: WaveTilemapGridConfig;

  readonly physics?: WorldStreamingPhysicsConfig;

  readonly queryPriority?: number;

  readonly renderer?: WaveTilemapRendererConfig;

  readonly required?: boolean;

  readonly solver?: WaveTilemapSolverConfig;

  readonly workers?: WaveWorldWorkerPolicy;

}

interface WaveTiles3DGridConfig {

  readonly activeRadius?: number | WaveWorldRadius;

  readonly cellDepth?: number;

  readonly cellSize?: number;

  readonly cellWidth?: number;

  readonly cols?: number;

  readonly endless?: boolean;

  readonly gridInfo?: GridLayout;

  readonly layerHeight?: number;

  readonly layers?: number;

  readonly origin?: WaveTiles3DVector3Config;

  readonly rows?: number;

  readonly seed?: number;

}

interface WaveTiles3DLayerConfig<TRendererOptions extends object = object> {

  readonly grid: Omit<WaveTiles3DGridConfig, "activeRadius" | "endless" | "seed">;

  readonly renderer: WaveTiles3DRendererConfig<TRendererOptions>;

  readonly surface: WaveTiles3DSurfaceConfig;

  readonly transform: WaveTiles3DTransformConfig;

}

type WaveTiles3DRendererBackend = "babylon" | "cesium" | (string & {});

interface WaveTiles3DRendererConfig<TOptions extends object = object> {

  readonly backend: WaveTiles3DRendererBackend;

  readonly options: TOptions;

}

interface WaveTiles3DSurfaceConfig {

  readonly allowNearestFallback?: boolean;

  readonly horizontalSearchPadding?: number;

  readonly includeDisabledMeshes?: boolean;

  readonly maxSlopeDegrees?: number;

  readonly mode?: WaveTiles3DSurfaceMode;

  readonly proxy?: WaveTiles3DSurfaceProxyKind;

  readonly verticalSearchPadding?: number;

}

type WaveTiles3DSurfaceMode = "walkableTop" | "nearest" | "outer";

type WaveTiles3DSurfaceProxyKind = "triangleSoup" | "none";

interface WaveTiles3DTransformConfig {

  readonly position?: WaveTiles3DVector3Config;

}

type WaveTiles3DVector3Config = Readonly<SerializableVector3>;

interface WaveTiles3DWorldLayerOptions<TRendererOptions extends object = object> {

  readonly activeRadius?: number | WaveWorldRadius;

  readonly endless?: boolean;

  readonly grid?: Omit<WaveTiles3DGridConfig, "activeRadius" | "endless" | "seed">;

  readonly physics?: WorldStreamingPhysicsConfig;

  readonly queryPriority?: number;

  readonly renderer?: WaveTiles3DRendererConfig<TRendererOptions>;

  readonly required?: boolean;

  readonly surface?: WaveTiles3DSurfaceConfig;

  readonly transform?: WaveTiles3DTransformConfig;

  readonly workers?: WaveWorldWorkerPolicy;

}

declare class WaveTimeLookback {

  constructor(value: number, unit: WaveTimeUnitKind);

  readonly kind = "lookback";

  readonly unit: WaveTimeUnitKind;

  readonly value: number;

}

declare class WaveTimePoint {

  constructor(unit: WaveTimeUnitKind, value: number, options?: { kind?: WaveTimePointKind; jsNowMs?: number | null; tick?: number | null; seconds?: number | null; });

  readonly jsNowMs: number | null;

  readonly kind: WaveTimePointKind;

  readonly seconds: number | null;

  readonly tick: number | null;

  readonly unit: WaveTimeUnitKind;

  readonly value: number;

}

type WaveTimePointKind = "point" | "now";

declare class WaveTimeRule {

  constructor(kind: WaveTimeRuleKind, options?: { mode?: WaveTimeRuleMode | null; value?: number | null; unit?: WaveTimeUnitKind | null; point?: WaveTimePoint | null; start?: WaveTimePoint | null; end?: WaveTimePoint | null; });

  readonly end: WaveTimePoint | null;

  readonly kind: WaveTimeRuleKind;

  readonly mode: WaveTimeRuleMode | null;

  readonly point: WaveTimePoint | null;

  readonly start: WaveTimePoint | null;

  readonly unit: WaveTimeUnitKind | null;

  readonly value: number | null;

}

type WaveTimeRuleKind = "always" | "never" | "once" | "every" | "forNext" | "on" | "after" | "before" | "through" | "between";

type WaveTimeRuleMode = "relative" | "absolute";

interface WaveTimeSpanSpec {

  readonly unit: WaveTimeUnitKind;

  readonly value: number;

}

interface WaveTimeUnit {

  (value: number): WaveTimePoint;

  readonly kind: WaveTimeUnitKind;

}

type WaveTimeUnitKind = "tick" | "second";

interface WaveTimeUnitReference {

  readonly kind: WaveTimeUnitKind;

}

interface WaveTimeValueDriveOptions {

  apply: (value: number) => void;

  callbacks?: TransitionLifecycleCallbacks<ValueDriveState> | undefined;

  clone?: WaveCallbackClonePolicy | undefined;

  curve: WaveValueCurveInput;

  name?: string | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  startPaused?: boolean | undefined;

  duration: WaveTimeSpan | number;

  loopMode?: WaveLoopMode;

  source?: never;

  speed?: number;

  startDelay?: WaveTimeSpan | number;

  unit?: WaveTimeUnit;

}

interface WaveTimeValueExpr {

  readonly type: "time";

  readonly unit?: "seconds" | "ms";

}

interface WaveTorusKnotPrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "torusKnot";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly p?: number;

  readonly q?: number;

  readonly radialSegments?: number;

  readonly radius: number;

  readonly tubeRadius: number;

  readonly tubularSegments?: number;

}

interface WaveTorusPrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "torus";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly arcFraction?: number;

  readonly radialSegments?: number;

  readonly radius: number;

  readonly tubeRadius: number;

}

interface WaveTransform2DAnimationRegistration {

  readonly animationId: number;

  readonly lifecycle: TransitionLifecycleHandle<WaveTransform2DProgressState>;

}

type WaveTransform2DAnimationState = WaveTransform2DProgressState;

declare enum WaveTransform2DChannelMask {

  All = 15,

  None = 0,

  Pivot = 8,

  Rotation = 2,

  Scale = 4,

  Translation = 1,

}

type WaveTransform2DChannelMotion = { readonly kind: "finite"; } | (WaveTransform2DContinuousMotionBase & { readonly operation: "translation"; readonly direction: Readonly<SerializableVector2>; readonly frame: WaveTransformFrameSpace; readonly frameEntityId: string | null; readonly parentFrameDepth: number; readonly rateUnitsPerSecond: number; }) | (WaveTransform2DContinuousMotionBase & { readonly operation: "rotation"; readonly rateDegreesPerSecond: number; }) | (WaveTransform2DContinuousMotionBase & { readonly operation: "turnTo"; readonly target: WaveTransform2DContinuousTurnTarget; readonly rateDegreesPerSecond: number; readonly toleranceDegrees: number; }) | (WaveTransform2DContinuousMotionBase & { readonly operation: "scale"; readonly mode: "uniform"; readonly factorPerSecond: number; }) | (WaveTransform2DContinuousMotionBase & { readonly operation: "scale"; readonly direction: Readonly<SerializableVector2>; readonly frame: WaveTransformFrameSpace; readonly frameEntityId: string | null; readonly parentFrameDepth: number; readonly mode: "along" | "toward"; readonly factorPerSecond: number; readonly localBounds: { readonly centerLocal: Readonly<SerializableVector2>; readonly halfExtentsLocal: Readonly<SerializableVector2>; }; });

interface WaveTransform2DChannelSnapshot {

  readonly channels: WaveTransform2DChannelMask;

  readonly easingId: string;

  readonly from: WaveTransform2DPoseSnapshot;

  readonly motion: WaveTransform2DChannelMotion;

  readonly playhead: number;

  readonly progressCurve?: WaveValueCurveSpec;

  readonly rotationInterpolation: "shortest" | "signed";

  readonly timing: WaveSerializableTransitionTiming;

  readonly to: WaveTransform2DPoseSnapshot;

  readonly viewId: string | null;

}

interface WaveTransform2DContinuousMotionBase {

  readonly durationSeconds: number | null;

  readonly elapsedSeconds: number;

  readonly kind: "continuous";

}

type WaveTransform2DContinuousTurnTarget = { readonly kind: "entity"; readonly entityId: string; } | { readonly kind: "entityDirection"; readonly entityId: string; } | { readonly kind: "rootPoint"; readonly point: Readonly<SerializableVector2>; } | { readonly kind: "screenPoint"; readonly point: WaveScreenPointRef; } | ({ readonly kind: "framedDirection"; readonly direction: Readonly<SerializableVector2>; } & WaveTransform2DFrameSelection);

declare enum WaveTransform2DDirtyMask {

  All = 511,

  Hierarchy = 32,

  Layer = 128,

  Layout = 64,

  None = 0,

  Pivot = 16,

  Placement = 1,

  Position = 2,

  Presentation = 256,

  Rotation = 4,

  Scale = 8,

}

interface WaveTransform2DEntityTarget {

  readonly runtimeRef: string;

}

type WaveTransform2DFitAxis = "auto" | WaveDirection2DInput;

interface WaveTransform2DFitIntent {

  readonly authoredViewId: string | null;

  end: WaveTransform2DFitTarget;

  readonly kind: "fitBetween";

  readonly options: WaveTransform2DFitOptions;

  start: WaveTransform2DFitTarget;

  viewId: string | null;

}

type WaveTransform2DFitOptions = WaveTransformFitBetweenBuilderOptions<WaveTransform2DFitAxis>;

type WaveTransform2DFitTarget = WaveTransform2DMoveTarget;

type WaveTransform2DFrame = WaveTransformFrameSpace;

interface WaveTransform2DFramedDirectionTurnTarget {

  readonly direction: Readonly<SerializableVector2>;

  readonly frame: WaveTransform2DFrame;

  readonly frameEntityId: string | null;

  readonly parentFrameDepth: number;

}

type WaveTransform2DFramedIntent = WaveTransform2DScopedIntent & WaveTransform2DFrameSelection;

interface WaveTransform2DFrameScope {

  alignDirectionWith(target: WaveTransform2DEntityTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  alignDirectionWith(target: WaveTransform2DEntityTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  alignDirectionWith(target: WaveTransform2DEntityTarget, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  alignDirectionWith(target: WaveTransform2DEntityTarget): cmp_transform2D;

  done(): cmp_transform2D;

  keepMoving(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepScalingAlong(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepScalingToward(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepTurningLeft(degreesPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepTurningRight(degreesPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  moveBy(delta: Vector2Like_3, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveBy(delta: Vector2Like_3, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveBy(delta: Vector2Like_3): cmp_transform2D;

  moveBy(direction: WaveDirection2DInput, distance: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveBy(direction: WaveDirection2DInput, distance: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveBy(direction: WaveDirection2DInput, distance: number): cmp_transform2D;

  moveX(distance: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveX(distance: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveX(distance: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  moveX(distance: number): cmp_transform2D;

  moveY(distance: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveY(distance: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveY(distance: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  moveY(distance: number): cmp_transform2D;

  root: cmp_transform2D;

  rotateBy(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  rotateBy(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  rotateBy(degrees: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  rotateBy(degrees: number): cmp_transform2D;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number): cmp_transform2D;

  scaleAlongTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleAlongTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleAlongTo(direction: WaveDirection2DInput, value: number): cmp_transform2D;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number): cmp_transform2D;

  scaleTowardTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTowardTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTowardTo(direction: WaveDirection2DInput, value: number): cmp_transform2D;

  turnLeft(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnLeft(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnLeft(degrees: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  turnLeft(degrees: number): cmp_transform2D;

  turnRight(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnRight(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnRight(degrees: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  turnRight(degrees: number): cmp_transform2D;

  turnTo(target: WaveTransform2DTurnTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnTo(target: WaveTransform2DTurnTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnTo(target: WaveTransform2DTurnTarget, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  turnTo(target: WaveTransform2DTurnTarget): cmp_transform2D;

  turnToward(direction: WaveDirection2DInput, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnToward(direction: WaveDirection2DInput, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnToward(direction: WaveDirection2DInput, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  turnToward(direction: WaveDirection2DInput): cmp_transform2D;

  inView(cameraId: string): WaveTransform2DFrameScope;

}

interface WaveTransform2DFrameSelection {

  readonly frame: WaveTransformFrameSpace;

  readonly frameEntityId: string | null;

  readonly parentFrameDepth: number;

}

interface WaveTransform2DFrameSnapshot {

  readonly kind: "2dFrame";

  readonly pivot: Readonly<SerializableVector2>;

  readonly position: Readonly<SerializableVector2>;

  readonly rotationDegrees: number;

  readonly scale: Readonly<SerializableVector2>;

}

interface WaveTransform2DFrameSnapshotPatch {

  readonly position?: Readonly<SerializableVector2>;

  readonly rotationDegrees?: number;

  readonly scale?: Readonly<SerializableVector2>;

}

interface WaveTransform2DHistorySample {

  readonly authored: WaveTransform2DPoseSnapshot;

  readonly local: WaveTransform2DFrameSnapshot;

  readonly parent: WaveTransform2DFrameSnapshot | null;

  readonly recordedAtSeconds: number;

  readonly root: WaveTransform2DFrameSnapshot | null;

  readonly tickNumber: number;

  readonly viewId: string | null;

}

type WaveTransform2DHistoryTerms = "world" | "parent" | "local";

type WaveTransform2DIntent = ({ readonly kind: "moveTo"; readonly target: WaveTransform2DMoveTarget; readonly terms: WaveTransform2DTerms; } & WaveTransform2DScopedIntent) | ({ readonly kind: "moveBy"; readonly delta: Vector2Like; } & WaveTransform2DFramedIntent) | ({ readonly kind: "moveByDirection"; readonly direction: WaveDirection2DInput; readonly distance?: number; } & WaveTransform2DFramedIntent) | ({ readonly kind: "rotateTo"; readonly degrees: number; readonly terms: WaveTransform2DTerms; } & WaveTransform2DScopedIntent) | ({ readonly kind: "rotateBy"; readonly degrees: number; } & WaveTransform2DScopedIntent) | ({ readonly kind: "turnTo"; readonly target: WaveTransform2DResolvedTurnTarget; withTolerance?: number; } & WaveTransform2DFramedIntent) | ({ readonly kind: "alignDirectionWith"; readonly target: WaveTransform2DEntityTarget; withTolerance?: number; } & WaveTransform2DScopedIntent) | ({ readonly kind: "continuousRotation"; readonly directionSign: 1 | -1; } & WaveTransform2DScopedIntent) | ({ readonly kind: "scaleTo"; readonly value: number | Vector2Like; readonly terms: WaveTransform2DTerms; } & WaveTransform2DScopedIntent) | ({ readonly kind: "scaleBy"; readonly value?: number | Vector2Like; readonly terms: WaveTransform2DTerms; } & WaveTransform2DScopedIntent) | ({ readonly kind: "scaleAlong" | "scaleToward"; readonly direction: WaveDirection2DInput; readonly factor?: number; readonly target?: number; } & WaveTransform2DFramedIntent) | ({ readonly kind: "pivot"; readonly value: Vector2Like; } & WaveTransform2DScopedIntent) | ({ readonly kind: "applyFrameSnapshot"; readonly snapshot: WaveTransform2DFrameSnapshotPatch; readonly terms: Exclude<WaveTransform2DTerms, "local">; } & WaveTransform2DScopedIntent) | WaveTransform2DFitIntent | ({ readonly kind: "transitionTo"; readonly pose: WaveTransform2DPoseSnapshot; } & WaveTransform2DScopedIntent);

type WaveTransform2DMotionReadiness = "warming_up" | "ready";

type WaveTransform2DMoveTarget = Vector2Like | WaveScreenPointRef | WaveTransform2DEntityTarget | WaveLocator2DRef;

interface WaveTransform2DPose {

  readonly kind: "2d";

  parentEntityId: string | null;

  readonly pivot: SerializableVector2;

  placement: Wave2DPlacementBasis;

  readonly position: SerializableVector2;

  rotationDegrees: number;

  readonly scale: SerializableVector2;

}

interface WaveTransform2DPoseSnapshot {

  readonly kind: "2d";

  readonly parentEntityId: string | null;

  readonly pivot: Readonly<SerializableVector2>;

  readonly placement: Wave2DPlacementBasis;

  readonly position: Readonly<SerializableVector2>;

  readonly rotationDegrees: number;

  readonly scale: Readonly<SerializableVector2>;

}

interface WaveTransform2DPresentationChannel {

  readonly channels: WaveTransform2DChannelMask;

  readonly easingId: string;

  readonly from: WaveTransform2DPoseSnapshot;

  readonly motion: WaveTransform2DChannelMotion;

  readonly playhead: number;

  readonly presentationProgress: number;

  readonly progressCurve?: WaveValueCurveSpec;

  readonly rotationInterpolation: "shortest" | "signed";

  readonly to: WaveTransform2DPoseSnapshot;

  readonly viewId: string | null;

}

interface WaveTransform2DProgressState {

  progress: number;

}

interface WaveTransform2DResolutionProvider {

  addAfterSynchronizeListener(listener: () => void): () => void;

  canPairAnimationPlacements(entityId: string, from: Wave2DPlacementBasis, to: Wave2DPlacementBasis, viewId: string | null): boolean;

  flushAfterSynchronizeListeners(): void;

  isKnownView(viewId: string): boolean;

  isResolutionCurrent(entityId: string): boolean;

  logicalToCssScale(entityId: string): number;

  markTransformDirty(entityId: string, mask: WaveTransform2DDirtyMask): void;

  rebindEntityRuntimeRef(previousEntityId: string, nextEntityId: string): void;

  resolvedRootMatrixCount(entityId: string): number;

  stackingKey(entityId: string): WaveTransform2DStackingKey | null;

  tryConvertParentPointToLocalPosition(entityId: string, viewId: string | null, parentPoint: Readonly<SerializableVector2>, out: SerializableVector2): boolean;

  tryConvertRootDeltaToLocalDelta(entityId: string, viewId: string | null, rootDelta: Readonly<SerializableVector2>, out: SerializableVector2): boolean;

  tryConvertRootPointToLocalPosition(entityId: string, rootPoint: Readonly<SerializableVector2>, out: SerializableVector2): boolean;

  tryConvertRootPointToLocalPositionInView(entityId: string, viewId: string, rootPoint: Readonly<SerializableVector2>, out: SerializableVector2): boolean;

  tryMaterializePresentationPose(entityId: string, nextParentEntityId: string | null, nextRootPlacement: Wave2DPlacementBasis | null, viewId: string, out: WaveMutableTransform2DMaterializedPose): boolean;

  tryResolveBodyGeometry(entityId: string, viewId: string | null, out: WaveResolved2DBodyGeometry): boolean;

  tryResolveParentTransformPosition(entityId: string, viewId: string | null, out: SerializableVector2): boolean;

  tryResolveRootMatrix(entityId: string, out: WaveAffine2D): boolean;

  tryResolveRootMatrixAt(entityId: string, index: number, out: WaveAffine2D): string | null;

  tryResolveRootMatrixForView(entityId: string, viewId: string, out: WaveAffine2D): boolean;

  tryResolveRootPivotPoint(entityId: string, viewId: string | null, out: SerializableVector2): boolean;

  tryResolveRootTransformPosition(entityId: string, viewId: string | null, out: SerializableVector2): boolean;

}

type WaveTransform2DResolvedTurnTarget = WaveTransform2DTurnTarget | WaveTransform2DFramedDirectionTurnTarget;

type WaveTransform2DScopedIntent = { readonly viewId: string | null; }

interface WaveTransform2DSnapshotMetadata {

  readonly domain: "2d";

  readonly id: string;

  readonly kind: "transform2D";

  readonly name: string;

  readonly pose: WaveTransform2DPoseSnapshot;

  readonly source: { readonly format: "wave"; }

}

interface WaveTransform2DStackingKey {

  readonly depth: number;

  readonly entityId: string;

  readonly layer: number;

  readonly parent: WaveTransform2DStackingKey | null;

  readonly stableOrder: number;

}

interface WaveTransform2DStateSnapshot {

  readonly activeChannels: readonly WaveTransform2DChannelSnapshot[];

  readonly layer: WaveVisual2DLayerState;

  readonly layout: WaveUILayoutState;

  readonly pose: WaveTransform2DPoseSnapshot;

}

type WaveTransform2DTerms = WaveTransformTermsSpace;

type WaveTransform2DTurnTarget = Vector2Like | WaveScreenPointRef | WaveTransform2DEntityTarget;

type WaveTransform2DVerbResult = cmp_transform2D | WaveTransform2DSnapshotBuilder | WaveTransform2DAnimationBuilder;

interface WaveTransform2DViewScope extends WaveTransform2DTermsScope {

  alignDirectionWith(target: WaveTransform2DEntityTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  alignDirectionWith(target: WaveTransform2DEntityTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  alignDirectionWith(target: WaveTransform2DEntityTarget, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  alignDirectionWith(target: WaveTransform2DEntityTarget): cmp_transform2D;

  applyParentSnapshot(snapshot: WaveTransform2DFrameSnapshotPatch): cmp_transform2D;

  applyWorldSnapshot(snapshot: WaveTransform2DFrameSnapshotPatch): cmp_transform2D;

  authoredPoseSnapshot(): WaveTransform2DPoseSnapshot;

  distanceTo(target: WaveTransform2DTurnTarget): number;

  fitBetween(start: WaveTransform2DFitTarget, end: WaveTransform2DFitTarget, mode: TransformVerbMode.Animate): WaveTransform2DFitBetweenAnimationBuilder;

  fitBetween(start: WaveTransform2DFitTarget, end: WaveTransform2DFitTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DFitBetweenBuilder;

  fitBetween(start: WaveTransform2DFitTarget, end: WaveTransform2DFitTarget, options: WaveTransform2DFitOptions): cmp_transform2D;

  fitBetween(start: WaveTransform2DFitTarget, end: WaveTransform2DFitTarget): cmp_transform2D;

  isFacing(target: WaveTransform2DTurnTarget, options?: WaveOrient2DOptions): boolean;

  keepScalingAlong(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepScalingToward(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepTurningLeft(degreesPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepTurningRight(degreesPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  parentSnapshot(): WaveTransform2DFrameSnapshot;

  parentSnapshot(when: WaveTimeLookback): WaveTransform2DFrameSnapshot | null;

  pivotAt(value: Vector2Like_3, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  pivotAt(value: Vector2Like_3, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  pivotAt(value: Vector2Like_3, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  pivotAt(value: Vector2Like_3): cmp_transform2D;

  resetPivot(): cmp_transform2D;

  rotateBy(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  rotateBy(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  rotateBy(degrees: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  rotateBy(degrees: number): cmp_transform2D;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number): cmp_transform2D;

  scaleAlongTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleAlongTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleAlongTo(direction: WaveDirection2DInput, value: number): cmp_transform2D;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number): cmp_transform2D;

  scaleTowardTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTowardTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTowardTo(direction: WaveDirection2DInput, value: number): cmp_transform2D;

  transition(): WaveTransform2DPoseTransitionBuilder;

  transitionTo(pose: WaveTransform2DPoseSnapshot): WaveTransform2DPoseTransitionBuilder;

  turnLeft(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnLeft(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnLeft(degrees: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  turnLeft(degrees: number): cmp_transform2D;

  turnRight(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnRight(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnRight(degrees: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  turnRight(degrees: number): cmp_transform2D;

  turnTo(target: WaveTransform2DTurnTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnTo(target: WaveTransform2DTurnTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnTo(target: WaveTransform2DTurnTarget, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  turnTo(target: WaveTransform2DTurnTarget): cmp_transform2D;

  turnToward(direction: WaveDirection2DInput, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnToward(direction: WaveDirection2DInput, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnToward(direction: WaveDirection2DInput, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  turnToward(direction: WaveDirection2DInput): cmp_transform2D;

  vectorFrom(source: WaveTransform2DTurnTarget): Vector2;

  vectorTo(target: WaveTransform2DTurnTarget): Vector2;

  worldSnapshot(): WaveTransform2DFrameSnapshot;

  worldSnapshot(when: WaveTimeLookback): WaveTransform2DFrameSnapshot | null;

  inFrameOf(target: WaveTransform2DEntityTarget): WaveTransform2DFrameScope;

  inLocalFrame(): WaveTransform2DFrameScope;

  inLocalTerms(): WaveTransform2DTermsScope;

  inParentFrame(depth?: number): WaveTransform2DFrameScope;

  inParentTerms(): WaveTransform2DTermsScope;

  inView(cameraId: string): WaveTransform2DViewScope;

  inWorldFrame(): WaveTransform2DFrameScope;

  inWorldTerms(): WaveTransform2DTermsScope;

}

type WaveTransformAccessor = TransformDirectionAccessor;

type WaveTransformChangedCallback<TTarget = WaveObject> = (target: TTarget, event: WaveTransformChangedEvent) => void;

interface WaveTransformChangedEvent {

  readonly positionChanged: boolean;

  readonly rotationChanged: boolean;

  readonly scaleChanged: boolean;

}

interface WaveTransformDomainExecutor<TRoot, TIntent, TAuthoredSnapshot, TResolvedPose> {

  apply(root: TRoot, intent: TIntent): TRoot;

  plan(root: TRoot, intent: TIntent): { readonly from: TAuthoredSnapshot; readonly to: TAuthoredSnapshot; readonly resolvedPose?: TResolvedPose; }

  snapshot(root: TRoot, intent: TIntent): TAuthoredSnapshot;

}

declare class WaveTransformFitBetweenAnimationBuilder {

  after(duration: WaveTimeSpan): WaveTransformFitBetweenAnimationBuilder;

  after(value: number, unit: WaveTimeUnit): WaveTransformFitBetweenAnimationBuilder;

  along(axis: FitBetweenAxis): WaveTransformFitBetweenAnimationBuilder;

  atRateOf(rate: WaveRate): WaveTransformFitBetweenAnimationBuilder;

  atRateOf(value: number, unit: WaveRateUnit): WaveTransformFitBetweenAnimationBuilder;

  between(start: any, end: any): WaveTransformFitBetweenAnimationBuilder;

  centered(): WaveTransformFitBetweenAnimationBuilder;

  from(start: any): WaveTransformFitBetweenAnimationBuilder;

  fromEnd(): WaveTransformFitBetweenAnimationBuilder;

  fromStart(): WaveTransformFitBetweenAnimationBuilder;

  over(duration: WaveTimeSpan): WaveTransformFitBetweenAnimationBuilder;

  over(value: number, unit: WaveTimeUnit): WaveTransformFitBetweenAnimationBuilder;

  to(end: any): WaveTransformFitBetweenAnimationBuilder;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): WaveTransformFitBetweenAnimationBuilder;

  withCallbacks(callbacks: TransitionLifecycleCallbacks<Record<string, number>>, options?: WaveAuthoredCallbackOptions): WaveTransformFitBetweenAnimationBuilder;

  withEasingEffect(ease: WaveEasing): WaveTransformFitBetweenAnimationBuilder;

  withOptions(options: FitBetweenOptions): WaveTransformFitBetweenAnimationBuilder;

  withoutScaling(): WaveTransformFitBetweenAnimationBuilder;

  withProgressCurve(curve: WaveValueCurveInput): WaveTransformFitBetweenAnimationBuilder;

  withScaling(enable?: boolean): WaveTransformFitBetweenAnimationBuilder;

  constructor(_executor: WaveTransformVerbExecutor<cmp_transform>, intent: FitBetweenIntent);

  play(): TransitionLifecycleHandle<Record<string, number>>;

}

declare class WaveTransformFitBetweenBuilder<TTransform extends cmp_transform = cmp_transform> {

  along(axis: FitBetweenAxis): WaveTransformFitBetweenBuilder<TTransform>;

  between(start: any, end: any): WaveTransformFitBetweenBuilder<TTransform>;

  centered(): WaveTransformFitBetweenBuilder<TTransform>;

  from(start: any): WaveTransformFitBetweenBuilder<TTransform>;

  fromEnd(): WaveTransformFitBetweenBuilder<TTransform>;

  fromStart(): WaveTransformFitBetweenBuilder<TTransform>;

  to(end: any): WaveTransformFitBetweenBuilder<TTransform>;

  withOptions(options: FitBetweenOptions): WaveTransformFitBetweenBuilder<TTransform>;

  withoutScaling(): WaveTransformFitBetweenBuilder<TTransform>;

  withScaling(enable?: boolean): WaveTransformFitBetweenBuilder<TTransform>;

  constructor(_executor: WaveTransformVerbExecutor<TTransform>, intent: FitBetweenIntent);

  take(): ResolvedWorldTransformSnapshot;

  take(id: string): WaveModelTransformSnapshotMetadata;

}

interface WaveTransformFitBetweenBuilderOptions<TAxis> {

  autoResize?: boolean;

  axis?: TAxis;

  placement?: FitBetweenPlacement;

}

type WaveTransformFitPlacement = "center" | "start" | "end";

declare class WaveTransformFrameScope<TTransform extends cmp_transform = cmp_transform> {

  inFrameOf(target: TransformReferenceLike): WaveTransformFrameScope<TTransform>;

  inLocalFrame(): WaveTransformFrameScope<TTransform>;

  inParentFrame(depth?: number): WaveTransformFrameScope<TTransform>;

  inWorldFrame(): WaveTransformFrameScope<TTransform>;

  constructor(_transform: TTransform, _executor: WaveTransformVerbExecutor<TTransform>, frame: WaveTransformFrameSpace, frameOf?: TransformReferenceLike, parentFrameDepth?: number);

  anchor(): WaveAnchorBuilder<TTransform>;

  done(): TTransform;

  isFacing(target: TransformReferenceLike | WavePointInput, options?: WaveOrientOptions): boolean;

  keepMoving(direction: DirectionInput): WaveTransformAnimationBuilder;

  keepRotatingAround(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingAlong(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingToward(axis: DirectionInput): WaveTransformAnimationBuilder;

  locator(): WaveLocatorBuilder<TTransform>;

  moveBy(direction: DirectionInput, distance: number): TTransform;

  moveBy(direction: DirectionInput, distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  moveBy(direction: DirectionInput, distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  moveX(distance: number): TTransform;

  moveX(distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  moveX(distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  moveY(distance: number): TTransform;

  moveY(distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  moveY(distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  moveZ(distance: number): TTransform;

  moveZ(distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  moveZ(distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  pitchDown(degrees: number): TTransform;

  pitchDown(degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  pitchDown(degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  pitchUp(degrees: number): TTransform;

  pitchUp(degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  pitchUp(degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  rollLeft(degrees: number): TTransform;

  rollLeft(degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  rollLeft(degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  rollRight(degrees: number): TTransform;

  rollRight(degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  rollRight(degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  get root(): TTransform;

  rotateAroundBy(axis: DirectionInput, degrees: number): TTransform;

  rotateAroundBy(axis: DirectionInput, degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  rotateAroundBy(axis: DirectionInput, degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  rotateAroundTo(axis: DirectionInput, degrees: number): TTransform;

  rotateAroundTo(axis: DirectionInput, degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  rotateAroundTo(axis: DirectionInput, degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  rotateBy(axis: DirectionInput, degrees: number): TTransform;

  rotateBy(axis: DirectionInput, degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  rotateBy(axis: DirectionInput, degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  rotateByQuaternion(delta: Quaternion): TTransform;

  rotateByQuaternion(delta: Quaternion, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  rotateByQuaternion(delta: Quaternion, mode: typeof Animate): WaveTransformAnimationBuilder;

  scaleAlongBy(axis: DirectionInput, factor: number): TTransform;

  scaleAlongBy(axis: DirectionInput, factor: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  scaleAlongBy(axis: DirectionInput, factor: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  scaleAlongTo(axis: DirectionInput, value: number): TTransform;

  scaleAlongTo(axis: DirectionInput, value: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  scaleAlongTo(axis: DirectionInput, value: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  scaleTowardBy(axis: DirectionInput, factor: number): TTransform;

  scaleTowardBy(axis: DirectionInput, factor: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  scaleTowardBy(axis: DirectionInput, factor: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  scaleTowardTo(axis: DirectionInput, value: number): TTransform;

  scaleTowardTo(axis: DirectionInput, value: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  scaleTowardTo(axis: DirectionInput, value: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  turnLeft(degrees: number): TTransform;

  turnLeft(degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  turnLeft(degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  turnRight(degrees: number): TTransform;

  turnRight(degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  turnRight(degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  turnTo(target: TransformReferenceLike | WavePointInput): TTransform;

  turnTo(target: TransformReferenceLike | WavePointInput, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  turnTo(target: TransformReferenceLike | WavePointInput, mode: typeof Animate): WaveTransformAnimationBuilder;

  turnToward(direction: DirectionInput): TTransform;

  turnToward(direction: DirectionInput, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  turnToward(direction: DirectionInput, mode: typeof Animate): WaveTransformAnimationBuilder;

}

type WaveTransformFrameSpace = "world" | "local" | "parent";

interface WaveTransformIntentAnimationExecutor {

  animateIntent(intent: TransformVerbIntent, config: TransformVerbAnimationConfig): TransitionLifecycleHandle<Record<string, number>>;

}

declare class WaveTransformPoseTransitionBuilder {

  after(duration: WaveTimeSpan): this;

  after(value: number, unit: WaveTimeUnit): this;

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): this;

  withCallbacks(callbacks: TransitionLifecycleCallbacks<Record<string, number>>, options?: WaveAuthoredCallbackOptions): this;

  withEasingEffect(ease: WaveEasing): this;

  withProgressCurve(curve: WaveValueCurveInput): this;

  constructor(_executor: WaveTransformVerbExecutor<cmp_transform>, target?: ResolvedWorldTransformSnapshot);

  from(snapshot: ResolvedWorldTransformSnapshot): this;

  play(): TransitionLifecycleHandle<Record<string, number>>;

  to(snapshot: ResolvedWorldTransformSnapshot): this;

}

declare class WaveTransformSnapshotBuilder<TTransform extends cmp_transform = cmp_transform> {

  constructor(_executor: WaveTransformVerbExecutor<TTransform>, _intent: TransformVerbIntent);

  animate(): WaveTransformAnimationBuilder;

  apply(): TTransform;

  byLocking(direction: DirectionInput): this;

  take(): ResolvedWorldTransformSnapshot;

  take(id: string): WaveModelTransformSnapshotMetadata;

  withTolerance(degrees: number): this;

}

interface WaveTransformSnapshotClipConfig {

  readonly duration: number;

  readonly keyframes: readonly WaveTransformSnapshotClipKeyframe[];

}

interface WaveTransformSnapshotClipHandle {

  addEvent(event: WaveEventInput, options: WaveTransformTimelineEventOptions): this;

  clearEvents(): this;

  readonly clipName: string;

  listEvents(): readonly WaveModelSnapshotClipEventMetadata[];

  readonly metadata: WaveModelSnapshotClipMetadata<"transform">;

  play(options?: WaveTransformTimelinePlayOptions): TransitionLifecycleHandle<Record<string, number>>;

  register(options?: WaveTransformTimelineRegisterOptions): this;

  removeEvent(event: WaveEventInput | string): this;

  readonly snapshots: readonly WaveModelTransformSnapshotMetadata[];

}

interface WaveTransformSnapshotClipKeyframe {

  readonly easing?: WaveModelSnapshotClipEasing;

  readonly time: number;

  readonly transform: WaveModelTransformSnapshotValue;

}

type WaveTransformStateSnapshot = TransformSnapshotLike;

declare class WaveTransformTermsScope<TTransform extends cmp_transform = cmp_transform> {

  constructor(_transform: TTransform, _executor: WaveTransformVerbExecutor<TTransform>, _terms: WaveTransformTermsSpace);

  angularRates(): Vector3;

  backward(): Vector3;

  backwardFaceCenter(): Vector3;

  bankAngle(): number;

  done(): TTransform;

  down(): Vector3;

  downFaceCenter(): Vector3;

  eulerAngles(): Vector3;

  forward(): Vector3;

  forwardFaceCenter(): Vector3;

  keepMoving(direction: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingBy(): WaveTransformAnimationBuilder;

  left(): Vector3;

  leftFaceCenter(): Vector3;

  moveBy(direction: DirectionInput, distance: number): TTransform;

  moveBy(direction: DirectionInput, distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  moveBy(direction: DirectionInput, distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  moveTo(target: TransformReferenceLike | WavePointInput): TTransform;

  moveTo(target: TransformReferenceLike | WavePointInput, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  moveTo(target: TransformReferenceLike | WavePointInput, mode: typeof Animate): WaveTransformAnimationBuilder;

  moveX(distance: number): TTransform;

  moveX(distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  moveX(distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  moveY(distance: number): TTransform;

  moveY(distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  moveY(distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  moveZ(distance: number): TTransform;

  moveZ(distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  moveZ(distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  pivot(): Vector3;

  position(): Vector3;

  right(): Vector3;

  rightFaceCenter(): Vector3;

  get root(): TTransform;

  rotateTo(rotation: Quaternion): TTransform;

  rotateTo(rotation: Quaternion, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  rotateTo(rotation: Quaternion, mode: typeof Animate): WaveTransformAnimationBuilder;

  rotation(): Quaternion;

  scale(): Vector3;

  scaleBy(value: number | Vector3Like): TTransform;

  scaleBy(value: number | Vector3Like, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  scaleBy(value: number | Vector3Like, mode: typeof Animate): WaveTransformAnimationBuilder;

  scaleTo(value: number | Vector3Like): TTransform;

  scaleTo(value: number | Vector3Like, mode: typeof Snapshot): WaveTransformSnapshotBuilder<TTransform>;

  scaleTo(value: number | Vector3Like, mode: typeof Animate): WaveTransformAnimationBuilder;

  speed(): number;

  speedAlong(axis: DirectionInput): number;

  up(): Vector3;

  upFaceCenter(): Vector3;

  velocity(): Vector3;

}

type WaveTransformTermsSpace = "world" | "local" | "parent";

interface WaveTransformTimelineEventOptions {

  readonly at: WaveAnimationTimeInput;

  readonly id?: string;

  readonly payload?: WaveModelSerializableValue;

  readonly unit?: WaveTimeUnit;

}

interface WaveTransformTimelineHost {

  readonly fixedDelta: number;

  readonly ownerName: string;

  playTransformTimeline(clip: WaveModelSnapshotClipMetadata<"transform">, snapshots: readonly WaveModelTransformSnapshotMetadata[], options?: WaveTransformTimelinePlayOptions): TransitionLifecycleHandle<Record<string, number>>;

  registerTransformTimeline(clip: WaveModelSnapshotClipMetadata<"transform">, snapshots: readonly WaveModelTransformSnapshotMetadata[], options?: WaveTransformTimelineRegisterOptions): WaveAnimationClip;

}

interface WaveTransformTimelinePlayOptions {

  readonly clone?: WaveAuthoredCallbackOptions["clone"];

  readonly reload?: WaveAuthoredCallbackOptions["reload"];

  readonly speed?: number;

}

interface WaveTransformTimelineRegisterOptions {

  readonly clipName?: string;

}

interface WaveTransformVerbExecutor<TTransform extends cmp_transform> {

  anchorOriginAt(position: Vector3Like): TTransform;

  anchorPivot(position: Vector3Like, space: WaveSpace): TTransform;

  anchorResetPivot(): TTransform;

  animateIntent(intent: TransformVerbIntent, config: TransformVerbAnimationConfig): TransitionLifecycleHandle<Record<string, number>>;

  animatePoseTransition(intent: TransformPoseTransitionIntent, config: TransformVerbAnimationConfig): TransitionLifecycleHandle<Record<string, number>>;

  applyIntent(intent: TransformVerbIntent): TTransform;

  moveByDirection(direction: DirectionInput, units: number, frame: WaveTransformFrameSpace, frameOf?: TransformReferenceLike, parentFrameDepth?: number): TTransform;

  snapshotIntent(intent: TransformVerbIntent): ResolvedWorldTransformSnapshot;

}

type WaveTriggerVolumeCallback<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject> = (event: WaveTriggerVolumeEvent<TEntity>) => void;

type WaveTriggerVolumeEntityQuery = (range: WaveRange, match: WaveRangeMatch, options: WaveRangeEntityMatchOptions, indexedNameOrTag?: string) => readonly WaveSpatial3DObject[];

interface WaveTriggerVolumeEvent<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject> {

  readonly deltaTime: number;

  readonly entity: TEntity;

  readonly kind: WaveTriggerVolumeEventKindValue;

  readonly occupants: readonly WaveSpatial3DObject[];

  readonly tickNumber: number;

  readonly timeInsideSeconds: number;

  readonly timeInsideTicks: number;

  readonly trigger: WaveTriggerVolume;

}

declare const WaveTriggerVolumeEventKind: { readonly Entered: "entered"; readonly Stayed: "stayed"; readonly Exited: "exited"; };

type WaveTriggerVolumeEventKindValue = (typeof WaveTriggerVolumeEventKind)[keyof typeof WaveTriggerVolumeEventKind];

interface WaveTriggerVolumeObservationOptions {

  borderEpsilon?: number | undefined;

  sample?: "center" | "bounds" | undefined;

  includeDisabled?: boolean;

  match?: WaveRangeMatch;

  name?: string;

}

declare const WaveTriggerVolumeOccupancyState: { readonly Inside: "inside"; readonly Outside: "outside"; };

type WaveTriggerVolumeOccupancyStateValue = (typeof WaveTriggerVolumeOccupancyState)[keyof typeof WaveTriggerVolumeOccupancyState];

type WaveTriggerVolumePredicate<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject> = (entity: TEntity) => boolean;

type WaveTriggerVolumeStateTarget<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject> = TEntity | readonly TEntity[];

type WaveTriggerVolumeTarget<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject> = string | TEntity | readonly TEntity[] | WaveTriggerVolumePredicate<TEntity>;

type WaveTTSBackendCommonOptions = WaveTTSBackendVoiceSlotOptions & { provider?: WaveStandardTTSProvider; fallbackProviders?: readonly WaveStandardTTSProvider[]; speechConcurrency?: WaveTTSSpeechConcurrency; speechFx?: WaveSpeechFxConfig | null; }

type WaveTTSBackendOptions = WaveTTSBackendCommonOptions & (WaveStandardTTSConfig | ElevenLabsTTSConfig | BrowserSpeechSynthesisTTSConfig);

type WaveTTSBackendProviderName = WaveStandardTTSBackendProviderName;

type WaveTTSBackendVoiceSlotOptions = Partial<Record<WaveTTSVoiceSlotName, WaveTTSVoiceSlotInput>>;

interface WaveTTSConfig {

  browserSpeechSynthesis?: BrowserSpeechSynthesisTTSConfig | null;

  elevenLabs?: ElevenLabsTTSConfig | null;

  fallbackProviders?: readonly WaveTTSProvider[];

  localNeural?: WaveLocalNeuralTTSConfig | null;

  provider?: WaveTTSProvider;

  speechConcurrency?: WaveTTSSpeechConcurrency;

  speechFx?: WaveSpeechFxConfig | null;

}

type WaveTTSProvider = "elevenLabs" | "browserSpeechSynthesis" | "localNeural";

type WaveTTSSpeechConcurrency = "restart" | "drop" | "queue";

interface WaveTTSVoiceSlotConfig {

  readonly label?: string;

  readonly slot: WaveTTSVoiceSlotName;

  readonly speechFx?: WaveSpeechFxConfig | null;

  readonly speed?: number;

  readonly voice: string;

}

type WaveTTSVoiceSlotInput = string | WaveTTSVoiceSlotOptions;

type WaveTTSVoiceSlotName = "voice1" | "voice2" | "voice3" | "voice4" | "voice5" | "voice6" | "voice7" | "voice8" | "voice9" | "voice10";

interface WaveTTSVoiceSlotOptions {

  label?: string;

  speechFx?: WaveSpeechFxConfig | null;

  speed?: number;

  voice: string;

}

type WaveTypedEventInput<TEventData = unknown> = WaveEventDefinition<TEventData> | WaveEventDefinitionMetadata<TEventData>;

type WaveUIAnchor = "top-left" | "top-center" | "top-right" | "center-left" | "center" | "center-right" | "bottom-left" | "bottom-center" | "bottom-right";

type WaveUIAtlasManifestAssetRef = string;

declare class WaveUICanvasButtonSkinRoleBuilder {

  apply(): WaveUISkinAsset;

  contentPadding(all: number): this;

  contentPadding(top: number, right: number, bottom: number, left: number): this;

  contentPadding(vertical: number, horizontal: number): this;

  done(): WaveUICanvasSkinBuilder;

  resolution(width: number, height: number): this;

  text(options: WaveUICanvasSkinTextOptions): this;

  disabled(draw: WaveUICanvasDrawCallback): this;

  hovered(draw: WaveUICanvasDrawCallback): this;

  normal(draw: WaveUICanvasDrawCallback): this;

  pressed(draw: WaveUICanvasDrawCallback): this;

}

declare class WaveUICanvasProgressSkinRoleBuilder {

  apply(): WaveUISkinAsset;

  done(): WaveUICanvasSkinBuilder;

  resolution(width: number, height: number): this;

  disabledFill(draw: WaveUICanvasDrawCallback): this;

  disabledTrack(draw: WaveUICanvasDrawCallback): this;

  fill(draw: WaveUICanvasDrawCallback): this;

  track(draw: WaveUICanvasDrawCallback): this;

}

declare class WaveUICanvasSkinBuilder {

  apply(): WaveUISkinAsset;

  button(roleId: string): WaveUICanvasButtonSkinRoleBuilder;

  progress(roleId: string): WaveUICanvasProgressSkinRoleBuilder;

  slider(roleId: string): WaveUICanvasSliderSkinRoleBuilder;

  textEntry(roleId: string): WaveUICanvasTextEntrySkinRoleBuilder;

  toggle(roleId: string): WaveUICanvasToggleSkinRoleBuilder;

}

declare class WaveUICanvasSliderSkinRoleBuilder {

  apply(): WaveUISkinAsset;

  done(): WaveUICanvasSkinBuilder;

  resolution(width: number, height: number): this;

  disabledFill(draw: WaveUICanvasDrawCallback): this;

  disabledThumb(draw: WaveUICanvasDrawCallback): this;

  disabledTrack(draw: WaveUICanvasDrawCallback): this;

  fill(draw: WaveUICanvasDrawCallback): this;

  hoveredThumb(draw: WaveUICanvasDrawCallback): this;

  pressedThumb(draw: WaveUICanvasDrawCallback): this;

  thumb(draw: WaveUICanvasDrawCallback): this;

  track(draw: WaveUICanvasDrawCallback): this;

}

declare class WaveUICanvasTextEntrySkinRoleBuilder {

  apply(): WaveUISkinAsset;

  contentPadding(all: number): this;

  contentPadding(top: number, right: number, bottom: number, left: number): this;

  contentPadding(vertical: number, horizontal: number): this;

  done(): WaveUICanvasSkinBuilder;

  resolution(width: number, height: number): this;

  text(options: WaveUICanvasSkinTextOptions): this;

  disabled(draw: WaveUICanvasDrawCallback): this;

  focused(draw: WaveUICanvasDrawCallback): this;

  normal(draw: WaveUICanvasDrawCallback): this;

}

declare class WaveUICanvasTextureBuilder {

  apply(): string;

  configure(options: WaveUICanvasTextureOptions): this;

}

declare class WaveUICanvasToggleSkinRoleBuilder {

  apply(): WaveUISkinAsset;

  done(): WaveUICanvasSkinBuilder;

  resolution(width: number, height: number): this;

  checked(draw: WaveUICanvasDrawCallback): this;

  checkedDisabled(draw: WaveUICanvasDrawCallback): this;

  checkedHovered(draw: WaveUICanvasDrawCallback): this;

  checkedPressed(draw: WaveUICanvasDrawCallback): this;

  unchecked(draw: WaveUICanvasDrawCallback): this;

  uncheckedDisabled(draw: WaveUICanvasDrawCallback): this;

  uncheckedHovered(draw: WaveUICanvasDrawCallback): this;

  uncheckedPressed(draw: WaveUICanvasDrawCallback): this;

}

type WaveUIColorInput = ColorInput | string;

declare class WaveUILayoutBuilder<TOwner extends Wave2DLayoutTarget> {

  above(target: Wave2DLayoutTarget): this;

  align(alignment: WaveUILayoutCrossAlignment): this;

  apply(): TOwner;

  atParentOrigin(): this;

  attachAt(anchor: WaveUIAnchor): this;

  below(target: Wave2DLayoutTarget): this;

  boundedContent(bounds: Omit<Extract<WaveUILayoutSize, { kind: "boundedIntrinsic"; }>, "kind">): this;

  clipChildren(enabled?: boolean): this;

  contentPadding(value: number | UILogicalInsets): this;

  fitContent(): this;

  gap(units: number): this;

  inAllViews(): this;

  inViews(...cameraIds: string[]): this;

  leftOf(target: Wave2DLayoutTarget): this;

  pointToward(target: WaveWorldProjectionTarget | WaveLocator3DRef): this;

  projectFrom(point: { readonly x: number; readonly y: number; readonly z: number; }): this;

  projectFrom(target: WaveWorldProjectionTarget | WaveLocator3DRef): this;

  rightOf(target: Wave2DLayoutTarget): this;

  size(width: number, height: number): this;

  useSkinContentPadding(): this;

  withLocalForward(direction: WaveDirection2DInput): this;

}

interface WaveUILayoutCommand {

  readonly layout?: WaveUILayoutPatch;

  readonly orientation?: WaveUIWorldOrientationBinding | null;

  readonly placement?: Wave2DPlacementChange;

}

type WaveUILayoutCrossAlignment = "start" | "center" | "end";

interface WaveUILayoutPatch {

  readonly attachAt?: WaveUIAnchor;

  readonly clipChildren?: boolean;

  readonly contentPaddingOverride?: UILogicalInsets | null;

  readonly size?: WaveUILayoutSize;

}

interface WaveUILayoutRelation {

  readonly align: WaveUILayoutCrossAlignment;

  readonly gap: number;

  readonly side: WaveUILayoutSide;

  readonly targetEntityId: string;

}

type WaveUILayoutSide = "above" | "below" | "leftOf" | "rightOf";

type WaveUILayoutSize = { readonly kind: "fixed"; readonly width: number; readonly height: number; } | { readonly kind: "intrinsic"; } | { readonly kind: "boundedIntrinsic"; readonly minWidth?: number; readonly minHeight?: number; readonly maxWidth?: number; readonly maxHeight?: number; }

interface WaveUILayoutState {

  readonly attachAt: WaveUIAnchor;

  readonly clipChildren: boolean;

  readonly contentPaddingOverride: UILogicalInsets | null;

  readonly orientation: WaveUIWorldOrientationBinding | null;

  readonly size: WaveUILayoutSize;

}

interface WaveUIPointerTrackingOptions {

  clone?: WaveCallbackClonePolicy | undefined;

  name?: string | undefined;

  once?: boolean | undefined;

  priority?: number | undefined;

  reload?: WaveCallbackReloadPolicy | undefined;

  offset?: { x: number; y: number; }

}

interface WaveUIProceduralAppearance {

  readonly borderColor?: WaveUIColorInput;

  readonly borderWidth?: number;

  readonly cornerRadius?: number;

  readonly fillColor?: WaveUIColorInput;

  readonly surfaceColor?: WaveUIColorInput;

}

declare class WaveUIPropertyAnimationBuilder {

  constructor(_playImpl: (config: WaveUIPropertyAnimationConfig) => TransitionLifecycleHandle<Record<string, number>>);

  after(duration: WaveTimeSpan): this;

  after(value: number, unit: WaveTimeUnit): this;

  atRateOf(rate: WaveRate): this;

  atRateOf(value: number, unit: WaveRateUnit): this;

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  play(): TransitionLifecycleHandle<Record<string, number>>;

  withCallbacks(callbacks: TransitionLifecycleCallbacks<Record<string, number>>): this;

  withEasingEffect(ease: WaveEasing): this;

  withProgressCurve(curve: WaveValueCurveInput): this;

}

interface WaveUIPropertyAnimationConfig {

  callbacks?: TransitionLifecycleCallbacks<Record<string, number>>;

  delay?: WaveTimeSpan;

  duration?: WaveTimeSpan;

  easingEffect?: WaveEasing;

  progressCurve?: WaveValueCurveInput;

  rate?: WaveRate;

}

declare class WaveUIPropertyPreview {

  constructor(_applyImpl: () => void, _animateImpl: () => WaveUIPropertyAnimationBuilder);

  animate(): WaveUIPropertyAnimationBuilder;

  apply(): void;

}

type WaveUISkinBinding = { readonly kind: typeof WAVE_UI_SKIN_ASSET_BINDING_KIND; readonly skinAssetId: string; readonly roleId: string; } | { readonly kind: typeof WAVE_UI_SKIN_SCOPE_BINDING_KIND; readonly scopeId: string; readonly roleId: string; }

interface WaveUISkinProjectAssetResolver {

  hasLoadedTexture(textureAssetRef: WaveUITextureAssetRef): boolean;

  resolveLoadedManifestJson(manifestAssetRef: WaveUIAtlasManifestAssetRef): unknown | null;

}

declare class WaveUISkinSceneOwner {

  constructor(_assetResolver?: WaveUISkinProjectAssetResolver | null, _onScopeCreated?: ((scope: WaveUISkinScope) => void) | null, _canPublishEqualRevisionReplacement?: (() => boolean) | null);

  captureScopeSnapshots(): readonly WaveUISkinScopeSnapshot[];

  createSkinScope(options: { readonly id: string; readonly skin: WaveUISkinAsset; readonly variants?: Readonly<Record<string, string>>; }): WaveUISkinScope;

  dispose(): void;

  hydrateScopeSnapshots(snapshots: readonly WaveUISkinScopeSnapshot[]): void;

  registerSkin(skin: WaveUISkinAsset): this;

  reset(): void;

  resolveBinding(binding: WaveUISkinBinding): WaveUISkinRoleHandle;

}

interface WaveUISkinScopeSnapshot {

  readonly id: string;

  readonly skinAssetId: string;

  readonly variants: Readonly<Record<string, string>>;

}

type WaveUITextureAssetRef = string;

interface WaveUIWorldOrientationBinding {

  readonly localForward: Readonly<SerializableVector2>;

  readonly missingSourcePolicy: "hideAndReport";

  readonly target: Extract<WaveWorldProjectionSource, { readonly kind: "entityLocator"; }>;

  readonly views: WaveWorldProjectionViews;

}

interface WaveUIWorldProjectionBinding {

  readonly clipPolicy: "hideOutsideClip";

  readonly missingSourcePolicy: "hideAndReport";

  readonly source: WaveWorldProjectionSource;

  readonly views: WaveWorldProjectionViews;

}

type WaveUniformPathSampleProvider = WavePathSampleProvider & { readonly closed: boolean; readonly pathRevision: number; uniformSamplesToRef(sampleCount: number, result: Vector3[], options?: WavePathQueryOptions, spare?: Vector3[]): Vector3[]; }

interface WaveUvRect {

  readonly u0: number;

  readonly u1: number;

  readonly v0: number;

  readonly v1: number;

}

type WaveValue = WaveValueByKind[WaveValueKind];

interface WaveValueByKind {

  readonly bool: boolean;

  readonly color: ColorInputAlpha;

  readonly number: number;

  readonly vec2: Vector2Like;

  readonly vec3: Vector3Like;

  readonly vec4: WaveVec4Like;

}

interface WaveValueCenteredFieldPosition2DOptions {

  readonly center: WaveVec2AuthoringInput;

  readonly uv: WaveVec2AuthoringInput;

  readonly worldSize: WaveNumberAuthoringInput;

}

type WaveValueCompareOp = ">" | "<" | ">=" | "<=" | "==" | "!=";

type WaveValueCurveBuiltInDomain = "normalized" | "normalizedAge" | "progress" | "pathProgress" | "distance01" | "impactIntensity" | "speed01" | "slope01" | "altitude01" | "uiProgress" | "audioIntensity" | "terrainFalloff";

interface WaveValueCurveBundle {

  curve(name: string): WaveValueCurve;

  readonly id: string | undefined;

  keys(): string[];

  toConfig(): WaveValueCurveBundleSpec;

  toSampleTable(options?: WaveValueCurveLoweringOptions): WaveValueCurveBundleSampleTable;

}

type WaveValueCurveBundleInput = Readonly<Record<string, WaveValueCurveInput>>;

interface WaveValueCurveBundleOptions {

  description?: string | undefined;

  eventHints?: readonly WaveValueCurveEventHint[] | undefined;

  label?: string | undefined;

  role?: string | undefined;

  tags?: readonly string[] | undefined;

  unit?: string | undefined;

  domain?: WaveValueCurveDomain;

  id?: string;

}

interface WaveValueCurveBundleSampleTable {

  bundle: WaveValueCurveBundleSpec;

  curves: Record<string, WaveValueCurveSampleTable>;

  format: "waveValueCurve.bundleSampleTable.v1";

  kind: "bundleSampleTable";

}

interface WaveValueCurveBundleSpec {

  readonly curves: Readonly<Record<string, WaveValueCurveSpec>>;

  readonly description?: string;

  readonly domain?: WaveValueCurveDomain;

  readonly eventHints?: readonly WaveValueCurveEventHint[];

  readonly id?: string;

  readonly kind: "valueCurveBundle";

  readonly label?: string;

  readonly role?: string;

  readonly tags?: readonly string[];

  readonly unit?: string;

}

interface WaveValueCurveCallbackOptions {

  interpolation?: WaveSampledValueCurveInterpolation;

  samples?: number;

}

type WaveValueCurveDomain = WaveValueCurveBuiltInDomain | (string & {});

type WaveValueCurveEvaluator = (input: number) => number;

interface WaveValueCurveEvaluatorLoweringOptions {

  description?: string | undefined;

  domain?: WaveValueCurveDomain | undefined;

  eventHints?: readonly WaveValueCurveEventHint[] | undefined;

  interpolation?: WaveSampledValueCurveInterpolation | undefined;

  label?: string | undefined;

  role?: string | undefined;

  sampleCount?: number | undefined;

  samples?: number | undefined;

  tags?: readonly string[] | undefined;

  target?: WaveValueCurvePortableTarget | undefined;

  unit?: string | undefined;

}

interface WaveValueCurveEvent {

  direction?: WaveValueCurveEventDirection;

  input: number;

  label?: string;

  source: WaveValueCurveEventSource;

  tags: string[];

  threshold?: number;

  type: WaveValueCurveEventType;

  value: number;

}

type WaveValueCurveEventDirection = "rising" | "falling" | "touching";

interface WaveValueCurveEventHint {

  readonly direction?: WaveValueCurveEventDirection;

  readonly input: number;

  readonly label?: string;

  readonly tags?: readonly string[];

  readonly threshold?: number;

  readonly type?: WaveValueCurveEventType;

  readonly value?: number;

}

interface WaveValueCurveEventOptions {

  description?: string | undefined;

  domain?: WaveValueCurveDomain | undefined;

  eventHints?: readonly WaveValueCurveEventHint[] | undefined;

  label?: string | undefined;

  role?: string | undefined;

  sampleCount?: number | undefined;

  tags?: readonly string[] | undefined;

  target?: WaveValueCurvePortableTarget | undefined;

  unit?: string | undefined;

  epsilon?: number;

  includeAuthored?: boolean;

  includeEndpoints?: boolean;

  includeKeyframes?: boolean;

  includePeaks?: boolean;

  includeValleys?: boolean;

  inputRange?: WaveValueCurveRangeSpec;

  prominence?: number;

  sampleInputs?: readonly number[];

  thresholds?: readonly number[];

}

type WaveValueCurveEventSource = "authored" | "keyframe" | "analysis";

interface WaveValueCurveEventTable {

  config: WaveValueCurveSpec;

  description?: string;

  domain?: WaveValueCurveDomain;

  events: WaveValueCurveEvent[];

  format: "waveValueCurve.events.v1";

  kind: "valueCurveEvents";

  label?: string;

  role?: string;

  sampleCount: number;

  tags: string[];

  unit?: string;

}

type WaveValueCurveEventType = "authored" | "keyframe" | "peak" | "valley" | "thresholdCrossing" | "sample";

type WaveValueCurveFalloffMode = "none" | "hard" | "linear" | "smooth" | "exponential" | "quadratic" | "inverseSquare";

type WaveValueCurveInput = number | WaveValueCurveSpec | WaveValueCurve;

type WaveValueCurveInterpolation = "stage" | "linear" | "easeIn" | "easeOut" | "smooth";

interface WaveValueCurveKeyframeOptions {

  base?: number;

}

interface WaveValueCurveLoweringOptions {

  description?: string | undefined;

  eventHints?: readonly WaveValueCurveEventHint[] | undefined;

  label?: string | undefined;

  role?: string | undefined;

  tags?: readonly string[] | undefined;

  unit?: string | undefined;

  domain?: WaveValueCurveDomain;

  sampleCount?: number;

  target?: WaveValueCurvePortableTarget;

}

type WaveValueCurveMapper = (value: number, input: number) => number;

type WaveValueCurvePortableTarget = "js" | "worker" | "gpuLut" | "audioAutomation" | "fxCurve" | "uiPlot";

interface WaveValueCurveRangeSpec {

  readonly max: number;

  readonly min: number;

}

interface WaveValueCurveSample {

  readonly input: number;

  readonly value: number;

}

interface WaveValueCurveSampleTable {

  config: WaveValueCurveSpec;

  description?: string;

  domain?: WaveValueCurveDomain;

  format: "waveValueCurve.sampleTable.v1";

  kind: "sampleTable";

  label?: string;

  maxValue: number;

  minValue: number;

  role?: string;

  sampleCount: number;

  samples: WaveValueCurveSample[];

  tags: string[];

  target: WaveValueCurvePortableTarget;

  unit?: string;

}

interface WaveValueCurveSemanticOptions {

  description?: string;

  eventHints?: readonly WaveValueCurveEventHint[];

  label?: string;

  role?: string;

  tags?: readonly string[];

  unit?: string;

}

type WaveValueCurveSpec = WaveConstantValueCurveSpec | WaveLinearValueCurveSpec | WavePowerValueCurveSpec | WaveFalloffValueCurveSpec | WaveKeyframedValueCurveSpec | WaveSmoothStepValueCurveSpec | WaveBumpValueCurveSpec | WaveSineValueCurveSpec | WaveClampValueCurveSpec | WaveCompositeValueCurveSpec | WaveSubtractValueCurveSpec | WaveSafeDivideValueCurveSpec | WaveSampledValueCurveSpec | WaveRangeMappedValueCurveSpec | WaveSemanticValueCurveSpec;

interface WaveValueCurveValueSetter<TNext> {

  value(value: number): TNext;

  Value(value: number): TNext;

}

type WaveValueDriveOptions = WaveTimeValueDriveOptions | WaveSourceValueDriveOptions;

type WaveValueExpr = WaveConstantValueExpr | WaveVariableValueExpr | WaveTimeValueExpr | WaveMathValueExpr | WaveRandomValueExpr | WaveCurveValueExpr | WaveNoiseValueExpr | WaveSpatialValueExpr | WaveTextureSampleValueExpr | WaveSwizzleValueExpr | WaveComposeValueExpr;

interface WaveValueFalloffOptions {

  readonly fullUntil: number;

  readonly mode?: WaveValueCurveFalloffMode;

  readonly zeroAt: number;

}

interface WaveValueFieldReprojection2DOptions {

  readonly currentCenter: WaveVec2AuthoringInput;

  readonly previousCenter: WaveVec2AuthoringInput;

  readonly uv: WaveVec2AuthoringInput;

  readonly worldSize: WaveNumberAuthoringInput;

}

interface WaveValueFollow2DOptions {

  readonly active?: WaveNumberAuthoringInput;

  readonly deltaSeconds: WaveNumberAuthoringInput;

  readonly previous: WaveVec2AuthoringInput;

  readonly recoveryRate: WaveNumberAuthoringInput;

  readonly responseRate: WaveNumberAuthoringInput;

  readonly target: WaveVec2AuthoringInput;

}

type WaveValueFromSourceOptions = WaveSourceValueDriveOptions;

type WaveValueKind = "number" | "bool" | "vec2" | "vec3" | "vec4" | "color";

type WaveValueMathOp = "add" | "sub" | "mul" | "div" | "clamp" | "lerp" | "min" | "max" | "abs" | "sqrt" | "pow" | "exp" | "negate" | "frac" | "sin" | "cos" | "round" | "step" | "smoothstep" | "remap";

interface WaveValueNoiseOptions {

  readonly amplitude?: WaveNumberAuthoringInput;

  readonly frequency?: WaveNumberAuthoringInput;

  readonly seed?: WaveNumberAuthoringInput;

}

interface WaveValueNormalizedFieldUv2DOptions {

  readonly center?: WaveVec2AuthoringInput;

  readonly position: WaveVec2AuthoringInput;

  readonly worldSize: WaveNumberAuthoringInput;

}

interface WaveValuePeakHoldOptions {

  readonly attackRate?: WaveNumberAuthoringInput;

  readonly deltaSeconds: WaveNumberAuthoringInput;

  readonly previous: WaveNumberAuthoringInput;

  readonly recoveryRate: WaveNumberAuthoringInput;

  readonly target: WaveNumberAuthoringInput;

}

interface WaveValuePositionFieldSample2DOptions {

  readonly center?: WaveVec2AuthoringInput | undefined;

  readonly position: WaveVec2AuthoringInput;

  readonly worldSize: WaveNumberAuthoringInput;

  readonly outOfBounds?: "clamp" | "zero";

  readonly textureId: string;

}

interface WaveValueProgram {

  readonly locals: readonly WaveValueProgramLocal[];

  readonly value: WaveValueExpr;

}

type WaveValueProgramBoundRecord<TValues extends WaveValueRefRecord> = { readonly [TName in keyof TValues]: WaveValueRefByKind<TValues[TName]["kind"]>; }

interface WaveValueProgramBuilder {

  readonly contact: { sweptCircle2D(name: string, options: WaveValueSweptCircleContact2DOptions): WaveValueSweptCircleContact2D; sweptCircleField2D(name: string, options: WaveValueSweptCircleField2DOptions): WaveValueSweptCircleField2D; }

  readonly field: { reprojectUv2D(name: string, options: WaveValueFieldReprojection2DOptions): WaveVec2Ref; centeredPosition2D(name: string, options: WaveValueCenteredFieldPosition2DOptions): WaveVec2Ref; normalizedUv2D(name: string, options: WaveValueNormalizedFieldUv2DOptions): WaveVec2Ref; sampleReprojected2D(name: string, options: WaveValueReprojectedFieldSample2DOptions): WaveVec4Ref; sampleAtPosition2D(name: string, options: WaveValuePositionFieldSample2DOptions): WaveVec4Ref; }

  readonly geometry: { sweptPoint2D(name: string, options: WaveValueSweptPoint2DOptions): WaveValueSweptPoint2D; }

  let<TKind extends WaveValueKind>(name: string, value: WaveValueRef<TKind>): WaveValueRefByKind<TKind>;

  readonly motion: { rollingSphereXZ(name: string, options: WaveValueRollingSphereXZOptions): WaveValueRollingSphereXZ; }

  output(value: WaveValueRef): WaveValueProgram;

  readonly response: { peakHold(name: string, options: WaveValuePeakHoldOptions): WaveNumberRef; follow2D(name: string, options: WaveValueFollow2DOptions): WaveVec2Ref; spring3D(name: string, options: WaveValueSpring3DOptions): WaveVec3Ref; }

  values<TValues extends WaveValueRefRecord>(values: TValues): WaveValueProgramBoundRecord<TValues>;

  readonly vector: { normalize2D(name: string, value: WaveVec2AuthoringInput, epsilon?: number): WaveVec2Ref; }

}

interface WaveValueProgramLocal {

  readonly name: string;

  readonly value: WaveValueExpr;

}

interface WaveValueProgramOptions {

  readonly maxLocals?: number;

}

interface WaveValueRandomOptions {

  readonly perSample?: boolean;

  readonly salt?: number;

  readonly seed?: WaveNumberAuthoringInput;

}

interface WaveValueRef<TKind extends WaveValueKind = WaveValueKind> {

  readonly kind: TKind;

  toExpr(): WaveValueExpr;

  toJSON(): WaveValueExpr;

}

type WaveValueRefByKind<TKind extends WaveValueKind> = TKind extends "number" ? WaveNumberRef : TKind extends "bool" ? WaveBoolRef : TKind extends "vec2" ? WaveVec2Ref : TKind extends "vec3" ? WaveVec3Ref : TKind extends "vec4" ? WaveVec4Ref : TKind extends "color" ? WaveColorRef : WaveValueRef<TKind>;

type WaveValueRefRecord = Readonly<Record<string, WaveValueRef>>;

interface WaveValueReprojectedFieldSample2DOptions {

  readonly currentCenter: WaveVec2AuthoringInput;

  readonly previousCenter: WaveVec2AuthoringInput;

  readonly uv: WaveVec2AuthoringInput;

  readonly worldSize: WaveNumberAuthoringInput;

  readonly outOfBounds?: "clamp" | "zero";

  readonly textureId: string;

}

interface WaveValueRollingSphereXZ {

  readonly direction: WaveVec2Ref;

  readonly slip: WaveVec2Ref;

  readonly slipDirection: WaveVec2Ref;

  readonly slipSpeed: WaveNumberRef;

  readonly speed: WaveNumberRef;

}

interface WaveValueRollingSphereXZOptions {

  readonly angularVelocity: WaveVec2AuthoringInput;

  readonly epsilon?: number;

  readonly linearVelocity: WaveVec2AuthoringInput;

  readonly radius: WaveNumberAuthoringInput;

}

interface WaveValueSpring3DOptions {

  readonly active?: WaveNumberAuthoringInput;

  readonly damping: WaveNumberAuthoringInput;

  readonly deltaSeconds: WaveNumberAuthoringInput;

  readonly epsilon?: number;

  readonly maximumDistance?: WaveNumberAuthoringInput;

  readonly previousPosition: WaveVec3AuthoringInput;

  readonly previousVelocity: WaveVec3AuthoringInput;

  readonly result: "position" | "velocity";

  readonly stiffness: WaveNumberAuthoringInput;

  readonly target: WaveVec3AuthoringInput;

}

interface WaveValueSurfaceProximityOptions {

  readonly availability?: WaveNumberAuthoringInput;

  readonly centerHeight: WaveNumberAuthoringInput;

  readonly fullUntil: WaveNumberAuthoringInput;

  readonly surfaceHeight: WaveNumberAuthoringInput;

  readonly zeroAt: WaveNumberAuthoringInput;

}

interface WaveValueSweptCircleContact2D {

  readonly direction: WaveVec2Ref;

  readonly distance: WaveNumberRef;

  readonly offset: WaveVec2Ref;

  readonly progress: WaveNumberRef;

  readonly start: WaveVec2Ref;

  readonly travel: WaveVec2Ref;

  readonly distance01: WaveNumberRef;

}

interface WaveValueSweptCircleContact2DOptions {

  readonly continuity?: WaveValueTravelContinuityOptions | undefined;

  readonly currentCenter: WaveVec2AuthoringInput;

  readonly directionEpsilon?: number | undefined;

  readonly point: WaveVec2AuthoringInput;

  readonly previousCenter: WaveVec2AuthoringInput;

  readonly travelLengthSquaredEpsilon?: number | undefined;

  readonly extentEpsilon?: number;

  readonly padding?: WaveNumberAuthoringInput;

  readonly radius: WaveNumberAuthoringInput;

}

interface WaveValueSweptCircleField2D {

  readonly direction: WaveVec2Ref;

  readonly distance: WaveNumberRef;

  readonly distance01: WaveNumberRef;

  readonly offset: WaveVec2Ref;

  readonly progress: WaveNumberRef;

  readonly start: WaveVec2Ref;

  readonly travel: WaveVec2Ref;

  readonly worldPosition: WaveVec2Ref;

}

interface WaveValueSweptCircleField2DOptions {

  readonly continuity?: WaveValueTravelContinuityOptions | undefined;

  readonly currentCenter: WaveVec2AuthoringInput;

  readonly directionEpsilon?: number | undefined;

  readonly extentEpsilon?: number | undefined;

  readonly padding?: WaveNumberAuthoringInput | undefined;

  readonly previousCenter: WaveVec2AuthoringInput;

  readonly radius: WaveNumberAuthoringInput;

  readonly travelLengthSquaredEpsilon?: number | undefined;

  readonly fieldCenter: WaveVec2AuthoringInput;

  readonly fieldSize: WaveNumberAuthoringInput;

  readonly uv: WaveVec2AuthoringInput;

}

interface WaveValueSweptPoint2D {

  readonly direction: WaveVec2Ref;

  readonly distance: WaveNumberRef;

  readonly offset: WaveVec2Ref;

  readonly progress: WaveNumberRef;

  readonly start: WaveVec2Ref;

  readonly travel: WaveVec2Ref;

}

interface WaveValueSweptPoint2DOptions {

  readonly continuity?: WaveValueTravelContinuityOptions;

  readonly currentCenter: WaveVec2AuthoringInput;

  readonly directionEpsilon?: number;

  readonly point: WaveVec2AuthoringInput;

  readonly previousCenter: WaveVec2AuthoringInput;

  readonly travelLengthSquaredEpsilon?: number;

}

type WaveValueSwizzleComponent = "x" | "y" | "z" | "w" | "r" | "g" | "b" | "a";

interface WaveValueTravelContinuityOptions {

  readonly curve: WaveValueCurveInput;

}

interface WaveVariableValueExpr {

  readonly kind?: WaveValueKind;

  readonly name: string;

  readonly type: "var";

}

type WaveVec2AuthoringInput = WaveValueExpr | WaveVec2Ref;

interface WaveVec2Ref {

  readonly kind: "vec2";

  toExpr(): WaveValueExpr;

  toJSON(): WaveValueExpr;

  add(value: WaveVec2AuthoringInput): WaveVec2Ref;

  decay(deltaSeconds: WaveNumberAuthoringInput, rate: WaveNumberAuthoringInput): WaveVec2Ref;

  distanceTo(value: WaveVec2AuthoringInput): WaveNumberRef;

  div(value: WaveNumberAuthoringInput): WaveVec2Ref;

  dot(value: WaveVec2AuthoringInput): WaveNumberRef;

  leftNormal(): WaveVec2Ref;

  length(): WaveNumberRef;

  lengthSquared(): WaveNumberRef;

  lerp(to: WaveVec2AuthoringInput, amount: WaveNumberAuthoringInput): WaveVec2Ref;

  normalize(epsilon?: number): WaveVec2Ref;

  scale(value: WaveNumberAuthoringInput): WaveVec2Ref;

  sub(value: WaveVec2AuthoringInput): WaveVec2Ref;

  readonly x: WaveNumberRef;

  readonly y: WaveNumberRef;

}

type WaveVec3AuthoringInput = WaveValueExpr | WaveVec3Ref;

interface WaveVec3Ref {

  readonly kind: "vec3";

  toExpr(): WaveValueExpr;

  toJSON(): WaveValueExpr;

  add(value: WaveVec3AuthoringInput): WaveVec3Ref;

  div(value: WaveNumberAuthoringInput): WaveVec3Ref;

  dot(value: WaveVec3AuthoringInput): WaveNumberRef;

  length(): WaveNumberRef;

  lengthSquared(): WaveNumberRef;

  lerp(to: WaveVec3AuthoringInput, amount: WaveNumberAuthoringInput): WaveVec3Ref;

  normalize(epsilon?: number): WaveVec3Ref;

  scale(value: WaveNumberAuthoringInput): WaveVec3Ref;

  sub(value: WaveVec3AuthoringInput): WaveVec3Ref;

  readonly x: WaveNumberRef;

  readonly xy: WaveVec2Ref;

  readonly xz: WaveVec2Ref;

  readonly y: WaveNumberRef;

  readonly yz: WaveVec2Ref;

  readonly z: WaveNumberRef;

}

interface WaveVec4Like {

  readonly w: number;

  readonly x: number;

  readonly y: number;

  readonly z: number;

}

interface WaveVec4Ref {

  readonly kind: "vec4";

  toExpr(): WaveValueExpr;

  toJSON(): WaveValueExpr;

  readonly a: WaveNumberRef;

  readonly b: WaveNumberRef;

  readonly g: WaveNumberRef;

  readonly gb: WaveVec2Ref;

  readonly r: WaveNumberRef;

  readonly rgb: WaveVec3Ref;

  readonly w: WaveNumberRef;

  readonly x: WaveNumberRef;

  readonly xy: WaveVec2Ref;

  readonly xyz: WaveVec3Ref;

  readonly xz: WaveVec2Ref;

  readonly y: WaveNumberRef;

  readonly yz: WaveVec2Ref;

  readonly z: WaveNumberRef;

  readonly zw: WaveVec2Ref;

}

type WaveVector3FieldInput = WaveVector3Field;

type WaveVertexAttributeArray = Float32Array | Uint32Array | Uint16Array | Uint8Array;

type WaveVertexAttributeFormat = "float32" | "uint32" | "uint16" | "uint8" | "unorm16" | "unorm8";

interface WaveVertexAttributeInput {

  readonly components: 1 | 2 | 3 | 4;

  readonly data: ArrayLike<number>;

  readonly format: WaveVertexAttributeFormat;

  readonly interpolation?: WaveVertexAttributeInterpolation;

  readonly semantic: WaveVertexAttributeSemantic;

}

type WaveVertexAttributeInterpolation = "linear" | "normalizedLinear" | "nearest";

interface WaveVertexAttributePayload {

  readonly components: 1 | 2 | 3 | 4;

  readonly data: WaveVertexAttributeArray;

  readonly format: WaveVertexAttributeFormat;

  readonly interpolation: WaveVertexAttributeInterpolation;

  readonly semantic: WaveVertexAttributeSemantic;

}

type WaveVertexAttributeSemantic = "normal" | "tangent" | "uv0" | "uv1" | "color0" | "joints0" | "weights0" | "joints1" | "weights1" | `custom:${string}`;

interface WaveVertexDataInput {

  readonly attributes?: readonly WaveVertexAttributeInput[];

  readonly indices: ArrayLike<number>;

  readonly morphTargets?: readonly WaveMorphTargetInput[];

  readonly positions: ArrayLike<number>;

}

interface WaveVertexDataPayload {

  readonly attributes?: readonly WaveVertexAttributePayload[];

  readonly indices: Uint32Array;

  readonly morphTargets?: readonly WaveMorphTargetPayload[];

  readonly positions: Float32Array;

}

declare class WaveVertexMotionAnimationBuilder {

  affectsPhysics(): this;

  after(duration: WaveTimeSpan): this;

  after(value: number, unit: WaveTimeUnit): this;

  for(duration: WaveTimeSpan): this;

  for(value: number, unit: WaveTimeUnit): this;

  geometryMutable(): this;

  loop(enabled?: boolean): this;

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  physicsAccurate(): this;

  pingPong(enabled?: boolean): this;

  syncColliderEvery(frames: number): this;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): this;

  withCallbacks(callbacks: TransitionLifecycleCallbacks<WaveGeometryMotionAnimationState>, options?: WaveAuthoredCallbackOptions): this;

  withEasingEffect(ease: WaveEasing): this;

  withProgressCurve(curve: WaveValueCurveInput): this;

  along(path: FollowPathSource): this;

  backward(): this;

  forward(): this;

  named(layerName: string): this;

  play(): TransitionLifecycleHandle<WaveGeometryMotionAnimationState, FollowPathSource>;

}

declare class WaveVertexSimulationBuilder {

  constructor(_animator: cmp_modelAnimator);

  drivenBy(field: WaveVertexSimulationForceField): this;

  onGpu(): this;

  pinPoints(...points: readonly WaveGridPinPoint[]): this;

  pinUVEdge(edge: DirectionInput): this;

  pinUVLine(startU: number, startV: number, endU: number, endV: number, count: number): this;

  play(): cmp_modelAnimator;

  visualOnly(): this;

  withFixedStep(seconds: number): this;

  withMaterial(material: WaveSurfaceDynamicsMaterial): this;

  withSolverIterations(iterations: number): this;

}

interface WaveVertexSimulationForceField {

  sampleAt(target: WavePointInput): WaveVertexSimulationForceSample;

}

interface WaveVertexSimulationForceSample {

  readonly netDirection: Vector3Like;

  readonly netForce: Vector3Like;

  readonly strength: number;

}

type WaveVideoLoopCallback = (loopCount: number, video: WaveVideoPlayback) => void;

interface WaveVideoPlaybackAudioHost {

  bindAuthoredCallback<TArgs extends readonly unknown[]>(callback: (...args: TArgs) => void): WaveBoundAuthoredCallback<TArgs, void | undefined>;

  disconnectVideoAudio(video: HTMLVideoElement): void;

  routeVideoAudio(videoAssetName: string, video: HTMLVideoElement, busName: string, volume: number, muted: boolean): boolean;

}

type WaveVideoPlaybackCallback = (video: WaveVideoPlayback) => void;

interface WaveVideoPlaybackConstruction {

  bindVideo(ref: AssetRef<"video"> | ExactAssetRef<"video">, consumerId: string, intent?: VideoBindingIntent): WaveSceneVideoBinding;

  readonly consumerId: string;

  readonly host: WaveVideoPlaybackAudioHost;

  readonly intent?: VideoBindingIntent;

  readonly ref: AssetRef<"video"> | ExactAssetRef<"video">;

}

interface WaveVideoPlaybackSerialState {

  readonly bus: string;

  readonly currentTime: number;

  readonly followCurrent: boolean;

  readonly identityId: string;

  readonly loop: boolean;

  readonly muted: boolean;

  readonly rate: number;

  readonly revision?: string;

  readonly timeline: "shared" | "independent";

  readonly volume: number;

}

type WaveViewNdcPoint = ViewNdcPoint;

type WaveViewNormalizedPoint = ViewNormalizedPoint;

type WaveViewPixelPoint = ViewPixelPoint;

interface WaveVisual2DLayerState {

  readonly layer: number;

  readonly stableOrder: number;

}

declare class WaveVisualReflectionBuilder {

  constructor(_terminal: WaveReflectionPolicyTerminal, _target?: WaveVisualTargetRef | undefined);

  apply(): void;

  fallbackToIntrinsic(): this;

  intensity(value: number): this;

  prefer(source: WaveReflectionSourceRef): this;

  then(source: WaveReflectionSourceRef): this;

  thenEnvironment(): this;

  withoutFallback(): this;

}

interface WaveVisualTargetRef {

  readonly kind: "mesh" | "part";

  readonly ref: string;

  readonly slot?: number;

}

interface WaveVolumetricField {

  bounds: SpatialAabb;

  kind: "cavityUnion";

  minCrossDimension: number;

  nodes: readonly WaveCavityVolumetricNode[];

}

type WaveWaterBodyKind = "ocean" | "lake" | "river" | "pond" | "pool";

interface WaveWaterBodyModel {

  readonly buoyancy: WaveWaterBuoyancyModel;

  readonly foam: WaveWaterFoamModel;

  readonly frameGraph: WaveWaterFrameGraphPolicy;

  readonly id: string;

  readonly kind: WaveWaterBodyKind;

  readonly level: number;

  readonly optics: WaveWaterOpticsModel;

  readonly quality: WaveWaterQuality;

  readonly reflection: WaveWaterReflectionPolicy;

  readonly shoreline: WaveWaterShorelineModel;

  readonly surfaceMaterial: WaveWaterSurfaceMaterialPolicy;

  readonly underwater: WaveWaterUnderwaterModel;

  readonly waves: WaveWaterWaveModel;

}

type WaveWaterBodyModelPatch = Partial<{ readonly id: string; readonly kind: WaveWaterBodyKind; readonly quality: WaveWaterQuality; readonly level: number; readonly waves: Partial<Omit<WaveWaterWaveModel, "spectral" | "swells">> & { readonly spectral?: Partial<Omit<WaveWaterSpectralWavePolicy, "cascades">> & { readonly cascades?: readonly Partial<WaveWaterSpectralCascadePolicy>[]; }; readonly swells?: readonly Partial<WaveWaterGerstnerSwellPolicy>[]; }; readonly optics: Partial<{ readonly deepColor: WaveWaterColorInput; readonly shallowColor: WaveWaterColorInput; readonly foamColor: WaveWaterColorInput; readonly absorptionStrength: number; readonly scatteringStrength: number; readonly fresnelStrength: number; readonly fresnelPower: number; readonly specularStrength: number; readonly roughness: number; readonly refractionStrength: number; readonly refractionDistortion: number; readonly reflectionDistortion: number; }>; readonly surfaceMaterial: Partial<Omit<WaveWaterSurfaceMaterialPolicy, "normalDetail" | "foamDetail" | "waveNoise" | "flow" | "detailFade">> & { readonly normalDetail?: Partial<WaveWaterSurfaceMaterialPolicy["normalDetail"]>; readonly foamDetail?: Partial<WaveWaterSurfaceMaterialPolicy["foamDetail"]>; readonly waveNoise?: Partial<WaveWaterSurfaceMaterialPolicy["waveNoise"]>; readonly flow?: Partial<WaveWaterSurfaceMaterialPolicy["flow"]>; readonly detailFade?: Partial<WaveWaterSurfaceMaterialPolicy["detailFade"]>; }; readonly foam: Partial<WaveWaterFoamModel>; readonly reflection: Partial<{ readonly candidates: readonly WaveReflectionSourceRef[]; readonly fallback: WaveReflectionReceiverPolicy["fallback"]; readonly intensity: number; }>; readonly frameGraph: Partial<WaveWaterFrameGraphPolicy>; readonly shoreline: Partial<WaveWaterShorelineModel>; readonly buoyancy: Partial<WaveWaterBuoyancyModel>; readonly underwater: Partial<WaveWaterUnderwaterModel>; }>;

interface WaveWaterBuoyancyModel {

  readonly angularDamping: number;

  readonly defaultSampleMode: "singlePoint" | "multiPoint";

  readonly drag: number;

  readonly enabled: boolean;

  readonly linearDamping: number;

  readonly maxSamplesPerBody: number;

}

type WaveWaterColorInput = number | WaveWaterRgb;

interface WaveWaterFoamModel {

  readonly crestStrength: number;

  readonly enabled: boolean;

  readonly objectTrailStrength: number;

  readonly persistence: number;

  readonly shorelineStrength: number;

  readonly surfaceStrength: number;

}

interface WaveWaterFrameGraphPolicy {

  readonly backend: WaveWaterRenderBackend;

  readonly maxClipmapRings: number;

  readonly maxSurfaceVertices: number;

  readonly refractionResolutionScale: number;

  readonly shorelineTextureSize: number;

  readonly wakeTextureSize: number;

}

interface WaveWaterGerstnerSwellPolicy {

  readonly amplitude: number;

  readonly direction: WaveWaterVector2;

  readonly enabled: boolean;

  readonly speed: number;

  readonly steepness: number;

  readonly wavelength: number;

}

interface WaveWaterOpticsModel {

  readonly absorptionStrength: number;

  readonly deepColor: WaveWaterRgb;

  readonly foamColor: WaveWaterRgb;

  readonly fresnelPower: number;

  readonly fresnelStrength: number;

  readonly reflectionDistortion: number;

  readonly refractionDistortion: number;

  readonly refractionStrength: number;

  readonly roughness: number;

  readonly scatteringStrength: number;

  readonly shallowColor: WaveWaterRgb;

  readonly specularStrength: number;

}

type WaveWaterQuality = "mobile" | "balanced" | "cinematic";

type WaveWaterReflectionPolicy = WaveReflectionReceiverPolicy;

type WaveWaterRenderBackend = "frameGraph";

type WaveWaterRgb = Readonly<WaveRgbChannels>;

interface WaveWaterShorelineModel {

  readonly depthMeters: number;

  readonly enabled: boolean;

  readonly foamWidthMeters: number;

  readonly source: "terrainDepth" | "maskAtlas" | "none";

  readonly updateIntervalFrames: number;

}

interface WaveWaterSpectralCascadePolicy {

  readonly amplitude: number;

  readonly enabled: boolean;

  readonly resolution: number;

  readonly scale: number;

}

interface WaveWaterSpectralWavePolicy {

  readonly amplitude: number;

  readonly animationSpeed: number;

  readonly cascades: readonly WaveWaterSpectralCascadePolicy[];

  readonly choppiness: number;

  readonly directionalSpread: number;

  readonly enabled: boolean;

  readonly peakEnhancement: number;

  readonly seed: number;

  readonly swell: number;

  readonly windDirection: WaveWaterVector2;

  readonly windSpeed: number;

}

interface WaveWaterSurfaceMaterialPolicy {

  readonly alpha: number;

  readonly detailFade: { readonly start: number; readonly end: number; }

  readonly flow: { readonly strength: number; readonly coordinateSpace: "auto" | "world" | "uv"; }

  readonly foamDetail: { readonly asset: string | null; readonly scale: number; readonly evolutionSpeed: number; readonly warpStrength: number; readonly threshold: number; readonly softness: number; }

  readonly normalDetail: { readonly asset: string | null; readonly strength: number; readonly scale: number; readonly secondaryScale: number; }

  readonly reflectionTextureAsset: string | null;

  readonly tintVariation: number;

  readonly waveNoise: { readonly asset: string | null; readonly strength: number; readonly scale: number; readonly speed: number; }

}

interface WaveWaterSurfaceQueryPoint {

  readonly x: number;

  readonly z: number;

}

interface WaveWaterSurfaceSampleFrame {

  readonly count: number;

  readonly frameId: number;

  readonly queryRevision: number;

  readonly values: Float32Array;

}

interface WaveWaterUnderwaterModel {

  readonly causticsStrength: number;

  readonly distortionStrength: number;

  readonly enabled: boolean;

  readonly fogStrength: number;

  readonly waterlineFeather: number;

}

type WaveWaterVector2 = Readonly<SerializableVector2>;

interface WaveWaterWaveModel {

  readonly spectral: WaveWaterSpectralWavePolicy;

  readonly surfaceQueries: boolean;

  readonly swells: readonly WaveWaterGerstnerSwellPolicy[];

}

interface WaveWebcamHandTrackingError {

  error: unknown;

  message: string;

}

interface WaveWebcamHandTrackingHandle {

  dispose(): void;

  readonly error: unknown;

  isTracking(): boolean;

  readonly state: CaptureState;

  stopTracking(): void;

}

interface WaveWebcamHandTrackingMediaPipeAssets {

  gestureModelAssetPath?: string;

  wasmBaseUrl?: string;

}

type WaveWedgeFace = "slope" | "bottom" | "front" | "back" | "left" | "right";

interface WaveWedgePrimitiveRecipe {

  readonly doubleSideUv?: WavePrimitiveDoubleSideUv | undefined;

  readonly kind: "primitive";

  readonly shape: "wedge";

  readonly sideOrientation?: WaveSideOrientation | undefined;

  readonly version: 1;

  readonly faces?: Partial<Readonly<Record<WaveWedgeFace, WavePrimitiveFaceLayout>>>;

  readonly flipSlope?: boolean;

  readonly segments?: { readonly width?: number; readonly height?: number; readonly depth?: number; }

  readonly size: { readonly width: number; readonly height: number; readonly depth: number; }

}

interface WaveWGSLModule {

  readonly capabilities: readonly WaveWGSLModuleCapability[];

  readonly name: string;

  readonly schema: "wave.wgslModule.v1";

  readonly source: string;

  readonly stages: readonly WaveWGSLModuleStage[];

  readonly version: number;

  readonly cacheIdentity: string;

  readonly dependencies: readonly WaveWGSLModuleDependency[];

}

type WaveWGSLModuleCapability = "deform" | "noise" | "relief" | "field" | "sampling" | "temporal" | "material" | "custom";

interface WaveWGSLModuleDependency {

  readonly name: string;

  readonly version: number;

}

interface WaveWGSLModuleInput {

  readonly capabilities: readonly WaveWGSLModuleCapability[];

  readonly dependencies?: readonly WaveWGSLModuleDependency[];

  readonly name: string;

  readonly schema: "wave.wgslModule.v1";

  readonly source: string;

  readonly stages: readonly WaveWGSLModuleStage[];

  readonly version: number;

}

type WaveWGSLModuleStage = "vertex" | "fragment" | "compute";

interface WaveWorldBudgetPolicy {

  readonly chunkMaterializationsPerFrame?: number;

  readonly maxChunkWorkers?: number;

  readonly spawnMsPerFrame?: number;

}

interface WaveWorldComposerApplyTarget {

  apply(plan: WaveWorldPlan): void;

}

interface WaveWorldElementDeclaration {

  readonly id: string;

  readonly layerId: string;

  readonly options: WaveWorldElementRecipeOptions;

  readonly revision: string;

  readonly seed: number;

}

type WaveWorldElementPOIRecipe = Omit<WorldElementPOIOptions, "onPOISpawn"> & { readonly onPOISpawn?: never; }

type WaveWorldElementRecipeOptions = WorldElementScatterOptions | WorldElementGrassCarpetOptions | WorldElementWaterOptions | WorldElementSurfaceOptions | WorldElementEntityOptions | WaveWorldElementPOIRecipe;

interface WaveWorldLayerCapabilities {

  readonly geometry: boolean;

  readonly partition: "grid2D" | "grid3D" | "geospatial" | "custom";

  readonly semantics: boolean;

  readonly surface: "heightfield" | "mesh" | "volume" | "flat" | "none";

}

interface WaveWorldLayerDraft<TSourceOptions extends object = object, TLayerConfig extends object = object> {

  readonly config?: TLayerConfig;

  readonly id: string;

  readonly kind: WaveWorldLayerKind;

  readonly physics?: WorldStreamingPhysicsConfig;

  readonly queryPriority?: number;

  readonly required?: boolean;

  readonly source: WaveWorldSourceConfig<TSourceOptions>;

  readonly streaming?: WaveWorldStreamingPolicy;

  readonly workers?: WaveWorldWorkerPolicy;

}

type WaveWorldLayerKind = "terrainField" | "tilemap" | "spatialGrid" | "tiles3D" | "geo" | "voxel" | "authored" | (string & {});

interface WaveWorldLayerPlan<TSourceOptions extends object = object, TLayerConfig extends object = object> {

  readonly capabilities: WaveWorldLayerCapabilities;

  readonly config: TLayerConfig;

  readonly id: string;

  readonly kind: WaveWorldLayerKind;

  readonly physics: WorldStreamingPhysicsConfig;

  readonly queryPriority: number;

  readonly required: boolean;

  readonly revision: string;

  readonly seed: number;

  readonly source: WaveWorldSourceConfig<TSourceOptions>;

  readonly sourceVersion: number;

  readonly streaming: WaveWorldStreamingPolicy;

  readonly workers: WaveWorldWorkerPolicy;

}

interface WaveWorldPlan {

  readonly assets: readonly string[];

  readonly budgets: WaveWorldBudgetPolicy;

  readonly description?: string;

  readonly elements: readonly WaveWorldElementDeclaration[];

  readonly extensions: readonly WaveWorldRuntimeExtensionBinding[];

  readonly id: string;

  readonly kind: typeof WAVE_WORLD_PLAN_KIND;

  readonly layers: readonly WaveWorldLayerPlan[];

  readonly metadata: Readonly<Record<string, SerializableDataValue>>;

  readonly revision: string;

  readonly seed: number;

  readonly version: typeof WAVE_WORLD_PLAN_VERSION;

}

interface WaveWorldPlanDraft {

  readonly budgets?: WaveWorldBudgetPolicy;

  readonly description?: string;

  readonly elements?: readonly Omit<WaveWorldElementDeclaration, "revision" | "seed">[];

  readonly extensions?: readonly Omit<WaveWorldRuntimeExtensionBinding, "revision" | "seed">[];

  readonly id: string;

  readonly layers: readonly WaveWorldLayerDraft[];

  readonly metadata?: Readonly<Record<string, SerializableDataValue>>;

  readonly seed?: number;

}

interface WaveWorldPlanEditorCommitTarget {

  apply(plan: WaveWorldPlan): void;

}

type WaveWorldPlanElementWorkspaceBuilder = Omit<WorldPopulateWorkspaceBuilder<WaveWorldComposer>, "custom">;

interface WaveWorldPlanExplanation {

  readonly assets: readonly string[];

  readonly budgets: WaveWorldPlan["budgets"];

  readonly extensions: readonly { readonly id: string; readonly extensionId: string; readonly layerId: string | null; }[];

  readonly id: string;

  readonly layers: readonly { readonly id: string; readonly revision: string; readonly kind: string; readonly sourceProvider: string; readonly required: boolean; readonly queryPriority: number; readonly capabilities: WaveWorldPlan["layers"][number]["capabilities"]; readonly elementIds: readonly string[]; readonly terrainProfile?: WaveTerrainProfileExplanation; }[];

  readonly revision: string;

  readonly seed: number;

}

type WaveWorldPlanInput = WaveWorldPlan | WaveWorldPlanLike | WaveWorldPlanDraft;

interface WaveWorldPlanLike {

  toWorldPlan(): WaveWorldPlan;

}

type WaveWorldProjectionSource = { readonly kind: "worldPoint"; readonly point: SerializableVector3; } | { readonly kind: "entityLocator"; readonly entity: WaveEntityIdentityRef; readonly locator: WaveSerializable3DLocator; }

interface WaveWorldProjectionTarget {

  locator(): WaveLocatorBuilder;

  readonly networkID?: number;

  readonly runtimeRef: string;

  readonly scene: Wave2DLayoutTarget["scene"];

}

type WaveWorldProjectionViews = { readonly kind: "allViews"; } | { readonly kind: "selectedViews"; readonly cameraIds: readonly string[]; }

interface WaveWorldRadius {

  readonly cols?: number;

  readonly layers?: number;

  readonly rows?: number;

}

interface WaveWorldRuntimeExtensionBinding<TOptions extends SerializableDataValue = SerializableDataValue> {

  readonly assets?: readonly string[];

  readonly extensionId: string;

  readonly id: string;

  readonly layerId?: string;

  readonly options: TOptions;

  readonly revision: string;

  readonly seed: number;

}

interface WaveWorldSourceConfig<TOptions extends object = object> {

  readonly options: TOptions;

  readonly provider: WaveWorldSourceProvider;

}

type WaveWorldSourceProvider = "grid3D" | "terrainPreset" | "comboTileKit" | "googleMaps3DTiles" | "laasWorld" | (string & {});

interface WaveWorldStreamingPolicy {

  readonly activeRadius?: number | WaveWorldRadius;

  readonly endless?: boolean;

}

type WaveWorldTextFontInput = string | AssetRef<"font"> | ExactAssetRef<"font">;

interface WaveWorldTextModelHost {

  readonly [WAVE_WORLD_TEXT_MODEL_HOST]: true;

}

interface WaveWorldTextModelInput {

  readonly color?: ColorInputAlpha;

  readonly depthTest?: boolean;

  readonly font?: WaveWorldTextFontInput;

  readonly horizontalAlignment?: "left" | "center" | "right";

  readonly lineSpacing?: number;

  readonly model: typeof WAVE_WORLD_TEXT_MODEL_KIND;

  readonly orientation?: WaveWorldTextOrientation;

  readonly renderingGroupId?: number;

  readonly size?: number;

  readonly text: string;

  readonly verticalAlign?: "top" | "center" | "bottom";

}

type WaveWorldTextOrientation = "cameraUpright" | "ownerUpCameraFacing" | "nodePlane";

type WaveWorldWorkerMode = "required" | "preferred" | "off";

interface WaveWorldWorkerPolicy {

  readonly chunkWorkers?: number;

  readonly mode: WaveWorldWorkerMode;

}

interface WeaponSwooshOpts {

  blade: { base: WaveFxAnchorBinding; tip: WaveFxAnchorBinding; }

  blend?: "additive" | "alpha" | "multiply";

  color?: ColorLike;

  depthWrite?: boolean;

  fadeByAge?: boolean;

  glow?: FxGlowConfig;

  innerAlphaScale?: number;

  lifetime?: number;

  maxPoints?: number;

  minSampleDistance?: number;

  outerColor?: ColorLike;

  scatter?: number;

  texture?: string;

  textureMode?: "stretch" | "tile" | "distanceRepeat";

  textureRepeatDistance?: number;

}

declare class WeatherConfigurator<TEngine extends unknown = unknown> {

  apply(): WaveScene<TEngine>;

  apply(patch: Partial<WaveSceneWeatherConfig>): WaveScene<TEngine>;

  asRain(): WeatherConfigurator<TEngine>;

  asSnow(): WeatherConfigurator<TEngine>;

  intensity(val: number): WeatherConfigurator<TEngine>;

  none(): WeatherConfigurator<TEngine>;

  off(): WeatherConfigurator<TEngine>;

  rain(intensity?: number): WeatherConfigurator<TEngine>;

  snow(intensity?: number): WeatherConfigurator<TEngine>;

  stop(): WeatherConfigurator<TEngine>;

}

interface WeatherLightningOptions {

  beamLength?: number;

  burst?: number;

  flashSize?: number;

  intensityDefault?: number;

  lifetime?: NumLike;

  systemId?: string;

}

interface WeatherRainOptions {

  intensityDefault?: number;

  lifetime?: NumLike;

  rate?: number;

  size?: NumLike;

  spawnHeight?: number;

  speed?: number;

  systemId?: string;

}

interface WeatherSnowOptions {

  intensityDefault?: number;

  lifetime?: NumLike;

  rate?: number;

  size?: NumLike;

  spawnHeight?: number;

  speed?: number;

  systemId?: string;

}

declare const WEDGE_BACK_FACE: Readonly<{ readonly kind: "back"; }>;

declare const WEDGE_BOTTOM_FACE: Readonly<{ readonly kind: "bottom"; }>;

declare const WEDGE_FRONT_FACE: Readonly<{ readonly kind: "front"; }>;

declare const WEDGE_LEFT_FACE: Readonly<{ readonly kind: "left"; }>;

declare const WEDGE_RIGHT_FACE: Readonly<{ readonly kind: "right"; }>;

declare const WEDGE_SLOPE_FACE: Readonly<{ readonly kind: "slope"; }>;

type WedgeBackFaceSelector = typeof WEDGE_BACK_FACE;

type WedgeBottomFaceSelector = typeof WEDGE_BOTTOM_FACE;

type WedgeFaceSelector = WedgeSlopeFaceSelector | WedgeBottomFaceSelector | WedgeFrontFaceSelector | WedgeBackFaceSelector | WedgeLeftFaceSelector | WedgeRightFaceSelector;

type WedgeFrontFaceSelector = typeof WEDGE_FRONT_FACE;

type WedgeLeftFaceSelector = typeof WEDGE_LEFT_FACE;

type WedgeRightFaceSelector = typeof WEDGE_RIGHT_FACE;

type WedgeSlopeFaceSelector = typeof WEDGE_SLOPE_FACE;

declare const WINDMILL_PARTS: Readonly<{ readonly base: "base"; readonly tower: "tower"; readonly hub: "hub"; readonly blade1: "blade1"; readonly blade2: "blade2"; readonly blade3: "blade3"; readonly roof: "roof"; }>;

interface WobbleEffectConfig {

  frequency?: number;

  maxDisplacement?: number;

  smoothing?: number;

  speed?: number;

}

interface WorldChunkContext {

  bounds: { minX: number; maxX: number; minZ: number; maxZ: number; centerX: number; centerZ: number; }

  getHeightAt: (x: number, z: number) => number | null;

  getNormalAt?: (x: number, z: number) => { x: number; y: number; z: number; } | null;

  getSemanticAt?: (x: number, z: number) => WorldElementSemanticSample | null;

  getSlopeAt?: (x: number, z: number) => number | null;

  seed: number;

  tileDepth: number;

  tileWidth: number;

  tileX: number;

  tileZ: number;

}

declare class WorldCustomElementWorkspaceBuilder<TWorkspace> {

  alwaysLive(): this;

  apply(): TWorkspace;

  destroyOnExit(): this;

  distanceBands(...fractions: number[]): this;

  elevationRange(min: number, max: number): this;

  hideOnExit(): this;

  linkedTo(name: string, yOffset?: number): this;

  linkTo(name: string, yOffset?: number): this;

  lod(config: WorldElementLodConfig): this;

  lodBoundaries(...fractions: number[]): this;

  maxElevation(value: number): this;

  minElevation(value: number): this;

  notOnSemantic(tag: string | readonly string[]): this;

  onSemantic(tag: string | readonly string[]): this;

  persistOnExit(): this;

  recycle(policy: WorldElementRecyclePolicy): this;

  requiringSemantic(tag: string | readonly string[]): this;

  toDeclaration(): WorldElementDeclaration;

  withOptions(options: Partial<WorldElementCustomOptions>): this;

  constructor(workspace: TWorkspace, target: WorldElementWorkspaceTarget, name: string);

  onEnter(callback: WorldElementCustomOptions["onChunkEnter"]): this;

  onExit(callback: NonNullable<WorldElementCustomOptions["onChunkExit"]>): this;

}

interface WorldElementCustomOptions {

  linkedTo?: string | undefined;

  linkedYOffset?: number | undefined;

  lod?: WorldElementLodConfig | undefined;

  maxElevation?: number | undefined;

  minElevation?: number | undefined;

  recyclePolicy?: WorldElementRecyclePolicy | undefined;

  semantic?: WorldElementSemanticFilterOptions | undefined;

  kind: WorldElementKind.Custom;

  onChunkEnter: (ctx: WorldChunkContext) => { entities: unknown[]; }

  onChunkExit?: (ctx: WorldChunkContext, state: { entities: unknown[]; }) => void;

}

interface WorldElementDeclaration {

  name: string;

  options: WorldElementOptions;

}

type WorldElementDeformationIntent = { readonly verb: "sway"; readonly parameters: WaveGeometrySwayParameters; } | { readonly verb: "displace"; readonly parameters: WaveGeometryDisplaceParameters & { readonly turbulence: true; }; }

interface WorldElementEntityLodOverride {

  countPerChunk?: number;

  models?: string[];

  scaleRange?: [number, number];

}

interface WorldElementEntityOptions {

  linkedTo?: string | undefined;

  linkedYOffset?: number | undefined;

  lod?: WorldElementLodConfig | undefined;

  maxElevation?: number | undefined;

  minElevation?: number | undefined;

  recyclePolicy?: WorldElementRecyclePolicy | undefined;

  semantic?: WorldElementSemanticFilterOptions | undefined;

  countPerChunk: number;

  kind: WorldElementKind.Entity;

  models: string[];

  physics?: boolean;

  scaleRange?: [number, number];

  skipUnderwater?: boolean;

  surface?: boolean;

  yOffset?: number;

}

interface WorldElementGrassCarpetOptions {

  linkedTo?: string | undefined;

  linkedYOffset?: number | undefined;

  lod?: WorldElementLodConfig | undefined;

  maxElevation?: number | undefined;

  minElevation?: number | undefined;

  recyclePolicy?: WorldElementRecyclePolicy | undefined;

  semantic?: WorldElementSemanticFilterOptions | undefined;

  kind: WorldElementKind.GrassCarpet;

  material: WaveMaterialInput<"grass">;

  materialAsset: string;

  notInRange?: WaveRangeShape[];

  range?: WaveRangeShape[];

  seed?: number;

  yOffset?: number;

}

interface WorldElementLodBoundary {

  fraction: number;

}

interface WorldElementLodConfig {

  boundaries?: WorldElementLodBoundary[];

  coordinateWithFog?: boolean;

  entity?: WorldElementEntityLodOverride[];

  mode?: WorldElementLodMode;

  partition?: WorldElementLodPartitionConfig;

  scatter?: WorldElementScatterLodOverride[];

  water?: WorldElementWaterLodOverride[];

}

type WorldElementLodMode = "chunk" | "partitioned";

interface WorldElementLodPartitionConfig {

  grid?: number;

  size?: number;

}

type WorldElementOptions = WorldElementScatterOptions | WorldElementGrassCarpetOptions | WorldElementWaterOptions | WorldElementSurfaceOptions | WorldElementEntityOptions | WorldElementCustomOptions | WorldElementPOIOptions;

interface WorldElementPOIOptions {

  linkedTo?: string | undefined;

  linkedYOffset?: number | undefined;

  lod?: WorldElementLodConfig | undefined;

  maxElevation?: number | undefined;

  minElevation?: number | undefined;

  recyclePolicy?: WorldElementRecyclePolicy | undefined;

  semantic?: WorldElementSemanticFilterOptions | undefined;

  billboard?: boolean;

  categories?: string[];

  categoryModels?: Record<string, string>;

  defaultModel?: string;

  kind: WorldElementKind.POI;

  labelColor?: ColorInput;

  labelFontSize?: number;

  labelYOffset?: number;

  maxPerChunk?: number;

  onPOISpawn?: (entity: waveProp, poi: GeoPOIFeature) => void;

  physics?: boolean;

  scaleRange?: [number, number];

  showLabel?: boolean;

  surface?: boolean;

  yOffset?: number;

}

declare enum WorldElementRecyclePolicy {

  AlwaysLive = "alwaysLive",

  Destroy = "destroy",

  Hide = "hide",

  Persist = "persist",

}

interface WorldElementScatterLodOverride {

  alignToNormal?: boolean;

  color?: number;

  colorPalette?: number[] | false;

  countPerChunk?: number;

  deformation?: WorldElementDeformationIntent | false;

  model?: string | WaveModelInput;

  part?: WaveModelPartRef;

  scaleRange?: [number, number];

  scaleVariance?: { x?: [number, number]; y?: [number, number]; z?: [number, number]; } | false;

}

interface WorldElementScatterOptions {

  linkedTo?: string | undefined;

  linkedYOffset?: number | undefined;

  lod?: WorldElementLodConfig | undefined;

  maxElevation?: number | undefined;

  minElevation?: number | undefined;

  recyclePolicy?: WorldElementRecyclePolicy | undefined;

  semantic?: WorldElementSemanticFilterOptions | undefined;

  alignToNormal?: boolean;

  color?: number;

  colorByElevation?: Array<{ elevation: number; color: number; }>;

  colorPalette?: number[];

  countPerChunk: number;

  deformation?: WorldElementDeformationIntent;

  distribution?: { clustering?: number; minSpacing?: number; densityNoise?: { scale: number; threshold: number; }; }

  frustumCulling?: { radius: number; }

  kind: WorldElementKind.Scatter;

  minRadius?: number;

  model: string | WaveModelInput;

  notInRange?: WaveRangeShape[];

  part?: WaveModelPartRef;

  range?: WaveRangeShape[];

  scaleRange?: [number, number];

  scaleVariance?: { x?: [number, number]; y?: [number, number]; z?: [number, number]; }

  skipUnderwater?: boolean;

  slopeRange?: [number, number];

  slopeTransition?: number;

  surface?: boolean;

  yOffset?: number;

}

interface WorldElementSemanticFilterOptions {

  allTags?: readonly string[];

  notTags?: readonly string[];

  tags?: readonly string[];

}

interface WorldElementSemanticSample {

  readonly primaryTag: string;

  readonly sourceName?: string;

  readonly tags: readonly string[];

}

interface WorldElementSurfaceOptions {

  linkedTo?: string | undefined;

  linkedYOffset?: number | undefined;

  lod?: WorldElementLodConfig | undefined;

  maxElevation?: number | undefined;

  minElevation?: number | undefined;

  recyclePolicy?: WorldElementRecyclePolicy | undefined;

  semantic?: WorldElementSemanticFilterOptions | undefined;

  course: WorldWaterCourseConfig;

  kind: WorldElementKind.Surface;

  material?: WaveMaterialInput;

  materialAsset: string;

  shape: WorldSurfaceShape;

}

interface WorldElementWaterLodOverride {

  alpha?: number;

  bumpHeight?: number;

  crestFoamIntensity?: number;

  foamAndShorelineEnabled?: boolean;

  foamColor?: number;

  overlayMargin?: number;

  overlayUpdateInterval?: number;

  preset?: WaterBodyPreset;

  reflectSky?: boolean;

  reflectTerrain?: boolean;

  shorelineDepth?: number;

  shorelineFoamIntensity?: number;

  subdivisions?: number;

  waveCount?: number;

  waveHeight?: number;

  waveLength?: number;

  waveSpeed?: number;

  windForce?: number;

}

interface WorldElementWaterOptions {

  linkedTo?: string | undefined;

  linkedYOffset?: number | undefined;

  lod?: WorldElementLodConfig | undefined;

  maxElevation?: number | undefined;

  minElevation?: number | undefined;

  recyclePolicy?: WorldElementRecyclePolicy | undefined;

  semantic?: WorldElementSemanticFilterOptions | undefined;

  alpha?: number;

  bodyModel?: WaveWaterBodyModel;

  bumpHeight?: number;

  colorBlendFactor?: number;

  colorBlendFactor2?: number;

  course?: WorldWaterCourseConfig;

  crestFoamIntensity?: number;

  enableUnderwaterEffect?: boolean;

  enableVolume?: boolean;

  foamAndShorelineEnabled?: boolean;

  foamAtlasResolution?: number;

  foamColor?: number;

  foamPatternTexturePath?: string;

  kind: WorldElementKind.Water;

  material?: WaveMaterialInput<"water">;

  materialAsset?: string;

  normalTexturePath?: string;

  overlayMargin?: number;

  overlayPageResolution?: number;

  overlayUpdateInterval?: number;

  reflectionIntensity?: { sky?: number; clouds?: number; stars?: number; aurora?: number; }

  reflectSky?: boolean;

  reflectTerrain?: boolean;

  region?: WorldWaterRegionConfig;

  shape?: WorldWaterShape;

  shorelineDepth?: number;

  shorelineFoamIntensity?: number;

  subdivisions?: number;

  volumeAlpha?: number;

  volumeDepth?: number;

  waterColor?: number;

  waterColor2?: number;

  waterLevel?: number;

  waveCount?: number;

  waveHeight?: number;

  waveLength?: number;

  waveSpeed?: number;

  waveUpdateInterval?: number;

  windDirection?: { x: number; y: number; }

  windForce?: number;

}

interface WorldElementWorkspaceTarget {

  declareElement(name: string, options: WorldElementOptions): void;

  getElement(name: string): WorldElementDeclaration | null;

  removeElement(name: string): void;

  resolveRange?(range: PlacementRangeInput): WaveRangeShape | null;

}

interface WorldEmissiveConfig {

  readonly colorStops: readonly { readonly color: ColorInput; readonly position: number; }[];

  readonly gradientShape?: WorldEmissiveGradientShape;

  readonly intensity?: number;

  readonly noiseIntensity?: number;

  readonly noiseScale?: number;

  readonly octaves?: number;

  readonly pulseAmount?: number;

  readonly pulseSpeed?: number;

  readonly speed?: number;

}

type WorldEmissiveGradientShape = "horizontal" | "vertical" | "radial" | "angular" | "organic";

declare class WorldEntityElementWorkspaceBuilder<TWorkspace> {

  alwaysLive(): this;

  apply(): TWorkspace;

  destroyOnExit(): this;

  distanceBands(...fractions: number[]): this;

  elevationRange(min: number, max: number): this;

  hideOnExit(): this;

  linkedTo(name: string, yOffset?: number): this;

  linkTo(name: string, yOffset?: number): this;

  lod(config: WorldElementLodConfig): this;

  lodBoundaries(...fractions: number[]): this;

  maxElevation(value: number): this;

  minElevation(value: number): this;

  notOnSemantic(tag: string | readonly string[]): this;

  onSemantic(tag: string | readonly string[]): this;

  persistOnExit(): this;

  recycle(policy: WorldElementRecyclePolicy): this;

  requiringSemantic(tag: string | readonly string[]): this;

  toDeclaration(): WorldElementDeclaration;

  withOptions(options: Partial<WorldElementEntityOptions>): this;

  constructor(workspace: TWorkspace, target: WorldElementWorkspaceTarget, name: string);

  countPerChunk(count: number): this;

  model(model: string): this;

  models(...models: string[]): this;

  physics(enabled?: boolean): this;

  scaleRange(min: number, max: number): this;

  skipUnderwater(enabled?: boolean): this;

  surface(enabled?: boolean): this;

  yOffset(offset: number): this;

}

type WorldFixedTickDriverKind = "stopped" | "deadline" | "presentation";

interface WorldFixedTickOperationalState {

  readonly authoritativeTickNumber: number;

  readonly driverKind: WorldFixedTickDriverKind;

  readonly nextTickDeadlineMs: number;

  readonly overdueTickCount: number;

  readonly paused: boolean;

  readonly retainedWallDebtMs: number;

  readonly running: boolean;

  readonly simulationLagMs: number;

}

declare class WorldGrassElementWorkspaceBuilder<TWorkspace> {

  alwaysLive(): this;

  apply(): TWorkspace;

  destroyOnExit(): this;

  distanceBands(...fractions: number[]): this;

  elevationRange(min: number, max: number): this;

  hideOnExit(): this;

  linkedTo(name: string, yOffset?: number): this;

  linkTo(name: string, yOffset?: number): this;

  lod(config: WorldElementLodConfig): this;

  lodBoundaries(...fractions: number[]): this;

  maxElevation(value: number): this;

  minElevation(value: number): this;

  notOnSemantic(tag: string | readonly string[]): this;

  onSemantic(tag: string | readonly string[]): this;

  persistOnExit(): this;

  recycle(policy: WorldElementRecyclePolicy): this;

  requiringSemantic(tag: string | readonly string[]): this;

  toDeclaration(): WorldElementDeclaration;

  withOptions(options: Partial<WorldElementGrassCarpetOptions>): this;

  constructor(workspace: TWorkspace, target: WorldElementWorkspaceTarget, name: string);

  balanced(): this;

  blade(width: number, height: number, heightVariation?: number): this;

  color(base: number, tip?: number, shade?: number): this;

  colors(colors: readonly [number, number] | readonly [number, number, number]): this;

  configureMaterial(options: WaveGrassMaterialOptions): this;

  coverage(size: number): this;

  denseLikeInfiniteWorld(): this;

  denseNearCamera(): this;

  detail(bladesPerAxis: number): this;

  inRange(range: PlacementRangeInputSet): this;

  lodProfile(profile: WorldGrassLodProfile): this;

  lush(): this;

  material(): WaveMaterialInput<"grass">;

  notInRange(range: PlacementRangeInputSet): this;

  NotInRange(range: PlacementRangeInputSet): this;

  performanceFirst(): this;

  sampleResolution(resolution: number): this;

  seed(seed: number): this;

  urbanPerformance(): this;

  useMaterial(material: WaveMaterialInput<"grass">): this;

  wind(strength: number, scale?: number, speed?: number): this;

  windFromAtmosphere(intensity?: number): this;

  yOffset(offset: number): this;

}

type WorldGrassLodProfile = "lush" | "balanced" | "performance";

type WorldPathSurfaceAuthoringInput = WavePathSurfaceAuthoringInput;

type WorldPoint = Vector3 & { readonly [WAVE_SCREEN_COORDINATE_SPACE]: "worldPoint"; }

declare class WorldPopulateWorkspaceBuilder<TWorkspace> {

  constructor(_workspace: TWorkspace, _target: WorldElementWorkspaceTarget);

  custom(name: string): WorldCustomElementWorkspaceBuilder<TWorkspace>;

  entity(name: string): WorldEntityElementWorkspaceBuilder<TWorkspace>;

  get(name: string): WorldElementDeclaration | null;

  grass(name: string): WorldGrassElementWorkspaceBuilder<TWorkspace>;

  remove(name: string): TWorkspace;

  scatter(name: string): WorldScatterElementWorkspaceBuilder<TWorkspace>;

  surface(name: string): WorldSurfaceElementWorkspaceBuilder<TWorkspace>;

  water(name: string): WorldWaterElementWorkspaceBuilder<TWorkspace>;

}

declare class WorldScatterElementWorkspaceBuilder<TWorkspace> {

  alwaysLive(): this;

  apply(): TWorkspace;

  destroyOnExit(): this;

  distanceBands(...fractions: number[]): this;

  elevationRange(min: number, max: number): this;

  hideOnExit(): this;

  linkedTo(name: string, yOffset?: number): this;

  linkTo(name: string, yOffset?: number): this;

  lod(config: WorldElementLodConfig): this;

  lodBoundaries(...fractions: number[]): this;

  maxElevation(value: number): this;

  minElevation(value: number): this;

  notOnSemantic(tag: string | readonly string[]): this;

  onSemantic(tag: string | readonly string[]): this;

  persistOnExit(): this;

  recycle(policy: WorldElementRecyclePolicy): this;

  requiringSemantic(tag: string | readonly string[]): this;

  toDeclaration(): WorldElementDeclaration;

  withOptions(options: Partial<WorldElementScatterOptions>): this;

  constructor(workspace: TWorkspace, target: WorldElementWorkspaceTarget, name: string);

  alignToNormal(enabled?: boolean): this;

  avoidUnderwater(enabled?: boolean): this;

  clustering(value: number): this;

  color(color: number): this;

  colorPalette(colors: number[]): this;

  colors(colors: number[]): this;

  countPerChunk(count: number): this;

  deforming(intent: WorldElementDeformationIntent): this;

  density(countPerChunk: number): this;

  densityNoise(scale: number, threshold: number): this;

  frustumBoundsRadius(radius: number): this;

  frustumCulling(radius: number): this;

  inRange(range: PlacementRangeInputSet): this;

  instancesPerTile(count: number): this;

  lodLevel(level: number, override: WorldElementScatterLodOverride): this;

  lodModels(levels: readonly WorldElementScatterLodOverride[]): this;

  lodPartitionGrid(grid: number): this;

  minSpacing(value: number): this;

  model(model: string | WaveModelInput): this;

  notInRange(range: PlacementRangeInputSet): this;

  NotInRange(range: PlacementRangeInputSet): this;

  part(part: WaveModelPartRef): this;

  partitionedLod(partitionSize?: number): this;

  partitionedLOD(partitionSize?: number): this;

  placeOnSurface(enabled?: boolean): this;

  randomScale(min: number, max: number): this;

  renderAs(model: string | WaveModelInput, options?: { readonly part?: WaveModelPartRef; }): this;

  scaleRange(min: number, max: number): this;

  scaleVariance(axis: "x" | "y" | "z", min: number, max: number): this;

  skipUnderwater(enabled?: boolean): this;

  slopeRange(min: number, max: number): this;

  slopeTransition(degrees: number): this;

  surface(enabled?: boolean): this;

  useLODModels(levels: readonly WorldElementScatterLodOverride[]): this;

  usePartitionedLOD(partitionSize?: number): this;

  yOffset(offset: number): this;

}

type WorldStreamingColliderConfig = WorldStreamingHeightfieldColliderConfig | WorldStreamingNoColliderConfig;

interface WorldStreamingHeightfieldColliderConfig {

  readonly cookMode?: WorldStreamingHeightfieldCookMode;

  readonly kind: "heightfield";

  readonly maxSamplesPerFrame?: number;

  readonly rebuildDebounceFrames?: number;

  readonly refreshExistingCollidersWhenSurfaceChanges?: boolean;

  readonly samplesPerTile?: number;

}

type WorldStreamingHeightfieldCookMode = "worker" | "mainThread";

interface WorldStreamingNoColliderConfig {

  readonly kind: "none";

}

interface WorldStreamingPhysicsConfig {

  readonly collider?: WorldStreamingColliderConfig;

  readonly enabled?: boolean;

  readonly maxBuildsPerFrame?: number;

  readonly nearRadiusTiles?: number;

}

declare class WorldSurfaceCourseElementWorkspaceBuilder<TWorkspace> {

  alwaysLive(): this;

  apply(): TWorkspace;

  destroyOnExit(): this;

  distanceBands(...fractions: number[]): this;

  elevationRange(min: number, max: number): this;

  from(surface: WorldPathSurfaceAuthoringInput): this;

  hideOnExit(): this;

  linkedTo(name: string, yOffset?: number): this;

  linkTo(name: string, yOffset?: number): this;

  lod(config: WorldElementLodConfig): this;

  lodBoundaries(...fractions: number[]): this;

  materialAsset(name: string): this;

  maxElevation(value: number): this;

  minElevation(value: number): this;

  notOnSemantic(tag: string | readonly string[]): this;

  onSemantic(tag: string | readonly string[]): this;

  persistOnExit(): this;

  recycle(policy: WorldElementRecyclePolicy): this;

  requiringSemantic(tag: string | readonly string[]): this;

  toDeclaration(): WorldElementDeclaration;

  withOptions(options: Partial<WorldElementSurfaceOptions>): this;

  constructor(workspace: TWorkspace, target: WorldElementWorkspaceTarget, name: string, defaults?: Partial<WorldElementSurfaceOptions>);

  material(material: WorldSurfaceMaterialInput): this;

  surface(material: WorldSurfaceMaterialInput): this;

  useMaterial(material: WorldSurfaceMaterialInput): this;

}

declare class WorldSurfaceElementWorkspaceBuilder<TWorkspace> {

  alwaysLive(): this;

  apply(): TWorkspace;

  destroyOnExit(): this;

  distanceBands(...fractions: number[]): this;

  elevationRange(min: number, max: number): this;

  hideOnExit(): this;

  linkedTo(name: string, yOffset?: number): this;

  linkTo(name: string, yOffset?: number): this;

  lod(config: WorldElementLodConfig): this;

  lodBoundaries(...fractions: number[]): this;

  maxElevation(value: number): this;

  minElevation(value: number): this;

  notOnSemantic(tag: string | readonly string[]): this;

  onSemantic(tag: string | readonly string[]): this;

  persistOnExit(): this;

  recycle(policy: WorldElementRecyclePolicy): this;

  requiringSemantic(tag: string | readonly string[]): this;

  toDeclaration(): WorldElementDeclaration;

  withOptions(options: Partial<WorldElementSurfaceOptions>): this;

  constructor(workspace: TWorkspace, target: WorldElementWorkspaceTarget, name: string);

  from(surface: WorldPathSurfaceAuthoringInput): WorldSurfaceCourseElementWorkspaceBuilder<TWorkspace>;

}

type WorldSurfaceMaterialInput = string | WaveMaterialInput;

type WorldSurfaceShape = "course";

interface WorldWaterCourseConfig {

  depth: number;

  meander?: WorldWaterCourseMeanderOptions;

  path?: WorldWaterCoursePoint[];

  surface?: WorldWaterCourseSurfaceConfig;

  width: number;

}

declare class WorldWaterCourseElementWorkspaceBuilder<TWorkspace> {

  alwaysLive(): this;

  apply(): TWorkspace;

  destroyOnExit(): this;

  distanceBands(...fractions: number[]): this;

  elevationRange(min: number, max: number): this;

  from(surface: WorldPathSurfaceAuthoringInput): this;

  hideOnExit(): this;

  linkedTo(name: string, yOffset?: number): this;

  linkTo(name: string, yOffset?: number): this;

  lod(config: WorldElementLodConfig): this;

  lodBoundaries(...fractions: number[]): this;

  materialAsset(name: string): this;

  maxElevation(value: number): this;

  minElevation(value: number): this;

  notOnSemantic(tag: string | readonly string[]): this;

  onSemantic(tag: string | readonly string[]): this;

  persistOnExit(): this;

  recycle(policy: WorldElementRecyclePolicy): this;

  requiringSemantic(tag: string | readonly string[]): this;

  toDeclaration(): WorldElementDeclaration;

  withOptions(options: Partial<WorldElementWaterOptions>): this;

  constructor(workspace: TWorkspace, target: WorldElementWorkspaceTarget, name: string, defaults?: Partial<WorldElementWaterOptions>);

  depth(depth: number): this;

  material(material: WaterSurfaceMaterialInput): this;

  surface(material: WaterSurfaceMaterialInput): this;

  useMaterial(material: WaterSurfaceMaterialInput): this;

}

interface WorldWaterCourseMeanderOptions {

  end: WorldWaterCoursePoint;

  margin?: number;

  meanderAmplitude?: number;

  meanderWaves?: number;

  noiseAmplitude?: number;

  noiseWaves?: number;

  seed?: number;

  segments?: number;

  start: WorldWaterCoursePoint;

}

interface WorldWaterCoursePoint {

  x: number;

  z: number;

}

interface WorldWaterCourseSampledRibbonSample {

  distance: number;

  flowDirection: { x: number; y: number; z: number; }

  position: { x: number; y: number; z: number; }

  width: number;

}

interface WorldWaterCourseSampledRibbonSource {

  kind: "sampledRibbon";

  revision: string;

  samples: readonly WorldWaterCourseSampledRibbonSample[];

}

interface WorldWaterCourseSurfaceConfig {

  cap?: "none" | "round" | "square";

  heightAboveRiverbed?: number;

  inset?: number;

  invertNormals?: boolean;

  level?: number;

  sampleSpacing?: number;

  source?: WorldWaterCourseSampledRibbonSource;

  tilePadding?: number;

  uScale?: number;

  uvMode?: "bounds" | "world";

  vScale?: number;

  width?: number;

}

declare class WorldWaterElementWorkspaceBuilder<TWorkspace> {

  alwaysLive(): this;

  apply(): TWorkspace;

  destroyOnExit(): this;

  distanceBands(...fractions: number[]): this;

  elevationRange(min: number, max: number): this;

  hideOnExit(): this;

  linkedTo(name: string, yOffset?: number): this;

  linkTo(name: string, yOffset?: number): this;

  lod(config: WorldElementLodConfig): this;

  lodBoundaries(...fractions: number[]): this;

  maxElevation(value: number): this;

  minElevation(value: number): this;

  notOnSemantic(tag: string | readonly string[]): this;

  onSemantic(tag: string | readonly string[]): this;

  persistOnExit(): this;

  recycle(policy: WorldElementRecyclePolicy): this;

  requiringSemantic(tag: string | readonly string[]): this;

  toDeclaration(): WorldElementDeclaration;

  withOptions(options: Partial<WorldElementWaterOptions>): this;

  constructor(workspace: TWorkspace, target: WorldElementWorkspaceTarget, name: string);

  body(patch?: Omit<WaveWaterBodyModelPatch, "id" | "level">): this;

  buoyancy(buoyancy: Partial<WaveWaterBuoyancyModel>): this;

  configureMaterial(options: WaveWaterMaterialAuthoringOptions): this;

  course(surface?: WorldPathSurfaceAuthoringInput): WorldWaterCourseElementWorkspaceBuilder<TWorkspace>;

  foam(foam: Partial<WaveWaterFoamModel>): this;

  foamDetail(foamDetail: Partial<WaveWaterSurfaceMaterialPolicy["foamDetail"]>): this;

  frameGraph(frameGraph: Partial<WaveWaterFrameGraphPolicy>): this;

  kind(kind: WaveWaterBodyKind): this;

  lake(): this;

  level(level: number): this;

  material(material: WaveMaterialInput<"water">): this;

  materialize(): WaveWaterBodyModel;

  normalDetail(normalDetail: Partial<WaveWaterSurfaceMaterialPolicy["normalDetail"]>): this;

  ocean(): this;

  opacity(alpha: number): this;

  optics(optics: NonNullable<WaveWaterBodyModelPatch["optics"]>): this;

  pond(): this;

  pool(): this;

  quality(quality: WaveWaterQuality): this;

  reflections(reflection: WaveWaterBodyModelPatch["reflection"]): this;

  reflectionTexture(asset: string | null): this;

  shoreline(shoreline: Partial<WaveWaterShorelineModel>): this;

  subdivisions(value: number): this;

  surface(material: WaveMaterialInput<"water">): this;

  surfaceFlow(flow: Partial<WaveWaterSurfaceMaterialPolicy["flow"]>): this;

  surfaceMaterial(surfaceMaterial: NonNullable<WaveWaterBodyModelPatch["surfaceMaterial"]>): this;

  toModel(): WaveWaterBodyModel;

  underwater(underwater: Partial<WaveWaterUnderwaterModel>): this;

  useMaterial(material: WaveMaterialInput<"water">): this;

  waterLevel(level: number): this;

  waves(waves: WaveWaterBodyModelPatch["waves"]): this;

  wind(speed: number, direction?: { x: number; y: number; }): this;

}

interface WorldWaterRegionConfig {

  surfaces: readonly WorldWaterRegionSurfaceConfig[];

}

interface WorldWaterRegionPoint {

  x: number;

  y: number;

  z: number;

}

interface WorldWaterRegionPolygonSource {

  componentId: string;

  holes?: readonly (readonly WorldWaterRegionPoint[])[];

  kind: "polygon";

  outline: readonly WorldWaterRegionPoint[];

  revision: string;

}

interface WorldWaterRegionSurfaceConfig {

  invertNormals?: boolean;

  source: WorldWaterRegionPolygonSource;

  uScale?: number;

  uvMode?: "bounds" | "world";

  vScale?: number;

}

type WorldWaterShape = "body" | "course" | "region";

interface XRAnchorConfig {

  persistent?: boolean;

  placement?: XRAnchorPlacement;

  scaleMode?: XRScaleMode;

}

interface XRAnchorState {

  anchorId: string | null;

  isAnchored: boolean;

}

interface XRFeatureConfig {

  anchorSystem: boolean;

  handTracking: boolean;

  hitTest: boolean;

  motionControllers: boolean;

  movement: boolean | MovementConfig;

  passthrough: boolean;

  planeDetection: boolean;

  pointerSelection: boolean;

  teleportation: boolean | TeleportationConfig;

}

interface XRGrabState {

  handedness: "left" | "right" | "none";

  ownerClientId: string | null;

  startedAtMs: number | null;

}

type XRHandedness = "left" | "right" | "none";

interface XRInteractableConfig {

  followRotation?: boolean;

  grabOffset?: Vector3Like;

  grabPoint?: Vector3Like;

  hapticIntensity?: number;

  modes?: XRInteractionMode[];

  nearInteractDistance?: number;

}

interface XRSessionConfig {

  autoEnter: boolean;

  features: XRFeatureConfig;

  floorHeight: number;

  mode: "immersive-vr" | "immersive-ar" | "inline";

  referenceSpace: "local-floor" | "bounded-floor" | "local" | "viewer" | "unbounded";

}

interface ActivePhysicsHumanoidConfig {

  readonly armSwingDegrees?: number;

  readonly bodyColor?: ColorInput;

  readonly driveStrength?: number;

  readonly equipmentMounts?: readonly WavePhysicalEquipmentMountDefinition<ActivePhysicsHumanoidEntityId>[];

  readonly footLift?: number;

  readonly poseJitterDegrees?: number;

  readonly poseJitterSeed?: number;

  readonly selfCollision?: WaveActivePhysicsRigSelfCollisionMode;

  readonly stepDuration?: WaveTimeSpanSpec;

  readonly stepReachDegrees?: number;

  readonly strideLength?: number;

}

type ActivePhysicsHumanoidEntityId = typeof WAVE_PHYSICAL_HUMANOID_MODEL_PARTS[keyof typeof WAVE_PHYSICAL_HUMANOID_MODEL_PARTS];

declare enum ActorDecisionState {

  Cancelled = "cancelled",

  CapabilityCompleted = "capabilityCompleted",

  ChoiceSelected = "choiceSelected",

  Completed = "completed",

  Failed = "failed",

  Idle = "idle",

  OutcomeReported = "outcomeReported",

  OutcomeTimedOut = "outcomeTimedOut",

  PreparingDecision = "preparingDecision",

  Queued = "queued",

  RunningCapability = "runningCapability",

  Speaking = "speaking",

  WaitingForDecision = "waitingForDecision",

  WaitingForOutcome = "waitingForOutcome",

}

declare function after(value: number, unit: WaveTimeUnit): WaveTimeRule;

declare function after(point: WaveTimePoint): WaveTimeRule;

declare function always(): WaveTimeRule;

declare const Animate = TransformVerbMode.Animate;type AudioSpatialPreset = typeof AudioSpatialPreset[keyof typeof AudioSpatialPreset];

declare const AudioSpatialPreset: { readonly Off: "off"; readonly Subtle: "subtle"; readonly Natural: "natural"; readonly Focused: "focused"; readonly Tight: "tight"; readonly LargeWorld: "largeWorld"; };

declare enum AudioSpeechState {

  Cancelled = "cancelled",

  Completed = "completed",

  Failed = "failed",

  GeneratingAudio = "generatingAudio",

  PreparingVoice = "preparingVoice",

  Queued = "queued",

  Ready = "ready",

  Speaking = "speaking",

}

interface AuroraState {

  angularWidth: number;

  azimuthDegrees: number;

  baseGlow: number;

  brightness: number;

  colorAccent: ColorInput;

  colorBottom: ColorInput;

  colorMix: number;

  colorTop: ColorInput;

  curtainFolds: number;

  elevationMax: number;

  elevationMin: number;

  enabled: boolean;

  pulsation: number;

  rayIntensity: number;

  speed: number;

}

declare enum BasinPreset {

  BasinChain = "basinChain",

  Caldera = "caldera",

  CollapsedSinkhole = "collapsedSinkhole",

  DryLakebed = "dryLakebed",

  ErodedCrater = "erodedCrater",

  FreshCrater = "freshCrater",

  MarshLakebed = "marshLakebed",

  NaturalBasin = "naturalBasin",

  SaltFlat = "saltFlat",

  SmoothSinkhole = "smoothSinkhole",

  SoftBowl = "softBowl",

  SteepBowl = "steepBowl",

}

declare function before(point: WaveTimePoint): WaveTimeRule;

declare function between(start: WaveTimePoint, end: WaveTimePoint): WaveTimeRule;

declare enum BodyPart {

  Chest = "Chest",

  Head = "Head",

  Hips = "Hips",

  LeftFoot = "LeftFoot",

  LeftHand = "LeftHand",

  LeftIndexDistal = "LeftIndexDistal",

  LeftIndexIntermediate = "LeftIndexIntermediate",

  LeftIndexProximal = "LeftIndexProximal",

  LeftLittleDistal = "LeftLittleDistal",

  LeftLittleIntermediate = "LeftLittleIntermediate",

  LeftLittleProximal = "LeftLittleProximal",

  LeftLowerArm = "LeftLowerArm",

  LeftLowerLeg = "LeftLowerLeg",

  LeftMiddleDistal = "LeftMiddleDistal",

  LeftMiddleIntermediate = "LeftMiddleIntermediate",

  LeftMiddleProximal = "LeftMiddleProximal",

  LeftRingDistal = "LeftRingDistal",

  LeftRingIntermediate = "LeftRingIntermediate",

  LeftRingProximal = "LeftRingProximal",

  LeftShoulder = "LeftShoulder",

  LeftThumbDistal = "LeftThumbDistal",

  LeftThumbIntermediate = "LeftThumbIntermediate",

  LeftThumbProximal = "LeftThumbProximal",

  LeftToes = "LeftToes",

  LeftUpperArm = "LeftUpperArm",

  LeftUpperLeg = "LeftUpperLeg",

  Neck = "Neck",

  RightFoot = "RightFoot",

  RightHand = "RightHand",

  RightIndexDistal = "RightIndexDistal",

  RightIndexIntermediate = "RightIndexIntermediate",

  RightIndexProximal = "RightIndexProximal",

  RightLittleDistal = "RightLittleDistal",

  RightLittleIntermediate = "RightLittleIntermediate",

  RightLittleProximal = "RightLittleProximal",

  RightLowerArm = "RightLowerArm",

  RightLowerLeg = "RightLowerLeg",

  RightMiddleDistal = "RightMiddleDistal",

  RightMiddleIntermediate = "RightMiddleIntermediate",

  RightMiddleProximal = "RightMiddleProximal",

  RightRingDistal = "RightRingDistal",

  RightRingIntermediate = "RightRingIntermediate",

  RightRingProximal = "RightRingProximal",

  RightShoulder = "RightShoulder",

  RightThumbDistal = "RightThumbDistal",

  RightThumbIntermediate = "RightThumbIntermediate",

  RightThumbProximal = "RightThumbProximal",

  RightToes = "RightToes",

  RightUpperArm = "RightUpperArm",

  RightUpperLeg = "RightUpperLeg",

  Spine = "Spine",

  Spine1 = "Spine1",

  Spine2 = "Spine2",

  UpperChest = "UpperChest",

}

declare function buildColorPalettes(defs: { name: string; hexColors: number[]; }[]): ColorPalette[];

declare function buildCyberpunkReferenceEnvironment(myScene: WaveScene): CyberpunkReferenceEnvironmentHandles;

declare class CameraFollowViewBuilder {

  constructor(_camera: cmp_camera);

  apply(): cmp_camera;

  avoid(volume: CameraVolumeConstraintSource, options?: CameraConstraintOptions | number): cmp_camera;

  blendFollowViewChanges(options?: CameraFollowViewBlendOptions): this;

  following(target: TransformReferenceLike): this;

  from(direction: DirectionInput, distance: number): this;

  inFrameOf(target: TransformReferenceLike): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  keepAbove(surface: CameraHeightSurfaceSource, options?: CameraConstraintOptions | number): cmp_camera;

  lookingAtOrigin(): this;

  lookingAtVisualCenter(): this;

  snapFollowViewChanges(): this;

  stayInside(volume: CameraVolumeConstraintSource, options?: CameraStayInsideOptions | number): cmp_camera;

  tilted(degrees: number): this;

  trackingCinematically(options?: Partial<Extract<CameraTargetTrackingConfig, { kind: "cinematic"; }>>): this;

  trackingRigidly(): this;

  trackingSmoothly(smoothing?: number): this;

  withConstraint(constraint: FollowConstraint): this;

  withFocusOffset(offset: WavePointInput | TransformReferenceLike): this;

  withFocusOffset(x: number, y: number, z: number): this;

  withPointOffset(offset: WavePointInput | TransformReferenceLike): this;

  withPointOffset(x: number, y: number, z: number): this;

  withRigTransition(transition: CameraRigTransitionInput): this;

}

declare const CANONICAL_SDF_FONT_ASSETS: Readonly<{ Poppins_Regular: "Poppins-Regular.sdfAtlas"; Poppins_Medium: "Poppins-Medium.sdfAtlas"; }>;

interface CelestialBodyState {

  angularSize: number;

  brightness: number;

  color: ColorInput;

  craterDetail: number;

  glowIntensity: number;

  id: string;

  minElevation: number;

  orbitOffset: number;

}

interface CloudLayer {

  altitude: number;

  coverage: number;

  density: number;

  scale: number;

  thickness: number;

}

declare class cmp_2dInteractable<TOwner extends WaveEntity = WaveEntity> {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroy(): void;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: TOwner;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: TOwner);

  static readonly typeName = ComponentTypeName.Interactable2D;

  bindEnabledTo<S extends PropertyKey>(stateSource: WaveEntity<S>, enabledIn: S[]): this;

  bindTextTo<S extends PropertyKey>(stateSource: WaveEntity<S>, textMap: Partial<Record<S, string>>): this;

  bindVisibilityTo<S extends PropertyKey>(stateSource: WaveEntity<S>, visibleIn: S[]): this;

  clearAllCallbacks(): void;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  get destroyPriority(): number;

  hasCallbacks(): boolean;

  isHovered(): boolean;

  isMouseClickedOn(): boolean;

  isTouched(): boolean;

  off(handleOrName: CallbackHandle | string): boolean;

  offAll(): void;

  onDrag(callback: UI2DDragCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  onDragMove(options?: UI2DDragMoveOptions): UI2DDragMoveHandle<TOwner>;

  onDragMove(callback: UI2DDragMoveCallback<TOwner>, options?: UI2DDragMoveOptions): UI2DDragMoveHandle<TOwner>;

  triggerCanvasClick(x: number, y: number, clientId?: string, timestamp?: number): void;

  triggerCanvasClick(x: number, y: number, button: MouseButton, clientId?: string, timestamp?: number): void;

  triggerCanvasPointerDown(x: number, y: number, clientId?: string, timestamp?: number): void;

  triggerCanvasPointerDown(x: number, y: number, button: MouseButton, clientId?: string, timestamp?: number): void;

  triggerCanvasPointerDown(x: number, y: number, button: MouseButton, clientId: string | undefined, timestamp: number | undefined, screenX: number, screenY: number): void;

  triggerCanvasPointerMove(x: number, y: number, clientId?: string, timestamp?: number): void;

  triggerCanvasPointerMove(x: number, y: number, button: MouseButton, clientId?: string, timestamp?: number): void;

  triggerCanvasPointerMove(x: number, y: number, button: MouseButton, clientId: string | undefined, timestamp: number | undefined, screenX: number, screenY: number): void;

  triggerCanvasPointerUp(x: number, y: number, clientId?: string, timestamp?: number): void;

  triggerCanvasPointerUp(x: number, y: number, button: MouseButton, clientId?: string, timestamp?: number): void;

  triggerCanvasPointerUp(x: number, y: number, button: MouseButton, clientId: string | undefined, timestamp: number | undefined, screenX: number, screenY: number): void;

  triggerClick(clientId?: string, timestamp?: number): void;

  triggerClick(button: MouseButton, clientId?: string, timestamp?: number): void;

  triggerHolding(button?: MouseButton, x?: number, y?: number, heldTicks?: number, heldDurationMs?: number, clientId?: string, timestamp?: number): void;

  triggerHoverEnter(x?: number, y?: number, clientId?: string, timestamp?: number): void;

  triggerHoverExit(x?: number, y?: number, clientId?: string, timestamp?: number): void;

  triggerHovering(x?: number, y?: number, clientId?: string, timestamp?: number): void;

  triggerInput(text: string, clientId?: string, timestamp?: number): void;

  triggerPressed(button?: MouseButton, x?: number, y?: number, clientId?: string, timestamp?: number): void;

  triggerReleased(button?: MouseButton, x?: number, y?: number, clientId?: string, timestamp?: number): void;

  triggerSliderChange(value: number, clientId?: string, timestamp?: number): void;

  triggerSubmit(text: string, clientId?: string, timestamp?: number): void;

  triggerToggle(state: boolean, clientId?: string, timestamp?: number): void;

  triggerTouched(x?: number, y?: number, clientId?: string, timestamp?: number): void;

  whenBackClickedOn(callback: UI2DClickCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenBackHoldingOn(callback: UI2DHoldingCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenBackHoldingOn(callback: UI2DHoldingCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenBackPressedOn(callback: UI2DPressCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenBackReleasedOn(callback: UI2DReleaseCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenCanvasClicked(callback: UI2DCanvasClickCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenCanvasPointerDown(callback: UI2DCanvasPointerCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenCanvasPointerMove(callback: UI2DCanvasPointerCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenCanvasPointerUp(callback: UI2DCanvasPointerCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenClickedOn(callback: UI2DClickCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenForwardClickedOn(callback: UI2DClickCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenForwardHoldingOn(callback: UI2DHoldingCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenForwardHoldingOn(callback: UI2DHoldingCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenForwardPressedOn(callback: UI2DPressCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenForwardReleasedOn(callback: UI2DReleaseCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenHoldingOn(callback: UI2DHoldingCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenHoldingOn(callback: UI2DHoldingCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenHoverEnteredOn(callback: UI2DHoverCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenHoverExitedOn(callback: UI2DHoverCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenHoveringOn(callback: UI2DHoverCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenInputChanged(callback: UI2DInputCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenLeftClickedOn(callback: UI2DClickCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenLeftHoldingOn(callback: UI2DHoldingCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenLeftHoldingOn(callback: UI2DHoldingCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenLeftPressedOn(callback: UI2DPressCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenLeftReleasedOn(callback: UI2DReleaseCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenMiddleClickedOn(callback: UI2DClickCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenMiddleHoldingOn(callback: UI2DHoldingCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenMiddleHoldingOn(callback: UI2DHoldingCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenMiddlePressedOn(callback: UI2DPressCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenMiddleReleasedOn(callback: UI2DReleaseCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenPressedOn(callback: UI2DPressCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenReleasedOn(callback: UI2DReleaseCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenRightClickedOn(callback: UI2DClickCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenRightHoldingOn(callback: UI2DHoldingCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenRightHoldingOn(callback: UI2DHoldingCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<UI2DCallbackOptions, "holdThreshold">): CallbackHandle;

  whenRightPressedOn(callback: UI2DPressCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenRightReleasedOn(callback: UI2DReleaseCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenSliderChanged(callback: UI2DSliderCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenSubmit(callback: UI2DInputSubmitCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenToggled(callback: UI2DToggleCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

  whenTouchedOn(callback: UI2DTouchCallback<TOwner>, options?: UI2DCallbackOptions): CallbackHandle;

}

declare class cmp_3dInteractable<TOwner extends WaveEntity = WaveEntity> {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroy(): void;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: TOwner;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: TOwner);

  static readonly typeName = ComponentTypeName.Interactable3d;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  get destroyPriority(): number;

  disableMeshPicking(): this;

  enableMeshPicking(): this;

  getPickingTagMask(): bigint;

  isHovered(): boolean;

  isMouseClickedOn(): boolean;

  isTouched(): boolean;

  off(handleOrName: CallbackHandle | string): boolean;

  offAll(): void;

  onDrag(callback: InteractionDragCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  onDragMove(options?: InteractionDragMoveOptions): InteractionDragMoveHandle<TOwner>;

  onDragMove(callback: InteractionDragMoveCallback<TOwner>, options?: InteractionDragMoveOptions): InteractionDragMoveHandle<TOwner>;

  onMeshesChanged(): void;

  registerForPicking(): void;

  setPickingTagMask(tagMask: bigint): void;

  unregisterFromPicking(): void;

  whenBackClickedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenBackHoldingOn(callback: InteractionCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenBackHoldingOn(callback: InteractionCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenBackPressedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenBackReleasedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenClickedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenClickedOnMesh(callback: InteractionMeshCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenClickedOnPart(callback: InteractionPartCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenForwardClickedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenForwardHoldingOn(callback: InteractionCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenForwardHoldingOn(callback: InteractionCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenForwardPressedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenForwardReleasedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenHoldingOn(callback: InteractionCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenHoldingOn(callback: InteractionCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenHoverEnteredOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenHoverExitedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenHoveringOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenLeftClickedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenLeftHoldingOn(callback: InteractionCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenLeftHoldingOn(callback: InteractionCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenLeftPressedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenLeftReleasedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenMiddleClickedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenMiddleHoldingOn(callback: InteractionCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenMiddleHoldingOn(callback: InteractionCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenMiddlePressedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenMiddleReleasedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenPressedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenReleasedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenRightClickedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenRightHoldingOn(callback: InteractionCallback<TOwner>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenRightHoldingOn(callback: InteractionCallback<TOwner>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenRightPressedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenRightReleasedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

  whenTouchedOn(callback: InteractionCallback<TOwner>, options?: InteractionCallbackOptions): CallbackHandle;

}

declare abstract class cmp_animatorBase {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroy(): void;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity, componentName: string);

  animateTransformIntent(intent: TransformVerbIntent, config: TransformVerbAnimationConfig): TransitionLifecycleHandle<Record<string, number>>;

  animateTransformPoseTransition(intent: TransformPoseTransitionIntent, config: TransformVerbAnimationConfig): TransitionLifecycleHandle<Record<string, number>>;

  clearStateChangeCallbacks(): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  get currentTime(): number;

  get destroyPriority(): number;

  driveFromValue(options: WaveValueFromSourceOptions): TransitionLifecycleHandle<ValueDriveState>;

  driveValue(options: WaveValueDriveOptions): TransitionLifecycleHandle<ValueDriveState>;

  followPath(waypoints: FollowPathSource): FollowPathBuilder;

  followPath(waypoints: FollowPathSource, speed: number, options?: FollowPathOptions): FollowPathPlaybackHandle;

  isPaused(): boolean;

  isPlaying(): boolean;

  isStopped(): boolean;

  offStateChange(callback: AnimatorStateChangeCallback): this;

  onStateChange(callback: AnimatorStateChangeCallback, options?: WaveAuthoredCallbackOptions): this;

  get playState(): AnimationPlayState;

  setCurrentTime(time: number): void;

  setPlayState(state: AnimationPlayState): void;

  setSpeed(value: number): void;

  get speed(): number; set speed(value: number);

}

declare class cmp_audio {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity);

  static readonly typeName = ComponentTypeName.Audio;

  get activeInstrumentId(): string | null;

  addClip(name: string, clip: WaveAudioClip): void;

  analyzeBeats(clipNameOrPath: string, options?: WaveAudioBeatAnalysisOptions): WaveAudioBeatAnalysisBuilder;

  analyzeBus(busName?: string, options?: WaveAudioAnalysisOptions): WaveAudioAnalysisBuilder;

  analyzeClip(clipNameOrPath?: string, options?: WaveAudioAnalysisOptions): WaveAudioAnalysisBuilder;

  analyzeMicrophone(options?: WaveAudioAnalysisOptions): WaveAudioAnalysisBuilder;

  get browserSpeechSynthesisTTSConfig(): BrowserSpeechSynthesisTTSConfig | null;

  busName: string;

  configureImpactProfile(profile: WaveAudioImpactProfile): this;

  configureInstrument(config: WaveInstrumentConfig): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  createClip(name: string, path: string, options?: AudioOptions): WaveAudioClip;

  get currentClipName(): string | undefined;

  destroy(): void;

  get destroyPriority(): number;

  get elevenLabsTTSConfig(): ElevenLabsTTSConfig | null;

  getBoundAudioClip(name: string): BoundAudioClipEntry | undefined;

  getClip(name: string): WaveAudioClip | undefined;

  getImpactProfile(id: string): WaveAudioImpactProfile | undefined;

  getInstrumentConfig(id: string): WaveInstrumentConfig | undefined;

  isSpatial: boolean;

  get localNeuralTTSConfig(): WaveLocalNeuralTTSConfig | null;

  noteOff(midiNote: number): this;

  noteOn(midiNote: number, options?: WaveNoteOnOptions): this;

  onError(callback: WaveSpeechErrorCallback, options?: WaveAuthoredCallbackOptions): this;

  onSpeechEnd(callback: WaveSpeechCallback, options?: WaveAuthoredCallbackOptions): this;

  onSpeechLoadProgress(callback: WaveSpeechLoadProgressCallback, options?: WaveAuthoredCallbackOptions): this;

  onSpeechStart(callback: WaveSpeechCallback, options?: WaveAuthoredCallbackOptions): this;

  pause(): boolean;

  pianoKeyOff(keyIndex1to88: number): this;

  pianoKeyOn(keyIndex1to88: number, options?: WaveNoteOnOptions): this;

  get pitch(): number; set pitch(value: number);

  play(clipNameOrPath: string, loopOrOptions?: boolean | WaveAudioPlaybackOptions): void;

  playAbcScore(abcText: string, options?: WaveAbcPlaybackOptions): this;

  playImpact(profileId: string, input: WaveAudioImpactInput | number): this;

  playImpact(profileId: string, relativeImpactSpeed: number): this;

  playNote(midiNote: number, options?: WaveNoteOnOptions): this;

  playNote(midiNote: number, durationMs: number, options?: Omit<WaveNoteOnOptions, "durationMs">): this;

  playSound(clipNameOrPath: string, loopOrOptions?: boolean | WaveAudioPlaybackOptions): WaveAudioPlaybackHandle;

  prepareInstrument(instrumentId?: string | WaveInstrumentPreset): Promise<void>;

  registerClip(clip: WaveAudioClip): void;

  resume(): boolean;

  serialize(): SerializedCall[];

  setBus(busName: string): void;

  setPitch(value: number): void;

  setSpatial(enabled: boolean): void;

  setSpatialPreset(preset: AudioSpatialPreset): void;

  setVolume(value: number): void;

  get spatialPreset(): AudioSpatialPreset | null;

  speakText(text: string, options?: WaveSpeakTextOptions): WaveSpeechPlaybackHandle;

  get speechFxConfig(): WaveSpeechFxConfig | null;

  speechState(): AudioSpeechState | null;

  stop(): void;

  stopNote(midiNote: number): this;

  stopScorePlayback(): this;

  get ttsFallbackProviders(): readonly WaveTTSProvider[];

  get ttsProvider(): WaveTTSProvider | null;

  get ttsSpeechConcurrency(): WaveTTSSpeechConcurrency;

  useAudioGraph(graphId: string | AssetRef<"audio"> | null, busName?: string): this;

  useInstrument(id: string | WaveInstrumentPreset | null, revision?: string): this;

  useSpatialPreset(preset: AudioSpatialPreset): this;

  useTTS(backend: WaveTTSBackend): this;

  get volume(): number; set volume(value: number);

}

declare class cmp_camera {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity);

  static readonly typeName = ComponentTypeName.Camera;

  activate(): this;

  activateView(): this;

  applyAnimatedCameraFovSample(fov: number): void;

  applyAnimatedCameraLookAtOffsetSample(offset: Vector3): void;

  applyAnimatedCameraOffsetSample(offset: Vector3): void;

  applyAnimatedCameraZoomSample(zoom: number): void;

  avoid(volume: CameraVolumeConstraintSource, options?: CameraConstraintOptions | number): this;

  blendFollowViewChanges(options?: CameraFollowViewBlendOptions): this;

  blendOwnerTransformViewChanges(options?: CameraFollowViewBlendOptions): this;

  get cameraConstraints(): readonly CameraConstraintConfig[];

  get cameraId(): string | null;

  get cameraKind(): CameraKind | null;

  centerAtECEF(center: Vec3Like): this;

  centerAtECEF(x: number, y: number, z: number): this;

  centerAtLatLon(latitudeDegrees: number, longitudeDegrees: number, altitudeMeters?: number): this;

  clearCameraConstraints(): this;

  controlAsGeospatial(input?: GeospatialCameraControlInput): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  deactivate(): this;

  destroy(): void;

  get destroyPriority(): number;

  disableOrbit(): this;

  enableOrbit(options?: OrbitOptions): this;

  get far(): number;

  get focusPoint(): CameraFocusPoint;

  get followConstraint(): FollowConstraint;

  followFreeAll(): this;

  followFrom(direction: Vector3 | DirectionInput, distance: number, angleDeg?: number): this;

  followOnAxis(axis: Direction): this;

  followOnPlane(plane: WavePlane): this;

  followView(): CameraFollowViewBuilder;

  get followViewConfig(): CameraFollowViewConfig;

  get fov(): number;

  get geospatialConfig(): GeospatialCameraControlConfig;

  getCameraData(): { position: Vector3; lookDirection: Vector3; fov: number; zoom: number; }

  getCameraLookAt(): Vector3;

  getCameraLookDirection(): Vector3;

  getCameraPosition(): Vector3;

  inFrameOf(target: TransformReferenceLike): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  get isActive(): boolean;

  get isOrbitEnabled(): boolean;

  get isPossessing(): boolean;

  keepAbove(surface: CameraHeightSurfaceSource, options?: CameraConstraintOptions | number): this;

  get layerMask(): number;

  get lookAtOffset(): Vector3;

  lookingAtOrigin(): this;

  lookingAtVisualCenter(): this;

  get near(): number;

  get nearAuto(): CameraNearAutoConfig | null;

  get offset(): Vector3;

  get offsetFrame(): CameraFollowOffsetFrame;

  orbitFrom(input: GeospatialCameraOrbitInput): this;

  orbitFrom(radius: number, yawRadians?: number, pitchRadians?: number): this;

  get orthoSize(): number;

  possess(cameraId?: string): this;

  get projection(): CameraProjection;

  release(): this;

  replaceCameraConstraints(constraints: readonly CameraConstraintConfig[]): this;

  get rigDirectionBlend(): CameraRigDirectionBlend;

  get rigTransition(): CameraRigTransitionConfig;

  setCameraLookAt(target: WavePointInput): this;

  setCameraLookAt(x: number, y: number, z: number): this;

  setCameraLookDirection(direction: Vector3 | DirectionInput): this;

  setCameraLookDirection(x: number, y: number, z: number): this;

  setCameraPosition(position: WavePointInput): this;

  setCameraPosition(x: number, y: number, z: number): this;

  setFar(far: number): this;

  setFollowView(input: CameraFollowViewInput): this;

  setFov(fov: number): this;

  setFov(fov: number, mode: typeof Snapshot): WavePropertySnapshot;

  setFov(fov: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  setGeospatialControls(settings: GeospatialCameraControlSettings): this;

  setLayerMask(mask: number): this;

  setLookAtOffset(offset: WavePointInput | TransformReferenceLike): this;

  setLookAtOffset(offset: WavePointInput | TransformReferenceLike, mode: typeof Snapshot): WavePropertySnapshot;

  setLookAtOffset(offset: WavePointInput | TransformReferenceLike, mode: typeof Animate): WavePropertyAnimationBuilder;

  setLookAtOffset(x: number, y: number, z: number): this;

  setNear(near: number): this;

  setNearAuto(options?: CameraNearAutoOptions): this;

  setOffset(offset: WavePointInput | TransformReferenceLike): this;

  setOffset(offset: WavePointInput | TransformReferenceLike, mode: typeof Snapshot): WavePropertySnapshot;

  setOffset(offset: WavePointInput | TransformReferenceLike, mode: typeof Animate): WavePropertyAnimationBuilder;

  setOffset(x: number, y: number, z: number): this;

  setOrbitTarget(target: WavePointInput, options?: OrbitTargetOptions): this;

  setOrthoSize(size: number): this;

  setProjection(projection: CameraProjection): this;

  setRigDirectionBlend(blend: CameraRigDirectionBlend): this;

  setViewport(viewport: CameraViewport): this;

  setZoom(zoom: number): this;

  setZoom(zoom: number, mode: typeof Snapshot): WavePropertySnapshot;

  setZoom(zoom: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  snapFollowViewChanges(): this;

  snapOwnerTransformViewChanges(): this;

  stayInside(volume: CameraVolumeConstraintSource, options?: CameraStayInsideOptions | number): this;

  get targetTracking(): CameraTargetTrackingConfig;

  trackingCinematically(options?: Partial<Extract<CameraTargetTrackingConfig, { kind: "cinematic"; }>>): this;

  trackingRigidly(): this;

  trackingSmoothly(smoothing?: number): this;

  get viewport(): CameraViewport;

  withFocusOffset(offset: WavePointInput | TransformReferenceLike): this;

  withFocusOffset(x: number, y: number, z: number): this;

  withPointOffset(offset: WavePointInput | TransformReferenceLike): this;

  withPointOffset(x: number, y: number, z: number): this;

  withRigTransition(transition: CameraRigTransitionInput): this;

  get zoom(): number;

}

declare class cmp_decal {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  destroy(): void;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity, config?: DecalOptions);

  static readonly typeName = ComponentTypeName.Decal;

  get albedoTexture(): string;

  get albedoTint(): unknown;

  get angleFade(): number;

  get angleFadeCos(): number;

  get blendMode(): DecalBlendMode;

  get destroyPriority(): number;

  get emissiveIntensity(): number;

  get glowColor(): unknown;

  get hasAlbedo(): boolean;

  get hasNormal(): boolean;

  get height(): number;

  get isDirty(): boolean;

  get layerMask(): number;

  get length(): number;

  markClean(): void;

  markDirty(): void;

  get mask(): DecalMaskMode;

  get maskFeather(): number;

  get maskMode(): number;

  matchesReceiverMask(receiverMask: number): boolean;

  get metallicMultiplier(): number;

  get normalBlendMode(): DecalNormalBlendMode;

  get normalTexture(): string;

  get opacity(): number;

  get priority(): number;

  get roughnessMultiplier(): number;

  setAlbedoTexture(texturePath: string): this;

  setAlbedoTint(color: ColorInput): this;

  setAngleFade(degrees: number): this;

  setBlendMode(mode: DecalBlendMode): this;

  setDecalTextures(textures: { albedo?: string; normal?: string; }): this;

  setEmissiveIntensity(value: number): this;

  setGlowColor(color: ColorInput | null): this;

  setLayerMask(mask: number): this;

  setMask(v: DecalMaskMode): this;

  setMaskFeather(v: number): this;

  setMetallicMultiplier(value: number): this;

  setNormalBlendMode(mode: DecalNormalBlendMode): this;

  setNormalTexture(texturePath: string): this;

  setOpacity(value: number): this;

  setPriority(value: number): this;

  setRoughnessMultiplier(value: number): this;

  setSize(x: number, y: number, z: number): this;

  setUVOffset(x: number, y: number): this;

  setUVRotation(degrees: number): this;

  get uvOffsetX(): number;

  get uvOffsetY(): number;

  get uvRotation(): number;

  get uvRotationRadians(): number;

  get width(): number;

}

declare class cmp_environment {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroy(): void;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity);

  static readonly isSingleton = true;

  static readonly typeName = ComponentTypeName.Environment;

  addCelestialBody(body: Partial<CelestialBodyState>): this;

  clearCelestialBodies(): this;

  clearDirty(): void;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  get destroyPriority(): number;

  disableAurora(): this;

  disableGlobalIllumination(): this;

  disablePhysicalAtmosphere(): this;

  disableProceduralSky(): this;

  disableStarField(): this;

  disableTimeOfDay(): this;

  disableVolumetricClouds(): this;

  disableVolumetricFog(): this;

  getTimeOfDay(): Readonly<TimeOfDayState> | null;

  getTimeOfDayHours(): number;

  get isDirty(): boolean;

  serialize(): SerializedCall[];

  setAmbient(color: number, intensity?: number): this;

  setAurora(config?: Partial<Omit<AuroraState, "enabled">>): this;

  setBackgroundColor(color: number): this;

  setCelestialBodies(bodies: Partial<CelestialBodyState>[]): this;

  setCubeBackground(backgroundTexture: string, iblTexture: string, iblIntensity?: number, size?: number, center?: Vector3Like, backgroundIntensity?: number): this;

  setCubeSkybox(backgroundTexture: string, iblTexture: string, iblIntensity?: number, visibleSky?: boolean, backgroundIntensity?: number, size?: number): this;

  setEnvironmentIntensity(intensity: number): this;

  setFog(mode: FogMode, color: number, density?: number, start?: number, end?: number): this;

  setGlobalIllumination(config?: GlobalIlluminationConfig | null): this;

  setIBL(texture: string, intensity?: number): this;

  setIBLIntensity(intensity: number): this;

  setIndirectLighting(config?: GlobalIlluminationConfig): this;

  setMainLight(direction: Vector3Like, color?: number, intensity?: number, shadowEnabled?: boolean, shadowIntensity?: number, shadowDistance?: number, shadowCascades?: WaveShadowCascadeOptions | false, shadowUpdate?: WaveShadowUpdatePolicy): this;

  setPhysicalAtmosphere(config?: PhysicalAtmosphereConfig): this;

  setProceduralSky(config?: Partial<Omit<ProceduralSkyState, "enabled">>): this;

  setSkyAlpha(alpha: number): this;

  setSkybox(texture: string, fovMultiplier?: number, intensity?: number, size?: number, alpha?: number, rotation?: number): this;

  setSkyBrightness(intensity: number): this;

  setSkyRotation(rotation: number): this;

  setStarField(config?: Partial<Omit<StarFieldState, "enabled">>): this;

  setStreamingFog(policy: WaveStreamingFogPolicy | null | undefined): this;

  setTimeOfDay(config?: Partial<Omit<TimeOfDayState, "enabled">>): this;

  setTimeOfDayHours(timeHours: number): this;

  setVolumetricClouds(config?: VolumetricCloudSetConfig): this;

  setVolumetricFog(config?: Partial<VolumetricFogState>): this;

  setWeather(type: "none" | "rain" | "snow", intensity?: number, followCamera?: boolean): this;

  startRain(intensity?: number): this;

  startSnow(intensity?: number): this;

  get state(): EnvironmentState;

  stopWeather(): this;

  useSkyTexture(texture: string): this;

  get weather(): "none" | "rain" | "snow";

}

declare class cmp_fx {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity);

  static readonly typeName = ComponentTypeName.FX;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  destroy(): void;

  get destroyPriority(): number;

  drainPendingEvents(): FxQueuedEvent[];

  getFxState(): Readonly<FxStateSnapshot>;

  serialize(): SerializedCall[];

  setFxState(state: FxStateSnapshot): this;

  triggerEvent(instanceId: FxInstanceId, eventName: string, payload?: Record<string, FxValue>): void;

}

declare class cmp_kinematicController<TOwner extends WaveEntity = WaveEntity> {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroy(): void;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: TOwner;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: TOwner);

  static readonly typeName = ComponentTypeName.KinematicController;

  get acceleration(): number;

  addExternalAngularVelocity(delta: Vector3Like | DirectionInput): this;

  addExternalAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): this;

  addExternalVelocity(delta: Vector3Like | DirectionInput): this;

  addExternalVelocity(direction: Vector3Like | DirectionInput, speed: number): this;

  get airControlMultiplier(): number;

  get airLinearDamping(): number;

  get angularDamping(): number;

  applyAngularImpulse(impulse: Vector3Like | DirectionInput): this;

  applyAngularImpulse(axis: Vector3Like | DirectionInput, strength: number): this;

  applyForce(force: Vector3Like | DirectionInput): this;

  applyForce(direction: Vector3Like | DirectionInput, strength: number): this;

  applyImpulse(impulse: Vector3Like | DirectionInput): this;

  applyImpulse(direction: Vector3Like | DirectionInput, strength: number): this;

  applyTorque(torque: Vector3Like | DirectionInput): this;

  applyTorque(x: number, y: number, z: number): this;

  applyTorque(axis: Vector3Like | DirectionInput, strength: number): this;

  autoFitCapsule(): this;

  get autoFitEnabled(): boolean;

  avoidCollisionByTag(tag: string, ...tags: string[]): this;

  avoidCollisionByTag(tags: readonly string[]): this;

  avoidCollisionWith(...targets: (wave3DObject | readonly wave3DObject[])[]): this;

  get baseSpeed(): number;

  get boxSize(): Vector3;

  get capsuleCenterOffset(): Vector3;

  get capsuleHeight(): number;

  get capsuleRadius(): number;

  checkSupport(direction?: Vector3Like | DirectionInput, deltaTime?: number): SurfaceInfo | null;

  clearConstantForce(name?: string): this;

  clearConstantForces(): this;

  clearConstantTorque(name?: string): this;

  clearConstantTorques(): this;

  clearExternalAngularVelocity(): this;

  clearExternalVelocity(): this;

  clearIntent(): void;

  climbsStepsUpTo(height: number): this;

  get colliderShapeKind(): KinematicColliderShapeKind;

  get collisionGroup(): number;

  get collisionMask(): number;

  get config(): KinematicConfig;

  get constantForces(): KinematicConstantForceEntry[];

  get constantTorques(): KinematicConstantTorqueEntry[];

  get contactCount(): number;

  get contactEndGraceSubsteps(): number;

  get contactingBodies(): cmp_physicsBody[];

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  get currentIntent(): MovementIntent | null;

  get destroyPriority(): number;

  disableContactMonitor(): this;

  get dynamicFriction(): number;

  editConstantForce(name: string): WaveKinematicConstantForceBuilder<this>;

  editConstantTorque(name: string): WaveKinematicConstantTorqueBuilder<this>;

  get effectiveScale(): Vector3;

  enableCollisionByTag(tag: string, ...tags: string[]): this;

  enableCollisionByTag(tags: readonly string[]): this;

  enableCollisionWith(...targets: (wave3DObject | readonly wave3DObject[])[]): this;

  enableContactMonitor(options?: ContactMonitorOptions): this;

  get externalAngularVelocity(): SerializableVector3;

  get externalVelocity(): SerializableVector3;

  get footOffset(): number;

  forEachContactingBody(callback: (body: cmp_physicsBody) => void): this;

  get forwardDirection(): SerializableVector3;

  get friction(): number;

  get gravityFactor(): number;

  hasConstantForce(name: string): boolean;

  hasConstantTorque(name: string): boolean;

  inFrameOf(target: TransformReferenceLike): WaveKinematicFrameScope<this>;

  inLocalFrame(): WaveKinematicFrameScope<this>;

  inParentFrame(depth?: number): WaveKinematicFrameScope<this>;

  inWorldFrame(): WaveKinematicFrameScope<this>;

  isContactMonitorEnabled(): boolean;

  isGrounded(): boolean;

  isInContactWith(target: wave3DObject): boolean;

  isJumping(): boolean;

  isSliding(): boolean;

  get jumpVelocity(): number;

  get keepContactTolerance(): number;

  get keepDistance(): number;

  get linearDamping(): number;

  get mass(): number;

  get maxAcceleration(): number;

  get maxCastIterations(): number;

  get maxContactsReported(): number;

  get maxSlopeAngle(): number;

  get maxStepHeight(): number;

  moveWithCollisions(displacement: Vector3Like | DirectionInput): this;

  moveWithCollisions(x: number, y: number, z: number): this;

  moveWithCollisions(direction: Vector3Like | DirectionInput, distance: number): this;

  onAirborne(callback: CharacterEventCallback, options?: WaveAuthoredCallbackOptions): () => void;

  onContact(callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactBegin(callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactBeginByTag(tagOrTags: string | readonly string[], callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactBeginWith(target: wave3DObject | readonly wave3DObject[], callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactByTag(tagOrTags: string | readonly string[], callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactContinue(callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactContinueByTag(tagOrTags: string | readonly string[], callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactContinueWith(target: wave3DObject | readonly wave3DObject[], callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactEnd(callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactEndByTag(tagOrTags: string | readonly string[], callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactEndWith(target: wave3DObject | readonly wave3DObject[], callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactWith(target: wave3DObject | readonly wave3DObject[], callback: KinematicContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onEvent(event: CharacterEventType, callback: CharacterEventCallback, options?: WaveAuthoredCallbackOptions): () => void;

  onJumpStarted(callback: CharacterEventCallback, options?: WaveAuthoredCallbackOptions): () => void;

  onLanded(callback: CharacterEventCallback, options?: WaveAuthoredCallbackOptions): () => void;

  onScaleChanged(newScale: Vector3): void;

  onTransformChanged(change?: { positionChanged?: boolean; rotationChanged?: boolean; physicsMotion?: "direct" | "animated"; }): void;

  onTriggerEnter(callback: TriggerEventCallback, options?: WaveAuthoredCallbackOptions): () => void;

  onTriggerExit(callback: TriggerEventCallback, options?: WaveAuthoredCallbackOptions): () => void;

  onVisualBoundsChanged(): void;

  get penetrationRecoverySpeed(): number;

  get position(): SerializableVector3;

  processPostPhysicsStep(deltaTime: number): void;

  processPrePhysicsStep(deltaTime: number, gravity: Vector3, synchronizeAuthoredPose?: boolean): void;

  pushesDynamicBodies(strength: number): this;

  get pushStrength(): number;

  rebuildCharacterController(): void;

  requestJump(): void;

  rotateYaw(radians: number): void;

  rotateYawDegrees(degrees: number): void;

  scaleCapsuleAlongAxis(axis: Direction, factor: number): this;

  setAirControlMultiplier(value: number): this;

  setAngularDamping(damping: number): this;

  setBaseSpeed(value: number): this;

  setCapsuleCenterOffset(offset: Vector3Like): this;

  setCapsuleHeight(value: number): this;

  setCapsuleRadius(value: number): this;

  setCollisionGroup(value: number): this;

  setCollisionMask(value: number): this;

  setConfig(config: Partial<KinematicConfig>): this;

  setConstantForce(name: string, config: KinematicConstantForceConfig): this;

  setConstantForce(name: string, force: Vector3Like | DirectionInput, options?: KinematicConstantInfluenceOptions): this;

  setConstantForce(name: string, direction: Vector3Like | DirectionInput, strength: number, options?: KinematicConstantInfluenceOptions): this;

  setConstantTorque(name: string, config: KinematicConstantTorqueConfig): this;

  setConstantTorque(name: string, torque: Vector3Like | DirectionInput, options?: KinematicConstantInfluenceOptions): this;

  setConstantTorque(name: string, axis: Vector3Like | DirectionInput, strength: number, options?: KinematicConstantInfluenceOptions): this;

  setContactEndGraceSubsteps(substeps: number): this;

  setCrouchMultiplier(multiplier: number): this;

  setDirectionalSpeedScales(config: { reverse?: number; strafe?: number; ascend?: number; descend?: number; }): this;

  setDynamicFriction(value: number): this;

  setExternalAngularDamping(damping: number): this;

  setExternalAngularVelocity(velocity: Vector3Like | DirectionInput): this;

  setExternalAngularVelocity(x: number, y: number, z: number): this;

  setExternalDamping(grounded: number, airborne?: number): this;

  setExternalVelocity(velocity: Vector3Like | DirectionInput): this;

  setExternalVelocity(x: number, y: number, z: number): this;

  setFootOffset(value: number | null): this;

  setFriction(value: number): this;

  setGravityFactor(factor: number): this;

  setIntent(intent: MovementIntent): void;

  setJumpVelocity(value: number): this;

  setLinearDamping(damping: number): this;

  setMass(value: number): this;

  setMaxContactsReported(maxContacts: number): this;

  setMaxSlopeAngle(degrees: number): this;

  setMaxStepHeight(value: number): this;

  setPushStrength(value: number): this;

  setSprintMultiplier(multiplier: number): this;

  setStaticFriction(value: number): this;

  setUpVector(up: Vector3Like | DirectionInput): this;

  setYaw(radians: number): void;

  get state(): KinematicState;

  get staticFriction(): number;

  syncTransformFromPhysics(): void;

  teleport(position: WavePointInput, rotation?: QuaternionLike, preserveVelocity?: boolean): void;

  updateFromPhysics(deltaTime: number): void;

  get upVector(): SerializableVector3;

  useBoxCollider(width: number, height: number, depth: number): this;

  useCapsuleCollider(radius: number, height: number): this;

  useKinematicBody(): this;

  get velocity(): SerializableVector3;

  withAirJump(count: number): this;

  withCoyoteTime(duration: WaveTimeSpan): this;

  withCoyoteTime(value: number, unit: WaveTimeUnit): this;

  get yaw(): number;

}

declare class cmp_light {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity, defaultOptions?: LightRuntimeOptions);

  static readonly typeName = ComponentTypeName.Light;

  applyProjectorFitIntent(intent: LightProjectorFitIntent): this;

  get area(): LightAreaFacade;

  get beam(): LightBeamFacade;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  destroy(): void;

  get destroyPriority(): number;

  disableLight(): this;

  enableLight(): this;

  getLightState(): Readonly<LightState>;

  getTransform(): cmp_transform;

  hideAllHelpers(): this;

  get influence(): LightInfluenceFacade;

  get isLightEnabled(): boolean;

  isLightOn(): boolean;

  get lightAngle(): number;

  get lightColor(): unknown;

  get lightInnerAngle(): number;

  get lightIntensity(): number;

  get lightOffset(): Vector3;

  get lightRange(): number;

  get lightType(): LightType;

  get projector(): LightProjectorFacade;

  setAngle(angle: number): this;

  setAngle(angle: number, mode: typeof Snapshot): WavePropertySnapshot;

  setAngle(angle: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  setAreaLight(options?: LightAuthoringOptions): this;

  setColor(color: ColorInput): this;

  setColor(color: ColorInput, mode: typeof Snapshot): WavePropertySnapshot;

  setColor(color: ColorInput, mode: typeof Animate): WavePropertyAnimationBuilder;

  setDiffuse(color: ColorInput): this;

  setDirection(direction: DirectionInput | Vector3Like): this;

  setDirection(x: number, y: number, z: number): this;

  setDirectionalLight(options?: LightAuthoringOptions): this;

  setDirectionLabel(axis: Direction): this;

  setExponent(exponent: number): this;

  setFalloffType(falloff?: number): this;

  setGroundColor(color: ColorInput): this;

  setHemisphericLight(options?: LightAuthoringOptions): this;

  setInnerAngle(innerAngle?: number): this;

  setInnerAngle(innerAngle: number, mode: typeof Snapshot): WavePropertySnapshot;

  setInnerAngle(innerAngle: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  setIntensity(intensity: number): this;

  setIntensity(intensity: number, mode: typeof Snapshot): WavePropertySnapshot;

  setIntensity(intensity: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  setIntensityMode(mode?: number): this;

  setOffset(offset: WavePointInput | TransformReferenceLike): this;

  setOffset(offset: WavePointInput | TransformReferenceLike, mode: typeof Snapshot): WavePropertySnapshot;

  setOffset(offset: WavePointInput | TransformReferenceLike, mode: typeof Animate): WavePropertyAnimationBuilder;

  setOffset(x: number, y: number, z: number): this;

  setPointLight(options?: LightAuthoringOptions): this;

  setRadius(radius: number): this;

  setRange(range: number): this;

  setRange(range: number, mode: typeof Snapshot): WavePropertySnapshot;

  setRange(range: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  setShowAreaHelper(show: boolean): this;

  setShowConeHelper(show: boolean): this;

  setShowDirectionalHelper(show: boolean): this;

  setShowHelper(show: boolean): this;

  setShowHemisphereHelper(show: boolean): this;

  setShowRangeHelper(show: boolean): this;

  setSpecular(color: ColorInput): this;

  setSpotlight(options?: LightAuthoringOptions): this;

  setTarget(target: WavePointInput): this;

  setTarget(x: number, y: number, z: number): this;

  setType(type: LightType, options?: LightAuthoringOptions): this;

  get shadows(): LightShadowFacade;

  get shouldMaterializeBinding(): boolean;

  showAllHelpers(): this;

  get state(): Readonly<LightState>;

  toggle(): this;

  toggleLight(): this;

  turnOff(): this;

  turnOn(): this;

  get volume(): LightVolumeFacade;

}

declare class cmp_modelAnimator extends cmp_animatorBase {

  constructor(owner: WaveEntity);

  static readonly typeName = ComponentTypeName.ModelAnimator;

  addAnimationGroup(name: string, group: AnimationGroup, loop?: boolean, options?: { readonly ownsGroup?: boolean; }): void;

  addClip(clip: WaveAnimationClip): void;

  addClip(name: string, clip: WaveAnimationClip): void;

  addLocalAnimations(): void;

  addVATClip(name: string, vatAsset: VertexAnimationAsset, rangeName?: string, loop?: boolean): void;

  animateGeometryDeformIntent(intent: WaveGeometryDeformIntent, config: WaveGeometryDeformAnimationConfig): TransitionLifecycleHandle<WaveGeometryDeformAnimationState>;

  applySavedProceduralRuntime(clipName: string): boolean;

  attachGeneratedPlaybackGroup(name: string, group: AnimationGroup, loop?: boolean): void;

  clearGeometryDeformation(): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  createMeshMorphVertexAnimation(name: string, options: CreateMeshMorphVertexAnimationOptions): string;

  createVertexAnimation(name: string, options: CreateVertexAnimationOptions): string;

  get crossFadeDuration(): number; set crossFadeDuration(value: number);

  get currentClip(): string | undefined;

  destroy(): void;

  endEffector(endEffector: string, options?: WaveModelIKRuntimeSolveOptions): WaveEndEffectorScope;

  get geometryDeformPlan(): WaveGeometryGpuDeformPlan | null;

  getAllClips(): WaveAnimationClip[];

  getBool(name: string, defaultValue?: boolean): boolean;

  getClip(name: string): WaveAnimationClip | undefined;

  getClipNames(): string[];

  getClipPlaybackCallbacks(clipName: string): { readonly onStart?: () => void; readonly onUpdate?: () => void; readonly onComplete?: () => void; readonly onLoop?: () => void; } | undefined;

  getFloat(name: string, defaultValue?: number): number;

  getInt(name: string, defaultValue?: number): number;

  getProgress(): number;

  getRegisteredAnimationBinding(name: string): { readonly name: string; readonly ref: ExactAssetRef<"animation">; readonly handle: WaveSceneAnimationBinding; } | undefined;

  getTrigger(name: string): boolean;

  hasClip(name: string): boolean;

  isCurrentPlaybackController(controller: WaveAnimationController): boolean;

  isPaused(): boolean;

  isPlaying(): boolean;

  listEndEffectors(options?: WaveModelIKRuntimeSolveOptions): readonly WaveModelResolvedEndEffectorMetadata[];

  markClipAsTemporaryOverride(clipName: string): void;

  onCloneFinalized(): void;

  pause(): boolean;

  pauseGeometryDeformation(): this;

  play(clipNameOrClip: ModelAnimationClipInput, loopOrOptions?: boolean | ModelAnimationPlayOptions, crossFadeDuration?: number): WaveAnimationPlaybackHandle;

  playRigPoseClip(clipIdOrName: string, options?: WaveRigAnimationPlayOptions, registration?: WaveRigAnimationRegisterOptions): WaveAnimationPlaybackHandle;

  playVertexAnimation(assetNameOrOptions?: string | VertexAnimationPlaybackOptions, options?: VertexAnimationPlaybackOptions): this;

  registerRigPoseClip(clipIdOrName: string, options?: WaveRigAnimationRegisterOptions): WaveAnimationClip;

  removeClip(name: string): void;

  reset(clipName?: string): void;

  resetTriggers(): void;

  resolveClipName(targetName: string): string | null;

  resolvePlaybackAnimationGroup(clipName: string): AnimationGroup | null;

  resolvePlaybackVat(clipName: string): { readonly asset: VertexAnimationAsset; readonly range: VATAnimationRange; readonly binding: VatBindingValue; } | null;

  restart(clipName?: string, loop?: boolean): void;

  restartPlaybackController(controller: WaveAnimationController): void;

  restoreTemporaryOverride(clipName: string): boolean;

  resume(): boolean;

  resumeGeometryDeformation(): this;

  serialize(): SerializedCall[];

  setBool(name: string, value: boolean): void;

  setCurrentClip(name: string | undefined): void;

  setFloat(name: string, value: number): void;

  setGeometryDeformationAmount(value: number): this;

  setGeometryDeformationDirection(x: number, y: number, z: number): this;

  setInt(name: string, value: number): void;

  setMorphTarget(targetEntity: WaveGeometryMorphTarget): this;

  setTargetEntity(entity: WaveEntity | null): void;

  setTrigger(name: string): void;

  setVertexAnimationTime(seconds: number): this;

  simulateVertices(): WaveVertexSimulationBuilder;

  set speed(value: number);

  stop(clipName?: string): boolean;

  get targetEntity(): WaveEntity | null;

  timeline(name: string): WaveModelAnimatorTimelineBuilder;

  transitionByPose(startPose: ModelPoseInput, endPose: ModelPoseInput): WaveModelPoseTransitionBuilder;

  transitionByPose(startPose: ModelPoseInput, endPose: ModelPoseInput, durationSeconds: number, options?: WaveModelPoseTransitionOptions): WaveAnimationPlaybackHandle;

  transitionToPose(endPose: ModelPoseInput): WaveModelPoseTransitionBuilder;

  transitionToPose(endPose: ModelPoseInput, durationSeconds: number, options?: WaveModelPoseTransitionOptions): WaveAnimationPlaybackHandle;

  useVertexAnimation(assetName: string, rangeName?: string, loop?: boolean): this;

}

declare class cmp_movementController<TOwner extends WaveEntity = WaveEntity> {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroy(): void;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: TOwner;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: TOwner);

  static readonly typeName = ComponentTypeName.MovementController;

  addTrailPoint(position: WavePointInput): void;

  addTrailPoint(x: number, y: number, z: number): void;

  addWaypoint(position: WavePointInput): this;

  addWaypoint(x: number, y: number, z: number): this;

  addWaypoints(waypoints: Array<WavePointInput>): this;

  addWaypointXYZ(x: number, y: number, z: number): this;

  applyImpulse(impulse: SerializableVector3): void;

  asHumanoid(config?: { baseSpeed?: number; sprintMultiplier?: number; crouchMultiplier?: number; squatSpeed?: number; canSquat?: boolean; reverseSpeedScale?: number; strafeSpeedScale?: number; airControlFactor?: number; jumpForce?: number; mouseSensitivity?: number; invertY?: boolean; }): this;

  bindStandardActions(): void;

  clearIntent(): void;

  clearTrailPoints(): this;

  clearWaypoints(): this;

  get config(): ControllerConfig;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  get currentWaypointIndex(): number;

  get destroyPriority(): number;

  directionToCurrentWaypoint(): Vector3 | null;

  distanceToCurrentWaypoint(): number;

  getActionScheme(): ActionScheme;

  getCurrentSpeed(): number;

  getCurrentWaypoint(): Vector3 | null;

  getForwardDirection(): SerializableVector3;

  getNextWaypoint(loop?: boolean): Vector3 | null;

  getPosition(): SerializableVector3;

  getRightDirection(): SerializableVector3;

  getTrailPoints(): Vector3[];

  getVelocity(): SerializableVector3;

  getWaypoints(): Vector3[];

  hasReachedEnd(): boolean;

  hideTrail(): this;

  isCrouching(): boolean;

  isGrounded(): boolean;

  isJumping(): boolean;

  isMoving(): boolean;

  get isRecordingTrail(): boolean;

  isSprinting(): boolean;

  move(delta: SerializableVector3): void;

  recordTrail(intervalTicks?: number, skipTrivialMovements?: boolean, reset?: boolean): this;

  removeWaypointAt(index: number): this;

  removeWaypointNear(position: WavePointInput, threshold?: number): this;

  requestJump(): void;

  resetWaypointIndex(): this;

  rotate(yaw: number, pitch: number, roll?: number): void;

  setActionScheme(scheme: Partial<ActionScheme>): this;

  setConfig(config: Partial<ControllerConfig>): this;

  setCustomMovement(callback: CustomMovementCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  setIntent(intent: Partial<ControllerIntent>): void;

  setMovementMode(mode: MovementMode): this;

  setMovementParams(params: Partial<MovementParameters>): this;

  setMovementStrategy(strategy: MovementStrategy): this;

  setRotation(yaw: number, pitch: number, roll?: number): void;

  setRotationParams(params: Partial<RotationParameters>): this;

  setTrailPointCapacity(capacity: number | null): this;

  setWaypointIndex(index: number): this;

  setWaypoints(waypoints: Array<WavePointInput>): this;

  showTrail(frequencyTicks?: number, trailLength?: number | null): this;

  get state(): ControllerState;

  stopRecordingTrail(): this;

  syncFromPhysics(): void;

  teleport(position: SerializableVector3): void;

  get trailPointCapacity(): number | null; set trailPointCapacity(capacity: number | null);

  get trailPointCount(): number;

  unbindActions(): void;

  useFlightScheme(config?: { baseSpeed?: number; ascendSpeedScale?: number; descendSpeedScale?: number; pitchRate?: number; rollRate?: number; yawRate?: number; invertPitch?: boolean; }): this;

  useSpectatorScheme(config?: { baseSpeed?: number; sprintMultiplier?: number; crouchMultiplier?: number; lookSensitivity?: number; turnSensitivity?: number; ascendSpeedScale?: number; descendSpeedScale?: number; }): this;

  useVehicleScheme(config?: { baseSpeed?: number; reverseSpeedScale?: number; acceleration?: number; brakeStrength?: number; steeringSensitivity?: number; }): this;

  get waypointCount(): number;

  withAirControl(factor: number): this;

  withBaseSpeed(speed: number): this;

  withCrouchMultiplier(multiplier: number): this;

  withDirectionalSpeedScales(config: { reverse?: number; strafe?: number; ascend?: number; descend?: number; }): this;

  withFlightSensitivity(config: { pitch?: number; roll?: number; yaw?: number; throttle?: number; mouse?: number; }): this;

  withFriction(friction: number): this;

  withGamepadSensitivity(sens: number): this;

  withGravityScale(scale: number): this;

  withHumanoidSensitivity(config: { mouse?: number; gamepad?: number; yaw?: number; pitch?: number; }): this;

  withInvertPitch(invert?: boolean): this;

  withInvertYaw(invert?: boolean): this;

  withJumpForce(force: number): this;

  withMouseSensitivity(sens: number): this;

  withoutAirControl(): this;

  withPitchLimits(min: number, max: number): this;

  withPitchRate(rate: number): this;

  withRollRate(rate: number): this;

  withSpectatorTuning(config: { baseSpeed?: number; sprintMultiplier?: number; crouchMultiplier?: number; mouse?: number; turn?: number; ascendSpeedScale?: number; descendSpeedScale?: number; }): this;

  withSprintMultiplier(multiplier: number): this;

  withSteeringSensitivity(sensitivity: number): this;

  withYawRate(rate: number): this;

}

declare class cmp_networkBehavior {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity, options?: NetworkOptions);

  static readonly bindingSystem = "networkBehavior";

  static readonly typeName = ComponentTypeName.NetworkBehavior;

  applyNetworkTransform(transform: NetworkTransform): void;

  get authority(): EntityAuthority;

  configure(options: NetworkOptions): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  destroy(): void;

  get destroyPriority(): number;

  getLastSyncedTransform(): NetworkTransform | null;

  getNetworkTransform(): NetworkTransform;

  handleRPC(methodName: string, args: unknown[], sourceClientId: string): void;

  invokeRPC(methodName: string, args?: unknown[], targetClients?: string[]): void;

  llmAccessMode: LLMAccessMode | undefined;

  llmEndpointId: string | undefined;

  get networkId(): number;

  get ownerClientId(): string | null;

  properties: Record<string, unknown>;

  get replicateMode(): ReplicateMode;

  get replicateTargets(): string[];

  requestLLM(request: LLMRequest, options?: LLMRequestRuntimeOptions): Promise<LLMResponse>;

  setAuthority(authority: EntityAuthority): this;

  setOwnerClient(clientId: string | null): this;

  setReplicateMode(mode: ReplicateMode): this;

  setReplicateTargets(targets: string[]): this;

  shouldReplicateToClient(clientId: string): boolean;

  updateLastSyncedTransform(transform: NetworkTransform): void;

}

declare class cmp_physicsBody<TOwner extends WaveEntity = WaveEntity> implements PhysicsBodyPinAuthoringExecutor<cmp_physicsBody<TOwner>>, WaveSpatialVolumeContract {

  activationPolicy: RigidBodyActivationPolicy;

  actuationTriggerIds: string[];

  addAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): this;

  addAngularVelocity(delta: Vector3Like | DirectionInput): this;

  addAngularVelocity(dx: number, dy: number, dz: number): this;

  addLinearVelocity(delta: Vector3Like | DirectionInput): this;

  addLinearVelocity(direction: Vector3Like | DirectionInput, speed: number): this;

  addLinearVelocity(dx: number, dy: number, dz: number): this;

  alwaysActive(enabled?: boolean): this;

  angularDamping: number;

  angularInertiaConfig: any;

  applyAngularImpulse(axis: Vector3Like | DirectionInput, strength: number): this;

  applyAngularImpulse(impulse: Vector3Like | DirectionInput): this;

  applyForce(direction: Vector3Like | DirectionInput, strength: number, contactPoint?: RigidBodyContactPointInput): this;

  applyForce(force: Vector3Like | DirectionInput, contactPoint?: RigidBodyContactPointInput): this;

  applyForce(hit: RigidBodyInteractionHitInput, strength?: number): this;

  applyImpulse(direction: Vector3Like | DirectionInput, strength: number, contactPoint?: RigidBodyContactPointInput): this;

  applyImpulse(hit: RigidBodyInteractionHitInput, strength?: number): this;

  applyImpulse(impulse: Vector3Like | DirectionInput, contactPoint?: RigidBodyContactPointInput): this;

  applyTorque(axis: Vector3Like | DirectionInput, strength: number): this;

  applyTorque(torque: Vector3Like | DirectionInput): this;

  applyTorque(x: number, y: number, z: number): this;

  applyTransform(position: Vector3Like, rotation?: QuaternionLike_3): void;

  autoColliderFromMeshOptions: AutoColliderFromMeshOptions | null;

  autoFitCenterOffset: any;

  autoFitEnabled: boolean;

  avoidCollisionByTag(tag: string, ...tags: string[]): this;

  avoidCollisionByTag(tags: readonly string[]): this;

  avoidCollisionWith(...targets: (wave3DObject | readonly wave3DObject[])[]): this;

  bodyType: RigidBodyType;

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  centerOfMassConfig: any;

  clearConstantForce(name?: string): this;

  clearConstantForces(): this;

  clearConstantTorque(name?: string): this;

  clearConstantTorques(): this;

  clearMass(): this;

  clearMassModel(): this;

  colliderAutoRebuildEnabled: boolean;

  colliderStaticPositionOffset: any;

  colliderStaticRotationOffset: any;

  colliderStaticScaleOffset: any;

  collisionGroup: number;

  collisionMask: number;

  collisionTruthPolicy: WaveCollisionTruthPolicy;

  readonly componentName: string;

  compoundChildren: CompoundColliderChildConfig[] | null;

  compoundChildrenGeneration: number;

  compoundCollidersFromMeshesEnabled: boolean;

  compoundCollidersFromMeshesOptions: CompoundCollidersFromMeshesOptions | null;

  configurePhysics(mutator: (body: this) => void): this;

  constantForces: ConstantForceEntry[];

  constantTorques: ConstantTorqueEntry[];

  constraintConfigSnapshots: ConstraintConfigSnapshot[];

  constraintEndpointLabel: string;

  constraintIds: string[];

  constraintInstanceIndex: undefined;

  constrainTo(target: PhysicsConstraintEndpoint): ConstraintBuilder;

  constraintRuntimeUnitScale: any;

  contactCount: number;

  contactEndGraceSubsteps: number;

  contactingBodies: cmp_physicsBody<WaveEntity<unknown>>[];

  contactVerificationDistance: number;

  createActuationTrigger(options: RigidBodyActuationTriggerOptions): RigidBodyActuationTrigger;

  createConstraintConfig(id: string, target: PhysicsConstraintEndpoint, config: ConstraintConfig): PhysicsConstraintProjectionResult;

  createJointTo(target: PhysicsConstraintEndpoint, config?: RigidBodyJointConfig, options?: RigidBodyJointOptions): RigidBodyJointResult;

  deferNativePhysicsBodyUntilUsed(): this;

  destroy(): void;

  destroyPriority: number;

  disable(): this;

  disableColliderAutoRebuild(): this;

  disableContactMonitor(): this;

  disableGravity(): this;

  dispose(): void;

  disposeConstraint(id: string): boolean;

  editConstantForce(name: string): WaveRigidBodyConstantForceBuilder<this>;

  editConstantTorque(name: string): WaveRigidBodyConstantTorqueBuilder<this>;

  enable(): this;

  enableCollisionByTag(tag: string, ...tags: string[]): this;

  enableCollisionByTag(tags: readonly string[]): this;

  enableCollisionWith(...targets: (wave3DObject | readonly wave3DObject[])[]): this;

  enableContactMonitor(options?: ContactMonitorOptions): this;

  enabled: boolean;

  enableGravity(factor?: number): this;

  engine: unknown;

  evaluateActuationTriggers(timestampMs: number): void;

  executePendingRebuild(): void;

  forEachContactingBody(callback: (body: this) => void): this;

  frameAuthoredLinearVelocityIntent: FrameAuthoredLinearVelocityIntent | null;

  friction: number | null;

  generateConstraintId(): string;

  getActuationTrigger(id: string): RigidBodyActuationTrigger | undefined;

  getConstraint(id: string): unknown | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getRigidMotionToRefs(linearTarget: Vector3Like, angularTarget: Vector3Like): boolean;

  gravityFactor: number;

  hasActuationCollisionTracking(): boolean;

  hasActuationTrigger(id: string): boolean;

  hasActuationTriggers(): boolean;

  hasAngularVelocityLimit(): boolean;

  hasConstantForce(name: string): boolean;

  hasConstantTorque(name: string): boolean;

  hasConstraint(id: string): boolean;

  hasEnabledConstantForce(): boolean;

  hasEnabledConstantTorque(): boolean;

  hasLinearVelocityLimit(): boolean;

  hasNativePhysicsBodyRequested(): boolean;

  hasPendingColliderAutoRebuild(): boolean;

  hasVelocityLimit(): boolean;

  heightfieldData: HeightfieldData | null;

  heightfieldGroundMesh: any;

  inFrameOf(target: TransformReferenceLike): WaveRigidBodyFrameScope<this>;

  init(): Promise<void> | void;

  initialAngularVelocity: any;

  initialLinearVelocity: any;

  inLocalFrame(): WaveRigidBodyFrameScope<this>;

  inParentFrame(depth?: number): WaveRigidBodyFrameScope<this>;

  inWorldFrame(): WaveRigidBodyFrameScope<this>;

  isCapable: boolean;

  isComponentActive: boolean;

  isConstraintEndpointDisposed: boolean;

  isContactMonitorEnabled(): boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isDynamic: boolean;

  isFullyRotationLocked(): boolean;

  isInContactWith(target: cmp_physicsBody | wave3DObject | null | undefined): boolean;

  isKinematic: boolean;

  isRotationLocked(): boolean;

  isSensor: boolean;

  isStatic: boolean;

  isUnbound: boolean;

  linearDamping: number;

  lockRotation(): this;

  lockRotationAxis(axis: "x" | "y" | "z"): this;

  mass: number;

  massIntent: Readonly<PhysicsMassIntent>;

  massModelConfig: WaveModelMassModelConfig | null;

  maxAngularVelocity: number;

  maxContactsReported: number;

  maxLinearVelocity: number;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onContact(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactBegin(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactBeginByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactBeginWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactContinue(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactContinueByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactContinueWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactEnd(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactEndByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactEndWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onMeshesChanged(): void;

  onMeshPhysicsSurfaceChanged(): void;

  onPartPhysicsChanged(removedPartIds?: readonly string[]): void;

  onScaleChanged(newScale: Vector3Like): void;

  onTransformChanged(change?: { positionChanged?: boolean; rotationChanged?: boolean; physicsMotion?: "direct" | "animated"; }): void;

  owner: TOwner;

  partCompoundColliderChildType: CompoundColliderChildType;

  partCompoundColliderMaxChildren: number;

  partCompoundCollidersEnabled: boolean;

  physicsTimeScale: number;

  rebuildColliderNow(): this;

  requestNativePhysicsBody(): this;

  requestRebuild(): void;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  resetConstraint(constraintId: string): boolean;

  restitution: number | null;

  resumeColliderAutoRebuild(): this;

  rotationLock: RotationLockFlags;

  scene: WaveScene<unknown> | null;

  setActivationPolicy(policy: RigidBodyActivationPolicy): this;

  setAngularDamping(value: number): this;

  setAngularInertia(value: number): this;

  setAngularInertia(value: Vector3Like): this;

  setAngularInertia(x: number, y: number, z: number): this;

  setAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): this;

  setAngularVelocity(velocity: Vector3Like | DirectionInput): this;

  setAngularVelocity(x: number, y: number, z: number): this;

  setAutoFitCenterOffset(value: Vector3Like): void;

  setAutoFitCenterOffset(x: number, y: number, z: number): void;

  setCenterOfMass(value: Vector3Like): this;

  setCenterOfMass(x: number, y: number, z: number): this;

  setColliderStaticPositionOffset(value: Vector3Like): this;

  setColliderStaticPositionOffset(x: number, y: number, z: number): this;

  setColliderStaticRotationOffset(value: Vector3Like): this;

  setColliderStaticRotationOffset(x: number, y: number, z: number): this;

  setColliderStaticScaleOffset(value: Vector3Like): this;

  setColliderStaticScaleOffset(x: number, y: number, z: number): this;

  setCollisionFilter(group: number, mask: number): this;

  setCollisionGroup(value: number): void;

  setCollisionMask(value: number): void;

  setConstantForce(name: string, config: ConstantForceConfig): this;

  setConstantForce(name: string, direction: Vector3Like | DirectionInput, strength: number, options?: ConstantForceOptions): this;

  setConstantForce(name: string, force: Vector3Like | DirectionInput, options?: ConstantForceOptions): this;

  setConstantTorque(name: string, config: ConstantTorqueConfig): this;

  setConstantTorque(name: string, direction: Vector3Like | DirectionInput, strength: number, options?: ConstantTorqueOptions): this;

  setConstantTorque(name: string, torque: Vector3Like | DirectionInput, options?: ConstantTorqueOptions): this;

  setConstraintBallAndSocket(target: cmp_physicsBody, ownLocalPivot: Vector3Like, targetLocalPivot: Vector3Like, enableCollisions?: boolean, constraintId?: string): string | null;

  setConstraintDistance(target: cmp_physicsBody, minDistance: number, maxDistance: number, enableCollisions?: boolean, constraintId?: string): string | null;

  setConstraintHinge(target: cmp_physicsBody, ownLocalPivot: Vector3Like, targetLocalPivot: Vector3Like, axis: DirectionInput, minAngle?: number, maxAngle?: number, enableCollisions?: boolean, constraintId?: string): string | null;

  setConstraintLock(target: cmp_physicsBody, ownLocalPivot: Vector3Like, targetLocalPivot: Vector3Like, enableCollisions?: boolean, constraintId?: string): string | null;

  setConstraintSixDoF(target: cmp_physicsBody, ownLocalPivot: Vector3Like, targetLocalPivot: Vector3Like, motorAxis?: ConstraintAxis, motorMode?: MotorMode, motorTarget?: number, motorMaxForce?: number, enableCollisions?: boolean, constraintId?: string): string | null;

  setContactEndGraceSubsteps(substeps: number): this;

  setContactVerificationDistance(distance: number): this;

  setEnabled(value: false, options?: DisablePhysicsOptions): this;

  setEnabled(value: true, options?: EnablePhysicsOptions): this;

  setFriction(value: number): this;

  setGravityFactor(value: number): this;

  setHeightfieldData(data: Float32Array, columns: number, rows: number, worldWidth: number, worldDepth: number, minHeight: number, maxHeight: number, options?: { colliderStaticPositionOffset?: Vector3Like; }): this;

  setInitialAngularVelocity(value: Vector3Like): void;

  setInitialAngularVelocity(x: number, y: number, z: number): void;

  setInitialLinearVelocity(value: Vector3Like): void;

  setInitialLinearVelocity(x: number, y: number, z: number): void;

  setIsSensor(value: boolean): void;

  setLinearDamping(value: number): this;

  setLinearVelocity(direction: Vector3Like | DirectionInput, speed: number): this;

  setLinearVelocity(velocity: Vector3Like | DirectionInput): this;

  setLinearVelocity(x: number, y: number, z: number): this;

  setMass(value: number): this;

  setMaxAngularVelocity(value: number): void;

  setMaxContactsReported(maxContacts: number): this;

  setMaxLinearVelocity(value: number): void;

  setPhysicsTimeScale(value: number): this;

  setRestitution(value: number): this;

  setRotationLock(flags: Partial<RotationLockFlags>): this;

  setSize(value: Vector3Like): void;

  setSize(x: number, y: number, z: number): void;

  setSizeFromAutoFit(value: Vector3Like): void;

  setSizeFromAutoFit(x: number, y: number, z: number): void;

  setTargetTransform(position: WavePointInput, rotation?: QuaternionLike_3): void;

  shapeType: RigidBodyShapeType;

  size: any;

  syncTransformFromPhysics(): void;

  teleport(position: WavePointInput, rotation?: QuaternionLike_3, preserveVelocity?: boolean): void;

  typeName: string;

  unlockRotation(): this;

  unlockRotationAxis(axis: "x" | "y" | "z"): this;

  useActorDynamicBoxPhysicsPreset(): void;

  useAutoColliderFromMesh(options?: AutoColliderFromMeshOptions): this;

  useBoxCollider(): this;

  useBoxCollider(size: Vector3Like): this;

  useBoxCollider(x: number, y: number, z: number): this;

  useCapsuleCollider(radius?: number, height?: number): this;

  useCompoundCollider(children: CompoundColliderChildConfig[]): this;

  useConvexHullCollider(): this;

  useCylinderCollider(radius?: number, height?: number): this;

  useHeightfieldCollider(): this;

  useMeshCollider(): this;

  useMeshCompoundCollider(options?: MeshCollidersOptions): this;

  usePartCompoundCollider(options?: PartCollidersOptions): this;

  useSphereCollider(radius?: number): this;

  useVisualBoundsCollider(shape: PrimitiveColliderShapeName): this;

  wakeUp(): void;

  worldPointToConstraintLocal(worldPoint: WavePointInput): Vector3Like;

  constructor(owner: TOwner);

  static readonly typeName = ComponentTypeName.PhysicsBody;

  get angularVelocity(): Vector3Like | null;

  applyIntent(input: PhysicsBodyIntentInput): this;

  bindPhysicalMaterial(target: PhysicsMaterialBindingTarget, material: PhysicsMaterialDefinition | ResolvedPhysicsMaterial): this;

  captureState(): Promise<PhysicsBodyRuntimeState>;

  get centerOfMass(): Vector3Like | null;

  clearForces(): void;

  clearPhysicalMaterial(): this;

  clearPhysicalMaterialBinding(target: PhysicsMaterialBindingTarget): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  get density(): number | null;

  disableContinuousCollision(): this;

  disableFluidInteraction(): this;

  disableImpactFracture: () => this;

  disableSelfCollision(): this;

  get effectiveScale(): Vector3Like;

  enableContinuousCollision(): this;

  enableFluidInteraction(): this;

  enableImpactFracture: (options?: WaveImpactFractureEnableOptions) => this;

  enableSelfCollision(): this;

  fluidDomain(): WavePhysicsBodyFluidDomainBuilder<this>;

  fluidFlow(id: string): WavePhysicsBodyFluidFlowBuilder<this>;

  get fluidInteractionMode(): PhysicsFluidInteractionMode;

  fractureFrom: (impact: WaveImpactFractureObservation, options?: WaveImpactFractureOptions) => WaveFractureHandle;

  getFluidFlow(id: string): WavePhysicsBodyFluidFlowHandle<this>;

  getIntentSnapshot(): PhysicsBodyIntentSnapshot;

  getVelocityAtWorldPoint(point: WavePointInput): Vector3Like | null;

  readonly impactFractureEnabled: boolean;

  get inertia(): Vector3Like | null;

  get linearVelocity(): Vector3Like | null;

  get nativeConstraintBodyForConstraint(): unknown | null;

  get physicalMaterial(): ResolvedPhysicsMaterial | null;

  pinPoints(...selections: readonly PhysicsBodyPinSelectionInput[]): WavePhysicsBodyPinBuilder<this>;

  pinPointsAlong(path: PhysicsBodyPinPathInput): WavePhysicsBodyPathPinBuilder<this>;

  preserveVolume(value: number): this;

  requestNativeConstraintBody(): void;

  resetMotion(): this;

  resolvePhysicalMaterial(target?: PhysicsMaterialBindingTarget): PhysicsMaterialResolution | null;

  restoreState(state: PhysicsBodyRuntimeState): this;

  get rigidity(): number;

  serialize(): SerializedCall[];

  setBendResistance(value: number): this;

  setCompressibility(value: number): this;

  setDeformationDamping(value: number): this;

  setFluidDensity(value: number): this;

  setFluidFillLevel(value: number): this;

  setFluidInteraction(mode: PhysicsFluidInteractionMode): this;

  setFluidParticleCount(value: number): this;

  setHeightfieldGroundMesh(_mesh: unknown): this;

  setPlasticity(value: number): this;

  setRigidity(value: number): this;

  setStretchResistance(value: number): this;

  setViscosity(value: number): this;

  sleep(): void;

  get spatialVolume(): number | null;

  unpinPoints(...selections: readonly PhysicsBodyPinSelectionInput[]): this;

  useAutomaticFluidInteraction(): this;

  useDynamicBody(): this;

  useKinematicBody(): this;

  useMassModel(config: WaveModelMassModelConfig): this;

  usePhysicalMaterial(material: PhysicsMaterialDefinition | ResolvedPhysicsMaterial): this;

  useStaticBody(): this;

}

declare class cmp_rig implements IRigProvider {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity<unknown>);

  static readonly typeName = ComponentTypeName.Rig;

  addIKHandle(): RigIKHandleBuilder;

  addSocket(): RigSocketBuilder;

  apply(input: WaveRigInput): RigApplyResult;

  bone(nameOrPart: string | BodyPart): waveBoneHandle | null;

  capturePose(name?: string): RigPoseResult;

  captureRestPose(): RigPoseResult;

  clampBoneIKTargetToReach(endBoneRef: string | BodyPart, targetWorldPosition: Vector3Like, options: RigBoneIKOptions): RigIKReachResult;

  commitObjectModelRigPoseClip(clip: WaveModelRigPoseClipMetadata): WaveModelRigPoseClipMetadata;

  commitObjectModelRigPoseSnapshot(preset: WaveModelRigPoseSnapshotMetadata): WaveModelRigPoseSnapshotMetadata;

  get config(): WaveRigAuthoringConfig | null;

  createSocket(name: string, boneRef: string | BodyPart, offset?: SocketOffset, options?: BoneSocketCreateOptions): BoneSocket | null;

  destroy(): void;

  get destroyPriority(): number;

  disableIKDebugLogs(): this;

  editSkin(options?: WaveRigSkinAuthoringOptions): WaveRigSkinAuthoringSession;

  enableIKDebugLogs(enabled?: boolean): this;

  firstAvailablePart<TPart extends WaveRigPosePartRef>(candidates: readonly TPart[]): TPart | null;

  getAllBones(): ReadonlyMap<string, WaveBone>;

  getAllSockets(): ReadonlyMap<string, BoneSocket>;

  getBone(nameOrPart: string | BodyPart): WaveBone | null;

  getObjectModelRigPoseClip(idOrName: string): WaveModelRigPoseClipMetadata | null;

  getObjectModelRigPoseSnapshot(idOrName: string): WaveModelRigPoseSnapshotMetadata | null;

  getSocket(name: string): BoneSocket | null;

  hasBone(nameOrPart: string | BodyPart): boolean;

  get hasRigidObjectModelPhysics(): boolean;

  listObjectModelRigPoseClips(): WaveModelRigPoseClipMetadata[];

  listObjectModelRigPoseSnapshots(): WaveModelRigPoseSnapshotMetadata[];

  onModelLoaded(): void;

  get ownerName(): string;

  pose(name: string): WaveRigPoseAuthoringBuilder;

  ragdoll(options?: WaveSkeletalRagdollOptions): this;

  recover(options?: WaveSkeletalRecoveryOptions): WaveSkeletalRecoveryResult | null;

  releaseRigidObjectModelPhysics(): boolean;

  removeSocket(name: string): boolean;

  requireBone(nameOrPart: string | BodyPart): waveBoneHandle;

  rigidObjectModelActuation<TPartId extends WaveModelPartId = WaveModelPartId>(options?: WaveArticulatedActuationOptions<TPartId>): WaveArticulatedActuation<WavePhysicsRigPart, TPartId>;

  rigidObjectModelPhysics(): WaveRigidObjectModelPhysicsBuilder;

  savePose(id: string): WaveModelRigPoseSnapshotMetadata;

  savePoseFromIKHandles(name: string, options?: WaveRigIKHandleTargetPoseOptions): WaveModelRigPoseSnapshotMetadata;

  savePoseFromIKHandles(name: string, handles: Iterable<WaveRigIKHandle>, options?: WaveRigIKHandleTargetPoseOptions): WaveModelRigPoseSnapshotMetadata;

  savePoseRecipe(name: string, recipe: WaveRigPoseRecipe): WaveModelRigPoseSnapshotMetadata;

  savePoseRecipes(recipes: readonly WaveRigNamedPoseRecipe[]): WaveModelRigPoseSnapshotMetadata[];

  scanSkeleton(): number;

  serialize(): SerializedCall[];

  setBonePose(boneRef: string | BodyPart, transform: RuntimeBoneTransform, options?: SetBonePoseOptions): RigPoseResult;

  setBoneRotation(boneRef: string | BodyPart, axis: RuntimeBoneRotationAxis, radians: number, options?: SetBonePoseOptions): RigPoseResult;

  setPose(pose: WavePose): RigPoseResult;

  setPose(pose: WaveRigPoseInput): RigPoseResult;

  get skeletalPhysicsState(): WaveSkeletalPhysicsState;

  solveBoneIK(endBoneRef: string | BodyPart, targetWorldPosition: Vector3Like, options: RigBoneIKOptions): RigIKResult;

  useAnimationAuthority(recoveryOptions?: WaveSkeletalRecoveryOptions): this;

  usePhysicalAnimation(options?: WaveSkeletalPhysicalAnimationOptions): this;

  useRigidObjectModelPhysics(input?: WaveRigidObjectModelPhysicsIntent): this;

}

declare class cmp_sensing<TOwner extends WaveEntity = WaveEntity> {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: TOwner;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: TOwner);

  static readonly typeName = ComponentTypeName.Sensing;

  addCallbackRegistrationMetadata(metadata: CallbackRegistrationMetadata): void;

  cameraCapture(): WaveCameraCaptureBuilder;

  canDetect(target: WaveSensingSpatialEntity, blockingMask?: bigint): boolean;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  destroy(): void;

  get destroyPriority(): number;

  detectInBox(halfExtents: Vector3, tagMask?: bigint): DetectionResult;

  detectInBoxAt(center: Vector3, halfExtents: Vector3, tagMask?: bigint): DetectionResult;

  detectInCone(halfAngle?: number, maxDistance?: number, tagMask?: bigint): DetectionResult;

  detectInConeFrom(origin: Vector3, direction: Vector3 | DirectionInput, halfAngle: number, maxDistance: number, tagMask?: bigint): DetectionResult;

  detectInDirection(direction: Vector3 | DirectionInput, maxDistance?: number, tagMask?: bigint): DetectionResult;

  detectInSphere(radius?: number, tagMask?: bigint): DetectionResult;

  detectInSphereAt(center: Vector3, radius: number, tagMask?: bigint): DetectionResult;

  disableGestureOrbit(): void;

  enableGestureOrbit(options?: GestureOrbitOptions): void;

  getCallbackRegistrationMetadata(): CallbackRegistrationMetadata[];

  getDetectionFilters(): DetectionFilter[];

  getDetectionRange(): number;

  getFieldOfView(): number;

  getLineOfSightCheckEnabled(): boolean;

  getMouseDelta(): { x: number; y: number; }

  getMousePosition(): { x: number; y: number; }

  getPollingInterval(): WaveTimeSpan;

  getPressedKeys(): Keyboard[];

  hardware(): WaveHardwareBuilder;

  hasLineOfSightTo(target: WaveSensingSpatialEntity | WavePointInput, options?: LineOfSightOptions): boolean;

  get isGestureOrbitEnabled(): boolean;

  isKeyPressed(key: Keyboard): boolean;

  isMouseButtonPressed(button: MouseButton): boolean;

  off(handleOrName: CallbackHandle | string): boolean;

  offAction(actionName: WaveActionName | string, callback?: ActionCallback<TOwner>): void;

  offAll(): void;

  onAction(actionName: WaveActionName | string, callback: ActionCallback<TOwner>, options?: ActionCallbackOptions): CallbackHandle;

  onAudioLoudnessPeak(callback: InputCallback<AudioInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onAudioSpeech(callback: InputCallback<AudioInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onGamepadButtonPress(callback: InputCallback<GamepadButtonInputData, TOwner>, button?: GamepadButton, options?: SensingCallbackOptions): CallbackHandle;

  onGamepadButtonRelease(callback: InputCallback<GamepadButtonInputData, TOwner>, button?: GamepadButton, options?: SensingCallbackOptions): CallbackHandle;

  onLeftClick(callback: InputCallback<MouseButtonInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onLeftStickMove(callback: InputCallback<GamepadAxisInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onMiddleClick(callback: InputCallback<MouseButtonInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onMouseButtonDown(callback: InputCallback<MouseButtonInputData, TOwner>, button?: MouseButton, options?: SensingCallbackOptions): CallbackHandle;

  onMouseButtonHolding(callback: InputCallback<MouseButtonInputData, TOwner>, button?: MouseButton, holdThreshold?: WaveTimeSpan, options?: SensingCallbackOptions): CallbackHandle;

  onMouseButtonHolding(callback: InputCallback<MouseButtonInputData, TOwner>, button: MouseButton | undefined, value: number, unit: WaveTimeUnit, options?: SensingCallbackOptions): CallbackHandle;

  onMouseButtonUp(callback: InputCallback<MouseButtonInputData, TOwner>, button?: MouseButton, options?: SensingCallbackOptions): CallbackHandle;

  onMouseClick(callback: InputCallback<MouseButtonInputData, TOwner>, button?: MouseButton, options?: SensingCallbackOptions): CallbackHandle;

  onMouseDoubleClick(callback: InputCallback<MouseButtonInputData, TOwner>, button?: MouseButton, options?: SensingCallbackOptions): CallbackHandle;

  onMouseMove(callback: InputCallback<MouseMoveInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onMouseWheel(callback: InputCallback<MouseWheelInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onPinch(callback: InputCallback<TouchGestureInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onRightClick(callback: InputCallback<MouseButtonInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onRightStickMove(callback: InputCallback<GamepadAxisInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onSwipeDown(callback: InputCallback<TouchGestureInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onSwipeLeft(callback: InputCallback<TouchGestureInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onSwipeRight(callback: InputCallback<TouchGestureInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onSwipeUp(callback: InputCallback<TouchGestureInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onTouchDown(callback: InputCallback<TouchInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onTouchHolding(callback: InputCallback<TouchInputData, TOwner>, holdThreshold?: WaveTimeSpan, options?: SensingCallbackOptions): CallbackHandle;

  onTouchHolding(callback: InputCallback<TouchInputData, TOwner>, value: number, unit: WaveTimeUnit, options?: SensingCallbackOptions): CallbackHandle;

  onTouchMove(callback: InputCallback<TouchMoveInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onTouchUp(callback: InputCallback<TouchInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onVisionGesture(callback: InputCallback<VisionInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onVisionHandDetected(callback: InputCallback<VisionInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  onVisionHandLost(callback: InputCallback<VisionInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  setCallbackRegistrationMetadata(metadata: CallbackRegistrationMetadata[]): void;

  setDetectionFilters(filters: DetectionFilter[]): void;

  setDetectionRange(range: number): void;

  setFieldOfView(fovRadians: number): void;

  setLineOfSightCheckEnabled(enabled: boolean): void;

  setPollingInterval(duration: WaveTimeSpan): void;

  setPollingInterval(value: number, unit: WaveTimeUnit): void;

  simulateHolding(key: Keyboard, duration?: WaveTimeSpan, options?: SensingKeyboardSimulationOptions): SensingInputSimulationHandle;

  simulateHolding(key: Keyboard, value: number, unit: WaveTimeUnit, options?: SensingKeyboardSimulationOptions): SensingInputSimulationHandle;

  simulateLeftClick(point?: SensingSimulationPointInput, options?: SensingPointerSimulationOptions): void;

  simulateMiddleClick(point?: SensingSimulationPointInput, options?: SensingPointerSimulationOptions): void;

  simulateMouseButtonDown(button?: MouseButton, point?: SensingSimulationPointInput, options?: SensingPointerSimulationOptions): SensingInputSimulationHandle;

  simulateMouseButtonHolding(button?: MouseButton, point?: SensingSimulationPointInput, duration?: WaveTimeSpan, options?: SensingPointerSimulationOptions): SensingInputSimulationHandle;

  simulateMouseButtonHolding(button: MouseButton | undefined, point: SensingSimulationPointInput | undefined, value: number, unit: WaveTimeUnit, options?: SensingPointerSimulationOptions): SensingInputSimulationHandle;

  simulateMouseButtonUp(button?: MouseButton, point?: SensingSimulationPointInput, options?: SensingPointerSimulationOptions): void;

  simulateMouseClick(button?: MouseButton, point?: SensingSimulationPointInput, options?: SensingPointerSimulationOptions): void;

  simulateMouseDoubleClick(button?: MouseButton, point?: SensingSimulationPointInput, options?: SensingPointerSimulationOptions): void;

  simulateMouseMove(point: SensingSimulationPointInput, options?: SensingPointerSimulationOptions): void;

  simulateMouseWheel(deltaY: number, deltaX?: number, deltaZ?: number, options?: SensingWheelSimulationOptions): void;

  simulatePress(key: Keyboard, options?: SensingKeyboardSimulationOptions): SensingInputSimulationHandle;

  simulateRelease(key: Keyboard, options?: SensingKeyboardSimulationOptions): void;

  simulateRightClick(point?: SensingSimulationPointInput, options?: SensingPointerSimulationOptions): void;

  simulateTouchDown(point: SensingSimulationPointInput, options?: SensingTouchSimulationOptions): SensingSimulationTouchHandle;

  simulateTouchHolding(point: SensingSimulationPointInput, duration?: WaveTimeSpan, options?: SensingTouchSimulationOptions): SensingSimulationTouchHandle;

  simulateTouchHolding(point: SensingSimulationPointInput, value: number, unit: WaveTimeUnit, options?: SensingTouchSimulationOptions): SensingSimulationTouchHandle;

  simulateTouchMove(touchId: number, point: SensingSimulationPointInput, options?: SensingTouchSimulationOptions): void;

  simulateTouchUp(touchId: number, point?: SensingSimulationPointInput, options?: SensingTouchSimulationOptions): void;

  speechCommands<TCommand extends string = string>(): WaveSpeechCommandBuilder<TCommand>;

  webcamHands(): WaveWebcamHandTrackingBuilder;

  whenHolding(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, TOwner>, holdThreshold?: WaveTimeSpan, options?: SensingCallbackOptions): CallbackHandle;

  whenHolding(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, TOwner>, value: number, unit: WaveTimeUnit, options?: SensingCallbackOptions): CallbackHandle;

  whenPress(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

  whenRelease(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, TOwner>, options?: SensingCallbackOptions): CallbackHandle;

}

declare class cmp_thinBatchPhysicsBody<TOwner extends WaveEntity = WaveEntity> {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: TOwner;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  typeName: string;

  constructor(owner: TOwner);

  static readonly typeName = ComponentTypeName.PhysicsBody;

  applyAngularImpulse(impulse: ThinBatchPhysicsBodyVectorInput): this;

  applyAngularImpulse(axis: ThinBatchPhysicsBodyVectorInput, strength: number): this;

  applyAngularImpulseForAll(impulse: ThinBatchPhysicsBodyVectorInput): this;

  applyAngularImpulseForAll(axis: ThinBatchPhysicsBodyVectorInput, strength: number): this;

  applyIntent(input: PhysicsBodyIntentInput): this;

  applyTorque(torque: ThinBatchPhysicsBodyVectorInput): this;

  applyTorque(x: number, y: number, z: number): this;

  applyTorque(axis: ThinBatchPhysicsBodyVectorInput, strength: number): this;

  applyTorqueForAll(torque: ThinBatchPhysicsBodyVectorInput): this;

  applyTorqueForAll(x: number, y: number, z: number): this;

  applyTorqueForAll(axis: ThinBatchPhysicsBodyVectorInput, strength: number): this;

  at(index: number, validateIndex?: ThinBatchIndexValidator): ThinBatchPhysicsBodyIndexScope<this>;

  get bodyType(): RigidBodyType;

  clearConstantForce(name?: string): this;

  clearConstantForces(): this;

  clearForces(): this;

  get colliderStaticPositionOffset(): Vector3Like;

  get colliderStaticRotationOffset(): Vector3Like;

  get colliderStaticScaleOffset(): Vector3Like;

  get constantForces(): ThinBatchConstantForceEntry[];

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  destroy(): void;

  get destroyPriority(): number;

  disableContinuousCollision(): this;

  disableGravity(): this;

  disableMotionSettleSleep(): this;

  disablePhysics(): this;

  disableSelfCollision(): this;

  disposeConstraint(id: string): boolean;

  driveKinematicMotion(config: ThinBatchKinematicMotionConfig): this;

  enableContinuousCollision(): this;

  enableGravity(factor?: number): this;

  enablePhysics(): this;

  enableSelfCollision(): this;

  get friction(): number | null;

  getAngularDamping(): number;

  getConstraint(id: string): unknown | undefined;

  getConstraintConfigSnapshots(): ThinBatchConstraintConfigSnapshot[];

  getConstraintIds(): string[];

  getGravityFactor(): number;

  getIntentSnapshot(): PhysicsBodyIntentSnapshot;

  getLinearDamping(): number;

  getMass(): number;

  hasConstantForce(name: string): boolean;

  hasConstraint(id: string): boolean;

  get hasNativeBody(): boolean;

  ignoreGravity(): this;

  get isPhysicsRequested(): boolean;

  get motionSettleSleepPolicy(): ThinBatchMotionSettleSleepPolicy | null;

  get nativeBody(): unknown | null;

  onContact(callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactBegin(callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactContinue(callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): this;

  onContactEnd(callback: ThinBatchContactCallback, options?: WaveAuthoredCallbackOptions): this;

  preserveVolume(value: number): this;

  readDiagnostics(): ThinBatchPhysicsBodyDiagnostics;

  rememberCurrentTransformsAs(name: string): this;

  resetToRememberedTransforms(name: string): this;

  get restitution(): number | null;

  get rigidity(): number;

  serialize(): SerializedCall[];

  setAngularDamping(damping: number): this;

  setAngularDampingForAll(damping: number): this;

  setAngularVelocity(velocity: ThinBatchPhysicsBodyVectorInput): this;

  setAngularVelocity(x: number, y: number, z: number): this;

  setAngularVelocity(axis: ThinBatchPhysicsBodyVectorInput, speed: number): this;

  setAngularVelocityForAll(velocity: ThinBatchPhysicsBodyVectorInput): this;

  setAngularVelocityForAll(x: number, y: number, z: number): this;

  setAngularVelocityForAll(axis: ThinBatchPhysicsBodyVectorInput, speed: number): this;

  setBendResistance(value: number): this;

  setColliderStaticPositionOffset(value: Vector3Like): this;

  setColliderStaticPositionOffset(x: number, y: number, z: number): this;

  setColliderStaticRotationOffset(value: Vector3Like): this;

  setColliderStaticRotationOffset(x: number, y: number, z: number): this;

  setColliderStaticScaleOffset(value: Vector3Like): this;

  setColliderStaticScaleOffset(x: number, y: number, z: number): this;

  setCompressibility(value: number): this;

  setConstantForce(name: string, config: ThinBatchConstantForceConfig): this;

  setConstantForce(name: string, force: ThinBatchPhysicsBodyVectorInput, options?: ThinBatchConstantForceOptions): this;

  setConstantForce(name: string, direction: ThinBatchPhysicsBodyVectorInput, strength: number, options?: ThinBatchConstantForceOptions): this;

  setDeformationDamping(value: number): this;

  setEnabled(value: boolean): this;

  setFriction(friction: number): this;

  setFrictionForAll(friction: number): this;

  setGravityFactor(factor: number): this;

  setGravityFactorForAll(factor: number): this;

  setLinearDamping(damping: number): this;

  setLinearDampingForAll(damping: number): this;

  setLinearVelocity(velocity: ThinBatchPhysicsBodyVectorInput): this;

  setLinearVelocity(x: number, y: number, z: number): this;

  setLinearVelocity(direction: ThinBatchPhysicsBodyVectorInput, speed: number): this;

  setLinearVelocityForAll(velocity: ThinBatchPhysicsBodyVectorInput): this;

  setLinearVelocityForAll(x: number, y: number, z: number): this;

  setLinearVelocityForAll(direction: ThinBatchPhysicsBodyVectorInput, speed: number): this;

  setMass(mass: number): this;

  setMassForAll(mass: number): this;

  setPlasticity(value: number): this;

  setRestitution(restitution: number): this;

  setRestitutionForAll(restitution: number): this;

  setRigidity(value: number): this;

  setStretchResistance(value: number): this;

  setViscosity(value: number): this;

  sleepWhenMotionSettled(options?: ThinBatchMotionSettleSleepOptions): this;

  stopKinematicMotion(): this;

  teleportToCurrentTransforms(): this;

  useBoxCollider(): this;

  useBoxCollider(size: Vector3Like): this;

  useBoxCollider(x: number, y: number, z: number): this;

  useCapsuleCollider(radius?: number, height?: number): this;

  useCylinderCollider(radius?: number, height?: number): this;

  useDynamicBody(): this;

  useKinematicBody(): this;

  useSphereCollider(radius?: number): this;

  useStaticBody(): this;

  useVisualBoundsCollider(shape: PrimitiveColliderShapeName): this;

}

declare class cmp_thinBatchTransform {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity);

  static readonly typeName = ComponentTypeName.ThinBatchTransform;

  at(index: number, validateIndex?: ThinBatchIndexValidator): ThinBatchTransformFrameScope;

  get capacity(): number;

  clearInstances(): this;

  get colorBuffer(): Float32Array | null;

  commitToGPU(updateExisting?: boolean): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  get count(): number;

  destroy(): void;

  get destroyPriority(): number;

  enableFrustumCulling(radius: number, scene: unknown): this;

  enlargeBy(index: number, factor: number): this;

  fitBetween(index: number, start: WavePointInput, end: WavePointInput, options?: FitBetweenOptions): this;

  get frustumCullingEnabled(): boolean;

  getColorAt(index: number): WaveThinBatchColorSample | null;

  getMatrix(index: number, terms?: ThinBatchTransformTerms): unknown;

  getMatrixToRef(index: number, target: unknown, terms?: ThinBatchTransformTerms): unknown;

  getPosition(index: number, terms?: ThinBatchTransformTerms): Vector3;

  getPositionToRef(index: number, target: Vector3, terms?: ThinBatchTransformTerms): Vector3;

  getRotation(index: number, terms?: ThinBatchTransformTerms): Quaternion;

  getRotationToRef(index: number, target: Quaternion, terms?: ThinBatchTransformTerms): Quaternion;

  getScale(index: number, terms?: ThinBatchTransformTerms): Vector3;

  getScaleToRef(index: number, target: Vector3, terms?: ThinBatchTransformTerms): Vector3;

  get matrices(): Float32Array | null;

  get mesh(): unknown | null;

  moveBy(index: number, axis: DirectionInput, units: number, frame?: ThinBatchTransformFrame): this;

  moveTo(index: number, position: WavePointInput, terms?: ThinBatchTransformTerms): this;

  moveX(index: number, units: number, frame?: ThinBatchTransformFrame): this;

  moveY(index: number, units: number, frame?: ThinBatchTransformFrame): this;

  moveZ(index: number, units: number, frame?: ThinBatchTransformFrame): this;

  rotateAroundBy(index: number, axis: DirectionInput, degrees: number, frame?: ThinBatchTransformFrame): this;

  rotateAroundTo(index: number, axis: DirectionInput, degrees: number, frame?: ThinBatchTransformFrame): this;

  rotateBy(index: number, axis: DirectionInput, degrees: number, frame?: ThinBatchTransformFrame): this;

  rotateByQuaternion(index: number, delta: Quaternion, frame?: ThinBatchTransformFrame): this;

  rotateTo(index: number, rotation: Quaternion, terms?: ThinBatchTransformTerms): this;

  scaleAlongBy(index: number, axis: DirectionInput, factor: number, frame?: ThinBatchTransformFrame): this;

  scaleAlongTo(index: number, axis: DirectionInput, value: number, frame?: ThinBatchTransformFrame): this;

  scaleBy(index: number, uniform: number, terms?: ThinBatchTransformTerms): this;

  scaleTo(index: number, value: number | Vector3Like, terms?: ThinBatchTransformTerms): this;

  scaleTowardBy(index: number, axis: DirectionInput, factor: number, frame?: ThinBatchTransformFrame): this;

  scaleTowardTo(index: number, axis: DirectionInput, value: number, frame?: ThinBatchTransformFrame): this;

  setColor(index: number, color: ColorInputAlpha): this;

  setColorHex(index: number, hex: number, alpha?: number): this;

  setColorRGBA(index: number, r: number, g: number, b: number, a?: number): this;

  setInstanceCount(count: number): this;

  setMatrix(index: number, matrix: unknown, terms?: ThinBatchTransformTerms): this;

  setPosition(index: number, position: WavePointInput, terms?: ThinBatchTransformTerms): this;

  setRotation(index: number, rotation: Quaternion, terms?: ThinBatchTransformTerms): this;

  setScale(index: number, scale: Vector3Like, terms?: ThinBatchTransformTerms): this;

  setScale(index: number, uniform: number, terms?: ThinBatchTransformTerms): this;

  setScale(index: number, x: number, y: number, z: number, terms?: ThinBatchTransformTerms): this;

  setTexturePopulation(intent: ThinBatchTexturePopulationIntent): ThinBatchTexturePopulationResult;

  setTransform(index: number, position: WavePointInput, rotation: Quaternion, scale: Vector3Like | number, terms?: ThinBatchTransformTerms): this;

  setVisible(visible: boolean): this;

  shrinkBy(index: number, factor: number): this;

  swapRemove(index: number): this;

}

declare class cmp_thinInstanceAnimator extends cmp_animatorBase implements ThinBatchTransformAnimationBackend {

  constructor(owner: WaveEntity);

  static readonly typeName = ComponentTypeName.ThinInstanceAnimator;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  deformGeometry(intent: WaveGeometryDeformIntent): this;

  get deformPlan(): WaveGeometryGpuDeformPlan | null;

  destroy(): void;

  pause(): void;

  play(): void;

  resume(): void;

  setDeformationAmount(value: number): this;

  setDeformationDirection(x: number, y: number, z: number): this;

  setMorphTarget(targetEntity: WaveGeometryMorphTarget): this;

  set speed(value: number);

  stop(): void;

  get targetMesh(): unknown | null;

}

declare class cmp_thinking<TOwner extends WaveEntity<unknown> = WaveEntity<unknown>> {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroy(): void;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: TOwner;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  typeName: string;

  constructor(owner: TOwner);

  static readonly bindingSystem = "sys_thinking";

  static readonly typeName = ComponentTypeName.Thinking;

  acceleratesWith(mode?: ThinkingAccelerationMode): this;

  get accelerationMode(): ThinkingAccelerationMode;

  get choiceDefinitions(): ReadonlyArray<NormalizedThinkingDecisionChoice>;

  get choices(): ReadonlyArray<ThinkingChoiceRunner>;

  clearContext(name?: string): this;

  clearConversationMemory(): this;

  clearInstructions(): this;

  clearKnowledge(): this;

  configureHttp(config: HttpConfig | null): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  decide(options?: ThinkingLLMDecisionOptions): this;

  get decisionSemanticVersion(): number;

  get decisionStateFunction(): ThinkingDecisionStateValueCallback | null;

  get decisionStateGranularity(): number;

  get decisionStateLabelFunction(): ThinkingDecisionStateLabelCallback | null;

  decisionStats(): ThinkingDecisionStats;

  get destroyPriority(): number;

  disableOutcomeLearning(): this;

  get discountFactor(): number;

  discreteState(): ThinkingDiscreteStateBuilder<TOwner, this>;

  get discreteStateConfig(): ThinkingDiscreteStateConfig<WaveEntity<unknown>>;

  eligibility(options: ThinkingEligibilityOptions | number): this;

  get eligibilityLambda(): number;

  enableOutcomeLearning(): this;

  get experienceCapacity(): number;

  get explorationRate(): number;

  get featureBudget(): number;

  features(options: ThinkingFeatureOptions): this;

  get featureTilings(): number;

  http(endpointId?: string): ThinkingHttpRequestBuilder;

  get isActive(): boolean;

  get isLearningEnabled(): boolean;

  get learningBackend(): ThinkingLearningBackend;

  get learningRate(): number;

  learningReport(): ThinkingDecisionPerformanceReport;

  learnsWith(backend?: ThinkingLearningBackend): this;

  get llmState(): ThinkingLLMState<WaveEntity<unknown>>;

  get maxActiveFeatures(): number;

  maximize(scoreFn: ThinkingScoreCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  minimize(scoreFn: ThinkingScoreCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  get objectiveType(): GoalType;

  onDecision(callback: ThinkingLLMDecisionCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  onError(callback: ThinkingLLMErrorCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  onResponse(callback: ThinkingLLMReplyCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  onTargetReached(callback: ThinkingTargetReachedCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  get onTargetReachedCallback(): ThinkingTargetReachedCallback | null;

  get planningSteps(): number;

  get potentialFunction(): ThinkingPotentialCallback | null;

  get predictorConfigs(): ReadonlyMap<string, PredictorConfig>;

  predictSignal(name: string, deltaTimeMs?: number): ThinkingSignalValue | null;

  readSituation(callback: ThinkingDecisionStateValueCallback<TOwner>, granularity: number, options?: WaveAuthoredCallbackOptions): this;

  readSituationLabel(callback: ThinkingDecisionStateLabelCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  rememberConversation(options?: boolean | Partial<ThinkingLLMConversationMemoryConfig>): this;

  replayPlanningSteps(steps: number): this;

  requestHttp(request: HttpRequest, options?: HttpRequestRuntimeOptions): Promise<HttpResponse>;

  requestLLM(request: LLMRequest, options?: LLMRequestRuntimeOptions): Promise<LLMResponse>;

  resetLearning(): this;

  resetPredictor(name: string): this;

  sampleTrackedSignals(): this;

  sampleWhenDeciding(enabled: boolean): this;

  get sampleWhenDecidingEnabled(): boolean;

  get scoreFunction(): ThinkingScoreCallback | null;

  sendChat(text?: string, options?: ThinkingLLMChatOptions): this;

  setEnabled(value: boolean): this;

  setHttpApiKey(endpointId: string, apiKey: string): this;

  shapeRewardWithPotential(name: string, callback: ThinkingPotentialCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  get signalCallbacks(): ReadonlyMap<string, ThinkingSignalCallback>;

  signalPattern(name: string): ThinkingSignalPattern | null;

  signalPredictionStats(name: string): ThinkingPredictorStats | null;

  startDeciding(): this;

  stepDecision(): this;

  stopDeciding(): this;

  stopTrackingSignal(name: string): this;

  get targetScore(): number | null;

  toTarget(targetScore: number): this;

  trackedSignals(): string[];

  trackSignal(name: string, callback: ThinkingSignalCallback, config?: PredictorConfig): this;

  useCharacter(character: WaveCharacter | WaveCharacterSnapshot): this;

  useLLM(backend: WaveLLMBackend): this;

  usePrompt(prompt: string | null): this;

  withBio(bio: string | null): this;

  withChoices(choices: ThinkingDecisionChoiceInput<TOwner>[], options?: WaveAuthoredCallbackOptions): this;

  withContext(name: string, provider: ThinkingLLMContextProvider<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  withDiscountFactor(gamma: number): this;

  withDiscreteSignal(name: string, callback: ThinkingDiscreteSignalCallback<TOwner>, options?: ThinkingDiscreteSignalOptions): this;

  withExplorationRate(epsilon: number): this;

  withInstruction(instruction: string | null): this;

  withKnowledge(entries: readonly string[] | string): this;

  withLearningRate(alpha: number): this;

  withLLMDecisionPolicy(policy: ThinkingLLMDecisionPolicy<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  withMood(mood: string | null): this;

  withName(name: string | null): this;

  withPersona(persona: ThinkingLLMPersonaConfig | string): this;

  withReplyPolicy(policy: ThinkingLLMReplyPolicyConfig): this;

  withStateAgeBuckets(secondsPerBucket: number | null): this;

  withStyle(style: string | null): this;

  withSystemState(lane: SystemStateLane, key?: string, alias?: string): this;

}

declare class cmp_tool {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroy(): void;

  dispose(): void;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity);

  static readonly typeName = ComponentTypeName.Tool;

  buildSpeedText(options?: SpeedDisplayOptions): string;

  clickToMark(size: number): this;

  clickToMark(options?: ClickToMarkOptions): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  get destroyPriority(): number;

  disable(): this;

  disableClickToMark(): this;

  enable(): this;

  hideAngularInertia(): this;

  hideAngularVelocity(): this;

  hideAxis(): this;

  hideBoundingBox(): this;

  hideCenterOfMass(): this;

  hideCollider(): this;

  hideControlSphere(): this;

  hideCoordinate(): this;

  hideCustomDirection(name: string): this;

  hideDimensions(): this;

  hideDirection(): this;

  hideDirectionAndAxis(): this;

  hideDistanceTo(target: DistanceTarget): this;

  hideForceArrow(): this;

  hideLabel(): this;

  hideLinearVelocity(): this;

  hideLocalPivot(): this;

  hideLocalPoint(name: string): this;

  hideMass(): this;

  hideMeshCount(): this;

  hideName(): this;

  hideOrigin(): this;

  hidePartCount(): this;

  hidePivot(): this;

  hidePlane(): this;

  hideRotation(): this;

  hideScale(): this;

  hideSkeleton(): this;

  hideSpeed(): this;

  hideTag(): this;

  get isAxisRequested(): boolean;

  get isBoundingBoxRequested(): boolean;

  get isColliderRequested(): boolean;

  get isControlSphereRequested(): boolean;

  get isCoordinateRequested(): boolean;

  get isDimensionRequested(): boolean;

  get isDirectionAndAxisRequested(): boolean;

  get isDirectionRequested(): boolean;

  get isSkeletonRequested(): boolean;

  get mode(): ToolMode;

  onCloneFinalized(): void;

  onModelLoaded(): void;

  onVisualBoundsChanged(): void;

  refreshCollider(): this;

  replaceMeshBoundingBoxTarget(oldMesh: unknown, newMesh: unknown): this;

  setMode(mode: ToolMode): this;

  showAngularInertia(options?: DevToolTextOptions): this;

  showAngularVelocity(options?: VelocityArrowOptions): this;

  showAxis(axis: Direction, options?: AxisArrowOptions): this;

  showAxis(options?: AxisArrowOptions): this;

  showBoundingBox(show: boolean, options?: BoundingBoxOptions): this;

  showBoundingBox(target: PartCreationRef | WaveModelSerializedVisualTarget, show: boolean, options?: BoundingBoxOptions): this;

  showCenterOfMass(options?: AnchorMarkerOptions): this;

  showCollider(show: boolean, color?: ColorInput): this;

  showCollider(target: PartCreationRef | WaveModelSerializedVisualTarget, show: boolean, color?: ColorInput): this;

  showControlSphere(options?: ControlSphereOptions): this;

  showCoordinate(options?: CoordinateDisplayOptions): this;

  showCustomDirection(name: string, direction: Vector3Like, options?: CustomDirectionArrowOptions): this;

  showDimensions(show: boolean, options?: DimensionArrowOptions): this;

  showDimensions(target: PartCreationRef | WaveModelSerializedVisualTarget, show: boolean, options?: DimensionArrowOptions): this;

  showDirection(direction: DirectionInput, options?: DirectionArrowOptions): this;

  showDirection(options?: DirectionArrowOptions): this;

  showDirectionAndAxis(direction: DirectionInput, options?: DirectionAndAxisArrowOptions): this;

  showDirectionAndAxis(options?: DirectionAndAxisArrowOptions): this;

  showDistanceTo(target: DistanceTarget, options?: DistanceArrowOptions): this;

  showForceArrow(options?: ForceArrowOptions): this;

  showLabel(show: boolean, options?: LabelPanelOptions): this;

  showLabel(target: PartCreationRef | WaveModelSerializedVisualTarget, show: boolean, options?: LabelPanelOptions): this;

  showLinearVelocity(options?: VelocityArrowOptions): this;

  showLocalPivot(options?: PointMarkerOptions): this;

  showLocalPoint(name: string, pointOrOptions?: WavePointInput | PointMarkerOptions, options?: PointMarkerOptions): this;

  showMass(options?: DevToolTextOptions): this;

  showMeshBoundingBox(mesh: unknown, options?: BoundingBoxOptions): this;

  showMeshCount(show?: boolean, options?: OverheadPanelOptions): this;

  showName(show: boolean, options?: OverheadPanelOptions): this;

  showName(target: PartCreationRef | WaveModelSerializedVisualTarget, show: boolean, options?: OverheadPanelOptions): this;

  showOrigin(options?: AnchorMarkerOptions): this;

  showPartCount(show?: boolean, options?: OverheadPanelOptions): this;

  showPivot(options?: PivotMarkerOptions): this;

  showPlane(options?: PlaneOptions): this;

  showPosition(options?: CoordinateDisplayOptions): this;

  showPosition(point: WavePointInput | PositionFaceCenterInput, options?: CoordinateDisplayOptions): this;

  showPosition(show: boolean, options?: CoordinateDisplayOptions): this;

  showPosition(target: PartCreationRef | WaveModelSerializedVisualTarget, show: boolean, options?: CoordinateDisplayOptions): this;

  showRotation(options?: RotationPanelOptions): this;

  showScale(options?: DevToolTextOptions): this;

  showSkeleton(options?: SkeletonViewerOptions): this;

  showSpeed(options?: SpeedDisplayOptions): this;

  showTag(options?: OverheadPanelOptions): this;

  updateAllVisualizations(): void;

  updateSpeedOverhead(): void;

}

declare class cmp_transform {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  disable(): this;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: WaveEntity<unknown>;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: WaveEntity);

  static readonly LEVEL = 0;

  static readonly typeName = ComponentTypeName.Transform;

  alignDirectionWith(target: TransformReferenceLike): this;

  alignDirectionWith(target: TransformReferenceLike, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  alignDirectionWith(target: TransformReferenceLike, mode: typeof Animate): WaveTransformAnimationBuilder;

  anchor(): WaveAnchorBuilder<this>;

  animateIntent(intent: TransformVerbIntent, config: TransformVerbAnimationConfig): TransitionLifecycleHandle<Record<string, number>>;

  animatePoseTransition(intent: TransformPoseTransitionIntent, config: TransformVerbAnimationConfig): TransitionLifecycleHandle<Record<string, number>>;

  applyIntent(intent: TransformVerbIntent, options?: ApplyTransformIntentOptions): this;

  applyParentSnapshot(snapshot: ResolvedWorldTransformSnapshot, options?: ApplyTransformSnapshotOptions): this;

  applySnapshot(snapshot: Partial<ResolvedWorldTransformSnapshot>, options?: ApplyTransformSnapshotOptions): this;

  get backwardExtent(): number;

  get backwardFaceCenter(): Vector3;

  bindExternalAnchorNode(anchor: TransformNode): this;

  buildSemanticMirroredWorldRotation(source: TransformReferenceLike, referenceTransform: cmp_transform, flip: SemanticDirection): Quaternion | null;

  clearHistory(): this;

  clearVisualRootNodes(): void;

  computeRelativePlacementAnchorWorld(args: { axis: Direction; targetTransform: cmp_transform | null; targetAnchorWorld: Vector3; distance: number; clearance?: "center" | "bounds"; }): Vector3;

  copyLocalPointToRef(name: string, out: Vector3, space?: WaveSpace | "local"): boolean;

  copyPointAuthoringFrameFrom(source: TransformReferenceLike): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  defineLocalPoint(name: string, point: WavePointInput): this;

  defineLocalPointFromWorld(name: string, worldPoint: WavePointInput): this;

  destroy(): void;

  get destroyPriority(): number;

  dispose(): void;

  distanceTo(target: WavePointInput): number;

  get downExtent(): number;

  get downFaceCenter(): Vector3;

  faceDirection(forward: Vector3Like, up?: Vector3Like): this;

  fitBetween(start: FitBetweenTarget, end: FitBetweenTarget): this;

  fitBetween(start: FitBetweenTarget, end: FitBetweenTarget, mode: typeof Snapshot): WaveTransformFitBetweenBuilder<this>;

  fitBetween(start: FitBetweenTarget, end: FitBetweenTarget, mode: typeof Animate): WaveTransformFitBetweenAnimationBuilder;

  fitBetween(start: FitBetweenTarget, end: FitBetweenTarget, options: FitBetweenOptions): this;

  get forwardExtent(): number;

  get forwardFaceCenter(): Vector3;

  getAcceleration(space?: WaveSpace): Vector3;

  getAccelerationMagnitude(space?: WaveSpace): number;

  getAngularRates(space?: WaveSpace): Vector3;

  getBankAngle(space?: WaveSpace): number;

  getChildren(): cmp_transform[];

  getDirection(direction: DirectionInput, space?: WaveSpace): Vector3;

  getEulerAngles(space?: WaveSpace): Vector3;

  getFaceCenter(axis: SemanticDirection, space?: WavePointSourceSpace): Vector3;

  getHandednessMultiplier(): 1 | -1;

  getHistorySample(when: WaveTimeLookback): TransformHistorySample | null;

  getHistorySamples(): readonly TransformHistorySample[];

  getLocalPoint(name: string, space?: WaveSpace | "local"): Vector3 | undefined;

  getNetworkData(): Record<string, unknown>;

  getOwnerOrientedBounds(): ModelOrientedBounds | null;

  getParent(): cmp_transform | null;

  getPivot(space?: WaveSpace): Vector3;

  getPosition(): Vector3;

  getPosition(space: WaveSpace): Vector3;

  getPosition(when: WaveTimeLookback): Vector3 | null;

  getPosition(space: WaveSpace, when: WaveTimeLookback): Vector3 | null;

  getPositionToRef(space: WaveSpace, target: Vector3): Vector3;

  getRotation(): Quaternion;

  getRotation(space: WaveSpace): Quaternion;

  getRotation(when: WaveTimeLookback): Quaternion | null;

  getRotation(space: WaveSpace, when: WaveTimeLookback): Quaternion | null;

  getRotationToRef(space: WaveSpace, target: Quaternion): Quaternion;

  getScale(): Vector3;

  getScale(space: WaveSpace): Vector3;

  getScale(when: WaveTimeLookback): Vector3 | null;

  getScale(space: WaveSpace, when: WaveTimeLookback): Vector3 | null;

  getSemanticDirection(direction: Direction): Vector3;

  getSpeed(): number;

  getSpeedDeclineRate(): number;

  getSpeedGrowthRate(): number;

  getTransformCarrierNodeForRead(): TransformNode;

  getVelocity(space?: WaveSpace): Vector3;

  getVisualAttachmentParentNode(): TransformNode;

  getVisualFrameWorldMatrix(): unknown;

  getVisualRootNodes(): readonly TransformNode[];

  getVisualWorldPosition(): Vector3;

  hasLocalPoint(name: string): boolean;

  get historyDepth(): number;

  get historySampleCount(): number;

  inferSemanticMirrorFlip(point: WavePointInput): SemanticDirection;

  inFrameOf(target: TransformReferenceLike): WaveTransformFrameScope<this>;

  inLocalFrame(): WaveTransformFrameScope<this>;

  inLocalTerms(): WaveTransformTermsScope<this>;

  inParentFrame(depth?: number): WaveTransformFrameScope<this>;

  inParentTerms(): WaveTransformTermsScope<this>;

  invalidateVisualCenter(): void;

  inWorldFrame(): WaveTransformFrameScope<this>;

  inWorldTerms(): WaveTransformTermsScope<this>;

  isFacing(target: TransformReferenceLike | WavePointInput, options?: WaveOrientOptions): boolean;

  get isMotionReady(): boolean;

  get isRecordingHistory(): boolean;

  keepMoving(direction: DirectionInput): WaveTransformAnimationBuilder;

  keepRotatingAround(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingAlong(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingBy(): WaveTransformAnimationBuilder;

  keepScalingToward(axis: DirectionInput): WaveTransformAnimationBuilder;

  get leftExtent(): number;

  get leftFaceCenter(): Vector3;

  localOffsetToWorldDelta(offset: Vector3Like): Vector3;

  localToParent(localPoint: Vector3Like): Vector3;

  localToParent(x: number, y: number, z: number): Vector3;

  localToWorld(localPoint: Vector3Like): Vector3;

  localToWorld(x: number, y: number, z: number): Vector3;

  locator(): WaveLocatorBuilder<this>;

  marker(modelOrScale?: string | number, markerScale?: number): WaveMarkerHandle;

  markMotionDiscontinuous(): this;

  mirrorWorldPointInSemanticBounds(point: WavePointInput, flip: SemanticDirection): Vector3;

  mirrorWorldVectorInSemanticBounds(vector: Vector3Like, flip: SemanticDirection): Vector3;

  get motionReadiness(): "warming_up" | "ready";

  moveBy(direction: DirectionInput, distance: number): this;

  moveBy(direction: DirectionInput, distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  moveBy(direction: DirectionInput, distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  moveTo(target: TransformReferenceLike | WavePointInput): this;

  moveTo(target: TransformReferenceLike | WavePointInput, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  moveTo(target: TransformReferenceLike | WavePointInput, mode: typeof Animate): WaveTransformAnimationBuilder;

  moveX(distance: number): this;

  moveX(distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  moveX(distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  moveY(distance: number): this;

  moveY(distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  moveY(distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  moveZ(distance: number): this;

  moveZ(distance: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  moveZ(distance: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  observeAngularMotion(): this;

  observeMotion(): this;

  parentSnapshot(): ResolvedWorldTransformSnapshot;

  parentSnapshot(when: WaveTimeLookback): ResolvedWorldTransformSnapshot | null;

  parentToLocal(parentPoint: Vector3Like): Vector3;

  parentToLocal(x: number, y: number, z: number): Vector3;

  recordHistory(options?: TransformHistoryRecordingOptions): this;

  registerVisualRootNode(root: TransformNode, attachmentMode?: "preserveWorld" | "preserveLocal"): void;

  removeLocalPoint(name: string): boolean;

  resetVisualFrameLocal(): void;

  get rightExtent(): number;

  get rightFaceCenter(): Vector3;

  rotateAroundBy(axis: DirectionInput, degrees: number): this;

  rotateAroundBy(axis: DirectionInput, degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  rotateAroundBy(axis: DirectionInput, degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  rotateAroundTo(axis: DirectionInput, degrees: number): this;

  rotateAroundTo(axis: DirectionInput, degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  rotateAroundTo(axis: DirectionInput, degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  rotateBy(axis: DirectionInput, degrees: number): this;

  rotateBy(axis: DirectionInput, degrees: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  rotateBy(axis: DirectionInput, degrees: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  rotateByQuaternion(delta: Quaternion): this;

  rotateByQuaternion(delta: Quaternion, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  rotateByQuaternion(delta: Quaternion, mode: typeof Animate): WaveTransformAnimationBuilder;

  rotateTo(rotation: Quaternion): this;

  rotateTo(rotation: Quaternion, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  rotateTo(rotation: Quaternion, mode: typeof Animate): WaveTransformAnimationBuilder;

  saveSnapshot(id: string, snapshot?: ResolvedWorldTransformSnapshot): WaveModelTransformSnapshotMetadata;

  scaleAlongBy(axis: DirectionInput, factor: number): this;

  scaleAlongBy(axis: DirectionInput, factor: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  scaleAlongBy(axis: DirectionInput, factor: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  scaleAlongTo(axis: DirectionInput, value: number): this;

  scaleAlongTo(axis: DirectionInput, value: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  scaleAlongTo(axis: DirectionInput, value: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  scaleBoundsAlongTo(axis: DirectionInput, targetSize: number): boolean;

  scaleBy(value: number | Vector3Like): this;

  scaleBy(value: number | Vector3Like, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<this>;

  scaleBy(value: number | Vector3Like, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  scaleTo(value: number | Vector3Like): this;

  scaleTo(value: number | Vector3Like, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  scaleTo(value: number | Vector3Like, mode: typeof Animate): WaveTransformAnimationBuilder;

  scaleTowardBy(axis: DirectionInput, factor: number): this;

  scaleTowardBy(axis: DirectionInput, factor: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  scaleTowardBy(axis: DirectionInput, factor: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  scaleTowardTo(axis: DirectionInput, value: number): this;

  scaleTowardTo(axis: DirectionInput, value: number, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  scaleTowardTo(axis: DirectionInput, value: number, mode: typeof Animate): WaveTransformAnimationBuilder;

  setDirectionBasis(config: DirectionBasisConfig): this;

  setHistoryDepth(depth: number): this;

  setParent(parent: cmp_transform | null): this;

  setPosition(pos: WavePointInput, space?: WaveSpace): this;

  setPosition(x: number, y: number, z: number, space?: WaveSpace): this;

  setRotation(rot: Quaternion, space?: WaveSpace): this;

  setScale(scale: Vector3Like): this;

  setScale(uniform: number): this;

  setScale(x: number, y: number, z: number): this;

  snapshotIntent(intent: TransformVerbIntent): ResolvedWorldTransformSnapshot;

  stopRecordingHistory(options?: { clear?: boolean; }): this;

  swapForwardUp(): this;

  swapFrontBack(): this;

  swapLeftForward(): this;

  swapLeftRight(): this;

  swapLeftUp(): this;

  swapUpDown(): this;

  transition(): WaveTransformPoseTransitionBuilder;

  transitionTo(target: ResolvedWorldTransformSnapshot): WaveTransformPoseTransitionBuilder;

  turnTo(target: TransformReferenceLike | WavePointInput): this;

  turnTo(target: TransformReferenceLike | WavePointInput, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  turnTo(target: TransformReferenceLike | WavePointInput, mode: typeof Animate): WaveTransformAnimationBuilder;

  turnToward(direction: DirectionInput): this;

  turnToward(direction: DirectionInput, mode: typeof Snapshot): WaveTransformSnapshotBuilder<this>;

  turnToward(direction: DirectionInput, mode: typeof Animate): WaveTransformAnimationBuilder;

  unregisterVisualRootNode(root: TransformNode): void;

  get upExtent(): number;

  get upFaceCenter(): Vector3;

  vectorFrom(source: WavePointInput): Vector3;

  vectorTo(target: WavePointInput): Vector3;

  visualPivotSnapshot(): ResolvedWorldTransformSnapshot;

  worldOffsetToLocal(worldOffset: Vector3Like): Vector3;

  worldSnapshot(): ResolvedWorldTransformSnapshot;

  worldSnapshot(when: WaveTimeLookback): ResolvedWorldTransformSnapshot | null;

  worldToLocal(worldPoint: Vector3Like): Vector3;

  worldToLocal(x: number, y: number, z: number): Vector3;

}

declare class cmp_transformAnimator extends cmp_animatorBase {

  constructor(owner: WaveEntity);

  static readonly typeName = ComponentTypeName.TransformAnimator;

}

declare class cmp_visual3DModel<TOwner extends wave3DObject = wave3DObject> {

  actualizeStoredMaterialState(): boolean;

  addDecal(texture: string): DecalBuilder;

  addingNoise(): NoiseBuilder;

  addLocalAnimations(): void;

  adoptPart(targetObject: wave3DObject, options?: AdoptPartOptions): wave3DObject;

  adoptPartMesh(partEntityId: number, meshName: string): void;

  adoptParts(targetObjects: readonly wave3DObject[], options?: AdoptPartsOptions): wave3DObject[];

  adoptPartsFrom(targetObject: wave3DObject, options?: AdoptPartsOptions): wave3DObject[];

  alignOriginToModelBounds(forceAnchorMove?: boolean): module_visual3DModelSurfaceState<TOwner>;

  allowUnsafePartDestroy: boolean;

  anchor(anchorRef: string): WaveAttachmentSocket;

  applyPartPose(values: Readonly<Record<string, WaveModelPoseValue>>, options?: VisualModelPoseApplyOptions): module_visual3DModelSurfaceState<TOwner>;

  applyPartPoseBuffer(jointIds: readonly string[], values: Float64Array, options?: VisualModelPoseApplyOptions): module_visual3DModelSurfaceState<TOwner>;

  applyPartPoseSnapshot(preset: WaveModelRigPoseSnapshotMetadata, options?: VisualModelPoseApplyOptions): module_visual3DModelSurfaceState<TOwner>;

  applySurfaceConfig(config: ObjectSurfaceConfig, options?: { preserveExplicitColor?: boolean; }): void;

  applyTexturePainting(intent: PaintVertexColorsTextureIntent): VertexColorResult;

  attract(options: AttractOptions, force?: boolean): MeshEditResult;

  attracting(): AttractBuilder;

  autoRenameMeshes(): Record<string, string>;

  bend(options: BendOptions, force?: boolean): MeshEditResult;

  bending(): BendBuilder;

  bindMeshesToPart(partRef: PartRef, meshRefs: readonly MeshRef[], options?: BindMeshesToPartOptions): PartEntry;

  booleanBatch(steps: readonly VisualModelBooleanBatchStep[], options?: VisualModelBooleanOptions): CSGResult;

  bulging(): SurfaceDeformationBuilder;

  cacheVertices(force?: boolean): MeshEditResult;

  canEditMesh(): { canEdit: boolean; reason?: string; }

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  capturePartPose(name?: string, options?: VisualModelPoseApplyOptions): WaveModelRigPoseSnapshotMetadata;

  captureProjectMaterialAssetDefinition(): ProjectMaterialAssetDefinition;

  castShadow: boolean;

  clearDecals(): void;

  clearEmissiveDistortionInput(): void;

  clearGeometryInfluenceView(): module_visual3DModelSurfaceState<TOwner>;

  clearGpuDataSourceBindings(): module_visual3DModelSurfaceState<TOwner>;

  clearPbrModifiers(target?: VisualModelTarget | null): module_visual3DModelSurfaceState<TOwner>;

  clearReflectionPolicy(target?: WaveVisualTargetRef): module_visual3DModelSurfaceState<TOwner>;

  clearSurfaceVfx(options?: { resetProgress?: boolean; }): module_visual3DModelSurfaceState<TOwner>;

  clearVertexCache(force?: boolean): void;

  clearVideo(): void;

  clonePart(partRef: PartRef, options?: Omit<ExtractPartsOptions, "mode" | "source" | "partName">): wave3DObject;

  cloneParts(selection: PartSelection, options?: Omit<ExtractPartsOptions, "mode" | "source" | "partName">): wave3DObject[];

  collectVatPlaybackMeshes(): readonly { readonly mesh: unknown; readonly meshId?: string; readonly name: string; }[];

  combinePart(...args: Array<PartRef | readonly PartRef[] | CombinePartsOptions | null | undefined>): wave3DObject;

  combinePart(partRef: PartRef, options?: CombinePartsOptions): wave3DObject;

  combinePart(partRef: PartRef, secondPartRef: PartRef, ...partRefs: PartRef[]): wave3DObject;

  combinePart(partRef: PartRef, secondPartRef: PartRef, ...partRefsAndOptions: Array<PartRef | CombinePartsOptions>): wave3DObject;

  combinePart(partRefs: readonly PartRef[], options?: CombinePartsOptions): wave3DObject;

  readonly componentName: string;

  configureGaussianSplat(config: WaveGaussianSplatRuntimeConfig): module_visual3DModelSurfaceState<TOwner>;

  createAllParts(options?: CreatePartsOptions): wave3DObject[];

  createInstanceSource(options?: CreateInstanceSourceOptions): WaveInstanceSource;

  createPart(partName: string, options?: CreatePartsOptions): wave3DObject;

  createPart(partRef: PartCreationRef, options?: CreatePartsOptions): wave3DObject;

  createParts(selection?: PartCreationSelection, options?: CreatePartsOptions): wave3DObject[];

  createParts(selection?: string | readonly string[], options?: CreatePartsOptions): wave3DObject[];

  csgBatching(): CSGBatchBuilder;

  cut(tool: CutToolLike, capColorOrOptions?: FragInteriorColorInput | CutOptions): CutResult;

  cutting(tool: CutToolLike): CutBuilder;

  decalLayerMask: number;

  defineSurfaceState(input: WaveScalarSurfaceStateDefinition): WaveScalarSurfaceStateHandle;

  deleteVertexSelection(selection: VertexSelection, options?: VertexDeleteOptions, force?: boolean): VertexSelectionResult;

  destroyAllParts(): PartDeleteResult[];

  destroyPart(partRef: PartRef): void;

  destroyParts(selection: PartDestructiveSelection): PartDeleteResult[];

  disable(): this;

  disableAutoLOD(): module_visual3DModelSurfaceState<TOwner>;

  disableEdgeRendering(): module_visual3DModelSurfaceState<TOwner>;

  disableFresnelGlow(): module_visual3DModelSurfaceState<TOwner>;

  disableGlow(): module_visual3DModelSurfaceState<TOwner>;

  disableHighlight(): module_visual3DModelSurfaceState<TOwner>;

  disableOutline(): module_visual3DModelSurfaceState<TOwner>;

  disableSelectionOutline(): module_visual3DModelSurfaceState<TOwner>;

  disableTrail(): module_visual3DModelSurfaceState<TOwner>;

  discolorSurface(options?: SurfaceDiscolorOptions): module_visual3DModelSurfaceState<TOwner>;

  displacing(): DisplaceBuilder;

  dispose(): void;

  edgeColor: unknown;

  edgeEpsilon: number;

  edgeRenderingEnabled: boolean;

  edgeWidth: number;

  emissiveDistortion(): EmissiveDistortionBuilder;

  enable(): this;

  enableAutoLOD(config?: AutoLODConfig): module_visual3DModelSurfaceState<TOwner>;

  enableBreadcrumbTrail(options?: BreadcrumbTrailOptions): VisualBreadcrumbTrailHandle;

  enabled: boolean;

  enableEdgeRendering(options?: { width?: number; color?: ColorInput | string | [ number, number, number ] | number | null; epsilon?: number; }): module_visual3DModelSurfaceState<TOwner>;

  enableFresnelGlow(options?: { color?: ColorInput | string | [ number, number, number ] | number | null; bias?: number; power?: number; }): module_visual3DModelSurfaceState<TOwner>;

  enableGlow(intensity?: number, color?: ColorInput | string | [ number, number, number ] | number | null): module_visual3DModelSurfaceState<TOwner>;

  enableHighlight(color?: ColorInput | string | [ number, number, number ] | number | null, options?: { innerGlow?: boolean; outerGlow?: boolean; glowEmissiveOnly?: boolean; }): module_visual3DModelSurfaceState<TOwner>;

  enableOutline(options?: Parameters<module_visual3DModelEffectState["enableSelectionOutline"]>[0]): module_visual3DModelSurfaceState<TOwner>;

  enableSelectionOutline(options?: { thicknessPixels?: number; color?: ColorInput | string | [ number, number, number ] | number | null; occlusionStrength?: number; occlusionThreshold?: number; }): module_visual3DModelSurfaceState<TOwner>;

  enableTrail(options?: { blendFactor?: number; halfLifeSeconds?: number; intensity?: number; blendMode?: MotionTrailBlendMode; stretchPixels?: number; samples?: number; stretchDirection?: Vector2Like_3; worldSpace?: boolean; trailColor?: ColorInput | null; }): module_visual3DModelSurfaceState<TOwner>;

  engine: unknown;

  ensureIndependentMaterial(): unknown | null;

  eraseSurface(options?: SurfaceErasureOptions): module_visual3DModelSurfaceState<TOwner>;

  eraseVertexColors(center: WavePointInput, radius: number, channel: VertexColorChannel, falloff?: PaintBrushFalloff, force?: boolean): VertexColorResult;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Clone; }): wave3DObject;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Promote | WaveModelPartExtractionMode.Clone; }): TOwner | wave3DObject<unknown>;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Promote; }): TOwner;

  extractParts(selection: PartSelection, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Clone | WaveModelPartExtractionMode.Adopt; }): wave3DObject[];

  extractParts(selection: PartSelection, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Promote; }): TOwner[];

  extractParts(selection: PartSelection, options: ExtractPartsOptions): (TOwner | wave3DObject<unknown>)[];

  extrude(options: ExtrudeOptions, force?: boolean): MeshEditResult;

  extruding(): ExtrudeBuilder;

  findNearestVertex(at: Vector3Like, options?: VertexQueryOptions, force?: boolean): VertexQueryResult;

  flexing(): FlexBuilder;

  frag(fragmentCount: number, interiorColor?: FragInteriorColorInput, seed?: number, localOrigin?: { x: number; y: number; z: number; }, force?: boolean, worldOrigin?: { x: number; y: number; z: number; }): FragResult;

  fragmenting(): WaveSimpleFractureBuilder;

  fresnelBias: number;

  fresnelColor: unknown;

  fresnelEnabled: boolean;

  fresnelPower: number;

  gaussianSplat(): WaveGaussianSplatRuntimeHandle<module_visual3DModelSurfaceState<TOwner>>;

  geometryInfluenceViewEnabled: boolean;

  geometryInfluenceViewState: GeometryInfluenceViewModelState | null;

  getAccumulatedDeformation(deformationType: "bend" | "twist" | "skew" | "taper" | "regionalScale" | "extrude", force?: boolean): number | { startScale: number; endScale: number; } | RegionalScaleAccumulation | undefined;

  getBoundingBox(): ModelBoundingBox | null;

  getBoundingBoxVolume(): number;

  getBoundModelValue(): WaveSceneModelValue | null;

  getColliderBounds(): { centerLocal: Vector3; halfExtents: Vector3; } | null;

  getEditableMesh(force?: boolean): unknown | null;

  getGaussianSplatInfo(): WaveGaussianSplatRuntimeInfo | null;

  getHalfExtents(): Vector3;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getMesh(name: string, scope?: MeshScope): unknown | undefined;

  getMeshCount(scope?: MeshScope): number;

  getMeshEntry(meshRef: MeshRef, scope?: MeshScope): MeshEntry | undefined;

  getMeshes(scope?: MeshScope): readonly unknown[];

  getModelBounds(space?: BoundsSpace, useRestPose?: boolean, forceRefresh?: boolean, includeHiddenOrDisabledMeshes?: boolean): ModelBounds | null;

  getModelTopologySignature(): string | null;

  getOrientedBounds(): ModelOrientedBounds | null;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getPart(partName: string, scope?: WaveModelPartScope): wave3DObject | undefined;

  getPart(partRef: PartRef | VisualPartId, scope?: WaveModelPartScope): wave3DObject | undefined;

  getPartCount(scope?: WaveModelPartScope): number;

  getPartGraphMetadata(): WaveModelRigGraphMetadata | undefined;

  getPartGraphPoseController(): WavePartGraphPoseController;

  getPartInfo(partName: string, scope?: WaveModelPartScope): VisualPartInfo | undefined;

  getPartInfo(partRef: PartRef | VisualPartId, scope?: WaveModelPartScope): VisualPartInfo | undefined;

  getPartMetadata(partRef: PartRef, scope?: WaveModelPartScope): WaveModelPartMetadata | undefined;

  getParts(scope?: WaveModelPartScope): readonly wave3DObject[];

  getPbrModifierInstances(): readonly PbrModifierInstanceSnapshot[];

  getSize(): Vector3;

  getSkinAuthoringMesh(force?: boolean): unknown | null;

  getSurfaceState(id: string): WaveScalarSurfaceStateHandle | null;

  getVertexCache(force?: boolean): VertexCache | undefined;

  getVertexCount(meshName?: string): number;

  getVertexTopologyVersion(force?: boolean): number | null;

  getVisualBounds(space?: BoundsSpace): ModelBounds | null;

  glowColor: any;

  glowEnabled: boolean;

  glowIntensity: number;

  gpuBinding<TType extends WaveShaderBindingType = WaveShaderBindingType>(name: string): WaveGpuDrivenBindingHandle<TType>;

  gpuData(id: string): WaveGpuDrivenDataChannelHandle;

  gpuDataSourceDebugTexel(channelId: string, x: number, y: number): WaveGpuDataSourceDebugTexel | null;

  gpuDataSourceDiagnostics(): WaveGpuDataSourceDiagnostics;

  gpuDataSources(): WaveGpuDataSourceBindingBuilder<module_visual3DModelSurfaceState<TOwner>>;

  gpuDrivenDiagnostics(): WaveGpuDrivenModelRuntimeDiagnostics;

  gpuDrivenReady(): Promise<void>;

  gpuStateKernel(id: string): WaveGpuDrivenStateKernelHandle;

  hasFixedModelTopology: boolean;

  hasOwnedMeshes: boolean;

  hasPart(partName: string, scope?: WaveModelPartScope): boolean;

  hasPart(partRef: PartRef | VisualPartId, scope?: WaveModelPartScope): boolean;

  hasSharedMaterial(): boolean;

  hasVertexCache(force?: boolean): boolean;

  hide(): void;

  highlightColor: unknown;

  highlightEnabled: boolean;

  highlightGlowEmissiveOnly: boolean;

  highlightInnerGlow: boolean;

  highlightOuterGlow: boolean;

  init(): Promise<void> | void;

  initVertexColors(initialChannel?: VertexColorChannel, overwrite?: boolean, force?: boolean): VertexColorResult;

  instanceEntries: any;

  intersect(operand: VisualModelBooleanInput, options?: VisualModelBooleanOptions): CSGResult;

  intersecting(operand: VisualModelBooleanInput): CSGBuilder;

  intersectMany(operands: readonly VisualModelBooleanInput[], options?: VisualModelBooleanOptions): CSGResult;

  invalidateVisualBounds(): void;

  isAggregateMeshOwner: boolean;

  isCapable: boolean;

  isComponentActive: boolean;

  isDecomposedShell: boolean;

  isDestroyed: boolean;

  isDisposed: boolean;

  isDisposing: boolean;

  isEdgeDirty: boolean;

  isFresnelDirty: boolean;

  isGaussianSplat(): boolean;

  isGeometryInfluenceViewDirty: boolean;

  isGlowDirty: boolean;

  isGpuDrivenModel(): boolean;

  isHighlightDirty: boolean;

  isManifold(scope?: MeshScope): boolean;

  isMaterialStateDirty: boolean;

  isMeshlessModelRoot: boolean;

  isModelRevisionConsumerCurrent(): boolean;

  isMultiMesh(): boolean;

  isOutlineDirty: boolean;

  isPart: boolean;

  isPartView(): boolean;

  isRenderTintDirty: boolean;

  isSingleMesh(): boolean;

  isTrailDirty: boolean;

  isUnbound: boolean;

  listDecals(): waveDecal[];

  listGpuBindings(): readonly string[];

  listGpuDataChannels(): readonly string[];

  listGpuStateKernels(): readonly string[];

  listMeshEntries(scope?: MeshScope): MeshEntry[];

  listMeshes(scope?: MeshScope): MeshEntry[];

  listMeshNames(scope?: MeshScope): string[];

  listPartInfos(scope?: WaveModelPartScope): readonly VisualPartInfo[];

  listPartJointControls(query?: string): readonly WaveModelJointControlInfo[];

  listPartNames(scope?: WaveModelPartScope): string[];

  listParts(scope?: WaveModelPartScope): readonly VisualPartInfo[];

  markEdgeClean(): void;

  markFresnelClean(): void;

  markGeometryInfluenceViewClean(): void;

  markGlowClean(): void;

  markHighlightClean(): void;

  markMaterialStateClean(): void;

  markOutlineClean(): void;

  markPartAsPromoted(partId: string): void;

  markRenderTintClean(): void;

  markTrailClean(): void;

  materialAlphaMode: ProjectMaterialAlphaMode | null;

  materialAnisotropy: MaterialAnisotropyState;

  materialAssetName: string | null;

  materialClearCoat: MaterialClearCoatState;

  materialColor: unknown;

  materialDoubleSided: boolean;

  materialEmissiveColor: unknown;

  materialEmissiveIntensity: number;

  materialEnvironmentIntensity: number | null;

  materialFor(target: VisualModelTarget, slot?: number): MaterialEditorView;

  materialIridescence: MaterialIridescenceState;

  materialMaxSimultaneousLights: number | null;

  materialMetalness: number;

  materialOpacity: number;

  materialRoughness: number;

  materialSheen: MaterialSheenState;

  materialSlotFor(target: VisualModelTarget, slot: number): MaterialEditorView;

  materialSpecularIntensity: number | null;

  materialSubSurface: MaterialSubSurfaceState;

  materialTextures: { base?: string; normal?: string; metallic?: string; roughness?: string; ao?: string; emissive?: string; thickness?: string; transmission?: string; translucencyColor?: string; translucencyIntensity?: string; }

  materialTransparencyMode: ProjectMaterialTransparencyMode | null;

  materialType: "private" | "public";

  materialUseRadianceOverAlpha: boolean | null;

  materialUseSpecularOverAlpha: boolean | null;

  materialUVOffset: Vector2;

  materialUVRotation: number;

  materialUVRotationRadians: number;

  materialUVScale: Vector2;

  materialWireframe: boolean;

  maxDecals: number;

  mergeMeshes(disposeOriginals?: boolean): unknown | null;

  meshMaterial(name: string): MaterialEditorView;

  meshMaterialSlot(name: string, slot: number): MaterialEditorView;

  meshOwnershipState: MeshOwnershipState;

  modelName: string | null;

  modelRevisionAssetOwner: SceneAssetAccess;

  modelRevisionContributionGeneration: number;

  modifyWith(recipe: WavePbrModifierRecipe, options?: WavePbrModifierApplicationOptions): module_visual3DModelSurfaceState<TOwner>;

  morphingTo(target: WaveGeometryMorphTarget): MorphToBuilder;

  moveVertices(selection: VertexSelection, movement: DirectionInput, distance: number, options?: VertexMoveOptions, force?: boolean): VertexSelectionResult;

  moveVertices(selection: VertexSelection, movement: Vector3Like, options?: VertexMoveOptions, force?: boolean): VertexSelectionResult;

  readonly name: string;

  noise(options: NoiseOptions, force?: boolean): MeshEditResult;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  outlineColor: unknown;

  outlineEnabled: boolean;

  outlineOcclusionStrength: number;

  outlineOcclusionThreshold: number;

  outlineThicknessPixels: number;

  owner: TOwner;

  painting(): PaintVertexColorsBuilder;

  paintingPolygon(): PaintVertexColorsPolygonBuilder;

  paintingTexture(): PaintVertexColorsTextureBuilder;

  paintVertexColors(options: PaintVertexColorsOptions, force?: boolean): VertexColorResult;

  paintVertexColorsPolygon(options: PaintVertexColorsPolygonOptions, force?: boolean): VertexColorResult;

  partMaterial(partRef: PartRef, slot?: number): MaterialEditorView;

  partMaterialSlot(partRef: PartRef, slot: number): MaterialEditorView;

  partOwnerVisual: cmp_visual3DModel<wave3DObject<unknown>> | null;

  pickPartAtWorldPoint(point: Vector3Like, options?: PickPartOptions): wave3DObject | undefined;

  prepareOperablePBR(): MaterialPretreatmentResult;

  previewPartPose(elapsedMs: number, options?: VisualModelPosePreviewOptions): Readonly<Record<string, WaveModelPoseValue>>;

  prewarmSurfaceVfx(options?: SurfaceErasureWarmupOptions): SurfaceErasureWarmupResult;

  primaryMesh: any;

  privatizeMaterial(): void;

  promotedPartIds: unknown;

  promotedPartSource: PromotedVisualPartSource | null;

  promotePart(partRef: PartRef): TOwner;

  promoteParts(selection: PartSelection): TOwner[];

  promoteResultMeshes(meshes: readonly unknown[]): TOwner[];

  qualifyMeshesAsParts(selection?: MeshRef | readonly MeshRef[], options?: CreatePartsOptions): PartEntry[];

  receiveDecals: boolean;

  receiveShadow: boolean;

  reflection(target?: WaveVisualTargetRef): WaveVisualReflectionBuilder;

  reflectionPolicies: readonly WaveReflectionReceiverPolicy[];

  refreshGpuDataSources(): module_visual3DModelSurfaceState<TOwner>;

  regionalScaling(): RegionalScaleBuilder;

  reloadModel(modelName: string): void;

  removeAntiTiling(): void;

  removeDecal(decal: waveDecal): void;

  removeEmissiveDistortion(): void;

  removeMaterial(options?: { fromAll?: boolean; restoreInnate?: boolean; }): void;

  removeMeshFromModel(mesh: unknown, meshKey: string): void;

  removeModel(): void;

  removePbrModifier(instanceIdInput: string): module_visual3DModelSurfaceState<TOwner>;

  removeSurfaceState(id: string): boolean;

  removeWorldEmissive(): void;

  renameMesh(meshRef: MeshRef, newName: string): string;

  renameMeshes(renames?: Readonly<Record<string, string>>): Record<string, string>;

  renamePart(partRef: PartRef, newName: string): string;

  renameParts(renames?: Readonly<Record<string, string>>): Record<string, string>;

  renderTintColor: unknown;

  renderTintEnabled: boolean;

  reparentPart(childPartRef: PartRef, parentPartRef: PartRef | null): PartMutationResult;

  replaceFollowCurrentModel(change: AssetRevisionChange<"model">): void;

  requireEditableMesh(force?: boolean): unknown;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  requireSkinAuthoringMesh(force?: boolean): unknown;

  resetDeformation(deformationType: "bend" | "twist" | "skew" | "taper" | "regionalScale" | "noise" | "attract" | "extrude" | "all", force?: boolean): MeshEditResult;

  resetOrigin(forceAnchorMove?: boolean): module_visual3DModelSurfaceState<TOwner>;

  resetPartPose(options?: VisualModelPoseApplyOptions): module_visual3DModelSurfaceState<TOwner>;

  resolveMaterialSplatPaintChannel(layer: VertexColorChannel | MaterialSplatLayerId): VertexColorChannel;

  restoreVertices(force?: boolean): MeshEditResult;

  runTimeCleanUp(): void;

  saveIntoModelAsset(options?: SaveIntoModelAssetOptions): Promise<SaveIntoModelAssetResult>;

  scaleRegion(options: RegionalScaleOptions, force?: boolean): MeshEditResult;

  scene: WaveScene<unknown> | null;

  segment(options: SegmentOptions | readonly SegmentOptions[], force?: boolean): SegmentResult;

  segmenting(): SegmentBuilder;

  selectFaceVertices(faceIndex: number, force?: boolean): VertexSelectionResult;

  selectVertex(vertexIndex: number, force?: boolean): VertexSelectionResult;

  selectVertexNeighbors(selection: VertexSelection, rings?: number, force?: boolean): VertexSelectionResult;

  selectVerticesInRadius(center: Vector3Like, radius: number, options?: VertexQueryOptions, force?: boolean): VertexSelectionResult;

  setAlphaMode(mode: MaterialAlphaMode | null): void;

  setAnisotropy(config: Partial<Omit<MaterialAnisotropyState, "direction">> & { direction?: Vector2 | readonly [ number, number ]; }): void;

  setAntiTiling(options?: WaveMaterialAntiTilingOptions): void;

  setAOTexture(texturePath: string): void;

  setBaseTexture(texturePath: string): void;

  setClearCoat(config: Partial<MaterialClearCoatState>): void;

  setColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setDecalLayerMask(v: number): module_visual3DModelSurfaceState<TOwner>;

  setDepthBias(value: number): void;

  setDoubleSided(enabled: boolean): void;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setEmissiveDistortion(config: EmissiveDistortionConfig): void;

  setEmissiveEffect<THandle extends WaveTextureEffectHandle = WaveTextureEffectHandle>(effect: WaveEffectInput): THandle;

  setEmissiveIntensity(intensity: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveIntensity(intensity: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveIntensity(intensity: number): void;

  setEmissiveTexture(texturePath: string): void;

  setEmissiveWobbleInput(x: number, y: number): void;

  setEnvironmentIntensity(value: number): void;

  setGeometryInfluenceView(state: GeometryInfluenceViewModelState): module_visual3DModelSurfaceState<TOwner>;

  setGlowColor(color: ColorInput | string | [ number, number, number ] | number | null): module_visual3DModelSurfaceState<TOwner>;

  setGlowIntensity(intensity: number): module_visual3DModelSurfaceState<TOwner>;

  setGpuDataSourceBindings(input: WaveGpuDataSourceBindingPlanInput): module_visual3DModelSurfaceState<TOwner>;

  setHighlightColor(color: ColorInput | string | [ number, number, number ] | number): module_visual3DModelSurfaceState<TOwner>;

  setIndexOfRefraction(ior: number): void;

  setIridescence(config: Partial<MaterialIridescenceState>): void;

  setMaxDecals(v: number): module_visual3DModelSurfaceState<TOwner>;

  setMaximumThickness(value: number): void;

  setMaxSimultaneousLights(value: number): void;

  setMeshes(input: MeshPatchInput): MeshMutationResult[];

  setMeshMaterialColor(meshName: string, color: unknown | string | [ number, number, number ] | number, preserveInterior?: boolean): boolean;

  setMetallicTexture(texturePath: string): void;

  setMetalness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setMetalness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setMetalness(value: number): void;

  setMinimumThickness(value: number): void;

  setNormalTexture(texturePath: string): void;

  setOpacity(alpha: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setOpacity(alpha: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setOpacity(alpha: number): void;

  setPart(partRef: PartRef, patch: PartPatchValue): PartMutationResult;

  setPartJointValue(jointIdOrName: string, value: WaveModelPoseValue, options?: VisualModelPoseApplyOptions): module_visual3DModelSurfaceState<TOwner>;

  setPartMassProperties(partRef: PartRef, input: PartMassPropertiesInput): PartMutationResult;

  setPartMetadata(partRef: PartRef, metadata: WaveModelPartMetadata | null | undefined): PartMutationResult;

  setParts(input: PartPatchInput): PartMutationResult[];

  setPbrModifier(instanceIdInput: string, recipeInput: WavePbrModifierRecipe, options?: SetPbrModifierOptions): module_visual3DModelSurfaceState<TOwner>;

  setPbrModifierEnabled(instanceIdInput: string, enabled: boolean): module_visual3DModelSurfaceState<TOwner>;

  setPbrModifierInputBindings(instanceIdInput: string, patch: WavePbrModifierInputBindings): module_visual3DModelSurfaceState<TOwner>;

  setPbrModifierOrder(instanceIds: readonly string[]): module_visual3DModelSurfaceState<TOwner>;

  setPbrModifierParameters(instanceIdInput: string, patch: WavePbrModifierParameterValues): module_visual3DModelSurfaceState<TOwner>;

  setReceiveDecals(v: boolean): module_visual3DModelSurfaceState<TOwner>;

  setReflectionPolicy(policy: WaveReflectionReceiverPolicy): module_visual3DModelSurfaceState<TOwner>;

  setRefractionIntensity(value: number): void;

  setRoughness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setRoughness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setRoughness(value: number): void;

  setRoughnessTexture(texturePath: string): void;

  setSheen(config: Partial<Omit<MaterialSheenState, "color">> & { color?: ColorInput | string | [ number, number, number ] | number; }): void;

  setSpecularIntensity(value: number): void;

  setSubSurface(config: Partial<Omit<MaterialSubSurfaceState, "tintColor">> & { tintColor?: ColorInput | string | [ number, number, number ] | number | null; }): void;

  setSubSurfaceTintColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setSurfacePreset(preset: SurfacePreset, category?: SurfaceCategory): void;

  setSurfaceVfxProgress(progress: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setSurfaceVfxProgress(progress: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setSurfaceVfxProgress(progress: number): module_visual3DModelSurfaceState<TOwner>;

  setThicknessTexture(texturePath: string): void;

  setTrailBlendFactor(factor: number): module_visual3DModelSurfaceState<TOwner>;

  setTrailColor(color: ColorInput | string | [ number, number, number ] | number | null): module_visual3DModelSurfaceState<TOwner>;

  setTranslucencyColorTexture(texturePath: string): void;

  setTranslucencyIntensity(value: number): void;

  setTranslucencyIntensityTexture(texturePath: string): void;

  setTransmissionTexture(texturePath: string): void;

  setUseRadianceOverAlpha(enabled: boolean): void;

  setUseSpecularOverAlpha(enabled: boolean): void;

  setUVOffset(offset: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(offset: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(offset: Vector2): void;

  setUVOffset(uOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, vOffset?: number): void;

  setUVRotation(degrees: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVRotation(degrees: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVRotation(degrees: number): void;

  setUVScale(scale: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(scale: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(scale: Vector2): void;

  setUVScale(uScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, vScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, vScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, vScale?: number): void;

  setWireframe(enabled: boolean): void;

  setWorldEmissive(config: WorldEmissiveConfig): void;

  show(): void;

  showMeshBoundingBox(meshRef: MeshRef, options?: BoundingBoxOptions): module_visual3DModelSurfaceState<TOwner>;

  skew(options: SkewOptions, force?: boolean): MeshEditResult;

  skewing(): SkewBuilder;

  source: ModelConsumerSource | null;

  stretching(): StretchBuilder;

  subdivideVertexSelection(selection: VertexSelection, options?: VertexSubdivideOptions, force?: boolean): VertexTopologyResult;

  subtract(operand: VisualModelBooleanInput, options?: VisualModelBooleanOptions): CSGResult;

  subtracting(operand: VisualModelBooleanInput): CSGBuilder;

  subtractMany(operands: readonly VisualModelBooleanInput[], options?: VisualModelBooleanOptions): CSGResult;

  surface(selector: WaveFaceSelector, localDirection?: readonly [ number, number, number ]): WaveGeometrySurfaceHandle<MaterialEditorView>;

  surfaceSelection(id: string): WaveModelSurfaceSelectionBuilder;

  surfaceState(id: string): WaveScalarSurfaceStateBuilder<TOwner>;

  swaying(): SwayBuilder;

  syncMaterialFreezePolicy(): void;

  taper(options: TaperOptions, force?: boolean): MeshEditResult;

  tapering(): TaperBuilder;

  trailBlendFactor: number;

  trailBlendMode: MotionTrailBlendMode;

  trailColor: any;

  trailEnabled: boolean;

  trailHalfLifeSeconds: number | null;

  trailIntensity: number;

  trailSamples: number;

  trailStretchDirection: { x: number; y: number; } | null;

  trailStretchPixels: number;

  trailWorldSpace: boolean;

  transformVertices(selection: VertexSelection, options: VertexTransformOptions, force?: boolean): VertexSelectionResult;

  triggerEmissiveRipple(u?: number, v?: number, strength?: number): void;

  twist(options: TwistOptions, force?: boolean): MeshEditResult;

  twisting(): TwistBuilder;

  typeName: string;

  unbindMeshesFromPart(partRef: PartRef, meshRefs?: readonly MeshRef[]): unknown[];

  union(operand: VisualModelBooleanInput, options?: VisualModelBooleanOptions): CSGResult;

  unioning(operand: VisualModelBooleanInput): CSGBuilder;

  unionMany(operands: readonly VisualModelBooleanInput[], options?: VisualModelBooleanOptions): CSGResult;

  unmanageAllParts(): unknown[];

  unmanagePart(partRef: PartRef): unknown;

  unmanageParts(selection: PartDestructiveSelection): unknown[];

  useFixedGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedGeneratedModel(model: string): boolean;

  useFixedGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedModel(model: Visual3DModelAuthoringInput, options?: Omit<Visual3DModelUseOptions, "topology">): void;

  useGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useGeneratedModel(model: string): boolean;

  useGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useMaterial(material: MaterialInput, toAll?: boolean, materialType?: MaterialUseMode): void;

  useModel(model: Visual3DModelAuthoringInput, options?: Visual3DModelUseOptions): void;

  usePrivateMaterialInput(input: WaveMaterialInput, toAll?: boolean): void;

  useVideo(video: VisualVideoSource, intent?: VideoBindingIntent, serial?: WaveVideoPlaybackSerialState): WaveVideoPlayback | null;

  vertexEditing(): VertexEditingBuilder;

  videoMaterial(videoAssetName?: string): WaveVideoPlayback | null;

  visualLayer: VisualLayer;

  voxelize(options: VoxelizationOptions & { readonly execution: "workerThread"; }): VoxelGridResultAsync;

  voxelize(options: VoxelizationOptions): VoxelGridResult | VoxelGridResultAsync;

  voxelize(options?: VoxelizationOptions & { readonly execution?: "mainThread"; }): VoxelGridResult;

  voxelizing(): Visual3DModelVoxelizingBuilder<TOwner, "mainThread">;

  constructor(owner: TOwner);

  actualizeStoredMaterialState(): boolean;

  addDecal(texture: string): DecalBuilder;

  addingNoise(): NoiseBuilder;

  addLocalAnimations(): void;

  adoptPart(targetObject: wave3DObject, options?: AdoptPartOptions): wave3DObject;

  adoptPartMesh(partEntityId: number, meshName: string): void;

  adoptParts(targetObjects: readonly wave3DObject[], options?: AdoptPartsOptions): wave3DObject[];

  adoptPartsFrom(targetObject: wave3DObject, options?: AdoptPartsOptions): wave3DObject[];

  alignOriginToModelBounds(forceAnchorMove?: boolean): module_visual3DModelSurfaceState<TOwner>;

  allowUnsafePartDestroy: boolean;

  anchor(anchorRef: string): WaveAttachmentSocket;

  applyPartPose(values: Readonly<Record<string, WaveModelPoseValue>>, options?: VisualModelPoseApplyOptions): module_visual3DModelSurfaceState<TOwner>;

  applyPartPoseBuffer(jointIds: readonly string[], values: Float64Array, options?: VisualModelPoseApplyOptions): module_visual3DModelSurfaceState<TOwner>;

  applyPartPoseSnapshot(preset: WaveModelRigPoseSnapshotMetadata, options?: VisualModelPoseApplyOptions): module_visual3DModelSurfaceState<TOwner>;

  applySurfaceConfig(config: ObjectSurfaceConfig, options?: { preserveExplicitColor?: boolean; }): void;

  applyTexturePainting(intent: PaintVertexColorsTextureIntent): VertexColorResult;

  attract(options: AttractOptions, force?: boolean): MeshEditResult;

  attracting(): AttractBuilder;

  autoRenameMeshes(): Record<string, string>;

  bend(options: BendOptions, force?: boolean): MeshEditResult;

  bending(): BendBuilder;

  bindMeshesToPart(partRef: PartRef, meshRefs: readonly MeshRef[], options?: BindMeshesToPartOptions): PartEntry;

  booleanBatch(steps: readonly VisualModelBooleanBatchStep[], options?: VisualModelBooleanOptions): CSGResult;

  bulging(): SurfaceDeformationBuilder;

  cacheVertices(force?: boolean): MeshEditResult;

  canEditMesh(): { canEdit: boolean; reason?: string; }

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  capturePartPose(name?: string, options?: VisualModelPoseApplyOptions): WaveModelRigPoseSnapshotMetadata;

  captureProjectMaterialAssetDefinition(): ProjectMaterialAssetDefinition;

  castShadow: boolean;

  clearDecals(): void;

  clearEmissiveDistortionInput(): void;

  clearGeometryInfluenceView(): module_visual3DModelSurfaceState<TOwner>;

  clearGpuDataSourceBindings(): module_visual3DModelSurfaceState<TOwner>;

  clearPbrModifiers(target?: VisualModelTarget | null): module_visual3DModelSurfaceState<TOwner>;

  clearReflectionPolicy(target?: WaveVisualTargetRef): module_visual3DModelSurfaceState<TOwner>;

  clearSurfaceVfx(options?: { resetProgress?: boolean; }): module_visual3DModelSurfaceState<TOwner>;

  clearVertexCache(force?: boolean): void;

  clearVideo(): void;

  clonePart(partRef: PartRef, options?: Omit<ExtractPartsOptions, "mode" | "source" | "partName">): wave3DObject;

  cloneParts(selection: PartSelection, options?: Omit<ExtractPartsOptions, "mode" | "source" | "partName">): wave3DObject[];

  collectVatPlaybackMeshes(): readonly { readonly mesh: unknown; readonly meshId?: string; readonly name: string; }[];

  combinePart(...args: Array<PartRef | readonly PartRef[] | CombinePartsOptions | null | undefined>): wave3DObject;

  combinePart(partRef: PartRef, options?: CombinePartsOptions): wave3DObject;

  combinePart(partRef: PartRef, secondPartRef: PartRef, ...partRefs: PartRef[]): wave3DObject;

  combinePart(partRef: PartRef, secondPartRef: PartRef, ...partRefsAndOptions: Array<PartRef | CombinePartsOptions>): wave3DObject;

  combinePart(partRefs: readonly PartRef[], options?: CombinePartsOptions): wave3DObject;

  readonly componentName: string;

  configureGaussianSplat(config: WaveGaussianSplatRuntimeConfig): module_visual3DModelSurfaceState<TOwner>;

  createAllParts(options?: CreatePartsOptions): wave3DObject[];

  createInstanceSource(options?: CreateInstanceSourceOptions): WaveInstanceSource;

  createPart(partName: string, options?: CreatePartsOptions): wave3DObject;

  createPart(partRef: PartCreationRef, options?: CreatePartsOptions): wave3DObject;

  createParts(selection?: PartCreationSelection, options?: CreatePartsOptions): wave3DObject[];

  createParts(selection?: string | readonly string[], options?: CreatePartsOptions): wave3DObject[];

  csgBatching(): CSGBatchBuilder;

  cut(tool: CutToolLike, capColorOrOptions?: FragInteriorColorInput | CutOptions): CutResult;

  cutting(tool: CutToolLike): CutBuilder;

  decalLayerMask: number;

  defineSurfaceState(input: WaveScalarSurfaceStateDefinition): WaveScalarSurfaceStateHandle;

  deleteVertexSelection(selection: VertexSelection, options?: VertexDeleteOptions, force?: boolean): VertexSelectionResult;

  destroyAllParts(): PartDeleteResult[];

  destroyPart(partRef: PartRef): void;

  destroyParts(selection: PartDestructiveSelection): PartDeleteResult[];

  disable(): this;

  disableAutoLOD(): module_visual3DModelSurfaceState<TOwner>;

  disableEdgeRendering(): module_visual3DModelSurfaceState<TOwner>;

  disableFresnelGlow(): module_visual3DModelSurfaceState<TOwner>;

  disableGlow(): module_visual3DModelSurfaceState<TOwner>;

  disableHighlight(): module_visual3DModelSurfaceState<TOwner>;

  disableOutline(): module_visual3DModelSurfaceState<TOwner>;

  disableSelectionOutline(): module_visual3DModelSurfaceState<TOwner>;

  disableTrail(): module_visual3DModelSurfaceState<TOwner>;

  discolorSurface(options?: SurfaceDiscolorOptions): module_visual3DModelSurfaceState<TOwner>;

  displacing(): DisplaceBuilder;

  dispose(): void;

  edgeColor: unknown;

  edgeEpsilon: number;

  edgeRenderingEnabled: boolean;

  edgeWidth: number;

  emissiveDistortion(): EmissiveDistortionBuilder;

  enable(): this;

  enableAutoLOD(config?: AutoLODConfig): module_visual3DModelSurfaceState<TOwner>;

  enableBreadcrumbTrail(options?: BreadcrumbTrailOptions): VisualBreadcrumbTrailHandle;

  enabled: boolean;

  enableEdgeRendering(options?: { width?: number; color?: ColorInput | string | [ number, number, number ] | number | null; epsilon?: number; }): module_visual3DModelSurfaceState<TOwner>;

  enableFresnelGlow(options?: { color?: ColorInput | string | [ number, number, number ] | number | null; bias?: number; power?: number; }): module_visual3DModelSurfaceState<TOwner>;

  enableGlow(intensity?: number, color?: ColorInput | string | [ number, number, number ] | number | null): module_visual3DModelSurfaceState<TOwner>;

  enableHighlight(color?: ColorInput | string | [ number, number, number ] | number | null, options?: { innerGlow?: boolean; outerGlow?: boolean; glowEmissiveOnly?: boolean; }): module_visual3DModelSurfaceState<TOwner>;

  enableOutline(options?: Parameters<module_visual3DModelEffectState["enableSelectionOutline"]>[0]): module_visual3DModelSurfaceState<TOwner>;

  enableSelectionOutline(options?: { thicknessPixels?: number; color?: ColorInput | string | [ number, number, number ] | number | null; occlusionStrength?: number; occlusionThreshold?: number; }): module_visual3DModelSurfaceState<TOwner>;

  enableTrail(options?: { blendFactor?: number; halfLifeSeconds?: number; intensity?: number; blendMode?: MotionTrailBlendMode; stretchPixels?: number; samples?: number; stretchDirection?: Vector2Like_3; worldSpace?: boolean; trailColor?: ColorInput | null; }): module_visual3DModelSurfaceState<TOwner>;

  engine: unknown;

  ensureIndependentMaterial(): unknown | null;

  eraseSurface(options?: SurfaceErasureOptions): module_visual3DModelSurfaceState<TOwner>;

  eraseVertexColors(center: WavePointInput, radius: number, channel: VertexColorChannel, falloff?: PaintBrushFalloff, force?: boolean): VertexColorResult;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Clone; }): wave3DObject;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Promote | WaveModelPartExtractionMode.Clone; }): TOwner | wave3DObject<unknown>;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Promote; }): TOwner;

  extractParts(selection: PartSelection, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Clone | WaveModelPartExtractionMode.Adopt; }): wave3DObject[];

  extractParts(selection: PartSelection, options: ExtractPartsOptions & { readonly mode: WaveModelPartExtractionMode.Promote; }): TOwner[];

  extractParts(selection: PartSelection, options: ExtractPartsOptions): (TOwner | wave3DObject<unknown>)[];

  extrude(options: ExtrudeOptions, force?: boolean): MeshEditResult;

  extruding(): ExtrudeBuilder;

  findNearestVertex(at: Vector3Like, options?: VertexQueryOptions, force?: boolean): VertexQueryResult;

  flexing(): FlexBuilder;

  frag(fragmentCount: number, interiorColor?: FragInteriorColorInput, seed?: number, localOrigin?: { x: number; y: number; z: number; }, force?: boolean, worldOrigin?: { x: number; y: number; z: number; }): FragResult;

  fragmenting(): WaveSimpleFractureBuilder;

  fresnelBias: number;

  fresnelColor: unknown;

  fresnelEnabled: boolean;

  fresnelPower: number;

  gaussianSplat(): WaveGaussianSplatRuntimeHandle<module_visual3DModelSurfaceState<TOwner>>;

  geometryInfluenceViewEnabled: boolean;

  geometryInfluenceViewState: GeometryInfluenceViewModelState | null;

  getAccumulatedDeformation(deformationType: "bend" | "twist" | "skew" | "taper" | "regionalScale" | "extrude", force?: boolean): number | { startScale: number; endScale: number; } | RegionalScaleAccumulation | undefined;

  getBoundingBox(): ModelBoundingBox | null;

  getBoundingBoxVolume(): number;

  getBoundModelValue(): WaveSceneModelValue | null;

  getColliderBounds(): { centerLocal: Vector3; halfExtents: Vector3; } | null;

  getEditableMesh(force?: boolean): unknown | null;

  getGaussianSplatInfo(): WaveGaussianSplatRuntimeInfo | null;

  getHalfExtents(): Vector3;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getMesh(name: string, scope?: MeshScope): unknown | undefined;

  getMeshCount(scope?: MeshScope): number;

  getMeshEntry(meshRef: MeshRef, scope?: MeshScope): MeshEntry | undefined;

  getMeshes(scope?: MeshScope): readonly unknown[];

  getModelBounds(space?: BoundsSpace, useRestPose?: boolean, forceRefresh?: boolean, includeHiddenOrDisabledMeshes?: boolean): ModelBounds | null;

  getModelTopologySignature(): string | null;

  getOrientedBounds(): ModelOrientedBounds | null;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getPart(partName: string, scope?: WaveModelPartScope): wave3DObject | undefined;

  getPart(partRef: PartRef | VisualPartId, scope?: WaveModelPartScope): wave3DObject | undefined;

  getPartCount(scope?: WaveModelPartScope): number;

  getPartGraphMetadata(): WaveModelRigGraphMetadata | undefined;

  getPartGraphPoseController(): WavePartGraphPoseController;

  getPartInfo(partName: string, scope?: WaveModelPartScope): VisualPartInfo | undefined;

  getPartInfo(partRef: PartRef | VisualPartId, scope?: WaveModelPartScope): VisualPartInfo | undefined;

  getPartMetadata(partRef: PartRef, scope?: WaveModelPartScope): WaveModelPartMetadata | undefined;

  getParts(scope?: WaveModelPartScope): readonly wave3DObject[];

  getPbrModifierInstances(): readonly PbrModifierInstanceSnapshot[];

  getSize(): Vector3;

  getSkinAuthoringMesh(force?: boolean): unknown | null;

  getSurfaceState(id: string): WaveScalarSurfaceStateHandle | null;

  getVertexCache(force?: boolean): VertexCache | undefined;

  getVertexCount(meshName?: string): number;

  getVertexTopologyVersion(force?: boolean): number | null;

  getVisualBounds(space?: BoundsSpace): ModelBounds | null;

  glowColor: any;

  glowEnabled: boolean;

  glowIntensity: number;

  gpuBinding<TType extends WaveShaderBindingType = WaveShaderBindingType>(name: string): WaveGpuDrivenBindingHandle<TType>;

  gpuData(id: string): WaveGpuDrivenDataChannelHandle;

  gpuDataSourceDebugTexel(channelId: string, x: number, y: number): WaveGpuDataSourceDebugTexel | null;

  gpuDataSourceDiagnostics(): WaveGpuDataSourceDiagnostics;

  gpuDataSources(): WaveGpuDataSourceBindingBuilder<module_visual3DModelSurfaceState<TOwner>>;

  gpuDrivenDiagnostics(): WaveGpuDrivenModelRuntimeDiagnostics;

  gpuDrivenReady(): Promise<void>;

  gpuStateKernel(id: string): WaveGpuDrivenStateKernelHandle;

  hasFixedModelTopology: boolean;

  hasOwnedMeshes: boolean;

  hasPart(partName: string, scope?: WaveModelPartScope): boolean;

  hasPart(partRef: PartRef | VisualPartId, scope?: WaveModelPartScope): boolean;

  hasSharedMaterial(): boolean;

  hasVertexCache(force?: boolean): boolean;

  hide(): void;

  highlightColor: unknown;

  highlightEnabled: boolean;

  highlightGlowEmissiveOnly: boolean;

  highlightInnerGlow: boolean;

  highlightOuterGlow: boolean;

  init(): Promise<void> | void;

  initVertexColors(initialChannel?: VertexColorChannel, overwrite?: boolean, force?: boolean): VertexColorResult;

  instanceEntries: any;

  intersect(operand: VisualModelBooleanInput, options?: VisualModelBooleanOptions): CSGResult;

  intersecting(operand: VisualModelBooleanInput): CSGBuilder;

  intersectMany(operands: readonly VisualModelBooleanInput[], options?: VisualModelBooleanOptions): CSGResult;

  invalidateVisualBounds(): void;

  isAggregateMeshOwner: boolean;

  isCapable: boolean;

  isComponentActive: boolean;

  isDecomposedShell: boolean;

  isDestroyed: boolean;

  isDisposed: boolean;

  isDisposing: boolean;

  isEdgeDirty: boolean;

  isFresnelDirty: boolean;

  isGaussianSplat(): boolean;

  isGeometryInfluenceViewDirty: boolean;

  isGlowDirty: boolean;

  isGpuDrivenModel(): boolean;

  isHighlightDirty: boolean;

  isManifold(scope?: MeshScope): boolean;

  isMaterialStateDirty: boolean;

  isMeshlessModelRoot: boolean;

  isModelRevisionConsumerCurrent(): boolean;

  isMultiMesh(): boolean;

  isOutlineDirty: boolean;

  isPart: boolean;

  isPartView(): boolean;

  isRenderTintDirty: boolean;

  isSingleMesh(): boolean;

  isTrailDirty: boolean;

  isUnbound: boolean;

  listDecals(): waveDecal[];

  listGpuBindings(): readonly string[];

  listGpuDataChannels(): readonly string[];

  listGpuStateKernels(): readonly string[];

  listMeshEntries(scope?: MeshScope): MeshEntry[];

  listMeshes(scope?: MeshScope): MeshEntry[];

  listMeshNames(scope?: MeshScope): string[];

  listPartInfos(scope?: WaveModelPartScope): readonly VisualPartInfo[];

  listPartJointControls(query?: string): readonly WaveModelJointControlInfo[];

  listPartNames(scope?: WaveModelPartScope): string[];

  listParts(scope?: WaveModelPartScope): readonly VisualPartInfo[];

  markEdgeClean(): void;

  markFresnelClean(): void;

  markGeometryInfluenceViewClean(): void;

  markGlowClean(): void;

  markHighlightClean(): void;

  markMaterialStateClean(): void;

  markOutlineClean(): void;

  markPartAsPromoted(partId: string): void;

  markRenderTintClean(): void;

  markTrailClean(): void;

  materialAlphaMode: ProjectMaterialAlphaMode | null;

  materialAnisotropy: MaterialAnisotropyState;

  materialAssetName: string | null;

  materialClearCoat: MaterialClearCoatState;

  materialColor: unknown;

  materialDoubleSided: boolean;

  materialEmissiveColor: unknown;

  materialEmissiveIntensity: number;

  materialEnvironmentIntensity: number | null;

  materialFor(target: VisualModelTarget, slot?: number): MaterialEditorView;

  materialIridescence: MaterialIridescenceState;

  materialMaxSimultaneousLights: number | null;

  materialMetalness: number;

  materialOpacity: number;

  materialRoughness: number;

  materialSheen: MaterialSheenState;

  materialSlotFor(target: VisualModelTarget, slot: number): MaterialEditorView;

  materialSpecularIntensity: number | null;

  materialSubSurface: MaterialSubSurfaceState;

  materialTextures: { base?: string; normal?: string; metallic?: string; roughness?: string; ao?: string; emissive?: string; thickness?: string; transmission?: string; translucencyColor?: string; translucencyIntensity?: string; }

  materialTransparencyMode: ProjectMaterialTransparencyMode | null;

  materialType: "private" | "public";

  materialUseRadianceOverAlpha: boolean | null;

  materialUseSpecularOverAlpha: boolean | null;

  materialUVOffset: Vector2;

  materialUVRotation: number;

  materialUVRotationRadians: number;

  materialUVScale: Vector2;

  materialWireframe: boolean;

  maxDecals: number;

  mergeMeshes(disposeOriginals?: boolean): unknown | null;

  meshMaterial(name: string): MaterialEditorView;

  meshMaterialSlot(name: string, slot: number): MaterialEditorView;

  meshOwnershipState: MeshOwnershipState;

  modelName: string | null;

  modelRevisionAssetOwner: SceneAssetAccess;

  modelRevisionContributionGeneration: number;

  modifyWith(recipe: WavePbrModifierRecipe, options?: WavePbrModifierApplicationOptions): module_visual3DModelSurfaceState<TOwner>;

  morphingTo(target: WaveGeometryMorphTarget): MorphToBuilder;

  moveVertices(selection: VertexSelection, movement: DirectionInput, distance: number, options?: VertexMoveOptions, force?: boolean): VertexSelectionResult;

  moveVertices(selection: VertexSelection, movement: Vector3Like, options?: VertexMoveOptions, force?: boolean): VertexSelectionResult;

  readonly name: string;

  noise(options: NoiseOptions, force?: boolean): MeshEditResult;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  outlineColor: unknown;

  outlineEnabled: boolean;

  outlineOcclusionStrength: number;

  outlineOcclusionThreshold: number;

  outlineThicknessPixels: number;

  owner: TOwner;

  painting(): PaintVertexColorsBuilder;

  paintingPolygon(): PaintVertexColorsPolygonBuilder;

  paintingTexture(): PaintVertexColorsTextureBuilder;

  paintVertexColors(options: PaintVertexColorsOptions, force?: boolean): VertexColorResult;

  paintVertexColorsPolygon(options: PaintVertexColorsPolygonOptions, force?: boolean): VertexColorResult;

  partMaterial(partRef: PartRef, slot?: number): MaterialEditorView;

  partMaterialSlot(partRef: PartRef, slot: number): MaterialEditorView;

  partOwnerVisual: cmp_visual3DModel<wave3DObject<unknown>> | null;

  pickPartAtWorldPoint(point: Vector3Like, options?: PickPartOptions): wave3DObject | undefined;

  prepareOperablePBR(): MaterialPretreatmentResult;

  previewPartPose(elapsedMs: number, options?: VisualModelPosePreviewOptions): Readonly<Record<string, WaveModelPoseValue>>;

  prewarmSurfaceVfx(options?: SurfaceErasureWarmupOptions): SurfaceErasureWarmupResult;

  primaryMesh: any;

  privatizeMaterial(): void;

  promotedPartIds: unknown;

  promotedPartSource: PromotedVisualPartSource | null;

  promotePart(partRef: PartRef): TOwner;

  promoteParts(selection: PartSelection): TOwner[];

  promoteResultMeshes(meshes: readonly unknown[]): TOwner[];

  qualifyMeshesAsParts(selection?: MeshRef | readonly MeshRef[], options?: CreatePartsOptions): PartEntry[];

  receiveDecals: boolean;

  receiveShadow: boolean;

  reflection(target?: WaveVisualTargetRef): WaveVisualReflectionBuilder;

  reflectionPolicies: readonly WaveReflectionReceiverPolicy[];

  refreshGpuDataSources(): module_visual3DModelSurfaceState<TOwner>;

  regionalScaling(): RegionalScaleBuilder;

  reloadModel(modelName: string): void;

  removeAntiTiling(): void;

  removeDecal(decal: waveDecal): void;

  removeEmissiveDistortion(): void;

  removeMaterial(options?: { fromAll?: boolean; restoreInnate?: boolean; }): void;

  removeMeshFromModel(mesh: unknown, meshKey: string): void;

  removeModel(): void;

  removePbrModifier(instanceIdInput: string): module_visual3DModelSurfaceState<TOwner>;

  removeSurfaceState(id: string): boolean;

  removeWorldEmissive(): void;

  renameMesh(meshRef: MeshRef, newName: string): string;

  renameMeshes(renames?: Readonly<Record<string, string>>): Record<string, string>;

  renamePart(partRef: PartRef, newName: string): string;

  renameParts(renames?: Readonly<Record<string, string>>): Record<string, string>;

  renderTintColor: unknown;

  renderTintEnabled: boolean;

  reparentPart(childPartRef: PartRef, parentPartRef: PartRef | null): PartMutationResult;

  replaceFollowCurrentModel(change: AssetRevisionChange<"model">): void;

  requireEditableMesh(force?: boolean): unknown;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  requireSkinAuthoringMesh(force?: boolean): unknown;

  resetDeformation(deformationType: "bend" | "twist" | "skew" | "taper" | "regionalScale" | "noise" | "attract" | "extrude" | "all", force?: boolean): MeshEditResult;

  resetOrigin(forceAnchorMove?: boolean): module_visual3DModelSurfaceState<TOwner>;

  resetPartPose(options?: VisualModelPoseApplyOptions): module_visual3DModelSurfaceState<TOwner>;

  resolveMaterialSplatPaintChannel(layer: VertexColorChannel | MaterialSplatLayerId): VertexColorChannel;

  restoreVertices(force?: boolean): MeshEditResult;

  runTimeCleanUp(): void;

  saveIntoModelAsset(options?: SaveIntoModelAssetOptions): Promise<SaveIntoModelAssetResult>;

  scaleRegion(options: RegionalScaleOptions, force?: boolean): MeshEditResult;

  scene: WaveScene<unknown> | null;

  segment(options: SegmentOptions | readonly SegmentOptions[], force?: boolean): SegmentResult;

  segmenting(): SegmentBuilder;

  selectFaceVertices(faceIndex: number, force?: boolean): VertexSelectionResult;

  selectVertex(vertexIndex: number, force?: boolean): VertexSelectionResult;

  selectVertexNeighbors(selection: VertexSelection, rings?: number, force?: boolean): VertexSelectionResult;

  selectVerticesInRadius(center: Vector3Like, radius: number, options?: VertexQueryOptions, force?: boolean): VertexSelectionResult;

  setAlphaMode(mode: MaterialAlphaMode | null): void;

  setAnisotropy(config: Partial<Omit<MaterialAnisotropyState, "direction">> & { direction?: Vector2 | readonly [ number, number ]; }): void;

  setAntiTiling(options?: WaveMaterialAntiTilingOptions): void;

  setAOTexture(texturePath: string): void;

  setBaseTexture(texturePath: string): void;

  setClearCoat(config: Partial<MaterialClearCoatState>): void;

  setColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setDecalLayerMask(v: number): module_visual3DModelSurfaceState<TOwner>;

  setDepthBias(value: number): void;

  setDoubleSided(enabled: boolean): void;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setEmissiveDistortion(config: EmissiveDistortionConfig): void;

  setEmissiveEffect<THandle extends WaveTextureEffectHandle = WaveTextureEffectHandle>(effect: WaveEffectInput): THandle;

  setEmissiveIntensity(intensity: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveIntensity(intensity: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveIntensity(intensity: number): void;

  setEmissiveTexture(texturePath: string): void;

  setEmissiveWobbleInput(x: number, y: number): void;

  setEnvironmentIntensity(value: number): void;

  setGeometryInfluenceView(state: GeometryInfluenceViewModelState): module_visual3DModelSurfaceState<TOwner>;

  setGlowColor(color: ColorInput | string | [ number, number, number ] | number | null): module_visual3DModelSurfaceState<TOwner>;

  setGlowIntensity(intensity: number): module_visual3DModelSurfaceState<TOwner>;

  setGpuDataSourceBindings(input: WaveGpuDataSourceBindingPlanInput): module_visual3DModelSurfaceState<TOwner>;

  setHighlightColor(color: ColorInput | string | [ number, number, number ] | number): module_visual3DModelSurfaceState<TOwner>;

  setIndexOfRefraction(ior: number): void;

  setIridescence(config: Partial<MaterialIridescenceState>): void;

  setMaxDecals(v: number): module_visual3DModelSurfaceState<TOwner>;

  setMaximumThickness(value: number): void;

  setMaxSimultaneousLights(value: number): void;

  setMeshes(input: MeshPatchInput): MeshMutationResult[];

  setMeshMaterialColor(meshName: string, color: unknown | string | [ number, number, number ] | number, preserveInterior?: boolean): boolean;

  setMetallicTexture(texturePath: string): void;

  setMetalness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setMetalness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setMetalness(value: number): void;

  setMinimumThickness(value: number): void;

  setNormalTexture(texturePath: string): void;

  setOpacity(alpha: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setOpacity(alpha: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setOpacity(alpha: number): void;

  setPart(partRef: PartRef, patch: PartPatchValue): PartMutationResult;

  setPartJointValue(jointIdOrName: string, value: WaveModelPoseValue, options?: VisualModelPoseApplyOptions): module_visual3DModelSurfaceState<TOwner>;

  setPartMassProperties(partRef: PartRef, input: PartMassPropertiesInput): PartMutationResult;

  setPartMetadata(partRef: PartRef, metadata: WaveModelPartMetadata | null | undefined): PartMutationResult;

  setParts(input: PartPatchInput): PartMutationResult[];

  setPbrModifier(instanceIdInput: string, recipeInput: WavePbrModifierRecipe, options?: SetPbrModifierOptions): module_visual3DModelSurfaceState<TOwner>;

  setPbrModifierEnabled(instanceIdInput: string, enabled: boolean): module_visual3DModelSurfaceState<TOwner>;

  setPbrModifierInputBindings(instanceIdInput: string, patch: WavePbrModifierInputBindings): module_visual3DModelSurfaceState<TOwner>;

  setPbrModifierOrder(instanceIds: readonly string[]): module_visual3DModelSurfaceState<TOwner>;

  setPbrModifierParameters(instanceIdInput: string, patch: WavePbrModifierParameterValues): module_visual3DModelSurfaceState<TOwner>;

  setReceiveDecals(v: boolean): module_visual3DModelSurfaceState<TOwner>;

  setReflectionPolicy(policy: WaveReflectionReceiverPolicy): module_visual3DModelSurfaceState<TOwner>;

  setRefractionIntensity(value: number): void;

  setRoughness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setRoughness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setRoughness(value: number): void;

  setRoughnessTexture(texturePath: string): void;

  setSheen(config: Partial<Omit<MaterialSheenState, "color">> & { color?: ColorInput | string | [ number, number, number ] | number; }): void;

  setSpecularIntensity(value: number): void;

  setSubSurface(config: Partial<Omit<MaterialSubSurfaceState, "tintColor">> & { tintColor?: ColorInput | string | [ number, number, number ] | number | null; }): void;

  setSubSurfaceTintColor(color: ColorInput | string | [ number, number, number ] | number): void;

  setSurfacePreset(preset: SurfacePreset, category?: SurfaceCategory): void;

  setSurfaceVfxProgress(progress: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setSurfaceVfxProgress(progress: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setSurfaceVfxProgress(progress: number): module_visual3DModelSurfaceState<TOwner>;

  setThicknessTexture(texturePath: string): void;

  setTrailBlendFactor(factor: number): module_visual3DModelSurfaceState<TOwner>;

  setTrailColor(color: ColorInput | string | [ number, number, number ] | number | null): module_visual3DModelSurfaceState<TOwner>;

  setTranslucencyColorTexture(texturePath: string): void;

  setTranslucencyIntensity(value: number): void;

  setTranslucencyIntensityTexture(texturePath: string): void;

  setTransmissionTexture(texturePath: string): void;

  setUseRadianceOverAlpha(enabled: boolean): void;

  setUseSpecularOverAlpha(enabled: boolean): void;

  setUVOffset(offset: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(offset: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(offset: Vector2): void;

  setUVOffset(uOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, vOffset?: number): void;

  setUVRotation(degrees: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVRotation(degrees: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVRotation(degrees: number): void;

  setUVScale(scale: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(scale: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(scale: Vector2): void;

  setUVScale(uScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, vScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, vScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, vScale?: number): void;

  setWireframe(enabled: boolean): void;

  setWorldEmissive(config: WorldEmissiveConfig): void;

  show(): void;

  showMeshBoundingBox(meshRef: MeshRef, options?: BoundingBoxOptions): module_visual3DModelSurfaceState<TOwner>;

  skew(options: SkewOptions, force?: boolean): MeshEditResult;

  skewing(): SkewBuilder;

  source: ModelConsumerSource | null;

  stretching(): StretchBuilder;

  subdivideVertexSelection(selection: VertexSelection, options?: VertexSubdivideOptions, force?: boolean): VertexTopologyResult;

  subtract(operand: VisualModelBooleanInput, options?: VisualModelBooleanOptions): CSGResult;

  subtracting(operand: VisualModelBooleanInput): CSGBuilder;

  subtractMany(operands: readonly VisualModelBooleanInput[], options?: VisualModelBooleanOptions): CSGResult;

  surface(selector: WaveFaceSelector, localDirection?: readonly [ number, number, number ]): WaveGeometrySurfaceHandle<MaterialEditorView>;

  surfaceSelection(id: string): WaveModelSurfaceSelectionBuilder;

  surfaceState(id: string): WaveScalarSurfaceStateBuilder<TOwner>;

  swaying(): SwayBuilder;

  syncMaterialFreezePolicy(): void;

  taper(options: TaperOptions, force?: boolean): MeshEditResult;

  tapering(): TaperBuilder;

  trailBlendFactor: number;

  trailBlendMode: MotionTrailBlendMode;

  trailColor: any;

  trailEnabled: boolean;

  trailHalfLifeSeconds: number | null;

  trailIntensity: number;

  trailSamples: number;

  trailStretchDirection: { x: number; y: number; } | null;

  trailStretchPixels: number;

  trailWorldSpace: boolean;

  transformVertices(selection: VertexSelection, options: VertexTransformOptions, force?: boolean): VertexSelectionResult;

  triggerEmissiveRipple(u?: number, v?: number, strength?: number): void;

  twist(options: TwistOptions, force?: boolean): MeshEditResult;

  twisting(): TwistBuilder;

  typeName: string;

  unbindMeshesFromPart(partRef: PartRef, meshRefs?: readonly MeshRef[]): unknown[];

  union(operand: VisualModelBooleanInput, options?: VisualModelBooleanOptions): CSGResult;

  unioning(operand: VisualModelBooleanInput): CSGBuilder;

  unionMany(operands: readonly VisualModelBooleanInput[], options?: VisualModelBooleanOptions): CSGResult;

  unmanageAllParts(): unknown[];

  unmanagePart(partRef: PartRef): unknown;

  unmanageParts(selection: PartDestructiveSelection): unknown[];

  useFixedGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedGeneratedModel(model: string): boolean;

  useFixedGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useFixedModel(model: Visual3DModelAuthoringInput, options?: Omit<Visual3DModelUseOptions, "topology">): void;

  useGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): boolean;

  useGeneratedModel(model: string): boolean;

  useGeneratedModel(model: Visual3DModelGeneratedAttachmentInput): boolean;

  useMaterial(material: MaterialInput, toAll?: boolean, materialType?: MaterialUseMode): void;

  useModel(model: Visual3DModelAuthoringInput, options?: Visual3DModelUseOptions): void;

  usePrivateMaterialInput(input: WaveMaterialInput, toAll?: boolean): void;

  useVideo(video: VisualVideoSource, intent?: VideoBindingIntent, serial?: WaveVideoPlaybackSerialState): WaveVideoPlayback | null;

  vertexEditing(): VertexEditingBuilder;

  videoMaterial(videoAssetName?: string): WaveVideoPlayback | null;

  visualLayer: VisualLayer;

  voxelize(options: VoxelizationOptions & { readonly execution: "workerThread"; }): VoxelGridResultAsync;

  voxelize(options: VoxelizationOptions): VoxelGridResult | VoxelGridResultAsync;

  voxelize(options?: VoxelizationOptions & { readonly execution?: "mainThread"; }): VoxelGridResult;

  voxelizing(): Visual3DModelVoxelizingBuilder<TOwner, "mainThread">;

  static readonly typeName = ComponentTypeName.Visual3DModel;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  destroy(): void;

  get destroyPriority(): number;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

}

declare class cmp_xrAnchor<TOwner extends WaveEntity = WaveEntity> {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroy(): void;

  destroyPriority: number;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: TOwner;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: TOwner, config?: XRAnchorConfig);

  static readonly typeName = ComponentTypeName.XRAnchor;

  get anchorId(): string | null;

  get anchorState(): XRAnchorState;

  applyAnchorSnapshot(anchorId: string, snapshot: ResolvedWorldTransformSnapshot): this;

  clearAnchor(): this;

  configure(config: XRAnchorConfig): this;

  copyStateFrom(source: WaveComponent, options: CloneOptions): void;

  get persistent(): boolean;

  get placement(): XRAnchorPlacement;

  get scaleMode(): XRScaleMode;

  setAnchorState(anchorId: string | null, isAnchored: boolean): this;

  setPersistent(persistent: boolean): this;

  setPlacement(placement: XRAnchorPlacement): this;

  setScaleMode(mode: XRScaleMode): this;

}

declare class cmp_xrInteractable<TOwner extends WaveEntity = WaveEntity> {

  canPlayAudio: boolean;

  canRender: boolean;

  canSimulatePhysics: boolean;

  readonly componentName: string;

  destroy(): void;

  destroyPriority: number;

  disable(): this;

  dispose(): void;

  enable(): this;

  enabled: boolean;

  engine: unknown;

  getLiveOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getLiveOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getOwnerComponent<T extends WaveComponent>(componentName: string): T | undefined;

  init(): Promise<void> | void;

  isCapable: boolean;

  isComponentActive: boolean;

  isDestroyed: boolean;

  isDisposing: boolean;

  isUnbound: boolean;

  readonly name: string;

  offCreated(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | ComponentLifecycleCallback): boolean;

  onCloneFinalized(): void;

  onCreated(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: ComponentLifecycleCallback, nameOrOptions?: ComponentLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  owner: TOwner;

  requireOwnerComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  requireOwnerComponent<T extends WaveComponent>(componentName: string): T;

  scene: WaveScene<unknown> | null;

  serialize(): SerializedCall[];

  setEnabled(value: boolean): this;

  typeName: string;

  constructor(owner: TOwner, config?: XRInteractableConfig);

  static readonly typeName = ComponentTypeName.XRInteractable;

  clearGrabState(): this;

  configure(config: XRInteractableConfig): this;

  copyStateFrom(source: WaveComponent, _options: CloneOptions): void;

  get followRotation(): boolean;

  get grabOffset(): Vector3Like | undefined;

  get grabPoint(): Vector3Like | undefined;

  get grabState(): XRGrabState;

  get hapticIntensity(): number;

  hasMode(mode: XRInteractionMode): boolean;

  get isGrabbed(): boolean;

  get modes(): XRInteractionMode[];

  get nearInteractDistance(): number;

  setFollowRotation(enabled: boolean): this;

  setGrabHandedness(handedness: "left" | "right" | "none"): this;

  setGrabOffset(offset: Vector3Like | undefined): this;

  setGrabOwnerClientId(clientId: string | null): this;

  setGrabPoint(point: WavePointInput | undefined): this;

  setHapticIntensity(intensity: number): this;

  setModes(modes: XRInteractionMode[]): this;

  setNearInteractDistance(distanceMeters: number): this;

}

declare const COLOR: WaveColorSingleton;

declare function comboTileKit(input: ComboTileKitSourceInput): ComboTileKitSourceConfig;

type ComboTileKitSemanticTag = (typeof ComboTileKitSemanticTag)[keyof typeof ComboTileKitSemanticTag];

declare const ComboTileKitSemanticTag: Readonly<{ readonly Water: "water"; readonly Grass: "grass"; readonly Forest: "forest"; readonly Road: "road"; readonly River: "river"; readonly Bridge: "bridge"; readonly City: "city"; readonly Mixed: "mixed"; }>;

declare function comboTileKitWorld(options: ComboTileKitWorldOptions): WaveWorldPlan;

declare function compileWaveAssemblyTerminal<TInput, TController, TServices = void>(recipe: WaveAssemblyRecipe | WaveAssemblyRealizationPlan, program: WaveAssemblyRealizationProgram<TInput, TController, TServices>): WaveCompiledAssemblyTerminal<TInput, TController, TServices>;

declare function composeWaveWorld(id: string): WaveWorldComposer;

declare enum CompoundColliderChildType {

  Box = "box",

  Capsule = "capsule",

  ConvexHull = "convexHull",

  Cylinder = "cylinder",

  Sphere = "sphere",

}

declare function computeLinearLuminance(color: Pick<SampledRgbaColor, "r" | "g" | "b">): number;

declare enum ConstantForceSpace {

  Local = 1,

  World = 0,

}

declare class ConstraintBuilder {

  constructor(bodyA: PhysicsConstraintEndpoint, bodyB: PhysicsConstraintEndpoint);

  apply(): string | null;

  around(axis: DirectionInput): this;

  asBallAndSocket(): this;

  asDistance(): this;

  asHinge(): this;

  asLock(): this;

  asPrismatic(): this;

  asSixDoF(): this;

  asSlider(): this;

  atLocalPivots(ownLocalPivot: WavePointInput, targetLocalPivot: WavePointInput): this;

  atOwnLocalPivot(pivot: WavePointInput): this;

  atOwnLocalPivot(x: number, y: number, z: number): this;

  atOwnWorldPivot(point: WavePointInput): this;

  atSharedWorldPivot(point: WavePointInput): this;

  atTargetLocalPivot(pivot: WavePointInput): this;

  atTargetLocalPivot(x: number, y: number, z: number): this;

  atTargetWorldPivot(point: WavePointInput): this;

  atWorldPivots(ownWorldPivot: WavePointInput, targetWorldPivot: WavePointInput): this;

  build(): string | null;

  limitAngleDegrees(min: number, max: number): this;

  limitAngleRadians(min: number, max: number): this;

  withAngularLimits(axis: ConstraintAxis, min: number, max: number): this;

  withAxes(axisA: DirectionInput, axisB: DirectionInput): this;

  withCollisions(enabled?: boolean): this;

  withDistanceRange(min: number, max: number): this;

  withFixedDistance(distance: number): this;

  withHingePositionMotor(targetDegrees: number, maxForce?: number): this;

  withId(id: string): this;

  withLinearLimits(axis: ConstraintAxis, min: number, max: number): this;

  withMotor(axis: ConstraintAxis, mode: MotorMode, target: number, maxForce?: number, options?: { stiffness?: number; damping?: number; }): this;

  withPerpAxes(perpA: DirectionInput, perpB: DirectionInput): this;

  withPositionMotor(axis: ConstraintAxis, targetPosition: number, maxForce?: number): this;

  withReturnMotor(maxForce?: number, targetDegrees?: number): this;

  withSpring(spring: SpringConfig): this;

  withSpringMotor(axis: ConstraintAxis, targetPosition: number, maxForce?: number, stiffness?: number, damping?: number, mode?: MotorMode): this;

  withVelocityMotor(axis: ConstraintAxis, targetVelocity: number, maxForce?: number): this;

}

declare function createProceduralTexture(scene: unknown, name: string, width: number, height: number): ProceduralTextureHandle;

interface CreateSdfSurfaceFromRecipeOptions {

  readonly assetOptions?: WaveGeometryAssetOptions;

  readonly id: string;

  readonly structure: WaveSurfaceSdfRecipeStructure;

  readonly surfaceOptions?: WaveSdfRecipeSurfaceOptions;

}

declare function createWaveReflectionSourceRef(id: string): WaveReflectionSourceRef;

declare function createWaveTTSBackend(name: WaveTTSBackendProviderName, options?: WaveTTSBackendOptions): WaveTTSBackend;

declare function createWaveWaterBodyModel(patch?: WaveWaterBodyModelPatch): WaveWaterBodyModel;

interface CrosshairOptions {

  armLength?: number;

  color?: DrawColor;

  dotColor?: DrawColor;

  dotRadius?: number;

  gap?: number;

  lineWidth?: number;

  size?: number;

}

declare const CYBERPUNK_REFERENCE_ENVIRONMENT_ASSETS: readonly ["models/cyberpunkReference/CyberpunkReferenceCity.glb", "models/cyberpunkReference/CyberpunkReferenceBillboards.glb", "textures/cyberpunkReference/CyberpunkReferenceWetPuddlesAlbedo.jpg", "textures/cyberpunkReference/CyberpunkReferenceWetPuddlesRoughness.jpg", "textures/cyberpunkReference/CyberpunkReferenceWetPuddlesNormal.jpg", "hdr/cyberpunkReference/CyberpunkReferenceSunflowersPureSky1k.hdr", "videos/cyberpunkReference/CyberpunkReferenceBillboard01.mp4", "videos/cyberpunkReference/CyberpunkReferenceBillboard02.mp4", "videos/cyberpunkReference/CyberpunkReferenceBillboard03.mp4", "videos/cyberpunkReference/CyberpunkReferenceBillboard04.mp4", "videos/cyberpunkReference/CyberpunkReferenceBillboard05.mp4", "videos/cyberpunkReference/CyberpunkReferenceBillboard06.mp4"];

declare const CYBERPUNK_REFERENCE: Readonly<{ cityOffsetY: -20; ground: Readonly<{ size: 400; y: -5.4; uvRepeat: 14.9; roughnessScale: 0.55; reflectionStrength: 0.08; }>; camera: Readonly<{ position: Readonly<{ x: -138.564; y: -3.95; z: 34.181; }>; target: Readonly<{ x: -120; y: -3; z: 30; }>; fovDegrees: 65; near: 0.1; far: 300; }>; heroCar: Readonly<{ position: Readonly<{ x: -128; y: -5.47; z: 33; }>; yawRadians: number; scale: 1.1; }>; sun: Readonly<{ position: Readonly<{ x: 23; y: 31; z: 3; }>; direction: Readonly<{ x: -23; y: -31; z: -3; }>; color: 13627391; intensity: 10; }>; fill: Readonly<{ position: Readonly<{ x: -18; y: 22; z: -12; }>; direction: Readonly<{ x: 18; y: -22; z: 12; }>; color: 16766664; intensity: 1.5; }>; }>;

interface CyberpunkReferenceEnvironmentHandles {

  readonly billboards: waveProp;

  readonly city: waveProp;

  readonly ground: wavePlane;

  readonly rainWetness: WaveScalarSurfaceStateHandle;

}

declare class CycleController<TEntity extends object, TState> {

  constructor(entity: EntityStateControllerHost<TEntity, TState>, states: readonly TState[]);

  allStates(): readonly TState[];

  readonly callback: () => void;

  currentIndex(): number;

  currentState(): TState;

  cycle(): boolean;

  dispose(): void;

  goTo(state: TState): boolean;

  isActive(): boolean;

  next(): boolean;

  previous(): boolean;

  shuffleNext(): boolean;

}

interface DebugOverlayOptions {

  bgColor?: DrawColor;

  fontSize?: number;

  height?: number;

  textColor?: DrawColor;

  updateInterval?: number;

  width?: number;

}

declare const DEFAULT_SKY_BACKGROUND_COLOR = 8900331;

declare const DEFAULT_SKY_HORIZON_COLOR = 13626102;

declare const DEFAULT_WAVE_3D_TEXT_FONT_ASSET_ID = "helvetiker_regular";

declare function defineProjectAssetCatalog<TAssets extends readonly ProjectAssetManifestEntry[]>(catalog: { readonly assets: TAssets; readonly version?: 1; }): ProjectAssetCatalog<TAssets>;

declare function defineShaderMaterialRecipe<const TRecipe extends WaveShaderMaterialRecipe>(recipe: TRecipe): TRecipe;

declare function defineWaveUISkin(definition: WaveUISkinDefinition): WaveUISkinAsset;

declare const DegreesPerSecond: { (value: number): WaveRate; readonly kind: WaveRateUnitKind };

declare enum Direction {

  Backward = "backward",

  Down = "down",

  Forward = "forward",

  Left = "left",

  Right = "right",

  Up = "up",

  X = "x",

  Y = "y",

  Z = "z",

}



declare namespace Direction {

  function fan(axis: DirectionInput, planeNormal: DirectionInput, totalAngleDeg: number, index: number, count: number): DirectionVector;

  function mix(a: DirectionInput, b: DirectionInput, weight: number): DirectionVector;

  function random(seed?: number): DirectionVector;

  function randomBackwardLeft(seed?: number): DirectionVector;

  function randomBackwardRight(seed?: number): DirectionVector;

  function randomDownBackward(seed?: number): DirectionVector;

  function randomDownForward(seed?: number): DirectionVector;

  function randomDownLeft(seed?: number): DirectionVector;

  function randomDownRight(seed?: number): DirectionVector;

  function randomForwardLeft(seed?: number): DirectionVector;

  function randomForwardRight(seed?: number): DirectionVector;

  function randomFrom(directions: readonly Direction[], seed?: number): Direction;

  function randomInCone(axis: DirectionInput, halfAngleDeg: number, seed?: number): DirectionVector;

  function randomOnPlane(normal: DirectionInput, seed?: number): DirectionVector;

  function randomUpBackward(seed?: number): DirectionVector;

  function randomUpForward(seed?: number): DirectionVector;

  function randomUpLeft(seed?: number): DirectionVector;

  function randomUpRight(seed?: number): DirectionVector;

  function randomXY(seed?: number): DirectionVector;

  function randomXZ(seed?: number): DirectionVector;

  function randomYZ(seed?: number): DirectionVector;

}

type DoubleSideHeightfieldPreset = typeof DoubleSideHeightfieldPreset[keyof typeof DoubleSideHeightfieldPreset];

declare const DoubleSideHeightfieldPreset: Readonly<{ readonly Mesa: "mesa"; readonly Plateau: "plateau"; readonly Outcrop: "outcrop"; readonly Continent: "continent"; readonly Shard: "shard"; }>;

type DrawColor = ColorInputAlpha | string;

declare function drawColorToCss(color: DrawColor, alpha?: number): string;

declare const effectPrefabs: Readonly<{}>;

interface ElementMarkerOptions {

  color?: ColorInput;

  shape?: "dot" | "diamond" | "ring" | "sprite";

  size?: number;

  sprite?: string;

  visible?: boolean;

}

declare class engineLocal {

  activeBabylonScene(): unknown | null;

  activeWaveScene(): WaveScene | null;

  admissionPlanHash: string;

  animationSystem: sys_animation;

  applySceneConsents(scene: WaveSceneDefinition): void;

  readonly assetBaseUrl: string;

  readonly assetSigningUrl: string;

  readonly babylonSceneGraphOptimization: Required<WaveBabylonSceneGraphOptimizationConfig>;

  babylonSceneGraphOptimizer: WaveBabylonSceneGraphOptimizer | null;

  backbufferPolicy: RenderBackbufferPolicy;

  readonly browserShellGateways: WaveBrowserShellGateways | null;

  canLoadSceneWithoutEngineRecreate(scene: WaveSceneDefinition): boolean;

  readonly canvas: WaveRenderSurface | null;

  capabilities: WaveRuntimeCapabilities;

  capturePresentationFrame(options?: WavePresentationCaptureOptions): Promise<WaveCaptureResult>;

  createRoom(options?: CreateRoomOptions): Promise<string>;

  currentFrameNowMs: number;

  readonly debugRenderWatchdogOverlay: boolean;

  dispose(): Promise<void>;

  readonly enableAssetCaching: boolean;

  eventBus: WaveEventBus;

  readonly fixedDelta: number;

  fxSystem: unknown;

  getBabylonEngine(): unknown | null;

  getEngineReuseBlockers(scene: WaveSceneDefinition): readonly string[];

  getGraphicsBackendRuntime(): WaveGraphicsBackendRuntime | null;

  getRenderBackbufferDiagnostics(): RenderBackbufferDiagnostics;

  getSystemByName(name: string): unknown | null;

  getSystemByType<T extends unknown>(type: new (...args: unknown[]) => T): T | null;

  getUnsatisfiedRenderRequirements(scene: WaveSceneDefinition): readonly string[];

  getWorldFixedTickOperationalState(): WorldFixedTickOperationalState;

  readonly gpuNetworkAuthorityRegistry: WaveGpuNetworkAuthorityRegistry;

  graphicsDeviceLossError: Error | null;

  readonly gravity: Vector3;

  hasInstalledSystem(systemKey: WaveInstalledSystemKey): boolean;

  identityAdapter: IdentityAdapter;

  induceCrash(reason: string, details?: string): void;

  initializeEngineAndScene(options?: EngineInitializationOptions): Promise<void>;

  inputActionSystem: unknown;

  isAuthoritative: boolean;

  isClient: boolean;

  isHost: boolean;

  isPaused: boolean;

  joinRoom(options: JoinRoomOptions): Promise<void>;

  loadScene(scene: WaveSceneDefinition): Promise<LoadSceneResult>;

  mediaSystem: unknown;

  movingSystem: unknown;

  readonly networkDirectPort: unknown | undefined;

  readonly networkIceServers: readonly unknown[] | undefined;

  readonly networkProxyPort: unknown | undefined;

  readonly networkRegion: NetworkRegion | undefined;

  networkSystem: unknown;

  readonly networkTransport: NetworkTransport;

  pause(): void;

  pickPresentationAt(screenX: number, screenY: number, options?: WavePresentationPickOptions): Promise<WavePickResult>;

  preInitialize(): Promise<void>;

  readonly profileName: WaveEngineProfileName;

  readPresentationCamera(viewId?: string): Promise<WaveCameraResult>;

  registerSystem(system: unknown): void;

  renderingSystem: unknown;

  renderProfile: WaveRenderProfile;

  requestRequiredConsents(): Promise<ConsentReport>;

  readonly requiredConsents: string[];

  requireSystem<K extends WaveInstalledSystemKey>(key: K, context?: WaveSystemAccessContext): WaveEngineSystemMap[K];

  resume(): void;

  roomId: string | null;

  sessionId: string | null;

  setPaused(paused: boolean): void;

  shouldRender: boolean;

  signalInputSystem: unknown;

  readonly signalServerUrl: string | undefined;

  simulationSystem: unknown;

  readonly socketServerUrl: string | undefined;

  stage: EngineStage;

  startSceneMediaCapture(scene: WaveSceneDefinition): Promise<MediaStartReport>;

  stopTickLoop(): void;

  syncRenderBackbufferPolicy(): boolean;

  readonly systemErrorMode: WaveSystemErrorMode;

  terrainSystem: unknown;

  thinkingSystem: unknown;

  tickNumber: number;

  transitionToScene(nextScene: WaveSceneDefinition): Promise<LoadSceneResult>;

  tryGetSystem<K extends WaveInstalledSystemKey>(key: K): WaveEngineSystemMap[K] | null;

  useLargeWorldRendering: boolean;

  usesWebRTC: boolean;

  worldStreamingSystem: unknown;

  constructor(config: EngineLocalConfig);

}

declare class engineP2PHost {

  activeBabylonScene(): unknown | null;

  activeWaveScene(): WaveScene | null;

  admissionPlanHash: string;

  animationSystem: sys_animation;

  applySceneConsents(scene: WaveSceneDefinition): void;

  readonly assetBaseUrl: string;

  readonly assetSigningUrl: string;

  readonly babylonSceneGraphOptimization: Required<WaveBabylonSceneGraphOptimizationConfig>;

  babylonSceneGraphOptimizer: WaveBabylonSceneGraphOptimizer | null;

  backbufferPolicy: RenderBackbufferPolicy;

  readonly browserShellGateways: WaveBrowserShellGateways | null;

  canLoadSceneWithoutEngineRecreate(scene: WaveSceneDefinition): boolean;

  readonly canvas: WaveRenderSurface | null;

  capabilities: WaveRuntimeCapabilities;

  capturePresentationFrame(options?: WavePresentationCaptureOptions): Promise<WaveCaptureResult>;

  createRoom(options?: CreateRoomOptions): Promise<string>;

  currentFrameNowMs: number;

  readonly debugRenderWatchdogOverlay: boolean;

  dispose(): Promise<void>;

  readonly enableAssetCaching: boolean;

  eventBus: WaveEventBus;

  readonly fixedDelta: number;

  fxSystem: unknown;

  getBabylonEngine(): unknown | null;

  getEngineReuseBlockers(scene: WaveSceneDefinition): readonly string[];

  getGraphicsBackendRuntime(): WaveGraphicsBackendRuntime | null;

  getRenderBackbufferDiagnostics(): RenderBackbufferDiagnostics;

  getSystemByName(name: string): unknown | null;

  getSystemByType<T extends unknown>(type: new (...args: unknown[]) => T): T | null;

  getUnsatisfiedRenderRequirements(scene: WaveSceneDefinition): readonly string[];

  getWorldFixedTickOperationalState(): WorldFixedTickOperationalState;

  readonly gpuNetworkAuthorityRegistry: WaveGpuNetworkAuthorityRegistry;

  graphicsDeviceLossError: Error | null;

  readonly gravity: Vector3;

  hasInstalledSystem(systemKey: WaveInstalledSystemKey): boolean;

  identityAdapter: IdentityAdapter;

  induceCrash(reason: string, details?: string): void;

  initializeEngineAndScene(options?: EngineInitializationOptions): Promise<void>;

  inputActionSystem: unknown;

  isAuthoritative: boolean;

  isClient: boolean;

  isHost: boolean;

  isPaused: boolean;

  joinRoom(options: JoinRoomOptions): Promise<void>;

  loadScene(scene: WaveSceneDefinition): Promise<LoadSceneResult>;

  mediaSystem: unknown;

  movingSystem: unknown;

  readonly networkDirectPort: unknown | undefined;

  readonly networkIceServers: readonly unknown[] | undefined;

  readonly networkProxyPort: unknown | undefined;

  readonly networkRegion: NetworkRegion | undefined;

  networkSystem: unknown;

  readonly networkTransport: NetworkTransport;

  pause(): void;

  pickPresentationAt(screenX: number, screenY: number, options?: WavePresentationPickOptions): Promise<WavePickResult>;

  preInitialize(): Promise<void>;

  readonly profileName: WaveEngineProfileName;

  readPresentationCamera(viewId?: string): Promise<WaveCameraResult>;

  registerSystem(system: unknown): void;

  renderingSystem: unknown;

  renderProfile: WaveRenderProfile;

  requestRequiredConsents(): Promise<ConsentReport>;

  readonly requiredConsents: string[];

  requireSystem<K extends WaveInstalledSystemKey>(key: K, context?: WaveSystemAccessContext): WaveEngineSystemMap[K];

  resume(): void;

  roomId: string | null;

  sessionId: string | null;

  setPaused(paused: boolean): void;

  shouldRender: boolean;

  signalInputSystem: unknown;

  readonly signalServerUrl: string | undefined;

  simulationSystem: unknown;

  readonly socketServerUrl: string | undefined;

  stage: EngineStage;

  startSceneMediaCapture(scene: WaveSceneDefinition): Promise<MediaStartReport>;

  stopTickLoop(): void;

  syncRenderBackbufferPolicy(): boolean;

  readonly systemErrorMode: WaveSystemErrorMode;

  terrainSystem: unknown;

  thinkingSystem: unknown;

  tickNumber: number;

  transitionToScene(nextScene: WaveSceneDefinition): Promise<LoadSceneResult>;

  tryGetSystem<K extends WaveInstalledSystemKey>(key: K): WaveEngineSystemMap[K] | null;

  useLargeWorldRendering: boolean;

  usesWebRTC: boolean;

  worldStreamingSystem: unknown;

  constructor(config: EngineP2PHostConfig);

}

declare class engineThinClient {

  activeBabylonScene(): unknown | null;

  activeWaveScene(): WaveScene | null;

  admissionPlanHash: string;

  animationSystem: sys_animation;

  applySceneConsents(scene: WaveSceneDefinition): void;

  readonly assetBaseUrl: string;

  readonly assetSigningUrl: string;

  readonly babylonSceneGraphOptimization: Required<WaveBabylonSceneGraphOptimizationConfig>;

  babylonSceneGraphOptimizer: WaveBabylonSceneGraphOptimizer | null;

  backbufferPolicy: RenderBackbufferPolicy;

  readonly browserShellGateways: WaveBrowserShellGateways | null;

  canLoadSceneWithoutEngineRecreate(scene: WaveSceneDefinition): boolean;

  readonly canvas: WaveRenderSurface | null;

  capabilities: WaveRuntimeCapabilities;

  capturePresentationFrame(options?: WavePresentationCaptureOptions): Promise<WaveCaptureResult>;

  createRoom(options?: CreateRoomOptions): Promise<string>;

  currentFrameNowMs: number;

  readonly debugRenderWatchdogOverlay: boolean;

  dispose(): Promise<void>;

  readonly enableAssetCaching: boolean;

  eventBus: WaveEventBus;

  readonly fixedDelta: number;

  fxSystem: unknown;

  getBabylonEngine(): unknown | null;

  getEngineReuseBlockers(scene: WaveSceneDefinition): readonly string[];

  getGraphicsBackendRuntime(): WaveGraphicsBackendRuntime | null;

  getRenderBackbufferDiagnostics(): RenderBackbufferDiagnostics;

  getSystemByName(name: string): unknown | null;

  getSystemByType<T extends unknown>(type: new (...args: unknown[]) => T): T | null;

  getUnsatisfiedRenderRequirements(scene: WaveSceneDefinition): readonly string[];

  getWorldFixedTickOperationalState(): WorldFixedTickOperationalState;

  readonly gpuNetworkAuthorityRegistry: WaveGpuNetworkAuthorityRegistry;

  graphicsDeviceLossError: Error | null;

  readonly gravity: Vector3;

  hasInstalledSystem(systemKey: WaveInstalledSystemKey): boolean;

  identityAdapter: IdentityAdapter;

  induceCrash(reason: string, details?: string): void;

  initializeEngineAndScene(options?: EngineInitializationOptions): Promise<void>;

  inputActionSystem: unknown;

  isAuthoritative: boolean;

  isClient: boolean;

  isHost: boolean;

  isPaused: boolean;

  joinRoom(options: JoinRoomOptions): Promise<void>;

  loadScene(scene: WaveSceneDefinition): Promise<LoadSceneResult>;

  mediaSystem: unknown;

  movingSystem: unknown;

  readonly networkDirectPort: unknown | undefined;

  readonly networkIceServers: readonly unknown[] | undefined;

  readonly networkProxyPort: unknown | undefined;

  readonly networkRegion: NetworkRegion | undefined;

  networkSystem: unknown;

  readonly networkTransport: NetworkTransport;

  pause(): void;

  pickPresentationAt(screenX: number, screenY: number, options?: WavePresentationPickOptions): Promise<WavePickResult>;

  preInitialize(): Promise<void>;

  readonly profileName: WaveEngineProfileName;

  readPresentationCamera(viewId?: string): Promise<WaveCameraResult>;

  registerSystem(system: unknown): void;

  renderingSystem: unknown;

  renderProfile: WaveRenderProfile;

  requestRequiredConsents(): Promise<ConsentReport>;

  readonly requiredConsents: string[];

  requireSystem<K extends WaveInstalledSystemKey>(key: K, context?: WaveSystemAccessContext): WaveEngineSystemMap[K];

  resume(): void;

  roomId: string | null;

  sessionId: string | null;

  setPaused(paused: boolean): void;

  shouldRender: boolean;

  signalInputSystem: unknown;

  readonly signalServerUrl: string | undefined;

  simulationSystem: unknown;

  readonly socketServerUrl: string | undefined;

  stage: EngineStage;

  startSceneMediaCapture(scene: WaveSceneDefinition): Promise<MediaStartReport>;

  stopTickLoop(): void;

  syncRenderBackbufferPolicy(): boolean;

  readonly systemErrorMode: WaveSystemErrorMode;

  terrainSystem: unknown;

  thinkingSystem: unknown;

  tickNumber: number;

  transitionToScene(nextScene: WaveSceneDefinition): Promise<LoadSceneResult>;

  tryGetSystem<K extends WaveInstalledSystemKey>(key: K): WaveEngineSystemMap[K] | null;

  useLargeWorldRendering: boolean;

  usesWebRTC: boolean;

  worldStreamingSystem: unknown;

  constructor(config: EngineThinClientConfig);

}

declare function ensureAbcjsLoaded(url?: string): Promise<boolean>;

declare enum EntityAuthority {

  CLIENT = "client",

  HOST = "host",

  SHARED = "shared",

}

declare function every(value: number, unit: WaveTimeUnit): WaveTimeRule;

declare const EveryTime: Readonly<{ kind: "everyTime"; }>;

declare const FirstTime: Readonly<{ kind: "firstTime"; }>;

declare const Flips: Readonly<{ kind: "flips"; }>;

declare class FollowPathBuilder {

  constructor(_animator: cmp_animatorBase, _waypoints: FollowPathSource);

  alignUpToPathNormal(): this;

  atSpeed(speed: number): this;

  backward(): this;

  forward(): this;

  inFrameOf(path: FollowPathSource): this;

  inPathFrame(): this;

  inWorldFrame(): this;

  lookAt(target: TransformReferenceLike | WavePointInput, options?: WaveOrientOptions): this;

  offsetAlong(direction: DirectionInput, amount: FollowPathOffsetAmountInput): this;

  play(): FollowPathPlaybackHandle;

  rotateAroundBy(axis: DirectionInput, degrees: FollowPathRotationDegreesInput): this;

  start(): FollowPathPlaybackHandle;

  startPaused(enabled?: boolean): this;

  turnToFace(options?: WaveOrientOptions): this;

  turnToFace(enabled: boolean): this;

  upright(): this;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): this;

  withCallbacks(callbacks: NonNullable<FollowPathOptions["callbacks"]>, options?: WaveAuthoredCallbackOptions): this;

  withDirection(direction: NonNullable<FollowPathOptions["direction"]>): this;

  withEase(ease: NonNullable<FollowPathOptions["ease"]>): this;

  withLaps(laps: number): this;

  withLookAheadProgress(lookAheadProgress: number): this;

  withMaxTurnDegreesPerSecond(maxTurnDegreesPerSecond: number): this;

  withSpeed(speed: number): this;

  withSpeedByProgress(speedByProgress: NonNullable<FollowPathOptions["speedByProgress"]>): this;

  withTimeScale(timeScale: number): this;

  withUpVector(upVector: Vector3Like): this;

  yawOnly(): this;

}

declare function forNext(value: number, unit: WaveTimeUnit): WaveTimeRule;

declare const FX_STANDARD_VARS: { readonly SYSTEM_TIME: "System.TimeSeconds"; readonly SYSTEM_DELTA: "System.DeltaSeconds"; readonly SYSTEM_SEED: "System.Seed"; readonly SYSTEM_ANCHOR_POSITION: "System.Anchor.Position"; readonly SYSTEM_ANCHOR_FORWARD: "System.Anchor.Forward"; readonly SYSTEM_ANCHOR_UP: "System.Anchor.Up"; readonly SYSTEM_ANCHOR_RIGHT: "System.Anchor.Right"; readonly SYSTEM_ANCHOR_VELOCITY: "System.Anchor.Velocity"; readonly SYSTEM_ANCHOR_SPEED: "System.Anchor.Speed"; readonly SYSTEM_CONTROLLER_THROTTLE: "System.Controller.Throttle"; readonly EMITTER_TIME: "Emitter.TimeSeconds"; readonly EMITTER_SPAWNED: "Emitter.SpawnedThisFrame"; readonly EMITTER_LOD: "Emitter.LOD"; readonly EMITTER_ANCHOR_POSITION: "Emitter.Anchor.Position"; readonly EMITTER_ANCHOR_FORWARD: "Emitter.Anchor.Forward"; readonly EMITTER_ANCHOR_UP: "Emitter.Anchor.Up"; readonly EMITTER_ANCHOR_RIGHT: "Emitter.Anchor.Right"; readonly EMITTER_ANCHOR_VELOCITY: "Emitter.Anchor.Velocity"; readonly EMITTER_ANCHOR_SPEED: "Emitter.Anchor.Speed"; readonly EMITTER_ANCHOR_OFFSET_FORWARD: "Emitter.Anchor.OffsetForward"; readonly EMITTER_ANCHOR_OFFSET_UP: "Emitter.Anchor.OffsetUp"; readonly EMITTER_ANCHOR_OFFSET_RIGHT: "Emitter.Anchor.OffsetRight"; readonly PARTICLE_POSITION: "Particles.Position"; readonly PARTICLE_VELOCITY: "Particles.Velocity"; readonly PARTICLE_AGE: "Particles.Age"; readonly PARTICLE_LIFETIME: "Particles.Lifetime"; readonly PARTICLE_NORMALIZED_AGE: "Particles.NormalizedAge"; readonly PARTICLE_COLOR: "Particles.Color"; readonly PARTICLE_SIZE: "Particles.Size"; readonly PARTICLE_SIZE_BASE: "Particles.SizeBase"; readonly PARTICLE_ROTATION: "Particles.Rotation"; readonly PARTICLE_ROTATION3: "Particles.Rotation3"; readonly PARTICLE_RANDOM01: "Particles.Random01"; readonly PARTICLE_RIBBON_ID: "Particles.RibbonId"; readonly PARTICLE_SPRITE_FRAME: "Particles.SpriteFrame"; readonly PARTICLE_MASS: "Particles.Mass"; readonly PARTICLE_DRAG: "Particles.Drag"; readonly PARTICLE_SURFACE_NORMAL: "Particles.SurfaceNormal"; readonly PARTICLE_SURFACE_UV: "Particles.SurfaceUV"; readonly PARTICLE_SURFACE_TRIANGLE: "Particles.SurfaceTriangle"; };

declare const FxAnchor: { locate(): FxAnchorBuilder; };

declare const FxCondition: { readonly metric: (source: FxTrackMetricSource) => FxConditionMetricBuilder; readonly all: (...conditions: FxTrackCondition[]) => FxTrackCondition; readonly any: (...conditions: FxTrackCondition[]) => FxTrackCondition; readonly not: (condition: FxTrackCondition) => FxTrackCondition; };

declare class FxEmitterBuilder {

  constructor(id: string);

  build(): FxEmitterDefinition;

  readonly runtime: FxEmitterRuntimeSurface;

  readonly structure: FxEmitterStructureSurface;

}

declare class FxMotionBuilder {

  constructor(_pathIndexBase?: number);

  accelerate(acceleration: FxMotionTargetInput): this;

  attract(target: FxMotionTargetInput): this;

  axis(axis: DirectionInput): this;

  bounceOff(surface: FxCollisionSurface, opts?: FxMotionBounceOptions): this;

  climbRetainedVolume(volume: WaveFxRetainedVolume, opts?: FxMotionRetainedVolumeSteeringOptions): this;

  collective(opts: FxMotionCollectiveOptions): this;

  depositRetainedVolume(volume: WaveFxRetainedVolume, opts?: FxMotionRetainedVolumeDepositOptions): this;

  descendRetainedVolume(volume: WaveFxRetainedVolume, opts?: FxMotionRetainedVolumeSteeringOptions): this;

  fall(opts?: FxMotionFallOptions): this;

  falloff(mode: WaveValueCurveFalloffMode): this;

  followPath(path: FxMotionPathSource, opts?: FxMotionFollowPathOptions): this;

  followRetainedVolume(volume: WaveFxRetainedVolume, opts?: FxMotionRetainedVolumeSteeringOptions): this;

  gravity(target: FxMotionTargetInput): this;

  headingResponse(opts: FxMotionHeadingResponseOptions): this;

  integrate(opts?: FxMotionIntegrateOptions): this;

  get intents(): readonly FxMotionIntent[];

  loop(enabled?: boolean): this;

  mode(value: FxMotionPathMode): this;

  offset(value: NumLike): this;

  orbit(target: FxMotionTargetInput): this;

  orientToPath(opts?: FxMotionOrientOptions): this;

  orientToVelocity(opts?: FxMotionOrientOptions): this;

  orientToward(target: FxMotionTargetInput, opts?: FxMotionOrientOptions): this;

  outliers(chance: NumLike, spread: NumLike): this;

  get paths(): readonly FxMotionPathSpec[];

  get postIntegrateModules(): readonly FxModuleInvocation[];

  get preIntegrateModules(): readonly FxModuleInvocation[];

  radius(value: NumLike): this;

  repel(target: FxMotionTargetInput): this;

  get requiresCpuSim(): boolean;

  get requiresGpuSim(): boolean;

  sampleRetainedVolume(volume: WaveFxRetainedVolume, opts?: FxMotionRetainedVolumeSampleOptions): this;

  sampleRetainedVolumeGradient(volume: WaveFxRetainedVolume, opts?: FxMotionRetainedVolumeGradientSampleOptions): this;

  senseRetainedVolume(volume: WaveFxRetainedVolume, opts: FxMotionRetainedVolumeSensorOptions): this;

  softening(value: NumLike): this;

  speed(value: NumLike): this;

  speedClamp(maxSpeed: NumLike): this;

  spread(value: NumLike): this;

  strength(value: NumLike): this;

  wander(value: NumLike): this;

}

declare function gaussianSplatLoader(asset: string): WaveGaussianSplatLoaderConfigBuilder;

declare enum GeometryInfluenceViewMode {

  Heatmap = "heatmap",

  Mask = "mask",

}

type GlobalIlluminationConfig = Partial<GlobalIlluminationState>;

type GlobalIlluminationQuality = "low" | "medium" | "high";

interface GlobalIlluminationState {

  blur: boolean;

  bounceSourceIntensity: number;

  edgeArtifactCorrection: number;

  enabled: boolean;

  fullSizeBlur: boolean;

  giTextureSize: number;

  intensity: number;

  noiseFactor: number;

  quality: GlobalIlluminationQuality;

  qualityBlur: boolean;

  qualityUpsampling: boolean;

  radius: number;

  rotateSamples: boolean;

  rsmTextureSize: number;

  samples: number;

}

declare enum GoboPreset {

  Bars = "bars",

  Blinds = "blinds",

  Canopy = "canopy",

  Clouds = "clouds",

  Grid = "grid",

  Leaves = "leaves",

  NoirSlash = "noirSlash",

  OrganicBlob = "organicBlob",

  SoftCircle = "softCircle",

  StainedGlass = "stainedGlass",

  WaterRipple = "waterRipple",

  Window = "window",

}

declare function googleMaps3DTiles(options: GoogleMaps3DTilesSourceOptions): GoogleMaps3DTilesSourceConfig;

declare enum GradientAnimationMode {

  Oscillate = "oscillate",

  Scroll = "scroll",

  Static = "static",

}

declare function grid3DWorldLayer(gridInfo: GridLayout, options?: WaveGrid3DWorldLayerOptions & { readonly surfaceY?: number; }): WaveWorldLayerDraft<WaveGrid3DSourceOptions>;

interface HandGestureOverlayColorOptions {

  backgroundColor?: DrawColor;

  connectionColor?: DrawColor;

  landmarkColor?: DrawColor;

  palmColor?: DrawColor;

  textColor?: DrawColor;

}

interface HandGestureOverlayOptions extends HandGestureOverlayColorOptions {

  height?: number;

  landmarkRadius?: number;

  lineWidth?: number;

  mirrored?: boolean;

  showLabels?: boolean;

  showPalmCenter?: boolean;

  staleAfterMs?: number;

  width?: number;

}

declare enum InputPhase {

  Canceled = 2,

  Performed = 1,

  Started = 0,

}

declare class InstanceMeshGroup {

  constructor(options?: InstanceMeshGroupOptions);

  [Symbol.iterator](): Iterator<number>;

  get capacity(): number;

  castToProp(index: number, options?: CastToPropOptions): waveProp;

  dispose(): void;

  filter(fn: (index: number, group: InstanceMeshGroup) => boolean): number[];

  find(fn: (index: number, group: InstanceMeshGroup) => boolean): number;

  forEach(callback: (index: number, group: InstanceMeshGroup) => void): this;

  getInstance(index: number): waveInstanceMesh;

  getPosition(index: number): Vector3;

  getRotation(index: number): Quaternion;

  getScale(index: number): Vector3;

  get instances(): readonly waveInstanceMesh[];

  get length(): number;

  map<R>(fn: (index: number, group: InstanceMeshGroup) => R): R[];

  setAllVisible(visible: boolean): this;

  setAmount(count: number): this;

  setColor(index: number, color: ColorInput, alpha?: number): this;

  setPosition(index: number, position: WavePointInput): this;

  setRotation(index: number, rotation: Quaternion | QuaternionLike): this;

  setScale(index: number, scale: Vector3Like): this;

  setTransform(index: number, position: Vector3Like, rotation: Quaternion | QuaternionLike, scale: Vector3Like): this;

  setUniformScale(index: number, scale: number): this;

  setVisible(index: number, visible: boolean): this;

  useModel(model: string | AssetRef<"model"> | WaveModelInput): this;

}

interface InventoryOptions {

  bgColor?: DrawColor;

  cellBorderColor?: DrawColor;

  cellSize?: number;

  cols?: number;

  items?: string[][];

  rows?: number;

}

declare function isBlankPixel(input: BlankPixelInput, options?: BlankPixelOptions): boolean;

declare function islandSettlementPresentation(look?: ComboTileKitPresentationLook | WaveScenePresentationPlanDraft): WaveScenePresentationPlan;

declare function islandSettlementWorld(options?: IslandSettlementWorldOptions): WaveWorldPlan;

declare enum Keyboard {

  A = "KeyA",

  AltLeft = "AltLeft",

  AltRight = "AltRight",

  ArrowDown = "ArrowDown",

  ArrowLeft = "ArrowLeft",

  ArrowRight = "ArrowRight",

  ArrowUp = "ArrowUp",

  B = "KeyB",

  Backquote = "Backquote",

  Backslash = "Backslash",

  Backspace = "Backspace",

  BracketLeft = "BracketLeft",

  BracketRight = "BracketRight",

  C = "KeyC",

  CapsLock = "CapsLock",

  Comma = "Comma",

  ControlLeft = "ControlLeft",

  ControlRight = "ControlRight",

  D = "KeyD",

  Delete = "Delete",

  E = "KeyE",

  End = "End",

  Enter = "Enter",

  Equal = "Equal",

  Escape = "Escape",

  F = "KeyF",

  F1 = "F1",

  F10 = "F10",

  F11 = "F11",

  F12 = "F12",

  F2 = "F2",

  F3 = "F3",

  F4 = "F4",

  F5 = "F5",

  F6 = "F6",

  F7 = "F7",

  F8 = "F8",

  F9 = "F9",

  G = "KeyG",

  H = "KeyH",

  Home = "Home",

  I = "KeyI",

  Insert = "Insert",

  J = "KeyJ",

  K = "KeyK",

  L = "KeyL",

  M = "KeyM",

  MetaLeft = "MetaLeft",

  MetaRight = "MetaRight",

  Minus = "Minus",

  N = "KeyN",

  Num0 = "Digit0",

  Num1 = "Digit1",

  Num2 = "Digit2",

  Num3 = "Digit3",

  Num4 = "Digit4",

  Num5 = "Digit5",

  Num6 = "Digit6",

  Num7 = "Digit7",

  Num8 = "Digit8",

  Num9 = "Digit9",

  NumLock = "NumLock",

  O = "KeyO",

  P = "KeyP",

  PageDown = "PageDown",

  PageUp = "PageUp",

  Period = "Period",

  Q = "KeyQ",

  Quote = "Quote",

  R = "KeyR",

  S = "KeyS",

  Semicolon = "Semicolon",

  ShiftLeft = "ShiftLeft",

  ShiftRight = "ShiftRight",

  Slash = "Slash",

  Space = "Space",

  T = "KeyT",

  Tab = "Tab",

  U = "KeyU",

  V = "KeyV",

  W = "KeyW",

  X = "KeyX",

  Y = "KeyY",

  Z = "KeyZ",

}

declare class KinematicFlightActorBuilder<TActor extends waveKinematicActor<unknown> = waveKinematicActor<unknown>> {

  constructor(_actor: TActor, config?: KinematicFlightActorConfig);

  apply(): TActor;

  configure(config: KinematicFlightActorConfig): this;

  withAscendSpeedScale(scale: number): this;

  withBaseSpeed(speed: number): this;

  withDescendSpeedScale(scale: number): this;

  withInvertPitch(enabled?: boolean): this;

  withMouseSensitivity(sensitivity: number): this;

  withPitchRate(rate: number): this;

  withRollRate(rate: number): this;

  withThrottleSensitivity(sensitivity: number): this;

  withYawRate(rate: number): this;

}

declare class KinematicHumanoidActorBuilder<TActor extends waveKinematicActor<unknown> = waveKinematicActor<unknown>> {

  constructor(_actor: TActor, config?: KinematicHumanoidActorConfig);

  apply(): TActor;

  canSquat(enabled?: boolean): this;

  climbsStepsUpTo(height: number): this;

  configure(config: KinematicHumanoidActorConfig): this;

  pushesDynamicBodies(strengthOrOptions: number | KinematicHumanoidDynamicPushOptions): this;

  usesGroundContact(options: KinematicHumanoidGroundContactOptions): this;

  weighs(mass: number): this;

  withAirControl(factor: number): this;

  withBaseSpeed(speed: number): this;

  withBaseTurnSpeed(rate: WaveRate): this;

  withBaseTurnSpeed(value: number, unit: WaveRateUnit): this;

  withDynamicFriction(value: number): this;

  withFootOffset(offset: number | null): this;

  withFriction(staticFriction: number, dynamicFriction?: number): this;

  withJumpForce(force: number): this;

  withMass(mass: number): this;

  withMaxSlopeAngle(degrees: number): this;

  withMaxStepHeight(height: number): this;

  withMouseSensitivity(sensitivity: number): this;

  withoutAirControl(): this;

  withPushStrength(strength: number): this;

  withSprintMultiplier(multiplier: number): this;

  withSquatSpeed(speed: number): this;

  withSquatSpeedScale(scale: number): this;

  withStaticFriction(value: number): this;

  withStrafeSpeed(speed: number): this;

  withStrafeSpeedScale(scale: number): this;

}

type KinematicMotionStateChannel = typeof KinematicMotionStateChannel[keyof typeof KinematicMotionStateChannel];

declare const KinematicMotionStateChannel: { readonly Translation: "translation"; readonly Support: "support"; };

declare enum KinematicSupportState {

  Airborne = "airborne",

  Grounded = "grounded",

  Sliding = "sliding",

}

declare enum KinematicTranslationState {

  Stationary = "stationary",

  Translating = "translating",

}

declare class KinematicVehicleActorBuilder<TActor extends waveKinematicActor<unknown> = waveKinematicActor<unknown>> {

  constructor(_actor: TActor, config?: KinematicVehicleActorConfig);

  apply(): TActor;

  configure(config: KinematicVehicleActorConfig): this;

  withAcceleration(acceleration: number): this;

  withBaseSpeed(speed: number): this;

  withBrakeStrength(brakeStrength: number): this;

  withGravityMultiplier(multiplier: number): this;

  withReverseSpeedScale(scale: number): this;

  withSteeringSensitivity(sensitivity: number): this;

}

declare function laasGoldenRavinePresentation(presentation?: WaveScenePresentationPlanDraft): WaveScenePresentationPlan;

declare function laasOldGrowthWorld(options?: LaasWorldOptions): WaveWorldPlan;

declare enum LatheCap {

  Both = 3,

  End = 2,

  None = 0,

  Start = 1,

}

interface LightAuthoringOptions extends ShadowOptions {

  angle?: number;

  areaEmissionTexture?: AreaLightEmissionTextureInput | null;

  areaEmissionTexturePreprocessed?: boolean;

  areaHeight?: number;

  areaWidth?: number;

  castShadow?: boolean;

  color?: ColorInput;

  coloredShadow?: ColoredShadowConfig;

  diffuseColor?: ColorInput;

  direction?: Vector3Like;

  directionLabel?: Direction;

  exponent?: number;

  groundColor?: ColorInput;

  innerAngle?: number;

  intensity?: number;

  isOn?: boolean;

  lightBeam?: LightBeamConfig;

  offset?: Vector3Like;

  projectionCaustic?: CausticOverlayConfig;

  projectionFar?: number;

  projectionNear?: number;

  projectionPreset?: ProjectionContent | null;

  projectionRipple?: RippleEffectConfig;

  projectionSoftEdge?: number;

  projectionWobble?: WobbleEffectConfig;

  radius?: number;

  range?: number;

  showAreaHelper?: boolean;

  showConeHelper?: boolean;

  showDirectionalHelper?: boolean;

  showHelper?: boolean;

  showHemisphereHelper?: boolean;

  showRangeHelper?: boolean;

  specularColor?: ColorInput;

  target?: Vector3Like;

  type?: LightType;

  volumetricLight?: LightVolumetricConfig;

}

declare enum LineOfSightBlockerShape {

  Parts = "parts",

  Surface = "surface",

  Whole = "whole",

}

interface LineOptions {

  closed?: boolean;

  color?: ColorInput;

  dash?: [number, number];

  fillColor?: ColorInput;

  fillOpacity?: number;

  lineCap?: "butt" | "round" | "square";

  width?: number;

}

interface LoadSceneResult {

  assetsLoaded: number;

  loadTimeMs: number;

  name: string;

}

interface MarkerOptions {

  color?: ColorInput;

  shape?: MinimapMarkerShape | "cross";

  size?: number;

  sprite?: string;

}

interface MaterialEditorModelHost {

  applyPbrModifier?(scope: MaterialScope, recipe: WavePbrModifierRecipe, options: WavePbrModifierApplicationOptions): void;

  applyScopeStatePatch?(scope: MaterialScope, patch: MaterialStatePatch): void;

  captureScopeMaterialAssetDefinition?(scope: MaterialScope): ProjectMaterialAssetDefinition;

  createScopeStateAnimation?(scope: MaterialScope, label: string, resolveStartState: () => Record<string, number>, endState: Record<string, number>, patchFromState: (state: Record<string, number>) => MaterialStatePatch): WaveMaterialPropertyAnimationBuilder;

  getMesh(name: string): unknown | undefined;

  getMeshes(): readonly unknown[];

  getScopeState?(scope: MaterialScope): MaterialState | null;

  onMaterialCloned(mat: unknown): void;

  onMaterialGraphChanged?(): void;

  resolveMaterial?(path: string): unknown | null;

  resolveMaterialInput?(material: MaterialInput, materialType: MaterialUseMode): string;

  resolveMaterialUseMode?(materialName: string, materialType: MaterialUseMode): "public" | "private";

  resolveModifierTarget?(scope: MaterialScope): WaveVisualTargetRef;

  resolveTexture?(path: string): unknown | null;

  stopScopeStateAnimation?(scope: MaterialScope, label: string): void;

  syncMaterialFreezePolicy?(): void;

  useScopeMaterial?(scope: MaterialScope, materialName: string, materialType: MaterialUseMode): void;

  useScopeMaterialInput?(scope: MaterialScope, input: WaveMaterialInput, materialType: MaterialUseMode): void;

}

declare class MaterialEditorView {

  constructor(_host: MaterialEditorModelHost, _scope: MaterialScope);

  applySurfaceConfig(config: MaterialSurfaceConfig): this;

  captureProjectMaterialAssetDefinition(): ProjectMaterialAssetDefinition;

  getAlphaMode(): MaterialAlphaMode | null;

  getAntiTiling(): WaveMaterialAntiTilingOptions | null;

  getAOTexture(): unknown | null;

  getBaseTexture(): unknown | null;

  getColor(): unknown;

  getDepthBias(): number;

  getDirectIntensity(): number | null;

  getEmissiveColor(): unknown;

  getEmissiveIntensity(): number;

  getEmissiveTexture(): unknown | null;

  getEnvironmentIntensity(): number | null;

  getIndexOfRefraction(): number;

  getMetallicTexture(): unknown | null;

  getMetalness(): number;

  getNormalTexture(): unknown | null;

  getOpacity(): number;

  getRefractionIntensity(): number;

  getRoughness(): number;

  getTranslucencyIntensity(): number;

  getTransparencyMode(): MaterialTransparencyMode | null;

  getUseRadianceOverAlpha(): boolean | null;

  getUseSpecularOverAlpha(): boolean | null;

  modifyWith(recipe: WavePbrModifierRecipe, options?: WavePbrModifierApplicationOptions): this;

  removeAntiTiling(): this;

  removeMaterial(): this;

  setAlbedoEmissiveFill(color: MaterialColorInput, intensity: number): this;

  setAlphaMode(mode: MaterialAlphaMode | null): this;

  setAnisotropy(state: MaterialAnisotropyState): this;

  setAntiTiling(options?: WaveMaterialAntiTilingOptions): this;

  setAOTexture(path: string): this;

  setBaseTexture(path: string): this;

  setClearCoat(state: MaterialClearCoatState): this;

  setColor(color: MaterialColorInput): this;

  setColor(color: MaterialColorInput, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setColor(color: MaterialColorInput, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setDepthBias(value: number): this;

  setDirectIntensity(value: number): this;

  setDoubleSided(enabled: boolean): this;

  setEmissiveColor(color: MaterialColorInput): this;

  setEmissiveColor(color: MaterialColorInput, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveColor(color: MaterialColorInput, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveIntensity(intensity: number): this;

  setEmissiveIntensity(intensity: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveIntensity(intensity: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveTexture(path: string): this;

  setEnvironmentIntensity(value: number): this;

  setIndexOfRefraction(ior: number): this;

  setIridescence(state: MaterialIridescenceState): this;

  setMaximumThickness(value: number): this;

  setMaxSimultaneousLights(value: number): this;

  setMetallicTexture(path: string): this;

  setMetalness(value: number): this;

  setMetalness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setMetalness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setMinimumThickness(value: number): this;

  setNormalTexture(path: string): this;

  setOpacity(alpha: number): this;

  setOpacity(alpha: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setOpacity(alpha: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setRefractionIntensity(value: number): this;

  setRoughness(value: number): this;

  setRoughness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setRoughness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setRoughnessTexture(path: string): this;

  setSheen(state: MaterialSheenState): this;

  setSpecularIntensity(value: number): this;

  setSubSurface(state: MaterialSubSurfaceState): this;

  setSubSurfaceTintColor(color: MaterialColorInput): this;

  setSurfacePreset(preset: SurfacePreset, category?: SurfaceCategory): this;

  setThicknessTexture(path: string): this;

  setTranslucencyColorTexture(path: string): this;

  setTranslucencyIntensity(value: number): this;

  setTranslucencyIntensityTexture(path: string): this;

  setTransmissionTexture(path: string): this;

  setUseRadianceOverAlpha(enabled: boolean): this;

  setUseSpecularOverAlpha(enabled: boolean): this;

  setUVOffset(offset: Vector2): this;

  setUVOffset(offset: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(offset: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, vOffset?: number): this;

  setUVOffset(uOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVRotation(degrees: number): this;

  setUVRotation(degrees: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVRotation(degrees: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(scale: Vector2): this;

  setUVScale(scale: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(scale: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, vScale?: number): this;

  setUVScale(uScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, vScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, vScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setWireframe(enabled: boolean): this;

  get target(): WaveVisualTargetRef;

  useMaterial(material: MaterialInput, materialType?: MaterialUseMode): this;

}

type MaterialScope = { type: "mesh"; name: string; scopeKey?: string; } | { type: "meshMaterialSlot"; name: string; slot: number; scopeKey?: string; }

interface MaterialSplatBackfaceOptions {

  readonly floor?: MaterialSplatSurfaceDefinition;

  readonly roof?: MaterialSplatSurfaceDefinition;

  readonly wall?: MaterialSplatSurfaceDefinition;

}

interface MaterialSplatConfiguration {

  readonly antiTiling?: WaveMaterialAntiTilingOptions;

  readonly debugView?: MaterialSplatDebugViewMode;

  readonly doubleSided?: boolean;

  readonly mode?: MaterialSplatMode;

  readonly paint?: MaterialSplatPaintConfiguration;

  readonly ruleCompositing?: MaterialSplatRuleCompositing;

  readonly rules?: readonly MaterialSplatRule[];

  readonly ruleSpace?: MaterialSplatRuleSpace;

  readonly splatMap?: string;

  readonly stochastic?: MaterialSplatStochasticConfiguration;

}

interface MaterialSplatDefinition {

  readonly backface?: MaterialSplatBackfaceOptions;

  readonly config?: MaterialSplatConfiguration;

  readonly kind: "material-splat-definition";

  readonly layers: readonly MaterialSplatLayerDefinition[];

}

type MaterialSplatFalloff = "smooth" | "linear" | "hard";

interface MaterialSplatLayerDefinition extends MaterialSplatSurfaceDefinition {

  readonly name: MaterialSplatLayerId;

}

type MaterialSplatLayerId = string;

type MaterialSplatLayerInput = Omit<MaterialSplatLayerDefinition, "name">;

type MaterialSplatMode = "rules" | "splatMap" | "hybrid";

type MaterialSplatPaintBlendMode = "override" | "add" | "max";

interface MaterialSplatPaintConfiguration {

  readonly blendMode?: MaterialSplatPaintBlendMode;

  readonly enabled?: boolean;

  readonly resolution?: number;

}

interface MaterialSplatRule {

  readonly curve?: ReadonlyArray<{ readonly height: number; readonly value: number; }>;

  readonly heightTransition?: number;

  readonly id?: string;

  readonly layer: MaterialSplatLayerSelector;

  readonly maxHeight?: number;

  readonly maxSlope?: number;

  readonly minHeight?: number;

  readonly minSlope?: number;

  readonly noiseInfluence?: number;

  readonly priority?: number;

  readonly slopeTransition?: number;

  readonly strength?: number;

}

type MaterialSplatRuleCompositing = { readonly mode: "normalized"; } | { readonly mode: "priorityRemainder"; readonly baseLayer: MaterialSplatLayerSelector; }

type MaterialSplatRuleSpace = "world" | "local";

interface MaterialSplatStochasticConfiguration {

  readonly enabled?: boolean;

  readonly layerBias?: ReadonlyArray<{ readonly layer: MaterialSplatLayerId; readonly bias: number; }>;

  readonly patchContrast?: number;

  readonly patchScale?: number;

  readonly seed?: number;

  readonly worldScale?: number;

}

interface MaterialSplatSurfaceDefinition {

  readonly albedoColor?: ColorInput | undefined;

  readonly albedoTexture?: string | undefined;

  readonly aoTexture?: string | undefined;

  readonly emissiveColor?: ColorInput | undefined;

  readonly emissiveIntensity?: number | undefined;

  readonly metallic?: number | undefined;

  readonly metallicTexture?: string | undefined;

  readonly normalTexture?: string | undefined;

  readonly ormTexture?: string | undefined;

  readonly roughness?: number | undefined;

  readonly roughnessTexture?: string | undefined;

  readonly uvOffset?: Vector2Like | undefined;

  readonly uvScale?: Vector2Like | undefined;

  readonly avoidRepetition?: boolean;

  readonly heightBlend?: MaterialSplatHeightBlendDefinition;

  readonly material?: string;

  readonly projection?: "terrainUv" | "worldPlanar" | "triplanar";

  readonly triplanarBlendSharpness?: number;

  readonly worldScale?: number;

}

type MaterialSplatWeightChannel = "r" | "g" | "b" | "a";

interface MaterialSurfaceConfig {

  alphaMode: MaterialAlphaMode | null;

  anisotropyDirection: readonly [number, number];

  anisotropyEnabled: boolean;

  anisotropyIntensity: number;

  clearCoatEnabled: boolean;

  clearCoatIndexOfRefraction: number;

  clearCoatIntensity: number;

  clearCoatRoughness: number;

  color: number;

  doubleSided: boolean;

  emissiveColor: number | null;

  emissiveIntensity: number;

  environmentIntensity: number;

  indexOfRefraction: number;

  iridescenceEnabled: boolean;

  iridescenceIndexOfRefraction: number;

  iridescenceIntensity: number;

  iridescenceMaximumThickness: number;

  iridescenceMinimumThickness: number;

  maximumThickness: number;

  maxSimultaneousLights: number;

  metallic: number;

  minimumThickness: number;

  opacity: number;

  refractionIntensity: number;

  roughness: number;

  sheenColor: number;

  sheenEnabled: boolean;

  sheenIntensity: number;

  sheenRoughness: number | null;

  specularIntensity: number;

  subSurfaceTintColor: number | null;

  translucencyIntensity: number;

  transparencyMode: MaterialTransparencyMode | null;

  useRadianceOverAlpha: boolean;

  useSpecularOverAlpha: boolean;

}

declare enum MediaCaptureMode {

  Exclusive = "exclusive",

  Share = "share",

}

declare enum MinimapColorPalette {

  Arctic = "arctic",

  Desert = "desert",

  Grayscale = "grayscale",

  NightVision = "nightVision",

  Satellite = "satellite",

  Terrain = "terrain",

  Topographic = "topographic",

}

interface MinimapColorStop {

  color: ColorInput;

  t: number;

}

interface MinimapOptions {

  alignment?: { h: MinimapHAlign; v: MinimapVAlign; }

  colorPalette?: MinimapColorPalette | MinimapColorStop[];

  drawInterval?: number;

  heightRange?: [number, number];

  heightSampler?: (x: number, z: number) => number | null;

  initialZoom?: number;

  moveThreshold?: number;

  outsideColor?: ColorInput;

  playerIndicator?: PlayerIndicatorOptions | false;

  position?: { left: number; top: number; }

  resolution?: number;

  satelliteSampler?: (x: number, z: number) => [number, number, number, number] | null;

  showZoomButtons?: boolean;

  size?: number;

  style?: MinimapStyle;

  zoomButtonSize?: number;

  zoomRange?: [number, number];

  zoomStep?: number;

}

interface MinimapStyle {

  borderColor?: ColorInput;

  borderWidth?: number;

  cornerRadius?: number;

  layer?: number;

  opacity?: number;

}

declare function monitorWaveArticulatedPhysicalSettlement(rig: WavePhysicsRig, actuation: WaveArticulatedActuation, channel: WaveArticulatedActuationChannelHandle, target: WaveArticulatedPhysicalSettlementTarget, options?: WaveArticulatedPhysicalSettlementOptions): WaveArticulatedPhysicalSettlement;

declare enum MotionTrailBlendMode {

  Add = "add",

  Lerp = "lerp",

  Max = "max",

  Screen = "screen",

}

declare enum MountainPreset {

  AlpinePeak = "alpinePeak",

  ErodedButte = "erodedButte",

  Massif = "massif",

  Mesa = "mesa",

  RidgeChain = "ridgeChain",

  RoundedHill = "roundedHill",

  VolcanicCone = "volcanicCone",

}

declare enum MouseButton {

  Back = 3,

  Forward = 4,

  Left = 0,

  Middle = 1,

  Right = 2,

}

declare class netActor extends waveActor {

  constructor();

  constructor(modelAsset: Visual3DModelInput, options?: NetworkOptions);

  constructor(options: NetworkOptions);

  static readonly typeName = EntityType.netActor;

  applyNetworkTransform(transform: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netCamera extends waveCamera {

  constructor(options?: NetworkOptions);

  static readonly typeName: EntityType;

}

declare class netCapsule extends waveCapsule {

  constructor(options?: NetCapsuleOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netCavity extends waveCavity {

  constructor(model: WaveCavityModelInput, options?: NetCavityOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netCone extends waveCone {

  constructor(options?: NetConeOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netCube extends waveCube {

  constructor(options?: NetCubeOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netCylinder extends waveCylinder {

  constructor(options?: NetCylinderOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netDecal extends waveDecal {

  constructor(options?: NetDecalOptions);

  static readonly typeName = EntityType.netDecal;

  applyNetworkTransform(transform: NetworkTransform): void;

  getLastSyncedTransform(): NetworkTransform | null;

  getNetworkTransform(): NetworkTransform;

  get ownerClientId(): string | null;

  get replicateMode(): string;

  setOwnerClient(clientId: string | null): this;

  setReplicateMode(mode: "all" | "owner" | "targets"): this;

  shouldReplicateToClient(clientId: string): boolean;

  updateLastSyncedTransform(transform: NetworkTransform): void;

}

declare class netDisc extends waveDisc {

  constructor(options?: NetDiscOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netHumanoid extends waveHumanoid {

  constructor();

  constructor(modelAsset: Visual3DModelInput, options?: NetworkOptions);

  constructor(options: NetworkOptions);

  static readonly typeName = EntityType.netHumanoid;

  applyNetworkTransform(transform: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

  setAnimState(state: HumanoidAnimState): this;

}

declare class netInstanceMesh extends waveInstanceMesh {

  constructor(options: NetInstanceMeshOptions);

  static readonly typeName = EntityType.netInstanceMesh;

  applyNetworkTransform(transform: NetworkTransform): void;

  getLastSyncedTransform(): NetworkTransform | null;

  getNetworkTransform(): NetworkTransform;

  get ownerClientId(): string | null;

  get replicateMode(): string;

  setOwnerClient(clientId: string | null): this;

  setReplicateMode(mode: "all" | "owner" | "targets"): this;

  shouldReplicateToClient(clientId: string): boolean;

  updateLastSyncedTransform(transform: NetworkTransform): void;

}

declare class netKinematicActor extends waveKinematicActor {

  constructor();

  constructor(modelAsset: Visual3DModelInput, options?: NetworkOptions);

  constructor(options: NetworkOptions);

  static readonly typeName = EntityType.netKinematicActor;

  applyNetworkTransform(transform: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netLathe extends waveLathe {

  constructor(options?: NetLatheOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netLight extends waveLight {

  constructor(options?: NetworkOptions);

  static readonly typeName: EntityType;

}

declare class netPlane extends wavePlane {

  constructor(options?: NetPlaneOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netPolygon extends wavePolygon {

  constructor(options?: NetPolygonOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netProp extends waveProp {

  constructor();

  constructor(modelAsset: Visual3DModelInput, options?: NetworkOptions);

  constructor(options: NetworkOptions);

  static readonly typeName = EntityType.netProp;

  applyNetworkTransform(transform: NetworkTransform): void;

  getLastSyncedTransform(): NetworkTransform | null;

  getNetworkTransform(): NetworkTransform;

  get ownerClientId(): string | null;

  get replicateMode(): string;

  setOwnerClient(clientId: string | null): this;

  setReplicateMode(mode: "all" | "owner" | "targets"): this;

  shouldReplicateToClient(clientId: string): boolean;

  updateLastSyncedTransform(transform: NetworkTransform): void;

}

declare class netSphere extends waveSphere {

  constructor(options?: NetSphereOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netTorus extends waveTorus {

  constructor(options?: NetTorusOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netTorusKnot extends waveTorusKnot {

  constructor(options?: NetTorusKnotOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netWedge extends waveWedge {

  constructor(options?: NetWedgeOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(t: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netXR3DObject extends xr3DObject {

  constructor();

  constructor(modelAsset: Visual3DModelInput, options?: NetworkOptions);

  constructor(options: NetworkOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(transform: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netXRActor extends xrActor {

  constructor();

  constructor(modelAsset: Visual3DModelInput, options?: NetworkOptions);

  constructor(options: NetworkOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(transform: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare class netXRProp extends xrProp {

  constructor();

  constructor(modelAsset: Visual3DModelInput, options?: NetworkOptions);

  constructor(options: NetworkOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(transform: NetworkTransform): void;

  getNetworkTransform(): NetworkTransform;

}

declare function never(): WaveTimeRule;

interface NotificationOptions {

  autoDismissAfter?: WaveTimeSpan;

  bgColor?: DrawColor;

  cornerRadius?: number;

  fontSize?: number;

  height?: number;

  icon?: string;

  text?: string;

  textColor?: DrawColor;

  width?: number;

}

interface ObjectSurfaceConfig extends MaterialSurfaceConfig {

  fresnelBias: number;

  fresnelColor: number;

  fresnelEnabled: boolean;

  fresnelPower: number;

  glowColor: number | null;

  glowEnabled: boolean;

  glowIntensity: number;

}

declare class ObservationWindow {

  constructor(value: number, unit: WaveTimeUnit);

  readonly kind = "window";

  readonly unit: WaveTimeUnit["kind"];

  readonly value: number;

}

declare const officialPrefabs: Readonly<{ windmill: WaveOfficialPrefab<"windmill">; house: WaveOfficialPrefab<"house">; rocket: WaveOfficialPrefab<"rocket">; scaffold: WaveOfficialPrefab<"scaffold">; grass: WaveOfficialPrefab<"grass">; tree: WaveOfficialPrefab<"tree">; doubleSidedHeightfield: WaveOfficialPrefab<"doubleSidedHeightfield">; physicalHumanoid: WaveOfficialPrefab<"physicalHumanoid">; physicalQuadruped: WaveOfficialPrefab<"physicalQuadruped">; activePhysicsHumanoid: WaveOfficialPrefab<"activePhysicsHumanoid">; }>;

declare function on(point: WaveTimePoint): WaveTimeRule;

declare function once(): WaveTimeRule;

declare function Over(value: number, unit: WaveTimeUnit): ObservationWindow;

interface PaintVertexColorsTextureIntent {

  readonly center: SerializableVector3;

  readonly channel: VertexColorChannel;

  readonly forceMergeMesh: boolean;

  readonly height: number;

  readonly maskChannel: TextureStampMaskChannel;

  readonly maxPlaneDistance: number | null;

  readonly normal: SerializableVector3;

  readonly normalize: boolean;

  readonly rotationDegrees: number;

  readonly strength: number;

  readonly textureAsset: string;

  readonly threshold: number;

  readonly width: number;

}

declare const PALETTE: WaveColorSingleton;

declare function parseAbcScore(text: string): WaveAbcScore;

declare enum WaveModelPartDeleteMode {

  Destroy = "destroy",

  Unmanage = "unmanage",

}

declare enum WaveModelPartLifecycleState {

  Available = "available",

  Created = "created",

  Declared = "declared",

  Destroyed = "destroyed",

  Detached = "detached",

  Promoted = "promoted",

  Registered = "registered",

  Removed = "removed",

}

declare enum PathFollowFlags {

  Loop = 1,

  None = 0,

  PingPong = 4,

  Spin = 8,

  TurnToFace = 2,

}

declare const PerSecond: Readonly<{ kind: "perSecond"; }>;

declare const PerTick: Readonly<{ kind: "perTick"; }>;

type PhysicalAtmosphereConfig = Partial<Omit<PhysicalAtmosphereState, "enabled" | "physicalProperties">> & { physicalProperties?: PhysicalAtmospherePhysicalPropertiesConfig; }

interface PhysicalAtmosphereFogConfig {

  approximateTransmittance?: boolean;

  intensity?: number;

  radianceBias?: number;

  saturation?: number;

  transmittanceScale?: number;

  useLut?: boolean;

}

type PhysicalAtmospherePhysicalPropertiesConfig = Partial<PhysicalAtmospherePhysicalPropertiesState>;

interface PhysicalAtmospherePhysicalPropertiesState {

  atmosphereThickness: number;

  mieAbsorptionScale: number;

  mieScatteringScale: number;

  ozoneAbsorptionScale: number;

  peakMieAbsorption: Vector3Like;

  peakMieScattering: Vector3Like;

  peakOzoneAbsorption: Vector3Like;

  peakRayleighScattering: Vector3Like;

  planetRadius: number;

  planetRadiusOffset: number;

  rayleighScatteringScale: number;

}

interface PhysicalAtmosphereState {

  additionalDiffuseSkyIrradianceColor: ColorInput;

  additionalDiffuseSkyIrradianceIntensity: number;

  aerialPerspectiveIntensity: number;

  aerialPerspectiveRadianceBias: number;

  aerialPerspectiveSaturation: number;

  aerialPerspectiveTransmittanceScale: number;

  applyApproximateTransmittance: boolean;

  diffuseSkyIrradianceDesaturationFactor: number;

  diffuseSkyIrradianceIntensity: number;

  enabled: boolean;

  exposure: number;

  groundAlbedo: ColorInput;

  isAerialPerspectiveLutEnabled: boolean;

  isDiffuseSkyIrradianceLutEnabled: boolean;

  isSkyViewLutEnabled: boolean;

  minimumMultiScatteringColor: ColorInput;

  minimumMultiScatteringIntensity: number;

  multiScatteringIntensity: number;

  originHeight: number;

  physicalProperties: PhysicalAtmospherePhysicalPropertiesState;

}

declare const physicsMaterial: Readonly<{ none(overrides?: Partial<PhysicsMaterialDefinition>): PhysicsMaterialDefinition; glass(overrides?: Partial<PhysicsMaterialDefinition>): PhysicsMaterialDefinition; concrete(overrides?: Partial<PhysicsMaterialDefinition>): PhysicsMaterialDefinition; wood(overrides?: Partial<PhysicsMaterialDefinition>): PhysicsMaterialDefinition; hardwood(overrides?: Partial<PhysicsMaterialDefinition>): PhysicsMaterialDefinition; steel(overrides?: Partial<PhysicsMaterialDefinition>): PhysicsMaterialDefinition; rubber(overrides?: Partial<PhysicsMaterialDefinition>): PhysicsMaterialDefinition; foam(overrides?: Partial<PhysicsMaterialDefinition>): PhysicsMaterialDefinition; }>;

interface PlayerIndicatorOptions {

  color?: ColorInput;

  outlineColor?: ColorInput;

  outlineWidth?: number;

  rotateWithHeading?: boolean;

  shape?: "arrow" | "dot" | "diamond" | "chevron";

  size?: number;

}

declare enum PolygonCapMode {

  Both = "both",

  Bottom = "bottom",

  None = "none",

  Top = "top",

}

declare enum PostFxEffect {

  BlackAndWhite = "blackAndWhite",

  Bloom = "bloom",

  ChromaticAberration = "chromaticAberration",

  DamageVignette = "damageVignette",

  DepthOfField = "depthOfField",

  FXAA = "fxaa",

  Grain = "grain",

  ImageProcessing = "imageProcessing",

  MotionTrail = "motionTrail",

  NightVision = "nightVision",

  OilPainting = "oilPainting",

  PaniniProjection = "paniniProjection",

  RadialBlur = "radialBlur",

  Sharpen = "sharpen",

  SpeedLines = "speedLines",

  ThermalVision = "thermalVision",

  Underwater = "underwater",

  VolumetricLight = "volumetricLight",

}

declare enum PostFxEvent {

  ScreenShake = "screenShake",

}

interface PostFxPlan {

  custom?: PostFxCustomEffectSettings;

  effects?: PostFxEffectSettings;

  profile?: PostFxProfile | `${PostFxProfile}`;

}

declare enum PostFxProfile {

  Cinematic = "cinematic",

  Cool = "cool",

  Default = "default",

  Dreamy = "dreamy",

  HighContrast = "highContrast",

  LowContrast = "lowContrast",

  Noir = "noir",

  None = "none",

  Retro = "retro",

  Sharp = "sharp",

  Vibrant = "vibrant",

  Warm = "warm",

}

declare enum ProfileFieldType {

  bool = "bool",

  float = "float",

  int = "int",

  string = "string",

  vector2 = "vector2",

  vector3 = "vector3",

}

interface ProgressRingOptions {

  color?: DrawColor;

  radius?: number;

  ringWidth?: number;

  showText?: boolean;

  trackColor?: DrawColor;

  value?: number;

}

declare enum ProjectionLightPreset {

  AuroraRipple = "auroraRipple",

  ColorBeams = "colorBeams",

  GentlePulse = "gentlePulse",

  OrganicWash = "organicWash",

  StaticStain = "staticStain",

}

declare function projectRawAsset<TType extends RawProjectAssetType>(entry: Omit<ProjectRawAssetManifestEntry<TType>, "sourceType">): ProjectRawAssetManifestEntry<TType>;

interface Quaternion {

  clone(): Quaternion;

  copyFrom(source: Quaternion): this;

  copyFromFloats(x: number, y: number, z: number, w: number): this;

  multiply(other: Quaternion): Quaternion;

  multiplyToRef<T extends Quaternion>(other: Quaternion, result: T): T;

  normalize(): this;

  set(x: number, y: number, z: number, w: number): this;

  w: number;

  x: number;

  y: number;

  z: number;

}



declare const Quaternion: { new (x?: number, y?: number, z?: number, w?: number): Quaternion; FromEulerAngles(x: number, y: number, z: number): Quaternion; Identity(): Quaternion; RotationAxis(axis: WaveAuthoringVector3Like, angle: number): Quaternion; RotationAxisToRef(axis: WaveAuthoringVector3Like, angle: number, result: Quaternion): Quaternion; RotationYawPitchRoll(yaw: number, pitch: number, roll: number): Quaternion; RotationYawPitchRollToRef(yaw: number, pitch: number, roll: number, result: Quaternion): Quaternion; Slerp(left: WaveAuthoringQuaternionLike, right: WaveAuthoringQuaternionLike, amount: number): Quaternion };

declare function readTextureCpuPixelsSync(texture: unknown, options?: TextureCpuPixelsOptions): TexturePixelData | null;

declare function recomputeWaveVertexDataNormals(payload: WaveVertexDataPayload): WaveVertexDataPayload;

declare enum RegionalScaleFalloff {

  Hard = "hard",

  Linear = "linear",

  Sharp = "sharp",

  Smooth = "smooth",

}

declare const RENDERING_GROUP: { readonly SKYBOX: 0; readonly WORLD: 1; readonly UI_3D: 2; readonly DEBUG: 3; };

declare const Repeat: Readonly<{ break: typeof RepeatBreak; continue: typeof RepeatContinue; }>;

declare function requireWaveTerrainReliefData(value: unknown, subject?: string): WaveTerrainReliefData;

interface ResolvedWaveGrassMaterialOptions {

  alphaCutoff: number;

  baseColor: number;

  bladeHeight: number;

  bladeHeightVariation: number;

  bladeWidth: number;

  coverageSize: number;

  detail: number;

  fadeEnd: number;

  fadeStart: number;

  farTintAlpha: number;

  farTintCoverageMultiplier: number;

  farTintEnd: number;

  farTintStart: number;

  farTintSubdivisions: number;

  farTintYOffset: number;

  fieldUpdateDistance: number;

  fieldUpdateIntervalMs: number;

  positionJitter: number;

  sampleResolution: number;

  shadeColor: number;

  slopeFadeEnd: number;

  slopeFadeStart: number;

  tipColor: number;

  windScale: number;

  windSpeed: number;

  windStrength: number;

}

declare function resolveProjectionLightPreset(preset: ProjectionLightPreset): Readonly<ProjectionLightConfig>;

declare enum RigidBodyActuationCrossing {

  Above = "above",

  Below = "below",

}

declare enum RigidBodyActuationMetricKind {

  BankAngle = "bankAngle",

  PitchAngle = "pitchAngle",

  RollAngle = "rollAngle",

  YawAngle = "yawAngle",

}

declare class RigIKHandleBuilder {

  constructor(_rig: cmp_rig);

  allowOutOfReach(): this;

  at(bone: BodyPart): this;

  boundedByReach(): this;

  create(): WaveRigIKHandle;

  IKstep(steps: number, options?: RigIKOptions): this;

  IKtoRoot(options?: RigIKOptions): this;

  inheritScale(): this;

  offset(offset: SocketOffset): this;

  preserveWorldScale(): this;

  toIntent(): WaveRigIKHandleIntent;

  withIK(options: RigIKOptions): this;

  withOffset(offset: SocketOffset): this;

}

declare class RigSocketBuilder {

  constructor(_rig: cmp_rig);

  at(bone: BodyPart): this;

  create(): BoneSocket;

  inheritScale(): this;

  offset(offset: SocketOffset): this;

  preserveWorldScale(): this;

  toIntent(): WaveRigSocketIntent;

  withOffset(offset: SocketOffset): this;

}

declare enum RiverPreset {

  CanyonRiver = "canyonRiver",

  DeltaChannel = "deltaChannel",

  DryWash = "dryWash",

  MeanderingRiver = "meanderingRiver",

  MountainStream = "mountainStream",

}

declare const ScaleFactorPerSecond: { (value: number): WaveRate; readonly kind: WaveRateUnitKind };

interface SceneExecutionContext<TEngine extends unknown = unknown> {

  readonly babylonScene: unknown | null;

  readonly engine: TEngine & WaveSceneEngineAuthoringContext;

  readonly scene: WaveScene<TEngine>;

}

declare class SceneLoadingProgress {

  constructor(canvas: HTMLCanvasElement, config?: LoadingProgressConfig);

  static hideAllImmediate(): void;

  static subscribe(listener: SceneLoadingProgressListener): () => void;

  hide(): Promise<void>;

  hideImmediate(): void;

  get isVisible(): boolean;

  get progress(): Readonly<LoadingProgress>;

  setPhase(phase: LoadingPhase): void;

  show(): void;

  updateAssetProgress(current: number, total: number, assetPath: string, downloadProgress?: SceneLoadingDownloadProgress): void;

  updatePhaseProgress(phase: LoadingPhase, current: number, total: number, detailText?: string, downloadProgress?: SceneLoadingDownloadProgress): void;

}

interface SceneMainContext<TEngine extends unknown = unknown> extends SceneExecutionContext<TEngine> {

  readonly phase: "main";

}

interface SceneSetupContext<TEngine extends unknown = unknown> extends SceneExecutionContext<TEngine> {

  readonly phase: "setup";

}

declare class SdfSurfaceAssetBuilder<TResult = string> {

  constructor(_id: string, _buildAsset: SdfSurfaceBuildTarget<TResult>);

  apply(): TResult;

  assetOptions(assetOptions: WaveGeometryAssetOptions): this;

  bounds(bounds: DistanceFieldBounds3D): this;

  box(options: SdfSurfaceBoxOptions): this;

  capsule(options: SdfSurfaceCapsuleOptions): this;

  cellSize(cellSize: number): this;

  clipAbove(options: SdfSurfaceClipOptions): this;

  clipBelow(options: SdfSurfaceClipOptions): this;

  ellipsoid(options: SdfSurfaceEllipsoidOptions): this;

  filledPath(path: SdfSurfacePathInput, options: SdfSurfaceFilledPathOptions): this;

  flattenBottom(options: SdfSurfaceClipOptions): this;

  from(recipe: SdfSurfaceRecipeInput): this;

  intersection(shapes: readonly SdfSurfaceRecipeInput[], options?: SdfSurfaceBlendOptions): this;

  lobesAlong(path: SdfSurfacePathInput, options: SdfSurfacePathLobesOptions): this;

  metadata(metadata: Readonly<Record<string, unknown>>): this;

  normalSampleStep(normalSampleStep: number): this;

  options(options: SdfSurfaceAssetBuilderOptions): this;

  puffPath(path: SdfSurfacePathInput, options: SdfSurfaceFilledPathOptions): this;

  puffyShape(path: SdfSurfacePathInput, options: SdfSurfaceFilledPathOptions): this;

  readonly recipe: SdfSurfaceRecipeBuilder;

  repeatAlong(path: SdfSurfacePathInput, build: (sample: SdfSurfacePathRepeatSample) => SdfSurfaceRecipeInput, options?: SdfSurfacePathRepeatOptions): this;

  roundedBox(options: SdfSurfaceRoundedBoxOptions): this;

  roundedFootprint(path: SdfSurfacePathInput, options: SdfSurfaceFilledPathOptions): this;

  smoothIntersection(shapes: readonly SdfSurfaceRecipeInput[], options?: SdfSurfaceBlendOptions): this;

  smoothUnion(shapes: readonly SdfSurfaceRecipeInput[], options?: SdfSurfaceBlendOptions): this;

  smoothUnionEllipsoids(shapes: readonly SdfSurfaceEllipsoidOptions[], options?: SdfSurfaceBlendOptions): this;

  softFilledPath(path: SdfSurfacePathInput, options: SdfSurfaceFilledPathOptions): this;

  sphere(options: SdfSurfaceSphereOptions): this;

  strokeAlong(path: SdfSurfacePathInput, options: SdfSurfaceTubeAlongOptions): this;

  subtract(shape: SdfSurfaceRecipeInput | readonly SdfSurfaceRecipeInput[]): this;

  toConfig(): CreateSdfSurfaceFromRecipeOptions;

  tubeAlong(path: SdfSurfacePathInput, options: SdfSurfaceTubeAlongOptions): this;

  union(shapes: readonly SdfSurfaceRecipeInput[], options?: SdfSurfaceBlendOptions): this;

  uvScale(uvScale: number): this;

}

interface SdfSurfaceAssetBuilderOptions extends WaveSdfRecipeSurfaceOptions {

  readonly assetOptions?: WaveGeometryAssetOptions;

  readonly bounds?: DistanceFieldBounds3D;

  readonly fieldId?: string;

  readonly isoLevel?: number;

  readonly units?: DistanceFieldUnits3D;

}

type SdfSurfaceBuildTarget<TResult = string> = (options: CreateSdfSurfaceFromRecipeOptions) => TResult;

declare const Seconds: { (value: number): WaveTimePoint; readonly kind: WaveTimeUnitKind };

declare enum SensingDevice {

  Audio = "audio",

  Gamepad = "gamepad",

  Hardware = "hardware",

  KeyboardDevice = "keyboard",

  Motion = "motion",

  Mouse = "mouse",

  Touch = "touch",

  Vision = "vision",

  XR = "xr",

}

declare const shaderUniform: { <TType extends WaveShaderUniformType>(name: string, type: TType, options?: WaveShaderUniformOptions<TType>): WaveShaderUniformDefinition<TType>; readonly bool: ShaderUniformTypeHelper<"bool">; readonly color3: ShaderUniformTypeHelper<"color3">; readonly color4: ShaderUniformTypeHelper<"color4">; readonly float: ShaderUniformTypeHelper<"float">; readonly floatArray: ShaderUniformTypeHelper<"floatArray">; readonly int: ShaderUniformTypeHelper<"int">; readonly mat4: ShaderUniformTypeHelper<"mat4">; readonly matrix: ShaderUniformTypeHelper<"matrix">; readonly vec2: ShaderUniformTypeHelper<"vec2">; readonly vec3: ShaderUniformTypeHelper<"vec3">; readonly vec4: ShaderUniformTypeHelper<"vec4"> };

type ShadowCascadeOptions = WaveShadowCascadeOptions;

interface ShadowOptions {

  shadowAutoAddCasters?: boolean;

  shadowAutoReceiveShadows?: boolean;

  shadowBias?: number;

  shadowCascades?: WaveShadowCascadeOptions | false;

  shadowContactHardeningRatio?: number;

  shadowDarkness?: number;

  shadowDepthScale?: number;

  shadowEnableSoftTransparentShadow?: boolean;

  shadowFilter?: ShadowFilterMode;

  shadowFilteringQuality?: WaveGraphShadowFilteringQuality;

  shadowFrustumEdgeFalloff?: number;

  shadowFrustumSize?: number;

  shadowMapSize?: number;

  shadowMaxZ?: number;

  shadowMinZ?: number;

  shadowNormalBias?: number;

  shadowTransparencyShadow?: boolean;

  shadowUpdate?: WaveShadowUpdatePolicy;

  shadowUseFullFloat?: boolean;

  shadowUseOpacityTextureForTransparentShadow?: boolean;

  shadowUseRedTextureType?: boolean;

}

type ShadowUpdatePolicy = WaveShadowUpdatePolicy;

declare const Snapshot = TransformVerbMode.Snapshot;

declare class SpawnAroundBuilder<T extends WaveSpatial3DObject, I extends WaveSpawnInput<T> = WaveSpawnInput<T>> {

  at(origin: WavePointInput): SpawnAroundBuilder<T, I>;

  at(x: number, y: number, z: number): SpawnAroundBuilder<T, I>;

  avoidCollisions(avoid?: boolean): SpawnAroundBuilder<T, I>;

  collisionGroupBit(bit: number): SpawnAroundBuilder<T, I>;

  copyCallbacksToClones(copy?: boolean): SpawnAroundBuilder<T, I>;

  deepClone(deep?: boolean): SpawnAroundBuilder<T, I>;

  forceMergeMesh(force?: boolean): SpawnAroundBuilder<T, I>;

  hideOriginal(hide?: boolean): SpawnAroundBuilder<T, I>;

  includingOriginal(include?: boolean): SpawnAroundBuilder<T, I>;

  inRange(range: PlacementRangeInputSet): SpawnAroundBuilder<T, I>;

  inTotal(n: number): SpawnAroundBuilder<T, I>;

  makingEachSpawnIndependent(): SpawnAroundBuilder<T, I>;

  notInRange(range: PlacementRangeInputSet): SpawnAroundBuilder<T, I>;

  onEach(cb: (entity: SpawnResultMember<T, I>, index: number) => void): SpawnAroundBuilder<T, I>;

  originAt(origin: WavePointInput): SpawnAroundBuilder<T, I>;

  sharingAnimationRig(options: SpawnAnimationRigSharingOptions): SharedAnimationRigSpawnBuilder<SpawnAroundBuilder<T, I>>;

  sharingGeneratedAssetsUntilRegenerate(): SpawnAroundBuilder<T, I>;

  skipCallbacksOnClones(): SpawnAroundBuilder<T, I>;

  withCount(n: number): SpawnAroundBuilder<T, I>;

  withScaleRange(min: number, max: number): SpawnAroundBuilder<T, I>;

  withSeed(seed: number): SpawnAroundBuilder<T, I>;

  constructor(spawner: WaveSpawner, target?: WavePointInput | WaveSpatial3DObject, input?: I);

  evenlySpaced(): this;

  faceCenter(face?: boolean): this;

  faceOutward(face?: boolean): this;

  inRadius(radius: number): this;

  inRadius(minRadius: number, maxRadius: number): this;

  insidePerimeter(): this;

  onPerimeter(): this;

  onPlane(plane: WavePlaneFrameInput): this;

  onXYPlane(): this;

  onXZPlane(): this;

  onYZPlane(): this;

  outsidePerimeter(outerRadius?: number): this;

  place(): SpawnResult<T, I>;

  placeInBatch(): PlacementBatchFor<T>;

  with(input: FxPlayableSystem): FxAroundPlacementBuilder;

  with(input: waveThinBatch): ThinBatchAroundBuilder;

  with<U extends WaveSpatial3DObject>(input: U): SpawnAroundBuilder<U, U>;

  with<U extends WaveSpatial3DObject>(input: ReadonlyArray<U>): SpawnAroundBuilder<U, ReadonlyArray<U>>;

  with<U extends WaveSpatial3DObject>(input: WaveGroup<U>): SpawnAroundBuilder<U, WaveGroup<U>>;

  withHeightRange(min: number, max: number): this;

  withJitter(jitter: Vector3Like | number): this;

  withMinRadius(radius: number): this;

  withRadius(radius: number): this;

  withRandomStrength(strength: number): this;

}

declare class SpawnInGridBuilder<T extends WaveSpatial3DObject, I extends WaveSpawnInput<T> = WaveSpawnInput<T>> {

  at(origin: WavePointInput): SpawnInGridBuilder<T, I>;

  at(x: number, y: number, z: number): SpawnInGridBuilder<T, I>;

  avoidCollisions(avoid?: boolean): SpawnInGridBuilder<T, I>;

  collisionGroupBit(bit: number): SpawnInGridBuilder<T, I>;

  copyCallbacksToClones(copy?: boolean): SpawnInGridBuilder<T, I>;

  deepClone(deep?: boolean): SpawnInGridBuilder<T, I>;

  forceMergeMesh(force?: boolean): SpawnInGridBuilder<T, I>;

  hideOriginal(hide?: boolean): SpawnInGridBuilder<T, I>;

  includingOriginal(include?: boolean): SpawnInGridBuilder<T, I>;

  inRange(range: PlacementRangeInputSet): SpawnInGridBuilder<T, I>;

  inTotal(n: number): SpawnInGridBuilder<T, I>;

  makingEachSpawnIndependent(): SpawnInGridBuilder<T, I>;

  notInRange(range: PlacementRangeInputSet): SpawnInGridBuilder<T, I>;

  onEach(cb: (entity: SpawnResultMember<T, I>, index: number) => void): SpawnInGridBuilder<T, I>;

  originAt(origin: WavePointInput): SpawnInGridBuilder<T, I>;

  sharingAnimationRig(options: SpawnAnimationRigSharingOptions): SharedAnimationRigSpawnBuilder<SpawnInGridBuilder<T, I>>;

  sharingGeneratedAssetsUntilRegenerate(): SpawnInGridBuilder<T, I>;

  skipCallbacksOnClones(): SpawnInGridBuilder<T, I>;

  withCount(n: number): SpawnInGridBuilder<T, I>;

  withScaleRange(min: number, max: number): SpawnInGridBuilder<T, I>;

  withSeed(seed: number): SpawnInGridBuilder<T, I>;

  onEachCell(cb: (entity: SpawnResultMember<T, I>, row: number, col: number, layer: number) => void): this;

  onPlane(plane: WavePlaneFrameInput): this;

  onXYPlane(): this;

  onXZPlane(): this;

  onYZPlane(): this;

  place(): SpawnResult<T, I>;

  placeAs3DGrid(): Wave3DGrid<SpawnResultMember<T, I>>;

  placeInBatch(): PlacementBatchFor<T>;

  randomizeCells(random?: boolean): this;

  withCols(c: number): this;

  withColSpacing(s: number): this;

  withGridTopology(topology: GridTopology): this;

  withJitter(jitter: Vector3Like | number): this;

  withLayers(l: number): this;

  withLayerSpacing(s: number): this;

  withRandomYaw(min?: number, max?: number): this;

  withRows(r: number): this;

  withRowSpacing(s: number): this;

  withSize(rows: number, cols: number, layers?: number): this;

  withSpacing(s: number): this;

  withYawRange(min: number, max: number): this;

}

declare class SpawnInlineBuilder<T extends WaveSpatial3DObject, I extends WaveSpawnInput<T> = WaveSpawnInput<T>> {

  at(origin: WavePointInput): SpawnInlineBuilder<T, I>;

  at(x: number, y: number, z: number): SpawnInlineBuilder<T, I>;

  avoidCollisions(avoid?: boolean): SpawnInlineBuilder<T, I>;

  collisionGroupBit(bit: number): SpawnInlineBuilder<T, I>;

  copyCallbacksToClones(copy?: boolean): SpawnInlineBuilder<T, I>;

  deepClone(deep?: boolean): SpawnInlineBuilder<T, I>;

  forceMergeMesh(force?: boolean): SpawnInlineBuilder<T, I>;

  hideOriginal(hide?: boolean): SpawnInlineBuilder<T, I>;

  includingOriginal(include?: boolean): SpawnInlineBuilder<T, I>;

  inRange(range: PlacementRangeInputSet): SpawnInlineBuilder<T, I>;

  inTotal(n: number): SpawnInlineBuilder<T, I>;

  makingEachSpawnIndependent(): SpawnInlineBuilder<T, I>;

  notInRange(range: PlacementRangeInputSet): SpawnInlineBuilder<T, I>;

  onEach(cb: (entity: SpawnResultMember<T, I>, index: number) => void): SpawnInlineBuilder<T, I>;

  originAt(origin: WavePointInput): SpawnInlineBuilder<T, I>;

  sharingAnimationRig(options: SpawnAnimationRigSharingOptions): SharedAnimationRigSpawnBuilder<SpawnInlineBuilder<T, I>>;

  sharingGeneratedAssetsUntilRegenerate(): SpawnInlineBuilder<T, I>;

  skipCallbacksOnClones(): SpawnInlineBuilder<T, I>;

  withCount(n: number): SpawnInlineBuilder<T, I>;

  withScaleRange(min: number, max: number): SpawnInlineBuilder<T, I>;

  withSeed(seed: number): SpawnInlineBuilder<T, I>;

  alignToPath(align?: boolean): this;

  endAt(v: WavePointInput): this;

  from(v: WavePointInput): this;

  place(): SpawnResult<T, I>;

  placeInBatch(): PlacementBatchFor<T>;

  randomizeAlongPath(random?: boolean): this;

  startFrom(v: WavePointInput): this;

  to(v: WavePointInput): this;

  withJitter(jitter: Vector3Like | number): this;

  withSpacing(s: number): this;

  withUpVector(up: Vector3): this;

}

declare class SpawnInRangeBuilder<T extends WaveSpatial3DObject, I extends WaveSpawnInput<T> = WaveSpawnInput<T>> {

  at(origin: WavePointInput): SpawnInRangeBuilder<T, I>;

  at(x: number, y: number, z: number): SpawnInRangeBuilder<T, I>;

  avoidCollisions(avoid?: boolean): SpawnInRangeBuilder<T, I>;

  collisionGroupBit(bit: number): SpawnInRangeBuilder<T, I>;

  copyCallbacksToClones(copy?: boolean): SpawnInRangeBuilder<T, I>;

  deepClone(deep?: boolean): SpawnInRangeBuilder<T, I>;

  forceMergeMesh(force?: boolean): SpawnInRangeBuilder<T, I>;

  hideOriginal(hide?: boolean): SpawnInRangeBuilder<T, I>;

  includingOriginal(include?: boolean): SpawnInRangeBuilder<T, I>;

  inRange(range: PlacementRangeInputSet): SpawnInRangeBuilder<T, I>;

  inTotal(n: number): SpawnInRangeBuilder<T, I>;

  makingEachSpawnIndependent(): SpawnInRangeBuilder<T, I>;

  notInRange(range: PlacementRangeInputSet): SpawnInRangeBuilder<T, I>;

  onEach(cb: (entity: SpawnResultMember<T, I>, index: number) => void): SpawnInRangeBuilder<T, I>;

  originAt(origin: WavePointInput): SpawnInRangeBuilder<T, I>;

  sharingAnimationRig(options: SpawnAnimationRigSharingOptions): SharedAnimationRigSpawnBuilder<SpawnInRangeBuilder<T, I>>;

  sharingGeneratedAssetsUntilRegenerate(): SpawnInRangeBuilder<T, I>;

  skipCallbacksOnClones(): SpawnInRangeBuilder<T, I>;

  withCount(n: number): SpawnInRangeBuilder<T, I>;

  withScaleRange(min: number, max: number): SpawnInRangeBuilder<T, I>;

  withSeed(seed: number): SpawnInRangeBuilder<T, I>;

  constructor(spawner: WaveSpawner, range: WaveRange | string, input?: I);

  evenlySpaced(): this;

  facing(target: TransformReferenceLike | WavePointInput): this;

  insideRange(): this;

  onRangeSurface(): this;

  place(): SpawnResult<T, I>;

  placeInBatch(): PlacementBatchFor<T>;

  with(input: FxPlayableSystem): FxInRangePlacementBuilder;

  with(input: waveThinBatch): ThinBatchInRangeBuilder;

  with<U extends WaveSpatial3DObject>(input: U): SpawnInRangeBuilder<U, U>;

  with<U extends WaveSpatial3DObject>(input: ReadonlyArray<U>): SpawnInRangeBuilder<U, ReadonlyArray<U>>;

  with<U extends WaveSpatial3DObject>(input: WaveGroup<U>): SpawnInRangeBuilder<U, WaveGroup<U>>;

  withInset(inset: number): this;

  withJitter(jitter: Vector3Like | number): this;

  withRandomStrength(strength: number): this;

}

declare class SpawnOnPathBuilder<T extends WaveSpatial3DObject, I extends WaveSpawnInput<T> = WaveSpawnInput<T>> {

  at(origin: WavePointInput): SpawnOnPathBuilder<T, I>;

  at(x: number, y: number, z: number): SpawnOnPathBuilder<T, I>;

  avoidCollisions(avoid?: boolean): SpawnOnPathBuilder<T, I>;

  collisionGroupBit(bit: number): SpawnOnPathBuilder<T, I>;

  copyCallbacksToClones(copy?: boolean): SpawnOnPathBuilder<T, I>;

  deepClone(deep?: boolean): SpawnOnPathBuilder<T, I>;

  forceMergeMesh(force?: boolean): SpawnOnPathBuilder<T, I>;

  hideOriginal(hide?: boolean): SpawnOnPathBuilder<T, I>;

  includingOriginal(include?: boolean): SpawnOnPathBuilder<T, I>;

  inRange(range: PlacementRangeInputSet): SpawnOnPathBuilder<T, I>;

  inTotal(n: number): SpawnOnPathBuilder<T, I>;

  makingEachSpawnIndependent(): SpawnOnPathBuilder<T, I>;

  notInRange(range: PlacementRangeInputSet): SpawnOnPathBuilder<T, I>;

  onEach(cb: (entity: SpawnResultMember<T, I>, index: number) => void): SpawnOnPathBuilder<T, I>;

  originAt(origin: WavePointInput): SpawnOnPathBuilder<T, I>;

  sharingAnimationRig(options: SpawnAnimationRigSharingOptions): SharedAnimationRigSpawnBuilder<SpawnOnPathBuilder<T, I>>;

  sharingGeneratedAssetsUntilRegenerate(): SpawnOnPathBuilder<T, I>;

  skipCallbacksOnClones(): SpawnOnPathBuilder<T, I>;

  withCount(n: number): SpawnOnPathBuilder<T, I>;

  withScaleRange(min: number, max: number): SpawnOnPathBuilder<T, I>;

  withSeed(seed: number): SpawnOnPathBuilder<T, I>;

  alignToPath(align?: boolean): this;

  along(path: WaveCurveInput): this;

  followingPath(path: WaveCurveInput): this;

  place(): SpawnResult<T, I>;

  placeInBatch(): PlacementBatchFor<T>;

  randomizeAlongPath(random?: boolean): this;

  withJitter(jitter: Vector3Like | number): this;

  withSpacing(s: number): this;

  withUpVector(up: Vector3): this;

}

declare class SpawnOnSurfaceBuilder<T extends WaveSpatial3DObject, I extends WaveSpawnInput<T> = WaveSpawnInput<T>> {

  at(origin: WavePointInput): SpawnOnSurfaceBuilder<T, I>;

  at(x: number, y: number, z: number): SpawnOnSurfaceBuilder<T, I>;

  avoidCollisions(avoid?: boolean): SpawnOnSurfaceBuilder<T, I>;

  collisionGroupBit(bit: number): SpawnOnSurfaceBuilder<T, I>;

  copyCallbacksToClones(copy?: boolean): SpawnOnSurfaceBuilder<T, I>;

  deepClone(deep?: boolean): SpawnOnSurfaceBuilder<T, I>;

  forceMergeMesh(force?: boolean): SpawnOnSurfaceBuilder<T, I>;

  hideOriginal(hide?: boolean): SpawnOnSurfaceBuilder<T, I>;

  includingOriginal(include?: boolean): SpawnOnSurfaceBuilder<T, I>;

  inRange(range: PlacementRangeInputSet): SpawnOnSurfaceBuilder<T, I>;

  inTotal(n: number): SpawnOnSurfaceBuilder<T, I>;

  makingEachSpawnIndependent(): SpawnOnSurfaceBuilder<T, I>;

  notInRange(range: PlacementRangeInputSet): SpawnOnSurfaceBuilder<T, I>;

  onEach(cb: (entity: SpawnResultMember<T, I>, index: number) => void): SpawnOnSurfaceBuilder<T, I>;

  originAt(origin: WavePointInput): SpawnOnSurfaceBuilder<T, I>;

  sharingAnimationRig(options: SpawnAnimationRigSharingOptions): SharedAnimationRigSpawnBuilder<SpawnOnSurfaceBuilder<T, I>>;

  sharingGeneratedAssetsUntilRegenerate(): SpawnOnSurfaceBuilder<T, I>;

  skipCallbacksOnClones(): SpawnOnSurfaceBuilder<T, I>;

  withCount(n: number): SpawnOnSurfaceBuilder<T, I>;

  withScaleRange(min: number, max: number): SpawnOnSurfaceBuilder<T, I>;

  withSeed(seed: number): SpawnOnSurfaceBuilder<T, I>;

  constructor(spawner: WaveSpawner, _surface: SpawnSurface, input?: I);

  alignToNormal(align?: boolean): this;

  asGpuSurfaceSource(options?: WaveGpuSurfaceSourceOptions): WaveGpuDataSourceBindingBuilder<unknown>;

  followSurfaceDeformation(follow?: boolean): this;

  inSurfaceSelection(selection: WaveModelSurfaceSelectionDefinition): this;

  notInRiver(river: SurfaceRiverNoPlaceSource, options?: SurfaceRiverNoPlaceOptions): this;

  place(): SpawnResult<T, I>;

  placeInBatch(): PlacementBatchFor<T>;

  projectFrom(point: TransformReferenceLike | WavePointInput): this;

  with(input: FxPlayableSystem): FxOnSurfacePlacementBuilder;

  with(input: waveThinBatch): ThinBatchOnSurfaceBuilder;

  with<U extends WaveSpatial3DObject>(input: U): SpawnOnSurfaceBuilder<U, U>;

  with<U extends WaveSpatial3DObject>(input: ReadonlyArray<U>): SpawnOnSurfaceBuilder<U, ReadonlyArray<U>>;

  with<U extends WaveSpatial3DObject>(input: WaveGroup<U>): SpawnOnSurfaceBuilder<U, WaveGroup<U>>;

  withJitter(jitter: Vector3Like | number): this;

  withRandomYaw(min?: number, max?: number): this;

  withSurfaceOffset(offset: number): this;

  withYawRange(min: number, max: number): this;

  withYOffset(offset: number): this;

}

declare const speechFx: { chain(...nodes: readonly WaveInstrumentFxNode[]): WaveSpeechFxChainBuilder; chorus(options?: WaveSpeechFxNodeOptions<"chorus">): WaveSpeechFxConfig; compressor(options?: WaveSpeechFxNodeOptions<"compressor">): WaveSpeechFxConfig; convolver(options?: WaveSpeechFxNodeOptions<"convolver">): WaveSpeechFxConfig; delay(options?: WaveSpeechFxNodeOptions<"delay">): WaveSpeechFxConfig; distortion(options?: WaveSpeechFxNodeOptions<"distortion">): WaveSpeechFxConfig; eq(options: WaveSpeechFxNodeOptions<"eq">): WaveSpeechFxConfig; megaphone(): WaveSpeechFxConfig; none(): WaveSpeechFxConfig; panner(options?: WaveSpeechFxNodeOptions<"panner">): WaveSpeechFxConfig; preset(preset: WaveSpeechFxPreset): WaveSpeechFxConfig; radio(): WaveSpeechFxConfig; robot(): WaveSpeechFxConfig; simpleRoom(options?: WaveSpeechFxNodeOptions<"simpleRoom">): WaveSpeechFxConfig; softRoom(): WaveSpeechFxConfig; tremolo(options?: WaveSpeechFxNodeOptions<"tremolo">): WaveSpeechFxConfig };

declare function srgbColorToLinear(color: SampledRgbaColor): SampledRgbaColor;

declare enum StarFieldFormation {

  GALAXY_BAND = 1,

  SCATTERED = 0,

}

interface StarFieldState {

  brightness: number;

  celestialRotation: boolean;

  color: ColorInput;

  colorTemperature: number;

  enabled: boolean;

  formation: StarFieldFormation;

  galaxyCoreColor: ColorInput;

  galaxyEdgeColor: ColorInput;

  galaxyIntensity: number;

  minElevation: number;

  shootingStarBrightness: number;

  shootingStarDuration: number;

  shootingStarInterval: number;

  shootingStarLength: number;

  shootingStars: boolean;

  size: number;

  sizeVariance: number;

  starCount: number;

  twinkle: boolean;

  twinkleSpeed: number;

}

type SurfaceCategory = "wall" | "floor" | "ceiling";

declare class SurfaceDeformationPlayback {

  get failedError(): string | null;

  readonly id: string;

  isRunning(): boolean;

  stop(): void;

}

declare enum SurfacePreset {

  BrushedMetal = "brushedMetal",

  Chrome = "chrome",

  Emissive = "emissive",

  FrostedGlass = "frostedGlass",

  Glass = "glass",

  Gloss = "gloss",

  Matte = "matte",

  Metal = "metal",

  Plastic = "plastic",

  Rubber = "rubber",

  Satin = "satin",

  Toon = "toon",

}

declare enum SystemStateLane {

  ActorDecision = "sys:state:actorDecision",

  Audio = "sys:state:audio",

  Equipment = "sys:state:equipment",

  KinematicMotion = "sys:state:kinematicMotion",

  PhysicsActuation = "sys:state:physicsActuation",

  SpatialOccupancy = "sys:state:spatialOccupancy",

  Thinking = "sys:state:thinking",

}

declare enum SystemTag {

  Cloned = "sys:cloned",

  DebugWatch = "sys:debug:watch",

  Effect = "sys:effect",

  Environment = "sys:environment",

  GroupController = "sys:groupController",

  Handler = "Handler",

  HMRPersistent = "sys:hmr",

  MarkedForDestroy = "sys:destroy",

  Marker = "sys:marker",

  NPC = "sys:npc",

  Persistent = "sys:persistent",

  Pickable_Character = "sys:pickable:character",

  Pickable_Debug = "sys:pickable:debug",

  Pickable_Interactable = "sys:pickable:interactable",

  Pickable_Trigger = "sys:pickable:trigger",

  Pickable_UI = "sys:pickable:ui",

  Pickable_World = "sys:pickable:world",

  Pickable = "sys:pickable",

  Pickup = "sys:pickup",

  Player = "sys:player",

  Prefab = "sys:prefab",

  Projectile = "sys:projectile",

  Prop = "sys:prop",

  Suspect_CPU = "sys:suspect:cpu",

  Suspect_Leak = "sys:suspect:leak",

  Suspect_Memory = "sys:suspect:mem",

  Vehicle = "sys:vehicle",

}

declare enum TerracePreset {

  Agricultural = "agricultural",

  CliffSteps = "cliffSteps",

  NaturalShelves = "naturalShelves",

  RiceTerraces = "riceTerraces",

}

declare enum TerrainMaterialRole {

  Cliff = "cliff",

  Ground = "ground",

  RiverBank = "riverBank",

  RiverBed = "riverBed",

  Rock = "rock",

  Sand = "sand",

  Snow = "snow",

  Soil = "soil",

  WetGround = "wetGround",

}

type TerrainPreset = typeof TerrainPreset[keyof typeof TerrainPreset];

declare const TerrainPreset: Readonly<{ readonly FlatPlain: "flatPlain"; readonly RollingMeadow: "rollingMeadow"; readonly RollingHighlands: "rollingHighlands"; readonly AlpineValley: "alpineValley"; readonly RuggedHighlands: "ruggedHighlands"; readonly GlacialValley: "glacialValley"; readonly CoastalCliffs: "coastalCliffs"; readonly VolcanicIsland: "volcanicIsland"; readonly Archipelago: "archipelago"; readonly CanyonBadlands: "canyonBadlands"; readonly MesaPlateau: "mesaPlateau"; readonly DesertDunes: "desertDunes"; readonly KarstHills: "karstHills"; readonly RiverDelta: "riverDelta"; readonly CrateredBasin: "crateredBasin"; }>;

declare enum TerrainQuality {

  Balanced = "balanced",

  Cinematic = "cinematic",

  High = "high",

  Mobile = "mobile",

}

declare enum TerrainRiverRegion {

  Banks = "banks",

  Bed = "bed",

  Channel = "channel",

  Floodplain = "floodplain",

  Shoreline = "shoreline",

  Water = "water",

}

declare enum TerrainStyle {

  AnimeLowPoly = "animeLowPoly",

  ChunkyCartoon = "chunkyCartoon",

  Photorealistic = "photorealistic",

}

declare class ThinBatchIndexAuthoringScope {

  constructor(_batch: waveThinBatch, _index: number);

  addAngularVelocity(...args: ThinBatchPhysicsBodyVectorArgs): this;

  addLinearVelocity(...args: ThinBatchPhysicsBodyVectorArgs): this;

  applyAngularImpulse(...args: ThinBatchPhysicsBodyAngularImpulseArgs): this;

  applyForce(...args: ThinBatchPhysicsBodyForceArgs): this;

  applyImpulse(...args: ThinBatchPhysicsBodyImpulseArgs): this;

  applyTorque(...args: ThinBatchPhysicsBodyVectorArgs): this;

  get batch(): waveThinBatch;

  clearConstantForce(name?: string): this;

  done(): waveThinBatch;

  enlargeBy(factor: number): this;

  fitBetween(start: WavePointInput, end: WavePointInput, options?: FitBetweenOptions): this;

  getPosition(terms?: ThinBatchTransformTerms): Vector3;

  getRotation(terms?: ThinBatchTransformTerms): Quaternion;

  getScale(terms?: ThinBatchTransformTerms): Vector3;

  get index(): number;

  keepMoving(direction: DirectionInput): WaveTransformAnimationBuilder;

  keepMovingBackward(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepMovingDown(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepMovingForward(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepMovingLeft(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepMovingRight(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepMovingUp(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepPitchingDown(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepPitchingUp(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepRollingLeft(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepRollingRight(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepRotatingAround(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingAlong(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingAlongBackwardBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongBy(axis: DirectionInput, factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongDownBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongForwardBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongLeftBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongRightBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongUpBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingToward(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingTowardBackwardBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardBy(axis: DirectionInput, factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardDownBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardForwardBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardLeftBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardRightBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardUpBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepTurningLeft(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepTurningRight(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  moveBy(axis: DirectionInput, units: number): this;

  moveTo(position: WavePointInput, terms?: ThinBatchTransformTerms): this;

  moveX(units: number): this;

  moveY(units: number): this;

  moveZ(units: number): this;

  get physicsBody(): ThinBatchPhysicsBodyIndexScope;

  pitchDown(degrees: number): this;

  pitchUp(degrees: number): this;

  rollLeft(degrees: number): this;

  rollRight(degrees: number): this;

  rotateAroundBy(axis: DirectionInput, degrees: number): this;

  rotateAroundTo(axis: DirectionInput, degrees: number): this;

  rotateBy(axis: DirectionInput, degrees: number): this;

  rotateByQuaternion(delta: Quaternion): this;

  rotateTo(rotation: Quaternion, terms?: ThinBatchTransformTerms): this;

  scaleAlongBy(axis: DirectionInput, factor: number): this;

  scaleAlongTo(axis: DirectionInput, value: number): this;

  scaleBy(value: number, terms?: ThinBatchTransformTerms): this;

  scaleTo(value: number | Vector3Like, terms?: ThinBatchTransformTerms): this;

  scaleTowardBy(axis: DirectionInput, factor: number): this;

  scaleTowardTo(axis: DirectionInput, value: number): this;

  setAngularDamping(damping: number): this;

  setAngularVelocity(...args: ThinBatchPhysicsBodyVectorArgs): this;

  setAttribute(kind: string, value: number[], refresh?: boolean): this;

  setColor(color: ColorInput, alpha?: number): this;

  setColorRGBA(r: number, g: number, b: number, a?: number): this;

  setConstantForce(name: string, config: ThinBatchConstantForceConfig): this;

  setConstantForce(name: string, force: Vector3Like | DirectionInput, options?: ThinBatchConstantForceOptions): this;

  setConstantForce(name: string, direction: Vector3Like | DirectionInput, strength: number, options?: ThinBatchConstantForceOptions): this;

  setGravityFactor(factor: number): this;

  setLinearDamping(damping: number): this;

  setLinearVelocity(...args: ThinBatchPhysicsBodyVectorArgs): this;

  setMass(mass: number): this;

  setMatrix(matrix: unknown, terms?: ThinBatchTransformTerms): this;

  setPathFollowParams(params: PathFollowInstanceParams): this;

  setPosition(position: WavePointInput, terms?: ThinBatchTransformTerms): this;

  setRotation(rotation: Quaternion, terms?: ThinBatchTransformTerms): this;

  setScale(scale: Vector3Like, terms?: ThinBatchTransformTerms): this;

  setScale(uniform: number, terms?: ThinBatchTransformTerms): this;

  setScale(x: number, y: number, z: number, terms?: ThinBatchTransformTerms): this;

  setTargetTransform(position: WavePointInput, rotation?: QuaternionLike): this;

  setTransform(position: WavePointInput, rotation: Quaternion, scale: Vector3Like | number, terms?: ThinBatchTransformTerms): this;

  shrinkBy(factor: number): this;

  stopMoving(): this;

  stopPitching(): this;

  stopRolling(): this;

  stopRotating(): this;

  stopScaling(): this;

  stopTurning(): this;

  get transform(): ThinBatchTransformFrameScope;

  turnLeft(degrees: number): this;

  turnRight(degrees: number): this;

  useDynamicBody(): this;

  useKinematicBody(): this;

  useStaticBody(): this;

}

declare enum ThinkingAccelerationMode {

  Auto = "auto",

  CPU = "cpu",

  WebGPU = "webgpu",

}

declare function through(point: WaveTimePoint): WaveTimeRule;

declare const Ticks: { (value: number): WaveTimePoint; readonly kind: WaveTimeUnitKind };

declare function tilemapWorldLayer<TSourceOptions extends object>(id: string, source: WaveWorldSourceConfig<TSourceOptions>, options?: WaveTilemapWorldLayerOptions): WaveWorldLayerDraft<TSourceOptions, WaveTilemapLayerConfig>;

declare function tiles3DWorldLayer<TSourceOptions extends object, TRendererOptions extends object = object>(id: string, source: WaveWorldSourceConfig<TSourceOptions>, options?: WaveTiles3DWorldLayerOptions<TRendererOptions>): WaveWorldLayerDraft<TSourceOptions, WaveTiles3DLayerConfig<TRendererOptions>>;

declare function timeAgo(value: number, unit: WaveTimeUnit): WaveTimeLookback;

declare const ToFalse: Readonly<{ kind: "toFalse"; }>;

declare class ToggleController<TEntity extends object, TState> {

  constructor(entity: EntityStateControllerHost<TEntity, TState>, stateA: TState, stateB: TState);

  readonly callback: () => void;

  currentState(): TState;

  dispose(): void;

  isActive(): boolean;

  isFirst(): boolean;

  isSecond(): boolean;

  setToFirst(): boolean;

  setToSecond(): boolean;

  toggle(): boolean;

}

declare enum ToolMode {

  Dev = "dev",

  Production = "production",

}

interface TooltipOptions {

  bgColor?: DrawColor;

  cornerRadius?: number;

  fontSize?: number;

  height?: number;

  padding?: number;

  text?: string;

  textColor?: DrawColor;

  width?: number;

}

declare const ToTrue: Readonly<{ kind: "toTrue"; }>;

type TrackedMinimapEntity = WaveSpatial3DObject;

declare enum TransformVerbMode {

  Animate = "animate",

  Snapshot = "snapshot",

}

declare enum TransitionCorner {

  BottomLeft = 2,

  BottomRight = 3,

  TopLeft = 0,

  TopRight = 1,

}

declare class TransitionLifecycleHandle<State extends Record<string, number>, Source = unknown> implements TransitionLifecycleChainStepHandle {

  constructor(_startState: State);

  cancel(policy: TransitionCancellationPolicy): void;

  get completed(): boolean;

  get controller(): WaveAnimationController | null;

  get failed(): boolean;

  get lastProgress(): number;

  get lastState(): State;

  get loopCount(): number;

  markCompleted(state: State): void;

  markFailed(): void;

  notifyComplete(controller: WaveAnimationController): void;

  notifyLoopComplete(loopCount: number, controller: WaveAnimationController): void;

  notifyStart(controller: WaveAnimationController, options?: TransitionLifecycleStartOptions): void;

  notifyUpdate(controller: WaveAnimationController, state: State): void;

  onComplete(callback?: (controller: WaveAnimationController, state: State) => void): this;

  onFailed(callback?: () => void): this;

  onLoopComplete(callback?: (loop: number, controller: WaveAnimationController, state: State) => void): this;

  onProgress(callback?: (progress: number, controller: WaveAnimationController, state: State) => void): this;

  onStart(callback?: (controller: WaveAnimationController, state: State) => void): this;

  onStopped(callback?: () => void): this;

  onUpdate(callback?: (controller: WaveAnimationController, state: State) => void): this;

  pause(): void;

  restart(): void;

  resume(): void;

  setAbsoluteSpeed(speed: number): void;

  setSpeed(speed: number): void;

  get source(): Source | undefined;

  get sourceVersion(): number;

  stop(): void;

  get stopped(): boolean;

  get terminalReason(): TransitionLifecycleTerminalReason | null;

  thenDo(step: TransitionLifecycleThenDoStep): TransitionLifecycleChainHandle;

  updateSource(newSource: Source, options?: UpdateSourceOptions): void;

  withCallbacks(callbacks?: TransitionLifecycleCallbacks<State>): this;

}

declare enum TransitionMaskMode {

  DiagonalWipe = 1,

  FullScreen = 0,

  OvalMask = 2,

}

interface TreeBuildRecipe {

  readonly optimizeFor?: TreeOptimizationProfile;

}

type TreeCrownShape = "conical" | "round" | "broad" | "columnar";

type TreeFoliageDensity = "sparse" | "natural" | "lush" | number;

interface TreeFoliageRecipe {

  readonly cardSize?: number;

  readonly colors?: readonly number[];

  readonly density?: TreeFoliageDensity;

  readonly secondaryTint?: ColorInput;

  readonly tint?: ColorInput;

}

interface TreeGrowthRecipe {

  readonly branchAngle?: number;

  readonly branchDensity?: number;

  readonly crownShape?: TreeCrownShape;

  readonly curvature?: number;

  readonly height?: number;

  readonly trunkRadiusRatio?: number;

}

type TreeLeafColorsInput = readonly ColorInput[] | ColorGradientOptions | ColorPalette;

type TreeLeafPalette = typeof WAVE_TREE_LEAF_PALETTE[keyof typeof WAVE_TREE_LEAF_PALETTE];

type TreeOptimizationProfile = typeof WAVE_TREE_OPTIMIZATION[keyof typeof WAVE_TREE_OPTIMIZATION];

interface TreeRecipeSnapshot {

  readonly build?: TreeBuildRecipe;

  readonly foliage?: TreeFoliageRecipe;

  readonly growth?: TreeGrowthRecipe;

  readonly seed?: number;

  readonly species?: TreeSpeciesInput;

  readonly trunkColor?: ColorInput;

  readonly wind?: TreeWindRecipe;

}

type TreeSpecies = typeof WAVE_TREE_SPECIES[keyof typeof WAVE_TREE_SPECIES];

type TreeSpeciesInput = TreeSpecies | "white oak" | "oak" | "red maple" | "maple" | "tulip poplar" | "poplar" | "sweetgum" | "sweet gum" | "american beech" | "beech" | "broadleaf" | "ponderosa pine" | "pine" | "loblolly pine" | "loblolly" | "douglas fir" | "fir" | "joshua tree" | "yucca" | "saguaro" | "cactus";

type TreeWindIntent = "none" | "gentle" | "breezy" | number;

interface TreeWindRecipe {

  readonly strength?: TreeWindIntent;

}

type UICanvasAnchor = "top-left" | "top" | "top-right" | "left" | "center" | "right" | "bottom-left" | "bottom" | "bottom-right";

interface UICanvasBox {

  height: number;

  width: number;

  x: number;

  y: number;

}

interface UICanvasCurveBrushOptions {

  color?: ColorInput;

  lineCap?: UICanvasLineCap;

  lineJoin?: UICanvasLineJoin;

  minDistance?: number;

  opacity?: number;

  smoothing?: UICanvasCurveSmoothing;

  width?: number;

}

type UICanvasCurvePoint = WaveCurve2DPoint;

type UICanvasCurveSmoothing = WaveCurve2DSmoothing;

interface UICanvasCurveStroke {

  color: ColorInput;

  id: string;

  lineCap: UICanvasLineCap;

  lineJoin: UICanvasLineJoin;

  opacity: number;

  points: UICanvasCurvePoint[];

  smoothing: UICanvasCurveSmoothing;

  width: number;

}

interface UICanvasFitBoxOptions {

  align?: UICanvasAnchor;

  flipY?: boolean;

  padding?: number;

  preserveAspectRatio?: boolean;

  sourceBox?: UICanvasBox;

}

type UICanvasPathCommand = { type: "moveTo"; x: number; y: number; } | { type: "lineTo"; x: number; y: number; } | { type: "quadTo"; cpx: number; cpy: number; x: number; y: number; } | { type: "cubicTo"; cp1x: number; cp1y: number; cp2x: number; cp2y: number; x: number; y: number; } | { type: "ellipse"; cx: number; cy: number; rx: number; ry: number; rotation: number; startAngle: number; endAngle: number; counterclockwise: boolean; } | { type: "arcTo"; x1: number; y1: number; x2: number; y2: number; radius: number; } | { type: "close"; }

interface UICanvasPathFillOptions {

  color?: DrawColor;

  rule?: UICanvasFillRule;

}

interface UICanvasPathSnapshot {

  commands: UICanvasPathCommand[];

  cursor: UICanvasPathSnapshotPoint | null;

  fill: UICanvasPathFillOptions | null;

  lastCubicControl: UICanvasPathSnapshotPoint | null;

  lastQuadraticControl: UICanvasPathSnapshotPoint | null;

  name: string | null;

  opacity: number | null;

  stroke: UICanvasPathStrokeOptions | null;

  subpathStart: UICanvasPathSnapshotPoint | null;

  transform: UICanvasAffine2D;

}

interface UICanvasPathSnapshotPoint {

  x: number;

  y: number;

}

interface UICanvasPathStrokeOptions {

  color?: DrawColor;

  dash?: number[];

  lineCap?: UICanvasLineCap;

  lineJoin?: UICanvasLineJoin;

  miterLimit?: number;

  width?: number;

}

type UICanvasPathToPointsOptions = WaveCurve2DSamplingOptions;

type UICanvasPointerDrawActionCallback<TContext extends UICanvasPointerDrawActionContext = UICanvasPointerDrawActionContext> = (context: TContext) => void;

type UICanvasPointerDrawActionContext = UICanvasPointerDrawStartContext | UICanvasPointerDrawMoveContext | UICanvasPointerDrawFinishContext;

interface UICanvasPointerDrawActionSource {

  clientId?: string;

  isRemote?: boolean;

}

interface UICanvasPointerDrawFinishContext extends UICanvasPointerDrawActionSource {

  pointCount: number;

  strokeId: string;

  x: number;

  y: number;

  phase: "finish";

  stroke: UICanvasCurveStroke;

}

interface UICanvasPointerDrawMoveContext extends UICanvasPointerDrawActionSource {

  pointCount: number;

  strokeId: string;

  x: number;

  y: number;

  phase: "move";

}

interface UICanvasPointerDrawOptions extends UICanvasCurveBrushOptions {

  clearExisting?: boolean;

}

interface UICanvasPointerDrawStartContext extends UICanvasPointerDrawActionSource {

  pointCount: number;

  strokeId: string;

  x: number;

  y: number;

  phase: "start";

  stroke: UICanvasCurveStroke;

}

type UICanvasValueCurveEvaluator = (input: number) => number;

interface UICanvasValueCurvePlotOptions {

  axisColor?: DrawColor;

  backgroundColor?: DrawColor;

  curveColor?: DrawColor;

  curveWidth?: number;

  gridColor?: DrawColor;

  padding?: number | Partial<{ top: number; right: number; bottom: number; left: number; }>;

  sampleCount?: number;

  showSamples?: boolean;

  textColor?: DrawColor;

  title?: string;

  xLabel?: string;

  yLabel?: string;

  yRange?: readonly [number, number];

  zeroLineColor?: DrawColor;

}

declare const UnitsPerSecond: { (value: number): WaveRate; readonly kind: WaveRateUnitKind };

interface Vector2 {

  add(other: Vector2): Vector2;

  clone(): Vector2;

  copyFrom(source: Vector2): this;

  length(): number;

  lengthSquared(): number;

  normalize(): this;

  scale(factor: number): Vector2;

  set(x: number, y: number): this;

  subtract(other: Vector2): Vector2;

  x: number;

  y: number;

}



declare const Vector2: { new (x?: number, y?: number): Vector2; Distance(left: WaveAuthoringVector2Like, right: WaveAuthoringVector2Like): number; DistanceSquared(left: WaveAuthoringVector2Like, right: WaveAuthoringVector2Like): number; One(): Vector2; Zero(): Vector2 };

interface Vector3 {

  add(other: Vector3): Vector3;

  addInPlace(other: Vector3): this;

  addInPlaceFromFloats(x: number, y: number, z: number): this;

  clone(): Vector3;

  copyFrom(source: Vector3): this;

  copyFromFloats(x: number, y: number, z: number): this;

  length(): number;

  lengthSquared(): number;

  normalize(): this;

  rotateByQuaternionToRef<T extends Vector3>(rotation: Quaternion, result: T): T;

  scale(factor: number): Vector3;

  scaleInPlace(factor: number): this;

  set(x: number, y: number, z: number): this;

  setAll(value: number): this;

  subtract(other: Vector3): Vector3;

  subtractInPlace(other: Vector3): this;

  x: number;

  y: number;

  z: number;

}



declare const Vector3: { new (x?: number, y?: number, z?: number): Vector3; Backward(): Vector3; Cross(left: WaveAuthoringVector3Like, right: WaveAuthoringVector3Like): Vector3; Distance(left: WaveAuthoringVector3Like, right: WaveAuthoringVector3Like): number; DistanceSquared(left: WaveAuthoringVector3Like, right: WaveAuthoringVector3Like): number; Dot(left: WaveAuthoringVector3Like, right: WaveAuthoringVector3Like): number; Down(): Vector3; Forward(): Vector3; Left(): Vector3; Lerp(start: WaveAuthoringVector3Like, end: WaveAuthoringVector3Like, amount: number): Vector3; One(): Vector3; Right(): Vector3; TransformCoordinatesFromFloatsToRef(x: number, y: number, z: number, transformation: unknown, result: Vector3): Vector3; TransformCoordinatesToRef(vector: WaveAuthoringVector3Like, transformation: unknown, result: Vector3): Vector3; Up(): Vector3; Zero(): Vector3 };

declare enum VertexEditSpace {

  Mesh = "mesh",

  Parent = "parent",

  World = "world",

}

declare enum VertexFalloff {

  Gaussian = "gaussian",

  Linear = "linear",

  None = "none",

  Sharp = "sharp",

  Smooth = "smooth",

}

declare enum VertexInfluenceScope {

  Selection = "selection",

  WholeMesh = "wholeMesh",

}

declare enum VisionGestureName {

  ClosedFist = "closed-fist",

  FingerGun = "finger-gun",

  Grab = "grab",

  Horns = "horns",

  ILoveYou = "i-love-you",

  MiddlePinch = "middle-pinch",

  OK = "ok",

  OpenPalm = "open-palm",

  Pinch = "pinch",

  PinkyPinch = "pinky-pinch",

  PointingUp = "pointing-up",

  RingPinch = "ring-pinch",

  Shaka = "shaka",

  SwipeDown = "swipe-down",

  SwipeLeft = "swipe-left",

  SwipeRight = "swipe-right",

  SwipeUp = "swipe-up",

  Three = "three",

  ThumbDown = "thumb-down",

  ThumbUp = "thumb-up",

  Unknown = "unknown",

  Victory = "victory",

  Wave = "wave",

}

interface VisualBreadcrumbTrailHandle {

  readonly batch: waveThinBatch | null;

  clear(): this;

  readonly isActive: boolean;

  readonly isPaused: boolean;

  pause(): this;

  resume(): this;

  stop(): this;

}

type VolumetricCloudConfig = EnabledEnvironmentPatch<VolumetricCloudState>;

type VolumetricCloudSetConfig = VolumetricCloudConfig & { enabled?: boolean; }

interface VolumetricCloudState {

  altitude: number;

  cloudColorBottom?: ColorInput;

  cloudColorTop?: ColorInput;

  coverage: number;

  density: number;

  enabled: boolean;

  formation: WaveCloudFormation;

  layers?: CloudLayer[];

  lightAbsorption: number;

  scale: number;

  shapeEvolutionSeconds: number;

  steps: number;

  thickness: number;

  windDirection: { x: number; z: number; }

  windSpeed: number;

}

declare const WAVE_BROWSER_RUNTIME_FAULT_EVENT = "wave-browser-runtime-fault";

declare const WAVE_BROWSER_RUNTIME_STATUS_EVENT = "wave-browser-runtime-status";

declare const WAVE_CLOUD_FORMATIONS: readonly ["cumulus", "stratus", "cirrus", "storm"];

declare const WAVE_DEFORMATION_REST_POSITION_ATTRIBUTE = "waveDeformationRestPosition";

declare const WAVE_FOUNDATION_PROFILE_IDS: Readonly<{ local: WaveEngineProfileId; p2pHost: WaveEngineProfileId; p2pHostHeadless: WaveEngineProfileId; thinClient: WaveEngineProfileId; }>;

declare const WAVE_GPU_DRIVEN_GEOMETRY_FLEX_FORCE_FUNCTION: "waveGpuDrivenGeometryFlexWithForce";

declare const WAVE_SKINNED_SURFACE_FRAME_WGSL_MODULE: { readonly cacheIdentity: string; readonly dependencies: readonly WaveWGSLModuleDependency[]; readonly capabilities: readonly WaveWGSLModuleCapability[]; readonly dependencies?: readonly WaveWGSLModuleDependency[]; readonly name: string; readonly schema: "wave.wgslModule.v1"; readonly source: string; readonly stages: readonly WaveWGSLModuleStage[]; readonly version: number };

declare const WAVE_SKINNED_VERTEX_DECLARATION = "#include<bonesDeclaration>";

declare class wave2DObject<TState = void> extends WaveObject<TState, SerializableVector2, WaveTransform2DFrameSnapshotPatch, "2d"> {

  alignDirectionWith(target: Wave2DLayoutTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  alignDirectionWith(target: Wave2DLayoutTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  alignDirectionWith(target: Wave2DLayoutTarget): this;

  applyAuthoredPoseSnapshot(snapshot: WaveTransform2DPoseSnapshot): this;

  applyParentSnapshot(snapshot: WaveTransform2DFrameSnapshotPatch): this;

  applyTransformStateSnapshot(snapshot: WaveTransform2DStateSnapshot): this;

  attachTo(parent: Wave2DLayoutTarget): Wave2DReparentBuilder<this>;

  authoredPoseSnapshot(): WaveTransform2DPoseSnapshot;

  bodyBounds: WaveLayoutBodyBox;

  cancelTransformAnimations(policy: TransitionCancellationPolicy): this;

  clearHistory(): this;

  detachTo(point: WaveScreenPointRef): Wave2DReparentBuilder<this>;

  distanceTo(target: WaveTransform2DTurnTarget): number;

  down: Vector2;

  downExtent: number;

  downFaceCenter: Vector2;

  faceCenter(side: WaveBodySide2D): WaveLocator2DRef;

  fitBetween(): Wave2DFitBetweenBuilder<this>;

  fitBetween(start: Wave2DFitPoint, end: Wave2DFitPoint, mode: TransformVerbMode.Animate): WaveTransform2DFitBetweenAnimationBuilder;

  fitBetween(start: Wave2DFitPoint, end: Wave2DFitPoint, mode: TransformVerbMode.Snapshot): WaveTransform2DFitBetweenBuilder;

  fitBetween(start: Wave2DFitPoint, end: Wave2DFitPoint, options?: WaveTransform2DFitOptions): this;

  getAcceleration(): Vector2;

  getAccelerationMagnitude(): number;

  getAngularRate(): number;

  getHistorySample(when: WaveTimeLookback): WaveTransform2DHistorySample | null;

  getHistorySamples(): readonly WaveTransform2DHistorySample[];

  getLocalPosition(): SerializableVector2;

  getLocalRotation(): number;

  getParent2D(): Wave2DLayoutTarget | null;

  getPosition(): SerializableVector2;

  getPosition(when: WaveTimeLookback): SerializableVector2 | null;

  getRotation(): number;

  getRotation(when: WaveTimeLookback): number | null;

  getScale(): SerializableVector2;

  getScale(when: WaveTimeLookback): SerializableVector2 | null;

  getSpeed(): number;

  getSpeedDeclineRate(): number;

  getSpeedGrowthRate(): number;

  getVelocity(): Vector2;

  getWorldPosition(): SerializableVector2;

  getWorldRotation(): number;

  historyDepth: number;

  historySampleCount: number;

  inFrameOf(target: WaveTransform2DEntityTarget): WaveTransform2DFrameScope;

  inLocalFrame(): WaveTransform2DFrameScope;

  inLocalTerms(): WaveTransform2DTermsScope;

  inParentFrame(depth?: number): WaveTransform2DFrameScope;

  inParentTerms(): WaveTransform2DTermsScope;

  inView(cameraId: string): WaveTransform2DViewScope;

  inWorldFrame(): WaveTransform2DFrameScope;

  inWorldTerms(): WaveTransform2DTermsScope;

  isFacing(target: WaveTransform2DTurnTarget, options?: WaveOrient2DOptions): boolean;

  isMotionReady: boolean;

  isRecordingHistory: boolean;

  keepMoving(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepMovingDown(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepMovingLeft(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepMovingRight(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepMovingUp(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlong(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepScalingAlongBy(direction: WaveDirection2DInput, factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongDownBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongLeftBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongRightBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongUpBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingToward(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepScalingTowardBy(direction: WaveDirection2DInput, factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardDownBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardLeftBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardRightBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardUpBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepTurningLeft(degreesPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepTurningRight(degreesPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  layer: number;

  layout(): WaveUILayoutBuilder<this>;

  left: Vector2;

  leftExtent: number;

  leftFaceCenter: Vector2;

  localPosition: SerializableVector2;

  localRotationDegrees: number;

  localX: number;

  localY: number;

  locator(): WaveLocator2DBuilder;

  markMotionDiscontinuous(): this;

  motionReadiness: WaveTransform2DMotionReadiness;

  moveBy(delta: Vector2Like_3, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveBy(delta: Vector2Like_3, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveBy(delta: Vector2Like_3): this;

  moveBy(direction: WaveDirection2DInput, distance: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveBy(direction: WaveDirection2DInput, distance: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveBy(direction: WaveDirection2DInput, distance: number): this;

  moveBy(x: number, y: number): this;

  moveDown(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveDown(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveDown(units: number): this;

  moveLeft(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveLeft(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveLeft(units: number): this;

  moveRight(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveRight(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveRight(units: number): this;

  moveTo(target: WaveTransform2DMoveTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveTo(target: WaveTransform2DMoveTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveTo(target: WaveTransform2DMoveTarget): this;

  moveTo(x: number, y: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveTo(x: number, y: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveTo(x: number, y: number): this;

  moveUp(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveUp(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveUp(units: number): this;

  moveX(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveX(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveX(units: number): this;

  moveY(units: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveY(units: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveY(units: number): this;

  onDrag(callback: UI2DDragCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  onDragMove(callback: UI2DDragMoveCallback<this>, options?: UI2DDragMoveOptions): UI2DDragMoveHandle<this>;

  onDragMove(options?: UI2DDragMoveOptions): UI2DDragMoveHandle<this>;

  parentSnapshot(): WaveTransform2DFrameSnapshot;

  parentSnapshot(when: WaveTimeLookback): WaveTransform2DFrameSnapshot | null;

  pivotAt(value: Vector2Like_3, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  pivotAt(value: Vector2Like_3, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  pivotAt(value: Vector2Like_3): this;

  position: SerializableVector2;

  recordHistory(options?: TransformHistoryRecordingOptions): this;

  resetLayout(): this;

  resetPivot(): this;

  right: Vector2;

  rightExtent: number;

  rightFaceCenter: Vector2;

  rotateBy(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  rotateBy(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  rotateBy(degrees: number): this;

  rotateTo(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  rotateTo(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  rotateTo(degrees: number): this;

  rotationDegrees: number;

  scale2D: SerializableVector2;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number): this;

  scaleAlongTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleAlongTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleAlongTo(direction: WaveDirection2DInput, value: number): this;

  scaleBy(value: number | Vector2Like_3, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleBy(value: number | Vector2Like_3, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleBy(value: number | Vector2Like_3): this;

  scaleBy(x: number, y: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleBy(x: number, y: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleBy(x: number, y: number): this;

  scaleTo(value: number | Vector2Like_3, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTo(value: number | Vector2Like_3, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTo(value: number | Vector2Like_3): this;

  scaleTo(x: number, y: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTo(x: number, y: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTo(x: number, y: number): this;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number): this;

  scaleTowardTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTowardTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTowardTo(direction: WaveDirection2DInput, value: number): this;

  setHistoryDepth(depth: number): this;

  setLayer(layer: number): this;

  stopRecordingHistory(options?: { clear?: boolean; }): this;

  takeTransformStateSnapshot(): WaveTransform2DStateSnapshot;

  transition(): WaveTransform2DPoseTransitionBuilder;

  transitionTo(pose: WaveTransform2DPoseSnapshot): WaveTransform2DPoseTransitionBuilder;

  turnLeft(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnLeft(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnLeft(degrees: number): this;

  turnRight(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnRight(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnRight(degrees: number): this;

  turnTo(target: Vector2Like_3 | WaveScreenPointRef | Wave2DLayoutTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnTo(target: Vector2Like_3 | WaveScreenPointRef | Wave2DLayoutTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnTo(target: Vector2Like_3 | WaveScreenPointRef | Wave2DLayoutTarget): this;

  turnToward(direction: WaveDirection2DInput, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnToward(direction: WaveDirection2DInput, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnToward(direction: WaveDirection2DInput): this;

  up: Vector2;

  upExtent: number;

  upFaceCenter: Vector2;

  vectorFrom(source: WaveTransform2DTurnTarget): Vector2;

  vectorTo(target: WaveTransform2DTurnTarget): Vector2;

  whenClickedOn(callback: UI2DClickCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenHoverEnteredOn(callback: UI2DHoverCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenHoverExitedOn(callback: UI2DHoverCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenHoveringOn(callback: UI2DHoverCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenPressedOn(callback: UI2DPressCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenReleasedOn(callback: UI2DReleaseCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  worldSnapshot(): WaveTransform2DFrameSnapshot;

  worldSnapshot(when: WaveTimeLookback): WaveTransform2DFrameSnapshot | null;

  x: number;

  y: number;

  constructor();

  static readonly typeName: EntityType;

}

declare abstract class wave3DAbstract<TState = unknown> extends WaveObject<TState, Vector3, Partial<ResolvedWorldTransformSnapshot>, "3d"> {

  alignDirectionWith(target: TransformReferenceLike): this;

  alignDirectionWith(target: TransformReferenceLike, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  alignDirectionWith(target: TransformReferenceLike, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  get animator(): cmp_animatorBase;

  applyParentSnapshot(snapshot: ResolvedWorldTransformSnapshot): this;

  get backward(): Vector3;

  get backwardExtent(): number;

  get backwardFaceCenter(): Vector3;

  clickToMark(size: number): this;

  clickToMark(options?: ClickToMarkOptions): this;

  destroy(): void;

  disableClickToMark(): this;

  distanceTo(target: WavePointInput): number;

  get down(): Vector3;

  get downExtent(): number;

  get downFaceCenter(): Vector3;

  enlargeBy(factor: number): this;

  faceCenter(surface: SemanticWaveSurface | SemanticDirection): WavePointSource;

  findPointBy(): WaveAuthoredPoint;

  fitBetween(): FitBetweenBuilder<this>;

  fitBetween(start: FitBetweenPoint, end: FitBetweenPoint, mode: typeof Snapshot): WaveTransformFitBetweenBuilder<cmp_transform>;

  fitBetween(start: FitBetweenPoint, end: FitBetweenPoint, mode: typeof Animate): WaveTransformFitBetweenAnimationBuilder;

  fitBetween(start: FitBetweenPoint, end: FitBetweenPoint, options?: FitBetweenOptions): this;

  get forward(): Vector3;

  get forwardExtent(): number;

  get forwardFaceCenter(): Vector3;

  getBoundingBox(): ModelBoundingBox | null;

  getBoundingBoxVolume(): number;

  getHistorySample(when: WaveTimeLookback): TransformHistorySample | null;

  getHistorySamples(): readonly TransformHistorySample[];

  getLocalPosition(): Vector3;

  getLocalRotation(): Quaternion;

  getOrientedBounds(): ModelOrientedBounds | null;

  getPivotLocal(): Vector3;

  getPivotWorld(): Vector3;

  getPosition(): Vector3;

  getPosition(space: WaveSpace): Vector3;

  getPosition(when: WaveTimeLookback): Vector3 | null;

  getPosition(space: WaveSpace, when: WaveTimeLookback): Vector3 | null;

  getRotation(): Quaternion;

  getRotation(space: WaveSpace): Quaternion;

  getRotation(when: WaveTimeLookback): Quaternion | null;

  getRotation(space: WaveSpace, when: WaveTimeLookback): Quaternion | null;

  getScale(): Vector3;

  getScale(space: WaveSpace): Vector3;

  getScale(when: WaveTimeLookback): Vector3 | null;

  getScale(space: WaveSpace, when: WaveTimeLookback): Vector3 | null;

  getWorldPosition(): Vector3;

  getWorldRotation(): Quaternion;

  get hasAnimator(): boolean;

  hideAngularVelocity(): this;

  hideAxis(): this;

  hideBoundingBox(): this;

  hideControlSphere(): this;

  hideDirection(): this;

  hideDirectionAndAxis(): this;

  hideForceArrow(): this;

  hideLinearVelocity(): this;

  hideLocalPivot(): this;

  hideSkeleton(): this;

  isFacing(target: TransformReferenceLike | WavePointInput, options?: WaveOrientOptions): boolean;

  isInRange(range: WaveRange | string, options?: WaveRangeEntityMatchOptions): () => boolean;

  isOnRangeBorder(range: WaveRange | string, options?: WaveRangeEntityMatchOptions): () => boolean;

  isOutOfRange(range: WaveRange | string, options?: WaveRangeEntityMatchOptions): () => boolean;

  keepLookingAt(target: TransformReferenceLike | WavePointInput, options?: WaveLookAtOptions): this;

  keepMoving(direction: DirectionInput): WaveTransformAnimationBuilder;

  keepMovingBackward(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepMovingDown(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepMovingForward(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepMovingLeft(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepMovingRight(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepMovingUp(unitsPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepPitchingDown(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepPitchingUp(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepRollingLeft(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepRollingRight(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepRotatingAround(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingAlong(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingAlongBackwardBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongBy(axis: DirectionInput, factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongDownBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongForwardBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongLeftBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongRightBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingAlongUpBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingToward(axis: DirectionInput): WaveTransformAnimationBuilder;

  keepScalingTowardBackwardBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardBy(axis: DirectionInput, factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardDownBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardForwardBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardLeftBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardRightBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepScalingTowardUpBy(factorPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepTurningLeft(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  keepTurningRight(degreesPerSecond: number, durationSeconds?: number): TransitionLifecycleHandle<Record<string, number>>;

  get left(): Vector3;

  get leftExtent(): number;

  get leftFaceCenter(): Vector3;

  get localPosition(): Vector3;

  localToParent(localPoint: Vector3Like): Vector3;

  localToParent(x: number, y: number, z: number): Vector3;

  localToWorld(localPoint: Vector3Like): Vector3;

  localToWorld(x: number, y: number, z: number): Vector3;

  get localX(): number;

  get localY(): number;

  get localZ(): number;

  locator(): WaveLocatorBuilder;

  marker(modelOrScale?: string | number, markerScale?: number): WaveMarkerHandle;

  moveBackward(distance: number): this;

  moveBackward(distance: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  moveBackward(distance: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  moveBy(direction: DirectionInput, distance: number): this;

  moveBy(direction: DirectionInput, distance: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  moveBy(direction: DirectionInput, distance: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  moveDown(distance: number): this;

  moveDown(distance: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  moveDown(distance: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  moveForward(distance: number): this;

  moveForward(distance: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  moveForward(distance: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  moveLeft(distance: number): this;

  moveLeft(distance: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  moveLeft(distance: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  moveRight(distance: number): this;

  moveRight(distance: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  moveRight(distance: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  moveTo(target: TransformReferenceLike | WavePointInput): this;

  moveTo(target: TransformReferenceLike | WavePointInput, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  moveTo(target: TransformReferenceLike | WavePointInput, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  moveUp(distance: number): this;

  moveUp(distance: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  moveUp(distance: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  moveX(distance: number): this;

  moveX(distance: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  moveX(distance: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  moveY(distance: number): this;

  moveY(distance: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  moveY(distance: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  moveZ(distance: number): this;

  moveZ(distance: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  moveZ(distance: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  onBankAngle(space?: WaveSpace): NumericObservationSource<this>;

  onBankRate(space?: WaveSpace): NumericObservationSource<this>;

  onDistanceTo(target: WavePointInput | wave3DAbstract): NumericObservationSource<this>;

  onPitchAngle(space?: WaveSpace): NumericObservationSource<this>;

  onPitchRate(space?: WaveSpace): NumericObservationSource<this>;

  onRange(range: WaveRange | string, match?: WaveRangeMatch, options?: WaveRangeEntityMatchOptions): NumericObservationSource<this>;

  onRollAngle(space?: WaveSpace): NumericObservationSource<this>;

  onRollRate(space?: WaveSpace): NumericObservationSource<this>;

  onRotationRate(space?: WaveSpace): NumericObservationSource<this>;

  onSpeed(): NumericObservationSource<this>;

  onXPos(space?: WaveSpace): NumericObservationSource<this>;

  onXSpeed(space?: WaveSpace): NumericObservationSource<this>;

  onXYSpeed(): NumericObservationSource<this>;

  onXZSpeed(): NumericObservationSource<this>;

  onYawAngle(space?: WaveSpace): NumericObservationSource<this>;

  onYawRate(space?: WaveSpace): NumericObservationSource<this>;

  onYPos(space?: WaveSpace): NumericObservationSource<this>;

  onYSpeed(space?: WaveSpace): NumericObservationSource<this>;

  onYZSpeed(): NumericObservationSource<this>;

  onZPos(space?: WaveSpace): NumericObservationSource<this>;

  onZSpeed(space?: WaveSpace): NumericObservationSource<this>;

  parentSnapshot(): ResolvedWorldTransformSnapshot;

  parentSnapshot(when: WaveTimeLookback): ResolvedWorldTransformSnapshot | null;

  parentToLocal(parentPoint: Vector3Like): Vector3;

  parentToLocal(x: number, y: number, z: number): Vector3;

  pitchDown(degrees: number): this;

  pitchDown(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  pitchDown(degrees: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  pitchUp(degrees: number): this;

  pitchUp(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  pitchUp(degrees: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  placeAbove(target: RelativePlacementTarget, extraDistance?: number): this;

  placeAbove(position: Vector3Like, extraDistance?: number): this;

  placeAbove(x: number, y: number, z: number, extraDistance?: number): this;

  placeAt(target: TransformReferenceLike | WavePointInput): this;

  placeAt(x: number, y: number, z: number): this;

  placeBehind(target: RelativePlacementTarget, extraDistance?: number): this;

  placeBehind(position: Vector3Like, extraDistance?: number): this;

  placeBehind(x: number, y: number, z: number, extraDistance?: number): this;

  placeBelow(target: RelativePlacementTarget, extraDistance?: number): this;

  placeBelow(position: Vector3Like, extraDistance?: number): this;

  placeBelow(x: number, y: number, z: number, extraDistance?: number): this;

  placeInFrontOf(target: RelativePlacementTarget, extraDistance?: number): this;

  placeInFrontOf(position: Vector3Like, extraDistance?: number): this;

  placeInFrontOf(x: number, y: number, z: number, extraDistance?: number): this;

  placeMarkerAt(point: WavePointInput, modelOrScale?: string | number, markerScale?: number): WaveMarkerHandle;

  placeOnSurface(surface: SpawnSurface): this;

  placeOnSurface(surface: SpawnSurface, projectFrom: TransformReferenceLike | WavePointInput): this;

  placeToLeftOf(target: RelativePlacementTarget, extraDistance?: number): this;

  placeToLeftOf(position: Vector3Like, extraDistance?: number): this;

  placeToLeftOf(x: number, y: number, z: number, extraDistance?: number): this;

  placeToRightOf(target: RelativePlacementTarget, extraDistance?: number): this;

  placeToRightOf(position: Vector3Like, extraDistance?: number): this;

  placeToRightOf(x: number, y: number, z: number, extraDistance?: number): this;

  get position(): Vector3;

  randomPointInRadius(radius: number, lockAxis?: RawDirection): Vector3;

  resetPivot(): this;

  get right(): Vector3;

  get rightExtent(): number;

  get rightFaceCenter(): Vector3;

  rollLeft(degrees: number): this;

  rollLeft(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  rollLeft(degrees: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  rollRight(degrees: number): this;

  rollRight(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  rollRight(degrees: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  rotateAroundBy(axis: DirectionInput, degrees: number): this;

  rotateAroundBy(axis: DirectionInput, degrees: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  rotateAroundBy(axis: DirectionInput, degrees: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  rotateAroundTo(axis: DirectionInput, degrees: number): this;

  rotateAroundTo(axis: DirectionInput, degrees: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  rotateAroundTo(axis: DirectionInput, degrees: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  rotateBy(axis: DirectionInput, degrees: number): this;

  rotateBy(axis: DirectionInput, degrees: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  rotateBy(axis: DirectionInput, degrees: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  rotateByQuaternion(delta: Quaternion): this;

  rotateByQuaternion(delta: Quaternion, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  rotateByQuaternion(delta: Quaternion, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  rotateTo(rotation: Quaternion): this;

  rotateTo(rotation: Quaternion, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  rotateTo(rotation: Quaternion, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  scaleAlongBy(axis: DirectionInput, factor: number): this;

  scaleAlongBy(axis: DirectionInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  scaleAlongBy(axis: DirectionInput, factor: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  scaleAlongTo(axis: DirectionInput, value: number): this;

  scaleAlongTo(axis: DirectionInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  scaleAlongTo(axis: DirectionInput, value: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  scaleBy(value: number | Vector3Like): this;

  scaleBy(value: number | Vector3Like, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  scaleBy(value: number | Vector3Like, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  scaleTo(value: number | Vector3Like): this;

  scaleTo(value: number | Vector3Like, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  scaleTo(value: number | Vector3Like, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  scaleTowardBy(axis: DirectionInput, factor: number): this;

  scaleTowardBy(axis: DirectionInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  scaleTowardBy(axis: DirectionInput, factor: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  scaleTowardTo(axis: DirectionInput, value: number): this;

  scaleTowardTo(axis: DirectionInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  scaleTowardTo(axis: DirectionInput, value: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  setLocalPosition(position: WavePointInput): this;

  setLocalPosition(x: number, y: number, z: number): this;

  setLocalRotation(rotation: Quaternion): this;

  setOriginFromWorldPoint(newOriginWorld: WavePointInput): this;

  setOriginFromWorldPoint(x: number, y: number, z: number): this;

  setPivotLocal(localPoint: WavePointInput): this;

  setPivotLocal(x: number, y: number, z: number): this;

  setPivotWorld(worldPoint: WavePointInput): this;

  setPivotWorld(x: number, y: number, z: number): this;

  setScale(scale: Vector3Like): this;

  setScale(uniform: number): this;

  setScale(x: number, y: number, z: number): this;

  setUniformScale(scale: number): this;

  setWorldPosition(position: WavePointInput): this;

  setWorldPosition(x: number, y: number, z: number): this;

  setWorldRotation(rotation: Quaternion): this;

  showAngularInertia(options?: DevToolTextOptions): this;

  showAngularVelocity(options?: VelocityArrowOptions): this;

  showAxis(axis: Direction, options?: AxisArrowOptions): this;

  showAxis(options?: AxisArrowOptions): this;

  showBoundingBox(options?: BoundingBoxOptions): this;

  showCenterOfMass(options?: AnchorMarkerOptions): this;

  showCollider(color?: ColorInput): this;

  showControlSphere(options?: ControlSphereOptions): this;

  showCoordinate(options?: CoordinateDisplayOptions): this;

  showCustomDirection(name: string, direction: Vector3Like, options?: CustomDirectionArrowOptions): this;

  showDimensions(options?: DimensionArrowOptions): this;

  showDirection(direction: DirectionInput, options?: DirectionArrowOptions): this;

  showDirection(options?: DirectionArrowOptions): this;

  showDirectionAndAxis(direction: DirectionInput, options?: DirectionAndAxisArrowOptions): this;

  showDirectionAndAxis(options?: DirectionAndAxisArrowOptions): this;

  showDistance(target: wave3DAbstract<unknown>, options?: DistanceArrowOptions): this;

  showForceArrow(options?: ForceArrowOptions): this;

  showLabel(text: string, options?: LabelPanelOptions): this;

  showLinearVelocity(options?: VelocityArrowOptions): this;

  showLocalPivot(options?: PointMarkerOptions): this;

  showLocalPoint(name: string, pointOrOptions?: WavePointInput | PointMarkerOptions, options?: PointMarkerOptions): this;

  showMass(options?: DevToolTextOptions): this;

  showName(options?: OverheadPanelOptions): this;

  showName(name: string, options?: OverheadPanelOptions): this;

  showOrigin(options?: AnchorMarkerOptions): this;

  showPivot(options?: PivotMarkerOptions): this;

  showPlane(options?: PlaneOptions): this;

  showPosition(options?: CoordinateDisplayOptions): this;

  showPosition(point: WavePointInput | PositionFaceCenterInput, options?: CoordinateDisplayOptions): this;

  showRotation(options?: RotationPanelOptions): this;

  showScale(options?: DevToolTextOptions): this;

  showSkeleton(options?: SkeletonViewerOptions): this;

  showSpeed(options?: SpeedDisplayOptions): this;

  showTag(options?: OverheadPanelOptions): this;

  shrinkBy(factor: number): this;

  stopKeepingLookingAt(): this;

  get tool(): cmp_tool;

  transition(): WaveTransformPoseTransitionBuilder;

  transitionTo(target: ResolvedWorldTransformSnapshot): WaveTransformPoseTransitionBuilder;

  turnLeft(degrees: number): this;

  turnLeft(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  turnLeft(degrees: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  turnRight(degrees: number): this;

  turnRight(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  turnRight(degrees: number, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  turnTo(target: TransformReferenceLike | WavePointInput): this;

  turnTo(target: TransformReferenceLike | WavePointInput, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  turnTo(target: TransformReferenceLike | WavePointInput, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  turnToward(direction: DirectionInput): this;

  turnToward(direction: DirectionInput, mode: TransformVerbMode.Snapshot): WaveTransformSnapshotBuilder<cmp_transform>;

  turnToward(direction: DirectionInput, mode: TransformVerbMode.Animate): WaveTransformAnimationBuilder;

  get up(): Vector3;

  get upExtent(): number;

  get upFaceCenter(): Vector3;

  vectorFrom(source: WavePointInput): Vector3;

  vectorTo(target: WavePointInput): Vector3;

  whenAccelerating(options?: WaveMotionRateIntentOptions): WaveMotionRateIntentBuilder<this>;

  whenDecelerating(options?: WaveMotionRateIntentOptions): WaveMotionRateIntentBuilder<this>;

  worldSnapshot(): ResolvedWorldTransformSnapshot;

  worldSnapshot(when: WaveTimeLookback): ResolvedWorldTransformSnapshot | null;

  worldToLocal(worldPoint: Vector3Like): Vector3;

  worldToLocal(x: number, y: number, z: number): Vector3;

  get worldXDir(): Vector3;

  get worldYDir(): Vector3;

  get worldZDir(): Vector3;

  get x(): number;

  get y(): number;

  get z(): number;

}

declare class Wave3DGrid<T extends WaveSpatial3DObject = WaveSpatial3DObject> extends WaveGroup<T> {

  constructor(name: string, controller?: NoInfer<T> | wave3DObject, scene?: WaveGroupSceneBridge);

  asStreamingProvider(options?: Omit<Grid3DStreamingProviderOptions, "gridInfo">): Grid3DStreamingProvider;

  get cellCount(): number;

  clearCells(): this;

  configureGrid(info: Partial<Wave3DGridInfo>): this;

  deleteCell(row: number, col: number, layer?: number): boolean;

  destroyAllMembers(): void;

  findCell(entity: T): GridCellIndex | null;

  findHighestLayer(row: number, col: number, minLayer?: number, maxLayer?: number): number | null;

  forEachCell(fn: (entity: T, row: number, col: number, layer: number) => void): this;

  getCell(row: number, col: number, layer?: number): T | undefined;

  getCellAtWorldPosition(position: Vector3Like, snap?: GridCellSnapMode): T | undefined;

  getCellCoordinatesAtWorldPosition(position: Vector3Like, snap?: GridCellSnapMode): GridCellIndex | null;

  getCellWorldPosition(row: number, col: number, layer?: number): Vector3;

  getColumn(row: number, col: number): Array<{ layer: number; entity: T; }>;

  getNearestCell(position: Vector3Like): T | undefined;

  getNearestCellCoordinates(position: Vector3Like): GridCellIndex | null;

  get gridInfo(): Wave3DGridInfo;

  hasCell(row: number, col: number, layer?: number): boolean;

  pathfind(): Wave3DGridPathBuilder<T>;

  remove(member: T): boolean;

  setCell(row: number, col: number, layer: number, entity: T): this;

  setGridInfo(info: Wave3DGridInfo): this;

  get spatialGrid(): WaveSpatialGrid3D<T>;

}

declare class Wave3DGridPathBuilder<T extends WaveSpatial3DObject = WaveSpatial3DObject> {

  constructor(_grid: GridPathSource<T>);

  allowDiagonals(enabled?: boolean): this;

  allowEmptyCells(enabled?: boolean): this;

  allowVertical(enabled?: boolean): this;

  asCells(): GridCellIndex[];

  asEntities(): Array<T | null>;

  asSteps(): Array<Wave3DGridPathStep<T>>;

  asWorldPoints(): Vector3[];

  from(entity: T): this;

  from(position: Vector3Like, snap?: GridCellSnapMode): this;

  fromCell(row: number, col: number, layer?: number): this;

  fromWorldPosition(position: Vector3Like, snap?: GridCellSnapMode): this;

  to(entity: T): this;

  to(position: Vector3Like, snap?: GridCellSnapMode): this;

  toCell(row: number, col: number, layer?: number): this;

  toWorldPosition(position: Vector3Like, snap?: GridCellSnapMode): this;

  walkable(predicate: WalkablePredicate<T>): this;

}

declare class wave3DObject<TState = unknown> extends wave3DAbstract<TState> {

  constructor(modelAsset?: Visual3DModelAuthoringInput);

  static readonly typeName: EntityType;

  addAngularVelocity(delta: Vector3Like | DirectionInput): this;

  addAngularVelocity(dx: number, dy: number, dz: number): this;

  addAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): this;

  addComponent<T extends WaveComponent>(componentClassOrInstance: ComponentConstructor<T> | T, ...args: unknown[]): T | null;

  addDecal(texture: string): DecalBuilder;

  addingNoise(): ReturnType<cmp_visual3DModel["addingNoise"]>;

  addLinearVelocity(delta: Vector3Like | DirectionInput): this;

  addLinearVelocity(dx: number, dy: number, dz: number): this;

  addLinearVelocity(direction: Vector3Like | DirectionInput, speed: number): this;

  addTag(tag: string): this;

  addTags(...tags: string[]): this;

  adoptPart(targetObject: wave3DObject, options?: AdoptPartOptions): wave3DObject;

  adoptParts(targetObjects: readonly wave3DObject[], options?: AdoptPartsOptions): wave3DObject[];

  adoptPartsFrom(targetObject: wave3DObject, options?: AdoptPartsOptions): wave3DObject[];

  alignOriginToModelBounds(...args: Parameters<cmp_visual3DModel["alignOriginToModelBounds"]>): this;

  get allowUnsafePartDestroy(): boolean; set allowUnsafePartDestroy(value: boolean);

  get angularDamping(): number | null;

  get angularInertia(): Vector3Like | null;

  get angularVelocity(): Vector3Like | SerializableVector3 | null;

  get animator(): cmp_modelAnimator;

  applyAngularImpulse(impulse: Vector3Like | DirectionInput): this;

  applyAngularImpulse(axis: Vector3Like | DirectionInput, strength: number): this;

  applyForce(hit: RigidBodyInteractionHitInput, strength?: number): this;

  applyForce(force: Vector3Like | DirectionInput, contactPoint?: WavePhysicsContactPointInput): this;

  applyForce(direction: Vector3Like | DirectionInput, strength: number, contactPoint?: WavePhysicsContactPointInput): this;

  applyImpulse(hit: RigidBodyInteractionHitInput, strength?: number): this;

  applyImpulse(impulse: Vector3Like | DirectionInput, contactPoint?: WavePhysicsContactPointInput): this;

  applyImpulse(direction: Vector3Like | DirectionInput, strength: number, contactPoint?: WavePhysicsContactPointInput): this;

  applySurfaceConfig(config: ObjectSurfaceConfig): this;

  applyTexturePainting(...args: Parameters<cmp_visual3DModel["applyTexturePainting"]>): ReturnType<cmp_visual3DModel["applyTexturePainting"]>;

  applyTorque(torque: Vector3Like | DirectionInput): this;

  applyTorque(x: number, y: number, z: number): this;

  applyTorque(axis: Vector3Like | DirectionInput, strength: number): this;

  get archetype(): string;

  get attachedTo(): WaveEntity | null;

  attract(...args: Parameters<cmp_visual3DModel["attract"]>): ReturnType<cmp_visual3DModel["attract"]>;

  attracting(): ReturnType<cmp_visual3DModel["attracting"]>;

  autoRenameMeshes(...args: Parameters<cmp_visual3DModel["autoRenameMeshes"]>): ReturnType<cmp_visual3DModel["autoRenameMeshes"]>;

  avoidCollisionByTag(tag: string, ...tags: string[]): this;

  avoidCollisionByTag(tags: readonly string[]): this;

  avoidCollisionWith(...targets: (wave3DObject | readonly wave3DObject[])[]): this;

  bend(...args: Parameters<cmp_visual3DModel["bend"]>): ReturnType<cmp_visual3DModel["bend"]>;

  bending(): ReturnType<cmp_visual3DModel["bending"]>;

  bindMeshesToPart(...args: Parameters<cmp_visual3DModel["bindMeshesToPart"]>): ReturnType<cmp_visual3DModel["bindMeshesToPart"]>;

  booleanBatch(...args: Parameters<cmp_visual3DModel["booleanBatch"]>): ReturnType<cmp_visual3DModel["booleanBatch"]>;

  bulging(): ReturnType<cmp_visual3DModel["bulging"]>;

  cacheVertices(...args: Parameters<cmp_visual3DModel["cacheVertices"]>): ReturnType<cmp_visual3DModel["cacheVertices"]>;

  canEditMesh(): ReturnType<cmp_visual3DModel["canEditMesh"]>;

  castToProp(options?: CastToPropOptions): waveProp;

  checkSupport(direction?: Vector3Like | DirectionInput, deltaTime?: number): SurfaceInfo | null;

  clearConstantForce(name?: string): this;

  clearConstantForces(): this;

  clearConstantTorque(name?: string): this;

  clearConstantTorques(): this;

  clearDecals(): void;

  clearMass(): this;

  clearPickable(): this;

  clearSurfaceVfx(options?: Parameters<cmp_visual3DModel["clearSurfaceVfx"]>[0]): this;

  clearVertexCache(...args: Parameters<cmp_visual3DModel["clearVertexCache"]>): ReturnType<cmp_visual3DModel["clearVertexCache"]>;

  clonePart(partRef: PartRef, options?: Omit<ExtractPartsOptions, "mode" | "source" | "partName">): wave3DObject;

  cloneParts(selection: PartSelection, options?: Omit<ExtractPartsOptions, "mode" | "source" | "partName">): wave3DObject[];

  get collisionGroup(): number | null;

  get collisionMask(): number | null;

  combinePart(partRefs: readonly PartRef[], options?: CombinePartsOptions): wave3DObject;

  combinePart(partRef: PartRef, options?: CombinePartsOptions): wave3DObject;

  combinePart(partRef: PartRef, secondPartRef: PartRef, ...partRefs: PartRef[]): wave3DObject;

  combinePart(partRef: PartRef, secondPartRef: PartRef, ...partRefsAndOptions: Array<PartRef | CombinePartsOptions>): wave3DObject;

  combinePart(...args: Array<PartRef | readonly PartRef[] | CombinePartsOptions | null | undefined>): wave3DObject;

  configSurfaces(preset: SurfacePreset): this;

  configSurfaces(options: { preset: SurfacePreset; category?: SurfaceCategory; overrides?: Partial<Record<SurfaceCategory, Partial<ObjectSurfaceConfig>>>; }): this;

  get constantForces(): WavePhysicsConstantForceEntryFor<WavePhysicsBackendForOwner<this>>[];

  get constantTorques(): WavePhysicsConstantTorqueEntryFor<WavePhysicsBackendForOwner<this>>[];

  get contactCount(): number;

  get contactEndGraceSubsteps(): number;

  get contactingBodies(): wave3DObject[];

  get contactStatus(): WavePhysicsContactStatus;

  createAllParts(options?: CreatePartsOptions): wave3DObject[];

  createInstanceSource(options?: CreateInstanceSourceOptions): WaveInstanceSource;

  createMeshMorphVertexAnimation(name: string, options: CreateMeshMorphVertexAnimationOptions): string;

  createPart(partRef: PartCreationRef, options?: CreatePartsOptions): wave3DObject;

  createPartFromMesh(meshRef: MeshRef, options?: CreatePartsOptions): wave3DObject;

  createParts(selection?: PartCreationSelection, options?: CreatePartsOptions): wave3DObject[];

  createVertexAnimation(name: string, options: CreateVertexAnimationOptions): string;

  csgBatching(): ReturnType<cmp_visual3DModel["csgBatching"]>;

  cut(...args: Parameters<cmp_visual3DModel["cut"]>): ReturnType<cmp_visual3DModel["cut"]>;

  cutting(...args: Parameters<cmp_visual3DModel["cutting"]>): ReturnType<cmp_visual3DModel["cutting"]>;

  deleteVertexSelection(...args: Parameters<cmp_visual3DModel["deleteVertexSelection"]>): ReturnType<cmp_visual3DModel["deleteVertexSelection"]>;

  get density(): number | null;

  destroy(): void;

  destroyAllParts(): PartDeleteResult[];

  destroyPart(partRef: PartRef): void;

  destroyParts(selection: PartDestructiveSelection): PartDeleteResult[];

  disableContactMonitor(): this;

  disableGlow(): this;

  disablePhysics(options?: DisablePhysicsOptions): this;

  discolorSurface(options?: Parameters<cmp_visual3DModel["discolorSurface"]>[0]): this;

  displacing(): ReturnType<cmp_visual3DModel["displacing"]>;

  get displayName(): string;

  editConstantForce(name: string): WavePhysicsConstantForceBuilderFor<WavePhysicsBackendForOwner<this>>;

  editConstantTorque(name: string): WavePhysicsConstantTorqueBuilderFor<WavePhysicsBackendForOwner<this>>;

  emissiveDistortion(): ReturnType<cmp_visual3DModel["emissiveDistortion"]>;

  enableCollisionByTag(tag: string, ...tags: string[]): this;

  enableCollisionByTag(tags: readonly string[]): this;

  enableCollisionWith(...targets: (wave3DObject | readonly wave3DObject[])[]): this;

  enableContactMonitor(options?: ContactMonitorOptions): this;

  enableGlow(intensity?: number, color?: Parameters<cmp_visual3DModel["enableGlow"]>[1]): this;

  enableGravity(factor?: number): this;

  enablePhysics(options?: EnablePhysicsOptions): this;

  endEffector(endEffector: string, options?: WaveModelIKRuntimeSolveOptions): WaveEndEffectorScope;

  get equipment(): WaveEquipmentFacade<this>;

  eraseSurface(options?: Parameters<cmp_visual3DModel["eraseSurface"]>[0]): this;

  eraseVertexColors(...args: Parameters<cmp_visual3DModel["eraseVertexColors"]>): ReturnType<cmp_visual3DModel["eraseVertexColors"]>;

  explode(options?: ExplodeOptions): WaveGroup<wave3DObject> | null;

  explodeAsync(options?: ExplodeOptions): Promise<WaveGroup<wave3DObject> | null>;

  exploding(): ExplodeBuilder;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: PartExtractionMode.Promote; }): this;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: PartExtractionMode.Clone; }): wave3DObject;

  extractPart(partRef: PartRef, options: ExtractPartsOptions & { readonly mode: PartExtractionMode.Promote | PartExtractionMode.Clone; }): this | wave3DObject;

  extractParts(selection: PartSelection, options: ExtractPartsOptions & { readonly mode: PartExtractionMode.Promote; }): this[];

  extractParts(selection: PartSelection, options: ExtractPartsOptions & { readonly mode: PartExtractionMode.Clone | PartExtractionMode.Adopt; }): wave3DObject[];

  extractParts(selection: PartSelection, options: ExtractPartsOptions): Array<this | wave3DObject>;

  extrude(...args: Parameters<cmp_visual3DModel["extrude"]>): ReturnType<cmp_visual3DModel["extrude"]>;

  extruding(): ReturnType<cmp_visual3DModel["extruding"]>;

  face(surface: WaveSurface): ReturnType<cmp_visual3DModel["surface"]>;

  faceMaterial(surface: WaveSurface): MaterialEditorView;

  field<T extends ProfileFieldValue = number>(name: string, dataType?: ProfileFieldType, initialValue?: T): ProfileField<T>;

  get fieldNames(): string[];

  findNearestVertex(at: Vector3Like, options?: VertexQueryOptions, force?: boolean): VertexQueryResult;

  forceMergeMesh(force?: boolean): this;

  forEachContactingBody(callback: (body: wave3DObject, rigidBody: cmp_physicsBody) => void): this;

  frag(...args: Parameters<cmp_visual3DModel["frag"]>): ReturnType<cmp_visual3DModel["frag"]>;

  fragmenting(): ReturnType<cmp_visual3DModel["fragmenting"]>;

  freeze(): this;

  get friction(): number | null;

  getAccumulatedDeformation(...args: Parameters<cmp_visual3DModel["getAccumulatedDeformation"]>): ReturnType<cmp_visual3DModel["getAccumulatedDeformation"]>;

  getBoundingBox(...args: Parameters<cmp_visual3DModel["getBoundingBox"]>): ReturnType<cmp_visual3DModel["getBoundingBox"]>;

  getBoundingBoxVolume(...args: Parameters<cmp_visual3DModel["getBoundingBoxVolume"]>): ReturnType<cmp_visual3DModel["getBoundingBoxVolume"]>;

  getColliderBounds(...args: Parameters<cmp_visual3DModel["getColliderBounds"]>): ReturnType<cmp_visual3DModel["getColliderBounds"]>;

  getEditableMesh(...args: Parameters<cmp_visual3DModel["getEditableMesh"]>): ReturnType<cmp_visual3DModel["getEditableMesh"]>;

  getFieldValue(name: string): ProfileFieldValue | undefined;

  getHalfExtents(...args: Parameters<cmp_visual3DModel["getHalfExtents"]>): ReturnType<cmp_visual3DModel["getHalfExtents"]>;

  getMesh(...args: Parameters<cmp_visual3DModel["getMesh"]>): ReturnType<cmp_visual3DModel["getMesh"]>;

  getMeshCount(...args: Parameters<cmp_visual3DModel["getMeshCount"]>): ReturnType<cmp_visual3DModel["getMeshCount"]>;

  getMeshEntry(...args: Parameters<cmp_visual3DModel["getMeshEntry"]>): ReturnType<cmp_visual3DModel["getMeshEntry"]>;

  getMeshes(...args: Parameters<cmp_visual3DModel["getMeshes"]>): ReturnType<cmp_visual3DModel["getMeshes"]>;

  getModelBounds(...args: Parameters<cmp_visual3DModel["getModelBounds"]>): ReturnType<cmp_visual3DModel["getModelBounds"]>;

  getOrientedBounds(...args: Parameters<cmp_visual3DModel["getOrientedBounds"]>): ReturnType<cmp_visual3DModel["getOrientedBounds"]>;

  getParent(): wave3DAbstract | null;

  getPart(partRef: PartRef, scope?: PartScope): wave3DObject | undefined;

  getPartCount(scope?: PartScope): number;

  getPartInfo(partRef: PartRef, scope?: PartScope): VisualPartInfo | undefined;

  getPartMetadata(partRef: PartRef, scope?: PartScope): WaveModelPartMetadata | undefined;

  getParts(scope?: PartScope): readonly wave3DObject[];

  getPickProxyEntities(): wave3DObject[];

  getSize(...args: Parameters<cmp_visual3DModel["getSize"]>): ReturnType<cmp_visual3DModel["getSize"]>;

  getSkinAuthoringMesh(...args: Parameters<cmp_visual3DModel["getSkinAuthoringMesh"]>): ReturnType<cmp_visual3DModel["getSkinAuthoringMesh"]>;

  getVelocityAtWorldPoint(point: WavePointInput): Vector3Like | null;

  getVertexCache(...args: Parameters<cmp_visual3DModel["getVertexCache"]>): ReturnType<cmp_visual3DModel["getVertexCache"]>;

  getVertexCount(...args: Parameters<cmp_visual3DModel["getVertexCount"]>): ReturnType<cmp_visual3DModel["getVertexCount"]>;

  getVertexTopologyVersion(force?: boolean): number | null;

  getVisualBounds(...args: Parameters<cmp_visual3DModel["getVisualBounds"]>): ReturnType<cmp_visual3DModel["getVisualBounds"]>;

  get gravityFactor(): number | null;

  hasAllTags(...tags: string[]): boolean;

  get hasAnimator(): boolean;

  hasAnyTag(...tags: string[]): boolean;

  hasConstantForce(name: string): boolean;

  hasConstantTorque(name: string): boolean;

  hasField(name: string): boolean;

  hasLineOfSightTo(target: WaveSensingSpatialEntity | WavePointInput, options?: LineOfSightOptions): boolean;

  hasPart(partRef: PartRef, scope?: PartScope): boolean;

  get hasPhysicsBody(): boolean;

  hasTag(tag: string): boolean;

  hasVertexCache(...args: Parameters<cmp_visual3DModel["hasVertexCache"]>): ReturnType<cmp_visual3DModel["hasVertexCache"]>;

  hide(options?: Wave3DObjectHideOptions): this;

  ignoreGravity(): this;

  initVertexColors(...args: Parameters<cmp_visual3DModel["initVertexColors"]>): ReturnType<cmp_visual3DModel["initVertexColors"]>;

  intersect(...args: Parameters<cmp_visual3DModel["intersect"]>): ReturnType<cmp_visual3DModel["intersect"]>;

  intersecting(...args: Parameters<cmp_visual3DModel["intersecting"]>): ReturnType<cmp_visual3DModel["intersecting"]>;

  intersectMany(...args: Parameters<cmp_visual3DModel["intersectMany"]>): ReturnType<cmp_visual3DModel["intersectMany"]>;

  isContactMonitorEnabled(): boolean;

  get isDynamic(): boolean;

  get isFrozen(): boolean;

  isInContactWith(target: wave3DObject): boolean;

  get isKinematic(): boolean;

  get isKinematicController(): boolean;

  get isKinematicRigidBody(): boolean;

  isMultiMesh(): ReturnType<cmp_visual3DModel["isMultiMesh"]>;

  get isPart(): boolean;

  get isPickable(): boolean;

  get isPrefab(): boolean;

  isSingleMesh(): ReturnType<cmp_visual3DModel["isSingleMesh"]>;

  get isStatic(): boolean;

  get kinematicTuning(): WavePhysicsKinematicTuning | null;

  get linearDamping(): number | null;

  get linearVelocity(): Vector3Like | SerializableVector3 | null;

  listDecals(): waveDecal[];

  listMeshEntries(...args: Parameters<cmp_visual3DModel["listMeshEntries"]>): ReturnType<cmp_visual3DModel["listMeshEntries"]>;

  listMeshes(...args: Parameters<cmp_visual3DModel["listMeshes"]>): ReturnType<cmp_visual3DModel["listMeshes"]>;

  listMeshNames(...args: Parameters<cmp_visual3DModel["listMeshNames"]>): ReturnType<cmp_visual3DModel["listMeshNames"]>;

  listPartInfos(scope?: PartScope): readonly VisualPartInfo[];

  listPartNames(scope?: PartScope): string[];

  lockRotation(): this;

  get mass(): number | null;

  materialFor(target: Parameters<cmp_visual3DModel["materialFor"]>[0], slot?: number): MaterialEditorView;

  materialSlotFor(target: Parameters<cmp_visual3DModel["materialSlotFor"]>[0], slot: number): MaterialEditorView;

  get materialUVOffset(): Vector2;

  get materialUVScale(): Vector2;

  get maxContactsReported(): number;

  mergeMeshes(...args: Parameters<cmp_visual3DModel["mergeMeshes"]>): ReturnType<cmp_visual3DModel["mergeMeshes"]>;

  meshMaterial(name: string): MaterialEditorView;

  meshMaterialSlot(name: string, slot: number): MaterialEditorView;

  get model(): cmp_visual3DModel<this>;

  get modelName(): cmp_visual3DModel["modelName"];

  modifyWith(recipe: Parameters<cmp_visual3DModel["modifyWith"]>[0], options?: Parameters<cmp_visual3DModel["modifyWith"]>[1]): this;

  morphingTo(...args: Parameters<cmp_visual3DModel["morphingTo"]>): ReturnType<cmp_visual3DModel["morphingTo"]>;

  moveVertices(selection: VertexSelection, movement: MeshDirectionInput, distance: number, options?: VertexMoveOptions, force?: boolean): VertexSelectionResult;

  moveVertices(selection: VertexSelection, movement: Vector3Like, options?: VertexMoveOptions, force?: boolean): VertexSelectionResult;

  moveWithCollisions(displacement: Vector3Like | DirectionInput): this;

  moveWithCollisions(x: number, y: number, z: number): this;

  moveWithCollisions(direction: Vector3Like | DirectionInput, distance: number): this;

  noise(...args: Parameters<cmp_visual3DModel["noise"]>): ReturnType<cmp_visual3DModel["noise"]>;

  onContact(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactBegin(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactBeginByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactBeginWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactContinue(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactContinueByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactContinueWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactEnd(callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactEndByTag(tagOrTags: string | readonly string[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactEndWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onContactWith(target: wave3DObject | readonly wave3DObject[], callback: (event: ContactEvent) => void, options?: WaveAuthoredCallbackOptions): this;

  onDrag(callback: InteractionDragCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  onDragMove(options?: InteractionDragMoveOptions): InteractionDragMoveHandle<this>;

  onDragMove(callback: InteractionDragMoveCallback<this>, options?: InteractionDragMoveOptions): InteractionDragMoveHandle<this>;

  painting(): ReturnType<cmp_visual3DModel["painting"]>;

  paintingPolygon(): ReturnType<cmp_visual3DModel["paintingPolygon"]>;

  paintingTexture(): ReturnType<cmp_visual3DModel["paintingTexture"]>;

  paintVertexColors(...args: Parameters<cmp_visual3DModel["paintVertexColors"]>): ReturnType<cmp_visual3DModel["paintVertexColors"]>;

  paintVertexColorsPolygon(...args: Parameters<cmp_visual3DModel["paintVertexColorsPolygon"]>): ReturnType<cmp_visual3DModel["paintVertexColorsPolygon"]>;

  partMaterial(partRef: Parameters<cmp_visual3DModel["partMaterial"]>[0], slot?: number): MaterialEditorView;

  partMaterialSlot(partRef: Parameters<cmp_visual3DModel["partMaterialSlot"]>[0], slot: number): MaterialEditorView;

  get partOwnerVisual(): cmp_visual3DModel | null;

  pauseAnimation(): this;

  pauseSound(): this;

  get physicsBackendKind(): WavePhysicsBackendKind;

  get physicsBody(): cmp_physicsBody<this>;

  get physicsBodyProperties(): WavePhysicsBodyProperties;

  get physicsMaterial(): WavePhysicsMaterialProperties;

  get physicsMotionKind(): WavePhysicsMotionKind;

  get physicsType(): WavePhysicsRigidBodyTypeFor<WavePhysicsBackendForOwner<this>>;

  pickPartAtWorldPoint(point: WavePointInput, options?: PickPartOptions): wave3DObject | undefined;

  playAnimation(clip: ModelAnimationClipInput, loop?: boolean, speed?: number): WaveAnimationPlaybackHandle;

  playAnimation(clip: ModelAnimationClipInput, options?: Wave3DObjectAnimationOptions): WaveAnimationPlaybackHandle;

  playSound(clipName: string, loopOrOptions?: boolean | WaveAudioPlaybackOptions): WaveAudioPlaybackHandle;

  playVertexAnimation(assetName: string, options?: VertexAnimationPlaybackOptions): this;

  playVertexAnimation(options?: VertexAnimationPlaybackOptions): this;

  prepareOperablePBR(): ReturnType<cmp_visual3DModel["prepareOperablePBR"]>;

  prewarmSurfaceVfx(options?: Parameters<cmp_visual3DModel["prewarmSurfaceVfx"]>[0]): ReturnType<cmp_visual3DModel["prewarmSurfaceVfx"]>;

  get primaryMesh(): cmp_visual3DModel["primaryMesh"];

  privatizeMaterial(): this;

  promotePart(partRef: PartRef): this;

  promoteParts(selection: PartSelection): this[];

  qualifyMeshesAsParts(...args: Parameters<cmp_visual3DModel["qualifyMeshesAsParts"]>): ReturnType<cmp_visual3DModel["qualifyMeshesAsParts"]>;

  regionalScaling(): ReturnType<cmp_visual3DModel["regionalScaling"]>;

  removeAntiTiling(): this;

  removeDecal(decal: waveDecal): void;

  removeEmissiveDistortion(): this;

  removeMaterial(options?: { fromAll?: boolean; restoreInnate?: boolean; }): this;

  removeModel(): this;

  removeTag(tag: string): this;

  removeTags(...tags: string[]): this;

  removeWorldEmissive(): this;

  renameMesh(...args: Parameters<cmp_visual3DModel["renameMesh"]>): ReturnType<cmp_visual3DModel["renameMesh"]>;

  renameMeshes(...args: Parameters<cmp_visual3DModel["renameMeshes"]>): ReturnType<cmp_visual3DModel["renameMeshes"]>;

  renamePart(partRef: PartRef, newName: string): string;

  renameParts(renames?: Readonly<Record<string, string>>): Record<string, string>;

  reparentPart(childPartRef: PartRef, parentPartRef: PartRef | null): PartMutationResult;

  requireEditableMesh(...args: Parameters<cmp_visual3DModel["requireEditableMesh"]>): ReturnType<cmp_visual3DModel["requireEditableMesh"]>;

  requireSkinAuthoringMesh(...args: Parameters<cmp_visual3DModel["requireSkinAuthoringMesh"]>): ReturnType<cmp_visual3DModel["requireSkinAuthoringMesh"]>;

  resetDeformation(...args: Parameters<cmp_visual3DModel["resetDeformation"]>): ReturnType<cmp_visual3DModel["resetDeformation"]>;

  resetOrigin(forceAnchorMove?: boolean): this;

  resolveMaterialSplatPaintChannel(...args: Parameters<cmp_visual3DModel["resolveMaterialSplatPaintChannel"]>): ReturnType<cmp_visual3DModel["resolveMaterialSplatPaintChannel"]>;

  get restitution(): number | null;

  restoreVertices(...args: Parameters<cmp_visual3DModel["restoreVertices"]>): ReturnType<cmp_visual3DModel["restoreVertices"]>;

  resumeAnimation(): this;

  resumeSound(): this;

  get rig(): cmp_rig;

  scaleRegion(...args: Parameters<cmp_visual3DModel["scaleRegion"]>): ReturnType<cmp_visual3DModel["scaleRegion"]>;

  segment(...args: Parameters<cmp_visual3DModel["segment"]>): ReturnType<cmp_visual3DModel["segment"]>;

  segmenting(): ReturnType<cmp_visual3DModel["segmenting"]>;

  selectFaceVertices(faceIndex: number, force?: boolean): VertexSelectionResult;

  selectVertex(vertexIndex: number, force?: boolean): VertexSelectionResult;

  selectVertexNeighbors(selection: VertexSelection, rings?: number, force?: boolean): VertexSelectionResult;

  selectVerticesInRadius(center: Vector3Like, radius: number, options?: VertexQueryOptions, force?: boolean): VertexSelectionResult;

  setAlphaMode(mode: Parameters<cmp_visual3DModel["setAlphaMode"]>[0]): this;

  setAngularDamping(value: number): this;

  setAngularInertia(value: Vector3Like): this;

  setAngularInertia(value: number): this;

  setAngularInertia(x: number, y: number, z: number): this;

  setAngularVelocity(velocity: Vector3Like | DirectionInput): this;

  setAngularVelocity(x: number, y: number, z: number): this;

  setAngularVelocity(axis: Vector3Like | DirectionInput, speed: number): this;

  setAnisotropy(config: Parameters<cmp_visual3DModel["setAnisotropy"]>[0]): this;

  setAntiTiling(options?: WaveMaterialAntiTilingOptions): this;

  setAOTexture(texturePath: string): this;

  setArchetype(type: string): this;

  setAttachedTo(entity: WaveEntity | null): this;

  setBaseTexture(texturePath: string): this;

  setClearCoat(config: Parameters<cmp_visual3DModel["setClearCoat"]>[0]): this;

  setCollisionGroup(value: number): this;

  setCollisionMask(value: number): this;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0]): this;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0], mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0], mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setConstantForce(name: string, config: WavePhysicsConstantForceConfigFor<WavePhysicsBackendForOwner<this>>): this;

  setConstantForce(name: string, force: Vector3Like | DirectionInput, options?: WavePhysicsConstantForceOptionsFor<WavePhysicsBackendForOwner<this>>): this;

  setConstantForce(name: string, direction: Vector3Like | DirectionInput, strength: number, options?: WavePhysicsConstantForceOptionsFor<WavePhysicsBackendForOwner<this>>): this;

  setConstantTorque(name: string, config: WavePhysicsConstantTorqueConfigFor<WavePhysicsBackendForOwner<this>>): this;

  setConstantTorque(name: string, torque: Vector3Like | DirectionInput, options?: WavePhysicsConstantTorqueOptionsFor<WavePhysicsBackendForOwner<this>>): this;

  setConstantTorque(name: string, axis: Vector3Like | DirectionInput, strength: number, options?: WavePhysicsConstantTorqueOptionsFor<WavePhysicsBackendForOwner<this>>): this;

  setContactEndGraceSubsteps(substeps: number): this;

  setDepthBias(value: number): this;

  setDisplayName(name: string): this;

  setDoubleSided(enabled?: boolean): this;

  setEmissiveColor(color: Parameters<cmp_visual3DModel["setEmissiveColor"]>[0]): this;

  setEmissiveColor(color: Parameters<cmp_visual3DModel["setEmissiveColor"]>[0], mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveColor(color: Parameters<cmp_visual3DModel["setEmissiveColor"]>[0], mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveEffect<THandle extends WaveTextureEffectHandle = WaveTextureEffectHandle>(effect: WaveEffectInput): THandle;

  setEmissiveIntensity(intensity: number): this;

  setEmissiveIntensity(intensity: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setEmissiveIntensity(intensity: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setEmissiveTexture(texturePath: string): this;

  setEnvironmentIntensity(value: Parameters<cmp_visual3DModel["setEnvironmentIntensity"]>[0]): this;

  setField(name: string, value: ProfileFieldValue, dataType?: ProfileFieldType): this;

  setFriction(value: number): this;

  setGravityFactor(factor: number): this;

  setHeightTexture(texturePath: string): this;

  setIndexOfRefraction(ior: number): this;

  setIridescence(config: Parameters<cmp_visual3DModel["setIridescence"]>[0]): this;

  setIsPrefab(value: boolean): this;

  setKinematicTuning(tuning: WavePhysicsKinematicTuningInput): this;

  setLinearDamping(value: number): this;

  setLinearVelocity(velocity: Vector3Like | DirectionInput): this;

  setLinearVelocity(x: number, y: number, z: number): this;

  setLinearVelocity(direction: Vector3Like | DirectionInput, speed: number): this;

  setMass(value: number): this;

  setMaxContactsReported(maxContacts: number): this;

  setMaximumThickness(value: number): this;

  setMaxSimultaneousLights(value: number): this;

  setMeshes(...args: Parameters<cmp_visual3DModel["setMeshes"]>): ReturnType<cmp_visual3DModel["setMeshes"]>;

  setMeshMaterialColor(...args: Parameters<cmp_visual3DModel["setMeshMaterialColor"]>): ReturnType<cmp_visual3DModel["setMeshMaterialColor"]>;

  setMetalness(value: number): this;

  setMetalness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setMetalness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setMetalnessTexture(texturePath: string): this;

  setMinimumThickness(value: number): this;

  setNormalTexture(texturePath: string): this;

  setOpacity(value: number): this;

  setOpacity(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setOpacity(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setParent(parent: wave3DAbstract | null): this;

  setPart(partRef: PartRef, patch: PartPatchValue): PartMutationResult;

  setPartMassProperties(partRef: PartRef, input: PartMassPropertiesInput): PartMutationResult;

  setPartMetadata(partRef: PartRef, metadata: WaveModelPartMetadata | null | undefined): PartMutationResult;

  setParts(input: PartPatchInput): PartMutationResult[];

  setPhysicsBodyProperties(properties: WavePhysicsBodyPropertyInput): this;

  setPhysicsMaterial(properties: WavePhysicsMaterialInput): this;

  setPickable(pickingTag?: SystemTag): this;

  setRefractionIntensity(value: number): this;

  setRestitution(value: number): this;

  setRoughness(value: number): this;

  setRoughness(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setRoughness(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setRoughnessTexture(texturePath: string): this;

  setSheen(config: Parameters<cmp_visual3DModel["setSheen"]>[0]): this;

  setSpecularIntensity(value: number): this;

  setSubSurfaceTintColor(color: Parameters<cmp_visual3DModel["setSubSurfaceTintColor"]>[0]): this;

  setSurfacePreset(preset: SurfacePreset, category?: SurfaceCategory): this;

  setTags(tags: string[]): this;

  setTeamId(id: number): this;

  setThicknessTexture(texturePath: string): this;

  setTranslucencyColorTexture(texturePath: string): this;

  setTranslucencyIntensity(value: number): this;

  setTranslucencyIntensityTexture(texturePath: string): this;

  setTransmissionTexture(texturePath: string): this;

  setUpVector(up: Vector3Like | DirectionInput): this;

  setUseRadianceOverAlpha(enabled: Parameters<cmp_visual3DModel["setUseRadianceOverAlpha"]>[0]): this;

  setUseSpecularOverAlpha(enabled: Parameters<cmp_visual3DModel["setUseSpecularOverAlpha"]>[0]): this;

  setUVOffset(offset: Vector2): this;

  setUVOffset(offset: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(offset: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, vOffset?: number): this;

  setUVOffset(uOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVOffset(uOffset: number, vOffset: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVRotation(degrees: number): this;

  setUVRotation(degrees: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVRotation(degrees: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(scale: Vector2): this;

  setUVScale(scale: Vector2, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(scale: Vector2, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, vScale?: number): this;

  setUVScale(uScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setUVScale(uScale: number, vScale: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setUVScale(uScale: number, vScale: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setVertexAnimationTime(seconds: number): this;

  setWorldEmissive(config: Parameters<cmp_visual3DModel["setWorldEmissive"]>[0]): this;

  show(): this;

  showBreadcrumbTrail(options?: BreadcrumbTrailOptions): ReturnType<cmp_visual3DModel["enableBreadcrumbTrail"]>;

  showMeshBoundingBox(...args: Parameters<cmp_visual3DModel["showMeshBoundingBox"]>): this;

  showWireframe(enabled?: boolean): this;

  skew(...args: Parameters<cmp_visual3DModel["skew"]>): ReturnType<cmp_visual3DModel["skew"]>;

  skewing(): ReturnType<cmp_visual3DModel["skewing"]>;

  get spatialVolume(): number | null;

  stopAnimation(clipName?: string): this;

  stopSound(): this;

  stretching(): ReturnType<cmp_visual3DModel["stretching"]>;

  subdivideVertexSelection(selection: VertexSelection, options?: VertexSubdivideOptions, force?: boolean): VertexTopologyResult;

  subtract(...args: Parameters<cmp_visual3DModel["subtract"]>): ReturnType<cmp_visual3DModel["subtract"]>;

  subtracting(...args: Parameters<cmp_visual3DModel["subtracting"]>): ReturnType<cmp_visual3DModel["subtracting"]>;

  subtractMany(...args: Parameters<cmp_visual3DModel["subtractMany"]>): ReturnType<cmp_visual3DModel["subtractMany"]>;

  swaying(): ReturnType<cmp_visual3DModel["swaying"]>;

  get tags(): string[];

  taper(...args: Parameters<cmp_visual3DModel["taper"]>): ReturnType<cmp_visual3DModel["taper"]>;

  tapering(): ReturnType<cmp_visual3DModel["tapering"]>;

  get teamId(): number;

  get tool(): cmp_tool;

  transformVertices(selection: VertexSelection, options: VertexTransformOptions, force?: boolean): VertexSelectionResult;

  transitionByPose(startPose: ModelPoseInput, endPose: ModelPoseInput): WaveModelPoseTransitionBuilder;

  transitionByPose(startPose: ModelPoseInput, endPose: ModelPoseInput, durationSeconds: number, options?: WaveModelPoseTransitionOptions): WaveAnimationController | null;

  transitionToPose(endPose: ModelPoseInput): WaveModelPoseTransitionBuilder;

  transitionToPose(endPose: ModelPoseInput, durationSeconds: number, options?: WaveModelPoseTransitionOptions): WaveAnimationController | null;

  twist(...args: Parameters<cmp_visual3DModel["twist"]>): ReturnType<cmp_visual3DModel["twist"]>;

  twisting(): ReturnType<cmp_visual3DModel["twisting"]>;

  unbindMeshesFromPart(...args: Parameters<cmp_visual3DModel["unbindMeshesFromPart"]>): ReturnType<cmp_visual3DModel["unbindMeshesFromPart"]>;

  unfreeze(): this;

  union(...args: Parameters<cmp_visual3DModel["union"]>): ReturnType<cmp_visual3DModel["union"]>;

  unioning(...args: Parameters<cmp_visual3DModel["unioning"]>): ReturnType<cmp_visual3DModel["unioning"]>;

  unionMany(...args: Parameters<cmp_visual3DModel["unionMany"]>): ReturnType<cmp_visual3DModel["unionMany"]>;

  unmanageAllParts(): unknown[];

  unmanagePart(partRef: PartRef): unknown;

  unmanageParts(selection: PartDestructiveSelection): unknown[];

  get upVector(): Vector3Like | SerializableVector3 | null;

  useDynamicBody(options?: EnablePhysicsOptions): this;

  useFixedGeneratedModel(model: string | Visual3DModelGeneratedAttachmentInput): this;

  useFixedModel(model: Visual3DModelAuthoringInput, options?: Omit<Visual3DModelUseOptions, "topology">): this;

  useKinematicBody(options?: EnablePhysicsOptions): this;

  useMaterial(material: string | WaveMaterialInput, toAll?: boolean): this;

  useModel(model: Visual3DModelAuthoringInput, options?: Visual3DModelUseOptions): this;

  usePrivateMaterial(material: string | WaveMaterialInput, toAll?: boolean): this;

  useProceduralEmissiveTexture(handle: ProceduralTextureHandle): this;

  usePublicMaterial(material: string | WaveMaterialInput, toAll?: boolean): this;

  useStaticBody(options?: EnablePhysicsOptions): this;

  useVertexAnimation(assetName: string, rangeName?: string): this;

  useVideo(videoAssetName: string, intent?: Parameters<cmp_visual3DModel["useVideo"]>[1], serial?: Parameters<cmp_visual3DModel["useVideo"]>[2]): ReturnType<cmp_visual3DModel["useVideo"]>;

  vertexEditing(): VertexEditingBuilder;

  videoMaterial(videoAssetName?: string): ReturnType<cmp_visual3DModel["videoMaterial"]>;

  viewBack(distanceOrMeshName?: number | string, distance?: number): this;

  viewBottom(distanceOrMeshName?: number | string, distance?: number): this;

  viewFront(distanceOrMeshName?: number | string, distance?: number): this;

  viewLeft(distanceOrMeshName?: number | string, distance?: number): this;

  viewRight(distanceOrMeshName?: number | string, distance?: number): this;

  viewTop(distanceOrMeshName?: number | string, distance?: number): this;

  whenBackClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenBackHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenBackHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenBackPressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenBackReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenClickedOnMesh(callback: InteractionMeshCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenClickedOnPart(callback: InteractionPartCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenForwardClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenForwardHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenForwardHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenForwardPressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenForwardReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenHolding(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, this>, holdThreshold?: WaveTimeSpan, options?: Omit<CallbackOptions, "filter" | "holdThreshold">): CallbackHandle;

  whenHolding(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, this>, value: number, unit: WaveTimeUnit, options?: Omit<CallbackOptions, "filter" | "holdThreshold">): CallbackHandle;

  whenHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenHoverEnteredOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenHoverExitedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenHoveringOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenLeftClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenLeftHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenLeftHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenLeftPressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenLeftReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenMiddleClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenMiddleHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenMiddleHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenMiddlePressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenMiddleReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenPress(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, this>, options?: Omit<CallbackOptions, "filter">): CallbackHandle;

  whenPressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenRelease(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, this>, options?: Omit<CallbackOptions, "filter">): CallbackHandle;

  whenReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenRightClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenRightHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenRightHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenRightPressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenRightReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenTouchedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

}

interface Wave3DTextModelRecipe {

  readonly characterSpacing?: number;

  readonly font?: Wave3DTextFontInput;

  readonly options?: Wave3DTextOptionsRecipe;

  readonly path?: Wave3DTextPathRecipe;

  readonly text: string;

  readonly version: typeof WAVE_TEXT_MODEL_RECIPE_VERSION;

}

type Wave3DTextOptionsRecipe = Omit<Wave3DTextOptions, "name">;

interface Wave3DTextPathRecipe {

  readonly closed?: boolean;

  readonly localSampledPoints: readonly Vector3Like[];

}

declare const WaveAction: { readonly ActorMove: string; readonly ActorMoveForward: string; readonly ActorMoveBack: string; readonly ActorMoveLeft: string; readonly ActorMoveRight: string; readonly ActorJump: string; readonly ActorCrouch: string; readonly ActorSprint: string; readonly ActorWalk: string; readonly ActorDodge: string; readonly ActorLook: string; readonly ActorLookLeft: string; readonly ActorLookRight: string; readonly ActorLookUp: string; readonly ActorLookDown: string; readonly ActorZoom: string; readonly ActorAim: string; readonly ActorAttack: string; readonly ActorAttackSecondary: string; readonly ActorBlock: string; readonly ActorReload: string; readonly ActorSwitchWeapon: string; readonly ActorAbility: string; readonly ActorInteract: string; readonly ActorInteractAlt: string; readonly ActorDrop: string; readonly ActorInventory: string; readonly ActorHandPinch: string; readonly ActorHandGrab: string; readonly ActorHandPoint: string; readonly ActorHandOpenPalm: string; readonly ActorHandThumbsUp: string; readonly ActorHandVictory: string; readonly UIConfirm: string; readonly UICancel: string; readonly UIPause: string; readonly UINavigate: string; readonly UIScroll: string; readonly UITabLeft: string; readonly UITabRight: string; readonly VehicleThrottle: string; readonly VehicleBrake: string; readonly VehicleSteer: string; readonly VehicleHandbrake: string; readonly VehicleHorn: string; readonly VehicleToggle: string; readonly FlightPitch: string; readonly FlightRoll: string; readonly FlightYaw: string; readonly FlightThrottle: string; readonly FlightGear: string; readonly FlightFlaps: string; readonly SecondaryMove: string; readonly SecondaryLook: string; readonly SecondaryJump: string; readonly TertiaryMove: string; readonly TertiaryLook: string; };

type WaveActivePhysicsHumanoidModelBuilder = BuilderWithMethods<typeof HUMANOID_PARTS, WaveActivePhysicsHumanoidModelMethods>;

interface WaveActivePhysicsHumanoidModelMethods {

  readonly entities: typeof HUMANOID_PARTS;

  readonly joints: typeof ACTIVE_HUMANOID_JOINTS;

  withArmSwing(degrees: number): WaveActivePhysicsHumanoidModelBuilder;

  withBodyColor(color: ColorInput): WaveActivePhysicsHumanoidModelBuilder;

  withDriveStrength(strength: number): WaveActivePhysicsHumanoidModelBuilder;

  withEquipmentMount(name: string, configure: ActivePhysicsHumanoidEquipmentMountConfigurator): WaveActivePhysicsHumanoidModelBuilder;

  withFootLift(distance: number): WaveActivePhysicsHumanoidModelBuilder;

  withPoseJitter(maximumDegrees: number, seed?: number): WaveActivePhysicsHumanoidModelBuilder;

  withRecipe(config: ActivePhysicsHumanoidConfig): WaveActivePhysicsHumanoidModelBuilder;

  withSelfCollision(mode: NonNullable<ActivePhysicsHumanoidConfig["selfCollision"]>): WaveActivePhysicsHumanoidModelBuilder;

  withStepDuration(value: number, unit: WaveTimeUnitReference): WaveActivePhysicsHumanoidModelBuilder;

  withStepReach(degrees: number): WaveActivePhysicsHumanoidModelBuilder;

  withStrideLength(distance: number): WaveActivePhysicsHumanoidModelBuilder;

}

type WaveActivePhysicsRigSelfCollisionMode = "none" | "nonAdjacent" | "all";

declare class waveActor<TState = unknown> extends waveProp<TState> {

  constructor(modelAsset?: Visual3DModelInput);

  static readonly typeName: EntityType;

  can(capabilityId: string): WaveActorCapabilityBuilder<this>;

  can<TParameters extends WaveChoiceParameters>(choice: WaveChoiceInput<TParameters>): WaveActorCapabilityBuilder<this, TParameters>;

  can(capabilityId: string, runner: WaveActorCapabilityRunner<this>): this;

  can<TParameters extends WaveChoiceParameters>(choice: WaveChoiceInput<TParameters>, runner: WaveActorCapabilityRunner<this, TParameters>): this;

  can(capabilityId: string, options: WaveActorCapabilityShortcutOptions<this>): this;

  can<TParameters extends WaveChoiceParameters>(choice: WaveChoiceInput<TParameters>, options: WaveActorCapabilityShortcutOptions<this, TParameters>): this;

  decisionState(decision?: WaveActorDecision<this> | string): ActorDecisionState | null;

  learnFromOutcomes(options?: WaveActorLearningOptions): WaveActorLearningBuilder<this>;

  llmDecisionState(decision: WaveActorDecision<this> | string): ThinkingLLMDecisionState | null;

  llmReplyState(decision: WaveActorDecision<this> | string): ThinkingLLMReplyState | null;

  makeDecisionFromChat(userMessage: string, options?: WaveActorDecisionOptions): WaveActorDecisionBuilder<this>;

  makeDecisionFromPrompt(prompt: string, options?: WaveActorDecisionOptions): WaveActorDecisionBuilder<this>;

  predictionState(): ThinkingPredictionState | null;

  rememberOutcomes(options?: WaveOutcomeMemoryOptions): this;

  replyAsCharacterTo(userMessage: string, options?: WaveActorDecisionOptions & { speech?: WaveSpeakTextOptions; reply?: WaveActorDecisionReplyOptions; }): WaveActorDecision<this>;

  reportOutcomeOf(capabilityId: string, summary: string, options?: WaveActorReportOutcomeOptions): this;

  respondAsCharacterTo(userMessage: string, options?: WaveActorDecisionOptions & { choose?: readonly string[] | WaveActorDecisionMenu; reply?: WaveActorDecisionReplyOptions; }): WaveActorDecision<this>;

  speak(text: string, options?: WaveSpeakTextOptions): WaveSpeechPlaybackHandle;

  speakAsCharacter(directive: string, options?: WaveActorDecisionOptions & { speech?: WaveSpeakTextOptions; reply?: WaveActorDecisionReplyOptions; }): WaveActorDecision<this>;

  speakWith(backend: WaveTTSBackend): this;

  speechState(): AudioSpeechState | null;

  get thinking(): cmp_thinking<this>;

  thinkWith(backend: WaveLLMBackend): this;

  useCharacter(character: WaveCharacter | WaveCharacterSnapshot): this;

}

interface WaveActorDecision<TActor extends WaveActorDecisionActor> {

  readonly actor: TActor;

  cancel(): void;

  readonly choices: readonly WaveActorDecisionChoice[];

  readonly chosen: WaveActorDecisionChoice | null;

  readonly chosenReason: string | null;

  readonly id: string;

  readonly input: string;

  onCapabilityEnd(callback: WaveActorDecisionCapabilityCallback<TActor>): this;

  onCapabilityStart(callback: WaveActorDecisionCapabilityCallback<TActor>): this;

  onComplete(callback: WaveActorDecisionCompleteCallback<TActor>): this;

  onDecision(callback: WaveActorDecisionChoiceCallback<TActor>): this;

  onError(callback: WaveActorDecisionErrorCallback<TActor>): this;

  onLLMRequest(callback: WaveActorDecisionLLMRequestCallback<TActor>): this;

  onOutcome(callback: WaveActorDecisionOutcomeCallback<TActor>): this;

  onQueued(callback: WaveActorDecisionCallback<TActor>): this;

  onReply(callback: WaveActorDecisionReplyCallback<TActor>): this;

  onSpeechEnd(callback: WaveActorDecisionSpeechCallback<TActor>): this;

  onSpeechStart(callback: WaveActorDecisionSpeechCallback<TActor>): this;

  readonly outcomes: readonly WaveActorOutcomeRecord[];

  readonly replyText: string | null;

  reportOutcome(outcome: string | WaveActorOutcome, options?: WaveActorOutcomePolicy): this;

  reportOutcomeFor(target: WaveActorCapabilityUse, outcome: string | WaveActorOutcome, options?: WaveActorOutcomePolicy): this;

  readonly source: WaveActorDecisionSource;

  readonly state: ActorDecisionState;

  readonly timedOutCapabilities: readonly WaveActorCapabilityUse[];

  readonly usedCapabilities: readonly WaveActorCapabilityUse[];

}

interface WaveAnimationEventData<TPayload = WaveModelSerializableValue> {

  readonly at: WaveModelTimeSpanMetadata;

  readonly atMilliseconds: number;

  readonly atSeconds: number;

  readonly atTicks: number;

  readonly clipName: string;

  readonly entityId?: number;

  readonly occurrenceId: string;

  readonly ownerName: string;

  readonly payload?: TPayload;

}

declare class WaveArticulatedActuation<T extends WavePhysicsRigPart = WavePhysicsRigPart, TPartId extends WaveModelPartId = WaveModelPartId> {

  get appliedCommandJointIds(): readonly string[];

  branchPartIds(rootPartId: TPartId): readonly TPartId[];

  breakBefore(partId: TPartId): boolean;

  captureAppliedCommandsToRefs(buffers: WaveArticulatedAppliedCommandBuffers): number;

  capturePhysicalPoseSample(endEffector: string): WaveArticulatedPhysicalPoseSample;

  disableBranch(rootPartId: TPartId): this;

  dispose(): void;

  enableBranch(rootPartId: TPartId): this;

  endEffector(endEffector: string): WaveArticulatedEndEffectorActuationBuilder<T, TPartId>;

  readonly graph: WaveModelRigGraphMetadata;

  hasChannel(channelId: string): boolean;

  incomingJoint(partId: TPartId): WaveModelJointMetadata | null;

  lastIKResult(channelId: string): WaveModelIKSolveResult | null;

  parentPartId(partId: TPartId): TPartId | null;

  part(partId: TPartId): WaveArticulatedPartActuationBuilder<T, TPartId>;

  pose(values: Readonly<Record<string, WaveModelPoseValue>>): WaveArticulatedPoseActuationBuilder<T, TPartId>;

  readonly projection: WaveArticulatedActuationProjection;

  release(channelId: string): boolean;

  releaseAll(): this;

  releaseByPrefix(prefix: string): number;

  releasePartTargets(partId: TPartId): number;

  resetHistory(): this;

  resumeJointDrive(): this;

  setChannelEnabled(channelId: string, enabled: boolean): boolean;

  step(deltaTime?: number): this;

  readonly stepping: WaveArticulatedActuationStepping;

  suspendJointDrive(options?: { readonly maximumEffort?: number; readonly damping?: number; }): this;

  readonly topology: WaveModelRigTopology;

  withBodyDriveOutputFilter(filter: WavePhysicsRigDynamicDriveFilter<T> | null): this;

}

declare class WaveArticulatedPhysicalSettlement {

  constructor(rig: WavePhysicsRig, _actuation: WaveArticulatedActuation, _channel: WaveArticulatedActuationChannelHandle, _target: WaveArticulatedPhysicalSettlementTarget, options?: WaveArticulatedPhysicalSettlementOptions);

  dispose(): void;

  get disposed(): boolean;

  hold(): boolean;

  get holding(): boolean;

  release(): boolean;

  resume(): this;

  sample(deltaTime: number, coordinatorStepRevision?: number): this;

  get settled(): boolean;

  get snapshot(): Readonly<WaveArticulatedPhysicalSettlementSnapshot>;

}

declare class WaveAssemblyAnchor implements WavePointSource {

  constructor(id: string, slot: WaveAssemblyAnchorSlot);

  readonly id: string;

  rotation(): Quaternion;

  setWorldPose(position: Vector3Like, rotation?: Quaternion): this;

  toVector(space?: WavePointSourceSpace): Vector3;

  toVector3(): Vector3;

  toVectorToRef(space: WavePointSourceSpace, result: Vector3): Vector3;

}

declare function waveAssemblyRecipe(id: string): WaveAssemblyRecipeBuilder;

declare class WaveAudioAnalysisBuilder {

  constructor(_start: WaveAudioAnalysisStarter, initialOptions: WaveAudioAnalysisSubscriptionOptions, _capturePolicy: WaveAudioCallbackPolicyCapture, _admitCallback: WaveAudioCallbackAdmission);

  decibels(minDecibels: number, maxDecibels: number): this;

  fftSize(fftSize: WaveAudioAnalysisOptions["fftSize"]): this;

  fps(value: number): this;

  onBandPeak(band: AudioAnalysisBandName, threshold: number, callback?: WaveAudioBandPeakCallback, options?: WaveAuthoredCallbackOptions): this;

  onFrame(callback: WaveAudioAnalysisFrameCallback, options?: WaveAuthoredCallbackOptions): this;

  onSnap(callback?: WaveAudioSnapCallback, options?: WaveAudioSnapDetectionOptions): this;

  onSnap(callback: WaveAudioSnapCallback, options: WaveAudioSnapDetectionOptions, callbackOptions: WaveAuthoredCallbackOptions): this;

  onSnap(options?: WaveAudioSnapDetectionOptions): this;

  smoothing(value: number): this;

  start(options?: WaveAuthoredCallbackOptions): WaveAudioAnalysisHandle;

  startAnalyzing(options?: WaveAuthoredCallbackOptions): WaveAudioAnalysisHandle;

  withDecibelRange(minDecibels: number, maxDecibels: number): this;

  withFftSize(fftSize: WaveAudioAnalysisOptions["fftSize"]): this;

  withFrameRate(value: number): this;

  withSmoothing(value: number): this;

  withSnapDetection(options?: WaveAudioSnapDetectionOptions): this;

}

declare class WaveAudioBeatAnalysisBuilder {

  constructor(_start: WaveAudioBeatAnalysisStarter, initialOptions: WaveAudioBeatAnalysisOptions, _capturePolicy: WaveAudioCallbackPolicyCapture, _admitCallback: WaveAudioCallbackAdmission);

  analyze(options?: WaveAuthoredCallbackOptions): Promise<WaveAudioBeatAnalysisResult>;

  duration(seconds: number): this;

  maxTempo(value: number): this;

  minTempo(value: number): this;

  offset(seconds: number): this;

  onResult(callback: WaveAudioBeatAnalysisCallback, options?: WaveAuthoredCallbackOptions): this;

  start(options?: WaveAuthoredCallbackOptions): Promise<WaveAudioBeatAnalysisResult>;

  startAnalyzing(options?: WaveAuthoredCallbackOptions): Promise<WaveAudioBeatAnalysisResult>;

  tempoRange(minTempo: number, maxTempo: number): this;

  withDuration(seconds: number): this;

  withOffset(seconds: number): this;

  withTempoRange(minTempo: number, maxTempo: number): this;

}

declare class WaveAudioPlaybackHandle {

  constructor(_commit: WaveAudioPlaybackCommit, initialOptions?: WaveAudioPlaybackOptions);

  static noop(initialOptions?: WaveAudioPlaybackOptions): WaveAudioPlaybackHandle;

  atPosition(position: WavePointInput): this;

  endAt(ratio: number): this;

  loop(enabled?: boolean): this;

  onBus(busName: string): this;

  onComplete(callback: () => void, options?: WaveAuthoredCallbackOptions): this;

  oneShot(enabled?: boolean): this;

  onStart(callback: () => void, options?: WaveAuthoredCallbackOptions): this;

  startFrom(ratio: number): this;

  withBrightness(brightness: number): this;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): this;

  withPitchCents(pitchCents: number): this;

  withSpatialPreset(preset: AudioSpatialPreset): this;

  withSpatialSound(enabled?: boolean): this;

  withSpeed(speed: number): this;

  withVolume(volume: number): this;

}

interface WaveAuthoredPoint<TFrameReference = unknown> extends WavePointSource {

  inFrameOf(target: TFrameReference): WaveAuthoredPoint<TFrameReference>;

  inLocalFrame(): WaveAuthoredPoint<TFrameReference>;

  inLocalTerms(): WaveAuthoredPoint<TFrameReference>;

  inParentFrame(depth?: number): WaveAuthoredPoint<TFrameReference>;

  inParentTerms(): WaveAuthoredPoint<TFrameReference>;

  inWorldFrame(): WaveAuthoredPoint<TFrameReference>;

  inWorldTerms(): WaveAuthoredPoint<TFrameReference>;

  moveBackward(distance: number): WaveAuthoredPoint<TFrameReference>;

  moveBy(direction: DirectionInput, distance: number): WaveAuthoredPoint<TFrameReference>;

  moveDown(distance: number): WaveAuthoredPoint<TFrameReference>;

  moveForward(distance: number): WaveAuthoredPoint<TFrameReference>;

  moveLeft(distance: number): WaveAuthoredPoint<TFrameReference>;

  moveRight(distance: number): WaveAuthoredPoint<TFrameReference>;

  moveUp(distance: number): WaveAuthoredPoint<TFrameReference>;

  moveX(distance: number): WaveAuthoredPoint<TFrameReference>;

  moveY(distance: number): WaveAuthoredPoint<TFrameReference>;

  moveZ(distance: number): WaveAuthoredPoint<TFrameReference>;

}

declare class waveBoneHandle extends wave3DAbstract {

  constructor(options: WaveBoneHandleOptions);

  static readonly typeName: EntityType;

  applyNetworkTransform(transform: NetworkTransform): void;

  get bodyPart(): BodyPart | null;

  get bone(): WaveBone;

  get boneExactName(): string;

  get boneName(): string;

  get boneRef(): string | BodyPart;

  createNetworkProperties(ownerNetworkId: number): WaveBoneHandleNetworkProperties;

  enableNetworkIdentityFromOwner(options?: Partial<NetworkOptions>): this;

  getNetworkTransform(): NetworkTransform;

  getTransformDomainAdapter(transform: cmp_transform): TransformDomainAdapter | null;

  rebind(boneRef: string | BodyPart, bone: WaveBone): this;

  get sourceEntity(): WaveEntity<unknown>;

  get sourceRig(): cmp_rig;

}

interface WaveBrowserRuntimeFault {

  readonly details: string | null;

  readonly fatal: boolean;

  readonly message: string;

  readonly name: string;

  readonly occurredAtMs: number;

  readonly stack: string | null;

}

interface WaveBrowserRuntimeStatus {

  readonly message: string;

  readonly occurredAtMs: number;

  readonly severity: "info" | "error";

}

declare class waveCamera extends waveProp {

  constructor();

  static readonly typeName: EntityType;

  activate(): this;

  assignToNum0(): this;

  assignToNum1(): this;

  assignToNum2(): this;

  assignToNum3(): this;

  assignToNum4(): this;

  assignToNum5(): this;

  assignToNum6(): this;

  assignToNum7(): this;

  assignToNum8(): this;

  assignToNum9(): this;

  avoid(volume: CameraVolumeConstraintSource, options?: CameraConstraintOptions | number): this;

  calledOn(isCallOn?: boolean, color?: number): void;

  get cameraConstraints(): readonly CameraConstraintConfig[];

  get cameraLayer(): number | null; set cameraLayer(value: number | null);

  clearCameraConstraints(): this;

  clearPaniniProjection(): this;

  deactivate(): this;

  destroy(): void;

  dolly(distance: number, duration?: WaveTimeSpan, ease?: WaveEasing): this;

  dolly(distance: number, value: number, unit: WaveTimeUnit, ease?: WaveEasing): this;

  get far(): number;

  follow(target: TransformReferenceLike): CameraFollowViewBuilder;

  get FollowCamera(): cmp_camera;

  getCameraData(): WaveCameraData;

  hideBoundingBox(): this;

  hideCameraHelper(): this;

  hideCameraWidget(): this;

  hideCoordinate(): this;

  hideDimension(): this;

  hideDirection(): this;

  get isBoundingBoxRequested(): boolean;

  get isCoordinateRequested(): boolean;

  get isDimensionRequested(): boolean;

  get isDirectionRequested(): boolean;

  keepAbove(surface: CameraHeightSurfaceSource, options?: CameraConstraintOptions | number): this;

  get near(): number;

  get nearAuto(): CameraNearAutoConfig | null;

  pan(angleDeg: number, duration?: WaveTimeSpan, ease?: WaveEasing): this;

  pan(angleDeg: number, value: number, unit: WaveTimeUnit, ease?: WaveEasing): this;

  pedestal(distance: number, duration?: WaveTimeSpan, ease?: WaveEasing): this;

  pedestal(distance: number, value: number, unit: WaveTimeUnit, ease?: WaveEasing): this;

  pedestalDown(distance: number, duration?: WaveTimeSpan, ease?: WaveEasing): this;

  pedestalDown(distance: number, value: number, unit: WaveTimeUnit, ease?: WaveEasing): this;

  pedestalUp(distance: number, duration?: WaveTimeSpan, ease?: WaveEasing): this;

  pedestalUp(distance: number, value: number, unit: WaveTimeUnit, ease?: WaveEasing): this;

  pullBack(distance: number, duration?: WaveTimeSpan, ease?: WaveEasing): this;

  pullBack(distance: number, value: number, unit: WaveTimeUnit, ease?: WaveEasing): this;

  pushIn(distance: number, duration?: WaveTimeSpan, ease?: WaveEasing): this;

  pushIn(distance: number, value: number, unit: WaveTimeUnit, ease?: WaveEasing): this;

  setCamera(data: WaveCameraSetData): this;

  setFar(far: number): this;

  setFov(fov: number): this;

  setFov(fov: number, mode: typeof Snapshot): WavePropertySnapshot;

  setFov(fov: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  setLookDirection(direction: Vector3Like): this;

  setLookDirection(x: number, y: number, z: number): this;

  setNear(near: number): this;

  setNearAuto(options?: CameraNearAutoOptions): this;

  setPaniniProjection(d?: number, fovCompensation?: number): this;

  setZoom(zoom: number): this;

  setZoom(zoom: number, mode: typeof Snapshot): WavePropertySnapshot;

  setZoom(zoom: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  showBoundingBox(): this;

  showCoordinate(): this;

  showDimension(): this;

  showDirection(): this;

  showHelper(): this;

  showWidget(): this;

  smoothTransformViewChanges(options?: CameraFollowViewBlendOptions): this;

  snapTransformViewChanges(): this;

  standBy(): void;

  stayInside(volume: CameraVolumeConstraintSource, options?: CameraStayInsideOptions | number): this;

  tilt(angleDeg: number, duration?: WaveTimeSpan, ease?: WaveEasing): this;

  tilt(angleDeg: number, value: number, unit: WaveTimeUnit, ease?: WaveEasing): this;

  toggleCameraHelper(): this;

  truck(distance: number, duration?: WaveTimeSpan, ease?: WaveEasing): this;

  truck(distance: number, value: number, unit: WaveTimeUnit, ease?: WaveEasing): this;

  truckLeft(distance: number, duration?: WaveTimeSpan, ease?: WaveEasing): this;

  truckLeft(distance: number, value: number, unit: WaveTimeUnit, ease?: WaveEasing): this;

  truckRight(distance: number, duration?: WaveTimeSpan, ease?: WaveEasing): this;

  truckRight(distance: number, value: number, unit: WaveTimeUnit, ease?: WaveEasing): this;

  turnCameraTo(target: TransformReferenceLike | WavePointInput, options?: WaveLookAtOptions): this;

  turnCameraTo(x: number, y: number, z: number, options?: WaveLookAtOptions): this;

  whipPan(angle: number, duration?: WaveTimeSpan): this;

  whipPan(angle: number, value: number, unit: WaveTimeUnit): this;

}

interface WaveCameraResult {

  readonly cameraId: string | null;

  readonly capturedAtMs: number;

  readonly forward: readonly [number, number, number] | null;

  readonly frameRevision: number;

  readonly position: readonly [number, number, number] | null;

  readonly requestId: number;

  readonly verticalFovRadians: number | null;

}

interface WaveCamouflageMaterialPresetOptions extends WaveMaterialPresetOptions {

  readonly colors?: readonly [ColorInputAlpha, ColorInputAlpha, ColorInputAlpha];

}

declare class waveCapsule extends waveGeometry {

  configureGeometry(configuration: WaveCapsulePrimitiveRecipe | WavePrimitiveGeometryConfiguration<WaveCapsulePrimitiveRecipe>): this;

  primitiveRecipe: WaveCapsulePrimitiveRecipe;

  constructor(radius?: number, height?: number, tessellation?: number, heightSegments?: number, capSubdivisions?: number);

  static readonly typeName: EntityType;

  asCapsule(radius: number, height: number, tessellation?: number, heightSegments?: number, capSubdivisions?: number): this;

  get baseCapSubdivisions(): number;

  get baseHeight(): number;

  get baseHeightSegments(): number;

  get baseRadius(): number;

  get capSubdivisions(): number;

  get height(): number;

  get heightSegments(): number;

  get radius(): number;

  setBaseCapSubdivisions(segments: number): this;

  setBaseHeight(height: number): this;

  setBaseHeightSegments(segments: number): this;

  setBaseRadialSegments(segments: number): this;

  setBaseRadius(radius: number): this;

  setBaseSegments(radialSegments: number, heightSegments: number, capSubdivisions?: number): this;

  get tessellation(): number;

  get totalHeight(): number;

}

interface WaveCaptureResult {

  readonly bytes: Uint8Array;

  readonly height: number;

  readonly mimeType: string;

  readonly requestId: number;

  readonly width: number;

}

interface WaveCardClusterGeometryRecipeOptions {

  readonly includeCardIndex?: boolean | undefined;

  readonly name?: string | undefined;

  readonly outline?: readonly WaveCardRecipeOutlinePoint[] | undefined;

  readonly cards?: readonly WaveCardRecipePlacement[];

  readonly layout?: WaveCardRecipeClusterLayout;

}

interface WaveCardRecipeAnchor {

  readonly group?: string;

  readonly position: Vector3Like;

  readonly rotation?: QuaternionLike;

  readonly scale?: Vector3Like;

  readonly uvRect?: WaveCardRecipeUvRect;

}

interface WaveCardRecipeBoundsBox {

  readonly max: Vector3Like;

  readonly min: Vector3Like;

}

interface WaveCardRecipeBoundsCenterSize {

  readonly center: Vector3Like;

  readonly size: Vector3Like;

}

type WaveCardRecipeClusterLayout = { readonly mode: "explicit"; readonly cards: readonly WaveCardRecipePlacement[]; } | { readonly mode: "radialCross"; readonly cardCount?: number; readonly center?: Vector3Like; readonly radius?: number; readonly width?: number; readonly height?: number; readonly group?: string; readonly seed?: number; readonly uvRect?: WaveCardRecipeUvRect; } | { readonly mode: "scatterInVolume"; readonly count: number; readonly bounds: WaveCardRecipeBoundsBox | WaveCardRecipeBoundsCenterSize; readonly widthRange?: readonly [min: number, max: number]; readonly heightRange?: readonly [min: number, max: number]; readonly group?: string; readonly seed?: number; readonly uvRect?: WaveCardRecipeUvRect; } | { readonly mode: "anchoredScatter"; readonly anchors: readonly (Vector3Like | WaveCardRecipeAnchor)[]; readonly widthRange?: readonly [min: number, max: number]; readonly heightRange?: readonly [min: number, max: number]; readonly group?: string; readonly seed?: number; readonly uvRect?: WaveCardRecipeUvRect; }

type WaveCardRecipeOutlinePoint = readonly [x: number, y: number];

interface WaveCardRecipePlacement {

  position: Vector3Like_2;

  rotation: QuaternionLike_2;

  scale: Vector3Like_2;

  readonly color?: ColorInput;

  readonly group?: string;

  readonly id?: string;

  readonly uvRect?: WaveCardRecipeUvRect;

}

interface WaveCardRecipeUvRect {

  readonly u0: number;

  readonly u1: number;

  readonly v0: number;

  readonly v1: number;

}

interface WaveCardSpriteGeometryRecipeOptions {

  readonly includeCardIndex?: boolean | undefined;

  readonly name?: string | undefined;

  readonly outline?: readonly WaveCardRecipeOutlinePoint[] | undefined;

  readonly atlasColumns?: number;

  readonly atlasRows?: number;

  readonly height?: number;

  readonly placement?: WaveCardRecipePlacement;

  readonly uvRect?: WaveCardRecipeUvRect;

  readonly viewIndex?: number;

  readonly width?: number;

}

declare class waveCavity extends waveProp {

  constructor(model: WaveCavityModelInput);

  static readonly typeName: EntityType;

  get cavityModel(): WaveCavityModelInput;

  destroy(): void;

  getLightingRange(): WaveLightingZone | null;

  get lightingPolicy(): WaveCavityLightingPolicyConfigurator<waveCavity>;

  get lightingRange(): WaveLightingZone | null;

  setLightingPolicy(config: WaveCavityLightingPolicyConfig): this;

  useCavityModel(model: WaveCavityModelInput): this;

  useModel(model: WaveCavityModelInput, options?: Visual3DModelUseOptions): this;

  zone(id: string): WaveCavityZone;

  zones(): readonly WaveCavityZone[];

}

declare class WaveCavityModelBuilder {

  constructor(id: string);

  apply(): WaveCavityModelInput;

  autoConnect(): this;

  close(id: string, ...directions: WaveCavityOpenDirection[]): this;

  connect(source: string, target: string): this;

  natural(id: string, options: WaveCavityNaturalOptions): this;

  open(id: string, ...directions: WaveCavityOpenDirection[]): this;

  remove(id: string): this;

  room(id: string, options: WaveCavityRoomOptions): this;

  toConfig(): WaveCavityModelRecipe;

  tunnel(id: string, options: WaveCavityTunnelOptions): this;

  zone(id: string, ...nodeIds: string[]): this;

}

type WaveCavityModelInput = WaveModelInput<WaveCavityModelRecipe>;

interface WaveCavityModelRecipe {

  readonly collision: "staticMesh";

  readonly nodes: readonly WaveCavityNodeRecipe[];

  readonly topology: WaveCavityTopologyRecipe;

  readonly version: 1;

  readonly zones: readonly WaveCavityZoneRecipe[];

}

interface WaveCavityNaturalOptions extends WaveCavityNodePlacementOptions {

  readonly blendRadius?: number;

  readonly depth?: number;

  readonly height: number;

  readonly heightProgression?: WaveValueCurveSpec;

  readonly path?: readonly Vector3Like[];

  readonly profile?: WaveCavityProfile;

  readonly progressionSamples?: number;

  readonly surface?: WaveCavitySurfaceOptions;

  readonly width: number;

  readonly widthProgression?: WaveValueCurveSpec;

}

interface WaveCavityNodePlacementOptions {

  readonly at?: Vector3Like;

  readonly rotation?: QuaternionLike;

}

interface WaveCavityNodeProgressionRecipe {

  readonly height?: WaveValueCurveSpec;

  readonly samples: number;

  readonly width?: WaveValueCurveSpec;

}

interface WaveCavityNodeRecipe {

  readonly blendRadius?: number;

  readonly depth: number;

  readonly height: number;

  readonly id: string;

  readonly openings: readonly WaveCavityOpenDirection[];

  readonly path?: readonly WaveCavityVector3Recipe[];

  readonly profile?: WaveCavityProfile;

  readonly progression?: WaveCavityNodeProgressionRecipe;

  readonly shape: "room" | "natural";

  readonly surface?: WaveCavityVolumetricSurface;

  readonly transform: WaveCavityNodeTransformRecipe;

  readonly width: number;

}

interface WaveCavityNodeTransformRecipe {

  readonly position: WaveCavityVector3Recipe;

  readonly rotation: WaveCavityQuaternionRecipe;

}

type WaveCavityOpenDirection = "left" | "right" | "up" | "down" | "forward" | "backward";

type WaveCavityProfile = WaveCavityVolumetricProfile;

interface WaveCavityQuaternionRecipe extends WaveCavityVector3Recipe {

  readonly w: number;

}

interface WaveCavityRoomOptions extends WaveCavityNodePlacementOptions {

  readonly blendRadius?: number;

  readonly depth?: number;

  readonly height: number;

  readonly surface?: WaveCavitySurfaceOptions;

  readonly width: number;

}

interface WaveCavitySurfaceOptions {

  amount?: number | undefined;

  amplitude?: number | undefined;

  floorDamping?: number | undefined;

  frequency?: number | undefined;

  seed?: number | undefined;

  style?: "rough" | "layered" | "eroded" | undefined;

}

interface WaveCavityTopologyEdgeRecipe {

  readonly source: string;

  readonly target: string;

}

interface WaveCavityTopologyRecipe {

  readonly edges: readonly WaveCavityTopologyEdgeRecipe[];

  readonly mode: "explicit" | "spatial";

}

type WaveCavityTunnelOptions = Omit<WaveCavityNaturalOptions, "profile">;

interface WaveCavityVector3Recipe {

  readonly x: number;

  readonly y: number;

  readonly z: number;

}

interface WaveCavityZoneRecipe {

  readonly id: string;

  readonly nodeIds: readonly string[];

}

declare class WaveCharacter {

  constructor(name?: string);

  static createCharacter(name?: string): WaveCharacter;

  get bio(): string | undefined;

  clearInstructions(): this;

  clearKnowledge(): this;

  clone(): WaveCharacter;

  get instructions(): readonly string[];

  get knowledge(): readonly string[];

  get mood(): string | undefined;

  get name(): string | undefined;

  noMarkdown(enabled?: boolean): this;

  reply(policy: WaveCharacterReplyPolicy): this;

  get replyPolicy(): WaveCharacterReplyPolicy;

  requireCompleteThought(enabled?: boolean): this;

  snapshot(): WaveCharacterSnapshot;

  get style(): string | undefined;

  withBio(bio: string | null | undefined): this;

  withFallbackReply(text: string | null | undefined): this;

  withInstruction(instruction: string | null | undefined): this;

  withInstructions(instructions: readonly string[]): this;

  withKnowledge(entry: string | null | undefined): this;

  withKnowledge(entries: readonly string[]): this;

  withMood(mood: string | null | undefined): this;

  withName(name: string | null | undefined): this;

  withoutMarkdown(enabled?: boolean): this;

  withReplyMaxTokens(maxTokens: number): this;

  withReplyMaxWords(maxWords: number): this;

  withReplyPolicy(policy: WaveCharacterReplyPolicy): this;

  withStyle(style: string | null | undefined): this;

  withTemperature(temperature: number): this;

}

declare function waveChoice(id: string): WaveChoiceBuilder;

declare class WaveCloth extends WaveGroup<waveThinBatch> {

  anchorNode(nodeIndex: number, target: WaveSoftBodyAttachmentTarget, options?: WaveSoftBodyAttachmentOptions): this;

  captureRestState(): this;

  destroy(): void;

  getNode(index: number): WaveSoftBodyNodeHandle;

  getNodeWorldPositionsToRef(targets: readonly Vector3[]): readonly Vector3[];

  isDestroyed: boolean;

  nodeCount: number;

  nodes: readonly WaveSoftBodyNodeHandle[];

  physicsBatch: waveThinBatch | undefined;

  pinAllNodes(): this;

  pinNode(nodeIndex: number): this;

  relaxToRest(): this;

  resetToRest(): this;

  surface: wavePlane | undefined;

  unanchorNode(nodeIndex: number): boolean;

  unpinAllNodes(): this;

  unpinNode(nodeIndex: number): this;

  visualBatch: waveThinBatch | undefined;

  constructor(options: ClothGridOptions, scene?: WaveGroupSceneBridge);

  anchorCorner(corner: WaveClothCorner, target: WaveSoftBodyAttachmentTarget, options?: WaveSoftBodyAttachmentOptions): this;

  get cols(): number;

  getNodeAt(row: number, col: number): WaveSoftBodyNodeHandle;

  getNodeIndex(row: number, col: number): number;

  get particleCollisionPolicy(): WaveSoftBodyParticleCollisionPolicy;

  pinCorner(corner: WaveClothCorner): this;

  get rows(): number;

  toConfig(): WaveClothConfig;

  unpinCorner(corner: WaveClothCorner): this;

}

type WaveCloudFormation = typeof WAVE_CLOUD_FORMATIONS[number];

type WaveCloudQuality = "low" | "balanced" | "high";

declare class waveClusteredLights extends WaveGroupCollection<waveLight, WaveSpatial3DObject | wave3DObject> {

  constructor(name: string, controller?: WaveSpatial3DObject | wave3DObject, scene?: WaveGroupSceneBridge);

  add(...members: waveLight[]): this;

  capRangeAt(maxRange: number): this;

  readonly clusteredLightsKind: "waveClusteredLights";

  get config(): WaveClusteredLightsConfigSnapshot;

  containing(...members: waveLight[]): this;

  getAABB(): { min: Vector3; max: Vector3; }

  setControllerAsGroupParent(enabled?: boolean): this;

  whenUnsupportedLight(policy: WaveClusteredLightUnsupportedPolicy): this;

  withDepthSlices(depthSlices: number): this;

  withLights(...members: waveLight[]): this;

  withTileGrid(horizontalTiles: number, verticalTiles: number): this;

}

type WaveColorField = WaveMaterialField<"color">;

type WaveColorFieldInput = ColorInputAlpha | WaveColorField;

type WaveColorFieldRef = WaveMaterialFieldRef<"color">;

declare class WaveCompiledAssemblyInstance {

  constructor(_owner: WaveCompiledAssemblyInstances<unknown, unknown, unknown>, index: number, key: string);

  activate(): this;

  anchor(id: string): WaveAssemblyAnchor;

  bind<T extends wave3DObject>(slotId: string, entity: T): T;

  composeAppliedPhysicsRig<TPart extends WavePhysicsRigPart>(slotId: string, source: WavePhysicsRig<TPart> | WaveAssemblyAppliedPhysicsRigSource<TPart>): WaveModelPhysicsRig;

  entities(slotId: string): readonly wave3DObject[];

  readonly index: number;

  readonly key: string;

  makeDormant(): this;

  makeResident(): this;

  part(slotId: string, partId: string): waveProp | undefined;

  realizePhysicsRig<TPart extends WavePhysicsRigPart>(slotId: string, rig: WavePhysicsRig<TPart>, options?: WaveModelPhysicsRigOptions): WaveModelPhysicsRig;

  residency(): WaveAssemblyResidency;

  setResidency(residency: WaveAssemblyResidency): this;

  trackDisposable<T extends WaveAssemblyDisposable>(resource: T): T;

  trackRollback(rollback: () => void): void;

  useModel<T extends waveProp>(slotId: string, entity: T): T;

}

declare class waveCone extends waveGeometry {

  configureGeometry(configuration: WaveConePrimitiveRecipe | WavePrimitiveGeometryConfiguration<WaveConePrimitiveRecipe>): this;

  primitiveRecipe: WaveConePrimitiveRecipe;

  constructor(height?: number, diameter?: number, tessellation?: number, heightSegments?: number);

  static readonly typeName: EntityType;

  asCone(height: number, diameter: number, tessellation?: number, heightSegments?: number): this;

  get baseArc(): number;

  get baseCap(): number;

  get baseDiameter(): number;

  get baseEnclose(): boolean;

  get baseFaceColors(): unknown[] | null;

  get baseFaceUV(): unknown[] | null;

  get baseHeight(): number;

  clearBaseFaceColors(): this;

  clearBaseFaceUV(): this;

  get diameter(): number;

  face(surface: WaveSurface): ReturnType<cmp_visual3DModel["surface"]>;

  faceMaterial(surface: WaveSurface): ReturnType<cmp_visual3DModel["meshMaterialSlot"]>;

  get height(): number;

  get heightSegments(): number;

  get radius(): number;

  setBaseArc(arc: number): this;

  setBaseCap(cap: WaveCapMode | number): this;

  setBaseDiameter(diameter: number): this;

  setBaseEnclose(enclose: boolean): this;

  setBaseFaceColors(faceColors: ColorInputAlpha[]): this;

  setBaseFaceUV(faceUV: unknown[]): this;

  setBaseHeight(height: number): this;

  setBaseHeightSegments(segments: number): this;

  setBaseRadialSegments(segments: number): this;

  setBaseSegments(radialSegments: number, heightSegments: number): this;

  setBaseSideOrientation(sideOrientation: number): this;

  get tessellation(): number;

}

declare const waveCoverage: Readonly<{ fixedAt(u: number, v: number): WaveRelativeCoverageBuilder; aroundPrimaryCamera(): WaveRelativeCoverageBuilder; aroundEntity(entity: WaveEntityIdentityInput): WaveRelativeCoverageBuilder; }>;

declare class waveCube extends waveGeometry {

  configureGeometry(configuration: WaveBoxPrimitiveRecipe | WavePrimitiveGeometryConfiguration<WaveBoxPrimitiveRecipe>): this;

  primitiveRecipe: WaveBoxPrimitiveRecipe;

  constructor(width?: number, height?: number, depth?: number, widthSegments?: number, heightSegments?: number, depthSegments?: number);

  static readonly typeName: EntityType;

  asBox(width: number, height: number, depth: number, widthSegments?: number, heightSegments?: number, depthSegments?: number): this;

  asCutTool(enabled?: boolean): this;

  asTrapezoid(width?: number, height?: number, depth?: number, topWidth?: number, topDepth?: number, widthSegments?: number, heightSegments?: number, depthSegments?: number): this;

  get baseDepth(): number;

  get baseDepthSegments(): number;

  get baseFaceColors(): unknown[] | null;

  get baseFaceUV(): unknown[] | null;

  get baseHeight(): number;

  get baseHeightSegments(): number;

  get baseTopDepth(): number;

  get baseTopWidth(): number;

  get baseWidth(): number;

  get baseWidthSegments(): number;

  clearBaseFaceColors(): this;

  clearBaseFaceUV(): this;

  get depth(): number;

  get depthSegments(): number;

  face(surface: WaveSurface): ReturnType<cmp_visual3DModel["surface"]>;

  faceMaterial(surface: WaveSurface): ReturnType<cmp_visual3DModel["meshMaterialSlot"]>;

  get height(): number;

  get heightSegments(): number;

  get isCutTool(): boolean;

  setBaseDepth(depth: number): this;

  setBaseDepthSegments(segments: number): this;

  setBaseFaceColors(faceColors: ColorInputAlpha[]): this;

  setBaseFaceUV(faceUV: unknown[]): this;

  setBaseHeight(height: number): this;

  setBaseHeightSegments(segments: number): this;

  setBaseSegments(widthSegments: number, heightSegments: number, depthSegments: number): this;

  setBaseSideOrientation(sideOrientation: number): this;

  setBaseSizes(width: number, height: number, depth: number): this;

  setBaseTopDepth(topDepth: number): this;

  setBaseTopWidth(topWidth: number): this;

  setBaseWidth(width: number): this;

  setBaseWidthSegments(segments: number): this;

  get width(): number;

  get widthSegments(): number;

}

declare class waveCylinder extends waveGeometry {

  configureGeometry(configuration: WaveCylinderPrimitiveRecipe | WavePrimitiveGeometryConfiguration<WaveCylinderPrimitiveRecipe>): this;

  primitiveRecipe: WaveCylinderPrimitiveRecipe;

  constructor(height?: number, diameterTop?: number, diameterBottom?: number, tessellation?: number, heightSegments?: number);

  static readonly typeName: EntityType;

  asCylinder(height: number, diameterTop: number, diameterBottom: number, tessellation?: number, heightSegments?: number): this;

  get baseArc(): number;

  get baseCap(): number;

  get baseDiameterBottom(): number;

  get baseDiameterTop(): number;

  get baseEnclose(): boolean;

  get baseFaceColors(): unknown[] | null;

  get baseFaceUV(): unknown[] | null;

  get baseHeight(): number;

  get baseHeightSegments(): number;

  clearBaseFaceColors(): this;

  clearBaseFaceUV(): this;

  get diameterBottom(): number;

  get diameterTop(): number;

  face(surface: WaveSurface): ReturnType<cmp_visual3DModel["surface"]>;

  faceMaterial(surface: WaveSurface): ReturnType<cmp_visual3DModel["meshMaterialSlot"]>;

  get height(): number;

  get heightSegments(): number;

  get radiusBottom(): number;

  get radiusTop(): number;

  setBaseArc(arc: number): this;

  setBaseCap(cap: WaveCapMode | number): this;

  setBaseDiameters(top: number, bottom: number): this;

  setBaseEnclose(enclose: boolean): this;

  setBaseFaceColors(faceColors: ColorInputAlpha[]): this;

  setBaseFaceUV(faceUV: unknown[]): this;

  setBaseHeight(height: number): this;

  setBaseHeightSegments(segments: number): this;

  setBaseRadialSegments(segments: number): this;

  setBaseRadii(top: number, bottom: number): this;

  setBaseSegments(radialSegments: number, heightSegments: number): this;

  setBaseSideOrientation(sideOrientation: number): this;

  get tessellation(): number;

}

declare class waveDecal extends WaveObject<unknown, Vector3, Partial<ResolvedWorldTransformSnapshot>, "3d"> {

  constructor(config?: DecalOptions);

  static readonly typeName: EntityType;

  get decal(): cmp_decal;

  destroy(): void;

  fadeOutAndRemove(duration: WaveTimeSpan): void;

  fadeOutAndRemove(value: number, unit: WaveTimeUnit): void;

  getTransformDomainAdapter(transform: cmp_transform): TransformDomainAdapter | null;

  isAlive(): boolean;

  isRendered(): boolean;

  material(): DecalMaterialEditorView;

  onSurface(): WaveTransformFrameScope;

  placeAt(position: WavePointInput): this;

  placeAt(x: number, y: number, z: number): this;

  remove(): void;

  renderRank(): number | null;

  setAngleFade(degrees: number): this;

  setDecalBlendMode(mode: DecalBlendMode): this;

  setDecalGlowColor(color: ColorInput | null): this;

  setDecalLayerMask(mask: number): this;

  setDecalMask(mask: DecalMaskMode): this;

  setDecalMaskFeather(value: number): this;

  setDecalOpacity(opacity: number): this;

  setDecalPriority(priority: number): this;

  setDecalSize(x: number, y: number, z: number): this;

  setDecalTextures(options: { albedo?: string; normal?: string; }): this;

  setDecalTextureSet(options: DecalMaterialTextureSet): this;

  setDecalTint(color: ColorInput): this;

  setDecalUVOffset(x: number, y: number): this;

  setDecalUVRotation(degrees: number): this;

  setEmissiveIntensity(intensity: number): this;

  setMetallicMultiplier(multiplier: number): this;

  setRoughnessMultiplier(multiplier: number): this;

  get transformAnimator(): cmp_transformAnimator;

  whenClickedOn(callback: InteractionCallback<waveDecal>, options?: InteractionCallbackOptions): CallbackHandle;

}

declare class waveDisc extends waveGeometry {

  configureGeometry(configuration: WaveDiscPrimitiveRecipe | WavePrimitiveGeometryConfiguration<WaveDiscPrimitiveRecipe>): this;

  primitiveRecipe: WaveDiscPrimitiveRecipe;

  constructor(radius?: number, tessellation?: number);

  static readonly typeName: EntityType;

  asDisc(radius: number, tessellation?: number): this;

  asRing(outerRadius?: number, innerRadius?: number, tessellation?: number): this;

  get baseArc(): number;

  get baseBackUVs(): unknown | null;

  get baseFrontUVs(): unknown | null;

  get baseInnerRadius(): number;

  get baseOuterRadius(): number;

  get baseRadius(): number;

  clearBaseBackUVs(): this;

  clearBaseFrontUVs(): this;

  get innerRadius(): number;

  get outerRadius(): number;

  get radius(): number;

  setBaseArc(arc: number): this;

  setBaseBackUVs(backUVs: unknown): this;

  setBaseFrontUVs(frontUVs: unknown): this;

  setBaseInnerRadius(innerRadius: number): this;

  setBaseRadius(radius: number): this;

  setBaseSegments(segments: number): this;

  setBaseSideOrientation(sideOrientation: number): this;

  get tessellation(): number;

}

interface WaveDoubleSidedHeightfieldEdgeShape {

  readonly cliffBand: number;

  readonly falloffExponent: number;

  readonly falloffStart: number;

}

type WaveDoubleSidedHeightfieldModelBuilder = BuilderWithMethods<typeof DOUBLE_SIDED_HEIGHTFIELD_PARTS, WaveDoubleSidedHeightfieldModelMethods>;

interface WaveDoubleSidedHeightfieldModelMethods {

  shapeBottom(shape: WaveDoubleSidedHeightfieldSurfaceShape): WaveDoubleSidedHeightfieldModelBuilder;

  shapeEdges(shape: WaveDoubleSidedHeightfieldEdgeShape): WaveDoubleSidedHeightfieldModelBuilder;

  shapeTop(shape: WaveDoubleSidedHeightfieldSurfaceShape): WaveDoubleSidedHeightfieldModelBuilder;

  withBottomSurfaceColor(color: ColorInput): WaveDoubleSidedHeightfieldModelBuilder;

  withPartColors(partColors: Partial<Record<string, ColorInput>>): WaveDoubleSidedHeightfieldModelBuilder;

  withPreset(preset: DoubleSideHeightfieldPreset): WaveDoubleSidedHeightfieldModelBuilder;

  withSeed(seed: number): WaveDoubleSidedHeightfieldModelBuilder;

  withSize(width: number, depth: number): WaveDoubleSidedHeightfieldModelBuilder;

  withSubdivisions(subdivisions: number): WaveDoubleSidedHeightfieldModelBuilder;

  withTopSurfaceColor(color: ColorInput): WaveDoubleSidedHeightfieldModelBuilder;

}

interface WaveDoubleSidedHeightfieldSurfaceShape {

  readonly amplitude: number;

  readonly baseHeight: number;

  readonly frequency: number;

  readonly octaves: number;

  readonly persistence: number;

}

declare enum WaveEasing {

  BackIn = "back.in",

  BackInOut = "back.inOut",

  BackOut = "back.out",

  BounceIn = "bounce.in",

  BounceInOut = "bounce.inOut",

  BounceOut = "bounce.out",

  ElasticIn = "elastic.in",

  ElasticInOut = "elastic.inOut",

  ElasticOut = "elastic.out",

  ExpoIn = "expo.in",

  ExpoInOut = "expo.inOut",

  ExpoOut = "expo.out",

  Linear = "linear",

  None = "none",

  Power2In = "power2.in",

  Power2InOut = "power2.inOut",

  Power2Out = "power2.out",

  Power3In = "power3.in",

  Power3InOut = "power3.inOut",

  Power3Out = "power3.out",

  PowerIn = "power1.in",

  PowerInOut = "power1.inOut",

  PowerOut = "power1.out",

  SineIn = "sine.in",

  SineInOut = "sine.inOut",

  SineOut = "sine.out",

}

declare abstract class WaveEntity<TState = unknown> {

  static readonly typeName: string;

  addComponent<T extends WaveComponent>(arg1: ComponentConstructor<T> | T, ...args: unknown[]): T | null;

  after(duration: WaveTimeSpan): DelayedEntityProxy<this>;

  after(value: number, unit: WaveTimeUnit): DelayedEntityProxy<this>;

  atChanceOf(probability: number): ChanceEntityProxy<this>;

  blockEnterFor(state: TState, duration: WaveTimeSpan): this;

  blockEnterFor(state: TState, value: number, unit: WaveTimeUnit): this;

  blockExitFor(state: TState, duration: WaveTimeSpan): this;

  blockExitFor(state: TState, value: number, unit: WaveTimeUnit): this;

  cancelDelayedActions(): this;

  get canPlayAudio(): boolean;

  get canRender(): boolean;

  get canSimulatePhysics(): boolean;

  clone(name?: string): this | null;

  cloneWithOptions(name: string, options: CloneOptions): this | null;

  createCycle<T extends TState>(...states: T[]): CycleController<this, T>;

  get createdAt(): number;

  createToggle<T extends TState>(stateA: T, stateB: T): ToggleController<this, T>;

  get currentState(): TState | null;

  cycleThrough(callbacks: Array<EntityBehaviorCallback<this>>): this;

  deepClone(name?: string): this | null;

  destroy(): void;

  enableComponentInterception(): void;

  get engine(): unknown;

  enterState(state: TState): this;

  exitState(): this;

  getAllComponents(): WaveComponent[];

  getComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T | undefined;

  getComponent<T extends WaveComponent>(componentName: string): T | undefined;

  getComponentNames(): string[];

  getLastTickNumber(): number;

  getObservers(): ReadonlyMap<string, ObservationDefinition<WaveEntity<unknown>>>;

  getRequiredComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): T;

  getRequiredComponent<T extends WaveComponent>(componentName: string): T;

  goBackStateBy(steps: number): this;

  hasComponent<T extends WaveComponent>(ComponentClass: ComponentConstructor<T>): boolean;

  hasComponent(componentName: string): boolean;

  readonly id: number;

  inState(...states: TState[]): boolean;

  get isDestroyed(): boolean;

  get isEnabled(): boolean;

  isEnterBlocked(state: TState): boolean;

  isExitBlocked(state: TState): boolean;

  get isHeadless(): boolean;

  get isSpawned(): boolean;

  get name(): string;

  offCreated(callbackOrName?: string | EntityLifecycleCallback): boolean;

  offDestroyed(callbackOrName?: string | EntityLifecycleCallback): boolean;

  offDisabled(callbackOrName?: string | EntityLifecycleCallback): boolean;

  offEnabled(callbackOrName?: string | EntityLifecycleCallback): boolean;

  offEnter(state: TState, callback: (target: this) => void): boolean;

  offExit(state: TState, callback: (target: this) => void): boolean;

  offPostRender(callbackOrName: string | TickCallback<WaveEntity<unknown>>): boolean;

  offPostUpdate(callbackOrName: string | TickCallback<WaveEntity<unknown>>): boolean;

  offPreRender(callbackOrName: string | TickCallback<WaveEntity<unknown>>): boolean;

  offPreUpdate(callbackOrName: string | TickCallback<WaveEntity<unknown>>): boolean;

  offUpdate(callbackOrName: string | TickCallback<WaveEntity<unknown>>): boolean;

  on(selector: EntityNumericSelector<this>): NumericObservationSource<this>;

  onChangeRate<TEntity extends WaveEntity<unknown> = this>(selector: EntityNumericSelector<TEntity> | NumericObservationSource<WaveEntity<unknown>>): RateObservationSource<TEntity>;

  onCreated(callback: EntityLifecycleCallback<this>, nameOrOptions?: EntityLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onCreated(callback: EntityLifecycleCallback, nameOrOptions?: EntityLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDeclineRate<TEntity extends WaveEntity<unknown> = this>(selector: EntityNumericSelector<TEntity> | NumericObservationSource<WaveEntity<unknown>>): RateObservationSource<TEntity>;

  onDestroyed(callback: EntityLifecycleCallback<this>, nameOrOptions?: EntityLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDestroyed(callback: EntityLifecycleCallback, nameOrOptions?: EntityLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: EntityLifecycleCallback<this>, nameOrOptions?: EntityLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onDisabled(callback: EntityLifecycleCallback, nameOrOptions?: EntityLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: EntityLifecycleCallback<this>, nameOrOptions?: EntityLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnabled(callback: EntityLifecycleCallback, nameOrOptions?: EntityLifecycleCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onEnter(state: TState, callback: (target: this) => void, options?: WaveAuthoredCallbackOptions): this;

  onExit(state: TState, callback: (target: this) => void, options?: WaveAuthoredCallbackOptions): this;

  onGrowthRate<TEntity extends WaveEntity<unknown> = this>(selector: EntityNumericSelector<TEntity> | NumericObservationSource<WaveEntity<unknown>>): RateObservationSource<TEntity>;

  onPostRender(callback: TickCallback<this>, whenOrName?: WaveTimeRule | string, maybeNameOrOptions?: string | TickCallbackOptions): this;

  onPostUpdate(callback: TickCallback<this>, whenOrName?: WaveTimeRule | string, maybeNameOrOptions?: string | TickCallbackOptions): this;

  onPreRender(callback: TickCallback<this>, whenOrName?: WaveTimeRule | string, maybeNameOrOptions?: string | TickCallbackOptions): this;

  onPreUpdate(callback: TickCallback<this>, whenOrName?: WaveTimeRule | string, maybeNameOrOptions?: string | TickCallbackOptions): this;

  onTick(callback: TickCallback<this>, whenOrName?: WaveTimeRule | string, maybeNameOrOptions?: string | TickCallbackOptions): this;

  onUpdate(callback: TickCallback<this>, whenOrName?: WaveTimeRule | string, maybeNameOrOptions?: string | TickCallbackOptions): this;

  possiblyDo(options: Array<[number, EntityBehaviorCallback<this>]>): this;

  get previousState(): TState | null;

  randomlyDo(callbacks: Array<EntityBehaviorCallback<this>>): this;

  repeat<TDimensions extends readonly [number, ...number[]]>(dimensions: TDimensions): RepeatAction<this, RepeatIndices<TDimensions>>;

  repeat(dimensions: readonly number[]): RepeatAction<this, number[]>;

  repeat<TDimensions extends readonly [number, ...number[]]>(...dimensions: TDimensions): RepeatAction<this, RepeatIndices<TDimensions>>;

  get runtimeRef(): WaveEntityRuntimeRef;

  get scene(): WaveScene;

  setEnabled(value: boolean): this;

  setLifeTime(duration: WaveTimeSpan): this;

  setLifeTime(value: number, unit: WaveTimeUnit): this;

  setName(name: string): this;

  setTickableEnabled(enabled: boolean): void;

  get state(): EntityStateApi<this, TState>;

  get stateHistory(): readonly TState[];

  systemState<TSystemState = unknown>(lane: SystemStateLane, key?: string): ReadonlyEntityStateApi<this, TSystemState>;

  timeInCurrentState(): WaveTimeSpan;

  timesEnteredIn(state: TState, within: WaveTimeLookback): number;

  timesEnteredIn(state: TState, value: number, unit: WaveTimeUnit): number;

  timesExitedIn(state: TState, within: WaveTimeLookback): number;

  timesExitedIn(state: TState, value: number, unit: WaveTimeUnit): number;

  toggleBetween(cb1: EntityBehaviorCallback<this>, cb2: EntityBehaviorCallback<this>): this;

  totalTimeIn(state: TState): number;

  get typeName(): string;

  unblockEnter(state: TState): this;

  unblockExit(state: TState): this;

  when(selector: EntityBooleanSelector<this>): BooleanObservationSource<this>;

  whenIn(state: TState): ScopedObservationBuilder<this, TState>;

  whenIn(state: TState, callback: (target: this) => void, when?: WaveTimeRule, options?: WaveAuthoredCallbackOptions): this;

}

type WaveEquipmentAssignmentState = "empty" | "assigned";

declare const WaveEquipmentAssignmentState: { readonly Empty: "empty"; readonly Assigned: "assigned"; };

declare class WaveEquipmentFacade<TOwner extends wave3DObject = wave3DObject> {

  constructor(owner: TOwner);

  getSlot(slotName: string): WaveEquipmentSlotHandle<TOwner> | null;

  readonly owner: TOwner;

  slot(slotName: string): WaveEquipmentSlotHandle<TOwner>;

}

type WaveEquipmentMountState = "unmounted" | "mounting" | "mounted" | "unmounting";

declare const WaveEquipmentMountState: { readonly Unmounted: "unmounted"; readonly Mounting: "mounting"; readonly Mounted: "mounted"; readonly Unmounting: "unmounting"; };

declare class WaveEquipmentSlotHandle<TOwner extends wave3DObject = wave3DObject> {

  constructor(owner: TOwner, name: string);

  assign(item: wave3DObject): this;

  get assignmentState(): ReadonlyEntityStateApi<TOwner, WaveEquipmentAssignmentStateValue>;

  clear(): this;

  equip(item: wave3DObject): this;

  get item(): wave3DObject | null;

  mount(item?: wave3DObject | null): this;

  get mountedItem(): wave3DObject | null;

  get mountState(): ReadonlyEntityStateApi<TOwner, WaveEquipmentMountStateValue>;

  readonly name: string;

  onAssigned(callback: WaveEquipmentSlotCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  onCleared(callback: WaveEquipmentSlotCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  onEquipped(callback: WaveEquipmentSlotCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  onMounted(callback: WaveEquipmentSlotCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  onReleased(callback: WaveEquipmentSlotCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  onUnmounted(callback: WaveEquipmentSlotCallback<TOwner>, options?: WaveAuthoredCallbackOptions): this;

  readonly owner: TOwner;

  release(): this;

  get socket(): BoneSocket | null;

  unequip(): this;

  unmount(item?: wave3DObject | null): this;

  usesSocket(socket: BoneSocket): this;

  get useState(): ReadonlyEntityStateApi<TOwner, WaveEquipmentUseStateValue>;

}

type WaveEquipmentUseState = "idle" | "equipping" | "equipped" | "releasing" | "released";

declare const WaveEquipmentUseState: { readonly Idle: "idle"; readonly Equipping: "equipping"; readonly Equipped: "equipped"; readonly Releasing: "releasing"; readonly Released: "released"; };

declare function waveEvent<TEventData = unknown>(nameOrMetadata: string | WaveEventDefinitionMetadata<TEventData>): WaveEventDefinition<TEventData>;

interface WaveEvent<TPayload = unknown> {

  readonly data: TPayload;

  readonly name: string;

  readonly timestamp: number;

}

declare class WaveEventBus {

  clear(): void;

  clearEvent(event: WaveEventName | WaveEventInput): void;

  clearEventScoped(scopeId: string, event: WaveEventName | WaveEventInput): void;

  clearScope(scopeId: string): void;

  emit(event: WaveEventName | WaveEventInput, ...args: unknown[]): void;

  emitOne(event: WaveEventName | WaveEventInput, payload: unknown): void;

  emitRemote(event: WaveEventInput, payload: unknown, options?: RemoteEventOptions): void;

  emitScoped(scopeId: string, event: WaveEventName | WaveEventInput, ...args: unknown[]): void;

  emitScopedOne(scopeId: string, event: WaveEventName | WaveEventInput, payload: unknown): void;

  getHandlerCount(event: WaveEventName | WaveEventInput): number;

  getNetworkBridge(): NetworkEventBridge | null;

  getScopedHandlerCount(scopeId: string, event: WaveEventName | WaveEventInput): number;

  off<TEventData>(event: WaveTypedEventInput<TEventData>, handler: TypedEventHandler<TEventData>): void;

  off(event: WaveEventName | string, handler: EventHandler): void;

  offScoped<TEventData>(scopeId: string, event: WaveTypedEventInput<TEventData>, handler: TypedEventHandler<TEventData>): void;

  offScoped(scopeId: string, event: WaveEventName | string, handler: EventHandler): void;

  on<TEventData>(event: WaveTypedEventInput<TEventData>, handler: TypedEventHandler<TEventData>): WaveEventHandler;

  on(event: WaveEventName | string, handler: EventHandler): WaveEventHandler;

  once<TEventData>(event: WaveTypedEventInput<TEventData>, handler: TypedEventHandler<TEventData>): WaveEventHandler;

  once(event: WaveEventName | string, handler: EventHandler): WaveEventHandler;

  onceScoped<TEventData>(scopeId: string, event: WaveTypedEventInput<TEventData>, handler: TypedEventHandler<TEventData>): WaveEventHandler;

  onceScoped(scopeId: string, event: WaveEventName | string, handler: EventHandler): WaveEventHandler;

  onScoped<TEventData>(scopeId: string, event: WaveTypedEventInput<TEventData>, handler: TypedEventHandler<TEventData>): WaveEventHandler;

  onScoped(scopeId: string, event: WaveEventName | string, handler: EventHandler): WaveEventHandler;

  setNetworkBridge(bridge: NetworkEventBridge | null): void;

  shutdown(): void;

}

interface WaveEventHandler {

  readonly active: boolean;

  dispose(): void;

  readonly eventName: string;

  readonly scopeId: string;

  stop(): void;

}

declare enum WaveEventName {

  CLIENT_JOINED = "network:client:joined",

  CLIENT_KICKED = "network:client:kicked",

  CLIENT_LEFT = "network:client:left",

  COLLISION_END = "physics:collision:end",

  COLLISION_START = "physics:collision:start",

  ENGINE_START = "engine:start",

  ENGINE_STOP = "engine:stop",

  ENGINE_TICK = "engine:tick",

  ENTITY_CREATED = "entity:created",

  ENTITY_DESTROYED = "entity:destroyed",

  ENTITY_PARENT_CHANGED = "entity:parent:changed",

  ENTITY_REMOVED = "entity:removed",

  INPUT_ACTION = "input:action",

  INTERACTABLE_2D_CANVAS_CLICK = "sensing:interactable2d:canvas:click",

  INTERACTABLE_2D_CANVAS_CURVE_STROKE = "sensing:interactable2d:canvas:curve:stroke",

  INTERACTABLE_2D_CANVAS_POINTER_DOWN = "sensing:interactable2d:canvas:pointerdown",

  INTERACTABLE_2D_CANVAS_POINTER_MOVE = "sensing:interactable2d:canvas:pointermove",

  INTERACTABLE_2D_CANVAS_POINTER_UP = "sensing:interactable2d:canvas:pointerup",

  INTERACTABLE_2D_CLICK = "sensing:interactable2d:click",

  INTERACTABLE_2D_INPUT = "sensing:interactable2d:input",

  INTERACTABLE_2D_SLIDER = "sensing:interactable2d:slider",

  INTERACTABLE_2D_SUBMIT = "sensing:interactable2d:submit",

  INTERACTABLE_2D_TOGGLE = "sensing:interactable2d:toggle",

  INTERACTABLE_CLICK = "sensing:interactable:click",

  NETWORK_CONNECTED = "network:connected",

  NETWORK_CONNECTING = "network:connecting",

  NETWORK_CRITICAL_HEALTH = "network:health:critical",

  NETWORK_DISCONNECTED = "network:disconnected",

  NETWORK_ERROR = "network:error",

  NETWORK_HEALTH_CHANGED = "network:health:changed",

  NETWORK_ONBOARDING = "network:onboarding",

  NETWORK_POOR_HEALTH = "network:health:poor",

  NETWORK_READY = "network:ready",

  NETWORK_RECONNECTING = "network:reconnecting",

  NETWORK_RESUMED = "network:resumed",

  PHYSICS_READY = "physics:ready",

  REMOTE_INPUT_RECEIVED = "network:input:received",

  SCENE_CLEARED = "scene:cleared",

  SCENE_ENTITY_ADDED = "scene:entity:added",

  SCENE_ENTITY_REMOVED = "scene:entity:removed",

  SCENE_GRAPH_UPDATED = "scene:graph:updated",

  SCENE_LOADED = "scene:loaded",

  SCENE_METADATA_UPDATED = "scene:metadata:updated",

  SCENE_UPDATED = "scene:updated",

  SENSING_ACTION = "sensing:action",

  SENSING_INPUT_STATE = "sensing:input:state",

  SENSING_INPUT_TRIGGER = "sensing:input:trigger",

  SENSING_PERMISSIONS_CHANGED = "sensing:permissions:changed",

  SERVER_TICK = "server:tick",

  TERRAIN_HEIGHTFIELD_CHANGED = "terrain:heightfield:changed",

  TERRAIN_HEIGHTFIELD_READY = "terrain:heightfield:ready",

  TERRAIN_READY = "terrain:ready",

  TERRAIN_RUNTIME_RETIRED = "terrain:runtime:retired",

  WATER_READY = "water:ready",

  WORLD_READY = "world:ready",

  WORLD_STATE_RECEIVED = "network:worldstate:received",

  XR_GAZE_ENTER = "sensing:xr:gaze:enter",

  XR_GAZE_EXIT = "sensing:xr:gaze:exit",

  XR_GRAB_END = "sensing:xr:grab:end",

  XR_GRAB_START = "sensing:xr:grab:start",

  XR_POKE = "sensing:xr:poke",

  XR_RAY_ENTER = "sensing:xr:ray:enter",

  XR_RAY_EXIT = "sensing:xr:ray:exit",

  XR_RAY_SELECT = "sensing:xr:ray:select",

}

declare class WaveField extends WaveTriggerVolume {

  constructor(name: string, shape: WaveRangeShape | undefined, syncHelper: WaveRangeHelperSync | undefined, resolveModel: WaveRangeModelResolver | undefined, matchEntity: WaveRangeEntityMatcher | undefined, _resolveTexturePixels: WaveFieldTextureResolver | undefined, queryEntities: WaveTriggerVolumeEntityQuery | undefined, _syncForceVectorHelper: WaveFieldForceVectorHelperSync | undefined, callbackScope: WaveAuthoredCallbackScope);

  affects(...targets: WaveSpatial3DObject[]): this;

  affectsEntity(entity: WaveSpatial3DObject): boolean;

  affectsTag(...tags: string[]): this;

  applyAsAcceleration(): this;

  applyAsForce(): this;

  clearTargets(): this;

  compose(mode: WaveFieldCompositionMode): this;

  get compositionMode(): WaveFieldCompositionMode;

  configure(config: Omit<WaveFieldConfig, "name">): this;

  containsEntity(entity: WaveSpatial3DObject, options?: WaveRangeEntityMatchOptions): boolean;

  get defaultGravityMode(): WaveFieldDefaultGravityMode;

  directionAt(target: WaveSpatial3DObject | WavePointInput): Vector3;

  disposeTriggerObservers(): void;

  get forceVectorsVisible(): boolean;

  hideFieldHelper(): this;

  hideForceVectors(): this;

  get influences(): readonly WaveFieldInfluence[];

  perpendicularAt(target: WaveSpatial3DObject | WavePointInput, options?: WaveFieldTangentOptions): Vector3;

  preserveWorldGravity(): this;

  refreshForceVectors(): this;

  sampleAt(target: WaveSpatial3DObject | WavePointInput, options?: WaveFieldSampleOptions): WaveFieldSample;

  showFieldHelper(options?: WaveFieldHelperOptions): this;

  showForceVectors(options?: WaveFieldForceVectorOptions): this;

  sources(): WaveFieldSourceBuilder;

  suspendWorldGravity(suspend?: boolean): this;

  tangentAt(target: WaveSpatial3DObject | WavePointInput, options?: WaveFieldTangentOptions): Vector3;

  trustNativeSleep(): this;

}

declare const WaveFieldInfluenceKind: { readonly Gravity: "gravity"; readonly Wind: "wind"; readonly VectorField: "vectorField"; readonly Vortex: "vortex"; readonly Buoyancy: "buoyancy"; readonly Radial: "radial"; };

declare class WaveFieldSourceBuilder {

  constructor(_field: WaveField);

  buoyancy(config?: WaveFieldBuoyancySourceConfig): WaveFieldSourceHandle;

  buoyancy(id: string, config?: WaveFieldBuoyancySourceConfig): WaveFieldSourceHandle;

  field(): WaveField;

  gravityWell(config: WaveFieldGravityWellConfig): WaveFieldSourceHandle;

  gravityWell(id: string, config?: WaveFieldGravityWellConfig): WaveFieldSourceHandle;

  heightGradient(config: WaveFieldHeightGradientConfig): WaveFieldSourceHandle;

  heightGradient(id: string, config: WaveFieldHeightGradientConfig): WaveFieldSourceHandle;

  radialPull(config: WaveFieldRadialSourceConfig): WaveFieldSourceHandle;

  radialPull(id: string, config: WaveFieldRadialSourceConfig): WaveFieldSourceHandle;

  radialPush(config: WaveFieldRadialSourceConfig): WaveFieldSourceHandle;

  radialPush(id: string, config: WaveFieldRadialSourceConfig): WaveFieldSourceHandle;

  textureFlow(config: WaveFieldTextureFlowConfig): WaveFieldSourceHandle;

  textureFlow(id: string, config: WaveFieldTextureFlowConfig): WaveFieldSourceHandle;

  vectorGrid(config: WaveFieldVectorGridConfig): WaveFieldSourceHandle;

  vectorGrid(id: string, config: WaveFieldVectorGridConfig): WaveFieldSourceHandle;

  vectorVolume(config: WaveFieldVectorVolumeConfig): WaveFieldSourceHandle;

  vectorVolume(id: string, config: WaveFieldVectorVolumeConfig): WaveFieldSourceHandle;

  vortex(config: WaveFieldVortexSourceConfig): WaveFieldSourceHandle;

  vortex(id: string, config: WaveFieldVortexSourceConfig): WaveFieldSourceHandle;

  wind(config: WaveFieldWindSourceConfig): WaveFieldSourceHandle;

  wind(id: string, config: WaveFieldWindSourceConfig): WaveFieldSourceHandle;

}

declare class WaveFieldSourceHandle {

  constructor(_field: WaveField, _influence: WaveFieldInfluence);

  and(): WaveFieldSourceBuilder;

  applyAsAcceleration(): this;

  applyAsForce(): this;

  coreRadius(radius: number): this;

  damping(damping: number): this;

  done(): WaveField;

  falloff(falloff: WaveFieldVortexFalloff): this;

  gravityConstant(gravityConstant: number): this;

  limit(limit: number): this;

  mass(mass: number): this;

  softCore(radius: number): this;

  strength(strength: number): this;

  toggleLimit(activeLimit: number): this;

}

declare const waveFx: WaveFxWithParametricPath;

declare const waveFxPresets: { impactSparks(opts?: ImpactSparkOptions): WaveFxSystemAsset; rain(opts?: WeatherRainOptions): WaveFxSystemAsset; snow(opts?: WeatherSnowOptions): WaveFxSystemAsset; lightning(opts?: WeatherLightningOptions): WaveFxSystemAsset; };

declare class WaveFxRetainedVolume {

  constructor(id: string, options: WaveFxRetainedVolumeOptions);

  readonly definition: Readonly<FxRetainedVolumeDefinition>;

}

declare abstract class waveGeometry extends waveProp {

  constructor();

  static readonly typeName: EntityType;

  allowMeshDeform(enable?: boolean): this;

  applyUpdatedAssetConfig(): void;

  asSurfaceSource(): WaveSurfaceMeshAssetStructure;

  get baseSideOrientation(): number | null;

  get color(): unknown;

  destroy(): void;

  face(surface: WaveSurface): ReturnType<cmp_visual3DModel["surface"]>;

  faceMaterial(surface: WaveSurface): ReturnType<cmp_visual3DModel["meshMaterialSlot"]>;

  get mesh(): unknown | null;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0]): this;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0], mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0], mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setHighDetail(): this;

  setLowDetail(): this;

  setMediumDetail(): this;

  setVeryHighDetail(): this;

  get updatable(): boolean;

  useGeneratedModel(model: string | { mesh: unknown; name: string; }): this;

  useModel(modelName: Visual3DModelInput, options?: Visual3DModelUseOptions): this;

}

declare class WaveGeometryData {

  static canDeserialize(payload: unknown): payload is { kind: "wave-geometry-data"; version: 3; parts: unknown[]; name?: unknown; coordinateSpace?: unknown; sourceTag?: unknown; pointSetKind?: unknown; metadata?: unknown; }

  static deserialize(payload: unknown): WaveGeometryData;

  static fromParts(parts: readonly WaveGeometryPartData[], options?: WaveGeometryDataOptions, _runtimeContext?: unknown): WaveGeometryData;

  static fromPointSet(points: readonly Vector3Like[] | Float32Array, options?: WaveGeometryDataOptions): WaveGeometryData;

  static fromVertexData(data: WaveVertexDataInput, options?: WaveGeometryDataOptions): WaveGeometryData;

  static fromVoxels(voxels: readonly WaveGeometryVoxelData[], options?: WaveGeometryDataOptions): WaveGeometryData;

  get [WAVE_GEOMETRY_DATA_INSTANCE](): true;

  buildPathSampleCache(options?: WaveGeometryPathOptions): PathSampleCache;

  get coordinateSpace(): WaveGeometryCoordinateSpace;

  dispose(): void;

  getPointSet(): Float32Array | null;

  hasPointSet(): boolean;

  hasVoxels(): boolean;

  get metadata(): Readonly<Record<string, unknown>> | undefined;

  get name(): string | undefined;

  get parts(): readonly WaveGeometryPartData[];

  get pointSetKind(): WaveGeometryPointSetKind;

  resamplePathUniform(sampleCount: number, options?: WaveGeometryPathOptions): Vector3[];

  samplePathAtDistance(distance: number, options?: WaveGeometryPathOptions): PathSamplePoint;

  samplePathAtProgress(progress: number, options?: WaveGeometryPathOptions): PathSamplePoint;

  serialize(): Record<string, unknown>;

  get sourceTag(): string | undefined;

  toPathPoints(options?: WaveGeometryPathOptions): Vector3[];

  toVertexData(options?: WaveGeometryToVertexDataOptions): WaveVertexDataPayload;

  withShadowCaster(intent: WaveShadowCasterIntent): WaveGeometryData;

}

declare const waveGpuContact: Readonly<{ point: WaveVec3Ref; normal: WaveVec3Ref; relativeVelocityWorld: WaveVec3Ref; tangentialRelativeVelocityWorld: WaveVec3Ref; impactSpeed: WaveNumberRef; tangentialSpeed: WaveNumberRef; solverImpulse: WaveNumberRef; impactEnergy: WaveNumberRef; }>;

interface WaveGpuDrivenBoundsInput {

  readonly maximum: WaveGpuDrivenVector3Input;

  readonly minimum: WaveGpuDrivenVector3Input;

  readonly parts?: readonly WaveGpuDrivenPartBoundsInput[];

}

interface WaveGpuDrivenChannelSeedRecipe {

  readonly id: string;

  readonly source: WaveGpuDrivenDataSeedSource;

}

interface WaveGpuDrivenCollisionProxyDataOptions {

  readonly capacity?: number;

}

type WaveGpuDrivenDataSeedSource = WaveGpuDrivenZeroSeedSource | WaveGpuDrivenDeterministicNoiseSeedSource | WaveGpuDrivenProjectPayloadSeedSource;

interface WaveGpuDrivenDeterministicNoiseSeedSource {

  readonly alpha?: number;

  readonly kind: "deterministicNoiseRgba8";

  readonly seed: number;

}

interface WaveGpuDrivenEntitySpatialDataOptions {

  readonly fields: readonly WaveGpuEntitySpatialField[];

}

type WaveGpuDrivenFlexibleResponseAuthoringOptions = Omit<WaveGpuDrivenFlexibleResponseOptions, "stateChannelId" | "skinnedSurface" | "workgroupSize"> & { readonly state: WaveGpuDrivenFlexibleResponseStateOptions; readonly skinnedSurface?: { readonly source?: string; }; }

interface WaveGpuDrivenFlexibleResponseStateOptions {

  readonly height: number;

  readonly id: string;

  readonly sampling?: WaveGpuDrivenDataSampling;

  readonly valueType?: "float16" | "float32";

  readonly width: number;

}

interface WaveGpuDrivenGeometryOptions {

  readonly role: WaveGpuDrivenGeometryRole;

  readonly shadowCaster?: WaveShadowCasterIntent;

}

type WaveGpuDrivenGeometrySource = { readonly kind: "proceduralGeometry"; readonly recipe: WaveProceduralGeometryRecipe; } | WaveGpuDrivenProjectGeometryPackageSource;

declare class WaveGpuDrivenModelBuilder {

  constructor(_id: string);

  apply(): WaveGpuDrivenModelInput;

  bounds(input: WaveGpuDrivenBoundsInput): this;

  collision(policy: WaveGpuDrivenCollisionPolicy): this;

  geometry(recipe: WaveProceduralGeometryRecipe, options: WaveGpuDrivenGeometryOptions): this;

  geometryFromPackage(source: Omit<WaveGpuDrivenProjectGeometryPackageSource, "kind">, options: WaveGpuDrivenGeometryOptions): this;

  picking(policy: WaveGpuDrivenPickingPolicy): this;

  receivesCollisionProxies(options?: WaveGpuDrivenCollisionProxyDataOptions): this;

  receivesEntitySpatialState(options: WaveGpuDrivenEntitySpatialDataOptions): this;

  receivesRelativeCoverage(options?: WaveGpuDrivenRelativeCoverageDataOptions): this;

  receivesSurface(options: WaveGpuDrivenSurfaceDataOptions): this;

  revision(value: number): this;

  sampledData(id: string, options: WaveGpuDrivenSampledDataOptions): this;

  readonly seed: WaveGpuDrivenSeedAuthoring;

  semanticStateKernel(id: string, options: WaveGpuDrivenSemanticStateKernelOptions): this;

  stateKernel(id: string, options: WaveGpuDrivenStateKernelOptions): this;

  technique(input: WaveGpuDrivenTechniqueAuthoringInput): this;

  withFlexibleResponse(response: WaveResponseDefinition, options: WaveGpuDrivenFlexibleResponseAuthoringOptions): this;

  withGeometryFlex(parameters: WaveGeometryFlexParameters): this;

}

type WaveGpuDrivenModelDefinitionRecipe = Pick<WaveGpuDrivenModelDefinition, "revision" | "geometryRole" | "dataChannels" | "stateKernels" | "bounds" | "picking" | "collision" | "technique">;

interface WaveGpuDrivenModelGeometryRecipe {

  readonly role: WaveGpuDrivenGeometryRole;

  readonly shadowCaster?: WaveShadowCasterIntent;

  readonly source: WaveGpuDrivenGeometrySource;

}

type WaveGpuDrivenModelInput = WaveModelInput<WaveGpuDrivenModelRecipe>;

interface WaveGpuDrivenModelRecipe {

  readonly beautyBindingSet: WaveBindingSet;

  readonly channelSeeds: readonly WaveGpuDrivenChannelSeedRecipe[];

  readonly definition: WaveGpuDrivenModelDefinitionRecipe;

  readonly geometry: WaveGpuDrivenModelGeometryRecipe;

  readonly version: typeof WAVE_GPU_DRIVEN_MODEL_RECIPE_VERSION;

}

interface WaveGpuDrivenPartBoundsInput {

  readonly maximum: WaveGpuDrivenVector3Input;

  readonly minimum: WaveGpuDrivenVector3Input;

  readonly partIndex: number;

}

interface WaveGpuDrivenProjectGeometryPackageSource {

  readonly assetId: string;

  readonly importerPath?: string;

  readonly kind: "projectGeometryPackage";

  readonly manifestRef: string;

  readonly manifestSourceHash: string;

  readonly payloads: readonly WaveGpuDrivenProjectGeometryPayloadIdentity[];

}

interface WaveGpuDrivenProjectGeometryPayloadIdentity {

  readonly ref: string;

  readonly sourceHash: string;

}

interface WaveGpuDrivenProjectPayloadSeedSource {

  readonly assetId: string;

  readonly importerPath?: string;

  readonly kind: "projectPayload";

  readonly ref: string;

  readonly sourceHash: string;

}

interface WaveGpuDrivenRelativeCoverageDataOptions {

  readonly layerCapacity?: number;

}

interface WaveGpuDrivenSampledDataOptions {

  readonly access?: WaveGpuDrivenDataAccess;

  readonly authority?: WaveGpuDrivenDataAuthority;

  readonly buffering?: WaveGpuDrivenDataBuffering;

  readonly channels: WaveGpuDrivenDataChannelCount;

  readonly clonePolicy?: WaveGpuDrivenClonePolicy;

  readonly contextRestore?: WaveGpuDrivenContextRestorePolicy;

  readonly height: number;

  readonly initial?: WaveGpuDrivenDataSeedSource;

  readonly readback?: WaveGpuDrivenDataReadback;

  readonly sampler?: string;

  readonly sampling?: WaveGpuDrivenDataSampling;

  readonly scope?: WaveGpuDrivenDataScope;

  readonly valueType: WaveGpuDrivenDataValueType;

  readonly width: number;

  readonly wrapU?: WaveGpuDrivenDataWrap;

  readonly wrapV?: WaveGpuDrivenDataWrap;

}

interface WaveGpuDrivenSeedAuthoring {

  deterministicNoiseRgba8(seed: number, options?: { readonly alpha?: number; }): WaveGpuDrivenDeterministicNoiseSeedSource;

  projectPayload(input: Omit<WaveGpuDrivenProjectPayloadSeedSource, "kind">): WaveGpuDrivenProjectPayloadSeedSource;

  zero(): WaveGpuDrivenZeroSeedSource;

}

type WaveGpuDrivenSemanticStateKernelOptions = Omit<WaveGpuDrivenSemanticKernelInput, "id">;

interface WaveGpuDrivenStateKernelOptions {

  readonly bindings: readonly WaveRetainedComputeKernelBinding[];

  readonly dispatch: readonly [number, number, number];

  readonly updatePolicy?: "everyFrame" | "manual";

  readonly wgsl: string;

}

type WaveGpuDrivenSurfaceDataOptions = { readonly kind: "terrain"; readonly resolution: number | readonly [number, number]; } | { readonly kind: "skinned"; readonly sampleCount: number; readonly boneCapacity: number; }

interface WaveGpuDrivenTechniqueAuthoringInput {

  readonly beauty: WaveShaderMaterialDescriptor;

  readonly modules?: readonly WaveGpuDrivenShaderModule[];

}

declare const waveGpuDrivenValue: Readonly<{ kernel: Readonly<{ uv: WaveVec2Ref; coordinate: WaveVec2Ref; size: WaveVec2Ref; index: WaveNumberRef; deltaSeconds: WaveNumberRef; elapsedSeconds: WaveNumberRef; frameIndex: WaveNumberRef; dispatchIndex: WaveNumberRef; }>; source: Readonly<{ surface: Readonly<{ textureId: "waveSurface"; }>; relativeCoverage: (layerCapacity?: number) => Readonly<{ current: WaveVec4Ref; previous: WaveVec4Ref; }>; collisionProxy: (index?: number, capacity?: number) => Readonly<{ currentCenterRadius: WaveVec4Ref; previousCenter: WaveVec4Ref; }>; entitySpatialState: (fields: readonly WaveGpuEntitySpatialField[]) => Readonly<{ field(field: WaveGpuEntitySpatialField): WaveVec4Ref; }>; skinnedSurface: Readonly<{ availabilityAt(rowUv: WaveNumberAuthoringInput): WaveNumberRef; }>; }>; program: () => WaveValueProgramBuilder; }>;

type WaveGpuDrivenVector3Input = readonly [number, number, number] | { readonly x: number; readonly y: number; readonly z: number; }

interface WaveGpuDrivenZeroSeedSource {

  readonly kind: "zero";

}

declare class WaveGrassMaterial {

  apply(): WaveMaterialInput<"grass">;

  readonly name: string;

  private(key?: string): this;

  shared(): this;

  constructor(name: string, options?: WaveGrassMaterialOptions);

  blade(width: number, height: number, heightVariation?: number): this;

  colors(base: number, tip?: number, shade?: number): this;

  configure(options: WaveGrassMaterialOptions): this;

  coverage(size: number): this;

  denseLikeInfiniteWorld(): this;

  detail(bladesPerAxis: number): this;

  fade(start: number, end: number): this;

  fieldRefresh(distance: number, intervalMs?: number): this;

  get options(): Readonly<WaveGrassMaterialOptions>;

  sampleResolution(resolution: number): this;

  slopeFade(start: number, end: number): this;

  get state(): Readonly<WaveGrassMaterialOptions>;

  urbanPerformance(): this;

  variant(name: string, options?: WaveGrassMaterialOptions): WaveGrassMaterial;

  wind(strength: number, scale?: number, speed?: number): this;

}

interface WaveGrassMaterialOptions {

  alphaCutoff?: number;

  baseColor?: number;

  bladeHeight?: number;

  bladeHeightVariation?: number;

  bladeWidth?: number;

  coverageSize?: number;

  detail?: number;

  fadeEnd?: number;

  fadeStart?: number;

  farTintAlpha?: number;

  farTintCoverageMultiplier?: number;

  farTintEnd?: number;

  farTintStart?: number;

  farTintSubdivisions?: number;

  farTintYOffset?: number;

  fieldUpdateDistance?: number;

  fieldUpdateIntervalMs?: number;

  positionJitter?: number;

  sampleResolution?: number;

  shadeColor?: number;

  slopeFadeEnd?: number;

  slopeFadeStart?: number;

  tipColor?: number;

  windScale?: number;

  windSpeed?: number;

  windStrength?: number;

}

type WaveGridLineStyle = "solid" | "dotted" | "dashed";

declare class WaveGridMaterial {

  apply(): WaveMaterialInput<"grid">;

  readonly name: string;

  private(key?: string): this;

  shared(): this;

  constructor(name: string, options?: WaveGridMaterialOptions);

  axisHighlight(enabled: boolean): this;

  backgroundColor(color: WaveMaterialColorInput): this;

  configure(options: WaveGridMaterialOptions): this;

  directIntensity(value: number): this;

  environmentIntensity(value: number): this;

  fadeDistance(distance: number): this;

  gridColor(color: WaveMaterialColorInput): this;

  gridSize(primary: number, secondary?: number): this;

  lineStyle(style: WaveGridLineStyle): this;

  lineWidths(primary: number, secondary?: number): this;

  metallic(value: number): this;

  get options(): Readonly<Required<WaveGridMaterialOptions>>;

  primaryGridSize(size: number): this;

  primaryLineColor(color: WaveMaterialColorInput): this;

  roughness(value: number): this;

  secondaryGridSize(size: number): this;

  secondaryLineColor(color: WaveMaterialColorInput): this;

  setAxisHighlight(enabled: boolean): this;

  setBackgroundColor(color: WaveMaterialColorInput): this;

  setGridSize(primary: number, secondary?: number): this;

  setLineStyle(style: WaveGridLineStyle): this;

  setLineWidths(primary: number, secondary?: number): this;

  setPrimaryGridSize(size: number): this;

  setPrimaryLineColor(color: WaveMaterialColorInput): this;

  setSecondaryGridSize(size: number): this;

  setSecondaryLineColor(color: WaveMaterialColorInput): this;

  setXAxisColor(color: WaveMaterialColorInput): this;

  setZAxisColor(color: WaveMaterialColorInput): this;

  get state(): Readonly<Required<WaveGridMaterialOptions>>;

  variant(name: string, options?: WaveGridMaterialOptions): WaveGridMaterial;

  xAxisColor(color: WaveMaterialColorInput): this;

  zAxisColor(color: WaveMaterialColorInput): this;

}

interface WaveGridMaterialOptions {

  axisHighlight?: boolean;

  backgroundColor?: WaveMaterialColorInput;

  directIntensity?: number;

  environmentIntensity?: number;

  fadeDistance?: number;

  lineStyle?: WaveGridLineStyle;

  metallic?: number;

  primaryGridSize?: number;

  primaryLineColor?: WaveMaterialColorInput;

  primaryLineWidth?: number;

  roughness?: number;

  secondaryGridSize?: number;

  secondaryLineColor?: WaveMaterialColorInput;

  secondaryLineWidth?: number;

  xAxisColor?: WaveMaterialColorInput;

  zAxisColor?: WaveMaterialColorInput;

}

declare class WaveGroup<T extends WaveSpatial3DObject = WaveSpatial3DObject> {

  constructor(name: string, controller?: NoInfer<T> | wave3DObject, scene?: WaveGroupSceneBridge);

  [Symbol.iterator](): Iterator<T>;

  add(...members: T[]): this;

  at(index: number): T | undefined;

  attractTo(point: WavePointInput | WaveSpatial3DObject, strength?: number): this;

  avoidCollisionWith(...targets: (WaveGroup | wave3DObject)[]): this;

  avoidCollisionWithinGroup(): this;

  bakeIntoProp(name?: string, cleanupMode?: bakIntoPropPolicy): waveProp;

  clearCollisionRuleWith(...targets: (WaveGroup | wave3DObject)[]): this;

  get collisionBitMask(): number;

  get controller(): T | wave3DObject;

  destroyAllMembers(): void;

  disablePhysics(options?: DisablePhysicsOptions): this;

  dispose(): void;

  enableCollisionWith(...targets: (WaveGroup | wave3DObject)[]): this;

  enableCollisionWithinGroup(): this;

  enableGravity(factor?: number): this;

  enablePhysics(options?: EnablePhysicsOptions): this;

  every(fn: (member: T, index: number, array: T[]) => boolean): boolean;

  expelFrom(point: WavePointInput | WaveSpatial3DObject, strength?: number): this;

  explode(strength?: number): this;

  filter(fn: (member: T, index: number, array: T[]) => boolean): T[];

  find(fn: (member: T, index: number, array: T[]) => boolean): T | undefined;

  findIndex(fn: (member: T, index: number, array: T[]) => boolean): number;

  forEach(fn: (member: T, index: number, array: T[]) => void): void;

  getAABB(): { min: Vector3; max: Vector3; }

  getAABBCenter(): Vector3;

  getAABBSize(): Vector3;

  getAggregateVolumeSnapshot(): WaveRangeAabbShape | null;

  ignoreGravity(): this;

  implode(strength?: number): this;

  includes(member: T): boolean;

  indexOf(member: T): number;

  keepControllerCentered(offset?: Vector3Like): this;

  get length(): number;

  map<R>(fn: (member: T, index: number, array: T[]) => R): R[];

  get members(): readonly T[];

  get name(): string;

  recenterController(offset?: Vector3Like): this;

  reduce<R>(fn: (acc: R, member: T, index: number, array: T[]) => R, initial: R): R;

  refreshAggregateVolumeSnapshot(): this;

  remove(member: T): boolean;

  setControllerAsGroupParent(enabled?: boolean): this;

  get size(): number;

  snapshotAggregateVolume(): this;

  some(fn: (member: T, index: number, array: T[]) => boolean): boolean;

  spawnInto(factory: (index: number) => T, count: number): T[];

  stopKeepingControllerCentered(): this;

  toArray(): T[];

}

declare class WaveGroupCollection<T extends WaveSpatial3DObject = WaveSpatial3DObject, TController extends WaveSpatial3DObject = T | wave3DObject> {

  constructor(name: string, controller?: TController, scene?: WaveGroupSceneBridge);

  add(...members: T[]): this;

  at(index: number): T | undefined;

  clearMembers(): void;

  get controller(): TController;

  dispose(): void;

  getAABB(): { min: Vector3; max: Vector3; }

  includes(member: T): boolean;

  members(): readonly T[];

  get name(): string;

  remove(member: T): boolean;

  setControllerAsGroupParent(enabled?: boolean): this;

  get size(): number;

}

interface WaveHardSurfaceAnchorOptions {

  readonly at: WaveModelVec3Tuple | Readonly<Vector3Like>;

  readonly kind?: WaveModelAnchorMetadata["kind"];

  readonly metadata?: WaveProceduralModelMetadata;

  readonly name?: string;

  readonly on: string;

  readonly rotation?: WaveModelVec3Tuple | Readonly<Vector3Like>;

}

interface WaveHardSurfaceAssemblyOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly mode?: "preserveChildren" | "mergeCompatible" | "coordinatedGroups";

}

interface WaveHardSurfaceBlockOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly center?: Readonly<Vector3Like>;

  readonly segments?: { readonly x?: number; readonly y?: number; readonly z?: number; }

  readonly size: Readonly<Vector3Like>;

}

interface WaveHardSurfaceCollisionOptions {

  readonly geometry: WaveHardSurfaceNodeRef;

  readonly metadata?: WaveProceduralModelMetadata;

  readonly on: string;

}

interface WaveHardSurfaceCylinderOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly along: DirectionInput;

  readonly cap?: WaveCapMode;

  readonly center?: Readonly<Vector3Like>;

  readonly length: number;

  readonly radialSegments?: number;

  readonly radius: number;

}

interface WaveHardSurfaceExternalOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly bounds: WaveHardSurfaceBounds;

  readonly estimatedTriangles: number;

  readonly estimatedVertices: number;

  readonly operator: string;

  readonly parameters: Readonly<Record<string, SerializableDataValue>>;

}

interface WaveHardSurfaceHollowTubeOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly along: DirectionInput;

  readonly center?: Readonly<Vector3Like>;

  readonly end?: WaveHardSurfaceTubeEnd;

  readonly innerRadius: number;

  readonly length: number;

  readonly outerRadius: number;

  readonly radialSegments?: number;

}

interface WaveHardSurfaceLatheOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly along?: DirectionInput;

  readonly arcFraction?: number;

  readonly cap?: WaveCapMode;

  readonly profile: readonly { readonly x: number; readonly y: number; }[];

  readonly radialSegments?: number;

  readonly radius?: number;

}

interface WaveHardSurfaceLinearPatternOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly along: DirectionInput;

  readonly count: number;

  readonly spacing?: number;

  readonly spacingCurve?: WaveValueCurveInput;

}

interface WaveHardSurfaceLoftOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

}

declare class WaveHardSurfaceModelBuilder {

  constructor(id: string);

  anchor(id: string, options: WaveHardSurfaceAnchorOptions): this;

  apply(): WaveHardSurfaceModelInput;

  collision(id: string, options: WaveHardSurfaceCollisionOptions): this;

  finish(options: Partial<WaveHardSurfaceFinishSpec>): this;

  metadata(value: SerializableDataValue): this;

  optimize(options: Partial<WaveHardSurfaceOptimizeSpec>): this;

  part(id: string, root: WaveHardSurfaceNodeRef, options?: WaveHardSurfacePartOptions): this;

  provider(intent: WaveHardSurfaceProviderIntent): this;

  readonly recipe: Readonly<WaveHardSurfaceRecipeBuilder>;

  surface(id: string, options: WaveHardSurfaceSurfaceOptions): this;

  toConfig(): WaveProceduralModelRecipe;

  useMaterial(targetId: string, material: WaveProceduralMaterialInput, options?: WaveProceduralMaterialAssignmentOptions): this;

  withLOD(lodGraph: WaveModelLODGraphMetadata): this;

}

type WaveHardSurfaceModelInput = WaveProceduralModelInput;

interface WaveHardSurfacePartOptions {

  readonly metadata?: WaveProceduralModelMetadata;

  readonly name?: string;

  readonly parent?: string | null;

}

interface WaveHardSurfacePathPatternOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly closed?: boolean;

  readonly count?: number;

  readonly facing?: "path" | "fixed";

  readonly path: WaveProceduralPathInput;

  readonly samples?: number;

  readonly space?: WaveGeometryCoordinateSpace;

  readonly spacing?: number;

}

interface WaveHardSurfacePrismCorners {

  readonly bottomLeft?: WaveHardSurfacePrismTreatment;

  readonly bottomRight?: WaveHardSurfacePrismTreatment;

  readonly topLeft?: WaveHardSurfacePrismTreatment;

  readonly topRight?: WaveHardSurfacePrismTreatment;

}

interface WaveHardSurfacePrismOptions {

  readonly back?: WaveHardSurfacePrismTreatment;

  readonly corners?: WaveHardSurfacePrismCorners;

  readonly front?: WaveHardSurfacePrismTreatment;

  readonly holes?: readonly WaveProfile2DRecipe[];

  readonly regions: WaveHardSurfacePrismRegions;

  readonly role?: string;

  readonly size: Readonly<Vector3Like>;

}

interface WaveHardSurfacePrismRegions {

  readonly back: string;

  readonly edges: string;

  readonly front: string;

  readonly holes: string;

  readonly sides: string;

}

type WaveHardSurfacePrismTreatment = { readonly chamfer: number; readonly fillet?: never; readonly segments?: 1; } | { readonly chamfer?: never; readonly fillet: number; readonly segments?: 1 | 2; }

interface WaveHardSurfaceProfileExtrusionOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly along: DirectionInput;

  readonly center?: Readonly<Vector3Like>;

  readonly depth: number;

  readonly holes?: readonly WaveProfile2DRecipe[];

  readonly profile: WaveProfile2DRecipe;

}

interface WaveHardSurfaceRadialPatternOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly angle: number;

  readonly around: DirectionInput;

  readonly count: number;

  readonly radius: number;

}

declare class WaveHardSurfaceRecipeBuilder {

  align(source: WaveHardSurfaceNodeRef, options: { readonly from: DirectionInput; readonly to: DirectionInput; }): WaveHardSurfaceNodeRef;

  assembly(children: readonly WaveHardSurfaceNodeRef[], options?: WaveHardSurfaceAssemblyOptions): WaveHardSurfaceNodeRef;

  block(options: WaveHardSurfaceBlockOptions): WaveHardSurfaceNodeRef;

  cylinder(options: WaveHardSurfaceCylinderOptions): WaveHardSurfaceNodeRef;

  external(options: WaveHardSurfaceExternalOptions): WaveHardSurfaceNodeRef;

  hollowTube(options: WaveHardSurfaceHollowTubeOptions): WaveHardSurfaceNodeRef;

  intersection(children: readonly WaveHardSurfaceNodeRef[], options?: WaveHardSurfaceSemanticOptions): WaveHardSurfaceNodeRef;

  lathe(options: WaveHardSurfaceLatheOptions): WaveHardSurfaceNodeRef;

  loft(recipe: WaveLoftGeometryInput | WaveLoftGeometryRecipe, options?: WaveHardSurfaceLoftOptions): WaveHardSurfaceNodeRef;

  mirror(source: WaveHardSurfaceNodeRef, options: WaveHardSurfaceSemanticOptions & { readonly normal: DirectionInput; readonly offset?: number; }): WaveHardSurfaceNodeRef;

  prism(options: WaveHardSurfacePrismOptions): WaveHardSurfaceNodeRef;

  readonly profile: WaveProfile2DBuilder;

  profileExtrusion(options: WaveHardSurfaceProfileExtrusionOptions): WaveHardSurfaceNodeRef;

  repeatAlong(source: WaveHardSurfaceNodeRef, options: WaveHardSurfacePathPatternOptions): WaveHardSurfaceNodeRef;

  repeatLinear(source: WaveHardSurfaceNodeRef, options: WaveHardSurfaceLinearPatternOptions): WaveHardSurfaceNodeRef;

  repeatRadial(source: WaveHardSurfaceNodeRef, options: WaveHardSurfaceRadialPatternOptions): WaveHardSurfaceNodeRef;

  roundedBlock(options: WaveHardSurfaceRoundedBlockOptions): WaveHardSurfaceNodeRef;

  subtract(base: WaveHardSurfaceNodeRef, cutters: readonly WaveHardSurfaceNodeRef[], options?: WaveHardSurfaceSemanticOptions): WaveHardSurfaceNodeRef;

  sweep(options: WaveHardSurfaceSweepOptions): WaveHardSurfaceNodeRef;

  toRecipe(root: WaveHardSurfaceNodeRef, options: WaveHardSurfaceRecipeOptions): WaveHardSurfaceGeometryRecipe;

  transform(source: WaveHardSurfaceNodeRef, transform: TransformSnapshotLike): WaveHardSurfaceNodeRef;

  tube(options: WaveHardSurfaceTubeOptions): WaveHardSurfaceNodeRef;

  union(children: readonly WaveHardSurfaceNodeRef[], options?: WaveHardSurfaceSemanticOptions): WaveHardSurfaceNodeRef;

}

interface WaveHardSurfaceRecipeOptions {

  readonly defaultRegionId: string;

  readonly finish?: Partial<WaveHardSurfaceFinishSpec> & { readonly bevel?: WaveHardSurfaceBevelSpec; }

  readonly metadata?: SerializableDataValue;

  readonly optimize?: Partial<WaveHardSurfaceOptimizeSpec>;

  readonly provider?: WaveHardSurfaceProviderIntent;

}

interface WaveHardSurfaceRoundedBlockOptions extends WaveHardSurfaceBlockOptions {

  readonly bevelSegments?: number;

  readonly cornerRadius: number;

}

interface WaveHardSurfaceSurfaceOptions {

  readonly aliases?: readonly string[];

  readonly localNormalHint?: WaveModelVec3Tuple | Readonly<Vector3Like>;

  readonly metadata?: WaveProceduralModelMetadata;

  readonly name?: string;

  readonly parts: readonly string[];

  readonly region?: string;

  readonly selectors?: readonly WaveModelSurfaceSelectorDescriptor[];

}

interface WaveHardSurfaceSweepOptions {

  readonly regionId?: string | undefined;

  readonly role?: string | undefined;

  readonly cap?: WaveCapMode;

  readonly closed?: boolean;

  readonly frame?: WaveProceduralFrameInput;

  readonly path: WaveProceduralPathInput;

  readonly profile: WaveProfile2DRecipe;

  readonly profileSamples?: number;

  readonly progressions?: WaveSectionProgressionsInput;

  readonly samples?: number;

}

type WaveHardSurfaceTubeEnd = { readonly kind: "flat"; } | { readonly kind: "crowned"; readonly depth: number; }

interface WaveHardSurfaceTubeOptions extends WaveHardSurfaceCylinderOptions {

  readonly innerRadius?: number;

}

declare class waveHumanoid extends waveKinematicActor {

  constructor(modelAsset?: Visual3DModelInput);

  static readonly typeName: EntityType;

  get boneTransforms(): Map<HumanoidBone, TransformNode> | null;

}

declare class waveInstanceGroup extends InstanceMeshGroup {

  constructor(name: string, controller?: WaveSpatial3DObject | wave3DObject, scene?: WaveGroupSceneBridge);

  castToProp(index: number, options?: CastToPropOptions): waveProp;

  get controller(): WaveSpatial3DObject | wave3DObject;

  dispose(): void;

  getAABB(): { min: Vector3; max: Vector3; }

  get name(): string;

  setAmount(count: number): this;

  setControllerAsGroupParent(enabled?: boolean): this;

  get size(): number;

}

declare class waveInstanceMesh extends wave3DAbstract {

  constructor(config?: InstanceMeshConfig);

  static readonly typeName: EntityType;

  addComponent<T extends WaveComponent>(componentClassOrInstance: ComponentConstructor<T> | T, ...args: unknown[]): T | null;

  castShadows(enabled?: boolean): this;

  castToProp(options?: CastToPropOptions): waveProp;

  createVertexAnimation(name: string, options: CreateVertexAnimationOptions): string;

  disableGlow(): this;

  enableGlow(intensity?: number, color?: ColorInput | null): this;

  get hasSensing(): boolean;

  get instanceAnimator(): cmp_instanceAnimator;

  get instanceMesh(): cmp_instanceMesh;

  get interactable(): cmp_3dInteractable<this>;

  get isVisible(): boolean;

  keepActiveWhenOffscreen(enabled?: boolean): this;

  onDrag(callback: InteractionDragCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  onDragMove(options?: InteractionDragMoveOptions): InteractionDragMoveHandle<this>;

  onDragMove(callback: InteractionDragMoveCallback<this>, options?: InteractionDragMoveOptions): InteractionDragMoveHandle<this>;

  playVertexAnimation(assetName: string, options?: VertexAnimationPlayOptions): this;

  playVertexAnimation(options?: VertexAnimationPlayOptions): this;

  get sensing(): cmp_sensing<this>;

  setColor(color: ColorInput, alpha?: number): this;

  setGlowIntensity(intensity: number): this;

  setVertexAnimationTime(seconds: number): this;

  setVisible(visible: boolean): this;

  useModel(model: string | AssetRef<"model"> | WaveModelInput): this;

  useVertexAnimation(assetName: string, rangeName?: string): this;

  whenBackClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenBackHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenBackHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenBackPressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenBackReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenForwardClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenForwardHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenForwardHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenForwardPressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenForwardReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenHoverEnteredOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenHoverExitedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenHoveringOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenLeftClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenLeftHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenLeftHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenLeftPressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenLeftReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenMiddleClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenMiddleHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenMiddleHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenMiddlePressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenMiddleReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenPressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenRightClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenRightHoldingOn(callback: InteractionCallback<this>, holdThreshold?: WaveTimeSpan, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenRightHoldingOn(callback: InteractionCallback<this>, value: number, unit: WaveTimeUnit, options?: Omit<InteractionCallbackOptions, "holdThreshold">): CallbackHandle;

  whenRightPressedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenRightReleasedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenTouchedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

}

declare class waveKinematicActor<TState = unknown> extends wave3DObject<TState> {

  constructor(modelAsset?: Visual3DModelInput);

  static readonly typeName: EntityType;

  get animator(): cmp_modelAnimator;

  asFlight(config?: KinematicFlightActorConfig): KinematicFlightActorBuilder<waveKinematicActor<unknown>>;

  asHumanoid(config?: KinematicHumanoidActorConfig): KinematicHumanoidActorBuilder<waveKinematicActor<unknown>>;

  asVehicle(config?: KinematicVehicleActorConfig): KinematicVehicleActorBuilder<waveKinematicActor<unknown>>;

  get audio(): cmp_audio;

  get camera(): cmp_camera;

  can(capabilityId: string): WaveActorCapabilityBuilder<this>;

  can<TParameters extends WaveChoiceParameters>(choice: WaveChoiceInput<TParameters>): WaveActorCapabilityBuilder<this, TParameters>;

  can(capabilityId: string, runner: WaveActorCapabilityRunner<this>): this;

  can<TParameters extends WaveChoiceParameters>(choice: WaveChoiceInput<TParameters>, runner: WaveActorCapabilityRunner<this, TParameters>): this;

  can(capabilityId: string, options: WaveActorCapabilityShortcutOptions<this>): this;

  can<TParameters extends WaveChoiceParameters>(choice: WaveChoiceInput<TParameters>, options: WaveActorCapabilityShortcutOptions<this, TParameters>): this;

  decisionState(decision?: WaveActorDecision<this> | string): ActorDecisionState | null;

  get facingDirection(): Vector3Like;

  get fx(): FxFacade;

  getMovementSnapshot(options: KinematicActorMovementSnapshotOptions): KinematicActorMovementSnapshot;

  get groundState(): KinematicActorGroundState;

  get hasAnimator(): boolean;

  get hasAudio(): boolean;

  get hasCamera(): boolean;

  get hasInteractable(): boolean;

  get hasKinematicController(): boolean;

  get hasLight(): boolean;

  get hasMovementController(): boolean;

  get hasSensing(): boolean;

  get hasThinking(): boolean;

  get horizontalSpeed(): number;

  get interactable(): cmp_3dInteractable<this>;

  get isAirborne(): boolean;

  get isGrounded(): boolean;

  get isJumping(): boolean;

  get isMoving(): boolean;

  get isSliding(): boolean;

  get kinematicController(): cmp_kinematicController<this>;

  kinematicSupportState(): KinematicSupportState;

  kinematicTranslationState(): KinematicTranslationState;

  learnFromOutcomes(options?: WaveActorLearningOptions): WaveActorLearningBuilder<this>;

  get light(): cmp_light;

  llmDecisionState(decision: WaveActorDecision<this> | string): ThinkingLLMDecisionState | null;

  llmReplyState(decision: WaveActorDecision<this> | string): ThinkingLLMReplyState | null;

  makeDecisionFromChat(userMessage: string, options?: WaveActorDecisionOptions): WaveActorDecisionBuilder<this>;

  makeDecisionFromPrompt(prompt: string, options?: WaveActorDecisionOptions): WaveActorDecisionBuilder<this>;

  get movementController(): cmp_movementController<this>;

  get movementSnapshot(): KinematicActorMovementSnapshot;

  movesFasterThan(speedThreshold: number): boolean;

  get physicsBody(): cmp_physicsBody<this>;

  predictionState(): ThinkingPredictionState | null;

  ragdoll(options?: WaveSkeletalRagdollOptions): this;

  recoverFromRagdoll(options?: WaveSkeletalRecoveryOptions): WaveSkeletalRecoveryResult | null;

  rememberOutcomes(options?: WaveOutcomeMemoryOptions): this;

  replyAsCharacterTo(userMessage: string, options?: WaveActorDecisionOptions & { speech?: WaveSpeakTextOptions; reply?: WaveActorDecisionReplyOptions; }): WaveActorDecision<this>;

  reportOutcomeOf(capabilityId: string, summary: string, options?: WaveActorReportOutcomeOptions): this;

  respondAsCharacterTo(userMessage: string, options?: WaveActorDecisionOptions & { choose?: readonly string[] | WaveActorDecisionMenu; reply?: WaveActorDecisionReplyOptions; }): WaveActorDecision<this>;

  get sensing(): cmp_sensing<this>;

  speak(text: string, options?: WaveSpeakTextOptions): WaveSpeechPlaybackHandle;

  speakAsCharacter(directive: string, options?: WaveActorDecisionOptions & { speech?: WaveSpeakTextOptions; reply?: WaveActorDecisionReplyOptions; }): WaveActorDecision<this>;

  speakWith(backend: WaveTTSBackend): this;

  speechState(): AudioSpeechState | null;

  get speed(): number;

  get thinking(): cmp_thinking<this>;

  thinkWith(backend: WaveLLMBackend): this;

  useAnimationAuthority(recoveryOptions?: WaveSkeletalRecoveryOptions): this;

  useCharacter(character: WaveCharacter | WaveCharacterSnapshot): this;

  usePhysicalAnimation(options?: WaveSkeletalPhysicalAnimationOptions): this;

  get velocity(): Vector3Like;

  get verticalSpeed(): number;

}

declare class waveLathe extends waveGeometry {

  configureGeometry(configuration: WaveLathePrimitiveRecipe | WavePrimitiveGeometryConfiguration<WaveLathePrimitiveRecipe>): this;

  primitiveRecipe: WaveLathePrimitiveRecipe;

  constructor(radius?: number, tessellation?: number, shape?: LatheShapeInput, arc?: number);

  static readonly typeName: EntityType;

  get arc(): number;

  asLathe(radius: number, tessellation?: number, shape?: LatheShapeInput, arc?: number): this;

  get baseBackUVs(): unknown | null;

  get baseCap(): number;

  get baseFrontUVs(): unknown | null;

  get baseRadius(): number;

  clearBaseBackUVs(): this;

  clearBaseFrontUVs(): this;

  get radius(): number;

  setArc(arc: number): this;

  setBaseArc(arc: number): this;

  setBaseBackUVs(backUVs: unknown): this;

  setBaseCap(cap: WaveCapMode | LatheCap | number): this;

  setBaseFrontUVs(frontUVs: unknown): this;

  setBaseRadius(radius: number): this;

  setBaseSegments(segments: number): this;

  setBaseShape(shape: LatheShapeInput): this;

  setBaseShapePath(path: wavePath): this;

  setBaseSideOrientation(sideOrientation: number): this;

  setConfig(config: WaveLatheConfig): this;

  setShape(shape: LatheShapeInput): this;

  get shape(): Vector3[];

  get shapeInput(): LatheShapeInput;

  get tessellation(): number;

  toConfig(): WaveLatheConfig;

}

declare const waveLife3d: Readonly<{ murmuration: (requestedId: string, options?: WaveLife3dMurmurationOptions) => WaveLife3dSystemAsset; trailOrganism: (requestedId: string, options?: WaveLife3dTrailOrganismOptions) => WaveLife3dSystemAsset; hybrid: (requestedId: string, options?: WaveLife3dHybridOptions) => WaveLife3dSystemAsset; }>;

type WaveLife3dAppearance = WaveLife3dSpriteAppearance | WaveLife3dMeshAppearance;

interface WaveLife3dBounds {

  readonly center: WaveLife3dVector3;

  readonly halfExtents: WaveLife3dVector3;

}

interface WaveLife3dColor {

  readonly a?: number;

  readonly b: number;

  readonly g: number;

  readonly r: number;

}

interface WaveLife3dHybridOptions {

  readonly appearance?: WaveLife3dAppearance;

  readonly bounds?: WaveLife3dBounds;

  readonly densityCohesion?: number;

  readonly depositRadius?: number;

  readonly depositStrength?: number;

  readonly fieldDecay?: number;

  readonly fieldDiffusion?: number;

  readonly fieldResolution?: number;

  readonly fieldRetention?: number;

  readonly flowAlignment?: number;

  readonly maximumCandidates?: number;

  readonly maximumCells?: number;

  readonly maximumSpeed?: number;

  readonly maximumTurnRate?: number;

  readonly minimumSpeed?: number;

  readonly neighborRange?: number;

  readonly neighbors?: number;

  readonly population?: number;

  readonly separation?: number;

  readonly separationRadius?: number;

  readonly speedConvergence?: number;

}

interface WaveLife3dMeshAppearance {

  readonly blend?: "additive" | "alpha" | "multiply";

  readonly color?: WaveLife3dColor;

  readonly depthWrite?: boolean;

  readonly kind: "mesh";

  readonly meshAsset: string;

  readonly scale?: number;

}

interface WaveLife3dMurmurationOptions {

  readonly alignment?: number;

  readonly appearance?: WaveLife3dAppearance;

  readonly bounds?: WaveLife3dBounds;

  readonly cohesion?: number;

  readonly maximumCandidates?: number;

  readonly maximumCells?: number;

  readonly maximumSpeed?: number;

  readonly maximumTurnRate?: number;

  readonly minimumSpeed?: number;

  readonly neighborRange?: number;

  readonly neighbors?: number;

  readonly population?: number;

  readonly rearBlindAngleDegrees?: number;

  readonly separation?: number;

  readonly separationRadius?: number;

  readonly speedConvergence?: number;

}

interface WaveLife3dSpriteAppearance {

  readonly billboard?: "all" | "y" | "none" | "stretched";

  readonly blend?: "additive" | "alpha" | "multiply";

  readonly color?: WaveLife3dColor;

  readonly depthWrite?: boolean;

  readonly kind?: "sprite";

  readonly size?: number;

  readonly texture?: string;

}

type WaveLife3dSystemAsset = ReturnType<typeof waveFx.system>;

interface WaveLife3dTrailOrganismOptions {

  readonly appearance?: WaveLife3dAppearance;

  readonly bounds?: WaveLife3dBounds;

  readonly depositRadius?: number;

  readonly depositStrength?: number;

  readonly fieldDecay?: number;

  readonly fieldDiffusion?: number;

  readonly fieldResolution?: number;

  readonly fieldRetention?: number;

  readonly maximumSpeed?: number;

  readonly maximumTurnRate?: number;

  readonly minimumSpeed?: number;

  readonly population?: number;

  readonly sensorForwardBias?: number;

  readonly sensorForwardOffset?: number;

  readonly sensorLateralOffset?: number;

  readonly sensorStrength?: number;

  readonly sensorTurn?: number;

  readonly speedConvergence?: number;

}

interface WaveLife3dVector3 {

  readonly x: number;

  readonly y: number;

  readonly z: number;

}

declare class waveLight extends waveProp {

  constructor();

  static readonly typeName: EntityType;

  aimAt(target: WavePointInput): this;

  aimAt(x: number, y: number, z: number): this;

  asAreaLight(): this;

  asDirectionalLight(): this;

  asHemisphericLight(): this;

  asPointLight(): this;

  asSpotlight(): this;

  clearProjection(): this;

  disableCausticOverlay(): this;

  disableColoredShadow(): this;

  disableLightBeam(): this;

  disableShadow(): this;

  disableVolumetricLight(): this;

  enableCausticOverlay(): this;

  enableColoredShadow(): this;

  enableLightBeam(): this;

  enableRipple(): this;

  enableShadow(options?: ShadowOptions): this;

  enableVolumetricLight(config?: Omit<LightVolumetricConfig, "enabled">): this;

  enableWobble(): this;

  excludeObjects(...objects: LightInfluenceObject[]): this;

  hideDirection(): this;

  hideHelpers(): this;

  hidePosition(): this;

  keepLookingAt(target: TransformReferenceLike | WavePointInput, options?: WaveLookAtOptions): this;

  lerpGradientTo(newStops: GradientColorStop[], duration: WaveTimeSpan): this;

  lerpGradientTo(newStops: GradientColorStop[], value: number, unit: WaveTimeUnit): this;

  lightBeam(config: LightBeamConfig): this;

  projectCausticPattern(): this;

  projectCustom(fragmentShader: string): this;

  projectGobo(mask: GoboPreset | string): this;

  projectGradient(colorStops: GradientColorStop[]): this;

  projectImage(source: string): this;

  projectNoise(algorithm: "perlin" | "simplex" | "voronoi" | "worley" | "fbm", colorRamp: GradientColorStop[]): this;

  projectPattern(pattern: "stripes" | "grid" | "dots" | "chevron" | "hexGrid" | "radialBurst" | "concentricRings"): this;

  projectSpotlightCone(): this;

  projectVideo(source: string): this;

  setAngle(angle: number): this;

  setAngle(angle: number, mode: typeof Snapshot): WavePropertySnapshot;

  setAngle(angle: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  setAreaEmissionTexture(texture: AreaLightEmissionTextureInput | null, options?: AreaLightEmissionTextureOptions): this;

  setAreaSize(width: number, height: number): this;

  setDiffuseColor(color: ColorInput): this;

  setDirection(direction: DirectionInput | Vector3): this;

  setDirection(x: number, y: number, z: number): this;

  setExponent(exponent: number): this;

  setGroundColor(color: ColorInput): this;

  setInnerAngle(innerAngle?: number): this;

  setInnerAngle(innerAngle: number, mode: typeof Snapshot): WavePropertySnapshot;

  setInnerAngle(innerAngle: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  setIntensity(intensity: number): this;

  setIntensity(intensity: number, mode: typeof Snapshot): WavePropertySnapshot;

  setIntensity(intensity: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  setLightColor(color: ColorInput): this;

  setLightColor(color: ColorInput, mode: typeof Snapshot): WavePropertySnapshot;

  setLightColor(color: ColorInput, mode: typeof Animate): WavePropertyAnimationBuilder;

  setLightOffset(offset: WavePointInput | TransformReferenceLike): this;

  setLightOffset(offset: WavePointInput | TransformReferenceLike, mode: typeof Snapshot): WavePropertySnapshot;

  setLightOffset(offset: WavePointInput | TransformReferenceLike, mode: typeof Animate): WavePropertyAnimationBuilder;

  setLightOffset(x: number, y: number, z: number): this;

  setProjectionCaustic(config: CausticOverlayConfig): this;

  setProjectionPreset(preset: ProjectionContent): this;

  setProjectionRange(near: number, far: number): this;

  setProjectionSoftEdge(amount: number): this;

  setRadius(radius: number): this;

  setRange(range: number): this;

  setRange(range: number, mode: typeof Snapshot): WavePropertySnapshot;

  setRange(range: number, mode: typeof Animate): WavePropertyAnimationBuilder;

  setSpecularColor(color: ColorInput): this;

  setTarget(target: WavePointInput): this;

  setTarget(x: number, y: number, z: number): this;

  setVolumetricLight(config?: LightVolumetricConfig): this;

  setWobbleInput(dirX: number, dirY: number): this;

  showDirection(): this;

  showHelpers(): this;

  showPosition(): this;

  toggle(): this;

  triggerRipple(u?: number, v?: number, strength?: number): this;

  turnOff(): this;

  turnOn(): this;

  use(type: LightType): this;

  withBeamColor(color: ColorInput): this;

  withBeamEndRadius(radius: number): this;

  withBeamIntensity(intensity: number): this;

  withBeamLength(length: number): this;

  withBeamNoiseIntensity(intensity: number): this;

  withBeamNoiseScale(scale: number): this;

  withBeamNoiseVelocity(x: number, y: number, z: number): this;

  withBeamOpacity(opacity: number): this;

  withBeamShape(shape: "cone" | "cylinder"): this;

  withBeamSideThickness(thickness: number): this;

  withBeamSourceRadius(radius: number): this;

  withCausticChromaticAberration(enabled: boolean): this;

  withCausticColor(color: ColorInput): this;

  withCausticIntensity(intensity: number): this;

  withCausticOctaves(octaves: number): this;

  withCausticScale(scale: number): this;

  withCausticSpeed(speed: number): this;

  withConeColor(color: ColorInput): this;

  withConeFalloff(exponent: number): this;

  withConeInnerRadius(radius: number): this;

  withConePulseSpeed(speed: number): this;

  withConeRimColor(color: ColorInput): this;

  withConeTemperatureDrift(speed: number): this;

  withGoboColor(color: ColorInput): this;

  withGoboRotation(radians: number): this;

  withGoboRotationSpeed(speed: number): this;

  withGoboScale(scale: number): this;

  withGoboSoftness(softness: number): this;

  withGradientAnimation(mode: GradientAnimationMode): this;

  withGradientDirection(direction: "horizontal" | "vertical" | "radial" | "angular"): this;

  withGradientNoiseIntensity(intensity: number): this;

  withGradientNoiseScale(scale: number): this;

  withGradientSoftEdge(softEdge: number): this;

  withGradientSpeed(speed: number): this;

  withMediaBrightness(brightness: number): this;

  withMediaLoop(loop: boolean): this;

  withMediaPlaybackRate(rate: number): this;

  withMediaTint(color: ColorInput): this;

  withNoiseFrequency(frequency: number): this;

  withNoiseOctaves(octaves: number): this;

  withNoiseSeed(seed: number): this;

  withNoiseSpeed(speed: number): this;

  withNoiseTurbulence(turbulence: number): this;

  withOverlayBlurRadius(radius: number): this;

  withOverlayIntensity(intensity: number): this;

  withOverlayIOR(ior: number): this;

  withOverlayResolution(resolution: number): this;

  withOverlaySoftEdge(softEdge: number): this;

  withPatternBackground(color: ColorInput): this;

  withPatternColor(color: ColorInput): this;

  withPatternDensity(density: number): this;

  withPatternPulseSpeed(speed: number): this;

  withPatternRotation(radians: number): this;

  withPatternScrollSpeed(speed: number): this;

  withPatternThickness(thickness: number): this;

  withProjectionRange(near: number, far: number): this;

  withProjectionResolution(resolution: number): this;

  withProjectionSoftEdge(amount: number): this;

  withRippleFrequency(frequency: number): this;

  withRippleMaxDisplacement(displacement: number): this;

  withRippleSpatialDecay(decay: number): this;

  withRippleSpeed(speed: number): this;

  withRippleTemporalDecay(decay: number): this;

  withShaderUniform(name: string, value: number | number[] | ColorInput): this;

  withShadowResolution(resolution: number): this;

  withShadowTransmittedAlpha(alpha: number): this;

  withShadowTransmittedColor(color: ColorInput): this;

  withWobbleFrequency(frequency: number): this;

  withWobbleMaxDisplacement(displacement: number): this;

  withWobbleSmoothing(smoothing: number): this;

  withWobbleSpeed(speed: number): this;

}

declare class WaveLightingZone extends WaveTriggerVolume {

  constructor(name: string, shape: WaveRangeShape | undefined, syncHelper: WaveRangeHelperSync | undefined, resolveModel: WaveRangeModelResolver | undefined, matchEntity: WaveRangeEntityMatcher | undefined, queryEntities: WaveTriggerVolumeEntityQuery | undefined, onLightingZoneRuntimeRevision: WaveLightingZoneRuntimeRevisionListener | undefined, callbackScope: WaveAuthoredCallbackScope);

  addInternalLight(...lights: waveLight[]): this;

  affectContents(enabled?: boolean): this;

  allowExternalLighting(enabled?: boolean): this;

  blockExternalLighting(): this;

  clearInternalLights(): this;

  configure(config: Omit<WaveLightingZoneConfig, "name">): this;

  containsEntity(entity: WaveSpatial3DObject, options?: WaveRangeEntityMatchOptions): boolean;

  containsInternalLight(entity: WaveSpatial3DObject, options?: WaveRangeEntityMatchOptions): boolean;

  disable(): this;

  enable(enabled?: boolean): this;

  externalDirectIntensity(value: number): this;

  externalEnvironmentIntensity(value: number): this;

  internalAmbient(color: ColorInput, intensity: number): this;

  get internalLightEntityIds(): readonly number[];

  maxExternalLights(value: number | null): this;

  maxInternalLights(value: number | null): this;

  membership(mode: WaveLightingZoneMembershipMode): this;

  get policy(): WaveLightingZoneResolvedPolicy;

  priority(value: number): this;

  removeInternalLight(...lights: waveLight[]): this;

  setInternalLightEntityIds(entityIds: readonly number[]): this;

  setPolicy(policy: WaveLightingZonePolicy): this;

  setSourceEntityId(entityId: number | null | undefined): this;

  get sourceEntityId(): number | null;

}

interface WaveLoftAlongOptions {

  readonly closed?: boolean;

}

declare class WaveLoftModelBuilder {

  constructor(id: string);

  along(path: WaveProceduralPathInput, options?: WaveLoftAlongOptions): this;

  apply(): WaveLoftModelInput;

  cap(mode: WaveLoftGeometryRecipe["cap"]): this;

  frame(spec: WaveProceduralFrameInput): this;

  metadata(value: SerializableDataValue): this;

  offset(curves: WaveLoftOffsetInput): this;

  readonly profile: WaveProfile2DBuilder;

  profileSamples(samples: number): this;

  scale(curves: WaveLoftScaleInput): this;

  section(section: Omit<WaveLoftSectionInput, "progress"> & { readonly at: Vector3Like; }): this;

  sectionAt(progress: number, sectionProfile: WaveProfile2DRecipe, options?: WaveLoftSectionAtOptions): this;

  surface(regionId: string): this;

  toConfig(): WaveLoftGeometryRecipe;

  twist(curve: WaveValueCurveInput): this;

  uv(options: WaveLoftUvOptions): this;

}

type WaveLoftModelInput = WaveProceduralModelInput;

interface WaveLoftOffsetInput {

  readonly binormal?: WaveValueCurveInput;

  readonly normal?: WaveValueCurveInput;

}

interface WaveLoftScaleInput {

  readonly x?: WaveValueCurveInput;

  readonly y?: WaveValueCurveInput;

}

type WaveLoftSectionAtOptions = Omit<WaveLoftSectionInput, "progress" | "at" | "profile">;

declare class waveMarker extends wave3DObject {

  constructor(model?: string);

  static setMarkerScale(scale?: number): void;

  static readonly typeName: EntityType;

  asMarker(model?: string): this;

  followFxAnchor(target: WaveMarkerTarget, anchor: WaveFxAnchorBinding, options?: WaveMarkerFollowOptions): this;

  followLocalPoint(target: WaveMarkerTarget, name: string, options?: WaveMarkerFollowOptions): this;

  followLocator(builder: WaveLocatorBuilder, options?: WaveMarkerFollowOptions): this;

  followWorldPosition(position: WavePointInput, options?: WaveMarkerFollowOptions): this;

  freezeLocator(): this;

  setModelScale(scale: number): this;

  setScaleFromBase(scale?: number): this;

  setWorldSize(size: number): this;

}

declare const waveMaterial: { buildGrass(id: string, options?: WaveGrassMaterialOptions): WaveGrassMaterial; buildGrid(id: string, options?: WaveGridMaterialOptions): WaveGridMaterial; buildPBR(id: string, options?: WavePBRMaterialOptions): WavePBRMaterial; buildPBRModifier(id: string, recipe?: WavePbrModifierRecipe): WavePbrModifier; buildPBRModifier(id: string, build: WavePbrModifierBuild): WavePbrModifier; readonly buildPBRModifierPreset: WavePbrModifierBuildPresetAuthoring; readonly buildPreset: WaveMaterialBuildPresetAuthoring; buildProceduralPBR(id: string): WaveProceduralPBRMaterial; buildProceduralPBR(id: string, recipe: WaveProceduralPBRRecipe): WaveProceduralPBRMaterial; buildProceduralPBR(id: string, build: WaveProceduralPBRBuild): WaveProceduralPBRMaterial; buildShader(id: string, definition: WaveShaderMaterialRecipe | WaveShaderMaterialDescriptor): WaveShaderMaterial; buildSplat(id: string): WaveSplatMaterial; buildStandard(id: string, options?: WaveStandardMaterialOptions): WaveStandardMaterial; buildWater(id: string, options?: WaveWaterMaterialAuthoringOptions): WaveWaterMaterial; createGrass(id: string, options?: WaveGrassMaterialOptions, author?: (builder: WaveGrassMaterial) => void): WaveMaterialInput<"grass">; createGrid(id: string, options?: WaveGridMaterialOptions, author?: (builder: WaveGridMaterial) => void): WaveMaterialInput<"grid">; createPBR(id: string, options?: WavePBRMaterialOptions, author?: (builder: WavePBRMaterial) => void): WaveMaterialInput<"pbr">; createPBRModifier(id: string, recipe: WavePbrModifierRecipe): WavePbrModifierRecipe; createPBRModifier(id: string, build: WavePbrModifierBuild): WavePbrModifierRecipe; readonly createPBRModifierPreset: WavePbrModifierCreatePresetAuthoring; readonly createPreset: WaveMaterialCreatePresetAuthoring; createProceduralPBR(id: string): WaveMaterialInput<"proceduralPbr">; createProceduralPBR(id: string, recipe: WaveProceduralPBRRecipe): WaveMaterialInput<"proceduralPbr">; createProceduralPBR(id: string, build: WaveProceduralPBRBuild): WaveMaterialInput<"proceduralPbr">; createShader(id: string, definition: WaveShaderMaterialRecipe | WaveShaderMaterialDescriptor, author?: (builder: WaveShaderMaterial) => void): WaveMaterialInput<"shader" | "wgslShader">; createSplat(id: string, author: (builder: WaveSplatMaterial) => void): WaveMaterialInput<"splat">; createStandard(id: string, options?: WaveStandardMaterialOptions, author?: (builder: WaveStandardMaterial) => void): WaveMaterialInput<"standard">; createWater(id: string, options?: WaveWaterMaterialAuthoringOptions, author?: (builder: WaveWaterMaterial) => void): WaveMaterialInput<"water">; readonly edit: WaveMaterialEditAuthoring };

interface WaveMaterialAntiTilingHexOptions {

  readonly contrast?: number;

  readonly exponent?: number;

  readonly fallOffContrast?: number;

  readonly rotationStrength?: number;

}

type WaveMaterialAntiTilingMode = "noiseBlend" | "hexTiling" | "tileRandomization" | "voronoiBombing";

interface WaveMaterialAntiTilingOptions {

  readonly hexTiling?: WaveMaterialAntiTilingHexOptions;

  readonly mode?: WaveMaterialAntiTilingMode;

}

interface WaveMaterialAuthoring {

  buildGrass(id: string, options?: WaveGrassMaterialOptions): WaveGrassMaterial;

  buildGrid(id: string, options?: WaveGridMaterialOptions): WaveGridMaterial;

  buildPBR(id: string, options?: WavePBRMaterialOptions): WavePBRMaterial;

  buildPBRModifier(id: string, recipe?: WavePbrModifierRecipe): WavePbrModifier;

  buildPBRModifier(id: string, build: WavePbrModifierBuild): WavePbrModifier;

  readonly buildPBRModifierPreset: WavePbrModifierBuildPresetAuthoring;

  readonly buildPreset: WaveMaterialBuildPresetAuthoring;

  buildProceduralPBR(id: string): WaveProceduralPBRMaterial;

  buildProceduralPBR(id: string, recipe: WaveProceduralPBRRecipe): WaveProceduralPBRMaterial;

  buildProceduralPBR(id: string, build: WaveProceduralPBRBuild): WaveProceduralPBRMaterial;

  buildShader(id: string, definition: WaveShaderMaterialRecipe | WaveShaderMaterialDescriptor): WaveShaderMaterial;

  buildSplat(id: string): WaveSplatMaterial;

  buildStandard(id: string, options?: WaveStandardMaterialOptions): WaveStandardMaterial;

  buildWater(id: string, options?: WaveWaterMaterialAuthoringOptions): WaveWaterMaterial;

  createGrass(id: string, options?: WaveGrassMaterialOptions, author?: (builder: WaveGrassMaterial) => void): WaveMaterialInput<"grass">;

  createGrid(id: string, options?: WaveGridMaterialOptions, author?: (builder: WaveGridMaterial) => void): WaveMaterialInput<"grid">;

  createPBR(id: string, options?: WavePBRMaterialOptions, author?: (builder: WavePBRMaterial) => void): WaveMaterialInput<"pbr">;

  createPBRModifier(id: string, recipe: WavePbrModifierRecipe): WavePbrModifierRecipe;

  createPBRModifier(id: string, build: WavePbrModifierBuild): WavePbrModifierRecipe;

  readonly createPBRModifierPreset: WavePbrModifierCreatePresetAuthoring;

  readonly createPreset: WaveMaterialCreatePresetAuthoring;

  createProceduralPBR(id: string): WaveMaterialInput<"proceduralPbr">;

  createProceduralPBR(id: string, recipe: WaveProceduralPBRRecipe): WaveMaterialInput<"proceduralPbr">;

  createProceduralPBR(id: string, build: WaveProceduralPBRBuild): WaveMaterialInput<"proceduralPbr">;

  createShader(id: string, definition: WaveShaderMaterialRecipe | WaveShaderMaterialDescriptor, author?: (builder: WaveShaderMaterial) => void): WaveMaterialInput<"shader" | "wgslShader">;

  createSplat(id: string, author: (builder: WaveSplatMaterial) => void): WaveMaterialInput<"splat">;

  createStandard(id: string, options?: WaveStandardMaterialOptions, author?: (builder: WaveStandardMaterial) => void): WaveMaterialInput<"standard">;

  createWater(id: string, options?: WaveWaterMaterialAuthoringOptions, author?: (builder: WaveWaterMaterial) => void): WaveMaterialInput<"water">;

  readonly edit: WaveMaterialEditAuthoring;

}

interface WaveMaterialBuildPresetAuthoring {

  brushedMetal(id: string, options?: WaveMaterialFinishPresetOptions): WavePBRMaterial;

  camouflage(id: string, options?: WaveCamouflageMaterialPresetOptions): WaveProceduralPBRMaterial;

  chrome(id: string, options?: WaveMaterialFinishPresetOptions): WavePBRMaterial;

  coatedSteel(id: string, options?: WaveMaterialPresetOptions): WaveProceduralPBRMaterial;

  concrete(id: string, options?: WaveMaterialPresetOptions): WaveProceduralPBRMaterial;

  cordura(id: string, options?: WaveMaterialPresetOptions): WaveProceduralPBRMaterial;

  emissive(id: string, options?: WaveMaterialFinishPresetOptions): WavePBRMaterial;

  frostedGlass(id: string, options?: WaveMaterialFinishPresetOptions): WavePBRMaterial;

  glass(id: string, options?: WaveMaterialFinishPresetOptions): WavePBRMaterial;

  gloss(id: string, options?: WaveMaterialFinishPresetOptions): WavePBRMaterial;

  matte(id: string, options?: WaveMaterialFinishPresetOptions): WavePBRMaterial;

  metal(id: string, options?: WaveMaterialFinishPresetOptions): WavePBRMaterial;

  plaster(id: string, options?: WaveMaterialPresetOptions): WaveProceduralPBRMaterial;

  plastic(id: string, options?: WaveMaterialFinishPresetOptions): WavePBRMaterial;

  rubber(id: string, options?: WaveMaterialPresetOptions): WaveProceduralPBRMaterial;

  satin(id: string, options?: WaveMaterialFinishPresetOptions): WavePBRMaterial;

  toon(id: string, options?: WaveMaterialFinishPresetOptions): WavePBRMaterial;

}

type WaveMaterialColorInput = ColorInput | string | [number, number, number];

type WaveMaterialCreatePresetAuthoring = Readonly<{ [TKey in keyof WaveMaterialBuildPresetAuthoring]: AppliedPreset<WaveMaterialBuildPresetAuthoring[TKey]>; }>;

interface WaveMaterialFbmOptions extends WaveMaterialNoiseOptions {

  readonly gain?: number;

  readonly lacunarity?: number;

  readonly noise?: "value" | "gradient" | "ridged";

  readonly octaves?: number;

}

declare class WaveMaterialField<TType extends WaveMaterialFieldValueType> {

  constructor(owner: FieldOwner, id: string, valueType: TType);

  readonly id: string;

  toRef(): WaveMaterialFieldRef<TType>;

  readonly valueType: TType;

}

declare class WaveMaterialFieldBuilder {

  constructor(nodes?: readonly WaveMaterialFieldNode[], onMutation?: () => void);

  abs(input: WaveScalarFieldInput): WaveScalarField;

  add(left: WaveScalarFieldInput, right: WaveScalarFieldInput): WaveScalarField;

  addColor(left: WaveColorFieldInput, right: WaveColorFieldInput): WaveColorField;

  atan2(y: WaveScalarFieldInput, x: WaveScalarFieldInput): WaveScalarField;

  blendNormals(base: WaveNormalFieldInput, detail: WaveNormalFieldInput, amount?: WaveScalarFieldInput): WaveNormalField;

  brick(options?: { readonly coordinates?: WaveVector2FieldInput; readonly columns?: number; readonly rows?: number; readonly mortar?: number; readonly stagger?: number; readonly softness?: number; }): WaveScalarField;

  cavityFromHeight(height: WaveScalarFieldInput, options?: { readonly radius?: number; readonly strength?: number; }): WaveScalarField;

  cellular(options: WaveMaterialNoiseOptions): WaveScalarField;

  channel(color: WaveColorFieldInput, channel: "r" | "g" | "b" | "a" | "luminance"): WaveScalarField;

  checker(options?: { readonly coordinates?: WaveVector2FieldInput; readonly scaleX?: number; readonly scaleY?: number; }): WaveScalarField;

  clamp(input: WaveScalarFieldInput, min: number, max: number): WaveScalarField;

  color(value: ColorInputAlpha): WaveColorField;

  colorParameter(parameterId: string, defaultValue: ColorInputAlpha): WaveColorField;

  colorRamp(input: WaveScalarFieldInput, stops: readonly WaveMaterialColorRampStop[]): WaveColorField;

  component(vector: WaveMaterialField<"vector2" | "vector3" | "normal">, component: "x" | "y" | "z"): WaveScalarField;

  constant(value: number): WaveScalarField;

  curve(input: WaveScalarFieldInput, curve: WaveValueCurveInput): WaveScalarField;

  externalInput(inputId: string, options?: { readonly coordinates?: WaveVector2FieldInput; readonly channel?: "r" | "g" | "b" | "a"; }): WaveScalarField;

  externalInput(inputId: string, options: { readonly coordinates?: WaveVector2FieldInput; readonly channel: "rgba"; }): WaveColorField;

  externalInput(inputId: string, options?: { readonly coordinates?: WaveVector2FieldInput; readonly channel?: "rgba" | "r" | "g" | "b" | "a"; }): WaveColorField | WaveScalarField;

  fbm(options: WaveMaterialFbmOptions): WaveScalarField;

  fract(input: WaveScalarFieldInput): WaveScalarField;

  gradientNoise(options: WaveMaterialNoiseOptions): WaveScalarField;

  grid(options?: { readonly coordinates?: WaveVector2FieldInput; readonly scaleX?: number; readonly scaleY?: number; readonly lineWidth?: number; readonly softness?: number; }): WaveScalarField;

  handle<TType extends WaveMaterialFieldValueType>(ref: WaveMaterialFieldRef<TType>): WaveMaterialField<TType>;

  incomingBaseColor(): WaveColorField;

  max(left: WaveScalarFieldInput, right: WaveScalarFieldInput): WaveScalarField;

  min(left: WaveScalarFieldInput, right: WaveScalarFieldInput): WaveScalarField;

  mix(from: WaveScalarFieldInput, to: WaveScalarFieldInput, amount: WaveScalarFieldInput): WaveScalarField;

  mixColor(from: WaveColorFieldInput, to: WaveColorFieldInput, amount: WaveScalarFieldInput): WaveColorField;

  multiply(left: WaveScalarFieldInput, right: WaveScalarFieldInput): WaveScalarField;

  negate(input: WaveScalarFieldInput): WaveScalarField;

  normalFromHeight(height: WaveScalarFieldInput, options?: { readonly strength?: number; }): WaveNormalField;

  normalMap(color: WaveColorFieldInput, options?: { readonly strength?: number; }): WaveNormalField;

  objectNormal(): WaveNormalField;

  objectPosition(): WaveVector3Field;

  offset2(vector: WaveVector2FieldInput, offset: { readonly x?: WaveScalarFieldInput; readonly y?: WaveScalarFieldInput; }): WaveVector2Field;

  offset3(vector: WaveVector3FieldInput, offset: { readonly x?: WaveScalarFieldInput; readonly y?: WaveScalarFieldInput; readonly z?: WaveScalarFieldInput; }): WaveVector3Field;

  power(base: WaveScalarFieldInput, exponent: WaveScalarFieldInput): WaveScalarField;

  projection(): WaveVector2Field;

  refs(): ReadonlyMap<string, WaveMaterialFieldRef>;

  remap(input: WaveScalarFieldInput, inputMin: number, inputMax: number, outputMin: number, outputMax: number, options?: { readonly clamp?: boolean; }): WaveScalarField;

  ridged(options: WaveMaterialNoiseOptions): WaveScalarField;

  safeDivide(numerator: WaveScalarFieldInput, denominator: WaveScalarFieldInput, options?: { readonly epsilon?: number; readonly fallback?: number; }): WaveScalarField;

  saturate(input: WaveScalarFieldInput): WaveScalarField;

  scalarParameter(parameterId: string, defaultValue: number): WaveScalarField;

  scale2(vector: WaveVector2FieldInput, scale: WaveScalarFieldInput): WaveVector2Field;

  scale3(vector: WaveVector3FieldInput, scale: WaveScalarFieldInput): WaveVector3Field;

  scaleColor(color: WaveColorFieldInput, scale: WaveScalarFieldInput): WaveColorField;

  simplexFbm3D(options: WaveMaterialSimplexFbm3DOptions): WaveScalarField;

  sine(input: WaveScalarFieldInput): WaveScalarField;

  smoothStep(edge0: number, edge1: number, input: WaveScalarFieldInput): WaveScalarField;

  sqrt(input: WaveScalarFieldInput): WaveScalarField;

  stripes(options: { readonly coordinates?: WaveVector2FieldInput; readonly frequency: number; readonly width?: number; readonly rotationRadians?: number; readonly softness?: number; }): WaveScalarField;

  subtract(left: WaveScalarFieldInput, right: WaveScalarFieldInput): WaveScalarField;

  texture(textureRef: string, options?: WaveMaterialFieldTextureSampleOptions & { readonly coordinates?: WaveVector2FieldInput; }): WaveColorField | WaveScalarField;

  time(): WaveScalarField;

  toNodes(): readonly WaveMaterialFieldNode[];

  toRef<TType extends WaveMaterialFieldValueType>(field: WaveMaterialField<TType>, type: TType, subject: string): WaveMaterialFieldRef<TType>;

  uv(): WaveVector2Field;

  valueNoise(options: WaveMaterialNoiseOptions): WaveScalarField;

  worldNormal(): WaveNormalField;

  worldPosition(): WaveVector3Field;

}

interface WaveMaterialFieldColorValue {

  readonly a: number;

  readonly b: number;

  readonly g: number;

  readonly r: number;

}

type WaveMaterialFieldNode = WaveMaterialScalarConstantNode | WaveMaterialColorConstantNode | WaveMaterialScalarParameterNode | WaveMaterialTimeNode | WaveMaterialColorParameterNode | WaveMaterialCoordinateNode | WaveMaterialVectorComponentNode | WaveMaterialVector2OffsetNode | WaveMaterialVector2ScaleNode | WaveMaterialVector3OffsetNode | WaveMaterialVector3ScaleNode | WaveMaterialIncomingBaseColorNode | WaveMaterialScalarUnaryNode | WaveMaterialScalarBinaryNode | WaveMaterialScalarClampNode | WaveMaterialScalarRemapNode | WaveMaterialScalarSmoothStepNode | WaveMaterialScalarMixNode | WaveMaterialColorMixNode | WaveMaterialColorScaleNode | WaveMaterialColorAddNode | WaveMaterialColorChannelNode | WaveMaterialNoiseNode | WaveMaterialFbmNode | WaveMaterialSimplexFbm3DNode | WaveMaterialStripesNode | WaveMaterialCheckerNode | WaveMaterialGridNode | WaveMaterialBrickNode | WaveMaterialCurveNode | WaveMaterialTextureSampleNode | WaveMaterialExternalInputSampleNode | WaveMaterialNormalMapNode | WaveMaterialNormalFromHeightNode | WaveMaterialCavityFromHeightNode | WaveMaterialNormalBlendNode;

interface WaveMaterialFieldRef<TType extends WaveMaterialFieldValueType = WaveMaterialFieldValueType> {

  readonly id: string;

  readonly valueType: TType;

}

interface WaveMaterialFieldTextureSampleOptions {

  readonly channel?: "rgba" | "r" | "g" | "b" | "a";

  readonly colorSpace?: "srgb" | "linear";

  readonly wrapU?: "repeat" | "clamp" | "mirror";

  readonly wrapV?: "repeat" | "clamp" | "mirror";

}

type WaveMaterialFieldValueType = "scalar" | "color" | "vector2" | "vector3" | "normal";

interface WaveMaterialFinishPresetOptions {

  readonly color?: ColorInput;

}

interface WaveMaterialInput<TKind extends WaveMaterialInputKind = WaveMaterialInputKind> {

  readonly contentHash: string;

  readonly id: string;

  readonly kind: TKind;

  readonly recipe: SerializableDataValue;

  readonly revision: string;

  readonly schema: typeof WAVE_MATERIAL_INPUT_SCHEMA;

  readonly sharing: WaveMaterialInputSharing;

}

type WaveMaterialInputKind = "pbr" | "standard" | "shader" | "wgslShader" | "proceduralPbr" | "grid" | "grass" | "water" | "splat";

type WaveMaterialInputSharing = { readonly mode: "shared"; } | { readonly mode: "private"; readonly key: string; }

interface WaveMaterialNoiseOptions {

  readonly coordinates?: WaveVector2FieldInput;

  readonly scale: number;

  readonly seed: number;

}

interface WaveMaterialParameterDeclaration {

  readonly defaultValue: WavePbrModifierParameterValue;

  readonly id: string;

  readonly valueType: "scalar" | "color";

}

interface WaveMaterialPresetOptions {

  readonly color?: ColorInputAlpha;

  readonly scale?: number;

  readonly seed?: number;

}

declare class WaveMaterialPropertyAnimationBuilder {

  constructor(_playImpl: (config: TransformVerbAnimationConfig) => TransitionLifecycleHandle<Record<string, number>>);

  after(duration: WaveTimeSpan): this;

  after(value: number, unit: WaveTimeUnit): this;

  atRateOf(rate: WaveRate): this;

  atRateOf(value: number, unit: WaveRateUnit): this;

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  play(): TransitionLifecycleHandle<Record<string, number>>;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): this;

  withCallbacks(callbacks: TransitionLifecycleCallbacks<Record<string, number>>, options?: WaveAuthoredCallbackOptions): this;

  withEasingEffect(ease: WaveEasing): this;

  withProgressCurve(curve: WaveValueCurveInput): this;

}

declare const waveModel: { build3DText(id: string, text: string): WaveModel3DTextBuilder; buildCavity(id: string): WaveCavityModelBuilder; buildGpuDrivenModel(id: string): WaveGpuDrivenModelBuilder; buildHardSurface(id: string): WaveHardSurfaceModelBuilder; buildLoft(id: string): WaveLoftModelBuilder; buildPrefab<TFamily extends WaveOfficialPrefabFamily>(id: string, prefab: WaveOfficialPrefab<TFamily>): WaveOfficialPrefabBuilderMap[TFamily]; buildProceduralModel(id: string): WaveProceduralModelBuilder; buildSdfSurface(id: string): SdfSurfaceAssetBuilder<WaveSdfSurfaceModelInput>; buildTerrainHeightfield(id: string, preset: TerrainPreset): WaveTerrainHeightfieldModelBuilder; buildWorldText(id: string, text: string): WaveModelWorldTextBuilder; create3DText(id: string, text: string, author?: (builder: WaveModel3DTextBuilder) => WaveModel3DTextBuilder): WaveModelInput<Wave3DTextModelRecipe>; createCavity(id: string, author: (builder: WaveCavityModelBuilder) => void): WaveCavityModelInput; createGpuDrivenModel(id: string, author: (builder: WaveGpuDrivenModelBuilder) => void): WaveGpuDrivenModelInput; createHardSurface(id: string, author: (builder: WaveHardSurfaceModelBuilder) => void): WaveHardSurfaceModelInput; createLoft(id: string, author: (builder: WaveLoftModelBuilder) => void): WaveLoftModelInput; createPrefab<TFamily extends WaveOfficialPrefabFamily>(id: string, prefab: WaveOfficialPrefab<TFamily>, configure?: (builder: WaveOfficialPrefabBuilderMap[TFamily]) => WaveOfficialPrefabBuilderMap[TFamily]): WaveModelInput; createProceduralModel(id: string, author: (builder: WaveProceduralModelBuilder) => void): WaveProceduralModelInput; createSdfSurface(id: string, author: (builder: SdfSurfaceAssetBuilder<WaveSdfSurfaceModelInput>) => void): WaveSdfSurfaceModelInput; createTerrainHeightfield(id: string, preset: TerrainPreset, author?: (builder: WaveTerrainHeightfieldModelBuilder) => void): WaveTerrainHeightfieldModelInput; createWorldText(id: string, text: string, author: (builder: WaveModelWorldTextBuilder) => WaveModelWorldTextBuilder): WaveModelInput<WaveWorldTextModelRecipe>; derive(input: WaveProceduralModelInput, newId: string): WaveProceduralModelDerivationBuilder; derive<TRecipe>(input: WaveModelInput<TRecipe>, newId: string): WaveModelDerivationBuilder<TRecipe>; part(model: WaveModelInput, partId: string): WaveModelPartRef; buildBox(id: string, options: WavePrimitiveModelOptions<"box">): WaveProceduralModelBuilder; buildCapsule(id: string, options: WavePrimitiveModelOptions<"capsule">): WaveProceduralModelBuilder; buildCone(id: string, options: WavePrimitiveModelOptions<"cone">): WaveProceduralModelBuilder; buildCylinder(id: string, options: WavePrimitiveModelOptions<"cylinder">): WaveProceduralModelBuilder; buildDisc(id: string, options: WavePrimitiveModelOptions<"disc">): WaveProceduralModelBuilder; buildLathe(id: string, options: WavePrimitiveModelOptions<"lathe">): WaveProceduralModelBuilder; buildPlane(id: string, options: WavePrimitiveModelOptions<"plane">): WaveProceduralModelBuilder; buildPolygon(id: string, options: WavePrimitiveModelOptions<"polygon">): WaveProceduralModelBuilder; buildPrimitive(id: string, recipe: WavePrimitiveGeometryInput): WaveProceduralModelBuilder; buildSphere(id: string, options: WavePrimitiveModelOptions<"sphere">): WaveProceduralModelBuilder; buildTorus(id: string, options: WavePrimitiveModelOptions<"torus">): WaveProceduralModelBuilder; buildTorusKnot(id: string, options: WavePrimitiveModelOptions<"torusKnot">): WaveProceduralModelBuilder; buildWedge(id: string, options: WavePrimitiveModelOptions<"wedge">): WaveProceduralModelBuilder; createBox(id: string, options: WavePrimitiveModelOptions<"box">): WaveProceduralModelInput; createCapsule(id: string, options: WavePrimitiveModelOptions<"capsule">): WaveProceduralModelInput; createCone(id: string, options: WavePrimitiveModelOptions<"cone">): WaveProceduralModelInput; createCylinder(id: string, options: WavePrimitiveModelOptions<"cylinder">): WaveProceduralModelInput; createDisc(id: string, options: WavePrimitiveModelOptions<"disc">): WaveProceduralModelInput; createLathe(id: string, options: WavePrimitiveModelOptions<"lathe">): WaveProceduralModelInput; createPlane(id: string, options: WavePrimitiveModelOptions<"plane">): WaveProceduralModelInput; createPolygon(id: string, options: WavePrimitiveModelOptions<"polygon">): WaveProceduralModelInput; createPrimitive(id: string, recipe: WavePrimitiveGeometryInput): WaveProceduralModelInput; createSphere(id: string, options: WavePrimitiveModelOptions<"sphere">): WaveProceduralModelInput; createTorus(id: string, options: WavePrimitiveModelOptions<"torus">): WaveProceduralModelInput; createTorusKnot(id: string, options: WavePrimitiveModelOptions<"torusKnot">): WaveProceduralModelInput; createWedge(id: string, options: WavePrimitiveModelOptions<"wedge">): WaveProceduralModelInput };

interface WaveModel3DTextBuilder {

  align(align: NonNullable<Wave3DTextOptionsRecipe["align"]>): WaveModel3DTextBuilder;

  alongPath(path: Wave3DTextPathInput): WaveModel3DTextBuilder;

  apply(): WaveModelInput<Wave3DTextModelRecipe>;

  useFont(font: Wave3DTextFontInput): WaveModel3DTextBuilder;

  withCharacterSpacing(spacing: number): WaveModel3DTextBuilder;

  withColor(color: ColorInput): WaveModel3DTextBuilder;

  withDepth(depth: number): WaveModel3DTextBuilder;

  withResolution(resolution: number): WaveModel3DTextBuilder;

  withSize(size: number): WaveModel3DTextBuilder;

}

declare class WaveModelAnimatorTimelineBuilder {

  constructor(_name: string, _rigPoseHost: WaveRigAnimationTimelineHost, _transformHost: WaveTransformTimelineHost);

  animates(target: cmp_transform): WaveTransformSnapshotTimelineBuilder;

  animates(target: cmp_rig): WaveRigAnimationTimelineBuilder;

}

type WaveModelDeclarationUse = "exclusive" | "reusable";

interface WaveModelDerivationBuilder<TRecipe = unknown> {

  apply(): WaveModelInput<TRecipe>;

}

interface WaveModelInput<TRecipe = unknown> {

  readonly compiler: WaveModelCompilerIdentity;

  readonly contentHash: string;

  readonly declarationUse: WaveModelDeclarationUse;

  readonly id: string;

  readonly model: typeof WAVE_MODEL_INPUT_KIND;

  readonly recipe: TRecipe;

  readonly version: typeof WAVE_MODEL_INPUT_VERSION;

}

declare enum WaveModelPartExtractionMode {

  Adopt = "adopt",

  Clone = "clone",

  Promote = "promote",

}

interface WaveModelPartRef {

  readonly modelId: string;

  readonly partId: string;

}

declare enum WaveModelPartScope {

  All = "all",

  Available = "available",

  Created = "created",

}

declare class WaveModelSurfaceSelectionBuilder {

  constructor(_host: SurfaceSelectionHost, _id: string);

  apply(): WaveModelSurfaceSelectionDefinition;

  exclude(...selectors: readonly WaveFaceSelector[]): this;

  excludeAll(): this;

  excludeAround(center: Vector3Like, radius: number, falloff?: WaveValueCurveFalloffMode | WaveValueCurveInput): this;

  excludeNear(selectors: WaveFaceSelector | readonly WaveFaceSelector[], radius: number, falloff?: WaveValueCurveFalloffMode | WaveValueCurveInput): this;

  include(...selectors: readonly WaveFaceSelector[]): this;

  includeAll(): this;

  includeAround(center: Vector3Like, radius: number, falloff?: WaveValueCurveFalloffMode | WaveValueCurveInput): this;

  includeNear(selectors: WaveFaceSelector | readonly WaveFaceSelector[], radius: number, falloff?: WaveValueCurveFalloffMode | WaveValueCurveInput): this;

}

interface WaveModelWorldTextBuilder {

  align(alignment: NonNullable<WaveWorldTextModelRecipe["horizontalAlignment"]>): WaveModelWorldTextBuilder;

  apply(): WaveModelInput<WaveWorldTextModelRecipe>;

  faceCamera(): WaveModelWorldTextBuilder;

  faceCameraKeepingOwnerUp(): WaveModelWorldTextBuilder;

  followModelPlane(): WaveModelWorldTextBuilder;

  inRenderingGroup(groupId: number): WaveModelWorldTextBuilder;

  useFont(font: WaveWorldTextFontInput): WaveModelWorldTextBuilder;

  verticallyAlign(alignment: NonNullable<WaveWorldTextModelRecipe["verticalAlign"]>): WaveModelWorldTextBuilder;

  withColor(color: ColorInputAlpha): WaveModelWorldTextBuilder;

  withDepthTest(enabled: boolean): WaveModelWorldTextBuilder;

  withLineSpacing(spacing: number): WaveModelWorldTextBuilder;

  withSize(size: number): WaveModelWorldTextBuilder;

}

declare class waveNavPath extends wavePath {

  static readonly typeName: EntityType;

  destroy(): void;

  get failureReason(): WaveNavPathFailureReason | undefined;

  frameAtDistance(distance: number, options?: PathFrameOptions & WavePathQueryOptions): PathFrame;

  frameAtDistanceToRef(distance: number, result: PathFrame, options?: PathFrameOptions & WavePathQueryOptions): PathFrame;

  frameAtProgress(t: number, options?: PathFrameOptions & WavePathQueryOptions): PathFrame;

  frameAtProgressToRef(t: number, result: PathFrame, options?: PathFrameOptions & WavePathQueryOptions): PathFrame;

  get navHandleId(): string;

  get navMetadata(): WaveNavPathMetadata;

  get status(): WaveNavPathStatus;

  get version(): number;

}

type WaveNormalField = WaveMaterialField<"normal">;

type WaveNormalFieldInput = WaveNormalField;

type WaveNormalFieldRef = WaveMaterialFieldRef<"normal">;

declare class WaveObject<TState = unknown, TScale extends object = Vector3, TSnapshot extends object = Partial<ResolvedWorldTransformSnapshot>, TSpatialDomain extends WaveSpatialDomain = "3d"> extends WaveEntity<TState> {

  constructor(...args: WaveObjectConstructionArgs<TSpatialDomain>);

  static readonly typeName: EntityType;

  readonly [WAVE_SPATIAL_DOMAIN]: TSpatialDomain;

  addTag(tag: string): void;

  addTags(...tags: string[]): void;

  applySnapshot(snapshot: WaveObjectSnapshotInput<TSpatialDomain, TSnapshot>): this;

  destroy(): void;

  get entityID(): number;

  findTag(partial: string): string | undefined;

  hasTag(tag: string): boolean;

  get networkId(): number;

  get networkID(): number;

  offScaleChanged(callbackOrName?: string | WaveScaleChangedCallback<this, TScale>): boolean;

  offTransformChanged(callbackOrName?: string | WaveTransformChangedCallback<this>): boolean;

  onScaleChanged(callback: WaveScaleChangedCallback<this, TScale>, nameOrOptions?: WaveSpatialCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  onTransformChanged(callback: WaveTransformChangedCallback<this>, nameOrOptions?: WaveSpatialCallbackNameOrOptions, options?: WaveAuthoredCallbackOptions): this;

  get profile(): cmp_profile;

  removeTag(tag: string): void;

  removeTags(...tags: string[]): void;

  setTags(tags: string[]): void;

  get tags(): string[];

  get transform(): WaveObjectTransform<TSpatialDomain>;

}

interface WaveOfficialPrefab<TFamily extends WaveOfficialPrefabFamily = WaveOfficialPrefabFamily> {

  readonly family: TFamily;

  readonly pluginId: typeof WAVE_OFFICIAL_PREFABS_PLUGIN_ID;

  readonly prefabId: string;

}

interface WaveOfficialPrefabBuilderMap {

  readonly activePhysicsHumanoid: WaveActivePhysicsHumanoidModelBuilder;

  readonly doubleSidedHeightfield: WaveDoubleSidedHeightfieldModelBuilder;

  readonly grass: WavePrefabModelBuilder<typeof GRASS_PARTS>;

  readonly house: WavePrefabModelBuilder<typeof HOUSE_PARTS>;

  readonly physicalHumanoid: WavePrefabModelBuilder<typeof HUMANOID_PARTS>;

  readonly physicalQuadruped: WavePrefabModelBuilder<typeof QUADRUPED_PARTS>;

  readonly rocket: WaveRocketModelBuilder;

  readonly scaffold: WaveScaffoldModelBuilder;

  readonly tree: WaveTreeModelBuilder;

  readonly windmill: WavePrefabModelBuilder<typeof WINDMILL_PARTS>;

}

type WaveOfficialPrefabCatalog = typeof officialPrefabs;

type WaveOfficialPrefabFamily = keyof WaveOfficialPrefabBuilderMap;

declare const waveParam: { text(): WaveTextParamBuilder; number(): WaveNumberParamBuilder; boolean(): WaveBooleanParamBuilder; choice<const TChoices extends readonly [string, ...string[]]>(...choices: TChoices): WaveChoiceParamBuilder<TChoices[number]>; };

declare class wavePath extends waveGeometry {

  constructor(options?: WavePathConstructionOptions);

  static createData(): wavePath;

  static readonly typeName: EntityType;

  static visualizeAll(paths: readonly wavePath[]): readonly wavePath[];

  get activeRenderPointCount(): number;

  addPoint(point: PathPointInput): this;

  addPoint(x: number, y: number, z: number): this;

  applyUpdatedAssetConfig(): void;

  avoid(obstacles: WavePathRangeInputSet, options?: WavePathAvoidOptions): this;

  blendTo(other: wavePath, t: number, options?: WavePathBlendToOptions): this;

  blendTo(other: wavePath, mode: typeof Animate, options?: WavePathBlendToOptions): WavePathBlendAnimationBuilder;

  catmullRom(options?: WavePathCatmullRomModeOptions): this;

  get catmullRomTension(): number;

  get closed(): boolean;

  closestPointTo(point: PathPointInput, options?: WavePathQueryOptions): Vector3;

  closestProgressTo(point: PathPointInput, options?: WavePathQueryOptions): number;

  get controlPointInputs(): PathPointInput[];

  get controlPoints(): Vector3[];

  controlPointsToRef(result: Vector3[], options?: WavePathQueryOptions, spare?: Vector3[]): Vector3[];

  curvatureAtDistance(distance: number, options?: WavePathQueryOptions): number;

  curvatureAtProgress(progress: number, options?: WavePathQueryOptions): number;

  get curveType(): WavePathCurveType;

  destroy(): void;

  distanceAtProgress(progress: number, options?: WavePathQueryOptions): number;

  drawBetween(pointA: PathPointInput, pointB: PathPointInput): DrawBetweenBuilder;

  frameAtDistance(distance: number, options?: PathFrameOptions & WavePathQueryOptions): PathFrame;

  frameAtDistanceToRef(distance: number, result: PathFrame, options?: PathFrameOptions & WavePathQueryOptions): PathFrame;

  frameAtProgress(t: number, options?: PathFrameOptions & WavePathQueryOptions): PathFrame;

  frameAtProgressToRef(t: number, result: PathFrame, options?: PathFrameOptions & WavePathQueryOptions): PathFrame;

  from2D(source: WaveCurve2DSource): WavePathProjectedCurveBuilder;

  fromValueCurves(): WavePathFromValueCurvesBuilder;

  insertPointAt(index: number, point: PathPointInput): this;

  join(input: WavePathJoinInput): this;

  length(options?: WavePathQueryOptions): number;

  linear(options?: WavePathLinearModeOptions): this;

  get localControlPoints(): Vector3[];

  get localSampledPoints(): Vector3[];

  markers(options?: WavePathMarkerOptions): WavePathMarkerTable;

  offsetOnPlane(distance: number, plane?: WavePathPlaneInput, origin?: Vector3Like): this;

  get pathProviderState(): WavePathSampleProviderState;

  get pathRevision(): number;

  playBlendTo(input: WavePathBlendAnimationInput, runtimeBindings: WavePathBlendAnimationRuntimeBindings): TransitionLifecycleHandle<ValueDriveState>;

  pointAtDistance(distance: number, options?: WavePathQueryOptions): Vector3;

  pointAtDistanceToRef(distance: number, result: Vector3, options?: WavePathQueryOptions): Vector3;

  pointAtProgress(t: number, options?: WavePathQueryOptions): Vector3;

  pointAtProgressToRef(t: number, result: Vector3, options?: WavePathQueryOptions): Vector3;

  progressAtDistance(distance: number, options?: WavePathQueryOptions): number;

  projectPoint(point: PathPointInput, options?: WavePathQueryOptions): PathProjection;

  projectPointToRef(point: PathPointInput, result: PathProjection, options?: WavePathQueryOptions): PathProjection;

  refreshFromPointInputs(): this;

  removePointAt(index: number): this;

  get renderPointCapacity(): number;

  resampleUniform(sampleCount: number): this;

  reserveRenderPointCapacity(capacity: number): this;

  restoreFromJSON(serialized: WavePathSerialized): this;

  reverse(): this;

  get sampledPointCount(): number;

  get sampledPoints(): Vector3[];

  sampledPointsToRef(result: Vector3[], options?: WavePathQueryOptions, spare?: Vector3[]): Vector3[];

  get sampleSegments(): number;

  get samplesPerSegment(): number;

  setArc(options: WavePathArcOptions): this;

  setCatmullRomTension(tension: number): this;

  setCircle(options: WavePathCircleOptions): this;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0]): this;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0], mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setColor(color: Parameters<cmp_visual3DModel["setColor"]>[0], mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setDefinition(definition: WavePathDefinition): this;

  setDrawBetween(input: WavePathDrawBetweenInput, runtimeBindings?: WavePathDrawBetweenRuntimeBindings): this;

  setEllipse(options: WavePathEllipseOptions): this;

  setLine(start: PathPointInput, end: PathPointInput, options?: WavePathLineOptions): this;

  setOpacity(value: number): this;

  setOpacity(value: number, mode: typeof Snapshot): WaveMaterialPropertySnapshot;

  setOpacity(value: number, mode: typeof Animate): WaveMaterialPropertyAnimationBuilder;

  setPointAt(index: number, point: PathPointInput): this;

  setPolygon(points: ReadonlyArray<PathPointInput>, options?: WavePathPolygonOptions): this;

  setPolyline(points: ReadonlyArray<PathPointInput>, options?: WavePathPolylineOptions): this;

  setProjectedCurve(input: WavePathProjectedCurveInput): this;

  setRadialPolygon(options: WavePathRadialPolygonOptions): this;

  setRectangle(options: WavePathRectangleOptions): this;

  setRegularPolygon(options: WavePathRegularPolygonOptions): this;

  setSampleSegments(sampleSegments: number): this;

  setSamplesPerSegment(samplesPerSegment: number): this;

  setSquare(options: WavePathSquareOptions): this;

  setValueCurves(input: WavePathFromValueCurvesInput): this;

  show(): this;

  showPosition(options?: CoordinateDisplayOptions): this;

  showPosition(point: TransformPointInput | PositionFaceCenterInput, options?: CoordinateDisplayOptions): this;

  simplify(tolerance: number): this;

  snapTo(surface: WaveHeightSurfaceInput, options?: WavePathSnapToOptions): this;

  splitAtProgress(options: WavePathSplitOptions): [wavePath, wavePath];

  startAt(start: Vector3Like): WavePathDefinitionBuilder;

  startAt(x: number, y: number, z: number): WavePathDefinitionBuilder;

  stayWithin(bounds: WavePathRangeInputSet, options?: WavePathRangeConstraintOptions): this;

  tangentAtDistance(distance: number, options?: WavePathQueryOptions): Vector3;

  tangentAtDistanceToRef(distance: number, result: Vector3, options?: WavePathQueryOptions): Vector3;

  tangentAtProgress(t: number, options?: WavePathQueryOptions): Vector3;

  tangentAtProgressToRef(t: number, result: Vector3, options?: WavePathQueryOptions): Vector3;

  toDefinition(): WavePathDefinition;

  toJSON(): WavePathSerialized;

  toPointNet(options?: WavePointNetPathOptions): wavePointNet;

  toSampledDefinition(): WavePathDefinition;

  trim(options: WavePathTrimOptions): this;

  uniformSamples(sampleCount: number, options?: WavePathQueryOptions): Vector3[];

  uniformSamplesToRef(sampleCount: number, result: Vector3[], options?: WavePathQueryOptions, spare?: Vector3[]): Vector3[];

  get uniqueSampledPointCount(): number;

  valueCurve(metric: WavePathValueCurveMetric, options?: WavePathValueCurveOptions): WaveValueCurve;

  valueCurveBundle(options?: WavePathValueCurveBundleOptions): WaveValueCurveBundle;

  visualize(): this;

}

declare enum WavePathCurveType {

  CatmullRom = "catmullrom",

  Linear = "linear",

}

declare class WavePathDefinitionBuilder {

  arcTo(to: Vector3Like, options: { center: Vector3Like; normal?: DirectionInput; clockwise?: boolean; samples?: number; }): this;

  closed(enabled?: boolean): this;

  create(): wavePath;

  cubicTo(control1: Vector3Like, control2: Vector3Like, to: Vector3Like, samples?: number): this;

  lineTo(point: Vector3Like): this;

  lineTo(x: number, y: number, z: number): this;

  open(): this;

  toDefinition(): WavePathDefinition;

  withSamplesPerSegment(samplesPerSegment: number): this;

}

declare class wavePathExtrusion extends waveGeometry {

  constructor(path?: WavePathExtrusionPathInput, profile?: WavePathExtrusionProfileInput, options?: PathExtrusionOptions);

  static readonly typeName: EntityType;

  asPathExtrusion(path: WavePathExtrusionPathInput, profile: WavePathExtrusionProfileInput, options?: PathExtrusionOptions): this;

  asTube(path?: WavePathExtrusionPathInput, radius?: number, tessellation?: number, options?: PathExtrusionOptions): this;

  get extrusionMetadata(): PathExtrusionMetadata | null;

  get extrusionOptions(): PathExtrusionOptions;

  get pathInput(): WavePathExtrusionPathInput;

  get profileInput(): WavePathExtrusionProfileInput;

  setConfig(config: WavePathExtrusionConfig): this;

  setOptions(options: PathExtrusionOptions): this;

  setPath(path: WavePathExtrusionPathInput): this;

  setProfile(profile: WavePathExtrusionProfileInput): this;

  toConfig(): WavePathExtrusionConfig;

  withOffsetProgression(offset: WavePathExtrusionOffsetProgressionInput): this;

  withRotationProgression(progression: WavePathExtrusionProgressionInput): this;

  withScaleProgression(progression: WavePathExtrusionProgressionInput): this;

}

declare class WavePathFromValueCurvesBuilder {

  alongU(curve: WaveValueCurveInput): this;

  alongV(curve: WaveValueCurveInput): this;

  alongX(curve: WaveValueCurveInput): this;

  alongY(curve: WaveValueCurveInput): this;

  alongZ(curve: WaveValueCurveInput): this;

  catmullRom(options?: WavePathCatmullRomModeOptions): this;

  closed(enabled?: boolean): this;

  create(): wavePath;

  inLocalSpace(): this;

  inWorldSpace(): this;

  linear(options?: WavePathLinearModeOptions): this;

  onPlane(plane: WavePathPlaneInput): this;

  open(): this;

  originAt(origin: Vector3Like): this;

  originAt(x: number, y: number, z: number): this;

  reserveRenderPointCapacity(renderPointCapacity: number): this;

  toInput(): WavePathFromValueCurvesInput;

  withSampleCount(sampleCount: number): this;

}

declare class wavePathSurface extends waveGeometry {

  constructor(options?: WavePathSurfaceCreateOptions);

  static readonly typeName: EntityType;

  along(path: PathSurfaceInput, width: number, options?: WavePathSurfaceAlongAdditionalOptions): this;

  along(path: PathSurfaceInput, options: WavePathSurfaceAlongOptions): this;

  asSurfacePath(source: WavePathSurfaceRailsSourceInput, options?: WavePathSurfaceRailsOptions): this;

  asSurfacePath(source: WavePathSurfaceCenterlineSourceInput, options: WavePathSurfaceAlongOptions): this;

  between(leftPath: PathSurfaceInput, rightPath: PathSurfaceInput, options?: WavePathSurfaceRailsOptions): this;

  centerlinePoints(): Vector3[];

  get centerPathInput(): PathSurfaceInput | null;

  destroy(): void;

  heightAboveSurface(offset: number): this;

  leftEdgePoints(): Vector3[];

  get leftPathInput(): PathSurfaceInput | null;

  noGoZone(options?: WavePathSurfaceNoPlaceZoneOptions): WaveRange;

  noPlaceZone(options?: WavePathSurfaceNoPlaceZoneOptions): WaveRange;

  resetOrigin(_forceAnchorMove?: boolean): this;

  rightEdgePoints(): Vector3[];

  get rightPathInput(): PathSurfaceInput | null;

  sampleCenterlineEvery(distance: number): Vector3[];

  setCenterline(path: PathSurfaceInput): this;

  setConfig(config: WavePathSurfaceConfig): this;

  setLeftPath(leftPath: PathSurfaceInput): this;

  setOptions(options: WavePathSurfaceOptionsUpdate): this;

  setPaths(leftPath: PathSurfaceInput, rightPath: PathSurfaceInput): this;

  setRightPath(rightPath: PathSurfaceInput): this;

  snapTo(surface: WaveHeightSurfaceInput, options?: WavePathSurfaceSnapOptions): this;

  get source(): WavePathSurfaceSourceInput | null;

  get surfaceMetadata(): PathSurfaceMetadata | null;

  get surfaceOptions(): WavePathSurfaceOptions;

  get surfaceRibbonMetadata(): SurfaceRibbonMetadata | null;

  toConfig(): WavePathSurfaceConfig;

  withCap(cap: WavePathSurfaceCapMode): this;

  withDistanceUvs(uScale?: number, vScale?: number): this;

  withNormalizedUvs(uScale?: number, vScale?: number): this;

  withoutCaps(): this;

  withRoundCaps(): this;

  withSampleSpacing(spacing: number): this;

  withSquareCaps(): this;

  withWidth(width: number): this;

}

declare class WavePathSurfaceDefinition implements WavePathSurfaceAuthoringInput {

  constructor(...args: never[]);

  along(path: PathSurfaceInput, width: number, options?: WavePathSurfaceAlongAdditionalOptions): this;

  along(path: PathSurfaceInput, options: WavePathSurfaceAlongOptions): this;

  asSurfacePath(source: WavePathSurfaceRailsSourceInput, options?: WavePathSurfaceRailsOptions): this;

  asSurfacePath(source: WavePathSurfaceCenterlineSourceInput, options: WavePathSurfaceAlongOptions): this;

  between(leftPath: PathSurfaceInput, rightPath: PathSurfaceInput, options?: WavePathSurfaceRailsOptions): this;

  heightAboveSurface(offset: number): this;

  setCenterline(path: PathSurfaceInput): this;

  setConfig(config: WavePathSurfaceConfig): this;

  setLeftPath(leftPath: PathSurfaceInput): this;

  setOptions(options: WavePathSurfaceOptionsUpdate): this;

  setPaths(leftPath: PathSurfaceInput, rightPath: PathSurfaceInput): this;

  setRightPath(rightPath: PathSurfaceInput): this;

  toConfig(): WavePathSurfaceConfig;

  withCap(cap: WavePathSurfaceCapMode): this;

  withDistanceUvs(uScale?: number, vScale?: number): this;

  withNormalizedUvs(uScale?: number, vScale?: number): this;

  withoutCaps(): this;

  withRoundCaps(): this;

  withSampleSpacing(spacing: number): this;

  withSquareCaps(): this;

  withWidth(width: number): this;

}

declare class WavePBRMaterial {

  apply(): WaveMaterialInput<"pbr">;

  readonly name: string;

  private(key?: string): this;

  shared(): this;

  constructor(name: string, options?: WavePBRMaterialOptions);

  albedo(value: ColorInput): this;

  anisotropy(options: ProjectMaterialAnisotropyOptions): this;

  clearCoat(options: ProjectMaterialClearCoatOptions): this;

  color(value: ColorInput): this;

  configure(options: WavePBRMaterialOptions): this;

  doubleSided(enabled?: boolean): this;

  emissive(color: ColorInput, intensity?: number): this;

  iridescence(options: ProjectMaterialIridescenceOptions): this;

  lightBalance(environmentIntensity: number, directIntensity?: number): this;

  metallic(value: number): this;

  metalness(value: number): this;

  normalTextureFlipY(enabled?: boolean): this;

  opacity(alpha: number, transparent?: boolean): this;

  get options(): Readonly<WavePBRMaterialOptions>;

  parallax(intent: WavePBRReliefIntent): this;

  roughness(value: number): this;

  sheen(options: ProjectMaterialSheenOptions): this;

  specularIntensity(value: number): this;

  get state(): Readonly<WavePBRMaterialOptions>;

  subSurface(options: ProjectMaterialSubSurfaceOptions): this;

  transparent(enabled?: boolean): this;

  useAlbedoTexture(textureRef: string): this;

  useAOTexture(textureRef: string): this;

  useEmissiveTexture(textureRef: string): this;

  useMetallicTexture(textureRef: string): this;

  useNormalTexture(textureRef: string): this;

  useOpacityTexture(textureRef: string): this;

  useORMTexture(textureRef: string): this;

  useRefractionTexture(textureRef: string): this;

  useRoughnessTexture(textureRef: string): this;

  useThicknessTexture(textureRef: string): this;

  useTranslucencyColorTexture(textureRef: string): this;

  useTranslucencyTexture(textureRef: string): this;

  uvOffset(x: number, y: number): this;

  uvRotation(degrees: number): this;

  uvScale(x: number, y?: number): this;

  variant(name: string, options?: WavePBRMaterialOptions): WavePBRMaterial;

  wireframe(enabled?: boolean): this;

}

interface WavePBRMaterialOptions {

  readonly albedoColor?: ColorInput | undefined;

  readonly albedoTexture?: string | undefined;

  readonly alpha?: number | undefined;

  readonly alphaCutoff?: number | undefined;

  readonly alphaMode?: ProjectMaterialAlphaMode | null | undefined;

  readonly anisotropy?: ProjectMaterialAnisotropyOptions | undefined;

  readonly aoTexture?: string | undefined;

  readonly clearCoat?: ProjectMaterialClearCoatOptions | undefined;

  readonly directIntensity?: number | undefined;

  readonly doubleSided?: boolean | undefined;

  readonly emissiveColor?: ColorInput | undefined;

  readonly emissiveIntensity?: number | undefined;

  readonly emissiveTexture?: string | undefined;

  readonly environmentIntensity?: number | undefined;

  readonly iridescence?: ProjectMaterialIridescenceOptions | undefined;

  readonly maxSimultaneousLights?: number | undefined;

  readonly metallic?: number | undefined;

  readonly metallicTexture?: string | undefined;

  readonly normalTexture?: string | undefined;

  readonly normalTextureFlipY?: boolean | undefined;

  readonly opacityTexture?: string | undefined;

  readonly ormTexture?: string | undefined;

  readonly refractionIntensityTexture?: string | undefined;

  readonly relief?: WavePBRReliefIntent | undefined;

  readonly roughness?: number | undefined;

  readonly roughnessTexture?: string | undefined;

  readonly sheen?: ProjectMaterialSheenOptions | undefined;

  readonly specularIntensity?: number | undefined;

  readonly subSurface?: ProjectMaterialSubSurfaceOptions | undefined;

  readonly thicknessTexture?: string | undefined;

  readonly translucencyColorTexture?: string | undefined;

  readonly translucencyIntensityTexture?: string | undefined;

  readonly transparencyMode?: ProjectMaterialTransparencyMode | null | undefined;

  readonly transparent?: boolean | undefined;

  readonly useAlbedoTextureAlpha?: boolean | undefined;

  readonly useRadianceOverAlpha?: boolean | undefined;

  readonly useSpecularOverAlpha?: boolean | undefined;

  readonly uvOffset?: Vector2Like | undefined;

  readonly uvRotation?: number | undefined;

  readonly uvScale?: Vector2Like | undefined;

  readonly wireframe?: boolean | undefined;

}

declare class WavePbrModifier {

  constructor(id: string, recipe?: WavePbrModifierRecipe);

  ao(value: WaveScalarFieldInput, blend?: Exclude<WavePbrModifierBlend, "normalBlend">): this;

  baseColor(value: WaveColorFieldInput, blend?: Exclude<WavePbrModifierBlend, "normalBlend">): this;

  colorParameter(id: string, defaultValue: ColorInputAlpha): WaveColorField;

  configureRecipe(recipe: WavePbrModifierRecipe): this;

  coverage(value: WaveScalarFieldInput, blend?: Exclude<WavePbrModifierBlend, "normalBlend">): this;

  emissive(value: WaveColorFieldInput, blend?: Exclude<WavePbrModifierBlend, "normalBlend">): this;

  get field(): WaveMaterialFieldBuilder;

  readonly id: string;

  input(id: string, options?: Parameters<WaveMaterialFieldBuilder["externalInput"]>[1]): ReturnType<WaveMaterialFieldBuilder["externalInput"]>;

  inputColor(id: string, options?: { readonly coordinates?: WaveVector2Field; }): WaveColorField;

  inputScalar(id: string, options?: { readonly coordinates?: WaveVector2Field; }): WaveScalarField;

  mask(value: WaveScalarFieldInput): this;

  metallic(value: WaveScalarFieldInput, blend?: Exclude<WavePbrModifierBlend, "normalBlend">): this;

  normal(value: WaveNormalField, blend?: "replace" | "mix" | "normalBlend"): this;

  opacity(value: WaveScalarFieldInput, blend?: Exclude<WavePbrModifierBlend, "normalBlend">): this;

  projection(input: Partial<WaveSurfaceProjectionSpec>): this;

  roughness(value: WaveScalarFieldInput, blend?: Exclude<WavePbrModifierBlend, "normalBlend">): this;

  scalarParameter(id: string, defaultValue: number): WaveScalarField;

  toRecipe(): WavePbrModifierRecipe;

}

type WavePbrModifierBlend = "replace" | "mix" | "add" | "multiply" | "min" | "max" | "normalBlend";

type WavePbrModifierBuild = (context: WavePbrModifierBuilderContext) => void | WavePbrModifierRecipe;

interface WavePbrModifierBuilderContext {

  readonly field: WaveMaterialFieldBuilder;

  readonly modifier: WavePbrModifier;

}

interface WavePbrModifierBuildPresetAuthoring {

  dirt(id: string, options?: WavePbrModifierPresetOptions): WavePbrModifier;

  paint(id: string, options?: WavePbrModifierPresetOptions): WavePbrModifier;

  scorch(id: string, options?: WavePbrModifierPresetOptions): WavePbrModifier;

  snow(id: string, options?: WavePbrModifierPresetOptions): WavePbrModifier;

  wetness(id: string, options?: WavePbrModifierPresetOptions): WavePbrModifier;

}

type WavePbrModifierChannel = "baseColor" | "normal" | "roughness" | "metallic" | "ao" | "emissive" | "opacity" | "coverage";

type WavePbrModifierCreatePresetAuthoring = Readonly<{ [TKey in keyof WavePbrModifierBuildPresetAuthoring]: AppliedPreset<WavePbrModifierBuildPresetAuthoring[TKey], "toRecipe">; }>;

interface WavePbrModifierGpuDataChannelInputBinding {

  readonly channelId: string;

  readonly kind: "gpuDataChannel";

}

type WavePbrModifierInputBinding = WavePbrModifierGpuDataChannelInputBinding | WavePbrModifierSurfaceStateInputBinding;

type WavePbrModifierInputBindings = Readonly<Record<string, WavePbrModifierInputBinding>>;

interface WavePbrModifierInputDeclaration {

  readonly id: string;

  readonly valueType: "scalar" | "color";

}

type WavePbrModifierOutput = WavePbrModifierScalarOutput | WavePbrModifierColorOutput | WavePbrModifierNormalOutput;

type WavePbrModifierParameterValue = number | WaveMaterialFieldColorValue;

type WavePbrModifierParameterValues = Readonly<Record<string, WavePbrModifierParameterValue>>;

interface WavePbrModifierPresetOptions {

  readonly color?: ColorInputAlpha;

  readonly detailStrength?: number;

  readonly intensity?: number;

  readonly roughness?: number;

}

interface WavePbrModifierRecipe {

  readonly id: string;

  readonly inputs: readonly WavePbrModifierInputDeclaration[];

  readonly mask?: WaveScalarFieldRef;

  readonly nodes: readonly WaveMaterialFieldNode[];

  readonly outputs: readonly WavePbrModifierOutput[];

  readonly parameters: readonly WaveMaterialParameterDeclaration[];

  readonly projection: WaveSurfaceProjectionSpec;

  readonly schema: "wave.pbrModifier/1";

}

declare class WavePhysicsRig<T extends WavePhysicsRigPart = WavePhysicsRigPart> extends WaveGroup<T> {

  constructor(name: string, controller?: NoInfer<T> | wave3DObject, scene?: WaveGroupSceneBridge);

  actuation<TPartId extends WaveModelPartId = WaveModelPartId>(options?: WaveArticulatedActuationOptions<TPartId>): WaveArticulatedActuation<T, TPartId>;

  apply(options?: WavePhysicsRigOptions): WaveModelPhysicsRig;

  bindObjectModel(owner: wave3DObject, options?: WavePhysicsRigObjectModelBindingOptions): this;

  chain(firstChild: T, ...moreChildren: T[]): WavePhysicsRigChainTargetBuilder<T>;

  clearJoints(): this;

  disablePhysics(options?: WavePhysicsRigDisablePhysicsOptions): this;

  dispose(): void;

  driveDynamicBodies(options?: WavePhysicsRigDynamicDriveOptions): WavePhysicsRigDynamicDriveBuilder<T>;

  driveKinematicBodies(): WavePhysicsRigKinematicDriveBuilder<T>;

  enablePhysics(options?: WavePhysicsRigEnablePhysicsOptions): this;

  fromCurrentPose(): this;

  getPhysicalRig(): WaveModelPhysicsRig | null;

  joint(child: T, ...moreChildren: T[]): WavePhysicsRigJointTargetBuilder<T>;

  get jointCount(): number;

  get joints(): readonly WavePhysicsRigJointRecord<T>[];

  get lastFailedJointIds(): readonly string[];

  plan(options?: WavePhysicsRigOptions): WaveModelPhysicsRigPlan;

  releaseActuation(): boolean;

  removeJoint(id: string): boolean;

  requireObjectModelParts<const TPartIds extends readonly WaveModelPartId[]>(partIds: TPartIds): Readonly<Record<TPartIds[number], T>>;

  reset(): this;

  toObjectModelRigGraph(): WaveModelRigGraphMetadata;

  useObjectModelGraph(graph: WaveModelRigGraphMetadata, parts: WavePhysicsRigObjectModelPartBindings<T>): this;

}

interface WavePickResult {

  readonly capturedAtMs: number;

  readonly distance: number | null;

  readonly entityId: number | null;

  readonly frameRevision: number;

  readonly handle: WavePresentationHandle | null;

  readonly hit: boolean;

  readonly normal: readonly [number, number, number] | null;

  readonly point: readonly [number, number, number] | null;

  readonly requestId: number;

}

declare class wavePlane extends waveGeometry {

  configureGeometry(configuration: WavePlanePrimitiveRecipe | WavePrimitiveGeometryConfiguration<WavePlanePrimitiveRecipe>): this;

  primitiveRecipe: WavePlanePrimitiveRecipe;

  constructor(width?: number, height?: number, doubleSided?: boolean, widthSegments?: number, heightSegments?: number);

  static readonly typeName: EntityType;

  asGround(width: number, height: number, subdivisions?: number): this;

  asPlane(width: number, height: number, doubleSided?: boolean, widthSegments?: number, heightSegments?: number): this;

  get baseBackUVs(): unknown | null;

  get baseFrontUVs(): unknown | null;

  get baseHeight(): number;

  get baseHeightSegments(): number;

  get baseWidth(): number;

  get baseWidthSegments(): number;

  clearBaseBackUVs(): this;

  clearBaseFrontUVs(): this;

  get doubleSided(): boolean;

  face(surface: WaveSurface): ReturnType<cmp_visual3DModel["surface"]>;

  faceMaterial(surface: WaveSurface): ReturnType<cmp_visual3DModel["meshMaterialSlot"]>;

  findPointByUV(u: number, v: number): WavePlaneUvPointSource;

  findPointsByUVLine(startU: number, startV: number, endU: number, endV: number, count: number): readonly WavePlaneUvPointSource[];

  get height(): number;

  get heightSegments(): number;

  get planeOrientation(): "xy" | "ground";

  setBaseBackUVs(backUVs: unknown): this;

  setBaseFrontUVs(frontUVs: unknown): this;

  setBaseHeight(height: number): this;

  setBaseHeightSegments(segments: number): this;

  setBaseSegments(widthSegments: number, heightSegments: number): this;

  setBaseSideOrientation(sideOrientation: number): this;

  setBaseSize(width: number, height: number): this;

  setBaseWidth(width: number): this;

  setBaseWidthSegments(segments: number): this;

  get width(): number;

  get widthSegments(): number;

}

declare enum WavePlane {

  XY = "xy",

  XZ = "xz",

  YZ = "yz",

}

interface WavePlaneFrame {

  readonly normal: Vector3Like;

  readonly origin: Vector3Like;

  readonly u: Vector3Like;

  readonly v: Vector3Like;

}

type WavePlaneFrameInput = WavePlaneOrientation | WavePlaneFrameIntent;

interface WavePlaneFrameIntent {

  readonly normal: SerializedDirectionInput;

  readonly u?: SerializedDirectionInput;

}

type WavePlaneOrientation = WavePlaneValue | SerializedDirectionInput;

declare class wavePoint extends wave3DAbstract implements WavePointSource {

  constructor(radius?: number, segments?: number);

  static readonly typeName: EntityType;

  get animator(): cmp_modelAnimator;

  toVector(space?: WavePointSourceSpace): Vector3;

  toVector3(): Vector3;

  toVectorToRef(space: WavePointSourceSpace, result: Vector3): Vector3;

}

declare class wavePointCloudBatch {

  constructor(batch?: waveThinBatch);

  bindSourceVisual(sourceVisual: PointCloudSourceVisual | null): this;

  configureFromVoxels(voxels: VoxelPointCloud[], voxelSize: number, options?: VoxelPointCloudOptions): this;

  destroy(): void;

  get isDissolving(): boolean;

  get length(): number;

  playDissolve(): this;

  stopDissolve(resetVisuals?: boolean): this;

  readonly thinBatch: waveThinBatch;

}

type WavePointInput = Vector3Like | WavePointSource | WaveStudioWorldPositionTarget;

declare class wavePointNet extends waveGeometry {

  constructor();

  constructor(points: ReadonlyArray<WavePointNetPointInput>, options?: WavePointNetOptions);

  constructor(path: WavePointNetPathSource, options?: WavePointNetPathOptions);

  static readonly typeName: EntityType;

  addPoint(point: WavePointNetPointInput): this;

  addPoint(x: number, y: number, z: number): this;

  asPointNet(points: ReadonlyArray<WavePointNetPointInput>, options?: WavePointNetOptions): this;

  captureGeometryData(): WaveGeometryData;

  captureSurfaceGeometryData(sceneOverride?: unknown): WaveGeometryData;

  clearPoints(): this;

  get closed(): boolean;

  destroy(): void;

  getLocalPoints(): readonly Vector3[];

  getPointAt(index: number): WavePointNetPointInput;

  getResolvedPointAt(index: number): Vector3;

  insertPointAt(index: number, point: WavePointNetPointInput): this;

  get linkMode(): WavePointNetLinkMode;

  get mode(): WavePointNetMode;

  pointAtDistance(distance: number): Vector3;

  pointAtProgress(progress: number): Vector3;

  get pointCount(): number;

  get pointInputs(): WavePointNetPointInput[];

  get points(): Vector3[];

  refreshFromPointInputs(): this;

  removePoint(point: WavePointSource): this;

  removePointAt(index: number): this;

  resampleUniform(sampleCount: number): this;

  setBaseCellSize(cellSize: number): this;

  setBaseClosed(closed: boolean): this;

  setBaseConnectSequential(connectSequential: boolean): this;

  setBaseGridColumns(gridColumns: number): this;

  setBaseGridRows(gridRows: number): this;

  setBaseLinkMode(linkMode: WavePointNetLinkMode): this;

  setBaseMode(mode: WavePointNetMode): this;

  setBasePadding(padding: number): this;

  setBasePath(path: WavePointNetPathSource, options?: WavePointNetPathOptions): this;

  setBasePoints(points: ReadonlyArray<WavePointNetPointInput>): this;

  setBaseRadius(radius: number): this;

  setBaseRingLattice(ringLattice: boolean): this;

  setBaseSmoothness(smoothness: number): this;

  setBaseUvScale(uvScale: number): this;

  setPointAt(index: number, point: WavePointNetPointInput): this;

  uniformSamples(sampleCount: number): Vector3[];

}

declare enum WavePointNetLinkMode {

  Live = "live",

  Snapshot = "snapshot",

}

declare enum WavePointNetMode {

  OuterShell = "outerShell",

  SdfSkin = "sdfSkin",

}

declare enum WavePointNetPathSamplingMode {

  ControlPoints = "controlPoints",

  RenderedPath = "renderedPath",

  Uniform = "uniform",

}

interface WavePointSource {

  toVector(space?: WavePointSourceSpace): Vector3;

  toVector3(): Vector3;

  toVectorToRef?(space: WavePointSourceSpace, result: Vector3): Vector3;

}

declare class wavePolygon extends waveGeometry {

  configureGeometry(configuration: WavePolygonPrimitiveRecipe | WavePrimitiveGeometryConfiguration<WavePolygonPrimitiveRecipe>): this;

  primitiveRecipe: WavePolygonPrimitiveRecipe;

  constructor(radius?: number, sides?: number);

  static readonly Face: Readonly<{ top: () => PrismTopFaceSelector; bottom: () => PrismBottomFaceSelector; side: (index: number) => PrismSideFaceSelector; }>;

  static readonly typeName: EntityType;

  asPolygon(radius: number, sides?: number): this;

  asPrism(sides?: number, radius?: number, height?: number, topRadius?: number, heightSegments?: number, capSubdivisions?: number): this;

  get baseCapSubdivisions(): number;

  get baseHeight(): number | null;

  get baseHeightSegments(): number;

  get baseRadius(): number;

  get baseSides(): number;

  get capMode(): PolygonCapMode;

  get capSubdivisions(): number;

  clearBaseHeight(): this;

  clearSeed(): this;

  face(surface: WaveSurface | PrismFaceSelector): ReturnType<cmp_visual3DModel["surface"]>;

  faceMaterial(surface: WaveSurface | PrismFaceSelector): ReturnType<cmp_visual3DModel["meshMaterialSlot"]>;

  get heightSegments(): number;

  get radius(): number;

  get regular(): boolean;

  get seed(): number | null;

  setBaseHeight(height: number): this;

  setBaseHeightSegments(segments: number): this;

  setBaseRadius(radius: number): this;

  setBaseSegments(segments: number): this;

  setBaseSideOrientation(sideOrientation: number): this;

  setBaseSides(sides: number): this;

  setCapMode(mode: PolygonCapMode): this;

  setCapSubdivisions(segments: number): this;

  setRegular(regular: boolean): this;

  setSeed(seed: number): this;

  setTopRadius(topRadius: number): this;

  get sides(): number;

  get topRadius(): number;

}

type WavePrefabModelBuilder<TParts extends Readonly<Record<string, string>>, TMethods extends object = Readonly<Record<never, never>>> = Readonly<{ readonly parts: WavePrefabModelPartRefs<TParts>; readonly useAuthoredLODByDistance?: (options?: WavePrefabModelLodDistanceOptions) => WavePrefabModelBuilder<TParts, TMethods>; apply(): WaveModelInput; } & TMethods>;

interface WavePrefabModelLodDistanceOptions {

  readonly hideBeyondLastLevel?: boolean;

  readonly highUntil?: number;

  readonly hysteresis?: number;

  readonly lowUntil?: number;

  readonly mediumUntil?: number;

  readonly thresholds?: Readonly<Record<string, number>>;

  readonly updateEveryFrames?: number;

}

type WavePrefabModelPartRefs<TParts extends Readonly<Record<string, string>>> = Readonly<{ [TKey in keyof TParts]: WaveModelPartRef; }>;

interface WavePresentationHandle {

  readonly generation: number;

  readonly slot: number;

}

type WavePrimitiveModelOptions<TShape extends WavePrimitiveShape> = Omit<Extract<WavePrimitiveGeometryInput, { readonly shape: TShape; }>, "kind" | "version" | "shape">;

interface WaveProceduralAnchorOptions {

  readonly at: WaveModelVec3Tuple | { readonly x: number; readonly y: number; readonly z: number; }

  readonly kind?: WaveModelAnchorMetadata["kind"];

  readonly metadata?: WaveProceduralModelMetadata;

  readonly name?: string;

  readonly on: string;

  readonly rotation?: WaveModelVec3Tuple | { readonly x: number; readonly y: number; readonly z: number; }

}

interface WaveProceduralAnchorRecipe {

  readonly at: WaveModelVec3Tuple;

  readonly id: string;

  readonly kind?: WaveModelAnchorMetadata["kind"];

  readonly metadata?: WaveProceduralModelMetadata;

  readonly name?: string;

  readonly on: string;

  readonly rotation?: WaveModelVec3Tuple;

}

interface WaveProceduralCollisionOptions {

  readonly geometry: string;

  readonly metadata?: WaveProceduralModelMetadata;

  readonly on: string;

}

interface WaveProceduralCollisionRecipe extends WaveProceduralCollisionOptions {

  readonly id: string;

}

interface WaveProceduralDetachedGeometrySource {

  readonly kind: "detachedGeometry";

  readonly payload: SerializableDataValue;

}

type WaveProceduralGeometryRecipe = WavePrimitiveGeometryRecipe | WaveLoftGeometryRecipe | WaveHardSurfaceGeometryRecipe | { readonly kind: "sdfSurface"; readonly options: WaveSdfSurfaceGeometryRecipeOptions; } | { readonly kind: "cardSprite"; readonly options?: WaveCardSpriteGeometryRecipeOptions; } | { readonly kind: "cardCluster"; readonly options: WaveCardClusterGeometryRecipeOptions; }

interface WaveProceduralGeometryRecipeSource {

  readonly kind: "proceduralGeometry";

  readonly recipe: WaveProceduralGeometryRecipe;

}

interface WaveProceduralMaterialAssignment {

  readonly id: string;

  readonly material: WaveProceduralModelMaterialIntent;

  readonly materialIndex?: number;

  readonly slotName: string;

  readonly state?: WaveModelMaterialStatePatch;

  readonly targetId: string;

  readonly targetKind: WaveProceduralMaterialTargetKind;

}

interface WaveProceduralMaterialAssignmentOptions {

  readonly materialIndex?: number;

  readonly slotName?: string;

  readonly state?: WaveModelMaterialStatePatch;

}

type WaveProceduralMaterialInput = string | WaveMaterialInput;

type WaveProceduralMaterialTargetKind = "model" | "geometry" | "part" | "surface";

declare class WaveProceduralModelBuilder {

  constructor(id: string);

  anchor(id: string, options: WaveProceduralAnchorOptions): this;

  apply(): WaveProceduralModelInput;

  collision(id: string, options: WaveProceduralCollisionOptions): this;

  geometry(id: string, source: WaveProceduralModelGeometryInput, options?: WaveProceduralModelGeometryOptions): this;

  loft(id: string, recipe: WaveLoftGeometryInput | WaveLoftGeometryRecipe, options?: WaveProceduralModelGeometryOptions): this;

  metadata(value: SerializableDataValue): this;

  part(id: string, options: WaveProceduralPartOptions): this;

  primitive(id: string, recipe: WavePrimitiveGeometryInput | WavePrimitiveGeometryRecipe, options?: WaveProceduralModelGeometryOptions): this;

  readonly recipe: WaveProceduralModelRecipeBuilder;

  skin(target: string, options?: WaveRigSkinIntent): this;

  surface(id: string, options: WaveProceduralSurfaceOptions): this;

  toConfig(): WaveProceduralModelRecipe;

  useMaterial(targetId: string, material: WaveProceduralMaterialInput, options?: WaveProceduralMaterialAssignmentOptions): this;

  withLOD(lodGraph: WaveModelLODGraphMetadata): this;

  withRig(rig: WaveRigInput): this;

}

interface WaveProceduralModelDerivationBuilder extends WaveModelDerivationBuilder<WaveProceduralModelInputRecipe> {

  removePart(partId: string): this;

}

type WaveProceduralModelGeometryInput = WaveGeometryDataSerializable | WaveProceduralGeometryRecipe | WaveSdfSurfaceModelInput | WaveProceduralModelGeometrySource;

interface WaveProceduralModelGeometryOptions {

  readonly displayName?: string;

  readonly localTransform?: TransformSnapshotLike;

  readonly metadata?: WaveProceduralModelMetadata;

  readonly name?: string;

}

interface WaveProceduralModelGeometrySlot {

  readonly displayName?: string;

  readonly id: string;

  readonly localTransform?: WaveProceduralModelTransformSnapshot;

  readonly metadata?: WaveProceduralModelMetadata;

  readonly name?: string;

  readonly source: WaveProceduralModelGeometrySource;

}

type WaveProceduralModelGeometrySource = WaveProceduralDetachedGeometrySource | WaveProceduralGeometryRecipeSource;

type WaveProceduralModelMaterialIntent = { readonly kind: "none"; } | { readonly kind: "asset"; readonly materialAssetId: string; } | { readonly kind: "inlinePbr"; readonly options: ProjectPBRMaterialOptions & ProjectPBRMaterialTextureSlots; } | { readonly kind: "inlineStandard"; readonly options: ProjectStandardMaterialOptions & ProjectStandardMaterialTextureSlots; } | { readonly kind: "inlineShader"; readonly recipe: WaveShaderMaterialRecipe; } | { readonly kind: "input"; readonly input: WaveMaterialInput; }

type WaveProceduralModelMetadata = Readonly<Record<string, SerializableDataValue>>;

interface WaveProceduralModelRecipe {

  readonly anchors?: readonly WaveProceduralAnchorRecipe[];

  readonly collisions?: readonly WaveProceduralCollisionRecipe[];

  readonly geometries: readonly WaveProceduralModelGeometrySlot[];

  readonly id: string;

  readonly lodGraph?: WaveModelLODGraphMetadata;

  readonly materialAssignments?: readonly WaveProceduralMaterialAssignment[];

  readonly metadata?: SerializableDataValue;

  readonly parts?: readonly WaveProceduralPartRecipe[];

  readonly rig?: WaveRigAuthoringConfig;

  readonly skinning?: readonly WaveProceduralSkinningRecipe[];

  readonly surfaces?: readonly WaveProceduralSurfaceRecipe[];

  readonly version: 1;

}

interface WaveProceduralModelRecipeBuilder {

  geometry(source: WaveProceduralModelGeometryInput): WaveProceduralModelGeometrySource;

  material(material: WaveProceduralMaterialInput): WaveProceduralModelMaterialIntent;

  rig(rig: WaveRigInput): WaveRigAuthoringConfig;

}

interface WaveProceduralModelTransformSnapshot {

  readonly position: { readonly x: number; readonly y: number; readonly z: number; }

  readonly rotation: { readonly x: number; readonly y: number; readonly z: number; readonly w: number; }

  readonly scale: { readonly x: number; readonly y: number; readonly z: number; }

}

interface WaveProceduralPartOptions {

  readonly collisionGeometry?: string;

  readonly geometry?: string;

  readonly metadata?: WaveProceduralModelMetadata;

  readonly name?: string;

  readonly parent?: string | null;

  readonly visualGeometry?: string;

}

interface WaveProceduralPartRecipe {

  readonly collisionGeometry?: string;

  readonly id: string;

  readonly metadata?: WaveProceduralModelMetadata;

  readonly name?: string;

  readonly parentPartId?: string | null;

  readonly visualGeometry?: string;

}

type WaveProceduralPBRBuild = (context: WaveProceduralPBRBuilderContext) => void | WaveProceduralPBRRecipe;

interface WaveProceduralPBRBuilderContext {

  readonly field: WaveMaterialFieldBuilder;

  readonly material: WaveProceduralPBRMaterial;

}

interface WaveProceduralPBRChannels {

  readonly ao?: WaveScalarFieldRef;

  readonly baseColor: WaveColorFieldRef;

  readonly emissive?: WaveColorFieldRef;

  readonly height?: WaveScalarFieldRef;

  readonly metalness?: WaveScalarFieldRef;

  readonly normal?: WaveNormalFieldRef;

  readonly opacity?: WaveScalarFieldRef;

  readonly roughness?: WaveScalarFieldRef;

}

interface WaveProceduralPBRCutoutOptions {

  readonly cutoff?: number;

}

declare class WaveProceduralPBRMaterial {

  apply(): WaveMaterialInput<"proceduralPbr">;

  readonly name: string;

  private(key?: string): this;

  shared(): this;

  constructor(name: string, recipe?: WaveProceduralPBRRecipe, bakePolicy?: WaveProceduralPBRBakePolicyInput);

  ao(value: WaveScalarFieldInput): this;

  aoFromHeight(options?: { readonly radius?: number; readonly strength?: number; }): this;

  bake(options?: WaveProceduralPBRBakeOptions): Promise<WaveProceduralPBRBakeResult>;

  bakedOnly(options?: Omit<WaveProceduralPBRBakePolicyInput, "mode">): this;

  bakeOnDemand(options?: Omit<WaveProceduralPBRBakePolicyInput, "mode">): this;

  bakeOnPublish(options?: Omit<WaveProceduralPBRBakePolicyInput, "mode">): this;

  get bakePolicy(): WaveProceduralPBRBakePolicy;

  baseColor(value: WaveColorFieldInput): this;

  captureProjectMaterialAssetDefinition(): WaveProceduralPBRProjectMaterialDefinition;

  configureRecipe(recipe: WaveProceduralPBRRecipe): this;

  cutout(value: WaveScalarFieldInput, options?: WaveProceduralPBRCutoutOptions): this;

  emissive(value: WaveColorFieldInput): this;

  get field(): WaveMaterialFieldBuilder;

  height(value: WaveScalarFieldInput): this;

  live(options?: Omit<WaveProceduralPBRBakePolicyInput, "mode">): this;

  metadata(value: SerializableDataValue): this;

  metallic(value: WaveScalarFieldInput): this;

  metalness(value: WaveScalarFieldInput): this;

  normal(value: WaveNormalFieldInput): this;

  normalFromHeight(options?: { readonly strength?: number; }): this;

  opacity(value: WaveScalarFieldInput): this;

  projection(input: WaveProceduralPBRProjectionInput): this;

  roughness(value: WaveScalarFieldInput): this;

  toConfig(): WaveProceduralPBRMaterialSerializedConfig;

  toRecipe(): WaveProceduralPBRRecipe;

  variant(name: string, build?: WaveProceduralPBRBuild): WaveProceduralPBRMaterial;

}

interface WaveProceduralPBRProjectionInput {

  readonly blendSharpness?: number;

  readonly mode?: WaveSurfaceProjectionSpec["mode"];

  readonly offset?: Partial<WaveSurfaceProjectionSpec["offset"]>;

  readonly primaryDirection?: DirectionInput;

  readonly scale?: number | Partial<WaveSurfaceProjectionSpec["scale"]>;

  readonly space?: WaveSurfaceProjectionSpec["space"];

}

interface WaveProceduralPBRProjectMaterialDefinition {

  readonly bakePolicy?: WaveProceduralPBRBakePolicy;

  readonly materialType: "proceduralPbr";

  readonly recipe: WaveProceduralPBRRecipe;

  readonly type: "material";

}

interface WaveProceduralPBRRecipe {

  readonly channels: WaveProceduralPBRChannels;

  readonly kind: "wave-procedural-pbr";

  readonly metadata?: SerializableDataValue;

  readonly nodes: readonly WaveMaterialFieldNode[];

  readonly projection: WaveSurfaceProjectionSpec;

  readonly transparency?: WaveProceduralPBRTransparencyIntent;

  readonly version: 1;

}

type WaveProceduralPBRTransparencyIntent = { readonly mode: "blend"; } | { readonly mode: "cutout"; readonly cutoff: number; }

interface WaveProceduralSkinningRecipe {

  readonly options?: WaveRigSkinIntent;

  readonly target: string;

}

interface WaveProceduralSurfaceOptions {

  readonly aliases?: readonly string[];

  readonly geometry: string;

  readonly localNormalHint?: WaveModelVec3Tuple;

  readonly metadata?: WaveProceduralModelMetadata;

  readonly name?: string;

  readonly region: string;

  readonly selectors?: readonly WaveModelSurfaceSelectorDescriptor[];

}

interface WaveProceduralSurfaceRecipe extends WaveProceduralSurfaceOptions {

  readonly id: string;

}

declare class waveProp<TState = unknown> extends wave3DObject<TState> {

  constructor(modelAsset?: Visual3DModelInput);

  static readonly typeName: EntityType;

  get animator(): cmp_modelAnimator;

  get audio(): cmp_audio;

  get camera(): cmp_camera;

  castToActor(options?: CastToPropOptions): waveActor;

  get fx(): FxFacade;

  get hasAnimator(): boolean;

  get hasAudio(): boolean;

  get hasCamera(): boolean;

  get hasInteractable(): boolean;

  get hasLight(): boolean;

  get hasMovementController(): boolean;

  get hasSensing(): boolean;

  get interactable(): cmp_3dInteractable<this>;

  get light(): cmp_light;

  mergeIntoProp(target: waveProp): waveProp;

  get movementController(): cmp_movementController<this>;

  get sensing(): cmp_sensing<this>;

}

declare class WaveRange {

  constructor(name: string, shape?: WaveRangeShape, syncHelper?: WaveRangeHelperSync, resolveModel?: WaveRangeModelResolver, matchEntity?: WaveRangeEntityMatcher);

  anchorAt(anchor: WaveRangeAnchorInput): this;

  anchorAt(x: number, y: number, z: number): this;

  asBox(halfExtents: Vector3Like): this;

  asBox(x: number, y: number, z: number): this;

  asBox(cube: waveCube): this;

  asSphere(radius: number): this;

  asSphere(sphere: waveSphere): this;

  get borderEpsilon(): number;

  clearVoxelGrid(): this;

  containsPoint(point: WavePointInput, inset?: number): boolean;

  containsPointRef(point: Vector3, inset?: number): boolean;

  fromModel(source: WaveRangeAuthoringModelSource, options?: WaveRangeModelOptions): this;

  fromPathBand(path: WaveRangePathBandInput, options: WaveRangePathBandOptions): this;

  fullyContains(entity: WaveSpatial3DObject, options?: WaveRangeEntityMatchOptions): boolean;

  fullyExcludes(entity: WaveSpatial3DObject, options?: WaveRangeEntityMatchOptions): boolean;

  getAabb(): WaveRangeAabb | null;

  getBox(): WaveRangeAabb | null;

  getSphere(): { center: Vector3; radius: number; } | null;

  getVoxelGrid(): WaveRangeVoxelGrid | null;

  get helperVisible(): boolean;

  hideHelper(): this;

  isOnBorder(entity: WaveSpatial3DObject, options?: WaveRangeEntityMatchOptions): boolean;

  matches(entity: WaveSpatial3DObject, match: WaveRangeMatch, options?: WaveRangeEntityMatchOptions): boolean;

  readonly name: string;

  setBorderEpsilon(epsilon: number): this;

  get shape(): WaveRangeShape;

  showHelper(options?: WaveRangeHelperOptions): this;

  transformMeshSurface(matrix: unknown | null): this;

  transformShape(matrix: unknown | null): this;

  transformVolumetricField(matrix: unknown | null): this;

  transformVoxelGrid(matrix: unknown | null): this;

  withVoxelGrid(options?: WaveRangeVoxelGridOptions): this;

}

declare const WaveRangeMatchMode: { readonly FullyIn: "fullyIn"; readonly FullyOut: "fullyOut"; readonly OnBorder: "onBorder"; };

declare const WaveRangeShapeKind: { readonly Aabb: "aabb"; readonly Sphere: "sphere"; readonly MeshSurface: "meshSurface"; readonly VoxelGrid: "voxelGrid"; readonly VolumetricField: "volumetricField"; };

declare const WaveRangeVoxelFillMode: { readonly Center: "center"; readonly Intersects: "intersects"; readonly Contained: "contained"; };

declare class WaveRate implements WaveRateSpec {

  constructor(value: number, unit: WaveRateUnitKind);

  readonly kind = "rate";

  readonly unit: WaveRateUnitKind;

  readonly value: number;

}

declare const waveResponse: Readonly<{ named(id: string): WaveResponseBuilder; }>;

declare const waveRig: { create(name?: string): WaveRigAuthoringHandle; fromConfig(config: WaveRigAuthoringConfig): WaveRigAuthoringConfig; resolve(input: WaveRigInput): WaveRigAuthoringConfig };

interface WaveRigAuthoring {

  create(name?: string): WaveRigAuthoringHandle;

  fromConfig(config: WaveRigAuthoringConfig): WaveRigAuthoringConfig;

  resolve(input: WaveRigInput): WaveRigAuthoringConfig;

}

declare class WaveRigidBodyConstantForceBuilder<TBody = unknown> {

  constructor(_executor: WaveRigidBodyFrameExecutor<TBody>, _name: string, frame: WaveTransformFrameSpace, frameOf?: TransformReferenceLike, parentFrameDepth?: number);

  clear(): this;

  done(): TBody;

  inFrameOf(target: TransformReferenceLike): this;

  inLocalFrame(): this;

  inParentFrame(depth?: number): this;

  inWorldFrame(): this;

  get name(): string;

  setContactPoint(contactPoint: WavePointInput): this;

  setDirection(direction: DirectionInput, strength?: number): this;

  setEnabled(enabled: boolean): this;

  setForce(force: Vector3Like): this;

  setMagnitude(strength: number): this;

}

type WaveRocketModelBuilder = BuilderWithMethods<typeof ROCKET_PARTS, WaveRocketModelMethods>;

interface WaveRocketModelMethods {

  baseNozzle(index: number): WaveModelPartRef;

  fin(index: number): WaveModelPartRef;

  interstage(index: number): WaveModelPartRef;

  stage(index: number): WaveModelPartRef;

  withBaseNozzles(count: number): WaveRocketModelBuilder;

  withFins(count: number): WaveRocketModelBuilder;

  withStages(count: number): WaveRocketModelBuilder;

  withTheme(color: ColorInput): WaveRocketModelBuilder;

}

type WaveScaffoldBridgeSegmentInput = number | readonly number[];

type WaveScaffoldLatticePattern = typeof WAVE_SCAFFOLD_LATTICE_PATTERN[keyof typeof WAVE_SCAFFOLD_LATTICE_PATTERN];

type WaveScaffoldModelBuilder = BuilderWithMethods<typeof SCAFFOLD_PARTS, WaveScaffoldModelMethods>;

interface WaveScaffoldModelMethods {

  ladder(index: number): WaveModelPartRef;

  lattice(index: number): WaveModelPartRef;

  segment(index: number): WaveModelPartRef;

  serviceBridge(index: number): WaveModelPartRef;

  servicePlatform(index: number): WaveModelPartRef;

  withFoundation(enabled: boolean): WaveScaffoldModelBuilder;

  withLadders(enabled: boolean): WaveScaffoldModelBuilder;

  withLatticePattern(pattern: WaveScaffoldLatticePattern): WaveScaffoldModelBuilder;

  withSegments(count: number): WaveScaffoldModelBuilder;

  withServiceBridges(levels: readonly number[]): WaveScaffoldModelBuilder;

  withServiceBridgeSegments(segments: WaveScaffoldBridgeSegmentInput): WaveScaffoldModelBuilder;

  withServicePlatforms(levels: readonly number[]): WaveScaffoldModelBuilder;

  withTheme(color: ColorInput): WaveScaffoldModelBuilder;

}

type WaveScalarField = WaveMaterialField<"scalar">;

type WaveScalarFieldInput = number | WaveScalarField;

type WaveScalarFieldRef = WaveMaterialFieldRef<"scalar">;

declare class WaveScene<TEngine extends unknown = unknown> {

  constructor(name?: string, options?: WaveSceneOptions);

  get activeLLM(): WaveLLMBackend;

  get activeTTS(): WaveTTSBackend;

  get assets(): WaveSceneAssetsFacade;

  get autoLOD(): AutoLODConfigurator<TEngine>;

  get babylonScene(): unknown | null;

  get camera(): CameraConfigurator<TEngine>;

  cleanupClientEntities(clientId: string): number;

  clear(): void;

  clearFields(): void;

  clearLightingZones(): void;

  clearPrint(): void;

  clearRanges(): void;

  clearTriggerVolumes(): void;

  get cloud(): Record<string, unknown>;

  configureField(config: WaveFieldConfig): WaveField;

  configureLightingZone(config: WaveLightingZoneConfig): WaveLightingZone;

  get controls(): WaveSceneControls<TEngine>;

  create3DGrid<T extends WaveSpatial3DObject = WaveSpatial3DObject>(name?: string, controller?: NoInfer<T> | wave3DObject): Wave3DGrid<T>;

  createActivePhysicsRig(name?: string): WaveActivePhysicsRigBuilder<TEngine>;

  createAssemblyInstances(recipe: WaveAssemblyRecipe | WaveAssemblyRealizationPlan, name?: string): WaveAssemblyInstances;

  createCloth(): WaveClothBuilder;

  createCloth(options: ClothGridOptions): WaveCloth;

  createClusteredLights(name?: string, controller?: WaveSpatial3DObject | wave3DObject): waveClusteredLights;

  createCompiledAssemblyInstances<TInput, TController, TServices>(terminal: WaveCompiledAssemblyTerminal<TInput, TController, TServices>, name?: string): WaveCompiledAssemblyInstances<TInput, TController, TServices>;

  readonly createdAt: number;

  createField(name?: string, shape?: WaveRangeShape): WaveField;

  createForceField(name?: string, shape?: WaveRangeShape): WaveField;

  createGravityField(name?: string, source?: WaveFieldPointInput): WaveField;

  createGroup<T extends WaveSpatial3DObject = WaveSpatial3DObject>(name?: string, controller?: NoInfer<T> | wave3DObject): WaveGroup<T>;

  createJointAssembly<T extends waveProp = waveProp>(name?: string, controller?: NoInfer<T> | wave3DObject): WaveJointAssembly<T>;

  createLightingZone(name?: string, shape?: WaveRangeShape): WaveLightingZone;

  createPhysicsRig<T extends WavePhysicsRigPart = WavePhysicsRigPart>(name?: string, controller?: NoInfer<T> | wave3DObject): WavePhysicsRig<T>;

  createRange(name?: string, shape?: WaveRangeShape): WaveRange;

  createRigidChain(anchor: waveProp): ChainBuilder;

  createRope(): WaveRopeBuilder;

  createRope(options: RopeChainOptions): WaveRope;

  createTriggerVolume(name?: string, shape?: WaveRangeShape): WaveTriggerVolume;

  get cursor(): WaveSceneCursorFacade<TEngine>;

  get data(): WaveSceneDataStore;

  destroyField(name: string): boolean;

  destroyGroup(name: string): boolean;

  destroyLightingZone(name: string): boolean;

  destroyRange(name: string): boolean;

  destroyTriggerVolume(name: string): boolean;

  get director(): waveSceneDirector;

  dispose(): void;

  get engine(): TEngine & WaveSceneEngineAuthoringContext;

  get entityCount(): number;

  get environment(): EnvironmentConfigurator<TEngine>;

  fadeIn(options?: SceneTransitionOptions): Promise<void>;

  fadeOut(options?: SceneTransitionOptions): Promise<void>;

  filterInRange(entities: WaveSpatial3DObject[], range: WaveRange | string, match: WaveRangeMatch, options?: WaveRangeEntityMatchOptions): WaveSpatial3DObject[];

  find(predicate: (entity: AnyWaveObject) => boolean): AnyWaveObject[];

  findFirst(predicate: (entity: AnyWaveObject) => boolean): AnyWaveObject | undefined;

  findInRange(range: WaveRange | string, match: WaveRangeMatch, options?: WaveRangeEntityMatchOptions): WaveSpatial3DObject[];

  firstByName(name: string): AnyWaveObject | undefined;

  firstByName<T extends AnyWaveObject>(name: string, expectedType: WaveSceneObjectClass<T>): T | undefined;

  get fog(): FogConfigurator<TEngine>;

  forceField(name?: string, shape?: WaveRangeShape): WaveField;

  get fx(): FxFacade;

  get(name: string): AnyWaveObject;

  get<T extends AnyWaveObject>(name: string, expectedType: WaveSceneObjectClass<T>): T;

  getAll(): AnyWaveObject[];

  getAllIds(): number[];

  getById(id: number): WaveEntity | undefined;

  getByName(name: string): AnyWaveObject[];

  getByName<T extends AnyWaveObject>(name: string, expectedType: WaveSceneObjectClass<T>): T[];

  getByOwner(clientId: string): AnyWaveObject[];

  getByRuntimeRef(runtimeRef: string): WaveEntity | undefined;

  getByTag(tag: string): AnyWaveObject[];

  getField(name: string): WaveField | undefined;

  getLightingZone(name: string): WaveLightingZone | undefined;

  getNetworkHealth(): NetworkHealthMetrics | null;

  getNetworkHealthForClient(clientId: string): NetworkHealthMetrics | null;

  getRange(name: string): WaveRange | undefined;

  getRenderHeight(): number;

  getRenderWidth(): number;

  getTriggerVolume(name: string): WaveTriggerVolume | undefined;

  get ground(): waveTerrainTile;

  has(entityOrId: WaveEntity | number): boolean;

  get hasDirector(): boolean;

  get hasInstrumentBootstrap(): boolean;

  get hasTerrain(): boolean;

  get hasTTSBootstrap(): boolean;

  get hasXRBootstrap(): boolean;

  hideByTag(tag: string): this;

  hidePosition(): this;

  get host(): WaveSceneHostFacade;

  hotReload(nextScene?: WaveScene<TEngine>, options?: WaveSceneHotReloadOptions): Promise<WaveSceneHotReloadResult>;

  get interactions(): WaveSceneInteractionsFacade;

  get isColdStart(): boolean;

  get isHotReload(): boolean;

  get isRetired(): boolean;

  get isRunning(): boolean;

  get lastHotReloadClassification(): WaveSceneHotReloadClassification | null;

  get lifecycle(): SceneLifecycle;

  get lighting(): LightingConfigurator<TEngine>;

  lightingZone(name?: string, shape?: WaveRangeShape): WaveLightingZone;

  loading?: WaveSceneLoadingPlan;

  main?: (engine: unknown) => Promise<void> | void;

  makeDraggable<TTarget extends wave3DObject>(target: TTarget): WaveSceneDraggableBuilder<TTarget>;

  mediaCapturePlan?: SceneMediaCapturePlan;

  metadata: Record<string, unknown>;

  get metaData(): Record<string, unknown>; set metaData(value: Record<string, unknown>);

  mirror<T extends WaveSpatial3DObject>(input: T): MirrorBuilder<T>;

  mirror<T extends WaveSpatial3DObject>(input: T, options: MirrorOptions<T>): T;

  readonly name: string;

  navOnSurface(surface: WaveNavSurfaceInput, name?: string): WaveNavSpaceHandle;

  navPathsOnSurface(surface: WaveNavSurfaceInput, name?: string): WaveNavPathBatchHandle;

  objects(): IterableIterator<AnyWaveObject>;

  objects2D(): IterableIterator<WaveSpatial2DObject>;

  objects3D(): IterableIterator<WaveSpatial3DObject>;

  objectsByName(name: string): IterableIterator<AnyWaveObject>;

  objectsByOwner(clientId: string): IterableIterator<AnyWaveObject>;

  objectsByTag(tag: string): IterableIterator<AnyWaveObject>;

  objectsOfType<T extends AnyWaveObject>(expectedType: WaveSceneObjectClass<T>): IterableIterator<T>;

  get occlusion(): WaveOcclusionCulling;

  off(event: WaveEventName | string, handler: (...args: unknown[]) => void): void;

  on(event: WaveEventName | string, handler: (...args: unknown[]) => void): WaveEventHandler;

  once(event: WaveEventName | string, handler: (...args: unknown[]) => void): WaveEventHandler;

  onceEngineEvent<TEventData>(event: WaveTypedEventInput<TEventData>, handler: (event: WaveEvent<TEventData>) => void): WaveEventHandler;

  onceEngineEvent(event: WaveEventName | string, handler: (...args: unknown[]) => void): WaveEventHandler;

  onClientConnected(handler: (clientId: string) => void): () => void;

  onClientConnecting(handler: (clientId: string) => void): () => void;

  onClientDisconnected(handler: (clientId: string) => void): () => void;

  onClientKicked(handler: (clientId: string, reason?: string) => void): () => void;

  onClientOnboarding(handler: (clientId: string) => void): () => void;

  onClientReady(handler: (clientId: string) => void): () => void;

  onClientTimeout(handler: (clientId: string) => void): () => void;

  onDispose(callback: () => void): this;

  onEngineEvent<TEventData>(event: WaveTypedEventInput<TEventData>, handler: (event: WaveEvent<TEventData>) => void): WaveEventHandler;

  onEngineEvent(event: WaveEventName | string, handler: (...args: unknown[]) => void): WaveEventHandler;

  onWorldReady(handler: (payload?: unknown) => void): WaveEventHandler;

  placeAround<T extends WaveSpatial3DObject>(target?: WavePointInput | WaveSpatial3DObject): SpawnAroundBuilder<T>;

  placeInGrid(input: waveThinBatch): ThinBatchInGridBuilder;

  placeInGrid(input: FxPlayableSystem): FxInGridPlacementBuilder;

  placeInGrid<T extends WaveSpatial3DObject>(input: T): SpawnInGridBuilder<T, T>;

  placeInGrid<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>): SpawnInGridBuilder<T, ReadonlyArray<T>>;

  placeInGrid<T extends WaveSpatial3DObject>(input: WaveGroup<T>): SpawnInGridBuilder<T, WaveGroup<T>>;

  placeInline(input: waveThinBatch): ThinBatchInlineBuilder;

  placeInline(input: FxPlayableSystem): FxInlinePlacementBuilder;

  placeInline<T extends WaveSpatial3DObject>(input: T): SpawnInlineBuilder<T, T>;

  placeInline<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>): SpawnInlineBuilder<T, ReadonlyArray<T>>;

  placeInline<T extends WaveSpatial3DObject>(input: WaveGroup<T>): SpawnInlineBuilder<T, WaveGroup<T>>;

  placeInRange<T extends WaveSpatial3DObject>(range: WaveRange | string): SpawnInRangeBuilder<T>;

  placeOnPath(input: waveThinBatch): ThinBatchOnPathBuilder;

  placeOnPath(input: FxPlayableSystem): FxOnPathPlacementBuilder;

  placeOnPath<T extends WaveSpatial3DObject>(input: T): SpawnOnPathBuilder<T, T>;

  placeOnPath<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>): SpawnOnPathBuilder<T, ReadonlyArray<T>>;

  placeOnPath<T extends WaveSpatial3DObject>(input: WaveGroup<T>): SpawnOnPathBuilder<T, WaveGroup<T>>;

  placeOnSurfaceOf<T extends WaveSpatial3DObject>(surface: SpawnSurface): SpawnOnSurfaceBuilder<T>;

  get postFx(): WavePostFx;

  prepareNavigation(): Promise<this>;

  get presentationPlan(): WaveScenePresentationPlan | null;

  print(text: unknown, fontSize?: number, color?: ColorInput | string, options?: WaveScenePrintOptions): void;

  get reflection(): WaveSceneReflectionFacade;

  reloadMainWith(mainFn: SceneMainFunction<TEngine>, options?: Omit<WaveSceneHotReloadOptions, "patchMainOnly">): Promise<WaveSceneHotReloadResult>;

  rememberStateAcrossHotReload(key: string): WaveSceneHotReloadStateBuilder;

  get rendering(): RenderingConfigurator<TEngine>;

  get renderingPlan(): WaveSceneRenderingPlan | undefined;

  get renderProfile(): WaveRenderProfile;

  replaceCursorWithAnimatedMaterial(source: string, options: WaveSceneAnimatedCursorOptions): WaveSceneCursorFacade<TEngine>;

  replaceCursorWithAnimatedSprite(source: string, options: WaveSceneAnimatedCursorOptions): WaveSceneCursorFacade<TEngine>;

  replaceCursorWithMaterial(source: string, options?: WaveSceneCursorOptions): WaveSceneCursorFacade<TEngine>;

  replaceCursorWithSprite(source: string, options?: WaveSceneCursorOptions): WaveSceneCursorFacade<TEngine>;

  replaceCursorWithTexture(source: string, options?: WaveSceneCursorOptions): WaveSceneCursorFacade<TEngine>;

  requiredConsents?: SensingDevice[];

  saveMaterial(options: SaveMaterialAssetOptions): Promise<SaveMaterialAssetResult>;

  saveModel(target: wave3DObject | cmp_visual3DModel, options?: SaveIntoModelAssetOptions): Promise<SaveIntoModelAssetResult>;

  saveVertexAnimation(options: CreateVertexAnimationOptions & { readonly id: string; readonly target: unknown; readonly fileName?: string; readonly metadata?: Readonly<Record<string, unknown>>; }): SaveVertexAnimationAssetResult;

  readonly sceneInstanceId: number;

  get screen(): WaveSceneScreenFacade;

  get screenMedia(): WaveScreenMedia;

  setup?: (engine: unknown) => Promise<void> | void;

  showByTag(tag: string): this;

  showCameraFov(fontSize?: number, color?: ColorInput | string): this;

  showCameraLookAt(fontSize?: number, color?: ColorInput | string): this;

  showCameraPos(fontSize?: number, color?: ColorInput | string): this;

  showPosition(positions: readonly WavePointInput[], options?: CoordinateDisplayOptions): this;

  showPosition(position: WavePointInput, options?: CoordinateDisplayOptions): this;

  showPosition(x: number, y: number, z: number, options?: CoordinateDisplayOptions): this;

  get simulation(): WaveSimulation;

  get sky(): SkyConfigurator<TEngine>;

  spawnAround<T extends WaveSpatial3DObject>(input: T, options: SpawnAroundOptions<T>): WaveGroup<T>;

  spawnAround<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, options: SpawnAroundOptions<T>): SpawnResultForArray<T>;

  spawnAround<T extends WaveSpatial3DObject>(input: WaveGroup<T>, options: SpawnAroundOptions<T>): WaveGroup<SpawnGroupMember<T>>;

  readonly spawner: WaveSpawner;

  spawnInGrid<T extends WaveSpatial3DObject>(input: T, options: SpawnInGridOptions<T> & { as3DGrid: true; }): Wave3DGrid<T>;

  spawnInGrid<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, options: SpawnInGridOptions<T> & { as3DGrid: true; }): Wave3DGrid<SpawnGroupMember<T>>;

  spawnInGrid<T extends WaveSpatial3DObject>(input: WaveGroup<T>, options: SpawnInGridOptions<T> & { as3DGrid: true; }): Wave3DGrid<SpawnGroupMember<T>>;

  spawnInGrid<T extends WaveSpatial3DObject>(input: T, options: SpawnInGridOptions<T>): WaveGroup<T>;

  spawnInGrid<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, options: SpawnInGridOptions<T>): SpawnResultForArray<T>;

  spawnInGrid<T extends WaveSpatial3DObject>(input: WaveGroup<T>, options: SpawnInGridOptions<T>): WaveGroup<SpawnGroupMember<T>>;

  spawnInline<T extends WaveSpatial3DObject>(input: T, options: SpawnInlineOptions<T>): WaveGroup<T>;

  spawnInline<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, options: SpawnInlineOptions<T>): SpawnResultForArray<T>;

  spawnInline<T extends WaveSpatial3DObject>(input: WaveGroup<T>, options: SpawnInlineOptions<T>): WaveGroup<SpawnGroupMember<T>>;

  spawnInRange<T extends WaveSpatial3DObject>(input: T, options: SpawnInRangeOptions<T>): WaveGroup<T>;

  spawnInRange<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, options: SpawnInRangeOptions<T>): SpawnResultForArray<T>;

  spawnInRange<T extends WaveSpatial3DObject>(input: WaveGroup<T>, options: SpawnInRangeOptions<T>): WaveGroup<SpawnGroupMember<T>>;

  spawnOnPath<T extends WaveSpatial3DObject>(input: T, path: WaveCurveInput, options?: SpawnOnPathOptions<T>): WaveGroup<T>;

  spawnOnPath<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, path: WaveCurveInput, options?: SpawnOnPathOptions<T>): SpawnResultForArray<T>;

  spawnOnPath<T extends WaveSpatial3DObject>(input: WaveGroup<T>, path: WaveCurveInput, options?: SpawnOnPathOptions<T>): WaveGroup<SpawnGroupMember<T>>;

  spawnOnSurface<T extends WaveSpatial3DObject>(input: T, options: SpawnOnSurfaceOptions<T>): WaveGroup<T>;

  spawnOnSurface<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, options: SpawnOnSurfaceOptions<T>): SpawnResultForArray<T>;

  spawnOnSurface<T extends WaveSpatial3DObject>(input: WaveGroup<T>, options: SpawnOnSurfaceOptions<T>): WaveGroup<SpawnGroupMember<T>>;

  get terrain(): WaveTerrainFacade<WaveScene<TEngine>>;

  get tooling(): WaveSceneTooling<TEngine>;

  triggerVolume(name?: string, shape?: WaveRangeShape): WaveTriggerVolume;

  get ui(): WaveUISkinSceneOwner;

  useNavigationRecast(runtime: WaveNavRecastRuntime): this;

  get volumetricFog(): VolumetricFogConfigurator<TEngine>;

  get water(): WaveSceneWaterFacade;

  get weather(): WeatherConfigurator<TEngine>;

  withAssets(assets: WaveSceneAssets | AssetCatalog | ProjectAssetCatalog, baseUrl?: string): this;

  withExternalLLM(provider: string, options?: WaveLLMBackendOptions): this;

  withInstruments(instrumentFn: InstrumentBootstrapFunction<TEngine>): this;

  withLocalNeuralTTS(config: WaveLocalNeuralTTSOptions | readonly WaveLocalNeuralTTSOptions[]): this;

  withMain(mainFn: SceneMainFunction<TEngine>): this;

  withMediaCapturePlan(plan: SceneMediaCapturePlan): this;

  withMetadata(metadata: Record<string, unknown>): this;

  withPresentation(input: WaveScenePresentationPlanInput): this;

  withRenderingPlan(renderingPlan: WaveSceneRenderingPlan): this;

  withRenderProfile(renderProfile: WaveRenderProfile): this;

  withRequiredConsents(consents: SensingDevice[]): this;

  withSetup(setupFn: SceneSetupFunction<TEngine>): this;

  withTTSBackend(name: WaveStandardTTSBackendProviderName, options?: WaveTTSBackendOptions): this;

  withXR(config: Partial<XRSessionConfig>): this;

  get world(): WaveSceneWorldFacade<TEngine>;

  get worldPlan(): WaveWorldPlan | null;

  get xr(): WaveSceneXRFacade;

  xrConfig?: XRSessionConfig;

}

interface WaveSceneAssetManifest {

  baseUrl?: string;

  loaders?: readonly WaveAssetLoaderDeclaration[];

  manifest: readonly string[];

}

interface WaveSceneDefinition {

  assets?: WaveSceneAssetManifest;

  loading?: WaveSceneLoadingPlan;

  main?: WaveSceneMainFunc;

  mediaCapturePlan?: SceneMediaCapturePlan;

  name: string;

  renderingPlan?: WaveSceneRenderingPlan;

  renderProfile?: WaveRenderProfile;

  requiredConsents?: SensingDevice[];

  setup?: WaveSceneSetupFunc;

  xrConfig?: XRSessionConfig;

}

declare class waveSceneDirector<S extends string = string> extends WaveObject<S, Vector3, Partial<ResolvedWorldTransformSnapshot>, "3d"> {

  constructor();

  static readonly typeName: EntityType;

  get audio(): cmp_audio;

  freezeOnTransition<TSnap extends SnapshotFactoryMap>(fromState: S, toState: S, thawState: S, snapshotFns: TSnap): Readonly<{ [K in keyof TSnap]: ReturnType<TSnap[K]>; }>;

  get frozenConfig(): Readonly<Record<string, unknown>> | null;

  getMouseDelta(): { x: number; y: number; }

  getMousePosition(): { x: number; y: number; }

  getPressedKeys(): Keyboard[];

  get hasSensing(): boolean;

  isKeyPressed(key: Keyboard): boolean;

  isMouseButtonPressed(button: MouseButton): boolean;

  isPermitted(action: string): boolean;

  off(handleOrName: CallbackHandle | string): boolean;

  offAction(actionName: WaveActionName | string, callback?: ActionCallback<this>): void;

  offAll(): void;

  onAction(actionName: WaveActionName | string, callback: ActionCallback<this>, options?: ActionCallbackOptions): CallbackHandle;

  onGamepadButtonPress(callback: InputCallback<GamepadButtonInputData, this>, button?: GamepadButton, options?: Omit<CallbackOptions, "filter">): CallbackHandle;

  onGamepadButtonRelease(callback: InputCallback<GamepadButtonInputData, this>, button?: GamepadButton, options?: Omit<CallbackOptions, "filter">): CallbackHandle;

  onLeftClick(callback: InputCallback<MouseButtonInputData, this>, options?: CallbackOptions): CallbackHandle;

  onLeftStickMove(callback: InputCallback<GamepadAxisInputData, this>, options?: CallbackOptions): CallbackHandle;

  onMouseButtonDown(callback: InputCallback<MouseButtonInputData, this>, button?: MouseButton, options?: Omit<CallbackOptions, "filter">): CallbackHandle;

  onMouseButtonUp(callback: InputCallback<MouseButtonInputData, this>, button?: MouseButton, options?: Omit<CallbackOptions, "filter">): CallbackHandle;

  onMouseClick(callback: InputCallback<MouseButtonInputData, this>, button?: MouseButton, options?: Omit<CallbackOptions, "filter">): CallbackHandle;

  onMouseDoubleClick(callback: InputCallback<MouseButtonInputData, this>, button?: MouseButton, options?: Omit<CallbackOptions, "filter">): CallbackHandle;

  onMouseMove(callback: InputCallback<MouseMoveInputData, this>, options?: CallbackOptions): CallbackHandle;

  onMouseWheel(callback: InputCallback<MouseWheelInputData, this>, options?: CallbackOptions): CallbackHandle;

  onRightClick(callback: InputCallback<MouseButtonInputData, this>, options?: CallbackOptions): CallbackHandle;

  onRightStickMove(callback: InputCallback<GamepadAxisInputData, this>, options?: CallbackOptions): CallbackHandle;

  permit(action: string, allowedStates: S[]): this;

  get sensing(): cmp_sensing<this>;

  setPermissionTable(table: Record<string, S[]>): this;

  whenHolding(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, this>, holdThreshold?: WaveTimeSpan, options?: Omit<CallbackOptions, "filter" | "holdThreshold">): CallbackHandle;

  whenHolding(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, this>, value: number, unit: WaveTimeUnit, options?: Omit<CallbackOptions, "filter" | "holdThreshold">): CallbackHandle;

  whenPress(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, this>, options?: Omit<CallbackOptions, "filter">): CallbackHandle;

  whenRelease(key: Keyboard | undefined, callback: InputCallback<KeyboardInputData, this>, options?: Omit<CallbackOptions, "filter">): CallbackHandle;

}

declare class WaveSceneDraggableBuilder<TTarget extends wave3DObject = wave3DObject> {

  constructor(_scene: WaveSceneDraggableScene, _target: TTarget);

  acrossScreen(): this;

  alongAxis(axis: DirectionInput): this;

  apply(): WaveSceneDraggableHandle<TTarget>;

  aroundGround(): this;

  keepCameraControls(): this;

  keepHeight(): this;

  lockCameraWhileDragging(lock?: boolean): this;

  meshScope(scope: MeshScope): this;

  onDrag(callback: WaveSceneDragCallback<TTarget>): this;

  onDragEnd(callback: WaveSceneDragCallback<TTarget>): this;

  onDragMove(callback: WaveSceneDragCallback<TTarget>): this;

  onDragStart(callback: WaveSceneDragCallback<TTarget>): this;

  onPlane(normal: DirectionInput): this;

  onPlane(options: { readonly normal: DirectionInput; }): this;

  ownedMeshes(): this;

  toConfig(): WaveSceneDraggableConfig;

  toIntent(): WaveSceneDraggableIntent;

  withLeftMouse(): this;

  withMiddleMouse(): this;

  withMouseButton(button: MouseButton): this;

  withRightMouse(): this;

  withSmoothing(ratio: number): this;

}

type WaveSceneMainFunc = (engine: BaseEngineRef) => void | Promise<void>;

interface WaveSceneScreenFacade {

  readonly canvas: WaveSceneCanvasScreenScope;

  metrics(): Readonly<ScreenMetrics>;

  rayDirectionIntoScene(point: WaveScreenPointRef): WaveScreenWorldDirection;

  rayDirectionOutOfScene(point: WaveScreenPointRef): WaveScreenWorldDirection;

  resolveToCanvasNormalized(point: WaveScreenPointRef): WaveCanvasNormalizedPoint;

  resolveToCanvasPixel(point: WaveScreenPointRef): WaveCanvasPixelPoint;

  resolveToScopeNormalized(point: WaveScreenPointRef): WaveCanvasNormalizedPoint | WaveViewNormalizedPoint;

  resolveToScopePixel(point: WaveScreenPointRef): WaveCanvasPixelPoint | WaveViewPixelPoint;

  resolveToViewNdc(point: WaveScreenPointRef): WaveViewNdcPoint;

  snapshot(): WaveScreenSpaceSnapshot;

  tryResolveToCanvasPixel(point: WaveScreenPointRef, out: WaveMutableVector2): boolean;

  tryResolveToScopePixel(point: WaveScreenPointRef, out: WaveMutableVector2): boolean;

  view(cameraId: string): WaveSceneViewScreenScope;

  viewAtCanvasPixel(screenX: number, screenY: number): WaveSceneViewScreenScope | null;

  views(): readonly Readonly<ScreenRenderView>[];

  worldPointAtCameraDistance(point: WaveScreenPointRef, distance: number): WaveScreenWorldPoint;

  worldPointAtDepth01(point: WaveScreenPointRef, depth01: number): WaveScreenWorldPoint;

}

type WaveSceneSetupFunc = (engine: BaseEngineRef) => void | Promise<void>;

declare class WaveSceneTooling<TEngine extends unknown = unknown> {

  clearInfluenceView(target?: WaveSceneInfluenceViewTarget): void;

  readonly geometryInfluence: WaveSceneGeometryInfluenceTooling;

  refreshInfluenceView(target: WaveSceneInfluenceViewTarget): boolean;

  showInfluenceView(target: WaveSceneInfluenceViewTarget, field: WaveGeometryInfluenceField, options?: WaveSceneShowInfluenceViewOptions): WaveSceneInfluenceViewHandle;

  showSkinWeights(target: WaveSceneInfluenceViewTarget, options?: WaveSceneShowSkinWeightsOptions): WaveSceneInfluenceViewHandle;

  showSurfaceSelection(target: WaveSceneInfluenceViewTarget, selection: WaveModelSurfaceSelectionDefinition, options?: WaveSceneShowInfluenceViewOptions): WaveSceneInfluenceViewHandle;

  constructor(_scene: WaveScene<TEngine>);

  isEntityVisible(entity: WaveEntity): boolean;

  registerTransformAuthoring(entity: WaveEntity, registration: WaveSceneTransformAuthoringRegistration): WaveSceneTransformAuthoringRegistrationHandle;

  resolveTransformAuthoringTarget(entity: WaveEntity, options?: WaveSceneTransformAuthoringResolveOptions): WaveSceneTransformAuthoringTarget | null;

  get runtimeMarkers(): WaveSceneRuntimeMarkerRegistry;

  snapshotEntityTree(options?: { readonly limit?: number; }): WaveSceneToolingTreeSnapshot;

}

declare const WaveSceneTransformAuthoringTools: { readonly Move: "move"; readonly Rotate: "rotate"; readonly Scale: "scale"; };

interface WaveSceneTTSBootstrapPlan {

  localNeural?: WaveLocalNeuralTTSPreloadConfig | readonly WaveLocalNeuralTTSPreloadConfig[];

}

interface WaveSceneWorldFacade<TEngine extends unknown = unknown> {

  compose(id: string): WaveWorldComposer;

  edit(): WaveWorldPlanEditor;

  explain(plan?: WaveWorldPlanInput): WaveWorldPlanExplanation | null;

  readonly geometry: WaveSceneWorldGeometryFacade;

  heightAt(x: number, z: number, layerId?: string): number | null;

  readonly isReady: boolean;

  readonly layerIds: readonly string[];

  normalAt(x: number, z: number, layerId?: string): WaveSceneWorldSurfaceNormal | null;

  readonly plan: WaveWorldPlan | null;

  readonly primaryLayerId: string | null;

  querySurface(position: SurfaceQueryInput, layerId?: string): SurfaceQueryResult | null;

  querySurface(x: number, z: number, layerId?: string): SurfaceQueryResult | null;

  querySurfaceAt(position: SurfaceQueryInput, layerId?: string): SurfaceQueryResult | null;

  readonly runtime: WaveSceneWorldRuntimeFacade<TEngine>;

  readonly surface: WaveSceneWorldSurfaceFacade;

  use(plan: WaveWorldPlanInput): WaveScene<TEngine>;

}

interface WaveSdfRecipeSurfaceOptions {

  readonly cellSize?: number;

  readonly coordinateSpace?: DistanceFieldUnits3D;

  readonly metadata?: Readonly<Record<string, unknown>>;

  readonly name?: string;

  readonly normalSampleStep?: number;

  readonly sourceTag?: string;

  readonly uvScale?: number;

}

type WaveSdfSurfaceGeometryRecipeOptions = Omit<CreateSdfSurfaceFromRecipeOptions, "assetOptions">;

type WaveSdfSurfaceModelInput = WaveModelInput<WaveSdfSurfaceModelRecipe>;

type WaveSdfSurfaceModelRecipe = Omit<CreateSdfSurfaceFromRecipeOptions, "id">;

type WaveShaderColor3Value = readonly [number, number, number] | { readonly r: number; readonly g: number; readonly b: number; }

type WaveShaderColor4Value = readonly [number, number, number, number] | { readonly r: number; readonly g: number; readonly b: number; readonly a: number; }

interface WaveShaderInlineSource {

  readonly fragment: string;

  readonly key: string;

  readonly kind: "inline";

  readonly overwrite?: boolean;

  readonly vertex: string;

}

interface WaveShaderInlineSourcePair {

  readonly fragment: string;

  readonly overwrite?: boolean;

  readonly vertex: string;

}

declare class WaveShaderMaterial {

  apply(): WaveMaterialInput<"shader" | "wgslShader">;

  readonly name: string;

  private(key?: string): this;

  shared(): this;

  constructor(name: string, definition: WaveShaderMaterialRecipe | WaveShaderMaterialDescriptor);

  useTexture(samplerName: string, textureRef: string): this;

}

type WaveShaderMaterialAlphaMode = ProjectMaterialAlphaMode | "opaque" | "combine";

interface WaveShaderMaterialDefinitionRecipe {

  readonly definition: WaveShaderMaterialRecipe | WaveShaderMaterialDescriptor;

  readonly textures: readonly WaveShaderTextureBinding[];

}

type WaveShaderMaterialLanguage = "glsl" | "wgsl";

interface WaveShaderMaterialRecipe {

  readonly attributes?: readonly string[];

  readonly bindingLayout?: readonly WaveShaderUniformBindingDescriptor[];

  readonly debugName?: string;

  readonly defines?: readonly string[];

  readonly kind?: "shader";

  readonly language?: WaveShaderMaterialLanguage;

  readonly metadata?: WaveShaderRecipeMetadata;

  readonly owner?: string;

  readonly renderState?: WaveShaderMaterialRenderState;

  readonly samplers?: readonly WaveShaderSamplerInput[];

  readonly shader: WaveShaderMaterialSource;

  readonly skinned?: boolean | WaveShaderMaterialSkinningOptions;

  readonly storageBuffers?: readonly string[];

  readonly storeEffectOnSubMeshes?: boolean;

  readonly tags?: readonly string[];

  readonly uniforms?: WaveShaderUniformCollection;

  readonly version?: number;

  readonly vertexLayout?: readonly WaveShaderVertexAttributeDescriptor[];

}

interface WaveShaderMaterialRenderState {

  readonly alpha?: number;

  readonly alphaMode?: WaveShaderMaterialAlphaMode;

  readonly backFaceCulling?: boolean;

  readonly depthWrite?: boolean;

  readonly disableDepthWrite?: boolean;

  readonly doubleSided?: boolean;

  readonly needAlphaBlending?: boolean;

  readonly needAlphaTesting?: boolean;

  readonly needDepthPrePass?: boolean;

  readonly transparent?: boolean;

  readonly wireframe?: boolean;

}

interface WaveShaderMaterialSkinningOptions {

  readonly enabled?: boolean;

}

type WaveShaderMaterialSource = WaveShaderInlineSource | WaveShaderStoreSource | WaveShaderSourceRef;

type WaveShaderMatrix4Value = readonly [ number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number ];

type WaveShaderRecipeMetadata = Readonly<Record<string, WaveShaderRecipeMetadataValue>>;

type WaveShaderRecipeMetadataValue = string | number | boolean | null | readonly WaveShaderRecipeMetadataValue[] | { readonly [key: string]: WaveShaderRecipeMetadataValue; }

interface WaveShaderSamplerDefinition {

  readonly description?: string;

  readonly name: string;

}

type WaveShaderSamplerInput = string | WaveShaderSamplerDefinition;

interface WaveShaderSourceRef {

  readonly fragmentKey?: string;

  readonly key: string;

  readonly source?: WaveShaderInlineSourcePair;

  readonly vertexKey?: string;

}

interface WaveShaderStoreSource {

  readonly fragmentKey?: string;

  readonly key: string;

  readonly kind: "shaderStore";

  readonly vertexKey?: string;

}

interface WaveShaderTextureBinding {

  readonly samplerName: string;

  readonly textureRef: string;

}

type WaveShaderUniformCollection = readonly WaveShaderUniformInput[] | WaveShaderUniformMap;

interface WaveShaderUniformDefinition<TType extends WaveShaderUniformType = WaveShaderUniformType> extends WaveShaderUniformSpec<TType> {

  readonly name: string;

}

type WaveShaderUniformInput = string | WaveShaderUniformDefinition;

type WaveShaderUniformLiveBinding = "sceneElapsedSeconds" | "screenResolution" | "primaryCameraPosition";

type WaveShaderUniformLiveBindingForType<TType extends WaveShaderUniformType> = TType extends "float" ? "sceneElapsedSeconds" : TType extends "vec2" ? "screenResolution" : TType extends "vec3" ? "primaryCameraPosition" : never;

type WaveShaderUniformMap = Readonly<Record<string, WaveShaderUniformSpec>>;

interface WaveShaderUniformOptions<TType extends WaveShaderUniformType> {

  readonly binding?: WaveShaderUniformLiveBindingForType<TType>;

  readonly default?: WaveShaderUniformValue<TType>;

  readonly defaultValue?: WaveShaderUniformValue<TType>;

  readonly description?: string;

}

interface WaveShaderUniformSpec<TType extends WaveShaderUniformType = WaveShaderUniformType> {

  readonly binding?: WaveShaderUniformLiveBindingForType<TType>;

  readonly default?: WaveShaderUniformValue<TType>;

  readonly defaultValue?: WaveShaderUniformValue<TType>;

  readonly description?: string;

  readonly type: TType;

}

type WaveShaderUniformType = keyof WaveShaderUniformValueByType;

type WaveShaderUniformValue<TType extends WaveShaderUniformType = WaveShaderUniformType> = WaveShaderUniformValueByType[TType];

interface WaveShaderUniformValueByType {

  readonly bool: boolean;

  readonly color3: WaveShaderColor3Value;

  readonly color4: WaveShaderColor4Value;

  readonly float: number;

  readonly floatArray: readonly number[];

  readonly int: number;

  readonly mat4: WaveShaderMatrix4Value;

  readonly matrix: WaveShaderMatrix4Value;

  readonly vec2: WaveShaderVector2Value;

  readonly vec3: WaveShaderVector3Value;

  readonly vec4: WaveShaderVector4Value;

}

type WaveShaderVector2Value = readonly [number, number] | { readonly x: number; readonly y: number; }

type WaveShaderVector3Value = readonly [number, number, number] | { readonly x: number; readonly y: number; readonly z: number; }

type WaveShaderVector4Value = readonly [number, number, number, number] | { readonly x: number; readonly y: number; readonly z: number; readonly w: number; }

declare class WaveSimulation {

  get activeRigCollisions(): WaveActiveRigCollisionFacade;

  get gravity(): WaveSimulationGravity;

  observeSolvedContacts(entityIds: readonly number[], observer: (observation: PhysicsSolvedContactObservation) => void): () => void;

  pause(): this;

  resume(): this;

  setGravity(gravity: Vector3Like): this;

  setGravity(x: number, y: number, z: number): this;

  setTimeScale(value: number): this;

  stepOnce(stepCount?: number): this;

  useQuality(intent: WaveSimulationQualityIntent): this;

}

declare function waveSkinnedVertexStage(options?: WaveSkinnedVertexStageOptions): string;

interface WaveSkinnedVertexStageOptions {

  readonly bindPositionVarying?: string;

  readonly normalAttribute?: string;

  readonly positionAttribute?: string;

  readonly skinnedNormalVarying?: string;

  readonly skinnedPositionVarying?: string;

}

declare enum WaveSpace {

  PARENT = "parent",

  WORLD = "world",

}

declare class WaveSpawner {

  constructor(_ctx: SpawnerContext);

  mirror<T extends WaveSpatial3DObject>(input: T, options: MirrorOptions<T>): T;

  placeBatchAround(batch: waveThinBatch, options: ThinBatchAroundOptions): waveThinBatch;

  placeBatchInGrid(batch: waveThinBatch, options: ThinBatchInGridOptions): waveThinBatch;

  placeBatchInline(batch: waveThinBatch, options: ThinBatchInlineOptions): waveThinBatch;

  placeBatchInRange(batch: waveThinBatch, options: ThinBatchInRangeOptions): waveThinBatch;

  placeBatchOnPath(batch: waveThinBatch, options: ThinBatchOnPathOptions): waveThinBatch;

  placeBatchOnSurface(batch: waveThinBatch, options: ThinBatchOnSurfaceOptions): waveThinBatch;

  spawnAround<T extends WaveSpatial3DObject>(input: T, options: SpawnAroundOptions<T>): WaveGroup<T>;

  spawnAround<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, options: SpawnAroundOptions<T>): SpawnResultForArray<T>;

  spawnAround<T extends WaveSpatial3DObject>(input: WaveGroup<T>, options: SpawnAroundOptions<T>): WaveGroup<SpawnGroupMember<T>>;

  spawnByPlacements(input: WaveSpawnInput, placements: SpawnPlacement[], options: SpawnCommonOptions & { physics?: SpawnPhysicsOptions; _pathUp?: Vector3; _alignToTangent?: boolean; _resultGroupFactory?: (name: string, controller?: WaveSpatial3DObject) => WaveGroup<WaveSpatial3DObject>; }): WaveGroup<WaveSpatial3DObject>;

  spawnInGrid<T extends WaveSpatial3DObject>(input: T, options: SpawnInGridOptions<T>): WaveGroup<T>;

  spawnInGrid<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, options: SpawnInGridOptions<T>): SpawnResultForArray<T>;

  spawnInGrid<T extends WaveSpatial3DObject>(input: WaveGroup<T>, options: SpawnInGridOptions<T>): WaveGroup<SpawnGroupMember<T>>;

  spawnInline<T extends WaveSpatial3DObject>(input: T, options: SpawnInlineOptions<T>): WaveGroup<T>;

  spawnInline<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, options: SpawnInlineOptions<T>): SpawnResultForArray<T>;

  spawnInline<T extends WaveSpatial3DObject>(input: WaveGroup<T>, options: SpawnInlineOptions<T>): WaveGroup<SpawnGroupMember<T>>;

  spawnInRange<T extends WaveSpatial3DObject>(input: T, options: SpawnInRangeOptions<T>): WaveGroup<T>;

  spawnInRange<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, options: SpawnInRangeOptions<T>): SpawnResultForArray<T>;

  spawnInRange<T extends WaveSpatial3DObject>(input: WaveGroup<T>, options: SpawnInRangeOptions<T>): WaveGroup<SpawnGroupMember<T>>;

  spawnOnPath<T extends WaveSpatial3DObject>(input: T, path: WaveCurveInput, options?: SpawnOnPathOptions<T>): WaveGroup<T>;

  spawnOnPath<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, path: WaveCurveInput, options?: SpawnOnPathOptions<T>): SpawnResultForArray<T>;

  spawnOnPath<T extends WaveSpatial3DObject>(input: WaveGroup<T>, path: WaveCurveInput, options?: SpawnOnPathOptions<T>): WaveGroup<SpawnGroupMember<T>>;

  spawnOnSurface<T extends WaveSpatial3DObject>(input: T, options: SpawnOnSurfaceOptions<T>): WaveGroup<T>;

  spawnOnSurface<T extends WaveSpatial3DObject>(input: ReadonlyArray<T>, options: SpawnOnSurfaceOptions<T>): SpawnResultForArray<T>;

  spawnOnSurface<T extends WaveSpatial3DObject>(input: WaveGroup<T>, options: SpawnOnSurfaceOptions<T>): WaveGroup<SpawnGroupMember<T>>;

}

interface WaveSpeechCommandBuilder<TCommand extends string = string> {

  matchInterimTranscripts(enabled?: boolean): this;

  onCommand(callback: (match: WaveSpeechCommandMatch<TCommand>) => void): this;

  onEnd(callback: () => void): this;

  onError(callback: (error: WaveSpeechCommandSessionError) => void): this;

  onTranscript(callback: (event: WaveSpeechTranscriptEvent) => void): this;

  restartWhenEnded(enabled?: boolean): this;

  startListening(): WaveSpeechCommandSession<TCommand> | null;

  withCommand(command: WaveSpeechCommandSpec<TCommand>): this;

  withCommands(commands: readonly WaveSpeechCommandSpec<TCommand>[]): this;

  withContinuousListening(enabled?: boolean): this;

  withInterimTranscripts(enabled?: boolean): this;

  withLanguage(lang: string): this;

  withMaxAlternatives(count: number): this;

  withMinScore(score: number): this;

}

declare class WaveSpeechFxChainBuilder implements WaveSpeechFxConfig {

  constructor(nodes?: readonly WaveInstrumentFxNode[]);

  add(node: WaveInstrumentFxNode): this;

  chorus(options?: WaveSpeechFxNodeOptions<"chorus">): this;

  compressor(options?: WaveSpeechFxNodeOptions<"compressor">): this;

  convolver(options?: WaveSpeechFxNodeOptions<"convolver">): this;

  delay(options?: WaveSpeechFxNodeOptions<"delay">): this;

  distortion(options?: WaveSpeechFxNodeOptions<"distortion">): this;

  eq(options: WaveSpeechFxNodeOptions<"eq">): this;

  readonly fxChain: WaveInstrumentFxNode[];

  panner(options?: WaveSpeechFxNodeOptions<"panner">): this;

  simpleRoom(options?: WaveSpeechFxNodeOptions<"simpleRoom">): this;

  tremolo(options?: WaveSpeechFxNodeOptions<"tremolo">): this;

}

interface WaveSpeechTranscriptEvent {

  alternatives: readonly WaveSpeechTranscriptAlternative[];

  isFinal: boolean;

  resultIndex: number;

  timestamp: number;

  transcript: string;

}

declare class waveSphere extends waveGeometry {

  configureGeometry(configuration: WaveSpherePrimitiveRecipe | WavePrimitiveGeometryConfiguration<WaveSpherePrimitiveRecipe>): this;

  primitiveRecipe: WaveSpherePrimitiveRecipe;

  constructor(radius?: number, segments?: number);

  static readonly typeName: EntityType;

  asDome(diameter?: number, arc?: number, segments?: number): this;

  asIcoSphere(radius?: number, subdivisions?: number, flat?: boolean): this;

  asSphere(radius: number, segments?: number): this;

  get baseArc(): number;

  get baseCapSegments(): number;

  get baseEllipsoid(): { x: number; y: number; z: number; } | null;

  get baseHeightSegments(): number;

  get baseRadius(): number;

  get baseSlice(): number;

  get baseWidthSegments(): number;

  get capBase(): boolean;

  get capSides(): boolean;

  clearBaseEllipsoid(): this;

  face(surface: WaveSurface): ReturnType<cmp_visual3DModel["surface"]>;

  faceMaterial(surface: WaveSurface): ReturnType<cmp_visual3DModel["meshMaterialSlot"]>;

  get flat(): boolean;

  get heightSegments(): number;

  get radius(): number;

  get segments(): number;

  setBaseArc(arc: number): this;

  setBaseCapSegments(segments: number): this;

  setBaseEllipsoid(dx: number, dy: number, dz: number): this;

  setBaseHeightSegments(segments: number): this;

  setBaseRadius(radius: number): this;

  setBaseSegments(segments: number): this;

  setBaseSegments(widthSegments: number, heightSegments: number): this;

  setBaseSideOrientation(sideOrientation: number): this;

  setBaseSlice(slice: number): this;

  setBaseSubdivisions(subdivisions: number): this;

  setBaseWidthSegments(segments: number): this;

  setCapBase(capBase: boolean): this;

  setCapSides(capSides: boolean): this;

  setFlat(flat: boolean): this;

  setSideCapSegments(segments: number): this;

  get sideCapSegments(): number;

  get subdivisions(): number;

  get topology(): "uv" | "ico";

  get widthSegments(): number;

}

declare class WaveSplatMaterial {

  apply(): WaveMaterialInput<"splat">;

  readonly name: string;

  private(key?: string): this;

  shared(): this;

  constructor(name: string, definition?: MaterialSplatDefinition);

  above(height: number): this;

  albedo(texturePath: string): this;

  antiRepetition(config?: NonNullable<MaterialSplatConfiguration["antiTiling"]>): this;

  antiTiling(config: NonNullable<MaterialSplatConfiguration["antiTiling"]>): this;

  aoMap(texturePath: string): this;

  backface(options: MaterialSplatBackfaceOptions): this;

  base(materialPath: string): this;

  base(name: MaterialSplatLayerId, layer: MaterialSplatLayerInput): this;

  below(height: number): this;

  between(minHeight: number, maxHeight: number): this;

  blend(distance: number): this;

  build(): MaterialSplatDefinition;

  config(config: MaterialSplatConfiguration): this;

  configure(config: MaterialSplatConfiguration): this;

  cut(): this;

  get definition(): Readonly<MaterialSplatDefinition>;

  from(height: number): this;

  hardCut(): this;

  layer(materialPath: string): this;

  layer(name: MaterialSplatLayerId, layer: MaterialSplatLayerInput): this;

  metallic(value: number): this;

  metallicMap(texturePath: string): this;

  natural(seed?: number): this;

  naturalBlend(distance: number): this;

  noiseInfluence(value: number): this;

  normal(texturePath: string): this;

  normalizedRules(): this;

  orm(texturePath: string): this;

  paintable(blendMode?: NonNullable<MaterialSplatConfiguration["paint"]>["blendMode"]): this;

  priority(value: number): this;

  priorityRemainder(baseLayer?: MaterialSplatLayerId): this;

  roughness(value: number): this;

  roughnessMap(texturePath: string): this;

  rulesFollowLocalShape(): this;

  rulesFollowWorldHeight(): this;

  ruleSpace(space: MaterialSplatRuleSpace): this;

  slope(minSlope: number, maxSlope: number): this;

  get state(): Readonly<MaterialSplatDefinition>;

  stochastic(config: NonNullable<MaterialSplatConfiguration["stochastic"]>): this;

  strength(value: number): this;

  to(height: number): this;

  uvScale(value: number): this;

  variant(name: string): WaveSplatMaterial;

}

declare const waveSprite: { buildAnimation(id: string, options?: WaveSpriteAnimationOptions): WaveSpriteAnimationAsset };

declare class WaveSpriteAnimationAsset {

  constructor(name: string, options?: WaveSpriteAnimationOptions);

  animation(name: string): WaveSpriteAnimationRef;

  animation(name: string, input: WaveSpriteAnimationInput): this;

  configure(options: WaveSpriteAnimationOptions): this;

  fromCompiledAtlas(manifestAsset: string, pageTextureAssets: Readonly<Record<string, string>>, motionTextureAssets?: Readonly<Record<string, string>>): this;

  fromSpriteSheet(textureAsset: string, grid: WaveSpriteGridInput): this;

  fromTextureAtlas(atlasAsset: string): this;

  readonly name: string;

  sampling(input: WaveSpriteSamplingInput): this;

  toConfig(): WaveSpriteAnimationSerializedConfig;

  toDefinition(manifest: WaveTextureAtlasManifest): AssetDefinition<"texture">;

}

interface WaveSpriteAnimationBinding {

  readonly animation: string;

  readonly atlasAsset: string;

}

interface WaveSpriteAnimationInput {

  readonly driveByAge?: boolean;

  readonly durationsMs?: readonly number[];

  readonly fps?: number;

  readonly frames: WaveSpriteAnimationFrames;

  readonly interpolation?: WaveTextureAtlasInterpolation;

  readonly playMode?: WaveTextureAtlasPlayMode;

  readonly seamlessLoop?: boolean;

}

interface WaveSpriteAnimationOptions {

  readonly animations?: Readonly<Record<string, WaveSpriteAnimationInput>>;

  readonly pivot?: WaveTextureAtlasPoint;

  readonly sampling?: WaveSpriteSamplingInput;

  readonly source: WaveSpriteAnimationSource;

}

declare class WaveSpriteAnimationRef {

  constructor(asset: WaveSpriteAsset | WaveSpriteAnimationAsset, animationName: string);

  readonly animationName: string;

  readonly asset: WaveSpriteAsset | WaveSpriteAnimationAsset;

  get assetName(): string;

  toJSON(): WaveSpriteAnimationBinding;

}

type WaveSpriteAnimationSource = { readonly kind: "spriteSheet"; readonly textureAsset: string; readonly grid: WaveSpriteGridInput; } | { readonly kind: "textureAtlas"; readonly atlasAsset: string; } | { readonly kind: "compiledAtlas"; readonly manifestAsset: string; readonly pageTextureAssets: Readonly<Record<string, string>>; readonly motionTextureAssets?: Readonly<Record<string, string>>; }

interface WaveSpriteGridInput {

  readonly columns: number;

  readonly frameCount?: number;

  readonly rows: number;

}

interface WaveSpriteSamplingInput {

  readonly alphaMode?: WaveTextureAtlasAlphaMode;

  readonly filter?: WaveTextureAtlasFilter;

  readonly mipMode?: WaveTextureAtlasMipMode;

  readonly uvInset?: number;

}

declare class WaveStandardMaterial {

  apply(): WaveMaterialInput<"standard">;

  readonly name: string;

  private(key?: string): this;

  shared(): this;

  constructor(name: string, options?: WaveStandardMaterialOptions);

  color(value: ColorInput): this;

  configure(options: WaveStandardMaterialOptions): this;

  doubleSided(enabled?: boolean): this;

  opacity(alpha: number, transparent?: boolean): this;

  get options(): Readonly<WaveStandardMaterialOptions>;

  useAmbientTexture(textureRef: string): this;

  useDiffuseTexture(textureRef: string): this;

  useEmissiveTexture(textureRef: string): this;

  useNormalTexture(textureRef: string): this;

  useSpecularTexture(textureRef: string): this;

  uvOffset(x: number, y: number): this;

  uvRotation(degrees: number): this;

  uvScale(x: number, y?: number): this;

  variant(name: string, options?: WaveStandardMaterialOptions): WaveStandardMaterial;

  wireframe(enabled?: boolean): this;

}

interface WaveStandardMaterialOptions {

  readonly alpha?: number | undefined;

  readonly ambientTexture?: string | undefined;

  readonly bumpTexture?: string | undefined;

  readonly diffuseColor?: ColorInput | undefined;

  readonly diffuseTexture?: string | undefined;

  readonly doubleSided?: boolean | undefined;

  readonly emissiveColor?: ColorInput | undefined;

  readonly emissiveTexture?: string | undefined;

  readonly maxSimultaneousLights?: number | undefined;

  readonly specularColor?: ColorInput | undefined;

  readonly specularPower?: number | undefined;

  readonly specularTexture?: string | undefined;

  readonly transparent?: boolean | undefined;

  readonly uvOffset?: Vector2Like | undefined;

  readonly uvRotation?: number | undefined;

  readonly uvScale?: Vector2Like | undefined;

  readonly wireframe?: boolean | undefined;

}

declare enum WaveSurface {

  Back = "back",

  Backward = "backward",

  Bottom = "bottom",

  Down = "down",

  EndCap = "endCap",

  Forward = "forward",

  Front = "front",

  Inner = "inner",

  Left = "left",

  Outer = "outer",

  Right = "right",

  Side = "side",

  Slope = "slope",

  StartCap = "startCap",

  Top = "top",

  Up = "up",

}

type WaveSurfaceProjectionMode = "uv" | "planar" | "triplanar";

type WaveSurfaceProjectionSpace = "object" | "world";

interface WaveSurfaceProjectionSpec {

  readonly blendSharpness: number;

  readonly mode: WaveSurfaceProjectionMode;

  readonly offset: { readonly x: number; readonly y: number; readonly z: number; }

  readonly primaryDirection: { readonly x: number; readonly y: number; readonly z: number; }

  readonly scale: { readonly x: number; readonly y: number; readonly z: number; }

  readonly space: WaveSurfaceProjectionSpace;

}

declare class WaveTerrainBasinFeatureHandle extends WaveTerrainFeatureHandle<WaveTerrainBasinNode> {

  constructor(target: WaveTerrainFeatureEditorTarget, id: string);

  baseRadius(value: number): this;

  chain(count: number, layout?: WaveTerrainBasinChainLayout, length?: number): this;

  chainTo(x: number, z: number): this;

  depth(value: number): this;

  dry(): this;

  floorNoiseFrequency(value: number): this;

  floorRadius(value: number): this;

  floorRoughness(value: number): this;

  preset(value: BasinPreset): this;

  radius(value: number): this;

  region(region: "footprint" | "floor" | "wall" | "rim" | "water"): WaveTerrainFeatureRegionReference;

  rim(height: number, width: number, roughness?: number): this;

  seed(value: number): this;

  slice(fraction: number, options?: Partial<Omit<WaveTerrainAngularSliceIntent, "fraction">>): this;

  wallRoughness(value: number): this;

  wallSteepness(value: number): this;

  water(bodyModel: WaveWaterBodyModel, options?: { readonly inset?: number; readonly edgeJitter?: number; readonly resolution?: number; readonly uScale?: number; readonly vScale?: number; }): this;

  waterLevel(value: number): this;

}

declare class WaveTerrainFacade<TTerminal> extends WaveTerrainLayerBuilder<TTerminal> implements WaveTerrainSurface {

  constructor(_host: WaveTerrainFacadeHost<TTerminal>, terminal: () => TTerminal);

  bounds(): WaveTerrainWorldBounds | null;

  brush(): WaveTerrainRuntimeFacade<TTerminal>;

  getHeightAt(x: number, z: number): number | null;

  getNormalAt(x: number, z: number): SurfaceQueryResult["normal"] | null;

  heightAt(x: number, z: number): number | null;

  normalAt(x: number, z: number): SurfaceQueryResult["normal"] | null;

  query(): WaveTerrainQueryFacade;

  rayIntersection(origin: Vector3, direction: Vector3, length?: number): RayHit | null;

  remove(): TTerminal;

  get runtime(): WaveTerrainRuntimeFacade<TTerminal>;

}

declare class WaveTerrainFeatureHandle<TNode extends WaveTerrainNode = WaveTerrainNode> {

  constructor(_target: WaveTerrainFeatureEditorTarget, id: string, _expectedKind?: TNode["kind"] | undefined);

  apply(): this;

  at(x: number, z: number): this;

  disable(): this;

  enable(): this;

  enlargeBy(factor: number): this;

  readonly id: string;

  moveBackward(amount: number): this;

  moveBy(x: number, y: number, z: number): this;

  moveDown(amount: number): this;

  moveForward(amount: number): this;

  moveLeft(amount: number): this;

  moveRight(amount: number): this;

  moveUp(amount: number): this;

  placeAt(x: number, y: number, z: number): this;

  remove(): void;

  scaleBy(x: number, y?: number, z?: number): this;

  shrinkBy(factor: number): this;

  snapshot(): TNode;

  turnLeft(degrees: number): this;

  turnRight(degrees: number): this;

  update(patch: WaveTerrainFeaturePatch<TNode>): this;

}

interface WaveTerrainHeightfieldModelBuilder {

  apply(): WaveTerrainHeightfieldModelInput;

  withSeed(seed: number): WaveTerrainHeightfieldModelBuilder;

  withSize(width: number, depth: number): WaveTerrainHeightfieldModelBuilder;

  withSubdivisions(subdivisions: number): WaveTerrainHeightfieldModelBuilder;

  withSurfaceColor(color: ColorInput): WaveTerrainHeightfieldModelBuilder;

  withSurfaceDirection(direction: WaveHeightfieldSurfaceDirection): WaveTerrainHeightfieldModelBuilder;

}

type WaveTerrainHeightfieldModelInput = WaveModelInput<WaveTerrainHeightfieldModelRecipe>;

interface WaveTerrainHeightfieldModelRecipe {

  readonly depth?: number;

  readonly preset: TerrainPreset;

  readonly seed?: number;

  readonly subdivisions?: number;

  readonly surfaceColor?: WaveTerrainHeightfieldSurfaceColor;

  readonly surfaceDirection?: WaveHeightfieldSurfaceDirection;

  readonly version: typeof WAVE_TERRAIN_HEIGHTFIELD_MODEL_RECIPE_VERSION;

  readonly width?: number;

}

interface WaveTerrainHeightfieldSurfaceColor {

  readonly b: number;

  readonly g: number;

  readonly r: number;

}

declare class WaveTerrainLayerBuilder<TTerminal> {

  constructor(_target: WaveTerrainLayerBuilderTarget<TTerminal>);

  addBasin(id: string): WaveTerrainBasinFeatureHandle;

  addContourRelief(id: string): WaveTerrainContourReliefFeatureHandle;

  addErosion(id: string): WaveTerrainErosionFeatureHandle;

  addLevelArea(id: string): WaveTerrainLevelAreaFeatureHandle;

  addMountain(id: string): WaveTerrainMountainFeatureHandle;

  addRiver(id: string, path?: readonly { readonly x: number; readonly z: number; }[]): WaveTerrainRiverFeatureHandle;

  addTerraces(id: string): WaveTerrainTerracesFeatureHandle;

  addTrail(id: string, path?: readonly { readonly x: number; readonly z: number; }[]): WaveTerrainTrailFeatureHandle;

  apply(): TTerminal;

  avoidMaterialRepetition(enabled?: boolean): this;

  endless(): this;

  explainProfile(): WaveTerrainProfileExplanation;

  feature(id: string): WaveTerrainFeatureHandle;

  finiteGrid(columns: number, rows: number): this;

  keepAllTilesResident(): this;

  keepAroundCamera(columns: number, rows?: number, options?: { readonly prefetch?: number; }): this;

  material(material: WaveTerrainMaterialInput): this;

  get materials(): WaveTerrainMaterialsFacade;

  metalness(value: number): this;

  physics(enabled?: boolean): this;

  physicsWithinSquareTileGrid(sideLengthInTiles: number): this;

  preset(value: TerrainPreset): this;

  quality(value: TerrainQuality): this;

  removeFeature(id: string): this;

  roughness(value: number): this;

  seed(value: number): this;

  singleTile(): this;

  size(width: number, depth?: number): this;

  snapshot(): WaveTerrainLayerDefinition;

  style(value: TerrainStyle): this;

  subdivisions(value: number): this;

  tileMaterialEvery(meters: number): this;

  tileSize(width: number, depth?: number): this;

  use(definition: WaveTerrainLayerDefinitionLike): this;

  useMaterial(material: WaveTerrainMaterialInput): this;

}

declare class WaveTerrainLevelAreaFeatureHandle extends WaveTerrainFeatureHandle<WaveTerrainLevelAreaNode> {

  constructor(target: WaveTerrainFeatureEditorTarget, id: string);

  blendDistance(value: number): this;

  height(value: number): this;

  region(region: "level" | "blend" | "footprint"): WaveTerrainFeatureRegionReference;

  within(value: WaveTerrainBounds): this;

}

declare class WaveTerrainMaterialLayerHandle {

  constructor(_target: WaveTerrainMaterialBuilderTarget, id: string);

  above(height: number): this;

  apply(): this;

  avoidRepetition(enabled?: boolean): this;

  below(height: number): this;

  between(minHeight: number, maxHeight: number): this;

  blendOver(distance: number): this;

  clearRules(): this;

  disableHeightBlend(): this;

  heightBlend(options?: WaveTerrainMaterialHeightBlendInput): this;

  readonly id: string;

  metallic(value: number): this;

  noiseInfluence(value: number): this;

  on(feature: WaveTerrainFeatureRegionReference | string, region?: string): this;

  onSlopes(minDegrees: number, maxDegrees?: number): this;

  priority(value: number): this;

  projection(value: WaveTerrainMaterialProjectionInput): this;

  role(role: TerrainMaterialRole): this;

  roughness(value: number): this;

  snapshot(): WaveTerrainMaterialLayerSnapshot;

  strength(value: number): this;

  terrainUv(repetitions?: number): this;

  tileEvery(meters: number): this;

  use(material: WaveTerrainMaterialInput): this;

  worldAligned(tileEvery?: number): this;

  wrapCliffs(options?: { readonly tileEvery?: number; readonly blendSharpness?: number; }): this;

}

declare class WaveTerrainMaterialsFacade {

  constructor(_target: WaveTerrainMaterialBuilderTarget);

  allowPainting(options?: { readonly pageWidth?: number; readonly pageDepth?: number; readonly gutter?: number; readonly maxResidentPages?: number; readonly blendMode?: "override" | "add" | "max"; }): this;

  apply(): this;

  base(id: string): WaveTerrainMaterialLayerHandle;

  clear(): this;

  disablePainting(): this;

  layer(id: string): WaveTerrainMaterialLayerHandle;

  remove(id: string): this;

  snapshot(): WaveTerrainMaterialDefinition;

}

declare class WaveTerrainMountainFeatureHandle extends WaveTerrainFeatureHandle<WaveTerrainMountainNode> {

  constructor(target: WaveTerrainFeatureEditorTarget, id: string);

  baseRadius(value: number): this;

  baseSize(value: number): this;

  craterDepth(value: number): this;

  footprint(jitter: number, noiseScale?: number): this;

  fullShape(): this;

  geometryStyle(value: WaveTerrainMountainGeometryStyle): this;

  height(value: number): this;

  peakHeight(value: number): this;

  preset(value: MountainPreset): this;

  region(region: "footprint" | "slope" | "summit" | "crater"): WaveTerrainFeatureRegionReference;

  ridge(count: number, layout?: WaveTerrainMountainRidgeLayout, length?: number): this;

  ridgeAlong(path: readonly WaveTerrainPoint2[]): this;

  ridgeTo(x: number, z: number): this;

  roughness(value: number): this;

  secondaryPeaks(value: number): this;

  seed(value: number): this;

  slice(fraction: number, options?: Partial<Omit<WaveTerrainAngularSliceIntent, "fraction">>): this;

  top(options: { readonly radiusFactor?: number; readonly heightFactor?: number; readonly blendFactor?: number; }): this;

}

declare class WaveTerrainQueryFacade {

  constructor(_host: WaveTerrainQueryHost);

  getHeightAt(x: number, z: number): number | null;

  getNormalAt(x: number, z: number): SurfaceQueryResult["normal"] | null;

  heightAt(x: number, z: number): number | null;

  heightsInGrid(query: TerrainHeightGridQuery): Float32Array;

  heightsInGridToRef(query: TerrainHeightGridQuery, out: Float32Array): Float32Array;

  isReady(): boolean;

  normalAt(x: number, z: number): SurfaceQueryResult["normal"] | null;

  normalAtToRef<TOut extends SerializableVector3>(x: number, z: number, out: TOut): TOut | null;

  query(position: SurfaceQueryInput): SurfaceQueryResult | null;

  query(x: number, z: number): SurfaceQueryResult | null;

  raycast(origin: Vector3, direction: Vector3, length?: number): RayHit | null;

  rayIntersection(origin: Vector3, direction: Vector3, length?: number): RayHit | null;

  surfaceAt(x: number, z: number): SurfaceQueryResult | null;

  surfaceAtToRef<TOut extends TerrainSurfaceQueryRef>(x: number, z: number, out: TOut): TOut | null;

  whenReady(callback: () => void): () => void;

}

interface WaveTerrainReliefContourPath {

  readonly closed: boolean;

  readonly elevationMeters: number;

  readonly normalizedXZInt16LeBase64: string;

  readonly pointCount: number;

}

interface WaveTerrainReliefData {

  readonly contourPaths: readonly WaveTerrainReliefContourPath[];

  readonly displayName: string;

  readonly elevationRangeMeters: Readonly<{ minimum: number; maximum: number; }>;

  readonly generation: Readonly<{ generator: string; method: string; }>;

  readonly grid: WaveTerrainElevationGrid;

  readonly id: string;

  readonly recommendedWorldSizeMeters: Readonly<{ width: number; depth: number; }>;

  readonly schema: typeof WAVE_TERRAIN_RELIEF_DATA_SCHEMA;

  readonly sources: readonly WaveTerrainReliefSource[];

  readonly spatialReference: WaveTerrainReliefSpatialReference;

}

declare class WaveTerrainRiverFeatureHandle extends WaveTerrainFeatureHandle<WaveTerrainRiverNode> {

  constructor(target: WaveTerrainFeatureEditorTarget, id: string);

  along(path: readonly WaveTerrainPoint2[]): this;

  bankSlope(value: number): this;

  bedWidth(value: number): this;

  blendDistance(value: number): this;

  crossSection(value: WaveTerrainRiverCrossSection): this;

  depth(value: number): this;

  dry(): this;

  followDownhill(minimumSlope?: number, maximumSlope?: number): this;

  followPath(): this;

  fromSourceToMouth(sourceElevation: number, mouthElevation: number): this;

  gradeProfile(points: readonly WaveTerrainRiverElevationControlPoint[]): this;

  materials(value: WaveTerrainRiverMaterialRoles): this;

  meander(options: { readonly amplitude: number; readonly wavelength: number; readonly roughness?: number; }): this;

  noGoZone(options?: WaveTerrainRiverRangeOptions): WaveRange;

  noPlaceZone(options?: WaveTerrainRiverRangeOptions): WaveRange;

  preset(value: RiverPreset): this;

  region(region: TerrainRiverRegion): WaveTerrainFeatureRegionReference;

  seed(value: number): this;

  water(bodyModel: WaveWaterBodyModel, options: { readonly depth: number; readonly clearance?: number; readonly uScale?: number; readonly vScale?: number; }): this;

  waterUvs(uScale: number, vScale: number): this;

  width(value: number): this;

}

declare class WaveTerrainRuntimeFacade<TTerminal> {

  constructor(_host: WaveTerrainRuntimeFacadeHost<TTerminal>);

  applyBrush(operation: WaveTerrainRuntimeDeltaInput): TTerminal;

  captureCheckpoint(): WaveTerrainRuntimeCheckpoint;

  clear(): TTerminal;

  diagnostics(): WaveTerrainRuntimeDeltaDiagnostics;

  erase(materialId?: string): WaveTerrainBrushBuilder<TTerminal>;

  erosion(): WaveTerrainBrushBuilder<TTerminal>;

  level(): WaveTerrainBrushBuilder<TTerminal>;

  lower(): WaveTerrainBrushBuilder<TTerminal>;

  noise(): WaveTerrainBrushBuilder<TTerminal>;

  paint(materialId?: string): WaveTerrainBrushBuilder<TTerminal>;

  raise(): WaveTerrainBrushBuilder<TTerminal>;

  restoreCheckpoint(checkpoint: WaveTerrainRuntimeCheckpoint): TTerminal;

  smooth(): WaveTerrainBrushBuilder<TTerminal>;

  snapshot(): WaveTerrainRuntimeDeltaSet;

  terminal(): TTerminal;

}

declare class WaveTerrainTerracesFeatureHandle extends WaveTerrainFeatureHandle<WaveTerrainTerracesNode> {

  constructor(target: WaveTerrainFeatureEditorTarget, id: string);

  heightRange(minHeight: number, maxHeight: number): this;

  preset(value: TerracePreset): this;

  stepHeight(value: number): this;

  strength(value: number): this;

  within(value: WaveTerrainBounds): this;

}

declare class waveTerrainTile extends waveProp {

  constructor();

  static readonly typeName: EntityType;

  castToActor(_options?: CastToPropOptions): waveActor;

  castToProp(_options?: CastToPropOptions): waveProp;

  clone(_name?: string): this | null;

  cloneWithOptions(_name: string, _options: CloneOptions): this | null;

  deepClone(_name?: string): this | null;

  destroy(): void;

  getPhysicsBodyDomainAdapter(_body: PhysicsBodyComponentCore): PhysicsBodyDomainAdapter | null;

  getTransformDomainAdapter(transform: cmp_transform): TransformDomainAdapter | null;

  getVisual3DModelDomainAdapter(_model: cmp_visual3DModel): Visual3DModelDomainAdapter | null;

  noise(...args: Parameters<waveProp["noise"]>): ReturnType<waveProp["noise"]>;

  noise(operationId: string): WaveTerrainBrushBuilder<this>;

  removeMaterial(...args: Parameters<waveProp["removeMaterial"]>): this;

  useMaterial(...args: Parameters<waveProp["useMaterial"]>): this;

  usePrivateMaterial(...args: Parameters<waveProp["usePrivateMaterial"]>): this;

  usePublicMaterial(...args: Parameters<waveProp["usePublicMaterial"]>): this;

}

declare class WaveTerrainTrailFeatureHandle extends WaveTerrainFeatureHandle<WaveTerrainTrailNode> {

  constructor(target: WaveTerrainFeatureEditorTarget, id: string);

  along(path: readonly WaveTerrainPoint2[]): this;

  blendDistance(value: number): this;

  height(value: number): this;

  region(region: "centerline" | "surface" | "shoulder"): WaveTerrainFeatureRegionReference;

  width(value: number): this;

}

declare class waveTextBatch extends WaveObject {

  constructor(model?: WaveWorldTextModelInput);

  static readonly typeName = EntityType.waveTextBatch;

  commitLabels(): this;

  destroy(): void;

  forEach(callback: (label: WaveTextBatchLabelAuthoringScope, index: number, batch: waveTextBatch) => void): void;

  hide(): this;

  get length(): number;

  setLabels(labels: readonly WaveTextBatchLabel[]): this;

  show(): this;

  useModel(model: WaveWorldTextModelInput | WaveModelInput): this;

}

declare class WaveTextBatchLabelAuthoringScope {

  constructor(_batch: waveTextBatch, _index: number, _topologyRevision: number);

  get batch(): waveTextBatch;

  done(): waveTextBatch;

  getPosition(): Vector3;

  get index(): number;

  moveBy(direction: DirectionInput, units: number): this;

  moveX(units: number): this;

  moveY(units: number): this;

  moveZ(units: number): this;

  scaleBy(factor: number): this;

  setColor(color: ColorInputAlpha): this;

  setPosition(position: Vector3Like): this;

  setPosition(x: number, y: number, z: number): this;

  setSize(size: number): this;

  setText(text: string): this;

}

declare class waveThinBatch extends WaveObject<unknown, Vector3, Partial<ResolvedWorldTransformSnapshot>, "3d"> {

  constructor();

  static readonly typeName: EntityType;

  [Symbol.iterator](): Iterator<ThinBatchIndexAuthoringScope>;

  addComponent<T extends WaveComponent>(componentClassOrInstance: ComponentConstructor<T> | T, ...args: unknown[]): T | null;

  at(index: number): ThinBatchIndexAuthoringScope;

  get batchTransform(): cmp_thinBatchTransform;

  get capacity(): number;

  castToProp(index: number, options?: CastToPropOptions): waveProp;

  clearInstances(): this;

  commitAnimationBuffers(): this;

  commitBuffers(updateExisting?: boolean): this;

  deformGeometry(intent: WaveGeometryDeformIntent): this;

  destroy(): void;

  detectNear(target: ThinBatchNearTarget): ThinBatchNearDetectionScope;

  disableDetection(): this;

  disablePathFollow(): this;

  disableSurfaceAttachment(): this;

  enableDetection(tagMask?: bigint): this;

  enableFrustumCulling(radius: number): this;

  enablePathFollow(pathSource: PathFollowSource, options?: PathFollowOptions): this;

  enablePathFollow(pathTexture: PathFollowTexture, options?: PathFollowOptions): this;

  enablePathFollow(pathSource: PathFollowSource | PathFollowTexture, options?: PathFollowOptions): this;

  enlargeBy(index: number, factor: number): this;

  every(fn: (instance: ThinBatchIndexAuthoringScope, index: number, batch: waveThinBatch) => boolean): boolean;

  filter(fn: (instance: ThinBatchIndexAuthoringScope, index: number, batch: waveThinBatch) => boolean): ThinBatchIndexAuthoringScope[];

  find(fn: (instance: ThinBatchIndexAuthoringScope, index: number, batch: waveThinBatch) => boolean): ThinBatchIndexAuthoringScope | undefined;

  findIndex(fn: (instance: ThinBatchIndexAuthoringScope, index: number, batch: waveThinBatch) => boolean): number;

  fitBetween(index: number, start: WavePointInput, end: WavePointInput, options?: FitBetweenOptions): this;

  forEach(callback: (instance: ThinBatchIndexAuthoringScope, index: number, batch: waveThinBatch) => void): void;

  forEachIndex(callback: (index: number, batch: waveThinBatch) => void): void;

  getParent(): ParentableWaveEntity | null;

  getTransformDomainAdapter(transform: cmp_transform): TransformDomainAdapter | null;

  get hasInteractable(): boolean;

  get hasPhysicsBody(): boolean;

  indexAt(position: number): number;

  get instanceCount(): number;

  get interactable(): cmp_3dInteractable<this>;

  get isDetectionEnabled(): boolean;

  isModelRevisionConsumerCurrent(): boolean;

  get isPathFollowEnabled(): boolean;

  get isPhysicsBodyRequested(): boolean;

  get isSurfaceAttachmentEnabled(): boolean;

  get length(): number;

  map<R>(fn: (instance: ThinBatchIndexAuthoringScope, index: number, batch: waveThinBatch) => R): R[];

  get material(): MaterialEditorView;

  get mesh(): unknown | null;

  get modelName(): string;

  morphInto(target: wave3DObject, duration?: WaveTimeSpan): this;

  morphInto(target: wave3DObject, value: number, unit: WaveTimeUnit): this;

  morphIntoHeavy(target: wave3DObject, duration?: WaveTimeSpan): Promise<this>;

  morphIntoHeavy(target: wave3DObject, value: number, unit: WaveTimeUnit): Promise<this>;

  moveBy(index: number, axis: DirectionInput, units: number, frame?: ThinBatchTransformFrame): this;

  moveTo(index: number, position: WavePointInput, terms?: ThinBatchTransformTerms): this;

  moveX(index: number, units: number, frame?: ThinBatchTransformFrame): this;

  moveY(index: number, units: number, frame?: ThinBatchTransformFrame): this;

  moveZ(index: number, units: number, frame?: ThinBatchTransformFrame): this;

  get physicsBody(): cmp_thinBatchPhysicsBody<this>;

  populateFromTexture(textureAsset: string): ThinBatchTexturePopulationBuilder;

  reduce<R>(fn: (acc: R, instance: ThinBatchIndexAuthoringScope, index: number, batch: waveThinBatch) => R, initial: R): R;

  registerAttribute(kind: string, stride: number): this;

  replaceFollowCurrentModel(change: { readonly identity: { readonly id: string; }; readonly nextRef: ExactAssetRef<"model">; }): void;

  resolveSurfaceAttachmentContact(input: ThinBatchSurfaceAttachmentContactInput): ThinBatchSurfaceAttachmentContact | null;

  rotateAroundBy(index: number, axis: DirectionInput, degrees: number, frame?: ThinBatchTransformFrame): this;

  rotateAroundTo(index: number, axis: DirectionInput, degrees: number, frame?: ThinBatchTransformFrame): this;

  rotateBy(index: number, axis: DirectionInput, degrees: number, frame?: ThinBatchTransformFrame): this;

  rotateByQuaternion(index: number, delta: Quaternion, frame?: ThinBatchTransformFrame): this;

  rotateTo(index: number, rotation: Quaternion, terms?: ThinBatchTransformTerms): this;

  scaleAlongBy(index: number, axis: DirectionInput, factor: number, frame?: ThinBatchTransformFrame): this;

  scaleAlongTo(index: number, axis: DirectionInput, value: number, frame?: ThinBatchTransformFrame): this;

  scaleBy(index: number, value: number, terms?: ThinBatchTransformTerms): this;

  scaleTo(index: number, value: number | Vector3Like, terms?: ThinBatchTransformTerms): this;

  scaleTowardBy(index: number, axis: DirectionInput, factor: number, frame?: ThinBatchTransformFrame): this;

  scaleTowardTo(index: number, axis: DirectionInput, value: number, frame?: ThinBatchTransformFrame): this;

  setAmount(capacity: number): this;

  setAttributeAt(kind: string, index: number, value: number[], refresh?: boolean): this;

  setColor(index: number, color: ColorInput, alpha?: number): this;

  setColorRGBA(index: number, r: number, g: number, b: number, a?: number): this;

  setEmissiveColor(color: ColorInput): this;

  setEnvironmentIntensity(value: number): this;

  setInstanceAnimationTime(index: number, timeOffset: number): this;

  setInstanceCount(count: number): this;

  setInstanceMatrix(index: number, matrix: unknown, terms?: ThinBatchTransformTerms): this;

  setMaterialColor(color: ColorInput): this;

  setMeshPosition(position: WavePointInput): this;

  setMeshPosition(x: number, y: number, z: number): this;

  setMetalness(value: number): this;

  setMorphTarget(targetEntity: WaveGeometryMorphTarget): this;

  setOpacity(value: number): this;

  setParent(parent: ParentableWaveEntity | null): this;

  setPathFollowParams(index: number, params: PathFollowInstanceParams): this;

  setPosition(index: number, position: WavePointInput, terms?: ThinBatchTransformTerms): this;

  setRotation(index: number, rotation: Quaternion, terms?: ThinBatchTransformTerms): this;

  setRoughness(value: number): this;

  setScale(index: number, scale: Vector3Like, terms?: ThinBatchTransformTerms): this;

  setScale(index: number, uniform: number, terms?: ThinBatchTransformTerms): this;

  setScale(index: number, x: number, y: number, z: number, terms?: ThinBatchTransformTerms): this;

  setTransform(index: number, position: WavePointInput, rotation: Quaternion, scale: Vector3Like | number, terms?: ThinBatchTransformTerms): this;

  setVertexAnimation(vatAsset: VertexAnimationAsset, rangeName?: string, randomizeOffset?: boolean): this;

  setVisible(visible: boolean): this;

  shareMaterialWith(source: waveThinBatch | wave3DObject | unknown): this;

  shrinkBy(index: number, factor: number): this;

  some(fn: (instance: ThinBatchIndexAuthoringScope, index: number, batch: waveThinBatch) => boolean): boolean;

  get source(): ModelConsumerSource;

  get thinInstanceAnimator(): cmp_thinInstanceAnimator;

  toArray(): ThinBatchIndexAuthoringScope[];

  updateVATTime(deltaTime: number): this;

  useBox(options?: PrimitiveOptions): this;

  useCylinder(options?: PrimitiveOptions): this;

  useMesh(mesh: unknown): this;

  useModel(model: string | AssetRef<"model"> | WaveModelInput, options?: WaveThinBatchModelOptions): this;

  useSphere(options?: PrimitiveOptions): this;

  get vatAsset(): VertexAnimationAsset | null;

  get vatManager(): unknown | null;

  get voxelSize(): number; set voxelSize(value: number);

  whenBackClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenForwardClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenIndexClicked(callback: (index: number, ctx: InteractionContext<this>) => void, options?: InteractionCallbackOptions): CallbackHandle;

  whenLeftClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenMiddleClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

  whenRightClickedOn(callback: InteractionCallback<this>, options?: InteractionCallbackOptions): CallbackHandle;

}

declare const WaveTime: { now(): WaveTimePoint; span(value: number, unit: WaveTimeUnit): WaveTimeSpan; rate(value: number, unit: WaveRateUnit): WaveRate; };

declare class WaveTimeSpan implements WaveTimeSpanSpec {

  constructor(value: number, unit: WaveTimeUnitKind, fixedDelta?: number | null, resolved?: { ticks?: number | null; seconds?: number | null; });

  atLeast(value: number, unit: WaveTimeUnit): boolean;

  readonly fixedDelta: number | null;

  readonly kind = "span";

  readonly resolvedSeconds: number | null;

  readonly resolvedTicks: number | null;

  toSeconds(fixedDelta?: number): number;

  toTicks(fixedDelta?: number): number;

  readonly unit: WaveTimeUnitKind;

  readonly value: number;

}

declare class waveTorus extends waveGeometry {

  configureGeometry(configuration: WaveTorusPrimitiveRecipe | WavePrimitiveGeometryConfiguration<WaveTorusPrimitiveRecipe>): this;

  primitiveRecipe: WaveTorusPrimitiveRecipe;

  constructor(radius?: number, tubeRadius?: number, tessellation?: number);

  static readonly typeName: EntityType;

  asTorus(radius: number, tubeRadius: number, tessellation?: number): this;

  get baseArc(): number;

  get baseBackUVs(): unknown | null;

  get baseFrontUVs(): unknown | null;

  get baseRadius(): number;

  get baseThickness(): number;

  clearBaseBackUVs(): this;

  clearBaseFrontUVs(): this;

  get radius(): number;

  setBaseArc(arc: number): this;

  setBaseBackUVs(backUVs: unknown): this;

  setBaseFrontUVs(frontUVs: unknown): this;

  setBaseRadius(radius: number): this;

  setBaseSegments(segments: number): this;

  setBaseSideOrientation(sideOrientation: number): this;

  setBaseTubeRadius(tubeRadius: number): this;

  get tessellation(): number;

  get tubeRadius(): number;

}

declare class waveTorusKnot extends waveGeometry {

  configureGeometry(configuration: WaveTorusKnotPrimitiveRecipe | WavePrimitiveGeometryConfiguration<WaveTorusKnotPrimitiveRecipe>): this;

  primitiveRecipe: WaveTorusKnotPrimitiveRecipe;

  constructor(radius?: number, tubeRadius?: number, tessellation?: number, p?: number, q?: number);

  static readonly typeName: EntityType;

  asTorusKnot(radius: number, tubeRadius: number, tessellation?: number, p?: number, q?: number): this;

  get baseRadius(): number;

  get radius(): number;

  setBaseRadius(radius: number): this;

  setBaseSegments(segments: number): this;

  setBaseTubeRadius(tubeRadius: number): this;

  setWindingNumbers(p: number, q: number): this;

  get tessellation(): number;

  get tubeRadius(): number;

  get windingP(): number;

  get windingQ(): number;

}

declare class WaveTransform2DAnimationBuilder {

  after(duration: WaveTimeSpan): this;

  after(value: number, unit: WaveTimeUnit): this;

  atRateOf(rate: WaveRate): this;

  atRateOf(value: number, unit: WaveRateUnit): this;

  for(duration: WaveTimeSpan): this;

  for(value: number, unit: WaveTimeUnit): this;

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): this;

  withCallbacks(callbacks: TransitionLifecycleCallbacks<WaveTransform2DProgressState>, options?: WaveAuthoredCallbackOptions): this;

  withEasingEffect(ease: WaveEasing): this;

  withProgressCurve(curve: WaveValueCurveInput): this;

  constructor(_root: cmp_transform2D, _executor: Wave2DTransformExecutor, _intent: WaveTransform2DIntent);

  play(): WaveTransform2DAnimationHandle;

  withTolerance(degrees: number): this;

}

declare class WaveTransform2DAnimationHandle {

  constructor(_root: cmp_transform2D, registration: WaveTransform2DAnimationRegistration, _viewId: string | null);

  readonly animationId: number;

  cancel(policy: TransitionCancellationPolicy): void;

  get controller(): TransitionLifecycleHandle<WaveTransform2DAnimationState>["controller"];

  get failed(): boolean;

  get lastProgress(): number;

  get lastState(): WaveTransform2DAnimationState;

  get loopCount(): number;

  onComplete(callback?: Parameters<TransitionLifecycleHandle<WaveTransform2DAnimationState>["onComplete"]>[0]): this;

  onLoopComplete(callback?: Parameters<TransitionLifecycleHandle<WaveTransform2DAnimationState>["onLoopComplete"]>[0]): this;

  onProgress(callback?: Parameters<TransitionLifecycleHandle<WaveTransform2DAnimationState>["onProgress"]>[0]): this;

  onStart(callback?: Parameters<TransitionLifecycleHandle<WaveTransform2DAnimationState>["onStart"]>[0]): this;

  onUpdate(callback?: Parameters<TransitionLifecycleHandle<WaveTransform2DAnimationState>["onUpdate"]>[0]): this;

  pause(): void;

  restart(): void;

  resume(): void;

  setSpeed(speed: number): void;

  stop(): void;

  thenDo(step: Parameters<TransitionLifecycleHandle<WaveTransform2DAnimationState>["thenDo"]>[0]): ReturnType<TransitionLifecycleHandle<WaveTransform2DAnimationState>["thenDo"]>;

  withCallbacks(callbacks?: TransitionLifecycleCallbacks<WaveTransform2DAnimationState>): this;

}

declare class WaveTransform2DAuthoring {

  acceleration(): Vector2;

  accelerationMagnitude(): number;

  alignDirectionWith(target: WaveTransform2DEntityTarget): cmp_transform2D;

  alignDirectionWith(target: WaveTransform2DEntityTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  alignDirectionWith(target: WaveTransform2DEntityTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  alignDirectionWith(target: WaveTransform2DEntityTarget, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  angularRate(): number;

  applyParentSnapshot(snapshot: WaveTransform2DFrameSnapshotPatch): cmp_transform2D;

  applyWorldSnapshot(snapshot: WaveTransform2DFrameSnapshotPatch): cmp_transform2D;

  authoredPoseSnapshot(): WaveTransform2DPoseSnapshot;

  bodyBounds(): WaveLayoutBodyBox;

  cancelAnimations(policy: TransitionCancellationPolicy): cmp_transform2D;

  clearHistory(): cmp_transform2D;

  distanceTo(target: WaveTransform2DTurnTarget): number;

  done(): cmp_transform2D;

  down(): Vector2;

  downExtent(): number;

  downFaceCenter(): Vector2;

  fitBetween(start: WaveTransform2DFitTarget, end: WaveTransform2DFitTarget): cmp_transform2D;

  fitBetween(start: WaveTransform2DFitTarget, end: WaveTransform2DFitTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DFitBetweenBuilder;

  fitBetween(start: WaveTransform2DFitTarget, end: WaveTransform2DFitTarget, mode: TransformVerbMode.Animate): WaveTransform2DFitBetweenAnimationBuilder;

  fitBetween(start: WaveTransform2DFitTarget, end: WaveTransform2DFitTarget, options: WaveTransform2DFitOptions): cmp_transform2D;

  getHistorySample(when: WaveTimeLookback): WaveTransform2DHistorySample | null;

  getHistorySamples(): readonly WaveTransform2DHistorySample[];

  get historyDepth(): number;

  get historySampleCount(): number;

  inFrameOf(target: WaveTransform2DEntityTarget): WaveTransform2DAuthoring;

  inLocalFrame(): WaveTransform2DAuthoring;

  inLocalTerms(): WaveTransform2DAuthoring;

  inParentFrame(depth?: number): WaveTransform2DAuthoring;

  inParentTerms(): WaveTransform2DAuthoring;

  inView(cameraId: string): WaveTransform2DAuthoring;

  inWorldFrame(): WaveTransform2DAuthoring;

  inWorldTerms(): WaveTransform2DAuthoring;

  isFacing(target: WaveTransform2DTurnTarget, options?: WaveOrient2DOptions): boolean;

  get isMotionReady(): boolean;

  get isRecordingHistory(): boolean;

  keepMoving(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepMovingDown(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepMovingLeft(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepMovingRight(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepMovingUp(unitsPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlong(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepScalingAlongBy(direction: WaveDirection2DInput, factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongDownBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongLeftBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongRightBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingAlongUpBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingBy(): WaveTransform2DAnimationBuilder;

  keepScalingToward(direction: WaveDirection2DInput): WaveTransform2DAnimationBuilder;

  keepScalingTowardBy(direction: WaveDirection2DInput, factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardDownBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardLeftBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardRightBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepScalingTowardUpBy(factorPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepTurningLeft(degreesPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  keepTurningRight(degreesPerSecond: number, durationSeconds?: number): WaveTransform2DAnimationHandle;

  left(): Vector2;

  leftExtent(): number;

  leftFaceCenter(): Vector2;

  get motionReadiness(): WaveTransform2DMotionReadiness;

  moveBy(delta: Vector2Like): cmp_transform2D;

  moveBy(delta: Vector2Like, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveBy(delta: Vector2Like, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveBy(direction: WaveDirection2DInput, distance: number): cmp_transform2D;

  moveBy(direction: WaveDirection2DInput, distance: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveBy(direction: WaveDirection2DInput, distance: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveTo(target: WaveTransform2DMoveTarget): cmp_transform2D;

  moveTo(target: WaveTransform2DMoveTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveTo(target: WaveTransform2DMoveTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveTo(target: WaveTransform2DMoveTarget, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  moveX(distance: number): cmp_transform2D;

  moveX(distance: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveX(distance: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveX(distance: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  moveY(distance: number): cmp_transform2D;

  moveY(distance: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  moveY(distance: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  moveY(distance: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  parentSnapshot(): WaveTransform2DFrameSnapshot;

  parentSnapshot(when: WaveTimeLookback): WaveTransform2DFrameSnapshot | null;

  pivot(): Vector2;

  pivotAt(value: Vector2Like): cmp_transform2D;

  pivotAt(value: Vector2Like, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  pivotAt(value: Vector2Like, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  pivotAt(value: Vector2Like, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  pivotFraction(): SerializableVector2;

  position(): SerializableVector2;

  position(when: WaveTimeLookback): SerializableVector2 | null;

  recordHistory(options?: TransformHistoryRecordingOptions): cmp_transform2D;

  resetPivot(): cmp_transform2D;

  resolvedFaceCenter(side: WaveBodySide2D): Vector2;

  right(): Vector2;

  rightExtent(): number;

  rightFaceCenter(): Vector2;

  get root(): cmp_transform2D;

  rotateBy(degrees: number): cmp_transform2D;

  rotateBy(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  rotateBy(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  rotateBy(degrees: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  rotateTo(degrees: number): cmp_transform2D;

  rotateTo(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  rotateTo(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  rotateTo(degrees: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  rotation(): number;

  rotation(when: WaveTimeLookback): number | null;

  scale(): SerializableVector2;

  scale(when: WaveTimeLookback): SerializableVector2 | null;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number): cmp_transform2D;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleAlongBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleAlongTo(direction: WaveDirection2DInput, value: number): cmp_transform2D;

  scaleAlongTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleAlongTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleBy(value: number | Vector2Like): cmp_transform2D;

  scaleBy(value: number | Vector2Like, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleBy(value: number | Vector2Like, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleBy(value: number | Vector2Like, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  scaleTo(value: number | Vector2Like): cmp_transform2D;

  scaleTo(value: number | Vector2Like, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTo(value: number | Vector2Like, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTo(value: number | Vector2Like, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number): cmp_transform2D;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTowardBy(direction: WaveDirection2DInput, factor: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  scaleTowardTo(direction: WaveDirection2DInput, value: number): cmp_transform2D;

  scaleTowardTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  scaleTowardTo(direction: WaveDirection2DInput, value: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  setHistoryDepth(depth: number): cmp_transform2D;

  speed(): number;

  speedAlong(direction: WaveDirection2DInput): number;

  speedDeclineRate(): number;

  speedGrowthRate(): number;

  stopRecordingHistory(options?: { clear?: boolean; }): cmp_transform2D;

  transition(): WaveTransform2DPoseTransitionBuilder;

  transitionTo(pose: WaveTransform2DPoseSnapshot): WaveTransform2DPoseTransitionBuilder;

  turnLeft(degrees: number): cmp_transform2D;

  turnLeft(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnLeft(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnLeft(degrees: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  turnRight(degrees: number): cmp_transform2D;

  turnRight(degrees: number, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnRight(degrees: number, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnRight(degrees: number, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  turnTo(target: WaveTransform2DTurnTarget): cmp_transform2D;

  turnTo(target: WaveTransform2DTurnTarget, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnTo(target: WaveTransform2DTurnTarget, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnTo(target: WaveTransform2DTurnTarget, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  turnToward(direction: WaveDirection2DInput): cmp_transform2D;

  turnToward(direction: WaveDirection2DInput, mode: TransformVerbMode.Snapshot): WaveTransform2DSnapshotBuilder;

  turnToward(direction: WaveDirection2DInput, mode: TransformVerbMode.Animate): WaveTransform2DAnimationBuilder;

  turnToward(direction: WaveDirection2DInput, mode?: TransformVerbModeInput): WaveTransform2DVerbResult;

  up(): Vector2;

  upExtent(): number;

  upFaceCenter(): Vector2;

  vectorFrom(source: WaveTransform2DTurnTarget): Vector2;

  vectorTo(target: WaveTransform2DTurnTarget): Vector2;

  velocity(): Vector2;

  worldSnapshot(): WaveTransform2DFrameSnapshot;

  worldSnapshot(when: WaveTimeLookback): WaveTransform2DFrameSnapshot | null;

}

declare class WaveTransform2DFitBetweenAnimationBuilder {

  after(duration: WaveTimeSpan): WaveTransform2DFitBetweenAnimationBuilder;

  after(value: number, unit: WaveTimeUnit): WaveTransform2DFitBetweenAnimationBuilder;

  along(axis: WaveTransform2DFitAxis): WaveTransform2DFitBetweenAnimationBuilder;

  atRateOf(rate: WaveRate): WaveTransform2DFitBetweenAnimationBuilder;

  atRateOf(value: number, unit: WaveRateUnit): WaveTransform2DFitBetweenAnimationBuilder;

  between(start: any, end: any): WaveTransform2DFitBetweenAnimationBuilder;

  centered(): WaveTransform2DFitBetweenAnimationBuilder;

  from(start: any): WaveTransform2DFitBetweenAnimationBuilder;

  fromEnd(): WaveTransform2DFitBetweenAnimationBuilder;

  fromStart(): WaveTransform2DFitBetweenAnimationBuilder;

  over(duration: WaveTimeSpan): WaveTransform2DFitBetweenAnimationBuilder;

  over(value: number, unit: WaveTimeUnit): WaveTransform2DFitBetweenAnimationBuilder;

  to(end: any): WaveTransform2DFitBetweenAnimationBuilder;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): WaveTransform2DFitBetweenAnimationBuilder;

  withCallbacks(callbacks: TransitionLifecycleCallbacks<WaveTransform2DProgressState>, options?: WaveAuthoredCallbackOptions): WaveTransform2DFitBetweenAnimationBuilder;

  withEasingEffect(ease: WaveEasing): WaveTransform2DFitBetweenAnimationBuilder;

  withOptions(options: WaveTransform2DFitOptions): WaveTransform2DFitBetweenAnimationBuilder;

  withoutScaling(): WaveTransform2DFitBetweenAnimationBuilder;

  withProgressCurve(curve: WaveValueCurveInput): WaveTransform2DFitBetweenAnimationBuilder;

  withScaling(enable?: boolean): WaveTransform2DFitBetweenAnimationBuilder;

  constructor(_root: cmp_transform2D, _executor: Wave2DTransformExecutor, _fitIntent: WaveTransform2DFitIntent);

  play(): WaveTransform2DAnimationHandle;

}

declare class WaveTransform2DFitBetweenBuilder {

  along(axis: WaveTransform2DFitAxis): WaveTransform2DFitBetweenBuilder;

  between(start: any, end: any): WaveTransform2DFitBetweenBuilder;

  centered(): WaveTransform2DFitBetweenBuilder;

  from(start: any): WaveTransform2DFitBetweenBuilder;

  fromEnd(): WaveTransform2DFitBetweenBuilder;

  fromStart(): WaveTransform2DFitBetweenBuilder;

  to(end: any): WaveTransform2DFitBetweenBuilder;

  withOptions(options: WaveTransform2DFitOptions): WaveTransform2DFitBetweenBuilder;

  withoutScaling(): WaveTransform2DFitBetweenBuilder;

  withScaling(enable?: boolean): WaveTransform2DFitBetweenBuilder;

  constructor(_root: cmp_transform2D, _executor: Wave2DTransformExecutor, _fitIntent: WaveTransform2DFitIntent);

  take(): WaveTransform2DPoseSnapshot;

  take(id: string): WaveTransform2DSnapshotMetadata;

}

declare class WaveTransform2DPoseTransitionBuilder {

  after(duration: WaveTimeSpan): this;

  after(value: number, unit: WaveTimeUnit): this;

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): this;

  withCallbacks(callbacks: TransitionLifecycleCallbacks<WaveTransform2DProgressState>, options?: WaveAuthoredCallbackOptions): this;

  withEasingEffect(ease: WaveEasing): this;

  withProgressCurve(curve: WaveValueCurveInput): this;

  constructor(_root: cmp_transform2D, _viewId: string | null, target?: WaveTransform2DPoseSnapshot);

  from(pose: WaveTransform2DPoseSnapshot): this;

  play(): WaveTransform2DAnimationHandle;

  to(pose: WaveTransform2DPoseSnapshot): this;

}

declare class WaveTransform2DSnapshotBuilder {

  constructor(_root: cmp_transform2D, _executor: Wave2DTransformExecutor, _intent: WaveTransform2DIntent);

  animate(): WaveTransform2DAnimationBuilder;

  apply(): cmp_transform2D;

  take(): WaveTransform2DPoseSnapshot;

  take(id: string): WaveTransform2DSnapshotMetadata;

  withTolerance(degrees: number): this;

}

interface WaveTransform2DTermsScope extends WaveTransform2DTermsScopeSurface {

  inView(cameraId: string): WaveTransform2DTermsScope;

}

type WaveTransform2DTermsScopeSurface = Pick<WaveTransform2DAuthoring, "root" | "done" | "position" | "rotation" | "scale" | "pivot" | "pivotFraction" | "left" | "right" | "up" | "down" | "bodyBounds" | "leftExtent" | "rightExtent" | "upExtent" | "downExtent" | "resolvedFaceCenter" | "leftFaceCenter" | "rightFaceCenter" | "upFaceCenter" | "downFaceCenter" | "velocity" | "acceleration" | "speed" | "angularRate" | "speedAlong" | "moveTo" | "moveBy" | "keepMoving" | "moveX" | "moveY" | "rotateTo" | "scaleTo" | "scaleBy" | "keepScalingBy">;

declare class WaveTransformAnimationBuilder {

  after(duration: WaveTimeSpan): this;

  after(value: number, unit: WaveTimeUnit): this;

  atRateOf(rate: WaveRate): this;

  atRateOf(value: number, unit: WaveRateUnit): this;

  for(duration: WaveTimeSpan): this;

  for(value: number, unit: WaveTimeUnit): this;

  over(duration: WaveTimeSpan): this;

  over(value: number, unit: WaveTimeUnit): this;

  withCallbackPolicy(options: WaveAuthoredCallbackOptions): this;

  withCallbacks(callbacks: TransitionLifecycleCallbacks<Record<string, number>>, options?: WaveAuthoredCallbackOptions): this;

  withEasingEffect(ease: WaveEasing): this;

  withProgressCurve(curve: WaveValueCurveInput): this;

  constructor(_executor: WaveTransformIntentAnimationExecutor, _intent: TransformVerbIntent);

  byLocking(direction: DirectionInput): this;

  play(): TransitionLifecycleHandle<Record<string, number>>;

  withTolerance(degrees: number): this;

}

declare class WaveTransformSnapshotTimelineBuilder {

  constructor(_host: WaveTransformTimelineHost, _name: string);

  addKeyframe(snapshot: WaveModelTransformSnapshotMetadata, at: WaveModelSnapshotKeyframeMetadata["at"], easing?: WaveModelSnapshotKeyframeMetadata["easing"]): this;

  at(time: WaveAnimationTimeInput, unit?: WaveTimeUnit): WaveTransformSnapshotTimelineTimeScope;

  create(): WaveTransformSnapshotClipHandle;

  loop(): this;

  loopOnce(): this;

  pingPong(): this;

  play(options?: WaveTransformTimelinePlayOptions): TransitionLifecycleHandle<Record<string, number>>;

  register(options?: WaveTransformTimelineRegisterOptions): WaveTransformSnapshotClipHandle;

}

declare class WaveTransformSnapshotTimelineTimeScope {

  constructor(_builder: WaveTransformSnapshotTimelineBuilder, _at: WaveModelSnapshotKeyframeMetadata["at"]);

  use(snapshot: WaveModelTransformSnapshotMetadata, easing?: WaveModelSnapshotKeyframeMetadata["easing"]): WaveTransformSnapshotTimelineBuilder;

}

type WaveTreeModelBuilder = BuilderWithMethods<typeof TREE_PARTS, WaveTreeModelMethods>;

interface WaveTreeModelMethods {

  grownFromSeed(seed: number): WaveTreeModelBuilder;

  optimizeFor(profile: TreeOptimizationProfile): WaveTreeModelBuilder;

  species(species: TreeSpeciesInput): WaveTreeModelBuilder;

  withAutumnLeaves(): WaveTreeModelBuilder;

  withFoliageDensity(density: TreeFoliageDensity): WaveTreeModelBuilder;

  withFoliageTint(tint: ColorInput, secondaryTint?: ColorInput): WaveTreeModelBuilder;

  withLeafColor(color: ColorInput, secondaryColor?: ColorInput): WaveTreeModelBuilder;

  withLeafColors(colors: TreeLeafColorsInput): WaveTreeModelBuilder;

  withLeafPalette(palette: TreeLeafPalette): WaveTreeModelBuilder;

  withNaturalHeight(height: number): WaveTreeModelBuilder;

  withRecipe(recipe: TreeRecipeSnapshot): WaveTreeModelBuilder;

  withSeed(seed: number): WaveTreeModelBuilder;

  withSpecies(species: TreeSpeciesInput): WaveTreeModelBuilder;

  withTrunkColor(color: ColorInput): WaveTreeModelBuilder;

  withWind(wind: TreeWindIntent): WaveTreeModelBuilder;

}

declare class WaveTriggerVolume extends WaveRange {

  constructor(name: string, shape: WaveRangeShape | undefined, syncHelper: WaveRangeHelperSync | undefined, resolveModel: WaveRangeModelResolver | undefined, matchEntity: WaveRangeEntityMatcher | undefined, queryEntities: WaveTriggerVolumeEntityQuery | undefined, _callbackScope: WaveAuthoredCallbackScope);

  disposeTriggerObservers(): void;

  isInside<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject>(entity: TEntity): boolean;

  isOutside<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject>(entity: TEntity): boolean;

  observe<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject>(target: WaveTriggerVolumeTarget<TEntity>, options?: WaveTriggerVolumeObservationOptions): WaveTriggerVolumeObserverBuilder<TEntity>;

  setEntityQuery(queryEntities: WaveTriggerVolumeEntityQuery | undefined): this;

  setShape(shape: WaveRangeShape): this;

  stateOf<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject>(entity: TEntity): ReadonlyEntityStateApi<TEntity, WaveTriggerVolumeOccupancyStateValue>;

  trackStateOf<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject>(target: WaveTriggerVolumeStateTarget<TEntity>, options?: WaveTriggerVolumeObservationOptions): WaveTriggerVolumeHandle;

  whenEnteredBy<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject>(target: WaveTriggerVolumeTarget<TEntity>, options?: WaveTriggerVolumeObservationOptions): WaveTriggerVolumeEventBuilder<TEntity>;

  whenExitedBy<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject>(target: WaveTriggerVolumeTarget<TEntity>, options?: WaveTriggerVolumeObservationOptions): WaveTriggerVolumeEventBuilder<TEntity>;

  whileOccupiedBy<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject>(target: WaveTriggerVolumeTarget<TEntity>, options?: WaveTriggerVolumeObservationOptions): WaveTriggerVolumeEventBuilder<TEntity>;

}

declare class WaveTriggerVolumeEventBuilder<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject> {

  constructor(_trigger: WaveTriggerVolume, _eventKind: WaveTriggerVolumeEventKindValue, _target: WaveTriggerVolumeTarget<TEntity>, _options: WaveTriggerVolumeObservationOptions);

  do(callback: WaveTriggerVolumeCallback<TEntity>): WaveTriggerVolumeHandle;

  every(value: number, unit: WaveTimeUnit): this;

  everyTick(): this;

  once(): this;

}

declare class WaveTriggerVolumeHandle {

  constructor(id: string, _dispose: (id: string) => void);

  dispose(): void;

  readonly id: string;

}

declare class WaveTriggerVolumeObserverBuilder<TEntity extends WaveSpatial3DObject = WaveSpatial3DObject> {

  constructor(_trigger: WaveTriggerVolume, _target: WaveTriggerVolumeTarget<TEntity>, _options: WaveTriggerVolumeObservationOptions);

  onEnter(callback: WaveTriggerVolumeCallback<TEntity>): WaveTriggerVolumeHandle;

  onExit(callback: WaveTriggerVolumeCallback<TEntity>): WaveTriggerVolumeHandle;

  onStay(callback: WaveTriggerVolumeCallback<TEntity>): WaveTriggerVolumeHandle;

}

interface WaveTTSBackend {

  readonly voice1: WaveTTSBackend;

  readonly voice10: WaveTTSBackend;

  readonly voice2: WaveTTSBackend;

  readonly voice3: WaveTTSBackend;

  readonly voice4: WaveTTSBackend;

  readonly voice5: WaveTTSBackend;

  readonly voice6: WaveTTSBackend;

  readonly voice7: WaveTTSBackend;

  readonly voice8: WaveTTSBackend;

  readonly voice9: WaveTTSBackend;

  readonly config: WaveTTSConfig;

  readonly id: string;

  readonly kind: "tts";

  readonly preload?: WaveLocalNeuralTTSPreloadConfig;

  readonly provider: WaveTTSProvider;

  readonly voiceSlots: readonly WaveTTSVoiceSlotConfig[];

}

interface WaveUIAtlasManifest {

  readonly frames: Readonly<Record<string, WaveUIAtlasManifestFrame>>;

  readonly schemaVersion?: string;

  readonly texture: { readonly width: number; readonly height: number; readonly paddingPx?: number; readonly extrusionPx?: number; }

}

interface WaveUIAtlasManifestFrame {

  readonly atlasRect?: WaveUISourceRect;

  readonly originalSize?: WaveUISourceSize;

  readonly rotated?: boolean;

  readonly slice?: WaveUINineSliceMargins;

  readonly sourceRect: WaveUISourceRect;

  readonly trimOffset?: { readonly x: number; readonly y: number; }

}

interface WaveUIAtlasManifestRef {

  readonly assetRef: WaveUIAtlasManifestAssetRef;

  readonly data: WaveUIAtlasManifest;

}

interface WaveUIAtlasSource {

  readonly manifest: WaveUIAtlasManifestRef;

  readonly sampling: { readonly filter: "nearest" | "linear"; readonly mipmaps: "none" | "generated"; readonly colorSpace: "srgb"; readonly alphaMode: "straight"; readonly extrusionTexels: number; readonly rotatedFrames: "reject"; }

  readonly sourcePixelsPerLogicalUnit: number;

  readonly texture: WaveUITextureAssetRef;

}

declare class waveUIButton extends wave2DObject {

  clearAppearanceOverrides(): this;

  clearOpacity(): this;

  hide(): this;

  interactable: cmp_2dInteractable<waveUIButton>;

  removeSkin(): this;

  setContentAlignment(h: UIHorizontalAlignInput, v: UIVerticalAlignInput): this;

  setOpacity(opacity: number, mode: typeof Animate): WaveUIPropertyAnimationBuilder;

  setOpacity(opacity: number, mode: typeof Snapshot): WaveUIPropertyPreview;

  setOpacity(opacity: number): this;

  setVisible(visible: boolean): this;

  show(): this;

  stopTrackingPointer(): this;

  trackPointer(options?: WaveUIPointerTrackingOptions): this;

  useSkin(role: WaveUISkinRoleHandle): this;

  constructor(options?: WaveUIOptions);

  static readonly typeName: EntityType;

  clearBackgroundColor(): this;

  clearCornerRadius(): this;

  clearFontFamily(): this;

  clearFontSize(): this;

  clearTextColor(): this;

  setBackgroundColor(color: ColorInput | string): this;

  setCornerRadius(radius: number): this;

  setFontFamily(fontFamily: string): this;

  setFontSize(size: number): this;

  setText(text: string): this;

  setTextColor(color: ColorInput | string): this;

  setTextWrapping(wrapping: UITextWrapping | boolean): this;

  whenClicked(callback: UI2DClickCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

}

declare class waveUICanvas extends wave2DObject {

  clearAppearanceOverrides(): this;

  clearOpacity(): this;

  hide(): this;

  interactable: cmp_2dInteractable<waveUICanvas>;

  removeSkin(): this;

  setContentAlignment(h: UIHorizontalAlignInput, v: UIVerticalAlignInput): this;

  setOpacity(opacity: number, mode: typeof Animate): WaveUIPropertyAnimationBuilder;

  setOpacity(opacity: number, mode: typeof Snapshot): WaveUIPropertyPreview;

  setOpacity(opacity: number): this;

  setVisible(visible: boolean): this;

  show(): this;

  stopTrackingPointer(): this;

  trackPointer(options?: WaveUIPointerTrackingOptions): this;

  useSkin(role: WaveUISkinRoleHandle): this;

  constructor(options?: WaveUIOptions);

  static skin(id: string): WaveUICanvasSkinBuilder;

  static readonly typeName: EntityType;

  asMaterial(materialId: string, options?: WavePBRMaterialOptions): WaveMaterialInput<"pbr">;

  asTexture(assetName: string): WaveUICanvasTextureBuilder;

  attachToMesh(mesh: UICanvasMeshTarget, options?: Omit<UICanvasMeshBindingOptions, "elementName">): this;

  attachToMesh(mesh: UICanvasMeshTarget, channel?: UICanvasMeshTextureChannel): this;

  capturePixels(): WaveUICanvasPixelData | null;

  clearBorder(): this;

  clearCornerRadius(): this;

  clearCurves(): this;

  clearPath(name: string): this;

  clearPaths(): this;

  definePath(name: string, renderer?: (path: UICanvasPathBuilder) => void): UICanvasPathBuilder;

  detachFromMesh(mesh: UICanvasMeshTarget, options?: Omit<UICanvasMeshBindingOptions, "elementName">): this;

  detachFromMesh(mesh: UICanvasMeshTarget, channel?: UICanvasMeshTextureChannel): this;

  drawSvg(image: WaveUICanvasImageSource, x?: number, y?: number, width?: number, height?: number): this;

  drawValueCurve(curve: UICanvasValueCurveInput, options?: UICanvasValueCurvePlotOptions): this;

  drawWith(callback: WaveUICanvasDrawCallback, options?: Omit<UICanvasCallbackOptions, "elementName">): this;

  enableInteraction(): this;

  getCurve(strokeId?: string): UICanvasCurveStroke;

  getCurves(): UICanvasCurveStroke[];

  getPath(name: string): UICanvasPathBuilder;

  hasPath(name: string): boolean;

  loadCurves(strokes: readonly UICanvasCurveStroke[]): this;

  pointerDraw(): UICanvasPointerDrawBuilder<this>;

  publishTexture(assetName: string, options?: WaveUICanvasTextureOptions): string;

  requestRedraw(): this;

  setBorder(width: number, color: ColorInput | string): this;

  setCornerRadius(radius: number): this;

  setPixels(pixels: WaveUICanvasPixelData): this;

  setRedrawPolicy(policy: WaveUICanvasRedrawPolicy): this;

  setResolution(width: number, height: number): this;

  toDataURL(type?: string): string;

  undoCurve(): this;

  whenClicked(callback: UI2DCanvasClickCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenPointerMoved(callback: UI2DCanvasPointerCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenPointerPressed(callback: UI2DCanvasPointerCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenPointerReleased(callback: UI2DCanvasPointerCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

}

type WaveUICanvasCompositeOperation = UICanvasCompositeOperation;

type WaveUICanvasDrawCallback = (painter: WaveUICanvasPainter, width: number, height: number) => void;

type WaveUICanvasFillRule = UICanvasFillRule;

interface WaveUICanvasGradient {

  addColorStop(offset: number, color: string): void;

}

type WaveUICanvasImageSource = string | WaveUICanvasPixelData;

type WaveUICanvasLineCap = UICanvasLineCap;

type WaveUICanvasLineJoin = UICanvasLineJoin;

type WaveUICanvasMatrix = UICanvasAffine2D;

interface WaveUICanvasMutablePixelData {

  readonly data: Uint8ClampedArray;

  readonly height: number;

  readonly width: number;

}

type WaveUICanvasPaint = string | WaveUICanvasGradient;

interface WaveUICanvasPainter {

  arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;

  arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void;

  beginPath(): void;

  bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;

  clearRect(x: number, y: number, width: number, height: number): void;

  clip(fillRule?: WaveUICanvasFillRule): void;

  closePath(): void;

  createImageData(width: number, height: number): WaveUICanvasMutablePixelData;

  createLinearGradient(x0: number, y0: number, x1: number, y1: number): WaveUICanvasGradient;

  createRadialGradient(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number): WaveUICanvasGradient;

  dataColor(red: number, green: number, blue: number, alpha?: number): string;

  drawImage(source: WaveUICanvasImageSource, destinationX: number, destinationY: number): void;

  drawImage(source: WaveUICanvasImageSource, destinationX: number, destinationY: number, destinationWidth: number, destinationHeight: number): void;

  drawImage(source: WaveUICanvasImageSource, sourceX: number, sourceY: number, sourceWidth: number, sourceHeight: number, destinationX: number, destinationY: number, destinationWidth: number, destinationHeight: number): void;

  ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise?: boolean): void;

  fill(fillRule?: WaveUICanvasFillRule): void;

  fillRect(x: number, y: number, width: number, height: number): void;

  fillStyle: WaveUICanvasPaint;

  fillText(text: string, x: number, y: number, maxWidth?: number): void;

  font: string;

  getLineDash(): number[];

  getTransform(): WaveUICanvasTransform;

  globalAlpha: number;

  globalCompositeOperation: WaveUICanvasCompositeOperation;

  imageSmoothingEnabled: boolean;

  lineCap: WaveUICanvasLineCap;

  lineDashOffset: number;

  lineJoin: WaveUICanvasLineJoin;

  lineTo(x: number, y: number): void;

  lineWidth: number;

  measureText(text: string): WaveUICanvasTextMetrics;

  miterLimit: number;

  moveTo(x: number, y: number): void;

  paintPath(path: UICanvasPathBuilder): void;

  putImageData(imageData: WaveUICanvasPixelData, destinationX: number, destinationY: number, dirtyX?: number, dirtyY?: number, dirtyWidth?: number, dirtyHeight?: number): void;

  quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void;

  rect(x: number, y: number, width: number, height: number): void;

  resetTransform(): void;

  restore(): void;

  rotate(angleRadians: number): void;

  roundRect(x: number, y: number, width: number, height: number, radius: number): void;

  save(): void;

  scale(x: number, y?: number): void;

  setLineDash(segments: readonly number[]): void;

  setTransform(transform: WaveUICanvasTransform): void;

  setTransform(a: number, b: number, c: number, d: number, e: number, f: number): void;

  stroke(): void;

  strokeRect(x: number, y: number, width: number, height: number): void;

  strokeStyle: WaveUICanvasPaint;

  strokeText(text: string, x: number, y: number, maxWidth?: number): void;

  textAlign: WaveUICanvasTextAlign;

  textBaseline: WaveUICanvasTextBaseline;

  transform(a: number, b: number, c: number, d: number, e: number, f: number): void;

  translate(x: number, y: number): void;

}

interface WaveUICanvasPixelData {

  readonly data: Uint8Array | Uint8ClampedArray;

  readonly height: number;

  readonly width: number;

}

type WaveUICanvasRedrawPolicy = { readonly kind: "onDemand"; } | { readonly kind: "continuous"; readonly everyFrames?: number; }

interface WaveUICanvasSkinTextOptions {

  readonly color?: ColorInput | string;

  readonly fontFamily?: string;

  readonly fontSize?: number;

}

type WaveUICanvasTextAlign = UICanvasTextAlign;

type WaveUICanvasTextBaseline = UICanvasTextBaseline;

interface WaveUICanvasTextMetrics {

  readonly actualBoundingBoxAscent: number;

  readonly actualBoundingBoxDescent: number;

  readonly actualBoundingBoxLeft: number;

  readonly actualBoundingBoxRight: number;

  readonly alphabeticBaseline: number;

  readonly emHeightAscent: number;

  readonly emHeightDescent: number;

  readonly fontBoundingBoxAscent: number;

  readonly fontBoundingBoxDescent: number;

  readonly hangingBaseline: number;

  readonly ideographicBaseline: number;

  readonly width: number;

}

type WaveUICanvasTextureColorSpace = "srgb" | "linear";

interface WaveUICanvasTextureOptions {

  readonly generateMipMaps?: boolean | undefined;

  readonly invertY?: boolean | undefined;

  readonly sampling?: GpuDataTextureSamplingMode | undefined;

  readonly wrapU?: GpuDataTextureWrapMode | undefined;

  readonly wrapV?: GpuDataTextureWrapMode | undefined;

  readonly colorSpace?: WaveUICanvasTextureColorSpace;

}

interface WaveUICanvasTransform {

  readonly a: number;

  readonly b: number;

  readonly c: number;

  readonly d: number;

  readonly e: number;

  readonly f: number;

}

type WaveUIControlKind = "panel" | "text" | "image" | "button" | "progressBar" | "slider" | "toggle" | "textInput" | "textArea" | "dropdown" | "canvas";

declare class waveUICrosshair extends waveUICanvas {

  constructor(opts?: CrosshairOptions);

  static readonly typeName: EntityType;

  setArmLength(length: number): this;

  setCrosshairColor(color: DrawColor): this;

  setCrosshairSize(size: number): this;

  setDot(radius: number, color?: DrawColor): this;

  setGap(gap: number): this;

  setLineWidth(width: number): this;

}

declare class waveUIDropdown extends wave2DObject {

  clearAppearanceOverrides(): this;

  clearOpacity(): this;

  hide(): this;

  interactable: cmp_2dInteractable<waveUIDropdown>;

  removeSkin(): this;

  setContentAlignment(h: UIHorizontalAlignInput, v: UIVerticalAlignInput): this;

  setOpacity(opacity: number, mode: typeof Animate): WaveUIPropertyAnimationBuilder;

  setOpacity(opacity: number, mode: typeof Snapshot): WaveUIPropertyPreview;

  setOpacity(opacity: number): this;

  setVisible(visible: boolean): this;

  show(): this;

  stopTrackingPointer(): this;

  trackPointer(options?: WaveUIPointerTrackingOptions): this;

  useSkin(role: WaveUISkinRoleHandle): this;

  constructor(options?: WaveUIOptions);

  static readonly typeName: EntityType;

  clearBackgroundColor(): this;

  clearBorder(): this;

  clearFontFamily(): this;

  clearFontSize(): this;

  clearTextColor(): this;

  setBackgroundColor(color: ColorInput | string): this;

  setBorder(width: number, color: ColorInput | string): this;

  setFontFamily(fontFamily: string): this;

  setFontSize(size: number): this;

  setOptions(options: readonly UIDropdownOptionInput[]): this;

  setPlaceholder(placeholder: string): this;

  setTextColor(color: ColorInput | string): this;

  setValue(value: string): this;

  whenSelectionChanged(callback: UI2DInputCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

}

interface WaveUIFrameRef {

  readonly atlasId: string;

  readonly frameId: string;

}

declare class waveUIHandGestureOverlay extends waveUICanvas {

  constructor(opts?: HandGestureOverlayOptions);

  static readonly typeName: EntityType;

  clearVisionSnapshot(): this;

  setMirrored(mirrored: boolean): this;

  setOverlayColors(options: HandGestureOverlayColorOptions): this;

  setOverlaySize(width: number, height: number): this;

  setVisionSnapshot(snapshot: VisionSnapshot | null, timestamp?: number): this;

  showLabels(visible: boolean): this;

  showPalmCenter(visible: boolean): this;

}

declare class waveUIImage extends wave2DObject {

  clearAppearanceOverrides(): this;

  clearOpacity(): this;

  hide(): this;

  interactable: cmp_2dInteractable<waveUIImage>;

  removeSkin(): this;

  setContentAlignment(h: UIHorizontalAlignInput, v: UIVerticalAlignInput): this;

  setOpacity(opacity: number, mode: typeof Animate): WaveUIPropertyAnimationBuilder;

  setOpacity(opacity: number, mode: typeof Snapshot): WaveUIPropertyPreview;

  setOpacity(opacity: number): this;

  setVisible(visible: boolean): this;

  show(): this;

  stopTrackingPointer(): this;

  trackPointer(options?: WaveUIPointerTrackingOptions): this;

  useSkin(role: WaveUISkinRoleHandle): this;

  constructor(options?: WaveUIOptions);

  static readonly typeName: EntityType;

  clearCornerRadius(): this;

  clearImageCell(): this;

  clearTintColor(): this;

  setCornerRadius(radius: number): this;

  setImage(src: string): this;

  setImageCell(cellWidth: number, cellHeight: number, cellId: number): this;

  setTintColor(color: ColorInput | string): this;

}

interface WaveUIInsets {

  readonly bottom: number;

  readonly left: number;

  readonly right: number;

  readonly top: number;

}

type WaveUIInsetsInput = number | Partial<WaveUIInsets>;

interface WaveUIInteractionSelector {

  readonly checked?: boolean;

  readonly disclosure?: "collapsed" | "expanded";

  readonly enabled?: boolean;

  readonly focus?: "blurred" | "focused";

  readonly pointer?: "idle" | "hovered" | "pressed";

  readonly selection?: "unselected" | "selected";

}

interface WaveUIInteractionVariant {

  readonly apply: WaveUISkinStylePatch;

  readonly when: WaveUIInteractionSelector;

}

type WaveUIMaterialRecipe = { readonly kind: "solid"; readonly color: WaveUIColorInput; } | { readonly kind: "sprite"; readonly frame: WaveUIFrameRef; readonly fit: "stretch" | "contain" | "cover" | "tile"; readonly tint?: WaveUIColorInput; readonly opacity?: number; } | { readonly kind: "nineSlice"; readonly frame: WaveUIFrameRef; readonly tint?: WaveUIColorInput; readonly opacity?: number; }

interface WaveUINineSliceMargins {

  readonly bottom: number;

  readonly left: number;

  readonly right: number;

  readonly top: number;

}

interface WaveUIOptions {

  readonly name?: string;

  readonly network?: NetworkOptions;

}

declare class waveUIPanel extends wave2DObject {

  clearAppearanceOverrides(): this;

  clearOpacity(): this;

  hide(): this;

  interactable: cmp_2dInteractable<waveUIPanel>;

  removeSkin(): this;

  setContentAlignment(h: UIHorizontalAlignInput, v: UIVerticalAlignInput): this;

  setOpacity(opacity: number, mode: typeof Animate): WaveUIPropertyAnimationBuilder;

  setOpacity(opacity: number, mode: typeof Snapshot): WaveUIPropertyPreview;

  setOpacity(opacity: number): this;

  setVisible(visible: boolean): this;

  show(): this;

  stopTrackingPointer(): this;

  trackPointer(options?: WaveUIPointerTrackingOptions): this;

  useSkin(role: WaveUISkinRoleHandle): this;

  constructor(options?: WaveUIOptions);

  static readonly typeName: EntityType;

  clearBackgroundColor(): this;

  clearBorder(): this;

  clearCornerRadius(): this;

  setBackgroundColor(color: ColorInput | string): this;

  setBorder(width: number, color: ColorInput | string): this;

  setCornerRadius(radius: number): this;

}

declare class waveUIProgressBar extends wave2DObject {

  clearAppearanceOverrides(): this;

  clearOpacity(): this;

  hide(): this;

  interactable: cmp_2dInteractable<waveUIProgressBar>;

  removeSkin(): this;

  setContentAlignment(h: UIHorizontalAlignInput, v: UIVerticalAlignInput): this;

  setOpacity(opacity: number, mode: typeof Animate): WaveUIPropertyAnimationBuilder;

  setOpacity(opacity: number, mode: typeof Snapshot): WaveUIPropertyPreview;

  setOpacity(opacity: number): this;

  setVisible(visible: boolean): this;

  show(): this;

  stopTrackingPointer(): this;

  trackPointer(options?: WaveUIPointerTrackingOptions): this;

  useSkin(role: WaveUISkinRoleHandle): this;

  constructor(options?: WaveUIOptions);

  static readonly typeName: EntityType;

  clearBackgroundColor(): this;

  clearCornerRadius(): this;

  clearFillColor(): this;

  setBackgroundColor(color: ColorInput | string): this;

  setCornerRadius(radius: number): this;

  setFillColor(color: ColorInput | string): this;

  setProgress(value: number, max?: number): this;

}

type WaveUIRoleParts = { readonly kind: "panel"; readonly surface: string; } | { readonly kind: "text"; } | { readonly kind: "image"; readonly image: string; } | { readonly kind: "button"; readonly surface: string; readonly icon?: string; } | { readonly kind: "progress"; readonly track: string; readonly fill: string; } | { readonly kind: "slider"; readonly track: string; readonly fill: string; readonly thumb: string; } | { readonly kind: "toggle"; readonly surface: string; readonly indicator?: string; readonly thumb?: string; } | { readonly kind: "textEntry"; readonly surface: string; readonly icon?: string; } | { readonly kind: "dropdown"; readonly surface: string; readonly indicator?: string; readonly optionRole: string; } | { readonly kind: "canvas"; }

declare class WaveUISkinAsset {

  constructor(definition: WaveUISkinDefinition);

  get compiledByteSize(): number;

  readonly definition: WaveUISkinDefinition;

  readonly id: string;

  readonly revision: number;

  role(roleId: string): WaveUISkinRoleHandle;

  readonly signature: string;

}

interface WaveUISkinDefinition {

  readonly atlases: Readonly<Record<string, WaveUIAtlasSource>>;

  readonly compiledByteBudget?: number;

  readonly id: string;

  readonly materials: Readonly<Record<string, WaveUIMaterialRecipe>>;

  readonly revision?: number;

  readonly roles: Readonly<Record<string, WaveUISkinRoleDefinition>>;

  readonly variantAxes?: Readonly<Record<string, readonly string[]>>;

}

interface WaveUISkinMetrics {

  readonly contentPadding?: WaveUIInsetsInput;

  readonly minimumHeight?: number;

  readonly minimumWidth?: number;

  readonly visualOutsets?: WaveUIInsetsInput;

}

interface WaveUISkinRoleDefinition {

  readonly appearance?: WaveUIProceduralAppearance;

  readonly controls: readonly WaveUIControlKind[];

  readonly interactionVariants?: readonly WaveUIInteractionVariant[];

  readonly metrics?: WaveUISkinMetrics;

  readonly parts: WaveUIRoleParts;

  readonly themeVariants?: readonly WaveUIThemeVariant[];

  readonly typography?: WaveUITypography;

}

declare class WaveUISkinRoleHandle {

  toJSON(): WaveUISkinBinding;

}

declare class WaveUISkinScope {

  dispose(): void;

  readonly id: string;

  get revision(): number;

  role(roleId: string): WaveUISkinRoleHandle;

  setVariant(axis: string, value: string): this;

  get skin(): WaveUISkinAsset;

  snapshot(): WaveUISkinScopeSnapshot;

}

interface WaveUISkinStylePatch {

  readonly appearance?: WaveUIProceduralAppearance;

  readonly materials?: Partial<Readonly<Record<WaveUIStylePart, string>>>;

  readonly typography?: WaveUITypography;

}

declare class waveUISlider extends wave2DObject {

  clearAppearanceOverrides(): this;

  clearOpacity(): this;

  hide(): this;

  interactable: cmp_2dInteractable<waveUISlider>;

  removeSkin(): this;

  setContentAlignment(h: UIHorizontalAlignInput, v: UIVerticalAlignInput): this;

  setOpacity(opacity: number, mode: typeof Animate): WaveUIPropertyAnimationBuilder;

  setOpacity(opacity: number, mode: typeof Snapshot): WaveUIPropertyPreview;

  setOpacity(opacity: number): this;

  setVisible(visible: boolean): this;

  show(): this;

  stopTrackingPointer(): this;

  trackPointer(options?: WaveUIPointerTrackingOptions): this;

  useSkin(role: WaveUISkinRoleHandle): this;

  constructor(options?: WaveUIOptions);

  static readonly typeName: EntityType;

  clearBackgroundColor(): this;

  setBackgroundColor(color: ColorInput | string): this;

  setRange(min: number, max: number, step?: number): this;

  setValue(value: number): this;

  whenValueChanged(callback: UI2DSliderCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

}

interface WaveUISourceRect {

  readonly height: number;

  readonly width: number;

  readonly x: number;

  readonly y: number;

}

interface WaveUISourceSize {

  readonly height: number;

  readonly width: number;

}

type WaveUIStylePart = "surface" | "image" | "icon" | "track" | "fill" | "thumb" | "indicator";

declare class waveUIText extends wave2DObject {

  clearAppearanceOverrides(): this;

  clearOpacity(): this;

  hide(): this;

  interactable: cmp_2dInteractable<waveUIText>;

  removeSkin(): this;

  setContentAlignment(h: UIHorizontalAlignInput, v: UIVerticalAlignInput): this;

  setOpacity(opacity: number, mode: typeof Animate): WaveUIPropertyAnimationBuilder;

  setOpacity(opacity: number, mode: typeof Snapshot): WaveUIPropertyPreview;

  setOpacity(opacity: number): this;

  setVisible(visible: boolean): this;

  show(): this;

  stopTrackingPointer(): this;

  trackPointer(options?: WaveUIPointerTrackingOptions): this;

  useSkin(role: WaveUISkinRoleHandle): this;

  constructor(options?: WaveUIOptions);

  static readonly typeName: EntityType;

  clearBackgroundColor(): this;

  clearFontFamily(): this;

  clearFontSize(): this;

  clearTextColor(): this;

  setBackgroundColor(color: ColorInput | string): this;

  setFontFamily(fontFamily: string): this;

  setFontSize(size: number): this;

  setText(text: string): this;

  setTextColor(color: ColorInput | string): this;

  setTextWrapping(wrapping: UITextWrapping | boolean): this;

  useFont(font: string | AssetRef<"font"> | ExactAssetRef<"font">): this;

}

declare class waveUITextArea extends wave2DObject {

  clearAppearanceOverrides(): this;

  clearOpacity(): this;

  hide(): this;

  interactable: cmp_2dInteractable<waveUITextArea>;

  removeSkin(): this;

  setContentAlignment(h: UIHorizontalAlignInput, v: UIVerticalAlignInput): this;

  setOpacity(opacity: number, mode: typeof Animate): WaveUIPropertyAnimationBuilder;

  setOpacity(opacity: number, mode: typeof Snapshot): WaveUIPropertyPreview;

  setOpacity(opacity: number): this;

  setVisible(visible: boolean): this;

  show(): this;

  stopTrackingPointer(): this;

  trackPointer(options?: WaveUIPointerTrackingOptions): this;

  useSkin(role: WaveUISkinRoleHandle): this;

  constructor(options?: WaveUIOptions);

  static readonly typeName: EntityType;

  clearBackgroundColor(): this;

  clearBorder(): this;

  clearFontFamily(): this;

  clearFontSize(): this;

  clearTextColor(): this;

  setBackgroundColor(color: ColorInput | string): this;

  setBorder(width: number, color: ColorInput | string): this;

  setFontFamily(fontFamily: string): this;

  setFontSize(size: number): this;

  setMaxContentHeight(maxContentHeight: number): this;

  setPlaceholder(placeholder: string): this;

  setScrollable(enabled?: boolean, maxContentHeight?: number): this;

  setTextColor(color: ColorInput | string): this;

  setValue(value: string): this;

  whenTextChanged(callback: UI2DInputCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

}

declare class waveUITextInput extends wave2DObject {

  clearAppearanceOverrides(): this;

  clearOpacity(): this;

  hide(): this;

  interactable: cmp_2dInteractable<waveUITextInput>;

  removeSkin(): this;

  setContentAlignment(h: UIHorizontalAlignInput, v: UIVerticalAlignInput): this;

  setOpacity(opacity: number, mode: typeof Animate): WaveUIPropertyAnimationBuilder;

  setOpacity(opacity: number, mode: typeof Snapshot): WaveUIPropertyPreview;

  setOpacity(opacity: number): this;

  setVisible(visible: boolean): this;

  show(): this;

  stopTrackingPointer(): this;

  trackPointer(options?: WaveUIPointerTrackingOptions): this;

  useSkin(role: WaveUISkinRoleHandle): this;

  constructor(options?: WaveUIOptions);

  static readonly typeName: EntityType;

  clearBackgroundColor(): this;

  clearBorder(): this;

  clearFontFamily(): this;

  clearFontSize(): this;

  clearTextColor(): this;

  setBackgroundColor(color: ColorInput | string): this;

  setBorder(width: number, color: ColorInput | string): this;

  setFontFamily(fontFamily: string): this;

  setFontSize(size: number): this;

  setPlaceholder(placeholder: string): this;

  setTextColor(color: ColorInput | string): this;

  setValue(value: string): this;

  submitOnEnter(enabled?: boolean): this;

  whenSubmitted(callback: UI2DInputSubmitCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

  whenTextChanged(callback: UI2DInputCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

}

interface WaveUIThemeVariant {

  readonly apply: WaveUISkinStylePatch;

  readonly when: Readonly<Record<string, string>>;

}

declare class waveUIToggle extends wave2DObject {

  clearAppearanceOverrides(): this;

  clearOpacity(): this;

  hide(): this;

  interactable: cmp_2dInteractable<waveUIToggle>;

  removeSkin(): this;

  setContentAlignment(h: UIHorizontalAlignInput, v: UIVerticalAlignInput): this;

  setOpacity(opacity: number, mode: typeof Animate): WaveUIPropertyAnimationBuilder;

  setOpacity(opacity: number, mode: typeof Snapshot): WaveUIPropertyPreview;

  setOpacity(opacity: number): this;

  setVisible(visible: boolean): this;

  show(): this;

  stopTrackingPointer(): this;

  trackPointer(options?: WaveUIPointerTrackingOptions): this;

  useSkin(role: WaveUISkinRoleHandle): this;

  constructor(options?: WaveUIOptions);

  static readonly typeName: EntityType;

  clearBackgroundColor(): this;

  setBackgroundColor(color: ColorInput | string): this;

  setChecked(state: boolean): this;

  whenToggled(callback: UI2DToggleCallback<this>, options?: UI2DCallbackOptions): CallbackHandle;

}

interface WaveUITypography {

  readonly fontFamily?: string;

  readonly fontSize?: number;

  readonly foregroundColor?: WaveUIColorInput;

}

declare const waveValue: Readonly<{ number: (value: WaveNumberAuthoringInput) => WaveNumberRef; bool: (value: boolean | WaveValueExpr) => WaveBoolRef; vec2: (x: WaveNumberAuthoringInput, y: WaveNumberAuthoringInput) => WaveVec2Ref; vec2Literal: (value: Vector2Like) => WaveVec2Ref; vec3: (x: WaveNumberAuthoringInput, y: WaveNumberAuthoringInput, z: WaveNumberAuthoringInput) => WaveVec3Ref; vec3Literal: (value: Vector3Like) => WaveVec3Ref; vec4: (x: WaveNumberAuthoringInput, y: WaveNumberAuthoringInput, z: WaveNumberAuthoringInput, w: WaveNumberAuthoringInput) => WaveVec4Ref; vec4Literal: (value: WaveVec4Like) => WaveVec4Ref; color: (r: WaveNumberAuthoringInput, g: WaveNumberAuthoringInput, b: WaveNumberAuthoringInput, a?: WaveNumberAuthoringInput) => WaveColorRef; colorLiteral: (value: ColorInputAlpha) => WaveColorRef; variable: typeof variable; fromExpr: typeof fromExpr; lerp: (from: WaveNumberAuthoringInput, to: WaveNumberAuthoringInput, amount: WaveNumberAuthoringInput) => WaveNumberRef; noise: (input: WaveNumberAuthoringInput, options?: WaveValueNoiseOptions) => WaveNumberRef; noise01: (input: WaveNumberAuthoringInput, options?: Omit<WaveValueNoiseOptions, "amplitude">) => WaveNumberRef; random: (min: WaveNumberAuthoringInput, max: WaveNumberAuthoringInput, options?: WaveValueRandomOptions) => WaveNumberRef; time: (unit?: "seconds" | "ms") => WaveNumberRef; spatial: (source: string, field: "position" | "forward" | "up" | "right" | "velocity") => WaveVec3Ref; sample: Readonly<{ texture: typeof texture; texel: typeof texel; }>; curve: (curveInput: WaveValueCurveInput) => WaveCurveRef; response: Readonly<{ exponentialDecayFactor: (deltaSeconds: WaveNumberAuthoringInput, rate: WaveNumberAuthoringInput) => WaveNumberRef; exponentialResponseFactor: (deltaSeconds: WaveNumberAuthoringInput, rate: WaveNumberAuthoringInput) => WaveNumberRef; }>; contact: Readonly<{ surfaceProximity: (options: WaveValueSurfaceProximityOptions) => WaveNumberRef; }>; program: (options?: WaveValueProgramOptions) => WaveValueProgramBuilder; }>;

interface WaveValueCurve {

  (input: number): number;

  clamp(min?: number, max?: number): WaveValueCurve;

  extractEvents(options?: WaveValueCurveEventOptions): WaveValueCurveEventTable;

  map(mapper: WaveValueCurveMapper): WaveValueCurve;

  sample(count?: number): WaveValueCurveSample[];

  sampleRandom(seed: number): number;

  toConfig(): WaveValueCurveSpec;

  toJSON(): WaveValueCurveSpec;

  toSampleTable(options?: WaveValueCurveLoweringOptions): WaveValueCurveSampleTable;

  withInputRange(min: number, max: number): WaveValueCurve;

  withMarkerHints(eventHints: readonly WaveValueCurveEventHint[], options?: WaveValueCurveSemanticOptions): WaveValueCurve;

  withOutputRange(min: number, max: number): WaveValueCurve;

}

declare const waveValueCurve: Readonly<{ constant: (value: number) => WaveValueCurve; linear: (multiplier?: number, offset?: number) => WaveValueCurve; between: (min: number, max: number) => WaveValueCurve; power: (exponent?: number) => WaveValueCurve; falloff: (mode?: WaveValueCurveFalloffMode) => WaveValueCurve; keyframes: (stops: readonly WaveKeyframedValueCurveStopSpec[], options?: WaveValueCurveKeyframeOptions) => WaveValueCurve; holdTo: (input: number) => WaveValueCurveValueSetter<WaveKeyframedValueCurve>; lineTo: (input: number) => WaveValueCurveValueSetter<WaveKeyframedValueCurve>; easeInTo: (input: number) => WaveValueCurveValueSetter<WaveKeyframedValueCurve>; easeOutTo: (input: number) => WaveValueCurveValueSetter<WaveKeyframedValueCurve>; smoothStepTo: (input: number) => WaveValueCurveValueSetter<WaveKeyframedValueCurve>; smoothStep: (startInput?: number, endInput?: number, startValue?: number, endValue?: number) => WaveValueCurve; bumpAt: (centerInput: number, width?: number, height?: number, baseValue?: number) => WaveValueCurve; sine: (amplitude?: number, cycles?: number, baseline?: number, phaseTurns?: number) => WaveValueCurve; add: (...curves: readonly WaveValueCurveInput[]) => WaveValueCurve; multiply: (...curves: readonly WaveValueCurveInput[]) => WaveValueCurve; subtract: (minuend: WaveValueCurveInput, ...subtrahends: readonly WaveValueCurveInput[]) => WaveValueCurve; safeDivide: (numerator: WaveValueCurveInput, denominator: WaveValueCurveInput, options?: WaveSafeDivideValueCurveOptions) => WaveValueCurve; semantic: (curve: WaveValueCurveInput, domain: WaveValueCurveDomain, options?: WaveValueCurveSemanticOptions) => WaveValueCurve; discretize: (curve: WaveValueCurveInput, options?: WaveValueCurveLoweringOptions) => WaveValueCurveSampleTable; extractEvents: (curve: WaveValueCurveInput, options?: WaveValueCurveEventOptions) => WaveValueCurveEventTable; withMarkerHints: (curve: WaveValueCurveInput, eventHints: readonly WaveValueCurveEventHint[], options?: WaveValueCurveSemanticOptions) => WaveValueCurve; curveBundle: (curves: WaveValueCurveBundleInput, options?: WaveValueCurveBundleOptions) => WaveValueCurveBundle; presets: Readonly<{ fx: Readonly<{ fadeIn(): WaveValueCurve; fadeOut(): WaveValueCurve; burstFlash(): WaveValueCurve; bloomThenShrink(): WaveValueCurve; pulse(cycles?: number): WaveValueCurve; }>; audio: Readonly<{ impactPunch(): WaveValueCurve; softCompression(): WaveValueCurve; distanceFalloff(): WaveValueCurve; rumbleEnvelope(): WaveValueCurve; }>; animation: Readonly<{ easeLaunch(): WaveValueCurve; settleOvershoot(): WaveValueCurve; pathSpeedProfile(): WaveValueCurve; }>; terrain: Readonly<{ softBrush(): WaveValueCurve; hardBrush(): WaveValueCurve; ridgeMask(): WaveValueCurve; basinFalloff(): WaveValueCurve; erosionMask(): WaveValueCurve; }>; ui: Readonly<{ linearProgress(): WaveValueCurve; meterResponse(): WaveValueCurve; smoothProgress(): WaveValueCurve; }>; }>; fromConfig: (config: WaveValueCurveSpec) => WaveValueCurve; fromCallback: (callback: WaveValueCurveEvaluator, options?: WaveValueCurveCallbackOptions) => WaveValueCurve; resolve: (input: WaveValueCurveInput) => WaveValueCurve; cloneConfig: (spec: WaveValueCurveSpec) => WaveValueCurveSpec; cloneBundleConfig: (spec: WaveValueCurveBundleSpec) => WaveValueCurveBundleSpec; compile: (spec: WaveValueCurveSpec) => WaveValueCurveEvaluator; compileInput: (input: WaveValueCurveInput) => WaveValueCurveEvaluator; evaluate: (spec: WaveValueCurveSpec, input: number) => number; discretizeEvaluator: (evaluator: WaveValueCurveEvaluator, options?: WaveValueCurveEvaluatorLoweringOptions) => WaveValueCurveSampleTable; isValueCurve: (value: unknown) => value is WaveValueCurve; isConfig: (value: unknown) => value is WaveValueCurveSpec; }>;

type WaveVector2Field = WaveMaterialField<"vector2">;

type WaveVector2FieldInput = WaveVector2Field;

type WaveVector2FieldRef = WaveMaterialFieldRef<"vector2">;

type WaveVector3Field = WaveMaterialField<"vector3">;

type WaveVector3FieldRef = WaveMaterialFieldRef<"vector3">;

declare class WaveVideoPlayback {

  constructor(construction: WaveVideoPlaybackConstruction);

  activateFollowCurrentSuccessor(next: WaveSceneVideoBinding, serial: WaveVideoPlaybackSerialState, wasPlaying: boolean): WaveSceneVideoBinding;

  applySerialState(serial: WaveVideoPlaybackSerialState): this;

  bus(busName: string): this;

  captureSerialState(): WaveVideoPlaybackSerialState;

  clearCallbacks(): this;

  commitFollowCurrentSuccessor(next: WaveSceneVideoBinding, serial: WaveVideoPlaybackSerialState, wasPlaying: boolean): void;

  get currentTime(): number;

  dispose(): void;

  get duration(): number | null;

  get handle(): WaveSceneVideoBinding;

  get isFollowCurrent(): boolean;

  get isPlaying(): boolean;

  loop(enabled?: boolean): this;

  get loopCount(): number;

  mute(enabled?: boolean): this;

  get name(): string;

  notifyNativeReplaced(): void;

  onComplete(callback?: WaveVideoPlaybackCallback): this;

  onCompleteOnce(callback?: WaveVideoPlaybackCallback): this;

  onEnd(callback?: WaveVideoPlaybackCallback): this;

  onEndOnce(callback?: WaveVideoPlaybackCallback): this;

  onLoop(callback?: WaveVideoLoopCallback): this;

  onNativeReplaced(callback: (playback: WaveVideoPlayback) => void): () => void;

  onPause(callback?: WaveVideoPlaybackCallback): this;

  onStart(callback?: WaveVideoPlaybackCallback): this;

  pause(): this;

  play(): this;

  prepareFollowCurrentSuccessor(nextRef: ExactAssetRef<"video">): WaveSceneVideoBinding;

  rate(value: number): this;

  get ref(): ExactAssetRef<"video">;

  releasePreparedSuccessor(next: WaveSceneVideoBinding): void;

  replaceFollowCurrentBinding(nextRef: ExactAssetRef<"video">): void;

  resetForAuthoringReplay(): void;

  restoreFollowCurrentPredecessor(previous: WaveSceneVideoBinding): void;

  seek(seconds: number): this;

  get sourceRef(): AssetRef<"video"> | ExactAssetRef<"video">;

  stop(): this;

  get texture(): unknown | null;

  get timeline(): "shared" | "independent";

  validateFollowCurrentSuccessor(next: WaveSceneVideoBinding, serial: WaveVideoPlaybackSerialState): void;

  get video(): HTMLVideoElement | null;

  volume(value: number): this;

  withCallbacks(callbacks?: WaveVideoPlaybackCallbacks): this;

}

interface WaveVideoPlaybackCallbacks {

  onComplete?: WaveVideoPlaybackCallback;

  onEnd?: WaveVideoPlaybackCallback;

  onLoop?: WaveVideoLoopCallback;

  onPause?: WaveVideoPlaybackCallback;

  onStart?: WaveVideoPlaybackCallback;

}

interface WaveWaterFlowOptions {

  coordinateSpace?: "auto" | "world" | "uv";

  direction?: Vector2Like;

  speed?: number;

  strength?: number;

}

interface WaveWaterFoamOptions {

  color?: WaveMaterialColorInput;

  evolutionSpeed?: number;

  scale?: number;

  softness?: number;

  strength?: number;

  threshold?: number;

  warpStrength?: number;

}

declare class WaveWaterMaterial {

  apply(): WaveMaterialInput<"water">;

  readonly name: string;

  private(key?: string): this;

  shared(): this;

  constructor(name: string, options?: WaveWaterMaterialAuthoringOptions);

  alpha(alpha: number): this;

  animationSpeed(speed: number): this;

  color(color: WaveMaterialColorInput): this;

  configure(options: WaveWaterMaterialAuthoringOptions): this;

  detailFade(start: number, end: number): this;

  flow(options: WaveWaterFlowOptions): this;

  get flowState(): Readonly<WaveWaterFlowOptions>;

  foam(options: WaveWaterFoamOptions): this;

  foamColor(color: WaveMaterialColorInput): this;

  get foamState(): Readonly<WaveWaterFoamOptions>;

  fresnel(strength: number, power?: number): this;

  normal(options: WaveWaterNormalOptions): this;

  get normalState(): Readonly<WaveWaterNormalOptions>;

  opacity(alpha: number): this;

  get options(): Readonly<WaveWaterMaterialAuthoringOptions>;

  reflection(strength: number): this;

  reflectionTexture(assetName: string): this;

  roughness(roughness: number): this;

  setAnimationSpeed(speed: number): this;

  setColor(color: WaveMaterialColorInput): this;

  setDetailFade(start: number, end: number): this;

  setFlow(options: WaveWaterFlowOptions): this;

  setFoam(options: WaveWaterFoamOptions): this;

  setFoamColor(color: WaveMaterialColorInput): this;

  setFoamMaskAsset(assetName: string): this;

  setFresnel(strength: number, power?: number): this;

  setNormal(options: WaveWaterNormalOptions): this;

  setNormalMapAsset(assetName: string): this;

  setOpacity(alpha: number): this;

  setReflectionStrength(strength: number): this;

  setReflectionTextureAsset(assetName: string): this;

  setRoughness(roughness: number): this;

  setShallowColor(color: WaveMaterialColorInput): this;

  setShoreline(options: WaveWaterShorelineOptions): this;

  setShorelineMaskAsset(assetName: string): this;

  setSpecularStrength(strength: number): this;

  setSurfaceWaveNoiseMapAsset(assetName: string): this;

  setSurfaceWaves(options: WaveWaterSurfaceWaveOptions): this;

  setTintVariation(amount: number): this;

  setWaterColor(color: WaveMaterialColorInput): this;

  shallowColor(color: WaveMaterialColorInput): this;

  shoreline(options: WaveWaterShorelineOptions): this;

  get shorelineState(): Readonly<WaveWaterShorelineState>;

  specular(strength: number): this;

  get state(): Readonly<WaveWaterMaterialAuthoringOptions>;

  get surfaceWaveState(): Readonly<WaveWaterSurfaceWaveOptions>;

  tintVariation(amount: number): this;

  variant(name: string, options?: WaveWaterMaterialAuthoringOptions): WaveWaterMaterial;

  waterColor(color: WaveMaterialColorInput): this;

  waves(options: WaveWaterSurfaceWaveOptions): this;

}

interface WaveWaterMaterialAuthoringOptions {

  alpha?: number;

  animationSpeed?: number;

  detailFadeEnd?: number;

  detailFadeStart?: number;

  flowCoordinateSpace?: "auto" | "world" | "uv";

  flowDirection?: Vector2Like;

  flowSpeed?: number;

  flowStrength?: number;

  foamColor?: WaveMaterialColorInput;

  foamEvolutionSpeed?: number;

  foamMaskAsset?: string;

  foamScale?: number;

  foamSoftness?: number;

  foamStrength?: number;

  foamThreshold?: number;

  foamWarpStrength?: number;

  fresnelPower?: number;

  fresnelStrength?: number;

  normalMapAsset?: string;

  normalScale?: number;

  normalStrength?: number;

  reflectionStrength?: number;

  reflectionTextureAsset?: string;

  roughness?: number;

  secondaryNormalScale?: number;

  shallowColor?: WaveMaterialColorInput;

  shorelineBreakFrequency?: number;

  shorelineBreakSpeed?: number;

  shorelineBreakStrength?: number;

  shorelineEnabled?: boolean;

  shorelineFoamStrength?: number;

  shorelineMaskAsset?: string;

  shorelineMin?: Vector2Like;

  shorelineSize?: Vector2Like;

  shorelineSoftness?: number;

  shorelineTintStrength?: number;

  specularStrength?: number;

  sunIntensity?: number;

  surfaceWaveChoppiness?: number;

  surfaceWaveDirection?: Vector2Like;

  surfaceWaveNoiseMapAsset?: string;

  surfaceWaveNoiseScale?: number;

  surfaceWaveNoiseSpeed?: number;

  surfaceWaveNoiseStrength?: number;

  surfaceWaveSpeed?: number;

  surfaceWaveStrength?: number;

  surfaceWaveWavelength?: number;

  tintVariation?: number;

  waterColor?: WaveMaterialColorInput;

}

interface WaveWaterNormalOptions {

  scale?: number;

  secondaryScale?: number;

  strength?: number;

}

interface WaveWaterShorelineOptions {

  breakFrequency?: number;

  breakSpeed?: number;

  breakStrength?: number;

  enabled?: boolean;

  foamStrength?: number;

  maskAsset?: string;

  min?: Vector2Like;

  size?: Vector2Like;

  softness?: number;

  tintStrength?: number;

}

interface WaveWaterShorelineState {

  breakFrequency?: number;

  breakSpeed?: number;

  breakStrength?: number;

  enabled?: boolean;

  foamStrength?: number;

  maskAsset?: string;

  min?: Vector2Like;

  size?: Vector2Like;

  softness?: number;

  tintStrength?: number;

}

interface WaveWaterSurfaceWaveOptions {

  choppiness?: number;

  direction?: Vector2Like;

  noiseScale?: number;

  noiseSpeed?: number;

  noiseStrength?: number;

  speed?: number;

  strength?: number;

  wavelength?: number;

}

interface WaveWebcamHandTrackingBuilder {

  onError(callback: (error: WaveWebcamHandTrackingError) => void): this;

  onGesture(callback: (data: VisionInputData) => void): this;

  onHandDetected(callback: (data: VisionInputData) => void): this;

  onHandLost(callback: (data: VisionInputData) => void): this;

  onLandmarks(callback: (data: VisionLandmarksTapData) => void): this;

  onStarted(callback: (handle: WaveWebcamHandTrackingHandle) => void): this;

  startTracking(): WaveWebcamHandTrackingHandle;

  withCaptureMode(mode: MediaCaptureMode): this;

  withFacingMode(facingMode: "user" | "environment"): this;

  withFrameRate(frameRate: number): this;

  withGestureRecognition(enabled?: boolean): this;

  withInferenceFps(fps: number): this;

  withLandmarkFps(fps: number): this;

  withMaxHands(maxHands: number): this;

  withMediaPipeAssets(options: WaveWebcamHandTrackingMediaPipeAssets): this;

  withMinGestureConfidence(confidence: number): this;

  withResolution(width: number, height: number): this;

}

declare class waveWedge extends waveGeometry {

  configureGeometry(configuration: WaveWedgePrimitiveRecipe | WavePrimitiveGeometryConfiguration<WaveWedgePrimitiveRecipe>): this;

  primitiveRecipe: WaveWedgePrimitiveRecipe;

  constructor(width?: number, height?: number, depth?: number, flipSlope?: boolean);

  static readonly Face: Readonly<{ Slope: Readonly<{ readonly kind: "slope"; }>; Bottom: Readonly<{ readonly kind: "bottom"; }>; Front: Readonly<{ readonly kind: "front"; }>; Back: Readonly<{ readonly kind: "back"; }>; Left: Readonly<{ readonly kind: "left"; }>; Right: Readonly<{ readonly kind: "right"; }>; }>;

  static readonly typeName: EntityType;

  asWedge(width?: number, height?: number, depth?: number, flipSlope?: boolean, widthSegments?: number, heightSegments?: number, depthSegments?: number): this;

  get baseDepth(): number;

  get baseDepthSegments(): number;

  get baseHeight(): number;

  get baseHeightSegments(): number;

  get baseWidth(): number;

  get baseWidthSegments(): number;

  get depthSegments(): number;

  face(surface: WaveSurface | WedgeFaceSelector): ReturnType<cmp_visual3DModel["surface"]>;

  faceMaterial(surface: WaveSurface | WedgeFaceSelector): ReturnType<cmp_visual3DModel["meshMaterialSlot"]>;

  get flipSlope(): boolean;

  get heightSegments(): number;

  setBaseDepthSegments(segments: number): this;

  setBaseHeightSegments(segments: number): this;

  setBaseSegments(widthSegments: number, heightSegments: number, depthSegments: number): this;

  setBaseSideOrientation(sideOrientation: number): this;

  setBaseSizes(width: number, height: number, depth: number): this;

  setBaseWidthSegments(segments: number): this;

  setFlipSlope(flip: boolean): this;

  get widthSegments(): number;

}

declare class WaveWorldComposer {

  constructor(_id: string, _target?: WaveWorldComposerApplyTarget | undefined);

  apply(): WaveWorldPlan;

  budgets(budgets: WaveWorldBudgetPolicy): this;

  describe(description: string): this;

  element(layerId: string, id: string, options: WaveWorldElementRecipeOptions): this;

  elements(layerId: string, author: (world: WaveWorldPlanElementWorkspaceBuilder) => void): this;

  extension<TOptions extends SerializableDataValue>(id: string, extensionId: string, options: TOptions, config?: { readonly layerId?: string; readonly assets?: readonly string[]; }): this;

  layer(layer: WaveWorldLayerDraft): this;

  layer(id: string, layer: Omit<WaveWorldLayerDraft, "id">): this;

  metadata(metadata: Readonly<Record<string, SerializableDataValue>>): this;

  seed(seed: number): this;

  terrain(id?: string, input?: WaveTerrainLayerDefinitionLike): WaveTerrainLayerBuilder<WaveWorldComposer>;

  toWorldPlan(): WaveWorldPlan;

}

declare function waveWorldPlan(input: WaveWorldPlanInput): WaveWorldPlan;

declare class WaveWorldPlanEditor {

  constructor(source: WaveWorldPlan, _target?: WaveWorldPlanEditorCommitTarget | undefined);

  budgets(budgets: WaveWorldBudgetPolicy): this;

  commit(): WaveWorldPlan;

  removeElement(id: string): this;

  removeExtension(id: string): this;

  removeLayer(layerId: string): this;

  seed(seed: number): this;

  terrain(id?: string, input?: WaveTerrainLayerDefinitionLike): WaveTerrainLayerBuilder<WaveWorldPlanEditor>;

  toWorldPlan(): WaveWorldPlan;

  upsertElement(layerId: string, id: string, options: WaveWorldElementRecipeOptions): this;

  upsertExtension(binding: Omit<WaveWorldRuntimeExtensionBinding, "revision" | "seed">): this;

  upsertLayer(layer: WaveWorldLayerDraft): this;

}

type WaveWorldTextModelRecipe = Readonly<{ version: typeof WAVE_TEXT_MODEL_RECIPE_VERSION; } & Omit<WaveWorldTextRuntimeInput, "model">>;

interface WaypointOptions {

  color?: ColorInput;

  label?: string;

  labelColor?: ColorInput;

  labelFontSize?: number;

  offScreenArrowColor?: ColorInput;

  pulse?: boolean;

  shape?: MinimapMarkerShape | "cross";

  showLabel?: boolean;

  showOffScreenArrow?: boolean;

  size?: number;

  sprite?: string;

}

declare enum WorldElementKind {

  Custom = "custom",

  Entity = "entity",

  GrassCarpet = "grassCarpet",

  POI = "poi",

  Scatter = "scatter",

  Surface = "surface",

  Water = "water",

}

declare class xr3DObject extends wave3DObject {

  constructor(modelAsset?: Visual3DModelInput);

  static readonly typeName: EntityType;

  get xrAnchor(): cmp_xrAnchor<this>;

  get xrInteractable(): cmp_xrInteractable<this>;

}

declare class xrActor extends waveActor {

  constructor(modelAsset?: Visual3DModelInput);

  static readonly typeName: EntityType;

  get xrInteractable(): cmp_xrInteractable<this>;

}

declare enum XRAnchorPlacement {

  AutoAny = 3,

  AutoHorizontal = 1,

  AutoVertical = 2,

  Manual = 0,

}

declare enum XRInteractionMode {

  GazeTarget = 3,

  Grab = 1,

  NearInteract = 5,

  None = 0,

  Poke = 2,

  RayTarget = 4,

}

declare class xrProp extends waveProp {

  constructor(modelAsset?: Visual3DModelInput);

  static readonly typeName: EntityType;

  get hasXrAnchor(): boolean;

  get hasXrInteractable(): boolean;

  get xrAnchor(): cmp_xrAnchor<this>;

  get xrInteractable(): cmp_xrInteractable<this>;

}

declare enum XRScaleMode {

  Adaptive = 1,

  World = 0,

}

// ═══════════════════════════════════════════════════════════════════════════
// WaveStudio Runtime Globals (pre-declared in user code context)
// ═══════════════════════════════════════════════════════════════════════════

declare const ctx: SceneContext;
declare const scene: WaveScene;
declare const myScene: WaveScene;
declare const myCloud: WaveSceneDataStore;
declare const createScene: (
  sceneId: string,
  options?: ConstructorParameters<typeof WaveScene>[1],
) => WaveScene;

declare type WaveStudioMonacoAssetMap<T extends Record<string, string>> = { readonly [K in keyof T]: T[K] };
declare type WaveStudioMonacoWarehouseMap<T extends Record<string, string>> = { readonly [K in keyof T]: string };
declare const ASSET_WAREHOUSE: {
  readonly models: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.ModelNames>;
  readonly gaussianSplats: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.GaussianSplatNames>;
  readonly animations: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.AnimationNames>;
  readonly vertexAnimations: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.VertexAnimationNames>;
  readonly hdr: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.HDREnvironmentNames>;
  readonly cubeMaps: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.CubeMapNames>;
  readonly textures: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.TextureNames>;
  readonly materials: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.MaterialNames>;
  readonly guis: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.GUINames>;
  readonly audios: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.AudioNames>;
  readonly instruments: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.InstrumentNames>;
  readonly videos: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.VideoNames>;
  readonly fonts: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.FontNames>;
  readonly serializedData: WaveStudioMonacoWarehouseMap<MonacoAssetMaps.SerializedDataNames>;
  readonly particles: Record<string, string>;
};
declare const models: WaveStudioMonacoAssetMap<MonacoAssetMaps.ModelNames>;
declare const gaussianSplats: WaveStudioMonacoAssetMap<MonacoAssetMaps.GaussianSplatNames>;
declare const animations: WaveStudioMonacoAssetMap<MonacoAssetMaps.AnimationNames>;
declare const vertexAnimations: WaveStudioMonacoAssetMap<MonacoAssetMaps.VertexAnimationNames>;
declare const poses: WaveStudioMonacoAssetMap<MonacoAssetMaps.PoseNames>;
declare const materials: WaveStudioMonacoAssetMap<MonacoAssetMaps.MaterialNames>;
declare const guis: WaveStudioMonacoAssetMap<MonacoAssetMaps.GUINames>;
declare const textures: WaveStudioMonacoAssetMap<MonacoAssetMaps.TextureNames>;
declare const audios: WaveStudioMonacoAssetMap<MonacoAssetMaps.AudioNames>;
declare const instruments: WaveStudioMonacoAssetMap<MonacoAssetMaps.InstrumentNames>;
declare const videos: WaveStudioMonacoAssetMap<MonacoAssetMaps.VideoNames>;
declare const hdr: WaveStudioMonacoAssetMap<MonacoAssetMaps.HDREnvironmentNames>;
declare const cubeMaps: WaveStudioMonacoAssetMap<MonacoAssetMaps.CubeMapNames>;
declare const fonts: WaveStudioMonacoAssetMap<MonacoAssetMaps.FontNames>;
declare const serializedData: WaveStudioMonacoAssetMap<MonacoAssetMaps.SerializedDataNames>;
declare const particles: typeof ASSET_WAREHOUSE['particles'];
declare const terrains: WaveStudioMonacoAssetMap<MonacoAssetMaps.TerrainNames>;
declare const fx: WaveStudioMonacoAssetMap<MonacoAssetMaps.FxNames>;