@turinhub/tale-js-sdk 1.3.0

package/dist/user/index.js

@@ -0,0 +1,786 @@
+import { getAppToken } from "../token.js";
+import { ApiError, ConfigurationError, NetworkError } from "../errors.js";
+/**
+ * Creates a new user in the Tale application.
+ *
+ * @param userData - User data to create the new user
+ * @param options - Optional configuration for the request
+ * @returns Promise resolving to the created user information
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails or returns invalid response
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * import { createUser } from '@tale/client';
+ *
+ * try {
+ *   const result = await createUser({
+ *     username: 'john_doe',
+ *     nickname: 'John Doe',
+ *     email: 'john@example.com'
+ *   });
+ *   console.log('User created:', result.user.user_id);
+ * } catch (error) {
+ *   console.error('Failed to create user:', error.message);
+ * }
+ * ```
+ */
+export async function createUser(userData, options) {
+    // Validate required fields
+    if (!userData.username || userData.username.trim() === "") {
+        throw new ApiError("username is required", 400, "9400");
+    }
+    // Use provided app token or get one from token service
+    const token = options?.appToken ?? (await getAppToken(options));
+    // Determine base URL
+    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");
+    }
+    const url = String(base).replace(/\/+$/, "") + "/account/v1/user";
+    let response;
+    try {
+        response = await globalThis.fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+            body: JSON.stringify(userData),
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to create user: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let json;
+    try {
+        const responseJson = await response.json();
+        json = responseJson;
+    }
+    catch (error) {
+        throw new ApiError(`Failed to parse user creation response: ${error instanceof Error ? error.message : "Invalid JSON"}`, response.status);
+    }
+    // Handle API errors
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string" ? json.msg : "User creation failed";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+    // Validate response structure
+    if (!json.data || !json.data.user || !json.data.app) {
+        throw new ApiError("Invalid user creation response: missing required data", response.status);
+    }
+    return json.data;
+}
+/**
+ * Retrieves user information by ID or open ID.
+ *
+ * @param userId - Optional user ID (open_id) to query. If not provided, returns current user info
+ * @param options - Optional parameters for inclusion flags and configuration
+ * @returns Promise resolving to the user information
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails or returns invalid response
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * import { getUserById } from '@tale/client';
+ *
+ * try {
+ *   const result = await getUserById('user_open_id_here');
+ *   console.log('User info:', result.user.username);
+ * } catch (error) {
+ *   console.error('Failed to get user:', error.message);
+ * }
+ * ```
+ */
+export async function getUserById(userId, options) {
+    // Use provided app token or get one from token service
+    const token = options?.appToken ?? (await getAppToken(options));
+    // Determine base URL
+    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");
+    }
+    // Build URL with query parameters
+    const url = new URL(String(base).replace(/\/+$/, "") + "/account/v1/user");
+    // Add query parameters
+    const queryParams = {
+        user_id: userId,
+        include_rbac: true,
+        include_login_methods: true,
+        include_user_groups: true,
+        include_acl: false,
+        ...options,
+    };
+    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 get user: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let json;
+    try {
+        const responseJson = await response.json();
+        json = responseJson;
+    }
+    catch (error) {
+        throw new ApiError(`Failed to parse user response: ${error instanceof Error ? error.message : "Invalid JSON"}`, response.status);
+    }
+    // Handle API errors
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string" ? json.msg : "User retrieval failed";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+    // Validate response structure
+    if (!json.data || !json.data.user || !json.data.app) {
+        throw new ApiError("Invalid user response: missing required data", response.status);
+    }
+    return json.data;
+}
+/**
+ * Deletes a user by ID or open ID.
+ *
+ * @param userId - User ID (open_id) to delete
+ * @param options - Optional configuration for the request
+ * @returns Promise resolving to the deletion result
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails or returns invalid response
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * import { deleteUser } from '@tale/client';
+ *
+ * try {
+ *   const result = await deleteUser('user_open_id_here');
+ *   console.log('User deleted:', result.deleted);
+ * } catch (error) {
+ *   console.error('Failed to delete user:', error.message);
+ * }
+ * ```
+ */
+export async function deleteUser(userId, options) {
+    // Validate required fields
+    if (!userId || userId.trim() === "") {
+        throw new ApiError("user_id is required for deletion", 400, "9400");
+    }
+    // Use provided app token or get one from token service
+    const token = options?.appToken ?? (await getAppToken(options));
+    // Determine base URL
+    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");
+    }
+    const url = String(base).replace(/\/+$/, "") +
+        `/account/v1/users/${encodeURIComponent(userId)}`;
+    let response;
+    try {
+        response = await globalThis.fetch(url, {
+            method: "DELETE",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to delete user: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let json;
+    try {
+        const responseJson = await response.json();
+        json = responseJson;
+    }
+    catch (error) {
+        throw new ApiError(`Failed to parse user deletion response: ${error instanceof Error ? error.message : "Invalid JSON"}`, response.status);
+    }
+    // Handle API errors
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string" ? json.msg : "User deletion failed";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+    // Validate response structure
+    if (!json.data || json.data.deleted !== true) {
+        throw new ApiError("Invalid user deletion response: deletion not confirmed", response.status);
+    }
+    return json.data;
+}
+/**
+ * Lists users with pagination, filtering, and search capabilities.
+ *
+ * @param options - Optional parameters for pagination, filtering, and configuration
+ * @returns Promise resolving to paginated user list with metadata
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails or returns invalid response
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * import { listUsers } from '@tale/client';
+ *
+ * try {
+ *   const result = await listUsers({
+ *     page: 0,
+ *     size: 20,
+ *     keyword: 'john',
+ *     sort_by: 'username',
+ *     sort_direction: 'asc'
+ *   });
+ *   console.log(`Found ${result.totalElements} users`);
+ *   console.log('First user:', result.content[0].user.username);
+ * } catch (error) {
+ *   console.error('Failed to list users:', error.message);
+ * }
+ * ```
+ */
+export async function listUsers(options) {
+    // Use provided app token or get one from token service
+    const token = options?.appToken ?? (await getAppToken(options));
+    // Determine base URL
+    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");
+    }
+    // Build URL with query parameters
+    const url = new URL(String(base).replace(/\/+$/, "") + "/account/v1/users");
+    // Add query parameters with defaults
+    const queryParams = {
+        page: 0,
+        size: 20,
+        sort_by: "createdAt",
+        sort_direction: "desc",
+        include_attributes: false,
+        ...options,
+    };
+    // Handle array parameters (need to be comma-separated)
+    if (queryParams.user_groups && queryParams.user_groups.length > 0) {
+        url.searchParams.append("user_groups", queryParams.user_groups.join(","));
+    }
+    if (queryParams.user_roles && queryParams.user_roles.length > 0) {
+        url.searchParams.append("user_roles", queryParams.user_roles.join(","));
+    }
+    if (queryParams.user_ids && queryParams.user_ids.length > 0) {
+        url.searchParams.append("user_ids", queryParams.user_ids.join(","));
+    }
+    // Add other parameters
+    if (queryParams.page !== undefined) {
+        url.searchParams.append("page", String(queryParams.page));
+    }
+    if (queryParams.size !== undefined) {
+        url.searchParams.append("size", String(queryParams.size));
+    }
+    if (queryParams.sort_by) {
+        url.searchParams.append("sort_by", queryParams.sort_by);
+    }
+    if (queryParams.sort_direction) {
+        url.searchParams.append("sort_direction", queryParams.sort_direction);
+    }
+    if (queryParams.keyword) {
+        url.searchParams.append("keyword", queryParams.keyword);
+    }
+    if (queryParams.include_attributes !== undefined) {
+        url.searchParams.append("include_attributes", String(queryParams.include_attributes));
+    }
+    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 users: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let json;
+    try {
+        const responseJson = await response.json();
+        json = responseJson;
+    }
+    catch (error) {
+        throw new ApiError(`Failed to parse users list response: ${error instanceof Error ? error.message : "Invalid JSON"}`, response.status);
+    }
+    // Handle API errors
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string" ? json.msg : "Users list retrieval failed";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+    // Validate response structure
+    if (!json.data || !Array.isArray(json.data.content)) {
+        throw new ApiError("Invalid users list response: missing required data", response.status);
+    }
+    return json.data;
+}
+/**
+ * Updates user information by user ID or open ID.
+ *
+ * @param userId - User ID (open_id) to update
+ * @param userData - User data to update
+ * @param options - Optional configuration for the request
+ * @returns Promise resolving to the update result
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails or returns invalid response
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * import { updateUser } from '@tale/client';
+ *
+ * try {
+ *   const result = await updateUser('user_open_id_here', {
+ *     nick_name: 'John Doe',
+ *     email: 'john@example.com'
+ *   });
+ *   console.log('User updated:', result.success);
+ * } catch (error) {
+ *   console.error('Failed to update user:', error.message);
+ * }
+ * ```
+ */
+export async function updateUser(userId, userData, options) {
+    // Validate required fields
+    if (!userId || userId.trim() === "") {
+        throw new ApiError("userId is required for update", 400, "9400");
+    }
+    // Use provided app token or get one from token service
+    const token = options?.appToken ?? (await getAppToken(options));
+    // Determine base URL
+    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");
+    }
+    const url = String(base).replace(/\/+$/, "") +
+        `/account/v1/user/${encodeURIComponent(userId)}`;
+    let response;
+    try {
+        response = await globalThis.fetch(url, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+            body: JSON.stringify(userData),
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to update user: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let json;
+    try {
+        const responseJson = await response.json();
+        json = responseJson;
+    }
+    catch (error) {
+        throw new ApiError(`Failed to parse user update response: ${error instanceof Error ? error.message : "Invalid JSON"}`, response.status);
+    }
+    // Handle API errors
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string" ? json.msg : "User update failed";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+    return {
+        success: true,
+        user_id: userId,
+    };
+}
+/**
+ * Updates user password.
+ *
+ * @param passwordData - Password data including user_id and encrypted password
+ * @param options - Optional configuration for the request
+ * @returns Promise resolving to the update result
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails or returns invalid response
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * import { updateUserPassword } from '@tale/client';
+ *
+ * try {
+ *   const result = await updateUserPassword({
+ *     user_id: 'user_open_id_here',
+ *     password_encrypted: 'encrypted_password_here'
+ *   });
+ *   console.log('Password updated:', result.success);
+ * } catch (error) {
+ *   console.error('Failed to update password:', error.message);
+ * }
+ * ```
+ */
+export async function updateUserPassword(passwordData, options) {
+    // Validate required fields
+    if (!passwordData.user_id || passwordData.user_id.trim() === "") {
+        throw new ApiError("user_id is required for password update", 400, "9400");
+    }
+    if (!passwordData.password_encrypted ||
+        passwordData.password_encrypted.trim() === "") {
+        throw new ApiError("password_encrypted is required", 400, "9400");
+    }
+    // Use provided app token or get one from token service
+    const token = options?.appToken ?? (await getAppToken(options));
+    // Determine base URL
+    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");
+    }
+    const url = String(base).replace(/\/+$/, "") + "/account/v1/user/password";
+    let response;
+    try {
+        response = await globalThis.fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+            body: JSON.stringify(passwordData),
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to update user password: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let json;
+    try {
+        const responseJson = await response.json();
+        json = responseJson;
+    }
+    catch (error) {
+        throw new ApiError(`Failed to parse password update response: ${error instanceof Error ? error.message : "Invalid JSON"}`, response.status);
+    }
+    // Handle API errors
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string" ? json.msg : "Password update failed";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+    return {
+        success: true,
+        user_id: passwordData.user_id,
+    };
+}
+/**
+ * Uploads user avatar image.
+ *
+ * @param file - File object to upload as avatar
+ * @param userId - User ID (open_id) of the user
+ * @param options - Optional configuration for the request
+ * @returns Promise resolving to the upload result with avatar OSS key
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails or returns invalid response
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * import { uploadAvatar } from '@tale/client';
+ *
+ * try {
+ *   const fileInput = document.querySelector('input[type="file"]');
+ *   const file = fileInput.files[0];
+ *   const result = await uploadAvatar(file, 'user_open_id_here');
+ *   console.log('Avatar uploaded:', result.avatar_oss_key);
+ * } catch (error) {
+ *   console.error('Failed to upload avatar:', error.message);
+ * }
+ * ```
+ */
+export async function uploadAvatar(file, userId, options) {
+    // Validate required fields
+    if (!file) {
+        throw new ApiError("file is required for avatar upload", 400, "9400");
+    }
+    if (!userId || userId.trim() === "") {
+        throw new ApiError("userId is required for avatar upload", 400, "9400");
+    }
+    // Use provided app token or get one from token service
+    const token = options?.appToken ?? (await getAppToken(options));
+    // Determine base URL
+    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");
+    }
+    const url = String(base).replace(/\/+$/, "") + "/account/v1/user/avatar/upload";
+    // Create FormData
+    const formData = new FormData();
+    formData.append("file", file);
+    formData.append("user_open_id", userId);
+    let response;
+    try {
+        response = await globalThis.fetch(url, {
+            method: "POST",
+            headers: {
+                "x-t-token": token,
+            },
+            body: formData,
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to upload avatar: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let json;
+    try {
+        const responseJson = await response.json();
+        json = responseJson;
+    }
+    catch (error) {
+        throw new ApiError(`Failed to parse avatar upload response: ${error instanceof Error ? error.message : "Invalid JSON"}`, response.status);
+    }
+    // Handle API errors
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string" ? json.msg : "Avatar upload failed";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+    // Validate response structure
+    if (!json.data || !json.data.avatar_oss_key) {
+        throw new ApiError("Invalid avatar upload response: missing avatar_oss_key", response.status);
+    }
+    return json.data;
+}
+/**
+ * Gets presigned URL for avatar access.
+ *
+ * @param ossKey - OSS key of the avatar
+ * @param options - Optional configuration for the request
+ * @returns Promise resolving to presigned URL information
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails or returns invalid response
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * import { getAvatarPresignedUrl } from '@tale/client';
+ *
+ * try {
+ *   const result = await getAvatarPresignedUrl('avatars/user123.jpg');
+ *   console.log('Presigned URL:', result.presignedUrl);
+ *   console.log('Expires in:', result.expireTimeInSeconds, 'seconds');
+ * } catch (error) {
+ *   console.error('Failed to get presigned URL:', error.message);
+ * }
+ * ```
+ */
+export async function getAvatarPresignedUrl(ossKey, options) {
+    // Validate required fields
+    if (!ossKey || ossKey.trim() === "") {
+        throw new ApiError("ossKey is required", 400, "9400");
+    }
+    // Use provided app token or get one from token service
+    const token = options?.appToken ?? (await getAppToken(options));
+    // Determine base URL
+    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");
+    }
+    const url = new URL(String(base).replace(/\/+$/, "") + "/cms/file/getPresignedUrl");
+    url.searchParams.append("ossKey", ossKey);
+    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 avatar presigned URL: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let json;
+    try {
+        const responseJson = await response.json();
+        json = responseJson;
+    }
+    catch (error) {
+        throw new ApiError(`Failed to parse presigned URL response: ${error instanceof Error ? error.message : "Invalid JSON"}`, response.status);
+    }
+    // Handle API errors
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string" ? json.msg : "Failed to get presigned URL";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+    // Validate response structure
+    if (!json.data || !json.data.presignedUrl) {
+        throw new ApiError("Invalid presigned URL response: missing presignedUrl", response.status);
+    }
+    return json.data;
+}
+/**
+ * Updates user frozen status (freeze or unfreeze a user account).
+ *
+ * @param userId - User ID (open_id) to update frozen status
+ * @param frozenData - Frozen status data including is_frozen flag and optional remark
+ * @param options - Optional configuration for the request
+ * @returns Promise resolving to the updated frozen status information
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails or returns invalid response
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * import { updateUserFrozenStatus } from '@tale/client';
+ *
+ * try {
+ *   // Freeze a user account
+ *   const result = await updateUserFrozenStatus('user_open_id_here', {
+ *     is_frozen: true,
+ *     remark: 'Violated community guidelines'
+ *   });
+ *   console.log('User frozen:', result.is_frozen);
+ *
+ *   // Unfreeze a user account
+ *   const unfrozenResult = await updateUserFrozenStatus('user_open_id_here', {
+ *     is_frozen: false,
+ *     remark: 'Account reactivated'
+ *   });
+ *   console.log('User unfrozen:', !unfrozenResult.is_frozen);
+ * } catch (error) {
+ *   console.error('Failed to update frozen status:', error.message);
+ * }
+ * ```
+ */
+export async function updateUserFrozenStatus(userId, frozenData, options) {
+    // Validate required fields
+    if (!userId || userId.trim() === "") {
+        throw new ApiError("userId is required for updating frozen status", 400, "9400");
+    }
+    if (frozenData.is_frozen === undefined || frozenData.is_frozen === null) {
+        throw new ApiError("is_frozen is required", 400, "9400");
+    }
+    // Use provided app token or get one from token service
+    const token = options?.appToken ?? (await getAppToken(options));
+    // Determine base URL
+    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");
+    }
+    const url = String(base).replace(/\/+$/, "") +
+        `/account/v1/user/${encodeURIComponent(userId)}/frozen-status`;
+    let response;
+    try {
+        response = await globalThis.fetch(url, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+            body: JSON.stringify(frozenData),
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to update user frozen status: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let json;
+    try {
+        const responseJson = await response.json();
+        json = responseJson;
+    }
+    catch (error) {
+        throw new ApiError(`Failed to parse frozen status update response: ${error instanceof Error ? error.message : "Invalid JSON"}`, response.status);
+    }
+    // Handle API errors
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string"
+            ? json.msg
+            : "Failed to update frozen status";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+    // Validate response structure
+    if (!json.data || json.data.user_id === undefined) {
+        throw new ApiError("Invalid frozen status update response: missing required data", response.status);
+    }
+    return json.data;
+}
+/**
+ * Gets user frozen status by user ID.
+ *
+ * @param userId - User ID (open_id) to query frozen status
+ * @param options - Optional configuration for the request
+ * @returns Promise resolving to the user frozen status information
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails or returns invalid response
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * import { getUserFrozenStatus } from '@tale/client';
+ *
+ * try {
+ *   const status = await getUserFrozenStatus('user_open_id_here');
+ *   console.log('User is frozen:', status.is_frozen);
+ *   console.log('Remark:', status.remark);
+ *   console.log('Last updated:', status.updated_at);
+ * } catch (error) {
+ *   console.error('Failed to get frozen status:', error.message);
+ * }
+ * ```
+ */
+export async function getUserFrozenStatus(userId, options) {
+    // Validate required fields
+    if (!userId || userId.trim() === "") {
+        throw new ApiError("userId is required for getting frozen status", 400, "9400");
+    }
+    // Use provided app token or get one from token service
+    const token = options?.appToken ?? (await getAppToken(options));
+    // Determine base URL
+    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");
+    }
+    const url = String(base).replace(/\/+$/, "") +
+        `/account/v1/user/${encodeURIComponent(userId)}/frozen-status`;
+    let response;
+    try {
+        response = await globalThis.fetch(url, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to get user frozen status: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    let json;
+    try {
+        const responseJson = await response.json();
+        json = responseJson;
+    }
+    catch (error) {
+        throw new ApiError(`Failed to parse frozen status response: ${error instanceof Error ? error.message : "Invalid JSON"}`, response.status);
+    }
+    // Handle API errors
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string" ? json.msg : "Failed to get frozen status";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+    // Validate response structure
+    if (!json.data || json.data.user_id === undefined) {
+        throw new ApiError("Invalid frozen status response: missing required data", response.status);
+    }
+    return json.data;
+}