Class BasicInformationServer

This is the default server implementation of BasicInformationBehavior.

Hierarchy

  • Base
    • BasicInformationServer

Constructors

constructor

Properties

[reference] agent cluster context endpoint env events features session state cluster defaults dependencies? early Events ExtensionInterface id Interface Internal name schema? State supervisor supports

Methods

[asyncDispose] asAdmin assertAttributeEnabled callback initialize reactTo requireAttributeEnabled toString alter enable for set with

Constructors

constructor

Properties

[reference]

[reference]: Datasource<StateType>

agent

agent: Agent

cluster

cluster: never

The implemented cluster.

context

context: ActionContext

endpoint

endpoint: Endpoint<Empty>

env

env: Environment

Readonlyevents

events: EventEmitter & Omit<ClusterEvents<BasicInformation.Cluster, typeof ClusterBehavior>,
    | "vendorName$Changing"
    | "vendorId$Changing"
    | "productId$Changing"
    | "vendorName$Changed"
    | "vendorId$Changed"
    | "productId$Changed"
    | "startUp"
    | "shutDown"
    | "leave"
    | "reachableChanged"
    | "reachable$Changing"
    | "productName$Changing"
    | "nodeLabel$Changing"
    | "hardwareVersion$Changing"
    | "hardwareVersionString$Changing"
    | "softwareVersion$Changing"
    | "softwareVersionString$Changing"
    | "manufacturingDate$Changing"
    | "partNumber$Changing"
    | "productUrl$Changing"
    | "productLabel$Changing"
    | "serialNumber$Changing"
    | "uniqueId$Changing"
    | "productAppearance$Changing"
    | "reachable$Changed"
    | "productName$Changed"
    | "nodeLabel$Changed"
    | "hardwareVersion$Changed"
    | "hardwareVersionString$Changed"
    | "softwareVersion$Changed"
    | "softwareVersionString$Changed"
    | "manufacturingDate$Changed"
    | "partNumber$Changed"
    | "productUrl$Changed"
    | "productLabel$Changed"
    | "serialNumber$Changed"
    | "uniqueId$Changed"
    | "productAppearance$Changed"
    | "dataModelRevision$Changing"
    | "location$Changing"
    | "capabilityMinima$Changing"
    | "specificationVersion$Changing"
    | "maxPathsPerInvoke$Changing"
    | "localConfigDisabled$Changing"
    | "dataModelRevision$Changed"
    | "location$Changed"
    | "capabilityMinima$Changed"
    | "specificationVersion$Changed"
    | "maxPathsPerInvoke$Changed"
    | "localConfigDisabled$Changed"> & {
    capabilityMinima$Changing: ClusterEvents.AttributeObservable<FixedAttribute<TypeFromFields<{
        caseSessionsPerFabric: FieldType<number>;
        subscriptionsPerFabric: FieldType<number>;
    }>, any>>;
    dataModelRevision$Changing: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    hardwareVersion$Changing: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    hardwareVersionString$Changing: ClusterEvents.AttributeObservable<FixedAttribute<string, any>>;
    location$Changing: ClusterEvents.AttributeObservable<WritableAttribute<string, any>>;
    maxPathsPerInvoke$Changing: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    nodeLabel$Changing: ClusterEvents.AttributeObservable<WritableAttribute<string, any>>;
    productId$Changing: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    productName$Changing: ClusterEvents.AttributeObservable<FixedAttribute<string, any>>;
    softwareVersion$Changing: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    softwareVersionString$Changing: ClusterEvents.AttributeObservable<FixedAttribute<string, any>>;
    specificationVersion$Changing: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    vendorId$Changing: ClusterEvents.AttributeObservable<FixedAttribute<VendorId, any>>;
    vendorName$Changing: ClusterEvents.AttributeObservable<FixedAttribute<string, any>>;
} & {
    localConfigDisabled$Changing: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<boolean, any>>;
    manufacturingDate$Changing: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
    partNumber$Changing: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
    productAppearance$Changing: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<TypeFromFields<{
        finish: FieldType<BasicInformation.ProductFinish>;
        primaryColor: FieldType<null | BasicInformation.Color>;
    }>, any>>;
    productLabel$Changing: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
    productUrl$Changing: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
    reachable$Changing: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<boolean, any>>;
    serialNumber$Changing: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
    uniqueId$Changing: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
} & {
    capabilityMinima$Changed: ClusterEvents.AttributeObservable<FixedAttribute<TypeFromFields<{
        caseSessionsPerFabric: FieldType<number>;
        subscriptionsPerFabric: FieldType<number>;
    }>, any>>;
    dataModelRevision$Changed: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    hardwareVersion$Changed: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    hardwareVersionString$Changed: ClusterEvents.AttributeObservable<FixedAttribute<string, any>>;
    location$Changed: ClusterEvents.AttributeObservable<WritableAttribute<string, any>>;
    maxPathsPerInvoke$Changed: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    nodeLabel$Changed: ClusterEvents.AttributeObservable<WritableAttribute<string, any>>;
    productId$Changed: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    productName$Changed: ClusterEvents.AttributeObservable<FixedAttribute<string, any>>;
    softwareVersion$Changed: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    softwareVersionString$Changed: ClusterEvents.AttributeObservable<FixedAttribute<string, any>>;
    specificationVersion$Changed: ClusterEvents.AttributeObservable<FixedAttribute<number, any>>;
    vendorId$Changed: ClusterEvents.AttributeObservable<FixedAttribute<VendorId, any>>;
    vendorName$Changed: ClusterEvents.AttributeObservable<FixedAttribute<string, any>>;
} & {
    localConfigDisabled$Changed: undefined | ClusterEvents.AttributeObservable<OptionalWritableAttribute<boolean, any>>;
    manufacturingDate$Changed: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
    partNumber$Changed: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
    productAppearance$Changed: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<TypeFromFields<{
        finish: FieldType<BasicInformation.ProductFinish>;
        primaryColor: FieldType<null | BasicInformation.Color>;
    }>, any>>;
    productLabel$Changed: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
    productUrl$Changed: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
    reachable$Changed: undefined | ClusterEvents.AttributeObservable<OptionalAttribute<boolean, any>>;
    serialNumber$Changed: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
    uniqueId$Changed: undefined | ClusterEvents.AttributeObservable<OptionalFixedAttribute<string, any>>;
} & {
    leave: ClusterEvents.EventObservable<Omit<OptionalEvent<TypeFromFields<{
        fabricIndex: FieldType<FabricIndex>;
    }>, any>, "optional"> & {
        optional: false;
    }>;
    shutDown: ClusterEvents.EventObservable<Omit<OptionalEvent<void, any>, "optional"> & {
        optional: false;
    }>;
    startUp: ClusterEvents.EventObservable<Omit<Event<TypeFromFields<{
        softwareVersion: FieldType<number>;
    }>, any>, "optional"> & {
        optional: false;
    }>;
} & {
    reachableChanged?: ClusterEvents.EventObservable<OptionalEvent<TypeFromFields<{
        reachableNewValue: FieldType<boolean>;
    }>, any>>;
}

