@turinhub/tale-js-sdk 1.3.0 → 2.0.0

package/dist/attachment-type/index.js

@@ -0,0 +1,203 @@
+import { getAppToken } from "../token.js";
+import { ApiError, ConfigurationError, NetworkError } from "../errors.js";
+function parseApiResponse(json, errorMessage, statusCode) {
+    if (typeof json !== "object" || json === null) {
+        throw new ApiError(`Invalid response: ${errorMessage} - not an object`, statusCode);
+    }
+    const response = json;
+    if (response.code !== 200) {
+        const errorMsg = typeof response.msg === "string" ? response.msg : errorMessage;
+        throw new ApiError(errorMsg, statusCode, response.code);
+    }
+    if (!response.data) {
+        throw new ApiError(`Invalid response: ${errorMessage} - missing data`, statusCode);
+    }
+    return response.data;
+}
+function assertRequiredString(value, fieldName) {
+    if (!value || value.trim() === "") {
+        throw new ApiError(`${fieldName} is required`, 400, "9400");
+    }
+}
+function getBaseUrl(options) {
+    const env = globalThis?.process?.env ?? import.meta?.env ?? undefined;
+    const base = options?.baseUrl ?? env?.TALE_BASE_URL ?? undefined;
+    if (!base) {
+        throw new ConfigurationError("Missing required environment variable: TALE_BASE_URL");
+    }
+    return String(base).replace(/\/+$/, "");
+}
+/** List attachment types */
+export async function listAttachmentTypes(request) {
+    const token = request?.appToken ?? (await getAppToken(request));
+    const base = getBaseUrl(request);
+    const url = new URL(base + "/attachment-type/v2/types");
+    const { appToken, baseUrl, ...requestParams } = request || {};
+    const queryParams = {
+        page: 0,
+        size: 20,
+        sort: "createdAt,desc",
+        ...requestParams,
+    };
+    Object.entries(queryParams).forEach(([key, value]) => {
+        if (value !== undefined) {
+            url.searchParams.append(key, String(value));
+        }
+    });
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to list attachment types: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to list attachment types", response.status);
+}
+/** List attachment types by reference */
+export async function listAttachmentTypesByRef(request) {
+    const refTypeId = request?.refTypeId?.trim();
+    const refType = request?.refType?.trim();
+    if (!refTypeId && !refType) {
+        throw new ApiError("At least one of refTypeId or refType is required", 400, "9400");
+    }
+    const token = request.appToken ?? (await getAppToken(request));
+    const base = getBaseUrl(request);
+    const url = new URL(base + "/attachment-type/v2/types/by-ref");
+    const { appToken, baseUrl, refTypeId: _refTypeId, refType: _refType, ...pagination } = request;
+    if (refTypeId) {
+        url.searchParams.append("refTypeId", refTypeId);
+    }
+    if (refType) {
+        url.searchParams.append("refType", refType);
+    }
+    const queryParams = {
+        page: 0,
+        size: 20,
+        sort: "createdAt,desc",
+        ...pagination,
+    };
+    Object.entries(queryParams).forEach(([key, value]) => {
+        if (value !== undefined) {
+            url.searchParams.append(key, String(value));
+        }
+    });
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to list attachment types by ref: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to list attachment types by ref", response.status);
+}
+/** Get attachment type by ID */
+export async function getAttachmentType(typeId, options) {
+    assertRequiredString(typeId, "typeId");
+    const token = options?.appToken ?? (await getAppToken(options));
+    const base = getBaseUrl(options);
+    const url = new URL(base + `/attachment-type/v2/types/${encodeURIComponent(typeId)}`);
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to get attachment type: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to get attachment type", response.status);
+}
+/** Create attachment type */
+export async function createAttachmentType(request, options) {
+    assertRequiredString(request?.refType, "refType");
+    assertRequiredString(request?.typeCode, "typeCode");
+    assertRequiredString(request?.typeName, "typeName");
+    const token = options?.appToken ?? (await getAppToken(options));
+    const base = getBaseUrl(options);
+    const url = new URL(base + "/attachment-type/v2/types");
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+            body: JSON.stringify(request),
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to create attachment type: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to create attachment type", response.status);
+}
+/** Update attachment type */
+export async function updateAttachmentType(typeId, request, options) {
+    assertRequiredString(typeId, "typeId");
+    const token = options?.appToken ?? (await getAppToken(options));
+    const base = getBaseUrl(options);
+    const url = new URL(base + `/attachment-type/v2/types/${encodeURIComponent(typeId)}`);
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+            body: JSON.stringify(request),
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to update attachment type: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to update attachment type", response.status);
+}
+/** Delete attachment type */
+export async function deleteAttachmentType(typeId, options) {
+    assertRequiredString(typeId, "typeId");
+    const token = options?.appToken ?? (await getAppToken(options));
+    const base = getBaseUrl(options);
+    const url = new URL(base + `/attachment-type/v2/types/${encodeURIComponent(typeId)}`);
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "DELETE",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to delete attachment type: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = (await response.json());
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string"
+            ? json.msg
+            : "Failed to delete attachment type";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+}

