@zcomponent/core 1.14.3 → 1.16.0-beta

package/lib/animation/tracks/propertytrack.d.ts

@@ -2,9 +2,24 @@ import { FadeParameters, BlendType } from '../../data';
 import { Animation } from '../animation';
 import { Keyframe } from '../keyframe';
 import { Track } from './track';
+/**
+ * Manages keyframes for animating entity properties over time.
+ * Handles initialization of property paths, registration of entities and paths, sorting of keyframes and weights.
+ * Supports computation of interpolated values between keyframes based on blend types.
+ * Facilitates adding, retrieving, and setting keyframes and weights, enabling precise and flexible property animation.
+ *
+ * @param anim The associated Animation instance.
+ * @param _entityID The ID of the entity associated with the track.
+ * @param _entity The entity itself.
+ * @param property The property or array of properties to be animated.
+ * @param id Optional unique identifier for the PropertyTrack.
+ */
 export declare class PropertyTrack extends Track {
     private _entityID;
     private _entity;
+    /**
+     *  Path representing the property being animated.
+     */
     path: string;
     private _property;
     private _path;
@@ -14,22 +29,91 @@ export declare class PropertyTrack extends Track {
     private _weights;
     private _weightsById;
     private _weightsDirty;
+    /**
+     * Optional parameters for fading animation properties.
+     */
     fadeParameters?: Partial<FadeParameters>;
+    /**
+     * Blend type for interpolating values.
+     */
     blend: BlendType;
+    /**
+     * Paths influenced by this track.
+     */
     influencedPaths: string[];
+    /**
+     * Creates an instance of PropertyTrack.
+     * @param anim - The associated Animation instance.
+     * @param _entityID - The ID of the entity associated with the track.
+     * @param _entity - The entity itself.
+     * @param property - The property or array of properties to be animated.
+     * @param id - Optional unique identifier for the PropertyTrack.
+     */
     constructor(anim: Animation, _entityID: string, _entity: any, property: string | number | (string | number)[], id?: string);
+    /**
+     * Adds a keyframe to manage the property's animation.
+     *
+     * @param k The keyframe to be added.
+     */
     addKeyframe(k: Keyframe): void;
+    /**
+     * Retrieves a keyframe by its ID.
+     *
+     * @param id The ID of the keyframe to retrieve.
+     * @returns The keyframe, if found; otherwise undefined.
+     */
     getKeyframeById(id: string): Keyframe | undefined;
+    /**
+     * Sets the keyframes for the track using an id-indexed object.
+     *
+     * @param keyframes An object mapping keyframe IDs to keyframes.
+     */
     setKeyframesById(keyframes: {
         [id: string]: Keyframe;
     }): void;
+    /**
+     * Getter for sorted keyframes by their time values.
+     *
+     * @returns A sorted array of keyframes.
+     */
     get sortedKeyframes(): Keyframe[];
+    /**
+     * Adds a weight keyframe to influence the property's animation.
+     *
+     * @param k The weight keyframe to be added.
+     */
     addWeight(k: Keyframe): void;
+    /**
+     * Sets the weight keyframes for the track using an id-indexed object.
+     *
+     * @param weights An object mapping weight keyframe IDs to keyframes.
+     */
     setWeightsById(weights: {
         [id: string]: Keyframe;
     }): void;
+    /**
+     * Getter for sorted weight keyframes by their time values.
+     *
+     * @returns A sorted array of weight keyframes.
+     */
     get sortedWeights(): Keyframe[];
+    /**
+     * Computes the fade length for a given path.
+     *
+     * @param path The path for which to compute the fade length.
+     * @returns The fade length, defaulting to 0 if not specified.
+     */
     getFadeLengthForPath(path: string): number;
+    /**
+     * Computes the property value for a given path at a specific time.
+     * Interpolates between keyframe values based on the specified blend type.
+     *
+     * @param t The time at which to compute the property.
+     * @param p The path of the property to compute.
+     * @param valueBefore The initial value of the property before computation.
+     * @param parentWeight Optional weight from the parent track.
+     * @returns The computed property value.
+     */
     computePathProperty(t: number, p: string, valueBefore: any, parentWeight?: number): any;
     private _computePathProperty;
 }

package/lib/animation/tracks/propertytrack.js

@@ -2,7 +2,27 @@ import { Observable } from '../../observable';
 import { addBlend, interpolate } from '../interpolate';
 import { resolveKeyframes, resolveKeyframeValue, Track } from './track';
 const _scratch = new Observable(undefined);
+/**
+ * Manages keyframes for animating entity properties over time.
+ * Handles initialization of property paths, registration of entities and paths, sorting of keyframes and weights.
+ * Supports computation of interpolated values between keyframes based on blend types.
+ * Facilitates adding, retrieving, and setting keyframes and weights, enabling precise and flexible property animation.
+ *
+ * @param anim The associated Animation instance.
+ * @param _entityID The ID of the entity associated with the track.
+ * @param _entity The entity itself.
+ * @param property The property or array of properties to be animated.
+ * @param id Optional unique identifier for the PropertyTrack.
+ */
 export class PropertyTrack extends Track {
+    /**
+     * Creates an instance of PropertyTrack.
+     * @param anim - The associated Animation instance.
+     * @param _entityID - The ID of the entity associated with the track.
+     * @param _entity - The entity itself.
+     * @param property - The property or array of properties to be animated.
+     * @param id - Optional unique identifier for the PropertyTrack.
+     */
     constructor(anim, _entityID, _entity, property, id) {
         super(anim, id);
         this._entityID = _entityID;
@@ -13,6 +33,9 @@ export class PropertyTrack extends Track {
         this._weights = [];
         this._weightsById = {};
         this._weightsDirty = false;
+        /**
+         * Blend type for interpolating values.
+         */
         this.blend = 'overlay';
         if (Array.isArray(property)) {
             this._property = property[0];
@@ -26,17 +49,38 @@ export class PropertyTrack extends Track {
         this.influencedPaths = [this.path];
         anim.registerEntityProperty(this.path, _entity, this._property);
     }
+    /**
+     * Adds a keyframe to manage the property's animation.
+     *
+     * @param k The keyframe to be added.
+     */
     addKeyframe(k) {
         this._keyframesById[k.id] = k;
         this._keyframesDirty = true;
     }
+    /**
+     * Retrieves a keyframe by its ID.
+     *
+     * @param id The ID of the keyframe to retrieve.
+     * @returns The keyframe, if found; otherwise undefined.
+     */
     getKeyframeById(id) {
         return this._keyframesById[id];
     }
+    /**
+     * Sets the keyframes for the track using an id-indexed object.
+     *
+     * @param keyframes An object mapping keyframe IDs to keyframes.
+     */
     setKeyframesById(keyframes) {
         this._keyframesById = keyframes;
         this._keyframesDirty = true;
     }
+    /**
+     * Getter for sorted keyframes by their time values.
+     *
+     * @returns A sorted array of keyframes.
+     */
     get sortedKeyframes() {
         if (!this._keyframesDirty)
             return this._keyframes;
@@ -45,14 +89,29 @@ export class PropertyTrack extends Track {
         this._keyframesDirty = false;
         return this._keyframes;
     }
+    /**
+     * Adds a weight keyframe to influence the property's animation.
+     *
+     * @param k The weight keyframe to be added.
+     */
     addWeight(k) {
         this._weightsById[k.id] = k;
         this._weightsDirty = true;
     }
+    /**
+     * Sets the weight keyframes for the track using an id-indexed object.
+     *
+     * @param weights An object mapping weight keyframe IDs to keyframes.
+     */
     setWeightsById(weights) {
         this._weightsById = weights;
         this._weightsDirty = true;
     }
+    /**
+     * Getter for sorted weight keyframes by their time values.
+     *
+     * @returns A sorted array of weight keyframes.
+     */
     get sortedWeights() {
         if (!this._weightsDirty)
             return this._weights;
@@ -61,9 +120,25 @@ export class PropertyTrack extends Track {
         this._weightsDirty = false;
         return this._weights;
     }
+    /**
+     * Computes the fade length for a given path.
+     *
+     * @param path The path for which to compute the fade length.
+     * @returns The fade length, defaulting to 0 if not specified.
+     */
     getFadeLengthForPath(path) {
         return this.fadeParameters?.time ?? 0;
     }
+    /**
+     * Computes the property value for a given path at a specific time.
+     * Interpolates between keyframe values based on the specified blend type.
+     *
+     * @param t The time at which to compute the property.
+     * @param p The path of the property to compute.
+     * @param valueBefore The initial value of the property before computation.
+     * @param parentWeight Optional weight from the parent track.
+     * @returns The computed property value.
+     */
     computePathProperty(t, p, valueBefore, parentWeight) {
         if (this._path.length === 0) {
             return this._computePathProperty(t, p, valueBefore, parentWeight);

package/lib/animation/tracks/streamtrack.d.ts

@@ -4,6 +4,13 @@ import { Keyframe } from '../keyframe';
 import { LayerClip } from '../layerclip';
 import { Stream, StreamState } from '../stream';
 import { Track } from './track';
+/**
+ * Allows a stream (e.g a video, audio, 3D model animation, anything extending the Stream interface) to be added to a clip.
+ *
+ * @param animation The associated Animation instance.
+ * @param _entity The entity whose stream is being managed.
+ * @param _property The property or array of properties targeted by the stream.
+ */
 export declare class StreamTrack extends Track {
     readonly animation: Animation;
     private _entity;
@@ -20,24 +27,68 @@ export declare class StreamTrack extends Track {
     private _lastState;
     private _lastRate;
     constructor(animation: Animation, _entity: any, _property: (string | number)[]);
+    /**
+     * Getter for the list of paths influenced by the track.
+     * As this track does not influence any paths, it returns an empty array.
+     *
+     * @returns An empty array.
+     */
     get influencedPaths(): string[];
+    /**
+     * Getter for the stream associated with the entity.
+     *
+     * @returns The Stream associated with the entity, if available.
+     */
     get stream(): Stream | undefined;
     computePathProperty(t: number, p: string, valueBefore: any, parentWeight?: number): any;
+    /**
+     * Sets the weight keyframes for the track using an id-indexed object.
+     *
+     * @param weights An object mapping weight keyframe IDs to keyframes.
+     */
     setWeightsById(weights: {
         [id: string]: Keyframe;
     }): void;
+    /**
+     * Getter for sorted weight keyframes by their time values.
+     *
+     * @returns A sorted array of weight keyframes.
+     */
     get sortedWeights(): Keyframe[];
+    /**
+     * Adds a block (StreamTrackEntity) representing a stream state in the timeline.
+     *
+     * @param k The block to be added.
+     */
     addBlock(k: StreamTrackEntity): void;
+    /**
+     * Sets the blocks for the track using an id-indexed object.
+     *
+     * @param blocks An object mapping block IDs to StreamTrackEntities.
+     */
     setBlocksById(weights: {
         [id: string]: StreamTrackEntity;
     }): void;
+    /**
+     * Getter for sorted blocks by their start time.
+     *
+     * @returns A sorted array of StreamTrackEntities.
+     */
     get sortedBlocks(): StreamTrackEntity[];
+    /** @internal */
     streamPause(isActive: boolean, active: LayerClip | null | undefined): void;
+    /** @internal */
     streamSeek(t: number, resolvedRate: number, isActive: boolean, active: LayerClip | null | undefined): void;
     private _isPlayingInClip;
     private _isPlayingInLayerClip;
+    /** @internal */
     streamTick(clipState: StreamState, t: number, rate: number, isActive: boolean, active: LayerClip | null | undefined, force?: boolean, stalled?: boolean, parentWeight?: number): void;
     private _applyState;
     private _resolveBlock;
+    /**
+     * Determines if the track's stream is stalled.
+     *
+     * @returns A boolean indicating if the stream is stalled.
+     */
     isStalled(): boolean;
 }

package/lib/animation/tracks/streamtrack.js

@@ -1,6 +1,13 @@
 import { StreamState } from '../stream';
 import { ClipTrack } from './cliptrack';
 import { resolveClipTimeLoops, Track } from './track';
+/**
+ * Allows a stream (e.g a video, audio, 3D model animation, anything extending the Stream interface) to be added to a clip.
+ *
+ * @param animation The associated Animation instance.
+ * @param _entity The entity whose stream is being managed.
+ * @param _property The property or array of properties targeted by the stream.
+ */
 export class StreamTrack extends Track {
     constructor(animation, _entity, _property) {
         super(animation);
@@ -14,9 +21,20 @@ export class StreamTrack extends Track {
         this._weightsById = {};
         this._weightsDirty = false;
     }
+    /**
+     * Getter for the list of paths influenced by the track.
+     * As this track does not influence any paths, it returns an empty array.
+     *
+     * @returns An empty array.
+     */
     get influencedPaths() {
         return [];
     }
+    /**
+     * Getter for the stream associated with the entity.
+     *
+     * @returns The Stream associated with the entity, if available.
+     */
     get stream() {
         if (!this._stream) {
             let obj = this._entity;
@@ -32,10 +50,20 @@ export class StreamTrack extends Track {
     computePathProperty(t, p, valueBefore, parentWeight) {
         // n/a
     }
+    /**
+     * Sets the weight keyframes for the track using an id-indexed object.
+     *
+     * @param weights An object mapping weight keyframe IDs to keyframes.
+     */
     setWeightsById(weights) {
         this._weightsById = weights;
         this._weightsDirty = true;
     }
+    /**
+     * Getter for sorted weight keyframes by their time values.
+     *
+     * @returns A sorted array of weight keyframes.
+     */
     get sortedWeights() {
         if (!this._weightsDirty)
             return this._weights;
@@ -44,14 +72,29 @@ export class StreamTrack extends Track {
         this._weightsDirty = false;
         return this._weights;
     }
+    /**
+     * Adds a block (StreamTrackEntity) representing a stream state in the timeline.
+     *
+     * @param k The block to be added.
+     */
     addBlock(k) {
         this._entitiesById[k.id] = k;
         this._entitiesDirty = true;
     }
+    /**
+     * Sets the blocks for the track using an id-indexed object.
+     *
+     * @param blocks An object mapping block IDs to StreamTrackEntities.
+     */
     setBlocksById(weights) {
         this._entitiesById = weights;
         this._entitiesDirty = true;
     }
+    /**
+     * Getter for sorted blocks by their start time.
+     *
+     * @returns A sorted array of StreamTrackEntities.
+     */
     get sortedBlocks() {
         if (!this._entitiesDirty)
             return this._entities;
@@ -60,6 +103,7 @@ export class StreamTrack extends Track {
         this._entitiesDirty = false;
         return this._entities;
     }
+    /** @internal */
     streamPause(isActive, active) {
         if (!isActive && this._isPlayingInLayerClip(active)) {
             delete this._lastLoopNumber;
@@ -70,6 +114,7 @@ export class StreamTrack extends Track {
         this.stream?.pause();
         this._lastState = StreamState.Paused;
     }
+    /** @internal */
     streamSeek(t, resolvedRate, isActive, active) {
         if (!isActive && this._isPlayingInLayerClip(active)) {
             delete this._lastLoopNumber;
@@ -78,12 +123,12 @@ export class StreamTrack extends Track {
         const blockNow = this._resolveBlock(t, 1);
         if (!blockNow)
             return;
-        const [bt, loopNumber] = resolveClipTimeLoops(t, blockNow.t0, blockNow.s0, blockNow.rate, this.stream?.length?.() ?? Infinity, (resolvedRate * blockNow.rate) < 0, blockNow.t1);
+        const [bt, loopNumber] = resolveClipTimeLoops(t, blockNow.t0, blockNow.s0, blockNow.rate, this.stream?.length?.() ?? Infinity, resolvedRate * blockNow.rate < 0, blockNow.t1);
         this.stream?.seek(bt);
         this._lastLoopNumber = loopNumber;
     }
     _isPlayingInClip(stream, clip) {
-        for (let s of clip._streamTracks) {
+        for (const s of clip._streamTracks) {
             if (s instanceof StreamTrack && s.stream === stream)
                 return true;
             if (s instanceof ClipTrack && this._isPlayingInClip(stream, s.clip))
@@ -99,6 +144,7 @@ export class StreamTrack extends Track {
             return false;
         return this._isPlayingInClip(stream, layerClip.clip);
     }
+    /** @internal */
     streamTick(clipState, t, rate, isActive, active, force = false, stalled = false, parentWeight) {
         if (!isActive && this._isPlayingInLayerClip(active)) {
             delete this._lastLoopNumber;
@@ -114,7 +160,7 @@ export class StreamTrack extends Track {
             desiredState = StreamState.Paused;
         }
         else {
-            const [bt, loopNumber] = resolveClipTimeLoops(t, block.t0, block.s0, block.rate, this.stream?.length?.() ?? Infinity, (rate * block.rate) < 0, block.t1);
+            const [bt, loopNumber] = resolveClipTimeLoops(t, block.t0, block.s0, block.rate, this.stream?.length?.() ?? Infinity, rate * block.rate < 0, block.t1);
             if ((t === block.t1 && rate >= +0) || (t === block.t0 && rate < 0)) {
                 desiredState = StreamState.Paused;
                 force = true;
@@ -158,6 +204,11 @@ export class StreamTrack extends Track {
         }
         return undefined;
     }
+    /**
+     * Determines if the track's stream is stalled.
+     *
+     * @returns A boolean indicating if the stream is stalled.
+     */
     isStalled() {
         return this.stream?.isStalled?.() ?? false;
     }

package/lib/animation/tracks/track.d.ts

@@ -1,14 +1,70 @@
 import { Observable } from '../../observable';
 import { Animation } from '../animation';
 import { Keyframe } from '../keyframe';
+/**
+ * Abstract base class for animation tracks.
+ * Tracks are responsible for managing animated properties and responding to time-based updates.
+ *
+ * @param anim The associated Animation instance.
+ * @param id Optional unique identifier for the track.
+ */
 export declare abstract class Track {
     readonly id?: string | undefined;
+    /** @internal */
     influencedPathsDirty: Observable<boolean, never>;
     constructor(anim: Animation, id?: string | undefined);
+    /**
+     * Abstract getter for the list of paths influenced by the track.
+     * Must be implemented by subclasses to return the relevant paths.
+     *
+     * @returns An array of strings representing the influenced paths.
+     */
     abstract get influencedPaths(): string[];
+    /**
+     * Abstract method to compute the property value for a given path at a specific time.
+     * Must be implemented by subclasses to provide the property computation logic.
+     *
+     * @param t The time at which to compute the property.
+     * @param p The path of the property to compute.
+     * @param valueBefore The initial value of the property before computation.
+     * @param parentWeight Optional weight from the parent track.
+     * @returns The computed property value.
+     */
     abstract computePathProperty(t: number, p: string, valueBefore: any, parentWeight?: number): any;
+    /**
+     * Determines if the track is stalled. Default implementation returns false.
+     *
+     * @returns A boolean indicating if the track is stalled.
+     */
     isStalled(): boolean;
 }
+/**
+ * Resolves the interpolated value between two keyframes at a given time.
+ *
+ * @param t The current time.
+ * @param before The keyframe before the current time.
+ * @param after The keyframe after the current time, if any.
+ * @returns The interpolated value.
+ */
 export declare function resolveKeyframeValue(t: number, before: Keyframe, after: Keyframe | undefined): any;
+/**
+ * Finds the keyframes before and after a given time.
+ *
+ * @param keyframes An array of keyframes.
+ * @param t The time for which to find the keyframes.
+ * @returns A tuple containing the keyframes before and after the given time.
+ */
 export declare function resolveKeyframes(keyframes: Keyframe[], t: number): [before: Keyframe | undefined, after: Keyframe | undefined];
+/**
+ * Resolves the clip time and loop number for a given time within a clip.
+ *
+ * @param t The current time.
+ * @param t0 The start time of the clip.
+ * @param s0 The initial state time of the clip.
+ * @param rate The rate of playback.
+ * @param length The length of the clip.
+ * @param timeBackwards A boolean indicating if time is moving backwards.
+ * @param t1 Optional end time of the clip.
+ * @returns A tuple containing the resolved clip time and loop number.
+ */
 export declare function resolveClipTimeLoops(t: number, t0: number, s0: number, rate: number, length: number, timeBackwards: boolean, t1?: number): [ct: number, loop: number];

package/lib/animation/tracks/track.js

@@ -1,23 +1,51 @@
 import { Observable } from '../../observable';
 import { computeEasing } from '../bezier';
 import { interpolate } from '../interpolate';
+/**
+ * Abstract base class for animation tracks.
+ * Tracks are responsible for managing animated properties and responding to time-based updates.
+ *
+ * @param anim The associated Animation instance.
+ * @param id Optional unique identifier for the track.
+ */
 export class Track {
     constructor(anim, id) {
         this.id = id;
+        /** @internal */
         this.influencedPathsDirty = new Observable(false);
         if (id)
             anim.trackByID.set(id, this);
     }
+    /**
+     * Determines if the track is stalled. Default implementation returns false.
+     *
+     * @returns A boolean indicating if the track is stalled.
+     */
     isStalled() {
         return false;
     }
 }
+/**
+ * Resolves the interpolated value between two keyframes at a given time.
+ *
+ * @param t The current time.
+ * @param before The keyframe before the current time.
+ * @param after The keyframe after the current time, if any.
+ * @returns The interpolated value.
+ */
 export function resolveKeyframeValue(t, before, after) {
     if (!after || !before.easing)
         return before.v;
     const tprop = computeEasing((t - before.t) / (after.t - before.t), before.easing);
     return interpolate(before.v, after.v, tprop);
 }
+/**
+ * Finds the keyframes before and after a given time.
+ *
+ * @param keyframes An array of keyframes.
+ * @param t The time for which to find the keyframes.
+ * @returns A tuple containing the keyframes before and after the given time.
+ */
 export function resolveKeyframes(keyframes, t) {
     let keyframeBefore;
     let keyframeAfter;
@@ -34,6 +62,18 @@ export function resolveKeyframes(keyframes, t) {
     }
     return [keyframeBefore, keyframeAfter];
 }
+/**
+ * Resolves the clip time and loop number for a given time within a clip.
+ *
+ * @param t The current time.
+ * @param t0 The start time of the clip.
+ * @param s0 The initial state time of the clip.
+ * @param rate The rate of playback.
+ * @param length The length of the clip.
+ * @param timeBackwards A boolean indicating if time is moving backwards.
+ * @param t1 Optional end time of the clip.
+ * @returns A tuple containing the resolved clip time and loop number.
+ */
 export function resolveClipTimeLoops(t, t0, s0, rate, length, timeBackwards, t1 = Infinity) {
     if (length === 0)
         return [0, 0];

package/lib/behavior.d.ts

@@ -1,11 +1,36 @@
 import { Component } from './component';
 import { ContextManager } from './context';
 import { Entity } from './entity';
+/**
+ * Represents a factory function for creating new Behavior instances.
+ *
+ * @typeParam BehaviorType - The specific type of Behavior to be constructed.
+ * @typeParam K - The type of Component associated with the Behavior.
+ * @returns A new instance of the specified BehaviorType.
+ */
 export type BehaviorConstructor<BehaviorType = Behavior, K extends Component = Component> = BehaviorType extends Behavior<K> ? new (contextManager: ContextManager, instance: K, ...args: any[]) => BehaviorType : never;
+/**
+ * Extracts the constructor properties of a specified Behavior type.
+ *
+ * @typeParam BehaviorType - The Behavior type for which the constructor properties are to be extracted.
+ * @returns The type of the component that the specified Behavior type is associated with.
+ */
 export type ConstructorPropsOfBehavior<BehaviorType> = BehaviorType extends Behavior<infer R> ? R : never;
+/**
+ * Defines a mapping of behavior IDs to their respective properties.
+ */
 export type BehaviorConstructorProps = {
     [id: string]: unknown;
 };
+/**
+ * Base class for all behaviors.
+ *
+ * Behaviors are a versatile way to add interactivity to your experience. They’re often used to:
+ * - Listen to the events emitted by a node and then perform an action, such as playing an animation or calling a function in a context.
+ * - Change the behavior or properties of the node they're attached to.
+ *
+ * @link [custom-behaviors](https://docs.zap.works/mattercraft/scripting/custom-behaviors/)
+ */
 export declare class Behavior<InstanceType extends Component = Component> extends Entity {
     readonly instance: InstanceType;
     /**
@@ -18,5 +43,17 @@ export declare class Behavior<InstanceType extends Component = Component> extend
     private _updateEnabledResolved;
     dispose(): never;
 }
+/**
+ * Checks if a specified Behavior should run at design time.
+ *
+ * @param b - The BehaviorConstructor to check.
+ * @returns A boolean indicating whether the behavior should run at design time.
+ */
 export declare function shouldBehaviorRunAtDesignTime(b: BehaviorConstructor): boolean;
+/**
+ * Registers a Behavior to run at design time.
+ *
+ * @param b - The BehaviorConstructor to register.
+ * @returns The updated Set containing all registered BehaviorConstructors.
+ */
 export declare function registerBehaviorRunAtDesignTime(b: BehaviorConstructor): Set<new (contextManager: ContextManager, instance: Component<any, import("./component").ConstructorProps>, ...args: any[]) => Behavior<Component<any, import("./component").ConstructorProps>>>;