@sendbird/sendbird-platform-sdk-typescript 2.1.1 → 2.1.5

package/tests/integration/user.test.ts

@@ -110,6 +110,155 @@ describe("User API", () => {
     expect(typeof response.timezone).toBe("string");
   });
 
+  it("call updatePushPreferences with dndSchedules and verify response", async () => {
+    // 1) 사전 초기화
+    await userApi.updatePushPreferences({
+      apiToken: API_TOKEN,
+      userId: MASTER_USER_ID,
+      updatePushPreferencesRequest: { dndSchedules: [] },
+    });
+
+    // 2) dndSchedules 설정 (자정을 넘기는 윈도우 포함)
+    // 서버는 자정 넘는 윈도우를 자동 분할:
+    //   monday 22:00~07:00 → monday 22:00~23:59 + tuesday 00:00~07:00
+    //   friday 23:30~06:00 → friday 23:30~23:59 + saturday 00:00~06:00
+    const response = await userApi.updatePushPreferences({
+      apiToken: API_TOKEN,
+      userId: MASTER_USER_ID,
+      updatePushPreferencesRequest: {
+        dndSchedules: [
+          {
+            dayOfWeek: "monday",
+            timeWindows: [
+              { startHour: 22, startMin: 0, endHour: 7, endMin: 0 },
+            ],
+          },
+          {
+            dayOfWeek: "friday",
+            timeWindows: [
+              { startHour: 23, startMin: 30, endHour: 6, endMin: 0 },
+              { startHour: 12, startMin: 0, endHour: 13, endMin: 0 },
+            ],
+          },
+        ],
+      },
+    });
+
+    // 3) 응답 검증 - 서버가 자정 넘는 윈도우를 분할하므로 4개 스케줄 반환
+    expect(response).toHaveProperty("dndSchedules");
+    expect(Array.isArray(response.dndSchedules)).toBe(true);
+    expect(response.dndSchedules!.length).toBe(4);
+
+    // monday: 22:00~23:59 (분할된 앞부분)
+    const monday = response.dndSchedules!.find((s) => s.dayOfWeek === "monday");
+    expect(monday).toBeDefined();
+    expect(monday!.timeWindows![0].startHour).toBe(22);
+    expect(monday!.timeWindows![0].endHour).toBe(23);
+    expect(monday!.timeWindows![0].endMin).toBe(59);
+
+    // tuesday: 00:00~07:00 (분할된 뒷부분)
+    const tuesday = response.dndSchedules!.find((s) => s.dayOfWeek === "tuesday");
+    expect(tuesday).toBeDefined();
+    expect(tuesday!.timeWindows![0].startHour).toBe(0);
+    expect(tuesday!.timeWindows![0].endHour).toBe(7);
+
+    // friday: 23:30~23:59 (분할), 12:00~13:00 (그대로)
+    const friday = response.dndSchedules!.find((s) => s.dayOfWeek === "friday");
+    expect(friday).toBeDefined();
+    expect(friday!.timeWindows!.length).toBe(2);
+
+    // saturday: 00:00~06:00 (friday 23:30~06:00의 분할된 뒷부분)
+    const saturday = response.dndSchedules!.find((s) => s.dayOfWeek === "saturday");
+    expect(saturday).toBeDefined();
+    expect(saturday!.timeWindows![0].startHour).toBe(0);
+    expect(saturday!.timeWindows![0].endHour).toBe(6);
+
+    // 4) GET으로 재확인
+    const view = await userApi.viewPushPreferences({
+      apiToken: API_TOKEN,
+      userId: MASTER_USER_ID,
+    });
+    expect(view).toHaveProperty("dndSchedules");
+    expect(Array.isArray(view.dndSchedules)).toBe(true);
+    expect(view.dndSchedules!.length).toBe(4);
+
+    // 5) 원상 복원
+    await userApi.updatePushPreferences({
+      apiToken: API_TOKEN,
+      userId: MASTER_USER_ID,
+      updatePushPreferencesRequest: {
+        dndSchedules: [],
+      },
+    });
+  });
+
+  it("call updatePushPreferences with single day dndSchedule", async () => {
+    // 단일 요일 설정
+    const response = await userApi.updatePushPreferences({
+      apiToken: API_TOKEN,
+      userId: MASTER_USER_ID,
+      updatePushPreferencesRequest: {
+        dndSchedules: [
+          {
+            dayOfWeek: "wednesday",
+            timeWindows: [
+              { startHour: 0, startMin: 0, endHour: 6, endMin: 30 },
+            ],
+          },
+        ],
+      },
+    });
+
+    expect(response).toHaveProperty("dndSchedules");
+    expect(response.dndSchedules!.length).toBe(1);
+    expect(response.dndSchedules![0].dayOfWeek).toBe("wednesday");
+    expect(response.dndSchedules![0].timeWindows!.length).toBe(1);
+    expect(response.dndSchedules![0].timeWindows![0].startHour).toBe(0);
+    expect(response.dndSchedules![0].timeWindows![0].startMin).toBe(0);
+    expect(response.dndSchedules![0].timeWindows![0].endHour).toBe(6);
+    expect(response.dndSchedules![0].timeWindows![0].endMin).toBe(30);
+
+    // 정리
+    await userApi.updatePushPreferences({
+      apiToken: API_TOKEN,
+      userId: MASTER_USER_ID,
+      updatePushPreferencesRequest: {
+        dndSchedules: [],
+      },
+    });
+  });
+
+  it("call updatePushPreferences with empty dndSchedules to clear", async () => {
+    // 먼저 스케줄 설정
+    await userApi.updatePushPreferences({
+      apiToken: API_TOKEN,
+      userId: MASTER_USER_ID,
+      updatePushPreferencesRequest: {
+        dndSchedules: [
+          {
+            dayOfWeek: "sunday",
+            timeWindows: [
+              { startHour: 22, startMin: 0, endHour: 8, endMin: 0 },
+            ],
+          },
+        ],
+      },
+    });
+
+    // 빈 배열로 초기화
+    const response = await userApi.updatePushPreferences({
+      apiToken: API_TOKEN,
+      userId: MASTER_USER_ID,
+      updatePushPreferencesRequest: {
+        dndSchedules: [],
+      },
+    });
+
+    expect(response).toHaveProperty("dndSchedules");
+    expect(Array.isArray(response.dndSchedules)).toBe(true);
+    expect(response.dndSchedules!.length).toBe(0);
+  });
+
   it("call removeARegistrationOrDeviceTokenWhenUnregisteringASpecificToken after addARegistrationOrDeviceToken", async () => {
     const TOKEN_TYPE = "GCM";
     const TEST_GCM_TOKEN = "dummy-token-123";
@@ -570,4 +719,239 @@ describe("User API", () => {
 
     expect(deleteAUserResponse).toBeDefined();
   });
+
+  it("call createUserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    const createMetadataResponse = await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+        },
+      },
+    });
+
+    expect(createMetadataResponse).toBeDefined();
+    expect(typeof createMetadataResponse).toBe("object");
+    expect(createMetadataResponse).toHaveProperty(TEST_METADATA_KEY);
+    expect(createMetadataResponse[TEST_METADATA_KEY]).toBe(
+      TEST_METADATA_VALUE
+    );
+  });
+  it("call deleteUserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+        },
+      },
+    });
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      fail(`error deleting metadata: ${e}`);
+    }
+  });
+  it("call updateUserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+        },
+      },
+    });
+
+    const UPDATED_METADATA_VALUE = "updated_test_value";
+
+    const updateMetadataResponse = await userApi.updateUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      updateUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: UPDATED_METADATA_VALUE,
+        },
+      },
+    });
+
+    expect(updateMetadataResponse).toBeDefined();
+    expect(typeof updateMetadataResponse).toBe("object");
+    expect(updateMetadataResponse).toHaveProperty(TEST_METADATA_KEY);
+    expect(updateMetadataResponse[TEST_METADATA_KEY]).toBe(
+      UPDATED_METADATA_VALUE
+    );
+  });
+  it("call Get Specific UserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+    const TEST_METADATA_KEY_1 = "create_metadata_key_1";
+    const TEST_METADATA_VALUE_1 = "test_value_1";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+          [TEST_METADATA_KEY_1]: TEST_METADATA_VALUE_1,
+        },
+      },
+    });
+
+    const getSpecificMetadataResponse = await userApi.viewSpecificUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      key: TEST_METADATA_KEY_1,
+    });
+
+    expect(getSpecificMetadataResponse).toBeDefined();
+    expect(typeof getSpecificMetadataResponse).toBe("object");
+    expect(getSpecificMetadataResponse).toHaveProperty(TEST_METADATA_KEY_1);
+    expect(getSpecificMetadataResponse[TEST_METADATA_KEY_1]).toBe(
+      TEST_METADATA_VALUE_1
+    );
+  });
+  it("call Update Specific UserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+    const TEST_METADATA_KEY_1 = "create_metadata_key_1";
+    const TEST_METADATA_VALUE_1 = "test_value_1";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+          [TEST_METADATA_KEY_1]: TEST_METADATA_VALUE_1,
+        },
+      },
+    });
+
+    const UPDATED_METADATA_VALUE_1 = "updated_test_value_1";
+    const updateSpecificMetadataResponse = await userApi.updateSpecificUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      key: TEST_METADATA_KEY_1,
+      updateSpecificUserMetadataRequest: {
+        value: UPDATED_METADATA_VALUE_1,
+      },
+    });
+
+    expect(updateSpecificMetadataResponse).toBeDefined();
+    expect(typeof updateSpecificMetadataResponse).toBe("object");
+    expect(updateSpecificMetadataResponse).toHaveProperty(TEST_METADATA_KEY_1);
+    expect(updateSpecificMetadataResponse[TEST_METADATA_KEY_1]).toBe(
+      UPDATED_METADATA_VALUE_1
+    );
+  });
+  it("call Delete Specific UserMetadata", async () => {
+    const TEST_METADATA_KEY = "create_metadata_key";
+    const TEST_METADATA_VALUE = "test_value";
+    const TEST_METADATA_KEY_1 = "create_metadata_key_1";
+    const TEST_METADATA_VALUE_1 = "test_value_1";
+
+    try {
+      await userApi.deleteUserAllMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignoring error deleting metadata:", e);
+    }
+
+    await userApi.createUserMetadata({
+      userId: MASTER_USER_ID,
+      apiToken: API_TOKEN,
+      createUserMetadataRequest: {
+        metadata: {
+          [TEST_METADATA_KEY]: TEST_METADATA_VALUE,
+          [TEST_METADATA_KEY_1]: TEST_METADATA_VALUE_1,
+        },
+      },
+    });
+
+    try {
+      await userApi.deleteSpecificUserMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+        key: TEST_METADATA_KEY_1,
+      });
+    } catch (e) {
+      fail(`error deleting specific metadata: ${e}`);
+    }
+
+    try {
+      await userApi.viewSpecificUserMetadata({
+        userId: MASTER_USER_ID,
+        apiToken: API_TOKEN,
+        key: TEST_METADATA_KEY_1,
+      });
+    } catch (e) {
+      const errorBody = JSON.parse((e as any).body);
+      expect(errorBody).toBeDefined();
+      expect(errorBody['code']).toBe(400201);
+    }
+  });
 });