package/dist/attachment-type/types.d.ts

@@ -0,0 +1,60 @@
+import type { CommonOptions } from "../common/types.js";
+export type { AttachmentRefType } from "../attachment/types.js";
+type AttachmentRefType = import("../attachment/types.js").AttachmentRefType;
+export interface AttachmentType {
+    typeId: string;
+    appId: string;
+    refType: string;
+    refTypeId?: string | null;
+    typeCode: string;
+    typeName: string;
+    description?: string;
+    allowedExtensions: string[];
+    allowedMimeTypes: string[];
+    maxFileSize: number;
+    isUnique: boolean;
+    isEnabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+    remark?: string;
+}
+export interface CreateAttachmentTypeRequest {
+    refType: AttachmentRefType;
+    refTypeId?: string;
+    typeCode: string;
+    typeName: string;
+    description?: string;
+    allowedExtensions?: string[];
+    allowedMimeTypes?: string[];
+    maxFileSize?: number;
+    isUnique?: boolean;
+    isEnabled?: boolean;
+    remark?: string;
+}
+export interface UpdateAttachmentTypeRequest {
+    refType?: AttachmentRefType;
+    refTypeId?: string;
+    typeCode?: string;
+    typeName?: string;
+    description?: string;
+    allowedExtensions?: string[];
+    allowedMimeTypes?: string[];
+    maxFileSize?: number;
+    isUnique?: boolean;
+    isEnabled?: boolean;
+    remark?: string;
+}
+export interface ListAttachmentTypesRequest {
+    page?: number;
+    size?: number;
+    sort?: string;
+}
+export interface ListAttachmentTypesByRefRequest {
+    refTypeId?: string;
+    refType?: AttachmentRefType;
+    page?: number;
+    size?: number;
+    sort?: string;
+}
+export interface AttachmentTypeOptions extends CommonOptions {
+}

package/dist/attachment-type/types.js

@@ -0,0 +1 @@
+export {};

package/dist/auth/index.d.ts

