Interface IdentifyBehavior

interface IdentifyBehavior {
    [reference]: Datasource<StateType>;
    agent: Agent;
    cluster: never;
    context: ActionContext;
    endpoint: Endpoint<Empty>;
    env: Environment;
    events: EventEmitter & Omit<ClusterEvents<Of<{
        attributes: {};
        commands: {};
        events: {};
        id: 0;
        name: "Unknown";
        revision: 0;
    }>, typeof ClusterBehavior>, never> & {
        identifyTime$Changing: ClusterEvents.AttributeObservable<WritableAttribute<number, any>>;
        identifyType$Changing: ClusterEvents.AttributeObservable<Attribute<Identify.IdentifyType, any>>;
    } & {} & {
        identifyTime$Changed: ClusterEvents.AttributeObservable<WritableAttribute<number, any>>;
        identifyType$Changed: ClusterEvents.AttributeObservable<Attribute<Identify.IdentifyType, any>>;
    } & {} & {} & {};
    features: TypeFromBitSchema<{}>;
    session: SecureSession;
    state: Omit<ClusterState.Type<Of<{
        attributes: {};
        commands: {};
        events: {};
        id: 0;
        name: "Unknown";
        revision: 0;
    }>, typeof ClusterBehavior>, never> & {
        identifyTime: number;
        identifyType: Identify.IdentifyType;
    } & {} & {} & {};
    [asyncDispose](): MaybePromise;
    asAdmin(fn: (() => void)): void;
    assertAttributeEnabled<This, K>(this: This, attributeName: K): void;
    callback<A, R>(reactor: Reactor<A, R>, options?: Reactor.Options): ((...args: A) => undefined | R);
    identify(request: Identify.IdentifyRequest): MaybePromise;
    initialize(_options?: {}): MaybePromise;
    reactTo<O>(observable: O, reactor: Reactor<Parameters<O["emit"]>, ReturnType<O["emit"]>>, options?: Reactor.Options): void;
    requireAttributeEnabled<This, K>(this: This, attributeName: K): Exclude<This["state"][K], undefined>;
    toString(): string;
    triggerEffect(request: Identify.TriggerEffectRequest): MaybePromise;
    State: any;
}

Hierarchy (view full)

Properties

[reference] agent cluster context endpoint env events features session state

Methods

[asyncDispose] asAdmin assertAttributeEnabled callback identify initialize reactTo requireAttributeEnabled toString triggerEffect

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<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior>, never> & {
    identifyTime$Changing: ClusterEvents.AttributeObservable<WritableAttribute<number, any>>;
    identifyType$Changing: ClusterEvents.AttributeObservable<Attribute<Identify.IdentifyType, any>>;
} & {} & {
    identifyTime$Changed: ClusterEvents.AttributeObservable<WritableAttribute<number, any>>;
    identifyType$Changed: ClusterEvents.AttributeObservable<Attribute<Identify.IdentifyType, any>>;
} & {} & {} & {}

Access the behavior's events.

features

features: TypeFromBitSchema<{}>

Supported features as a flag object.

session

session: SecureSession

Readonlystate

state: Omit<ClusterState.Type<Of<{
    attributes: {};
    commands: {};
    events: {};
    id: 0;
    name: "Unknown";
    revision: 0;
}>, typeof ClusterBehavior>, never> & {
    identifyTime: number;
    identifyType: Identify.IdentifyType;
} & {} & {} & {}

Access the behavior's state.

Type declaration

  • ReadonlyidentifyTime: number

    This attribute specifies the remaining length of time, in seconds, that the endpoint will continue to identify itself.

    If this attribute is set to a value other than 0 then the device shall enter its identification state, in order to indicate to an observer which of several nodes and/or endpoints it is. It is recommended that this state consists of flashing a light with a period of 0.5 seconds. The IdentifyTime attribute shall be decremented every second while in this state.

    If this attribute reaches or is set to the value 0 then the device shall terminate its identification state.

    See

    MatterSpecification.v13.Cluster § 1.2.5.1

  • ReadonlyidentifyType: Identify.IdentifyType

    This attribute specifies how the identification state is presented to the user.

    This field shall contain one of the values defined in IdentifyTypeEnum. The value None shall NOT be used if the device is capable of presenting its identification state using one of the other methods defined in IdentifyTypeEnum.

    See

    MatterSpecification.v13.Cluster § 1.2.5.2

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

identify

initialize

  • initialize(_options?): MaybePromise

  • 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.

    Parameters

    • Optional_options: {}

      Returns MaybePromise

    ProtectedreactTo

    • reactTo<O>(observable, reactor, options?): void

    • Install a Reactor.

      Important: The reactor MUST be a real JS function - arrow functions will not work!

      Type Parameters

      Parameters

      Returns void

    requireAttributeEnabled

    toString

    triggerEffect

    • triggerEffect(request): MaybePromise

    • This command allows the support of feedback to the user, such as a certain light effect. It is used to allow an implementation to provide visual feedback to the user under certain circumstances such as a color light turning green when it has successfully connected to a network. The use of this command and the effects themselves are entirely up to the implementer to use whenever a visual feedback is useful but it is not the same as and does not replace the identify mechanism used during commissioning.

      Parameters

      Returns MaybePromise

      See

      MatterSpecification.v13.Cluster § 1.2.6.2

    Settings

    Member Visibility

    On This Page

    Properties
    Methods