Access the behavior's events.

Type declaration

  • Readonlyleave: ClusterEvents.EventObservable<Omit<OptionalEvent<TypeFromFields<{
        fabricIndex: FieldType<FabricIndex>;
    }>, any>, "optional"> & {
        optional: false;
    }>

    The Leave event SHOULD be generated by a Node prior to permanently leaving a given Fabric, such as when the RemoveFabric command is invoked for a given fabric, or triggered by factory reset or some other manufacturer specific action to disable or reset the operational data in the Node. When a Leave event is generated, it SHOULD be assumed that the fabric recorded in the event is no longer usable, and subsequent interactions targeting that fabric will most likely fail.

    Upon receipt of Leave Event on a subscription, the receiving Node may update other nodes in the

    fabric by removing related bindings, access control list entries and other data referencing the leaving Node.

    See

    MatterSpecification.v13.Core § 11.1.6.3

  • ReadonlyshutDown: ClusterEvents.EventObservable<Omit<OptionalEvent<void, any>, "optional"> & {
        optional: false;
    }>

    The ShutDown event SHOULD be generated by a Node prior to any orderly shutdown sequence on a best-effort basis. When a ShutDown event is generated, it SHOULD be the last Data Model event recorded by the Node. This event SHOULD be delivered urgently to current subscribers on a best- effort basis. Any subsequent incoming interactions to the Node may be dropped until the completion of a future boot or reboot process.

    See

    MatterSpecification.v13.Core § 11.1.6.2

  • ReadonlystartUp: ClusterEvents.EventObservable<Omit<Event<TypeFromFields<{
        softwareVersion: FieldType<number>;
    }>, any>, "optional"> & {
        optional: false;
    }>

    The StartUp event shall be generated by a Node as soon as reasonable after completing a boot or reboot process. The StartUp event SHOULD be the first Data Model event recorded by the Node after it completes a boot or reboot process.

    See

    MatterSpecification.v13.Core § 11.1.6.1