@@ -35,11 +35,11 @@ export type { LoginRequest, LoginOptions, LoginWithSmsOptions, VerifySmsOptions,
  *   username: 'johndoe',
  *   password: 'secure_password_123'
  * }, {
- *   include_rbac: true,           // Include roles and privileges (SDK default: false)
- *   include_user_groups: true,    // Include user groups (SDK default: false)
- *   include_login_methods: true,  // Include login methods (SDK default: false)
- *   include_attributes: true,     // Include user attributes (SDK default: false)
- *   include_acl: true             // Include ACL records (SDK default: false)
+ *   includeRbac: true,           // Include roles and privileges (SDK default: false)
+ *   includeUserGroups: true,    // Include user groups (SDK default: false)
+ *   includeLoginMethods: true,  // Include login methods (SDK default: false)
+ *   includeAttributes: true,     // Include user attributes (SDK default: false)
+ *   includeAcl: true             // Include ACL records (SDK default: false)
  * });
  * ```
  *
@@ -49,11 +49,11 @@ export type { LoginRequest, LoginOptions, LoginWithSmsOptions, VerifySmsOptions,
  * @note By default, all include parameters are set to false for better performance.
  *       Explicitly set them to true if you need the additional data.
  *
- * @param options.include_rbac Include roles and privileges; default false
- * @param options.include_login_methods Include user login methods; default false
- * @param options.include_user_groups Include user groups; default false
- * @param options.include_attributes Include user attributes; default false
- * @param options.include_acl Include ACL records; default false
+ * @param options.includeRbac Include roles and privileges; default false
+ * @param options.includeLoginMethods Include user login methods; default false
+ * @param options.includeUserGroups Include user groups; default false
+ * @param options.includeAttributes Include user attributes; default false
+ * @param options.includeAcl Include ACL records; default false
  */
 export declare function login(credentials: LoginRequest, options?: LoginOptions): Promise<LoginResponse>;
 /**
@@ -98,7 +98,7 @@ export declare function validateToken(token: string, options?: {
  *
  * try {
  *   const result = await loginWithSms('+8613800138000');
- *   console.log('SMS sent:', result.sms_id);
+ *   console.log('SMS sent:', result.smsId);
  *   console.log('Type:', result.type); // 'login' or 'register'
  * } catch (error) {
  *   console.error('SMS sending failed:', error.message);
@@ -109,7 +109,7 @@ export declare function loginWithSms(phone: string, options?: LoginWithSmsOption
 /**
  * Verifies SMS code and authenticates user (login or register).
  *
- * @param request - SMS verification request with sms_id, code, and optional user data
+ * @param request - SMS verification request with smsId, code, and optional user data
  * @param options - Optional configuration for the request
  * @returns Promise resolving to login response with user info and token
  * @throws {ConfigurationError} When required environment variables are missing
@@ -122,11 +122,11 @@ export declare function loginWithSms(phone: string, options?: LoginWithSmsOption
  *
  * try {
  *   const result = await verifySmsCode({
- *     sms_id: 'uuid-here',
- *     sms_type: 'login',
- *     verification_code: '123456'
+ *     smsId: 'uuid-here',
+ *     smsType: 'login',
+ *     verificationCode: '123456'
  *   });
- *   console.log('Login successful:', result.user.user_id);
+ *   console.log('Login successful:', result.user.userId);
  *   console.log('User token:', result.token.token);
  * } catch (error) {
  *   console.error('SMS verification failed:', error.message);
@@ -150,13 +150,13 @@ export declare function verifySmsCode(request: VerifySmsRequest, options?: Verif
  *
  * try {
  *   const result = await registerWithSms({
- *     sms_id: 'uuid-here',
- *     sms_type: 'register',
- *     verification_code: '123456',
+ *     smsId: 'uuid-here',
+ *     smsType: 'register',
+ *     verificationCode: '123456',
  *     username: 'newuser',
- *     password_encrypted: 'encrypted_password'
+ *     passwordEncrypted: 'encrypted_password'
  *   });
- *   console.log('Registration successful:', result.user.user_id);
+ *   console.log('Registration successful:', result.user.userId);
  *   console.log('User token:', result.token.token);
  * } catch (error) {
  *   console.error('Registration failed:', error.message);

package/dist/auth/index.js

@@ -35,11 +35,11 @@ import { ApiError, ConfigurationError, NetworkError } from "../errors.js";
  *   username: 'johndoe',
  *   password: 'secure_password_123'
  * }, {
- *   include_rbac: true,           // Include roles and privileges (SDK default: false)
- *   include_user_groups: true,    // Include user groups (SDK default: false)
- *   include_login_methods: true,  // Include login methods (SDK default: false)
- *   include_attributes: true,     // Include user attributes (SDK default: false)
- *   include_acl: true             // Include ACL records (SDK default: false)
+ *   includeRbac: true,           // Include roles and privileges (SDK default: false)
+ *   includeUserGroups: true,    // Include user groups (SDK default: false)
+ *   includeLoginMethods: true,  // Include login methods (SDK default: false)
+ *   includeAttributes: true,     // Include user attributes (SDK default: false)
+ *   includeAcl: true             // Include ACL records (SDK default: false)
  * });
  * ```
  *