package/types/ObjectParamAPI.ts

@@ -20,6 +20,7 @@ import { CreateAChannelMetadataResponse } from '../models/CreateAChannelMetadata
 import { CreateAGroupChannelRequest } from '../models/CreateAGroupChannelRequest';
 import { CreateAUserRequest } from '../models/CreateAUserRequest';
 import { CreateAnOpenChannelRequest } from '../models/CreateAnOpenChannelRequest';
+import { CreateUserMetadataRequest } from '../models/CreateUserMetadataRequest';
 import { CreateUserTokenRequest } from '../models/CreateUserTokenRequest';
 import { CreateUserTokenResponse } from '../models/CreateUserTokenResponse';
 import { FreezeAGroupChannelRequest } from '../models/FreezeAGroupChannelRequest';
@@ -117,7 +118,11 @@ import { UpdateExtraDataInAMessageResponse } from '../models/UpdateExtraDataInAM
 import { UpdatePushPreferencesForAChannelRequest } from '../models/UpdatePushPreferencesForAChannelRequest';
 import { UpdatePushPreferencesForAChannelResponse } from '../models/UpdatePushPreferencesForAChannelResponse';
 import { UpdatePushPreferencesRequest } from '../models/UpdatePushPreferencesRequest';
+import { UpdatePushPreferencesRequestDndSchedulesInner } from '../models/UpdatePushPreferencesRequestDndSchedulesInner';
+import { UpdatePushPreferencesRequestDndSchedulesInnerTimeWindowsInner } from '../models/UpdatePushPreferencesRequestDndSchedulesInnerTimeWindowsInner';
 import { UpdatePushPreferencesResponse } from '../models/UpdatePushPreferencesResponse';