Type declaration

  • Optional ReadonlyreachableChanged?: ClusterEvents.EventObservable<OptionalEvent<TypeFromFields<{
        reachableNewValue: FieldType<boolean>;
    }>, any>>

    This event shall be supported if and only if the Reachable attribute is supported.

    This event (when supported) shall be generated when there is a change in the Reachable attribute.

    Its main use case is in the derived Bridged Device Basic Information cluster.

    See

    MatterSpecification.v13.Core § 11.1.6.4

features

features: TypeFromBitSchema<{}>

Supported features as a flag object.

session

session: SecureSession

Readonlystate

state: Omit<ClusterState.Type<BasicInformation.Cluster, typeof ClusterBehavior>,
    | "vendorName"
    | "vendorId"
    | "productId"
    | "productName"
    | "nodeLabel"
    | "hardwareVersion"
    | "hardwareVersionString"
    | "softwareVersion"
    | "softwareVersionString"
    | "manufacturingDate"
    | "partNumber"
    | "productUrl"
    | "productLabel"
    | "serialNumber"
    | "reachable"
    | "uniqueId"
    | "productAppearance"
    | "location"
    | "dataModelRevision"
    | "localConfigDisabled"
    | "capabilityMinima"
    | "specificationVersion"
    | "maxPathsPerInvoke"> & {
    location: string;
    nodeLabel: string;
} & {
    localConfigDisabled?: boolean;
    reachable?: boolean;
} & {
    capabilityMinima: TypeFromFields<{
        caseSessionsPerFabric: FieldType<number>;
        subscriptionsPerFabric: FieldType<number>;
    }>;
    dataModelRevision: number;
    hardwareVersion: number;
    hardwareVersionString: string;
    maxPathsPerInvoke: number;
    productId: number;
    productName: string;
    softwareVersion: number;
    softwareVersionString: string;
    specificationVersion: number;
    vendorId: VendorId;
    vendorName: string;
} & {
    manufacturingDate?: string;
    partNumber?: string;
    productAppearance?: TypeFromFields<{
        finish: FieldType<BasicInformation.ProductFinish>;
        primaryColor: FieldType<null | BasicInformation.Color>;
    }>;
    productLabel?: string;
    productUrl?: string;
    serialNumber?: string;
    uniqueId?: string;
}

Access the behavior's state.

Type declaration

  • Readonlylocation: string

    This attribute shall be an ISO 3166-1 alpha-2 code to represent the country, dependent territory, or special area of geographic interest in which the Node is located at the time of the attribute being set. This attribute shall be set during initial commissioning (unless already set) and may be updated by further reconfigurations. This attribute may affect some regulatory aspects of the Node’s operation, such as radio transmission power levels in given spectrum allocation bands if technologies where this is applicable are used. The Location’s region code shall be interpreted in a case-insensitive manner. If the Node cannot understand the location code with which it was configured, or the location code has not yet been configured, it shall configure itself in a region- agnostic manner as determined by the vendor, avoiding region-specific assumptions as much as is practical. The special value XX shall indicate that region-agnostic mode is used.

    See

    MatterSpecification.v13.Core § 11.1.5.7

  • ReadonlynodeLabel: string

    Indicates a user defined name for the Node. This attribute SHOULD be set during initial commissioning and may be updated by further reconfigurations.

    See

    MatterSpecification.v13.Core § 11.1.5.6

