@libertas-ai/types 0.1.0

package/index.d.ts

@@ -0,0 +1,1380 @@
+/** 
+ * Libertas OS API is intended to be used by 
+ * Libertas application developers.
+ * 
+ * Libertas OS is running on top of Libertas Hub.
+ * End-users create tasks as instances of applications.
+ * 
+ * The API comprises the major components below:
+ * - Device access API
+ * - Time and timers
+ * - Persistent database
+ * - Messaging
+ * - Miscellanies
+*/
+
+/** 
+ * A timer object.
+ * 
+ * @see {@link libertasTimerNewInterval}
+ * @see {@link libertasTimerNewDeadline}
+ * @see {@link libertasTimerUpdate}
+ * @see {@link libertasTimerCancel}
+ * 
+ */
+declare class LibertasTimer {
+}
+
+/** 
+ * A logical device endpoint.
+ * 
+ * @see {@link libertasDeviceReadReq}
+ * @see {@link libertasDeviceWriteReq}
+ * @see {@link libertasDeviceCommandReq}
+ * @see {@link libertasAppSubscribeReq}
+ * @see {@link libertasSetOnDevice}
+ */
+declare type LibertasDevice = number;
+
+/** 
+ * A WiFi or Ethernet device. 
+ * 
+ * @see {@link libertasNetConnectDevice}
+ * 
+ */
+declare type LibertasLanDevice = number;
+
+/** 
+ * A virtual device. The behaviors of the device are managed by application code. 
+ * 
+ * Virtual devices interact with the user during the runtime of Thing-App tasks.
+ * 
+ * @see [Virtual Device API](/doc/developers_doc/virtual_device_api/)
+ * @see {@link libertasVirtualDeviceCommandRsp}
+ * @see {@link libertasVirtualDeviceWriteRsp}
+ * @see {@link libertasVirtualDeviceUpdateEvents}
+ * @see {@link libertasVirtualDeviceAttributesChanged}
+ * @see {@link libertasVirtualDeviceAttributesRsp}
+ * @see {@link libertasSetOnVirtualDevice}
+ */
+declare type LibertasVirtualDevice = number;
+
+/** 
+ * The Date and Time data type. Usually seconds from Unix epoch time. Note the time is always in UTC, but it is presented to the end-user in local time on the UI. 
+ */
+declare type LibertasDateTime = number;
+/** 
+ * The 24-hour time data type, usually with seconds precision. 
+ */
+declare type LibertasTimeOnly = number;
+/** 
+ * User data type. Base type is an integer of a user ID or user group ID. 
+ * 
+ * @see {@link libertasMessageText}
+ */
+declare type LibertasUser = number;
+/** 
+ * Action data type. This type combines a device and device actions (command or attribute set) and is serialized to a string. 
+*/
+declare type LibertasAction = number;
+
+/**
+ * Specialized virtual device for agent/tool interactions.
+ * Data schema must be predefined and published by the server developer.
+ */
+declare type LibertasAgentTool = LibertasVirtualDevice;
+
+/**
+ * A handle to an indexed database table.
+ */
+declare type LibertasDataStore = number;
+
+/**
+ * Used to send broadcast data report in {@link libertasAgentToolSendResponse}. It should be 0xffffffff.
+ */
+declare const enum LibertasPeer {
+    Broadcast = 0xffffffff,
+}
+
+/**
+ * This action code is passed to the device and virtual device callback functions.
+ * 
+ * Based on the Matter interaction action code. Libertas added the {@link LibertasDeviceAction.ReadResponse} code to complete the logic.
+ * 
+ * @see {@link LibertasDeviceCallback} 
+ * @see {@link LibertasVirtualDeviceCallback}
+ * 
+ */
+declare const enum LibertasDeviceAction {
+    StatusResponse        = 0x01,
+    ReadRequest           = 0x02,
+    SubscribeRequest      = 0x03,
+    SubscribeResponse     = 0x04,
+    ReportData            = 0x05,
+    WriteRequest          = 0x06,
+    WriteResponse         = 0x07,
+    InvokeCommandRequest  = 0x08,
+    InvokeCommandResponse = 0x09,
+    ReadResponse          = 0x40,   /** Added by Libertas */
+}
+
+/**
+ * Represents an App's access permissions to a cluster of a {@link LibertasDevice}.
+ * 
+ * @see {@link LibertasDeviceClusterAccess} 
+ * @see {@link libertasDeviceGetClusterAccess} 
+ */
+declare enum LibertasAppAccess {
+    Read    = 0x01,
+    Write   = 0x02,
+}
+
+/**
+ * Used with Matter events.
+ */
+declare enum MatterPriority {
+    Debug = 0,
+    Info = 1,
+    Critical = 2,
+}
+
+/**
+ * Used with Matter events.
+ */
+declare enum MatterTimestampType {
+    System = 0,
+    Epoch = 1,
+}
+
+/**
+ * Message level.
+ * @see [Severity Level](https://librehome.com/doc/developers_doc/notification_api/#severity-level).
+ */
+declare enum LibertasMessageLevel {
+    DEBUG = 1,
+    INFO = 2,
+    ALERT_LOW = 3,
+    ALERT_GUARDED = 4,
+    ALERT_ELEVATED = 5,
+    ALERT_HIGH = 6,
+    ALERT_SEVERE = 7,
+}
+
+/**
+ * A value of the Matter data model, which Libertas adopts.
+ * The value can be the value of an attribute or a field of a command or event.
+ * Note that a command or event must be a LibertasStruct, which could be empty.
+ * 
+ * @see {@link LibertasStruct}
+ */
+declare type LibertasValue = number | boolean | string | BigInt | Uint8Array | LibertasValue[] | LibertasStruct | undefined;
+
+/**
+ * A LibertasStruct can be a LibertasValue. A command or event must be a LibertasStruct, which could be empty.
+ * 
+ * @see {@link LibertasValue} 
+ * @see {@link LibertasCommand} 
+ * @see {@link LibertasEvent} 
+ */
+declare type LibertasStruct = Map<number, LibertasValue>;
+
+/**
+ * A collection of attributes within a cluster as attribute id/value pairs.
+ * 
+ * @see {@link LibertasClusterAttributes}
+ * @see {@link LibertasClusterReport}
+ */
+declare type LibertasAttributes = Map<number, LibertasValue>;
+
+/**
+ * A map of ID/status code pairs. The ID can be an attribute ID, command ID, or event ID.
+ * 
+ * @see {@link LibertasClusterWriteRsp} 
+ * @see {@link LibertasClusterReport} 
+ */
+declare type LibertasIdStatus = Map<number, number>;
+
+/**
+ * A map of cluster ID and a {@link LibertasAppAccess}.
+ * 
+ * @see {@link libertasDeviceGetClusterAccess} 
+ */
+declare type LibertasDeviceClusterAccess = Map<number, number>;
+
+/**
+ * A tuple representing a Matter event.
+ * 
+ * @see {@link LibertasClusterReport}
+ * @see {@link libertasVirtualDeviceUpdateEvents}
+ */
+declare type LibertasEvent = [cluster: number, eventNo: number, priority: MatterPriority, timestamp: number, timestampType: MatterTimestampType, eventId: number, eventData?: LibertasStruct];
+
+/**
+ * A map of event IDs and "urgent" flags.
+ * 
+ * @remarks Use {@link libertasMakeIterable} to use LibertasClusterEventSubscription in a "for...of" loop.
+ * 
+ */
+declare type LibertasClusterEventSubscription = Map<number, boolean>;
+
+/**
+ * A tuple representing a Matter command.
+ * 
+ * @see {@link LibertasCommandRsp}
+ * @see {@link LibertasVirtualDeviceReq}
+ * @see {@link libertasSetOnDevice}
+ * @see {@link libertasDeviceCommandReq}
+ * @see {@link libertasVirtualDeviceCommandRsp}
+ */
+declare type LibertasCommand = [cluster: number, id: number, data?: LibertasStruct];
+
+/**
+ * A tuple representing a collection of attributes (id/value pairs) of a cluster.
+ */
+declare type LibertasClusterAttributes = [cluster: number, attributes: LibertasAttributes];
+
+/**
+ * A tuple representing a read request from a Thing-App task.
+ * 
+ * @see {@link LibertasVirtualDeviceReq}
+ * @see {@link libertasDeviceReadReq}
+ * @see {@link libertasVirtualDeviceAttributesChanged}
+ * 
+ * @remarks
+ * The subscribe request is slightly different than {@link LibertasClusterSubscribeReq} in that an event id can be set as "urgent" in subscription.
+ * 
+ * We currently do not support read by array index. We think it is a bad design. We may add that support in the future if there is a real need.
+ */
+declare type LibertasClusterReadReq = [cluster: number, attributes: number[], events?: number[] ];
+
+/**
+ * Represents a cluster subscription request of a device.
+ * 
+ * @see {@link LibertasClusterEventSubscription}
+ * @see {@link LibertasDeviceSubscribeReq}
+ * @see {@link libertasAppSubscribeReq}
+ * @see {@link libertasSetOnDevice}
+ * 
+ * @remarks
+ * The subscribe request is different than {@link LibertasClusterReadReq} in that an event ID can be set as "urgent."
+ * The minInterval and maxInterval are in seconds. 
+ * 
+ * The effective minInterval and maxInterval may differ due to the varying requirements of multiple agents and device settings.
+ * 
+ * The maxInterval affects the report timeout. The underlying Libertas OS performs timeout detection. The Thing-App task can keep idling until a report or error occurs.
+ */
+declare type LibertasClusterSubscribeReq = [cluster: number, minInterval: number, maxInterval: number, attributes: number[], events?: LibertasClusterEventSubscription ];
+
+/**
+ * Represents a subscription request for a logical device. `eventMin` is required if an event subscription is included.
+ * 
+ * @see {@link LibertasDevice}
+ * @see {@link LibertasClusterSubscribeReq}
+ * @see {@link libertasAppSubscribeReq}
+ * 
+ * @remarks We currently do not support subscribe by array index. We think it is a bad design. We may add that support in the future if there is a real need.
+ */
+declare type LibertasDeviceSubscribeReq = [device: LibertasDevice, clusterSubRequests: LibertasClusterSubscribeReq[], eventMin?: number ];
+
+/**
+ * A command response. The response may be a status code or a command, depending on the data model's design. 
+ * If an error occurs, the response will include the error status code. Applications may use runtime type checking to 
+ * find out the type of the response.
+ * 
+ * @see {@link LibertasCommand}
+ * @see {@link libertasDeviceCommandReq}
+ * @see {@link libertasVirtualDeviceCommandRsp}
+ */
+declare type LibertasCommandRsp = number | LibertasCommand;
+
+/**
+ * Represents a "write response." The key is cluster.
+ * 
+ * @remarks The original write request may be split into multiple requests to the destination. In that case, multiple "write responses" will be received.
+ */
+declare type LibertasClusterWriteRsp = Map<number, LibertasIdStatus>;
+
+/**
+ * Represents cluster report data, part of a device or virtual device report.
+ * 
+ * @see {@link LibertasAttributes}
+ * @see {@link LibertasIdStatus}
+ * @see {@link LibertasEvent}
+ * @see {@link LibertasDeviceRsp}
+ * @see {@link libertasDeviceReadReq}
+ * @see {@link libertasVirtualDeviceAttributesRsp}
+ * 
+ * @remarks attributeStatus must contain the status code of every requested ID. Status code 0 represents a success; otherwise, it is an error. If a status code 0 is present on an ID but the ID is not in the attributes table, a "null" value shall be assumed (this is important for the Lua VM because Lua cannot have a nil value in a table).
+ * 
+ * A virtual device's failure to include all IDs in the attribute status will result in unknown behavior.
+ */
+declare type LibertasClusterReport = [cluster: number, attributes: LibertasAttributes, attributeStatus: LibertasIdStatus, events?: LibertasEvent[], eventStatus?: LibertasIdStatus];
+
+/**
+ * A request to a virtual device. It can be one of three types, depending on the context.
+ * 
+ * @see {@link LibertasClusterReadReq}
+ * @see {@link LibertasClusterAttributes}
+ * @see {@link LibertasCommand}
+ * @see {@link LibertasVirtualDeviceCallback}
+ * @see {@link libertasSetOnVirtualDevice}
+ */
+declare type LibertasVirtualDeviceReq = LibertasClusterReadReq[] | LibertasClusterAttributes[] | LibertasCommand;
+
+/**
+ * All possible responses. A status response is a number.
+ * 
+ * @see {@link LibertasCommandRsp}
+ * @see {@link LibertasClusterWriteRsp}
+ * @see {@link LibertasClusterReport}
+ * @see {@link LibertasDeviceCallback}
+ * @see {@link libertasSetOnDevice}
+ */
+declare type LibertasDeviceRsp = LibertasCommandRsp | LibertasClusterWriteRsp[] | LibertasClusterReport[] | number;
+
+/**
+ * The signature of a device callback function. 
+ * 
+ * @param device A {@link LibertasDevice}.
+ * @param action The {@link LibertasDeviceAction}. Note Libertas added a {@link LibertasDeviceAction.ReadResponse} action.
+ * @param data The response data. It's a union type. The value shall be cast to a type decided by action.
+ * @param tag The arbitrary data passed to {@link libertasSetOnDevice} with the callback instance.
+ * @param ref The reference number of the original request. It is not available if the data is a subscription report.
+ * 
+ * @see {@link LibertasDeviceRsp}
+ * @see {@link libertasSetOnDevice}
+ * 
+ * @remarks For a "status response," if the ref is defined, the status refers to a status against a request; otherwise, it represents the device status (Timeout). 
+ * Subscription reports have no ref number associated.
+ */
+declare type LibertasDeviceCallback = (device: LibertasDevice, action: LibertasDeviceAction, data: LibertasDeviceRsp, tag?: any, ref?: number) => void;
+
+/**
+ * Possible interactions of an agent tool connection.
+ */
+declare const enum LibertasAgentToolAction {
+    /// Agent/tool subscription request opcode.
+    SubscriptionRequest = 3,
+    /// Agent/tool data message opcode.
+    ReportData = 5,
+    /// Agent/tool request opcode (expects response).
+    Request = 8,
+    /// Agent/tool response opcode.
+    Response = 9,
+    /// Agent/tool peer down notification opcode.
+    PeerDown = 20,
+}
+
+/**
+ * The signature of a virtual device I/O callback function.
+ * 
+ * @param device A {@link LibertasDevice}.
+ * @param ref The reference number of the original request. See remarks.
+ * @param action The {@link LibertasDeviceAction}. See remarks
+ * @param data The request data. It's a union type. The value shall be cast to a type decided by action.
+ * @param tag The arbitrary data passed to {@link libertasSetOnVirtualDevice} with the callback instance.
+ * @param peer Uniquely identifies a peer as subscription ID. See remarks.
+ * 
+ * @see {@link libertasSetOnVirtualDevice}
+ * 
+ * @remarks The callback is used to notify the virtual device of a request. Each request has an internally assigned ref number by the engine. 
+ * The ref number must be passed back in the corresponding response.
+ * 
+ * Valid actions:
+ * {@link LibertasDeviceAction.ReadRequest}, {@link LibertasDeviceAction.SubscribeRequest}, and {@link LibertasDeviceAction.ReportData} all request attribute data. {@link LibertasDeviceAction.ReadRequest}
+ * is a one-time read. {@link LibertasDeviceAction.SubscribeRequest} is an initial subscribe request. {@link LibertasDeviceAction.ReportData} is for 
+ * continuous subscription data report. Combined with `peer`, the Thing-App can keep track of current subscribers. The Thing-App can also keep the last subscription related request time to 
+ * calculate interval duration for more flexible subscrption delivery. A virtual device may even respond more data than requested if the common dirty-marking algorithm is not adequate.
+ */
+
+declare type LibertasVirtualDeviceCallback = (device: LibertasVirtualDevice, ref: number, action: LibertasDeviceAction, data: LibertasVirtualDeviceReq, tag?: any, peer?: number) => void;
+
+/**
+ * Callback of an agent tool connection.
+ * @param device A LibertasAgentTool client or server.
+ * @param action interaction action.
+ * @param peer The peer that protocol from which message comes.
+ * @param tag The arbitrary data passed to {@link libertasSetOnAgentTool} with the callback instance.
+ * @param data The protocol message, or undefined if `action` is `PeerDown`.
+ * @param ref The transaction Id. May be undefined if this is unsolicited `ReportData`.
+ */
+declare type LibertasAgentToolCallback<T> = (device: LibertasAgentTool, action: LibertasAgentToolAction, peer: number, tag: any, data?: T, ref?: number) => void;
+
+/**
+ * Set a callback function to receive responses and reports to a device.
+ * 
+ * @param device A {@link LibertasDevice}.
+ * @param func The callback function.
+ * @param tag A developer-defined value that will be passed to the callback function.
+ * 
+ * @see {@link LibertasDeviceCallback}
+ * @see {@link libertasDeviceReadReq}
+ * @see {@link libertasDeviceWriteReq}
+ * @see {@link libertasDeviceCommandReq}
+ * @see {@link libertasAppSubscribeReq}
+ */
+declare function libertasSetOnDevice(device: LibertasDevice, func: LibertasDeviceCallback, tag?: any): void;
+
+/**
+ * Obtain the cluster-access map of a device. This API is used to get basic information about a device.
+ * A LibertasDevice may support multiple types of devices with varying capabilities (clusters). This API returns
+ * the device's actual supported clusters and their App access rights.
+ * 
+ * Cluster access data is part of the App's static data and is returned without querying the "Descriptor" cluster from the device.
+ * 
+ * @param device A {@link LibertasDevice}.
+ * @returns A {@link LibertasDeviceClusterAccess}.
+ * 
+ */
+declare function libertasDeviceGetClusterAccess(device: LibertasDevice) : LibertasDeviceClusterAccess;
+
+/**
+ * Send an asynchronous read request to the device.
+ * 
+ * @param device A {@link LibertasDevice}.
+ * @param requests An array of {@link LibertasClusterReadReq} representing attributes and events for specified clusters.
+ * @param eventMin Must present if events are requested.
+ * @returns A reference number passed back in {@link LibertasDeviceRsp} of {@link LibertasDeviceCallback} callback.
+ * 
+ * @see {@link libertasDeviceGetClusterAccess} 
+ * @see {@link LibertasClusterReadReq}
+ * @see {@link libertasSetOnDevice}
+ * 
+ * @remarks
+ * Use {@link libertasSetOnDevice} to set up the callback function. The callback shall be called later with ReadRsp.
+ * 
+ * The callback will be triggered asynchronously with a {@link LibertasClusterReport}[] array and the reference number. 
+ * 
+ * IMPORTANT! The read request may be responded to with more than one response. Multiple read requests may be pooled into one single response.
+ * 
+ */
+declare function libertasDeviceReadReq(device: LibertasDevice, requests: LibertasClusterReadReq[], eventMin?: number) : number;
+
+/**
+ * Send an asynchronous write request to the device.
+ * 
+ * @param device A {@link LibertasDevice}.
+ * @param requests An array of {@link LibertasClusterAttributes}.
+ * @returns The reference number of this request.
+ * 
+ * @see {@link libertasDeviceGetClusterAccess} 
+ * @see {@link LibertasClusterAttributes}
+ * @see {@link LibertasClusterWriteRsp}
+ * @see {@link libertasSetOnDevice}
+ * 
+ * @remarks
+ * Use {@link libertasSetOnDevice} to set up the callback function for the response.
+ * 
+ * The callback will be triggered asynchronously with a {@link LibertasClusterWriteRsp}[] array and the reference number. 
+ * 
+ * IMPORTANT! If the task sends another WriteReq before the previous WriteReq is responded to, the previous one may be discarded by Libertas OS.
+ * As a general rule, a task shall always wait for the response to the previous interaction before sending another one or only expect the
+ * response to the latest request.
+ * 
+ * The request may never reach the recipient if, for example, there is a network problem. In that case, a 
+ * {@link LibertasDeviceAction.StatusResponse} with a {@link Matter.Status.Timeout} will be received from the callback registered with 
+ * {@link libertasSetOnDevice}.
+ * 
+ * The Thing-App task shall not assume that it is the only process that sends requests. Other agents
+ * may also send requests. A task can only receive {@link LibertasClusterWriteRsp} to its written requests. 
+ * 
+ * To receive all changes to an attribute, use {@link libertasAppSubscribeReq}.
+ * 
+ */
+declare function libertasDeviceWriteReq(device: LibertasDevice, requests: LibertasClusterAttributes[]) : number;
+
+/**
+ * Send an asynchronous command request to the device.
+ * 
+ * @param device A {@link LibertasDevice}.
+ * @param request The {@link LibertasCommand}.
+ * @returns The reference number of this request.
+ * 
+ * @see {@link libertasDeviceGetClusterAccess} 
+ * @see {@link LibertasCommandRsp}
+ * @see {@link libertasSetOnDevice}
+ * 
+ * @remarks
+ * Use {@link libertasSetOnDevice} to set up the callback function for the response.
+ * 
+ * The callback will be triggered asynchronously with a {@link LibertasCommandRsp} and the reference number. 
+ * 
+ * IMPORTANT! If the task sends another command before the previous one is responded to, the previous one may be discarded by Libertas OS.
+ * As a general rule, a task shall always wait for the response to the previous interaction before sending another one or only expect the
+ * response to the latest request.
+ * 
+ * If the task keeps sending commands while a previous command has not received a response, some commands will be
+ * automatically dropped because the Libertas engine can tell that only the last command matters.
+ * 
+ * The request may never reach the recipient if, for example, there is a network problem. In that case, a 
+ * {@link LibertasDeviceAction.StatusResponse} with a {@link Matter.Status.Timeout} will be received from the callback registered with 
+ * {@link libertasSetOnDevice}.
+ * 
+ * The Thing-App task shall not assume that it is the only process that sends requests. Other agents
+ * may also send requests. A task can only receive the {@link LibertasCommandRsp} to its command requests. 
+ * 
+ * To receive all changes to an attribute, use {@link libertasAppSubscribeReq}.
+ */
+declare function libertasDeviceCommandReq(device: LibertasDevice, request: LibertasCommand) : number;
+
+/**
+ * Send a subscription request.
+ * 
+ * @param requests An array of {@link LibertasDeviceSubscribeReq}.
+ * 
+ * @see {@link libertasDeviceGetClusterAccess} 
+ * @see {@link LibertasDeviceSubscribeReq}
+ * @see {@link LibertasClusterReport}
+ * @see {@link LibertasDeviceRsp}
+ * @see {@link libertasSetOnDevice}
+ * 
+ * @remarks
+ * An app only sends out one subscription request. The App must collect the list of all devices that require subscriptions and send them out all at once.
+ * 
+ * Because the Thing-App shares subscriptions with the host and possibly other Thing-Apps, the following behaviors may be observed:
+ * 
+ * 1. The first few data reports may be in response to ReadRequest.
+ * 2. The data reports may contain attributes and events that are not subscribed to by this Thing-App.
+ * 3. Libertas-OS will handle errors, including timeout. A StatusResponse report will be generated in case of errors.
+ * 
+ * The report data will be passed to the callback function {@link LibertasDeviceCallback} registered with {@link libertasSetOnDevice}.
+ */
+declare function libertasAppSubscribeReq(requests: LibertasDeviceSubscribeReq[]) : void;
+
+/**
+ * Notify the Libertas Thing-App engine that some attributes have changed values.
+ * @param device A {@link LibertasVirtualDevice}.
+ * @param attributes The list of cluster attribute IDs. We reuse the {@link LibertasClusterReadReq} structure to hold the required data.
+ * Note that the event field is always undefined because Libertas OS handles the event reports. 
+ * @param peer The subscription ID, which can be inferred from the peer in earlier {@link LibertasVirtualDeviceCallback}. Usually it should be undefined, unless
+ * the Thing-App needs to manage data report for each individual subscriber.
+ * 
+ * @remarks The Thing-App engine is responsible for reporting each subscription based on the subscribed attributes, events, and minimum/maximum intervals.
+ * Even if the virtual device reported the changes, the report may not be generated immediately if the minimum interval has not been reached.
+ * Also, when the Libertas Thing-App engine decides to generate a report, it will send a {@link LibertasDeviceAction.ReadRequest} or 
+ * {@link LibertasDeviceAction.SubscribeRequest} with an array of {@link LibertasClusterReadReq} for the up-to-date values of the specified
+ * attributes and expect a response from {@link libertasVirtualDeviceAttributesRsp} call. If this value is defined, the notification will 
+ * only be delivered to a single subscriber.
+ */
+declare function libertasVirtualDeviceAttributesChanged(device: LibertasVirtualDevice, attributes: LibertasClusterReadReq[], peer?: number) : void;
+
+/**
+ * Update new events.
+ * @param device A {@link LibertasVirtualDevice}.
+ * @param events An array of {@link LibertasEvent}.
+ * 
+ * @remarks Libertas OS manages the event reporting. The eventNo field shall be set to 0 and will be ignored. Libertas OS will automatically assign a consecutive number.
+ */
+declare function libertasVirtualDeviceUpdateEvents(device: LibertasVirtualDevice, events: LibertasEvent[]) : void;
+
+/**
+ * Update attributes unsolicited, or in response to a ReadRequest or SubscribeRequest.
+ * @param device A {@link LibertasVirtualDevice}.
+ * @param ref The ref number of the request.
+ * @param attributes An array of {@link LibertasClusterReport}. Note that the events and eventStatus are undefined. Use {@link libertasVirtualDeviceUpdateEvents} to write events.
+ * 
+ * @remarks
+ * The framework will maintain a cache of all attributes.
+ * 
+ * If a ref number is present, a read response or a report in response to this referenced request will be immediately sent out;
+ * otherwise the Libertas OS engine will decide when to send out the subscription reports.
+ */
+declare function libertasVirtualDeviceAttributesRsp(device: LibertasVirtualDevice, ref: number, attributes: LibertasClusterReport[]) : void;
+
+/**
+ * Send out command responses.
+ * @param device A {@link LibertasVirtualDevice}.
+ * @param ref The ref number of the request.
+ * @param rsp A {@link LibertasCommandRsp}.
+ */
+declare function libertasVirtualDeviceCommandRsp(device: LibertasVirtualDevice, ref: number, rsp: LibertasCommandRsp) : void;
+
+/**
+ * Send out write response.
+ * @param device A {@link LibertasVirtualDevice}.
+ * @param ref The ref number of the request.
+ * @param responses An array of {@link LibertasClusterWriteRsp}.
+ */
+declare function libertasVirtualDeviceWriteRsp(device: LibertasVirtualDevice, ref: number, responses: LibertasClusterWriteRsp[]) : void;
+
+/**
+ * Send out an error status code against an incoming request.
+ * @param device A {@link LibertasVirtualDevice}.
+ * @param ref The ref number of the request.
+ * @param status A {@link Matter.Status}.
+ */
+declare function libertasVirtualDeviceStatusRsp(device: LibertasVirtualDevice, ref: number, status: number) : void;
+
+/**
+ * Listen to a virtual device events.
+ * @param device A {@link LibertasVirtualDevice}.
+ * @param func A {@link LibertasVirtualDeviceCallback} function.
+ * @param tag Developer defined data that will be passed to callback function.
+ */
+declare function libertasSetOnVirtualDevice(device: LibertasVirtualDevice, func: LibertasVirtualDeviceCallback, tag?: any): void;
+
+/**
+ * Sends a request or subscribeRequest message to an agent tool.
+ * 
+ * @param device The target {@link LibertasAgentTool}.
+ * @param action The interaction action, such as {@link LibertasAgentToolAction.Request} or {@link LibertasAgentToolAction.SubscriptionRequest}.
+ * @param message The message payload to send.
+ * 
+ * @returns A transaction ID that can be used to track the request and match it with a future response.
+ */
+declare function libertasAgentToolSendRequest<T>(device: LibertasAgentTool, action: LibertasAgentToolAction, message: T): number;
+
+/**
+ * Sends a response to an agent tool for a previously received request.
+ * 
+ * @param device The target {@link LibertasAgentTool}.
+ * @param action The interaction action, typically {@link LibertasAgentToolAction.Response} or {@link LibertasAgentToolAction.ReportData}.
+ * @param message The message payload containing the response data.
+ * @param dest The request peer Id. It could be {@link LibertasPeer.Broadcast} for {@link LibertasAgentToolAction.ReportData}.
+ * @param transId The transaction ID (ref) from the original request being responded to.
+ */
+declare function libertasAgentToolSendResponse<T>(device: LibertasAgentTool, action: LibertasAgentToolAction, message: T, dest: number, transId: number): void;
+
+/**
+ * Agent tool message callback.
+ * @param device A {@link LibertasAgentTool}.
+ * @param func Callback function.
+ * @param tag Developer defined data that will be passed to callback function.
+ */
+declare function libertasSetOnAgentTool<T>(device: LibertasAgentTool, func: LibertasAgentToolCallback<T>, tag?: any): void;
+
+/**
+ * The signature of timer callback function.
+ * 
+ * @param timer A timer returned from {@link libertasTimerNewInterval} or {@link libertasTimerNewDeadline}.
+ * @param now Current time ticks in microseconds. It will start to lose precision after about 285 years from Linux epoch.
+ * @param tag A context object passed when creating the timer.
+ * 
+ * @see {@link libertasTimerNewInterval}
+ * @see {@link libertasTimerNewDeadline}
+ * @see {@link libertasTimerUpdate}
+ */
+declare type LibertasTimerCallback = (timer: LibertasTimer, now: number, tag: any) => void;
+
+/**
+ * Create a new interval timer.
+ * 
+ * @param timeout Positive timeout in microseconds using the monotonic timer source. If the timeout is 0, the timer is "put on hold"; use {@link libertasTimerUpdate} later to reschedule the timer.
+ * @param func Callback function.
+ * @param tag Developer-defined tag value to be passed over to the callback function.
+ * 
+ * @returns A new timer object.
+ * 
+ * @remarks
+ * Timer is always a one-off. When the timeout is reached, the callback is called, and the timer is then automatically canceled as if
+ * {@link libertasTimerCancel} is called.
+ * 
+ * Both active timers and canceled timers can be reused by calling {@link libertasTimerUpdate}. Always try to
+ * reuse instead of creating new timers.
+ * 
+ * The Timer API is a reactive API. Timers are driven by {@link libertasWaitReactive}. Never mix imperative and reactive APIs within the same thread.
+ * 
+ * @see {@link libertasTimerCancel} 
+ * @see {@link libertasTimerUpdate}
+ */
+declare function libertasTimerNewInterval(timeout: number, func: LibertasTimerCallback, tag?: any): LibertasTimer;
+
+/**
+ * Create a new deadline timer.
+ * 
+ * @param timeout Positive timeout in microseconds in UTC time. If the timeout is 0, the timer is "put on hold"; use {@link libertasTimerUpdate} later to reschedule the timer.
+ * @param func Callback function.
+ * @param tag Developer-defined tag value to be passed over to the callback function.
+ * 
+ * @returns A new timer object.
+ * 
+ * @remarks
+ * Timer is always a one-off. When the timeout is reached, the callback is called, and the timer is then automatically canceled as if
+ * {@link libertasTimerCancel} is called.
+ * 
+ * Both active timers and canceled timers can be reused by calling {@link libertasTimerUpdate}. Always try to
+ * reuse instead of creating new timers.
+ * 
+ * The Timer API is a reactive API. Timers are driven by {@link libertasWaitReactive}. Never mix imperative and reactive APIs within the same thread.
+ * 
+ * @see {@link libertasTimerCancel} 
+ * @see {@link libertasTimerUpdate}
+ */
+declare function libertasTimerNewDeadline(timeout: number, func: LibertasTimerCallback, tag?: any): LibertasTimer;
+
+/**
+ * Cancels a timer so it won't be triggered..
+ * 
+ * @param timer A {@link LibertasTimer} created with {@link libertasTimerNewInterval} or {@link libertasTimerNewDeadline}.
+ * 
+ * @remarks
+ * Timer is always a one-off. When the timeout is reached, the callback is called, and the timer is then automatically canceled as if
+ * {@link libertasTimerCancel} is called.
+ * 
+ * Both active timers and canceled timers can be reused by calling {@link libertasTimerUpdate}. Always try to
+ * reuse instead of creating new timers. Use {@link libertasTimerDestroy} to completely destroy a timer.
+ * 
+ * The Timer API is a reactive API. Timers are driven by {@link libertasWaitReactive}. Never mix imperative and reactive APIs within the same thread.
+ * 
+ * @see {@link libertasTimerNewInterval} 
+ * @see {@link libertasTimerNewDeadline} 
+ * @see {@link libertasTimerUpdate}
+ */
+declare function libertasTimerCancel(timer: LibertasTimer): void;
+
+/**
+ * Destroy a timer and releases all related resources.
+ * @param timer A {@link LibertasTimer} created with {@link libertasTimerNewInterval} or {@link libertasTimerNewDeadline}.
+ * 
+ * The timer cannot be used after this call.
+ */
+declare function libertasTimerDestroy(timer: LibertasTimer): void;
+
+/**
+ * Reset and update a timer.
+ * 
+ * @param timer A {@link LibertasTimer} created with {@link libertasTimerNewInterval} or {@link libertasTimerNewDeadline}.
+ * @param timeout Positive timeout in microseconds. The value is monotonic system ticks or UTC time, depending on the type of timer.
+ * @param func Optional. If present, replace the callback function of an old-timer.
+ * @param tag Optional. If present, replace the tag object of an old-timer.
+ * 
+ * @see {@link libertasTimerNewInterval}
+ * @see {@link libertasTimerNewDeadline}
+ * @see {@link LibertasTimerCallback}
+ * @see {@link libertasTimerCancel} 
+ * 
+ * @remarks Arguments func and tag will not be reset to undefined or null. If arguments are undefined, original values will be kept.
+ * 
+ * Timer is always a one-off. When the timeout is reached, the callback is called, and the timer is then automatically canceled as if
+ * {@link libertasTimerCancel} is called.
+ * 
+ * Both active timers and canceled timers can be reused by calling {@link libertasTimerUpdate}. Always try to
+ * reuse instead of creating new timers.
+ * 
+ * The Timer API is a reactive API. Timers are driven by {@link libertasWaitReactive}. Never mix imperative and reactive APIs within the same thread.
+ */
+declare function libertasTimerUpdate(timer: LibertasTimer, timeout: number, func?: LibertasTimerCallback, tag?: any): void
+
+/**
+ * Trigger a user defined action. Users can define action with a client UI tool during Thing-App task creation.
+ * @param action A {@link LibertasAction}.
+ */
+declare function libertasTriggerAction(action: LibertasAction): void;
+
+/**
+ * Notification severity levels.
+ *
+ * - `Debug`: Debugging info.
+ * - `Info`: General info.
+ * - `AlertLow`: Low-priority alerts.
+ * - `AlertGuarded`: Guarded alerts.
+ * - `AlertElevated`: Elevated alerts.
+ * - `AlertHigh`: High alerts.
+ * - `AlertSevere`: Severe alerts.
+ */
+declare const enum NotificationImportance {
+  Debug = 0,
+  Info = 1,
+  AlertLow = 2,
+  AlertGuarded = 3,
+  AlertElevated = 4,
+  AlertHigh = 5,
+  AlertSevere = 6,
+}
+
+/**
+ * Notification argument variant tags.
+ */
+declare const enum NotificationArgTag {
+  /**
+   * A literal string argument included in the message as-is, without being
+   * treated as a resource string. This can be used to include specific text that
+   * does not need to be localized or looked up from resources.
+   */
+  LiteralText = 0,
+  /**
+   * A Libertas system object, such as a device, user, or other entity within the
+   * system. The value is expected to be a 32-bit unsigned integer identifier.
+   *
+   * The application task must have access permission to the object in order to
+   * include it as an argument in the message.
+   */
+  Object = 1,
+  /**
+   * A boolean value, true or false, included as an argument in a message.
+   */
+  Boolean = 2,
+  /**
+   * A signed integer value included as an argument in a message.
+   *
+   * This can convey counts, measurements, or other integer-based data that can
+   * be positive or negative.
+   */
+  Signed = 3,
+  /**
+   * An unsigned integer value included as an argument in a message.
+   *
+   * This can convey non-negative numerical information such as counts, sizes, or
+   * other unsigned integer-based data.
+   */
+  Unsigned = 4,
+  /**
+   * A single-precision floating-point value included as an argument in a
+   * message.
+   */
+  Float = 5,
+  /**
+   * A double-precision floating-point value included as an argument in a
+   * message.
+   */
+  Double = 6,
+  /**
+   * A signed integer value with a specific unit type.
+   *
+   * This can represent measurements or other data with a unit of measurement,
+   * such as temperature, distance, or another relevant unit.
+   */
+  UnitSigned = 7,
+  /**
+   * An unsigned integer value with a specific unit type.
+   *
+   * This can represent measurements or other non-negative data with a unit of
+   * measurement, such as file sizes, speeds, or another relevant unit.
+   */
+  UnitUnsigned = 8,
+  /**
+   * A single-precision floating-point value with a specific unit type.
+   */
+  UnitFloat = 9,
+  /**
+   * A double-precision floating-point value with a specific unit type.
+   */
+  UnitDouble = 10,
+  /**
+   * A resource string argument.
+   *
+   * This is included in the message as a reference to a resource string rather
+   * than as literal text. This allows the text to be localized or looked up from
+   * resources based on the user's language or other context.
+   */
+  ResourceText = 11,
+  /**
+   * A plural value used for pluralization.
+   *
+   * This is typically used with resource string templates that have plural
+   * forms. The value determines which plural form of the resource string should
+   * be used when generating the final message.
+   */
+  Plural = 12,
+}
+
+/**
+ * Arguments for notification templates.
+ *
+ * Supports various data types for message formatting.
+ *
+ * The rendering of the message follows a "printf" style and is based on the
+ * resource string template and the provided arguments. This type supports
+ * literal text, resource text, objects, boolean values, numerical values, and
+ * unit values with specific unit types.
+ *
+ * These arguments allow messages to be rich in content and convey a wide range
+ * of information to users or other parts of the system when sending
+ * notifications through the Libertas system.
+ *
+ * This type is also used as an argument in name templates to provide
+ * predictable yet flexible names for database names and data fields, making
+ * Libertas apps fully self-describing.
+ */
+declare type NotificationArgument =
+    | { type: NotificationArgTag.LiteralText; value: string }
+    | { type: NotificationArgTag.Object; value: number }
+    | { type: NotificationArgTag.Boolean; value: boolean }
+    | { type: NotificationArgTag.Signed; value: bigint }
+    | { type: NotificationArgTag.Unsigned; value: bigint }
+    | { type: NotificationArgTag.Float; value: number }
+    | { type: NotificationArgTag.Double; value: number }
+    | { type: NotificationArgTag.UnitSigned; unit_type: string; value: bigint }
+    | { type: NotificationArgTag.UnitUnsigned; unit_type: string; value: bigint }
+    | { type: NotificationArgTag.UnitFloat; unit_type: string; value: number }
+    | { type: NotificationArgTag.UnitDouble; unit_type: string; value: number }
+    | { type: NotificationArgTag.ResourceText; value: string }
+    | { type: NotificationArgTag.Plural; value: bigint };
+
+/**
+ * Sends a templated notification to recipients.
+ *
+ * @param recipients - List of recipient IDs.
+ * @param level - Message severity.
+ * @param resource_name - Template resource name.
+ * @param args - Template arguments.
+ * @param source - Optional source ID. If omitted, the current task ID is used.
+ *
+ * @throws On size limits or permission violations.
+ */    
+declare function libertas_NotificationSend(recipients: number[], level: NotificationImportance, resource_name: string, args: NotificationArgument[], source?: number): void;
+
+/**
+ * Sends a literal text notification.
+ *
+ * @param recipients - List of recipient IDs.
+ * @param level - Message severity.
+ * @param text - Message content.
+ * @param source - Optional source ID. If omitted, the current task ID is used.
+ *
+ * @throws On size limits or permission violations.
+ */
+declare function libertas_NotificationSendLiteral(recipients: number[], level: NotificationImportance, text: string, source?: number): void;
+
+/**
+ * Data name with resource and arguments.
+ * Used for identifying standalone and indexed data in the database.
+ * printf-style localized templates shall be supplied in App documents to render the resource name into natural language with arguments.
+ */
+declare interface DataName {
+    resourceName: string;
+    arguments: NotificationArgument[];
+}
+
+declare const enum IndexDirection {
+    Above,
+    Below,
+}
+
+/**
+ * Statistics for opened indexed data.
+ *
+ * Contains handle, record count, and index range.
+ *
+ * If `count` is `0`, then `minIndex` and `maxIndex` are undefined. Otherwise,
+ * valid indices are in the range `[minIndex, maxIndex]`.
+ */
+declare interface IndexedDataStat {
+  /** Database handle. */
+  handle: LibertasDataStore;
+
+  /** Number of records in the indexed data store. */
+  count: bigint;
+
+  /** Minimum record index. Undefined when `count` is `0`. */
+  minIndex: bigint;
+
+  /** Maximum record index. Undefined when `count` is `0`. */
+  maxIndex: bigint;
+}
+
+/**
+ * Indexed data record with index and decoded data.
+ */
+declare interface IndexedData<T> {
+  /** Record index. */
+  index: bigint;
+
+  /** Decoded record data. */
+  data: T;
+}
+
+/**
+ * Returns all standalone data names.
+ *
+ * @returns Data names with resource names and arguments.
+ */
+declare function libertasDataGetNames(): DataName[];
+
+/**
+ * Returns all indexed data names.
+ *
+ * @returns Indexed data names.
+ */
+declare function libertasDataGetIndexedNames(): DataName[];
+
+/**
+ * Removes standalone data by resource name and arguments.
+ *
+ * @param resourceName - Resource name of the standalone data to remove.
+ * @param arguments_ - Resource arguments identifying the standalone data.
+ */
+declare function libertasDataRemove(
+  resourceName: string,
+  arguments_: readonly NotificationArgument[],
+): void;
+
+/**
+ * Removes a piece of indexed data from the indexed database.
+ *
+ * The data to remove is identified by the resource name and arguments. The
+ * resource name and arguments are encoded in Avro format and sent to the device
+ * to perform the removal. After this function is called, the specified indexed
+ * data will no longer be available in the indexed database.
+ *
+ * Note that indexed data is different from standalone data in that it is
+ * organized by an index value, which allows for efficient querying based on
+ * that index.
+ *
+ * When you remove indexed data using this function, you are removing all
+ * records that match the specified resource name and arguments, regardless of
+ * their index values.
+ *
+ * @param resourceName - Resource name of the indexed data to remove, such as
+ * `"player_score_history"` or `"enemy_spawn_events"`.
+ * @param arguments_ - Arguments that further specify the indexed data to
+ * remove. The specific arguments needed depend on how the indexed data was
+ * originally written to the database.
+ */
+declare function libertasDataRemoveIndexed(
+  resourceName: string,
+  arguments_: readonly NotificationArgument[],
+): void;
+
+/**
+ * Removes indexed records in the given index range.
+ *
+ * @param db - Database handle. See `libertasDataOpenIndexed` for obtaining the
+ * handle.
+ * @param indexLo - Lower index bound, inclusive.
+ * @param indexHi - Upper index bound, inclusive.
+ */
+declare function libertasDataRemoveIndexedRecords(
+  db: LibertasDataStore,
+  indexLo: number | bigint,
+  indexHi: number | bigint,
+): void;
+
+/**
+ * Opens indexed data and returns its handle with stats.
+ *
+ * @param resourceName - Resource identifier.
+ * @param arguments_ - Resource arguments.
+ *
+ * @returns Indexed data stats with handle, count, and index range. If `count`
+ * is `0`, then `minIndex` and `maxIndex` are undefined.
+ *
+ * @throws If the indexed data cannot be opened.
+ */
+declare function libertasDataOpenIndexed(
+  resourceName: string,
+  arguments_: readonly NotificationArgument[],
+): IndexedDataStat;
+
+/**
+ * Writes data to the standalone database.
+ *
+ * @param resourceName - Resource identifier.
+ * @param arguments_ - Resource arguments.
+ * @param data - Encodable data.
+ */
+declare function libertasDataWrite(
+  resourceName: string,
+  arguments_: readonly NotificationArgument[],
+  data: any,
+): void;
+
+/**
+ * Writes indexed data.
+ *
+ * @param db - Database handle. See `libertasDataOpenIndexed` for obtaining the
+ * handle.
+ * @param index - Record index.
+ * @param data - Encodable data.
+ */
+declare function libertasDataWriteIndexed(
+  db: LibertasDataStore,
+  index: number | bigint,
+  data: any,
+): void ;
+
+/**
+ * Reads standalone data.
+ *
+ * @typeParam T - Decoded data type.
+ *
+ * @param resourceName - Resource identifier.
+ * @param arguments_ - Resource arguments.
+ *
+ * @returns Decoded data, or `undefined` if not found.
+ */
+declare function libertasDataRead<T> (
+  resourceName: string,
+  arguments_: readonly NotificationArgument[]
+): T | undefined;
+
+/**
+ * Reads an indexed data range.
+ *
+ * @typeParam T - Decoded data type.
+ *
+ * @param db - Database handle. See `libertasDataOpenIndexed` for obtaining the
+ * handle.
+ * @param index - Starting index.
+ * @param direction - Read direction.
+ * @param maxN - Maximum number of records to read.
+ *
+ * @returns Decoded indexed records.
+ */
+declare function libertasDataReadIndexedRange<T> (
+  db: LibertasDataStore,
+  index: bigint,
+  direction: IndexDirection,
+  maxN: number,
+): IndexedData<T>[];
+
+/**
+ * Reads a single indexed data record.
+ *
+ * @typeParam T - Decoded data type.
+ *
+ * @param db - Database handle. See `libertasDataOpenIndexed` for obtaining the
+ * handle.
+ * @param index - Record index.
+ *
+ * @returns Decoded record, or `undefined` if not found.
+ */
+declare function libertasDataReadIndexed<T>(
+  db: LibertasDataStore,
+  index: number | bigint,
+): T | undefined;
+
+/**
+ * Log levels
+ */
+declare const enum LibertasLogLevel {
+    TRACE,
+    DEBUG,
+    INFO,
+    WARN,
+    ERROR,
+    FATAL,
+}
+
+/**
+ * Write a message to system log.
+ * @param level Log level.
+ * @param message A text message.
+ * 
+ * @remarks The log source is the name of the Thing-App task.
+ */
+declare function libertasLog(level: LibertasLogLevel, message: string): void;
+
+declare namespace Libertas {
+    /**
+     * The device type constants. Compatible with the Zigbee protocol with Libertas-specific additions.
+     */
+    export enum DeviceType {
+        NA = 0xFFFF,
+        ANY = 0xFFFF,
+        // LIBERTAS
+        TASK = 0xF000,
+        PROXIMITY_SENSOR = 0xF001,
+        GEN_MULTISTATE = 0xF002,
+        SPRINKLER_CONTROLLER = 0xF003,
+    }
+
+    /**
+     * The Libertas cluster constants. Compatible with the Zigbee protocol with Libertas-specific additions.
+     * 
+     * Clusters are a group of commands and attributes that define what a device can do. Think of clusters as a group of actions by function. A device can support multiple clusters to do a whole variety of tasks.
+     * 
+     * In another word, Clusters specify the capabilities of a device.
+     * 
+     */
+    export enum LibertasClusterId {
+        // General Clusters
+        INVALID = 0xFFFF,
+        // Clusters
+        LIBERTAS_SWITCH_CONFIG = 0xFC00,
+        LIBERTAS_SWITCH_LINKABLE = 0xFC01,
+        LIBERTAS_LEVEL_CONFIG = 0xFC02,
+        LIBERTAS_LEVEL_DISPLAY = 0xFC03,
+        LIBERTAS_BACKLIGHT_LEVEL = 0xFC04,
+        LIBERTAS_BACKLIGHT_CONFIG = 0xFC05,
+        LIBERTAS_ONOFF_CONFIG = 0xFC06,
+        LIBERTAS_GEN_SENSOR = 0xFC07,
+        LIBERTAS_FLASH_MEMORY = 0xFC10,
+        LIBERTAS_UI = 0xFC20,
+        LIBERTAS_REMOTE = 0xFC30,
+        LIBERTAS_THERMOSTAT = 0xFC40,
+        LIBERTAS_THERMOSTAT_HEAT = 0xFC41,
+        LIBERTAS_THERMOSTAT_COOL = 0xFC42,
+        LIBERTAS_THERMOSTAT_AUX = 0xFC43,
+        LIBERTAS_PROXIMITY = 0xFC50,
+        LIBERTAS_SPRINKLER_CONFIG = 0xFC60,
+        LIBERTAS_HUB = 0xFC70,
+        LIBERTAS_APP = 0xFC80,
+    }
+
+    /**
+     * Attributes are a set of properties within a Cluster.
+     * 
+     * Each attribute is identified by an ID (16-bit integer), along with a predefined data type.
+     * 
+     */
+    export enum LibertasAttrId {
+        LIBERTAS_HVAC_THERMOSTAT_LOCAL_HUMIDITY = 0x8000,
+        LIBERTAS_HVAC_THERMOSTAT_LOCAL_HUMIDITY_CALIBRATION = 0x8001,
+        LIBERTAS_HVAC_THERMOSTAT_HUMIDITY_LOW = 0x8002,
+        LIBERTAS_HVAC_THERMOSTAT_HUMIDITY_HIGH = 0x8003,
+        LIBERTAS_HVAC_THERMOSTAT_HEAT_USES_AUX = 0x8004,
+
+        // Power CFG
+        LIBERTAS_POWER_CFG_BATTERY_VOLTAGE = 0x8020,
+
+        // Required
+        LIBERTAS_SWITCH_LINKED_TO = 0x0000,
+
+        // In qwha_switch.h
+        // qwha_switch_type_t
+        LIBERTAS_SWITCH_TYPE = 0x0000,
+        LIBERTAS_SWITCH_CLUSTER = 0x0001,
+        LIBERTAS_SWITCH_PRESS_DELAY = 0x0002,
+        LIBERTAS_SWITCH_ACTION_COMMANDS_1 = 0x0003,
+        LIBERTAS_SWITCH_ACTION_COMMANDS_2 = 0x0004,
+        LIBERTAS_SWITCH_LOAD_DEVICE = 0x0005,
+
+        // ZCL_CLUSTER_ID_LIBERTAS_LEVEL_CONFIG
+        LIBERTAS_LEVEL_MAX = 0x0000,
+        LIBERTAS_LEVEL_MIN = 0x0001,
+        LIBERTAS_LEVEL_STEP_ONLY = 0x0002,
+        LIBERTAS_LEVEL_STEP_SINGLE = 0x0003,
+        LIBERTAS_LEVEL_STEP_REPEAT = 0x0004,
+        LIBERTAS_LEVEL_STEP_INTERVAL = 0x0005,
+        // ZCL_CLUSTER_ID_LIBERTAS_LEVEL_DISPLAY
+        LIBERTAS_LEVEL_DISPLAY_OFFSET = 0x0000,
+        LIBERTAS_LEVEL_DISPLAY_SCALE = 0x0001,
+        LIBERTAS_LEVEL_DISPLAY_DIGITS = 0x0002,
+        LIBERTAS_LEVEL_DISPLAY_FLAGS = 0x0003,
+        // ZCL_CLUSTER_ID_LIBERTAS_BACKLIGHT
+        LIBERTAS_BACKLIGHT_LEVEL = 0x0000,
+        LIBERTAS_BACKLIGHT_ON_PATTERN = 0x0001,
+        LIBERTAS_BACKLIGHT_OFF_PATTERN = 0x0002,
+        LIBERTAS_BACKLIGHT_ANI_PATTERN = 0x0003,
+        // ZCL_CLUSTER_ID_LIBERTAS_REMOTE
+        LIBERTAS_REMOTE_BUTTON_CONFIG = 0x0000,
+        // ZCL_CLUSTER_ID_LIBERTAS_ONOFF_CONFIG
+        LIBERTAS_ONOFF_DEFAULT_ON_TIME = 0x0000,
+        LIBERTAS_ONOFF_DEFAULT_OFF_WAIT_TIME = 0x0001,
+        LIBERTAS_ONOFF_TIME_INTERVAL = 0x0002,
+
+        // ZCL_CLUSTER_ID_LIBERTAS_THERMOSTAT
+        LIBERTAS_THERMOSTAT_COOL_HVAC_UNIT_ID = 0x0000,
+        LIBERTAS_THERMOSTAT_HEAT_HVAC_UNIT_ID = 0x0001,
+        LIBERTAS_THERMOSTAT_COOL_TYPE = 0x0002,
+        LIBERTAS_THERMOSTAT_HEAT_TYPE = 0x0003,
+        LIBERTAS_THERMOSTAT_AUX_HEAT_TYPE = 0x0004,
+        LIBERTAS_THERMOSTAT_COOL_STAGES = 0x0005,
+        LIBERTAS_THERMOSTAT_HEAT_STAGES = 0x0006,
+        LIBERTAS_THERMOSTAT_AUX_HEAT_STAGES = 0x0007,
+        LIBERTAS_THERMOSTAT_FAN_STAGES = 0x0008,
+        LIBERTAS_THERMOSTAT_HEAT_PUMP_OB_ON_COOL = 0x0009,
+        LIBERTAS_THERMOSTAT_FAN_USAGE = 0x000A,
+        LIBERTAS_THERMOSTAT_ACC_TYPE = 0x000B,
+        LIBERTAS_THERMOSTAT_ACC_EXT_POWER = 0x000C,
+
+        // Cool or heat parameters
+        LIBERTAS_THERMOSTAT_MIN_OFF_TIME = 0x0010,
+        LIBERTAS_THERMOSTAT_MIN_ON_TIME = 0x0011,
+        LIBERTAS_THERMOSTAT_MAINTENANCE_BAND = 0x0012,
+        LIBERTAS_THERMOSTAT_DISSIPATION_TIME = 0x0013,
+        LIBERTAS_THERMOSTAT_STAGE1_TEMP_DELTA = 0x0014,
+        LIBERTAS_THERMOSTAT_STAGE1_MAX_RUNTIME = 0x0015,
+        LIBERTAS_THERMOSTAT_STAGE2_TEMP_DELTA = 0x0016,
+        LIBERTAS_THERMOSTAT_STAGE2_MAX_RUNTIME = 0x0017,
+        LIBERTAS_THERMOSTAT_STAGE3_TEMP_DELTA = 0x0018,
+        
+        //LIBERTAS_HUB
+
+        /**
+         * Minimum state of a multi-state device, for {@link LibertasClusterId.LIBERTAS_HUB}.
+         * 
+         * @remarks This attribute can be generated by a virtual device driver App. Date type is int16.
+         */
+        LIBERTAS_MULTISTATE_MIN			=	0x0004,		// int16
+        /**
+         * Maximum state of a multi-state device, for {@link LibertasClusterId.LIBERTAS_HUB}.
+         * 
+         * @remarks This attribute can be generated by a virtual device driver App. Date type is int16.
+         */
+        LIBERTAS_MULTISTATE_MAX			=	0x0005,		// int16
+        /**
+         * Constrains valid values of a multi-state device, for {@link LibertasClusterId.LIBERTAS_HUB}.
+         */
+        LIBERTAS_MULTISTATE_VALUES		=	0x0006,		// int16 array
+        /**
+         * Name of states of a multi-state device, for {@link LibertasClusterId.LIBERTAS_HUB}.
+         */
+        LIBERTAS_MULTISTATE_NAMES		=	0x0007,		// string array
+    }
+
+    /**
+     * A logical device can be either load or non-load device.
+     * 
+     * For example, a "dummy" button is a non-load device because it can only be used to control other devices by sending control signals.
+     * 
+     * Sensors are considered "load" devices.
+     * 
+     * @remarks
+     * Only load devices are allowed within an IoT App. Non-load buttons are managed internally by the system through end-user device group linking.
+     * 
+     * As an exception, virtual devices can be either load or non-load type because it makes sense to emulate a non-load device (such as a button) with app code and expose the virtual device to the system.
+     *   
+     */
+    export enum LibertasDeviceLoadType {
+        LOAD_NON = 0,
+        LOAD = 1,
+        LOAD_ANY = 2,
+    }
+}
+
+declare namespace Matter {
+    /**
+     * Interaction model status codes.
+     */
+    export enum Status {
+        Success                = 0x0,
+        Failure                = 0x01,
+        InvalidSubscription    = 0x7d,
+        UnsupportedAccess      = 0x7e,
+        UnsupportedEndpoint    = 0x7f,
+        InvalidAction          = 0x80,
+        UnsupportedCommand     = 0x81,
+        Deprecated82           = 0x82,
+        Deprecated83           = 0x83,
+        Deprecated84           = 0x84,
+        InvalidCommand         = 0x85,
+        UnsupportedAttribute   = 0x86,
+        ConstraintError        = 0x87,
+        UnsupportedWrite       = 0x88,
+        ResourceExhausted      = 0x89,
+        Deprecated8a           = 0x8a,
+        NotFound               = 0x8b,
+        UnreportableAttribute  = 0x8c,
+        InvalidDataType        = 0x8d,
+        Deprecated8e           = 0x8e,
+        UnsupportedRead        = 0x8f,
+        Deprecated90           = 0x90,
+        Deprecated91           = 0x91,
+        DataVersionMismatch    = 0x92,
+        Deprecated93           = 0x93,
+        Timeout                = 0x94,
+        Reserved95             = 0x95,
+        Reserved96             = 0x96,
+        Reserved97             = 0x97,
+        Reserved98             = 0x98,
+        Reserved99             = 0x99,
+        Reserved9a             = 0x9a,
+        Busy                   = 0x9c,
+        Deprecatedc0           = 0xc0,
+        Deprecatedc1           = 0xc1,
+        Deprecatedc2           = 0xc2,
+        UnsupportedCluster     = 0xc3,
+        Deprecatedc4           = 0xc4,
+        NoUpstreamSubscription = 0xc5,
+        NeedsTimedInteraction  = 0xc6,
+        UnsupportedEvent       = 0xc7,
+        PathsExhausted         = 0xc8,
+        TimedRequestMismatch   = 0xc9,
+        FailsafeRequired       = 0xca,
+        InvalidInState         = 0xcb,
+        NoCommandResponse      = 0xcc,
+        WriteIgnored           = 0xF0, // non-spec error code and use only internally
+    }    
+}

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@libertas-ai/types",
+  "version": "0.1.0",
+  "description": "Libertas TypeScript SDK",
+  "license": "ISC",
+  "author": "Qingjun Wei",
+  "types": "./index.d.ts",
+  "files": [
+    "index.d.ts"
+  ]  
+}