+import { UpdateSpecificUserMetadataRequest } from '../models/UpdateSpecificUserMetadataRequest';
+import { UpdateUserMetadataRequest } from '../models/UpdateUserMetadataRequest';
 import { ViewBotByIdResponse } from '../models/ViewBotByIdResponse';
 import { ViewBotByIdResponseBot } from '../models/ViewBotByIdResponseBot';
 import { ViewCountPreferenceOfAChannelResponse } from '../models/ViewCountPreferenceOfAChannelResponse';
@@ -2756,6 +2761,27 @@ export interface UserApiCreateAUserRequest {
     createAUserRequest?: CreateAUserRequest
 }
 
+export interface UserApiCreateUserMetadataRequest {
+    /**
+     * (Required) 
+     * @type string
+     * @memberof UserApicreateUserMetadata
+     */
+    userId: string
+    /**
+     * 
+     * @type string
+     * @memberof UserApicreateUserMetadata
+     */
+    apiToken?: string
+    /**
+     * 
+     * @type CreateUserMetadataRequest
+     * @memberof UserApicreateUserMetadata
+     */
+    createUserMetadataRequest?: CreateUserMetadataRequest
+}
+
 export interface UserApiCreateUserTokenRequest {
     /**
      * (Required) 
@@ -2792,6 +2818,42 @@ export interface UserApiDeleteAUserRequest {
     apiToken?: string
 }
 
+export interface UserApiDeleteSpecificUserMetadataRequest {
+    /**
+     * (Required) 
+     * @type string
+     * @memberof UserApideleteSpecificUserMetadata
+     */
+    userId: string
+    /**
+     * 
+     * @type string
+     * @memberof UserApideleteSpecificUserMetadata
+     */
+    key: string
+    /**
+     * 
+     * @type string
+     * @memberof UserApideleteSpecificUserMetadata
+     */
+    apiToken?: string
+}
+
+export interface UserApiDeleteUserAllMetadataRequest {
+    /**
+     * (Required) 
+     * @type string
+     * @memberof UserApideleteUserAllMetadata
+     */
+    userId: string
+    /**
+     * 
+     * @type string
+     * @memberof UserApideleteUserAllMetadata
+     */
+    apiToken?: string
+}
+
 export interface UserApiGetChannelInvitationPreferenceRequest {
     /**
      * (Required) 
@@ -3395,6 +3457,54 @@ export interface UserApiUpdatePushPreferencesForAChannelRequest {
     updatePushPreferencesForAChannelRequest?: UpdatePushPreferencesForAChannelRequest
 }
 
+export interface UserApiUpdateSpecificUserMetadataRequest {
+    /**
+     * (Required) 
+     * @type string
+     * @memberof UserApiupdateSpecificUserMetadata
+     */
+    userId: string
+    /**
+     * 
+     * @type string
+     * @memberof UserApiupdateSpecificUserMetadata
+     */
+    key: string
+    /**
+     * 
+     * @type string
+     * @memberof UserApiupdateSpecificUserMetadata
+     */
+    apiToken?: string
+    /**
+     * 
+     * @type UpdateSpecificUserMetadataRequest
+     * @memberof UserApiupdateSpecificUserMetadata
+     */
+    updateSpecificUserMetadataRequest?: UpdateSpecificUserMetadataRequest
+}
+
+export interface UserApiUpdateUserMetadataRequest {
+    /**
+     * (Required) 
+     * @type string
+     * @memberof UserApiupdateUserMetadata
+     */
+    userId: string
+    /**
+     * 
+     * @type string
+     * @memberof UserApiupdateUserMetadata
+     */
+    apiToken?: string
+    /**
+     * 
+     * @type UpdateUserMetadataRequest
+     * @memberof UserApiupdateUserMetadata
+     */
+    updateUserMetadataRequest?: UpdateUserMetadataRequest
+}
+
 export interface UserApiViewAUserRequest {
     /**
      * (Required) 
@@ -3539,6 +3649,27 @@ export interface UserApiViewPushPreferencesForAChannelRequest {
     apiToken?: string
 }
 
+export interface UserApiViewSpecificUserMetadataRequest {
+    /**
+     * (Required) 
+     * @type string
+     * @memberof UserApiviewSpecificUserMetadata
+     */
+    userId: string
+    /**
+     * 
+     * @type string
+     * @memberof UserApiviewSpecificUserMetadata
+     */
+    key: string
+    /**
+     * 
+     * @type string
+     * @memberof UserApiviewSpecificUserMetadata
+     */
+    apiToken?: string
+}
+
 export interface UserApiViewWhoOwnsARegistrationOrDeviceTokenRequest {
     /**
      * (Required) 
@@ -3594,6 +3725,15 @@ export class ObjectUserApi {
         return this.api.createAUser(param.apiToken, param.createAUserRequest,  options).toPromise();
     }
 
+    /**
+     * ## Create metadata When creating new items of the user metadata. https://sendbird.com/docs/chat/platform-api/v3/user/managing-metadata/user-create-metadata
+     * Create user metadata
+     * @param param the request object
+     */
+    public createUserMetadata(param: UserApiCreateUserMetadataRequest, options?: Configuration): Promise<any> {
+        return this.api.createUserMetadata(param.userId, param.apiToken, param.createUserMetadataRequest,  options).toPromise();
+    }
+
     /**
      * ## Create user token  This action issues a session token for user authentication. Session tokens provide an efficient stateless authentication method by not storing the tokens in the Sendbird database, and thus improving the server's performance. See [access token vs. session token](https://sendbird.com/docs/chat/platform-api/v3/user/creating-users/create-a-user#2-access-token-vs-session-token) to learn more about authenticating users.  > **Note**: The endpoint `/users/{user_id}` is deprecated. Use `/users/{user_id}/token` for greater efficiency.      https://sendbird.com/docs/chat/platform-api/v3/user/managing-session-tokens/issue-a-session-token#1-issue-a-session-token
      * Create user token
@@ -3612,6 +3752,24 @@ export class ObjectUserApi {
         return this.api.deleteAUser(param.userId, param.apiToken,  options).toPromise();
     }
 
+    /**
+     * ## Delete metadata https://sendbird.com/docs/chat/platform-api/v3/user/managing-metadata/user-delete-metadata
+     * Delete user metadata
+     * @param param the request object
+     */
+    public deleteSpecificUserMetadata(param: UserApiDeleteSpecificUserMetadataRequest, options?: Configuration): Promise<any> {
+        return this.api.deleteSpecificUserMetadata(param.userId, param.key, param.apiToken,  options).toPromise();
+    }
+
+    /**
+     * ## Delete metadata You can delete a specific or all metadata of a user. Metadata stores additional user information such as their preference settings. https://sendbird.com/docs/chat/platform-api/v3/user/managing-metadata/user-delete-metadata
+     * Delete user metadata
+     * @param param the request object
+     */
+    public deleteUserAllMetadata(param: UserApiDeleteUserAllMetadataRequest, options?: Configuration): Promise<any> {
+        return this.api.deleteUserAllMetadata(param.userId, param.apiToken,  options).toPromise();
+    }
+
     /**
      * ## Get channel invitation preference  This action retrieves a user's [group channel](https://sendbird.com/docs/chat/platform-api/v3/channel/channel-overview#2-channel-types-3-group-channel) invitation preference. Users are subject to both user-specific and application-wide invitation preferences. Of the two, the invitation preference set for a specific user takes precedence over [the default channel invitation preference](https://sendbird.com/docs/chat/platform-api/v3/channel/setting-up-channels/get-default-invitation-preference).  [https://sendbird.com/docs/chat/platform-api/v3/channel/managing-a-channel/get-channel-invitation-preference#1-get-channel-invitation-preference](https://sendbird.com/docs/chat/platform-api/v3/channel/managing-a-channel/get-channel-invitation-preference#1-get-channel-invitation-preference)
      * Get channel invitation preference
@@ -3747,6 +3905,24 @@ export class ObjectUserApi {
         return this.api.updatePushPreferencesForAChannel(param.userId, param.channelUrl, param.apiToken, param.updatePushPreferencesForAChannelRequest,  options).toPromise();
     }
 
+    /**
+     * ## Update metadata https://sendbird.com/docs/chat/platform-api/v3/user/managing-metadata/user-update-metadata
+     * Update specific user metadata
+     * @param param the request object
+     */
+    public updateSpecificUserMetadata(param: UserApiUpdateSpecificUserMetadataRequest, options?: Configuration): Promise<any> {
+        return this.api.updateSpecificUserMetadata(param.userId, param.key, param.apiToken, param.updateSpecificUserMetadataRequest,  options).toPromise();
+    }
+
+    /**
+     * ## Update metadata When updating existing items of the user metadata by their keys or adding new items to the metadata https://sendbird.com/docs/chat/platform-api/v3/user/managing-metadata/user-update-metadata
+     * Update user metadata
+     * @param param the request object
+     */
+    public updateUserMetadata(param: UserApiUpdateUserMetadataRequest, options?: Configuration): Promise<any> {
+        return this.api.updateUserMetadata(param.userId, param.apiToken, param.updateUserMetadataRequest,  options).toPromise();
+    }
+
     /**
      * ## View a user  You can retrieve information about a user using this API.  https://sendbird.com/docs/chat/platform-api/v3/user/listing-users/get-a-user#1-get-a-user  `user_id`   Type: string   Description: Specifies the unique ID of the user to retrieve.
      * View a user
@@ -3801,6 +3977,15 @@ export class ObjectUserApi {
         return this.api.viewPushPreferencesForAChannel(param.userId, param.channelUrl, param.apiToken,  options).toPromise();
     }
 
+    /**
+     * ## Get metadata https://sendbird.com/docs/chat/platform-api/v3/user/managing-metadata/user-get-metadata
+     * Get specific user metadata
+     * @param param the request object
+     */
+    public viewSpecificUserMetadata(param: UserApiViewSpecificUserMetadataRequest, options?: Configuration): Promise<any> {
+        return this.api.viewSpecificUserMetadata(param.userId, param.key, param.apiToken,  options).toPromise();
+    }
+
     /**
      * ## View who owns a registration or device token  Retrieves a user who owns a FCM registration token, HMS device token, or APNs device token. You can pass one of two values in `token_type`: `gcm`, `huawei`, or `apns`, depending on which push service you are using.  https://sendbird.com/docs/chat/v3/platform-api/guides/user#2-view-who-owns-a-registration-or-device-token ----------------------------
      * View who owns a registration or device token