Type declaration

  • Optional ReadonlylocalConfigDisabled?: boolean

    This attribute shall allow a local Node configuration to be disabled. When this attribute is set to True the Node shall disable the ability to configure the Node through an on-Node user interface. The value of the LocalConfigDisabled attribute shall NOT in any way modify, disable, or otherwise affect the user’s ability to trigger a factory reset on the Node.

    See

    MatterSpecification.v13.Core § 11.1.5.17

  • Optional Readonlyreachable?: boolean

    This attribute (when used) shall indicate whether the Node can be reached. For a native Node this is implicitly True (and its use is optional).

    Its main use case is in the derived Bridged Device Basic Information cluster where it is used to indicate whether the bridged device is reachable by the bridge over the non-native network.

    See

    MatterSpecification.v13.Core § 11.1.5.18

Type declaration

  • ReadonlycapabilityMinima: TypeFromFields<{
        caseSessionsPerFabric: FieldType<number>;
        subscriptionsPerFabric: FieldType<number>;
    }>

    This attribute shall provide the minimum guaranteed value for some system-wide resource capabilities that are not otherwise cluster-specific and do not appear elsewhere. This attribute may be used by clients to optimize communication with Nodes by allowing them to use more than the strict minimum values required by this specification, wherever available.

    The values supported by the server in reality may be larger than the values provided in this attribute, such as if a server is not resource-constrained at all. However, clients SHOULD only rely on the amounts provided in this attribute.

    Note that since the fixed values within this attribute may change over time, both increasing and decreasing, as software versions change for a given Node, clients SHOULD take care not to assume forever unchanging values and SHOULD NOT cache this value permanently at Commissioning time.

    See

    MatterSpecification.v13.Core § 11.1.5.20

  • ReadonlydataModelRevision: number

    This attribute shall be set to the revision number of the Data Model against which the Node is certified. The value of this attribute shall be one of the valid values listed in Section 7.1.1, “Revision History”.

    See

    MatterSpecification.v13.Core § 11.1.5.1

  • ReadonlyhardwareVersion: number

    This attribute shall specify the version number of the hardware of the Node. The meaning of its value, and the versioning scheme, are vendor defined.

    See

    MatterSpecification.v13.Core § 11.1.5.8

  • ReadonlyhardwareVersionString: string

    This attribute shall specify the version number of the hardware of the Node. The meaning of its value, and the versioning scheme, are vendor defined. The HardwareVersionString attribute shall be used to provide a more user-friendly value than that represented by the HardwareVersion attribute.

    See

    MatterSpecification.v13.Core § 11.1.5.9

  • ReadonlymaxPathsPerInvoke: number

    Indicates the maximum number of elements in a single InvokeRequests list (see Section 8.8.2, “Invoke Request Action”) that the Node is able to process. Note that since this attribute may change over time, both increasing and decreasing, as software versions change for a given Node, clients SHOULD take care not to assume forever unchanging values and SHOULD NOT

    cache this value permanently at Commissioning time.

    If the MaxPathsPerInvoke attribute is absent or zero, such as in Basic Information cluster revisions prior to Revision 3, clients shall assume a value of 1.

    See

    MatterSpecification.v13.Core § 11.1.5.23

  • ReadonlyproductId: number

    This attribute shall specify the Product ID assigned by the vendor that is unique to the specific product of the Node.

    See

    MatterSpecification.v13.Core § 11.1.5.5

  • ReadonlyproductName: string

    This attribute shall specify a human readable (displayable) name of the model for the Node such as the model number (or other identifier) assigned by the vendor.

    See

    MatterSpecification.v13.Core § 11.1.5.4

  • ReadonlysoftwareVersion: number

    This attribute shall contain the current version number for the software running on this Node.

    The version number can be compared using a total ordering to determine if a version is logically newer than another one. A larger value of SoftwareVersion is newer than a lower value, from the perspective of software updates (see Section 11.20.3.3, “Availability of Software Images”). Nodes may query this field to determine the currently running version of software on another given Node.

    See

    MatterSpecification.v13.Core § 11.1.5.10

  • ReadonlysoftwareVersionString: string

    This attribute shall contain a current human-readable representation for the software running on the Node. This version information may be conveyed to users. The maximum length of the SoftwareVersionString attribute is 64 bytes of UTF-8 characters. The contents SHOULD only use simple 7-bit ASCII alphanumeric and punctuation characters, so as to simplify the conveyance of the value to a variety of cultures.

    Examples of version strings include "1.0", "1.2.3456", "1.2-2", "1.0b123", "1.2_3".

    See

    MatterSpecification.v13.Core § 11.1.5.11

  • ReadonlyspecificationVersion: number

    This attribute shall contain the current version number for the specification version this Node was certified against. The version number can be compared using a total ordering to determine if a version is logically newer than another one. A larger value of SpecificationVersion is newer than a lower value.

    Nodes may query this field to determine the currently supported version of the specification on another given Node.

    The format of this number is segmented as its four component bytes. Bit positions for the fields are as follows:

    For example, a SpecificationVersion value of 0x0102AA00 is composed of 4 version components, representing a version 1.2.170.0.

    In the example above:

    • Major version is the uppermost byte (0x01).

    • Minor version is the following byte (0x02).

    • Patch version is 170/0xAA.

    • Reserved1 value is 0.

    The initial revision (1.0) of this specification (1.0) was 0x01000000. Matter Spring 2024 release (1.3) was 0x01030000.

    If the SpecificationVersion is absent or zero, such as in Basic Information cluster revisions prior to Revision 3, the specification version cannot be properly inferred unless other heuristics are employed.

    Comparison of SpecificationVersion shall always include the total value over 32 bits, without masking reserved parts.

    See

    MatterSpecification.v13.Core § 11.1.5.22

  • ReadonlyvendorId: VendorId

    This attribute shall specify the Vendor ID.

    See

    MatterSpecification.v13.Core § 11.1.5.3

  • ReadonlyvendorName: string

    This attribute shall specify a human readable (displayable) name of the vendor for the Node.

    See

    MatterSpecification.v13.Core § 11.1.5.2