@@ -49,11 +49,11 @@ import { ApiError, ConfigurationError, NetworkError } from "../errors.js";
  * @note By default, all include parameters are set to false for better performance.
  *       Explicitly set them to true if you need the additional data.
  *
- * @param options.include_rbac Include roles and privileges; default false
- * @param options.include_login_methods Include user login methods; default false
- * @param options.include_user_groups Include user groups; default false
- * @param options.include_attributes Include user attributes; default false
- * @param options.include_acl Include ACL records; default false
+ * @param options.includeRbac Include roles and privileges; default false
+ * @param options.includeLoginMethods Include user login methods; default false
+ * @param options.includeUserGroups Include user groups; default false
+ * @param options.includeAttributes Include user attributes; default false
+ * @param options.includeAcl Include ACL records; default false
  */
 export async function login(credentials, options) {
     // Validate required fields
@@ -75,20 +75,20 @@ export async function login(credentials, options) {
         throw new ConfigurationError("Missing required environment variable: TALE_APP_KEY");
     }
     // Build URL with query parameters
-    const url = new URL(String(base).replace(/\/+$/, "") + "/auth/v1/login/username-password");
+    const url = new URL(String(base).replace(/\/+$/, "") + "/auth/v2/login/username-password");
     // Add include parameters as query params (SDK defaults to false)
-    url.searchParams.set("include_rbac", String(options?.include_rbac ?? false));
-    url.searchParams.set("include_login_methods", String(options?.include_login_methods ?? false));
-    url.searchParams.set("include_user_groups", String(options?.include_user_groups ?? false));
-    url.searchParams.set("include_attributes", String(options?.include_attributes ?? false));
-    url.searchParams.set("include_acl", String(options?.include_acl ?? false));
+    url.searchParams.set("includeRbac", String(options?.includeRbac ?? false));
+    url.searchParams.set("includeLoginMethods", String(options?.includeLoginMethods ?? false));
+    url.searchParams.set("includeUserGroups", String(options?.includeUserGroups ?? false));
+    url.searchParams.set("includeAttributes", String(options?.includeAttributes ?? false));
+    url.searchParams.set("includeAcl", String(options?.includeAcl ?? false));
     // Build request body
     const requestBody = {
         username: credentials.username.trim(),
         password: credentials.password,
-        app_key: appKey,
-        device_name: options?.device_name,
-        device_fingerprint: options?.device_fingerprint,
+        appKey: appKey,
+        deviceName: options?.deviceName,
+        deviceFingerprint: options?.deviceFingerprint,
         scope: options?.scope || "",
     };
     let response;
@@ -125,7 +125,7 @@ export async function login(credentials, options) {
         throw new ApiError("Account is frozen or access forbidden", response.status, "9403");
     }
     if (response.status === 401) {
-        throw new ApiError("Invalid app_key or authentication failed", response.status, "9401");
+        throw new ApiError("Invalid appKey or authentication failed", response.status, "9401");
     }
     if (!response.ok) {
         const errorMsg = typeof json === "object" &&
@@ -147,10 +147,10 @@ export async function login(credentials, options) {
         app: responseData.app,
         user: responseData.user,
         token: responseData.token,
-        user_roles: responseData.user_roles || [],
-        user_privileges: responseData.user_privileges || [],
-        user_groups: responseData.user_groups || [],
-        user_login_methods: responseData.user_login_methods || [],
+        userRoles: responseData.userRoles || [],
+        userPrivileges: responseData.userPrivileges || [],
+        userGroups: responseData.userGroups || [],
+        userLoginMethods: responseData.userLoginMethods || [],
     };
     return loginResponse;
 }
@@ -187,7 +187,7 @@ export async function validateToken(token, options) {
     if (!base) {
         throw new ConfigurationError("Missing required environment variable: TALE_BASE_URL");
     }
-    const url = new URL(String(base).replace(/\/+$/, "") + "/auth/v1/assert_token");
+    const url = new URL(String(base).replace(/\/+$/, "") + "/auth/v2/assert-token");
     if (options?.scope) {
         url.searchParams.append("scope", options.scope);
     }
@@ -223,7 +223,7 @@ export async function validateToken(token, options) {
  *
  * try {
  *   const result = await loginWithSms('+8613800138000');
- *   console.log('SMS sent:', result.sms_id);
+ *   console.log('SMS sent:', result.smsId);
  *   console.log('Type:', result.type); // 'login' or 'register'
  * } catch (error) {
  *   console.error('SMS sending failed:', error.message);
@@ -243,7 +243,7 @@ export async function loginWithSms(phone, options) {
     }
     // Use provided app token or get one from token service
     const authToken = options?.appToken ?? (await getAppToken());
-    const url = new URL(String(base).replace(/\/+$/, "") + "/auth/v1/sms/login_or_register");
+    const url = new URL(String(base).replace(/\/+$/, "") + "/auth/v2/sms/login-or-register");
     url.searchParams.append("phone", phone.trim());
     let response;
     try {
@@ -289,21 +289,21 @@ export async function loginWithSms(phone, options) {
     // Handle response data structure - check if data is wrapped in a 'data' field
     const responseData = json.data || json;
     // Validate response structure
-    if (!responseData || !responseData.sms_id || !responseData.type) {
+    if (!responseData || !responseData.smsId || !responseData.type) {
         throw new ApiError("Invalid SMS response: missing required data", response.status);
     }
     return {
-        app_key: responseData.app_key,
+        appKey: responseData.appKey,
         phone: responseData.phone,
         type: responseData.type,
-        sms_id: responseData.sms_id,
-        expired_at: responseData.expired_at,
+        smsId: responseData.smsId,
+        expiredAt: responseData.expiredAt,
     };
 }
 /**
  * Verifies SMS code and authenticates user (login or register).
  *
- * @param request - SMS verification request with sms_id, code, and optional user data
+ * @param request - SMS verification request with smsId, code, and optional user data
  * @param options - Optional configuration for the request
  * @returns Promise resolving to login response with user info and token
  * @throws {ConfigurationError} When required environment variables are missing
@@ -316,11 +316,11 @@ export async function loginWithSms(phone, options) {
  *
  * try {
  *   const result = await verifySmsCode({
- *     sms_id: 'uuid-here',
- *     sms_type: 'login',
- *     verification_code: '123456'
+ *     smsId: 'uuid-here',
+ *     smsType: 'login',
+ *     verificationCode: '123456'
  *   });
- *   console.log('Login successful:', result.user.user_id);
+ *   console.log('Login successful:', result.user.userId);
  *   console.log('User token:', result.token.token);
  * } catch (error) {
  *   console.error('SMS verification failed:', error.message);
@@ -329,14 +329,14 @@ export async function loginWithSms(phone, options) {
  */
 export async function verifySmsCode(request, options) {
     // Validate required fields
-    if (!request.sms_id || request.sms_id.trim() === "") {
-        throw new ApiError("sms_id is required", 400, "9400");
+    if (!request.smsId || request.smsId.trim() === "") {
+        throw new ApiError("smsId is required", 400, "9400");
     }
-    if (!request.sms_type || !["login", "register"].includes(request.sms_type)) {
-        throw new ApiError('sms_type must be "login" or "register"', 400, "9400");
+    if (!request.smsType || !["login", "register"].includes(request.smsType)) {
+        throw new ApiError('smsType must be "login" or "register"', 400, "9400");
     }
-    if (!request.verification_code || request.verification_code.trim() === "") {
-        throw new ApiError("verification_code is required", 400, "9400");
+    if (!request.verificationCode || request.verificationCode.trim() === "") {
+        throw new ApiError("verificationCode is required", 400, "9400");
     }
     // Determine base URL
     const env = globalThis?.process?.env ?? import.meta?.env ?? undefined;
@@ -346,10 +346,10 @@ export async function verifySmsCode(request, options) {
     }
     // Use provided app token or get one from token service
     const authToken = options?.appToken ?? (await getAppToken(options));
-    const url = new URL(String(base).replace(/\/+$/, "") + "/auth/v1/sms/verify");
-    url.searchParams.append("sms_id", request.sms_id.trim());
-    url.searchParams.append("sms_type", request.sms_type);
-    url.searchParams.append("verification_code", request.verification_code.trim());
+    const url = new URL(String(base).replace(/\/+$/, "") + "/auth/v2/sms/verify");
+    url.searchParams.append("smsId", request.smsId.trim());
+    url.searchParams.append("smsType", request.smsType);
+    url.searchParams.append("verificationCode", request.verificationCode.trim());
     let response;
     try {
         response = await globalThis.fetch(url.toString(), {
@@ -402,10 +402,10 @@ export async function verifySmsCode(request, options) {
         app: responseData.app,
         user: responseData.user,
         token: responseData.token,
-        user_roles: responseData.user_roles || [],
-        user_privileges: responseData.user_privileges || [],
-        user_groups: responseData.user_groups || [],
-        user_login_methods: responseData.user_login_methods || [],
+        userRoles: responseData.userRoles || [],
+        userPrivileges: responseData.userPrivileges || [],
+        userGroups: responseData.userGroups || [],
+        userLoginMethods: responseData.userLoginMethods || [],
     };
     return smsLoginResponse;
 }
@@ -425,13 +425,13 @@ export async function verifySmsCode(request, options) {
  *
  * try {
  *   const result = await registerWithSms({
- *     sms_id: 'uuid-here',
- *     sms_type: 'register',
- *     verification_code: '123456',
+ *     smsId: 'uuid-here',
+ *     smsType: 'register',
+ *     verificationCode: '123456',
  *     username: 'newuser',
- *     password_encrypted: 'encrypted_password'
+ *     passwordEncrypted: 'encrypted_password'
  *   });
- *   console.log('Registration successful:', result.user.user_id);
+ *   console.log('Registration successful:', result.user.userId);
  *   console.log('User token:', result.token.token);
  * } catch (error) {
  *   console.error('Registration failed:', error.message);
@@ -440,8 +440,8 @@ export async function verifySmsCode(request, options) {
  */
 export async function registerWithSms(request, options) {
     // Validate required fields for registration
-    if (request.sms_type !== "register") {
-        throw new ApiError('sms_type must be "register" for registration', 400, "9400");
+    if (request.smsType !== "register") {
+        throw new ApiError('smsType must be "register" for registration', 400, "9400");
     }
     // Determine base URL
     const env = globalThis?.process?.env ?? import.meta?.env ?? undefined;
@@ -451,14 +451,14 @@ export async function registerWithSms(request, options) {
     }
     // Use provided app token or get one from token service
     const authToken = options?.appToken ?? (await getAppToken(options));
-    const url = String(base).replace(/\/+$/, "") + "/auth/v1/sms/register/verify";
+    const url = String(base).replace(/\/+$/, "") + "/auth/v2/sms/register/verify";
     // Build request body
     const requestBody = {
-        sms_id: request.sms_id.trim(),
-        sms_type: request.sms_type,
-        verification_code: request.verification_code.trim(),
+        smsId: request.smsId.trim(),
+        smsType: request.smsType,
+        verificationCode: request.verificationCode.trim(),
         username: request.username?.trim(),
-        password_encrypted: request.password_encrypted,
+        passwordEncrypted: request.passwordEncrypted,
     };
     let response;
     try {
@@ -513,10 +513,10 @@ export async function registerWithSms(request, options) {
         app: responseData.app,
         user: responseData.user,
         token: responseData.token,
-        user_roles: responseData.user_roles || [],
-        user_privileges: responseData.user_privileges || [],
-        user_groups: responseData.user_groups || [],
-        user_login_methods: responseData.user_login_methods || [],
+        userRoles: responseData.userRoles || [],
+        userPrivileges: responseData.userPrivileges || [],
+        userGroups: responseData.userGroups || [],
+        userLoginMethods: responseData.userLoginMethods || [],
     };
     return registrationResponse;
 }