| Region | +Domain | +
|---|---|
Mainland China |
+
|
+
North America |
+
|
+
Europe |
+
|
+
Japan |
+
|
+
India |
+
|
+
Asia excluding mainland China |
+
|
+
RtmClient instance. If an operation corresponds to multiple methods, the number of the method calls of an operation equals the sum of the method calls of all corresponding methods in a specific time frame.
-
-RtmClient instances.{channel.subscribe[props.ag_platform]} method, the client can subscribe to a message channel and start receiving messages and event notifications within the channel. After successfully calling this method, users who subscribe to the channel and enable the presence event listener can receive a {config.onpresenceevent[props.ag_platform]} event with the {enumv.remotejoinchannel[props.ag_platform]} type.
+
+{channel.subscribe[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.subscribe(
+ channelName: string,
+ options?: object
+): Promiseoptions object includes the following properties:
+
+| Property | Type | Required | Default | Description |
+| :------------: | :-----: | :------: | :-----: | :----------------------------------------------------------: |
+| `withMessage` | boolean | Optional | `true` | Whether to subscribe to message event notifications in the channel. |
+| `withPresence` | boolean | Optional | `true` | Whether to subscribe to presence event notifications in the channel. |
+| `withMetadata` | boolean | Optional | `false` | Whether to subscribe to storage event notifications in the channel. |
+| `withLock` | boolean | Optional | `false` | Whether to subscribe to lock event notifications in the channel. |
+
+#### Basic usage
+
+```javascript
+const options ={
+ withMessage : true,
+ withPresence : true,
+ withMetadata : false,
+ withLock : false
+};
+try {
+ const result = await rtm.subscribe("chat_room", options);
+ console.log(result);
+} catch (status) {
+ console.log(status);
+}
+```
+
+#### Return value
+
+If the method call succeeds, the {channel.subscriberesulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type SubscribeResponse = {
+ timeToken : number // Reserved property, indicating the timestamp of the successful operation.
+ channelName : string // Channel name.
+}
+```
+
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
+
+### {channel.unsubscribe[props.ag_platform]}
+
+#### Description
+
+To cancel your subscription, call the {channel.unsubscribe[props.ag_platform]} method. After successfully unsubscribing from the channel, other users who subscribe to the channel and enable event listeners can receive a {config.onpresenceevent[props.ag_platform]} event notification with the {enumv.remoteleavechannel[props.ag_platform]} type. For details, see Event Listener.
+
+{channel.unsubscribe[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.unsubscribe(
+ channelName: string
+): Promise{channel.unsubscriberesulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type UnsubscribeResponse = {
+ timeToken : number // Reserved property, indicating the timestamp of the successful operation.
+ channelName : string // Channel name.
+}
+```
+
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
+
+### {channel.create[props.ag_platform]}
+
+#### Description
+
+Before using a stream channel, you need to call the {channel.create[props.ag_platform]} method to create an {channel.istreamchannel[props.ag_platform]} instance. After successfully creating the instance, you can call its relevant methods to implement functions, such as joining the channel, leaving the channel, sending messages in a topic, and subscribing to messages in a topic.
+
+{channel.create[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.createStreamChannel(chanelName: string): RTMStreamChannel;
+```
+
+| Parameter | Type | Required | Default | Description |
+| :-----------: | :----: | :------: | :-----: | :----------------------: |
+| `channelName` | string | Yes | - | The channel name. |
+
+
+#### Basic usage
+
+```javascript
+try{
+ const Loc_stChannel = await rtm.createStreamChannel( "Location");
+ console.log("Create Stream Channel success!: ");
+} catch (status){
+ console.log(status);
+}
+```
+
+#### Return value
+
+An {channel.istreamchannel[props.ag_platform]} instance.
+
+
+
+### {channel.join[props.ag_platform]}
+
+#### Description
+
+After successfully creating a stream channel, you can call the {channel.join[props.ag_platform]} method to join the stream channel. Once you join the channel, you can implement channel-related functions. At this point, users who subscribe to the channel and add event listeners can receive the following event notifications:
+
+- Local users:
+ - {config.onpresenceevent[props.ag_platform]} event notification with the {enumv.presencetypesnap[props.ag_platform]} type.
+ - {config.ontopicevent[props.ag_platform]}event notification with the {enumv.topictypesnap[props.ag_platform]} type.
+- Remote users: {config.onpresenceevent[props.ag_platform]} event notification with the {enumv.remotejoinchannel[props.ag_platform]} type.
+
+{channel.join[props.ag_platform]} method in the following way:
+
+```javascript
+join(options?: {
+ token?: string;
+ withPresence?: boolean;
+ withMetadata?: boolean;
+ withLock?: boolean;
+}): Promiseoptions object includes the following properties:
+
+| Property | Type | Required | Default | Description |
+| :------------: | :-----: | :------: | :-----: | :----------------------------------------------------------: |
+| `token` | string | Optional | - | The token used for joining a stream channel, which is currently the same as the RTC token. |
+| `withMetadata` | boolean | Optional | `false` | Whether to subscribe to storage event notifications in the channel. |
+| `withPresence` | boolean | Optional | `true` | Whether to subscribe to presence event notifications in the channel. |
+| `withLock` | boolean | Optional | `false` | Whether to subscribe to lock event notifications in the channel. |
+
+#### Basic usage
+
+```js
+const options ={
+ token : "yourToken",
+ withPresence : true,
+ withMetadata : false,
+ withLock : false
+};
+try {
+ const result = await stChannel.join(options);
+ console.log(result);
+} catch (status) {
+ console.log(status);
+}
+```
+
+
+#### Return value
+
+If the method call succeeds, the {channel.joinresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type JoinChannelResponse = {
+ timeToken : number , // Reserved property, indicating the timestamp of the successful operation.
+ channelName : string // Channel name.
+}
+```
+
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
+
+
+
+### {channel.leave[props.ag_platform]}
+
+#### Description
+
+Call the {channel.leave[props.ag_platform]} method to leave the channel. After leaving the channel, you can no longer receive any messages, states, or event notifications from this channel. At the same time, you can no longer be the topic publisher or subscriber of all topics. To restore your previous publisher role and subscribing relationship, call {channel.join[props.ag_platform]}, {topic.join[props.ag_platform]} and {topic.subscribe[props.ag_platform]} methods in order.
+
+After successfully leaving the channel, remote users in the channel can receive a {config.onpresenceevent[props.ag_platform]} event notification with the {enumv.remoteleavechannel[props.ag_platform]} type. For details, see Event Listener.
+
+{channel.leave[props.ag_platform]} method in the following way:
+
+```javascript
+leave(): Promise{channel.leaveresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type LeaveChannelResponse = {
+ timeToken : number // Reserved property, indicating the timestamp of the successful operation.
+ channelName : string // Channel name.
+}
+```
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
\ No newline at end of file
diff --git a/shared/signaling/reference/api-ref/_configuration-en.javascript.mdx b/shared/signaling/reference/api-ref/_configuration-en.javascript.mdx
new file mode 100644
index 000000000..bf0532569
--- /dev/null
+++ b/shared/signaling/reference/api-ref/_configuration-en.javascript.mdx
@@ -0,0 +1,271 @@
+import * as config from './shared/_configuration.mdx'
+import * as enumv from './shared/_enumv.mdx'
+import Status from './shared/_rtmstatus.mdx'
+
+Before initializing a Signaling client instance, you need to import the Signaling Javascript SDK into your project:
+
+```js
+
+```
+
+### Initialization
+
+#### Description
+
+Initialization in Signaling refers to creating and initializing a Signaling client instance. When initializing the instance, you need to pass in parameters including `appId` and `userId`. You can create a project and get the App ID on the Agora console.
+
+userId is globally unique and remains constant throughout the lifecycle of the user or device. {config.rtm[props.ag_platform]} | Optional | - | The configuration parameters for initialization, see {config.rtm[props.ag_platform]}. |
+
+#### Basic usage
+
+```javascript
+const { RTM } = AgoraRTM;
+const rtm = new RTM(
+ appId : "myAppId",
+ userId : "Tony"
+);
+```
+
+
+#### Return Value
+
+A Signaling client instance. Now you can call other Signaling APIs.
+
+### {config.rtm[props.ag_platform]}
+
+#### Description
+
+{config.rtm[props.ag_platform]} is used to configure additional properties when you initialize a Signaling client instance. These configuration properties take effect throughout the lifecycle of the Signaling client and affect the behaviors of the Signaling client.
+
+#### Method
+
+You can create a {config.rtm[props.ag_platform]} instance in the following way:
+
+```js
+const { RTMConfig } = AgoraRTM;
+```
+
+| Property | Type | Required | Default | 描述 |
+| :---------------: | :--------: | :------: | :-----: | ---------------------------------------- |
+| `token` | string | Optional | - | A dynamic key, usually generated by a token server. |
+| `encryptionMode` | string | Optional | - | Encryption mode for end-to-end messages. To disable end-to-end encryption, set this property to {enumv.encryptionmodenone[props.ag_platform]}. For details, see [Encryption Modes](#end-to-end-encryption-modes). |
+| `cipherKey` | string | Optional | - | The key used for encryption and decryption. Set this property to enable message encryption. |
+| `salt` | Uint8Array | Optional | - | The salt required for encryption. The value must be a 32-byte binary array. |
+| `useStringUserId` | boolean | Optional | `true` | Whether to use string-type user IDs: true: Use string-type user IDs. false: Use number-type user IDs. When set the property as false, SDK automatically converts string-type user IDs to number-type ones. In this case, the `userId` parameter must be a numeric string (for example, "123456"), otherwise initialization fails. true: Enable log uploadfalse: Disable log upload. true: Enable. false: Disable. {config.onmessageevent[props.ag_platform]} | Receive message event notifications in subscribed message channels and subscribed topics. |
+| {config.onpresenceevent[props.ag_platform]} | Receive presence event notifications in subscribed message channels and joined stream channels. |
+| {config.ontopicevent[props.ag_platform]} | Receive all topic event notifications in joined stream channels. |
+| {config.onstorageevent[props.ag_platform]} | Receive channel metadata event notifications in subscribed message channels and joined stream channels, and the user metadata event notification of the subscribed users. |
+| {config.onlockevent[props.ag_platform]} | Receive lock event notifications in subscribed message channels and joined stream channels. |
+| {config.onconnection[props.ag_platform]} | Receive event notifications when client connection status changes. |
+| {config.ontokenwillexpire[props.ag_platform]} | Receive event notifications when the client tokens are about to expire. |
+
+#### Add event listeners
+
+You can add event listeners in the following way:
+
+```javascript
+// Add message event listeners
+// Message
+rtm.addEventListener("message", event => {
+ const channelType = event.channelType; // Which channel type it is, Should be "STREAM" or "MESSAGE" .
+ const channelName = event.channelName; // Which channel does this message come from
+ const topic = event.topicName; // Which Topic does this message come from, it is valid when the channelType is "STREAM".
+ const messageType = event.messageType; // Which message type it is, Should be "sting" or "binary" .
+ const customType = event.customType; // User defined type
+ const publisher = event.publisher; // Message publisher
+ const message = event.message; // Message payload
+ const pubTime = event.publishTime; // Message publisher timestamp
+});
+// Presence
+rtm.addEventListener("presence", event => {
+ const action = event.eventType; // Which action it is ,should be one of 'SNAPSHOT'、'INTERVAL'、'JOIN'、'LEAVE'、'TIMEOUT、'STATE_CHANGED'、'OUT_OF_SERVICE'.
+ const channelType = event.channelType; // Which channel type it is, Should be "STREAM" or "MESSAGE" .
+ const channelName = event.channelName; // Which channel does this event come from
+ const publisher = event.publisher; // Who trigger this event
+ const states = event.stateChanged; // User state payload
+ const interval = event.interval; // Interval payload
+ const snapshot = event.snapshot; // Snapshot payload
+});
+// Topic
+rtm.addEventListener("topic", event => {
+ const action = event.evenType; // Which action it is ,should be one of 'SNAPSHOT'、'JOIN'、'LEAVE'.
+ const channelName = event.channelName; // Which channel does this event come from
+ const publisher = event.userId; // Who trigger this event
+ const topicInfos = event.topicInfos; // Topic information payload
+ const totalTopics = event.totalTopics; // How many topics
+});
+// Storage
+rtm.addEventListener("storage", event => {
+ const channelType = event.channelType; // Which channel type it is, Should be "STREAM" or "MESSAGE" .
+ const channelName = event.channelName; // Which channel does this event come from
+ const publisher = event.publisher; // Who trigger this event
+ const storageType = event.storageType; // Which category the event is, should be 'USER'、'CHANNEL'
+ const action = event.eventType; // Which action it is ,should be one of "SNAPSHOT"、"SET"、"REMOVE"、"UPDATE" or "NONE"
+ const data = event.data; // 'USER_METADATA' or 'CHANNEL_METADATA' payload
+});
+// Lock
+rtm.addEventListener("lock", event => {
+ const channelType = event.channelType; // Which channel type it is, Should be "STREAM" or "MESSAGE" .
+ const channelName = event.channelName; // Which channel does this event come from
+ const publisher = event.publisher; // Who trigger this event
+ const action = event.evenType; // Which action it is ,should be one of 'SET'、'REMOVED'、'ACQUIRED'、'RELEASED'、'EXPIRED'、'SNAPSHOT'
+ const lockName = event.lockName; // Which lock it effect
+ const ttl = event.ttl; // The ttl of this lock
+ const snapshot = event.snapshot; // Snapshot payload
+});
+// Connection State Change
+rtm.addEventListener("status", event => {
+ const currentState = event.state; // Which connection state right now
+ const changeReason = event.reason; // Why trigger this event
+});
+// Token Privilege Will Expire
+rtm.addEventListener("tokenPrivilegeWillExpire", (channelName) => {
+ const channelName = channelName; // Which Channel Token Will Expire
+});
+```
+
+#### Remove event listeners
+
+You can call the {config. removedelegate[props.ag_platform]} method to remove a specified event listener.
+
+```javascript
+rtm.removeEventListener('status', statusHandler);
+```
+
+### {config.login[props.ag_platform]}
+
+#### Description
+
+After creating and initializing a Signaling client instance, you need to perform the {config.login[props.ag_platform]} operation to log in to the Signaling service. With successful login, the client establishes a long link to the Signaling server and allows the client to access Signaling resources.
+
+#### Method
+
+You can call the {config.login[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.login(): Promise{config.loginresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type LoginResponse = {
+ timeToken: number // Reserved property, indicating the timestamp of the successful operation
+}
+```
+
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
+
+
+### {config.logout[props.ag_platform]}
+
+#### Description
+
+Log out of the Signaling.
+
+#### Method
+
+You can call the {config.logout[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.logout(): Promise{config.logoutresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type LoginResponse = {
+ timeToken: number // Reserved property, indicating the timestamp of the successful operation
+}
+```
+
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
\ No newline at end of file
diff --git a/shared/signaling/reference/api-ref/_enumv-en.mdx b/shared/signaling/reference/api-ref/_enumv-en.mdx
new file mode 100644
index 000000000..9e7c6c624
--- /dev/null
+++ b/shared/signaling/reference/api-ref/_enumv-en.mdx
@@ -0,0 +1,101 @@
+import * as config from './shared/_configuration.mdx'
+import * as enumv from './shared/_enumv.mdx'
+
+### Channel Types
+
+| Value | Description |
+| :----------: | ---------------------------------------------------------- |
+| {enumv.channeltypemessage[props.ag_platform]} | Message channel. |
+| {enumv.channeltypestream[props.ag_platform]} | Stream channel. |
+
+
+### Reasons for the SDK Connection State Change
+
+| Value | Description |
+| :----------: | ---------------------------------------------------------- |
+| {enumv.reasonconnecting[props.ag_platform]} | The SDK is connecting with the Signaling system. |
+| {enumv.reasonloginsuccess[props.ag_platform]} | The SDK logged in the Signaling system successfully. |
+| {enumv.reasonrejected[props.ag_platform]} | The SDK is rejected by the server. |
+| {enumv.reasonlost[props.ag_platform]} | The SDK lost the connection with the Signaling system. |
+| {enumv.reasoninterrupt[props.ag_platform]} | The connection was interrupted. |
+| {enumv.reasonlogout[props.ag_platform]} | The SDK logged out of the Signaling system. |
+| {enumv.reasonban[props.ag_platform]} | The SDK is banned by the server. |
+| {enumv.reasonsameuid[props.ag_platform]} | The same user ID was used to join the same channel on different devices. |
+| {enumv.reasontokenexpired[props.ag_platform]} | The used token expired. You need to request a new token from your server. |
+
+
+### SDK Connection States
+
+| Value | Description |
+| :----------: | ---------------------------------------------------------- |
+| {enumv.sdkdisconnect[props.ag_platform]} | The SDK has disconnected with the server. |
+| {enumv.sdkconnecting[props.ag_platform]} | The SDK disconnected with the server. |
+| {enumv.sdkconnected[props.ag_platform]} | The SDK has connected with the server. |
+| {enumv.sdkreconnect[props.ag_platform]} | The connection is lost. The SDK is reconnecting with the server. |
+| {enumv.sdkfailed[props.ag_platform]} | The SDK failed to connect with the server. |
+
+
+### End-to-End Encryption Modes
+
+| Value | Description |
+| :----------: | ---------------------------------------------------------- |
+| {enumv.encryptionmodenone[props.ag_platform]} | No encryption. |
+| {enumv.aesonetwoeight[props.ag_platform]} | AES-128-GCM mode. |
+| {enumv.aestwofivesix[props.ag_platform]} | AES-256-GCM mode. |
+
+
+### Lock Event Types
+
+| Value | Description |
+| :----------: | ---------------------------------------------------------- |
+| {enumv.locktypesnap[props.ag_platform]} | The snapshot of the lock when the user joined the channel. |
+| {enumv.locktypeset[props.ag_platform]} | The lock is set. |
+| {enumv.locktyperemoved[props.ag_platform]} | he lock is removed. |
+| {enumv.locktypeacquired[props.ag_platform]} | The lock is acquired. |
+| {enumv.locktypereleased[props.ag_platform]} | The lock is released. |
+| {enumv.locktypeexpired[props.ag_platform]} | The lock expired. |
+
+
+### Log Output Levels
+
+| Value | Description |
+| :----------: | ---------------------------------------------------------- |
+| {enumv.loglevelnone[props.ag_platform]} | No log. |
+| {enumv.loglevelinfo[props.ag_platform]} | Output the log at the `error`, `warn`, or `info` level. Agora recommends you set to this value. |
+| {enumv.loglevelwarn[props.ag_platform]} | Output the log at the `error` or `warn` level. |
+| {enumv.loglevelerror[props.ag_platform]} | Output the log at the `error` level. |
+| {enumv.logleveldebug[props.ag_platform]} | Output the log at all levels. |
+
+### Message Types
+
+| Value | Description |
+| :----------: | ---------------------------------------------------------- |
+| {enumv.binarymessage[props.ag_platform]} | Binary type. |
+| {enumv.stringmessage[props.ag_platform]} | String type. |
+
+### Presence Event Types
+
+| Value | Description |
+| :----------: | ---------------------------------------------------------- |
+| {enumv.presencetypesnap[props.ag_platform]} | When users joined a channel for the first time, they received a snapshot of the channel pushed by the server. |
+| {enumv.presencetypeint[props.ag_platform]} | When users in the channel reach the limit, the event notifications are sent at intervals rather than in real time. |
+| {enumv.presencetypejoin[props.ag_platform]} | A remote user joined the channel. |
+| {enumv.presencetypeleave[props.ag_platform]} | A remote user left the channel. |
+| {enumv.presencetypetimeout[props.ag_platform]} | A remote user's connection timed out. |
+| {enumv.presencetypechange[props.ag_platform]} | A remote user's temporary state changed. |
+| {enumv.presencetypeout[props.ag_platform]} | The user did not enable presence when joining the channel. |
+
+### Storage Event Types
+
+| Value | Description |
+| :----------: | ---------------------------------------------------------- |
+| {enumv.storagetypeuser[props.ag_platform]} | User metadata event. |
+| {enumv.storagetypechannel[props.ag_platform]} | Channel metadata event. |
+
+### Topic Event Types
+
+| Value | Description |
+| :----------: | ---------------------------------------------------------- |
+| {enumv.topictypesnap[props.ag_platform]} | The snapshot of the topic when the user joined the channel. |
+| {enumv.topictypejoin[props.ag_platform]} | A remote user joined the channel. |
+| {enumv.topictypeleave[props.ag_platform]} | A remote user left the channel. |
\ No newline at end of file
diff --git a/shared/signaling/reference/api-ref/_lock-en.javascript.mdx b/shared/signaling/reference/api-ref/_lock-en.javascript.mdx
new file mode 100644
index 000000000..66a6e0021
--- /dev/null
+++ b/shared/signaling/reference/api-ref/_lock-en.javascript.mdx
@@ -0,0 +1,357 @@
+import * as lock from './shared/_lock.mdx'
+import * as config from './shared/_configuration.mdx'
+import * as enumv from './shared/_enumv.mdx'
+import Status from './shared/_rtmstatus.mdx'
+
+
+A critical resource can only be used by one process at a time. If a critical resource is shared between different processes, each process needs to adopt a mutually exclusive method to prevent mutual interference. Signaling provides a full set of lock solutions. By controlling different processes in a distributed system, you can solve the competition problem when users access shared resources.
+
+{lock.set[props.ag_platform]} method. If the configuration succeeds, all users in the channel receives the {config.onlockevent[props.ag_platform]} event notifications of the {enumv.locktypeset[props.ag_platform]} type. For details, see [Event Listeners](#event-listeners).
+
+#### Method
+
+You can call the {lock.set[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.lock.setLock(
+ channelName: string,
+ channelType: string,
+ lockName: string,
+ options?: {
+ ttl?: number;
+ }
+): Promise{config.onlockevent[props.ag_platform]} event receives the {enumv.locktypereleased[props.ag_platform]} event. |
+
+#### Basic Usage
+
+```javascript
+try{
+ const result = await rtm.Lock.setLock(
+ channel:"my_channel",
+ channelType:"STREAM",
+ lockName: "my_lock",
+ { ttl: 30 }
+ );
+ console.log(result);
+} catch (status) {
+ console.log(status);
+}
+```
+
+#### Return Value
+
+If the method call succeeds, the {lock.setlockresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type SetLockResponse = {
+ timeToken: number , // Reserved property, indicating the timestamp of the successful operation.
+ channelName : string , // Channel name.
+ channelType : string , // Channel type.
+ lockName : string // Lock name.
+}
+```
+
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
+
+
+### {lock.acquire[props.ag_platform]}
+
+#### Description
+
+After setting a lock, you can call the {lock.acquire[props.ag_platform]} method on the client to acquire the right to own the lock. When you acquire the lock, other users in the channel receives the {config.onlockevent[props.ag_platform]} event of the {enumv.locktypeacquired[props.ag_platform]} type. For details, see Event Listener.
+
+#### Method
+
+You can call the {lock.acquire[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.lock.acquireLock(
+ channelName: string,
+ channelType: string,
+ lockName: string,
+ options?: { retry?: boolean }
+): Promise{lock.acquirelockresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type AcquireLockResponse = {
+ timeToken: number , // Reserved property, indicating the timestamp of the successful operation.
+ channelName : string , // Channel name.
+ channelType : string , // Channel type.
+ lockName : string // Lock name.
+}
+```
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
+
+
+### {lock.release[props.ag_platform]}
+
+#### Description
+
+When a user no longer needs to own a lock, the user can call the {lock.release[props.ag_platform]} method on the client side to release the lock. When the lock is released, other users in the channel receives the {config.onlockevent[props.ag_platform]} event of {enumv.locktypereleased[props.ag_platform]} type. For details, see Event Listeners.
+
+At this time, if other users want to acquire the lock, they can call the {lock.acquire[props.ag_platform]} method on the client side to compete. New users acquiring locks have the same contention priority as the users who set the `retry` property to automatically retry to acquire locks.
+
+#### Method
+
+You can call the {lock.acquire[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.lock.releaseLock(
+ channelName: string,
+ channelType: string,
+ lockName: string
+): Promise{lock.releaselockresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type ReleaseLockResponse = {
+ timeToken: number , // Reserved property, indicating the timestamp of the successful operation.
+ channelName : string , // Channel name.
+ channelType : string , // Channel type.
+ lockName : string // Lock name.
+}
+```
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
+
+
+### {lock.revoke[props.ag_platform]}
+
+#### Description
+
+You may need to take back a lock owned by another user and allow the other users to acquire the lock. You can call the {lock.revoke[props.ag_platform]} method to revoke the lock. When the lock is revoked, all users in the channel receives the {config.onlockevent[props.ag_platform]} event of the {enumv.locktypereleased[props.ag_platform]} type. For details, see Event Listeners.
+
+At this time, if other users want to acquire the lock, they can call the {lock.acquire[props.ag_platform]} method on the client side to compete. New users acquiring locks have the same contention priority as the users who set the `retry` property to automatically retry to acquire locks.
+
+#### Method
+
+You can call the {lock.revoke[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.lock.revokeLock(
+ channelName: string,
+ channelType: string,
+ lockName: string,
+ owner: string
+): Promise{lock.revokelockresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type RevokeLockResponse = {
+ timeToken: number , // Reserved property, indicating the timestamp of the successful operation.
+ channelName : string , // Channel name.
+ channelType : string , // Channel type.
+ lockName : string // Lock name.
+}
+```
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
+
+
+### {lock.get[props.ag_platform]}
+
+#### Description
+
+To query the lock information such as total number of locks, lock name, and lock user, time to live, call the {lock.get[props.ag_platform]} method on the client.
+
+#### Method
+
+You can call the {lock.get[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.lock.getLock(
+ channelName: string,
+ channelType: string
+): Promise{lock.getlockresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type GetLockResponse = {
+ timeToken: number , // Reserved property, indicating the timestamp of the successful operation.
+ channelName : string , // Channel name.
+ channelType : string , // Channel type.
+ totalLocks : string, // Total lock number.
+ lockDetails : [{
+ lockName: string, // Lock name.
+ owner: string, // Lock owner.
+ ttl: number // Time to live in seconds of the lock.
+ }]
+}
+```
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
+
+
+### {lock.remove[props.ag_platform]}
+
+#### Description
+
+Remove the lock by calling the {lock.remove[props.ag_platform]} method. When the lock is successfully removed, all the users in the channel receives the {config.onlockevent[props.ag_platform]} event notification in the {enumv.locktyperemoved[props.ag_platform]} type. For details, see Event Handlers.
+
+#### Method
+
+You can call the {lock.remove[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.lock.removeLock(
+ channelName: string,
+ channelType: string,
+ lockName: string
+): Promise{lock.removelockresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type RemoveLockResponse = {
+ timeToken: number , // Reserved property, indicating the timestamp of the successful operation.
+ channelName : string , // Channel name.
+ channelType : string , // Channel type.
+ lockName : string, // Lock name.
+}
+```
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
\ No newline at end of file
diff --git a/shared/signaling/reference/api-ref/_message-en.javascript.mdx b/shared/signaling/reference/api-ref/_message-en.javascript.mdx
new file mode 100644
index 000000000..6a6864bdb
--- /dev/null
+++ b/shared/signaling/reference/api-ref/_message-en.javascript.mdx
@@ -0,0 +1,104 @@
+import * as enumv from './shared/_enumv.mdx'
+import * as config from './shared/_configuration.mdx'
+import * as channel from './shared/_channel.mdx'
+import * as message from './shared/_message.mdx'
+import * as topic from './shared/_topic.mdx'
+import Status from './shared/_rtmstatus.mdx'
+import PublishOptions from './shared/_publishoptions.mdx';
+
+Sending and receiving messages is the most basic function of the Signaling service. Any message sent by the Signaling server can be delivered to any online subscribing user within 100 ms. Depending on your business requirements, you can send messages to one user only or broadcast messages to multiple users.
+
+Signaling offers two types of channels: message channels and stream channels. These channel types have the following differences in how messages are transmitted and methods are called:
+
+- Message Channel: The real-time channel. Messages are transmitted through the channel, and the channel is highly scalable. Local users can call the {message.publish[props.ag_platform]} method to send messages in the channel, and remote users can call the {channel.subscribe[props.ag_platform]} method to subscribe to the channel and receive messages.
+- Stream Channel: The streaming transmission channel. Messages are transmitted through the topic. Users need to join a channel first, and then join a topic. Local users can call the {topic.publish[props.ag_platform]} method to send messages in the topic, and remote users can call the {topic.subscribe[props.ag_platform]} method to subscribe to the topic and receive messages.
+
+This page introduces how to send and receive messages in a Message Channel.
+
+### {message.publish[props.ag_platform]}
+
+#### Description
+
+You can directly call the {message.publish[props.ag_platform]} method to send messages to all online users who subscribe to the channel. Even if you do not subscribe to a channel, you can still send messages in the channel.
+
+{config.onmessageevent[props.ag_platform]} event notification. Users who subscribe to the channel and enabled the event listener can receive this event notification. For details, see Event Listener.
+
+#### Method
+
+You can call the {message.publish[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.publish(
+ channelName: string,
+ message: string | Uint8Array,
+ options?: {customType?: string;}
+): Promise{config.onmessageevent[props.ag_platform]} event notification. Users who subscribe to the channel and enable event listener can receive this event notification. For details, see Event Listener.{message.publishresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type PublishResponse = {
+ timeToken: number , // Reserved property, indicating the timestamp of the successful operation.
+ chanelName : string // Channel name.
+}
+```
+
+If the method call fails, an [`ErrorInfo`](#errorinfo) response is returned.
+
+### Receive
+
+Signaling provides event notifications for messages, states, and event changes. By setting event listeners, you can receive messages and events in subscribed channels.
+
+For information on how to add and set event listeners, see Event Listener.
\ No newline at end of file
diff --git a/shared/signaling/reference/api-ref/_presence-en.javascript.mdx b/shared/signaling/reference/api-ref/_presence-en.javascript.mdx
new file mode 100644
index 000000000..2b4faf0bc
--- /dev/null
+++ b/shared/signaling/reference/api-ref/_presence-en.javascript.mdx
@@ -0,0 +1,272 @@
+import * as presence from './shared/_presence.mdx'
+import * as storage from './shared/_storage.mdx'
+import * as config from './shared/_configuration.mdx'
+import * as enumv from './shared/_enumv.mdx'
+import Status from './shared/_rtmstatus.mdx'
+import Stateitem from './shared/_stateitem.mdx'
+
+
+The presence feature provides the ability to monitor user online, offline, and user historical state change. With the Presence feature, you can get real-time access to the following information:
+
+- Real-time event notification when a user joins or leaves a specified channel.
+- Real-time event notification when the custom temporary user state changes.
+- Query which channels a specified user has joined or subscribed to.
+- Query which users have joined a specified channel and their temporary user state data.
+
+
+
+{presence.whonow[props.ag_platform]} method to query user information in real time such as the number of online users, the list of online users and their temporary user status in the specified channel.
+
+#### Method
+
+You can call the {presence.whonow[props.ag_platform]} method in the following way:
+
+```javascript
+rtm.presence.getOnlineUsers(
+ channelName: string,
+ channelType: string,
+ options?: object
+): Promiseoptions contains the following properties:
+
+| Property | Type | Required | Default | Description |
+| :--------------: | :-----: | :------: | :-----: | ------------------------------------------------------------------------------------- |
+| `includedUserId` | boolean | Optional | `true` | Whether the returned result contains the user ID of online users. |
+| `includedState` | boolean | Optional | `false` | Whether the returned result contains the temporary user state of online users. |
+| `page` | string | Optional | - | Page number of the returned result. If you do not provide this property, the SDK returns the first page by default. You can check whether there is next page in the `nextPage` property of the returned result. |
+
+#### Basic Usage
+
+```javascript
+const options = {
+ includeUserId : true ,
+ includeState : true,
+ page : "yourBookMark"
+}
+try{
+ const result = await rtm.presence.getOnlineUsers( "chat_room", 'MESSAGE', options );
+ console.log(result);
+} catch(status){
+ console.log(status);
+}
+```
+
+#### Return Value
+
+If the method call succeeds, the {presence.whonowresulttype[props.ag_platform]} response as follows is returned:
+
+```js
+type getOnlineUsersResponse = {
+ timeToken: number , // Reserved property, indicating the timestamp of the successful operation.
+ totalOccupancy : number , // Number of the online users in the channel.
+ occupants : ArraycreateAgoraService method, which creates an IAgoraService instance, and the initialize method, which initializes the created IAgoraService instance. As of this relase, you only need to call the createRtmService method and the initialize method to initialize it before being able to call its functions.
-
-
-**Issues Fixed**
-
-Occasionally fails to receive any callback after a channel attribute operation.
-
-## v1.2.1
-
-v1.2.1 was released on November 29, 2019.
-
-**New Feature**
-
-*Compatible with the endCall method of the Agora Signaling SDK*
-
-If you use the `sendMessageToPeer` method to send a text message in the format of AgoraRTMLegacyEndcallCompatibleMessagePrefix_\onTokenPrivilegeWillExpire and onTokenExpired callbacks to handle token expiration conditions, Agora recommends that you regularly renew the token (such as every hour) to keep the token valid.
-
- The names of methods, callbacks, and enums mentioned in the above section only apply to C++. Refer to the API documentation for names in other platforms.
-
-- **AccessToken**
-
- a | Region | -Domain | -
|---|---|
Mainland China |
-
|
-
North America |
-
|
-
Europe |
-
|
-
Japan |
-
|
-
India |
-
|
-
Asia excluding mainland China |
-
|
-