Type declaration

  • Optional ReadonlymanufacturingDate?: string

    This attribute shall specify the date that the Node was manufactured. The first 8 characters shall specify the date of manufacture of the Node in international date notation according to ISO 8601, i.e., YYYYMMDD, e.g., 20060814. The final 8 characters may include country, factory, line, shift or other related information at the option of the vendor. The format of this information is vendor defined.

    See

    MatterSpecification.v13.Core § 11.1.5.12

  • Optional ReadonlypartNumber?: string

    This attribute shall specify a human-readable (displayable) vendor assigned part number for the Node whose meaning and numbering scheme is vendor defined.

    Multiple products (and hence PartNumbers) can share a ProductID. For instance, there may be different packaging (with different PartNumbers) for different regions; also different colors of a product might share the ProductID but may have a different PartNumber.

    See

    MatterSpecification.v13.Core § 11.1.5.13

  • Optional ReadonlyproductAppearance?: TypeFromFields<{
        finish: FieldType<BasicInformation.ProductFinish>;
        primaryColor: FieldType<null | BasicInformation.Color>;
    }>

    This attribute shall provide information about the appearance of the product, which could be useful to a user trying to locate or identify the node.

    See

    MatterSpecification.v13.Core § 11.1.5.21

  • Optional ReadonlyproductLabel?: string

    This attribute shall specify a vendor specific human readable (displayable) product label. The ProductLabel attribute may be used to provide a more user-friendly value than that represented by the ProductName attribute. The ProductLabel attribute SHOULD NOT include the name of the vendor as defined within the VendorName attribute.

    See

    MatterSpecification.v13.Core § 11.1.5.15

  • Optional ReadonlyproductUrl?: string

    This attribute shall specify a link to a product specific web page. The syntax of the ProductURL attribute shall follow the syntax as specified in RFC 3986 [https://tools.ietf.org/html/rfc3986]. The specified URL SHOULD resolve to a maintained web page available for the lifetime of the product. The maximum length of the ProductUrl attribute is 256 ASCII characters.

    See

    MatterSpecification.v13.Core § 11.1.5.14

  • Optional ReadonlyserialNumber?: string

    This attribute shall specify a human readable (displayable) serial number.

    See

    MatterSpecification.v13.Core § 11.1.5.16

  • Optional ReadonlyuniqueId?: string

    This attribute (when used) shall indicate a unique identifier for the device, which is constructed in a manufacturer specific manner.

    It may be constructed using a permanent device identifier (such as device MAC address) as basis. In order to prevent tracking,

    • it SHOULD NOT be identical to (or easily derived from) such permanent device identifier

    • it SHOULD be updated when the device is factory reset

    • it shall not be identical to the SerialNumber attribute

    • it shall not be printed on the product or delivered with the product The value does not need to be human readable.

    See

    MatterSpecification.v13.Core § 11.1.5.19

Static Readonlycluster

cluster: WithAlterations<BasicInformation.Cluster, ElementFlagAlterations<{
    events: {
        leave: true;
        shutDown: true;
        startUp: true;
    };
}>>

Base cluster state include all attribute values but may be extended by subclasses.

Static Readonlydefaults

defaults: ClusterState.Type<WithAlterations<BasicInformation.Cluster, ElementFlagAlterations<{
    events: {
        leave: true;
        shutDown: true;
        startUp: true;
    };
}>>, Type<BasicInformation.Cluster, typeof ClusterBehavior, {
    components: never[];
}>>

Static Optional Readonlydependencies

dependencies?: Iterable<Type, any, any>

Static Readonlyearly

early: boolean

Static ReadonlyEvents

Events: ClusterEvents.Type<WithAlterations<BasicInformation.Cluster, ElementFlagAlterations<{
    events: {
        leave: true;
        shutDown: true;
        startUp: true;
    };
}>>, Type<BasicInformation.Cluster, typeof ClusterBehavior, {
    components: never[];
}>>

Static ReadonlyExtensionInterface

ExtensionInterface: {}

Static Readonlyid

id

The behavior ID for ClusterBehaviors is the name of the cluster.

Static ReadonlyInterface

Interface: {
    components: never[];
}

Static ReadonlyInternal

Internal: (new () => {})

Static Readonlyname

name: string

Static Optional Readonlyschema

schema?: Schema

Static ReadonlyState

State: (new () => ClusterState.Type<WithAlterations<BasicInformation.Cluster, ElementFlagAlterations<{
    events: {
        leave: true;
        shutDown: true;
        startUp: true;
    };
}>>, Type<BasicInformation.Cluster, typeof ClusterBehavior, {
    components: never[];
}>>)

Static Readonlysupervisor

supervisor: RootSupervisor

Staticsupports

supports: ((other: Type) => boolean)

Type declaration

    • (other): boolean

    • Does this behavior support functionality of a specific implementation?

      Parameters

      Returns boolean

Methods

[asyncDispose]

asAdmin

assertAttributeEnabled

Protectedcallback

  • callback<A, R>(reactor, options?): ((...args: A) => undefined | R)

  • Create a generic callback function that has the same properties as a Reactor.

    Like a reactor, the callback's "this" will be bound to an active Behavior instance. Because of this: The reactor MUST be a real JS function - arrow functions will not work!

    Type Parameters

    • A extends any[]
    • R

    Parameters

    Returns ((...args: A) => undefined | R)

      • (...args): undefined | R

      • Parameters

        • Rest...args: A

        Returns undefined | R

initialize

  • initialize(): void

  • Behaviors are ephemeral and should not perform initialization in their constructor. They can override this method instead.

    This method may be synchronous or asyncronous. If asynchronous, the behavior will not be available for external use until initialization completes.

    Returns void

ProtectedreactTo

requireAttributeEnabled

toString

Staticalter

Staticenable

Staticfor

Staticset

Staticwith

Settings

Member Visibility

On This Page

Constructors
Properties
Methods