uapi-browser-sdk 0.1.12 → 0.1.13

package/dist/src/errors.js

@@ -0,0 +1,247 @@
+export class UapiError extends Error {
+    constructor(code, status, message, details, payload, meta) {
+        super(`[${status}] ${code}: ${message}`);
+        this.code = code;
+        this.status = status;
+        this.details = details;
+        this.payload = payload;
+        this.meta = meta;
+    }
+}
+export class ApiErrorError extends UapiError {
+}
+export class AvatarNotFoundError extends UapiError {
+}
+export class ConversionFailedError extends UapiError {
+}
+export class FileOpenErrorError extends UapiError {
+}
+export class FileRequiredError extends UapiError {
+}
+export class InsufficientCreditsError extends UapiError {
+}
+export class InternalServerErrorError extends UapiError {
+}
+export class InvalidParameterError extends UapiError {
+}
+export class InvalidParamsError extends UapiError {
+}
+export class NotFoundError extends UapiError {
+}
+export class NoMatchError extends UapiError {
+}
+export class NoTrackingDataError extends UapiError {
+}
+export class PhoneInfoFailedError extends UapiError {
+}
+export class RecognitionFailedError extends UapiError {
+}
+export class RequestEntityTooLargeError extends UapiError {
+}
+export class ServiceBusyError extends UapiError {
+}
+export class TimezoneNotFoundError extends UapiError {
+}
+export class UnauthorizedError extends UapiError {
+}
+export class UnsupportedCarrierError extends UapiError {
+}
+export class UnsupportedFormatError extends UapiError {
+}
+export class VisitorMonthlyQuotaExhaustedError extends UapiError {
+}
+function defaultCode(status) {
+    switch (status) {
+        case 400:
+            return 'INVALID_PARAMETER';
+        case 401:
+            return 'UNAUTHORIZED';
+        case 402:
+            return 'INSUFFICIENT_CREDITS';
+        case 404:
+            return 'NOT_FOUND';
+        case 413:
+            return 'REQUEST_ENTITY_TOO_LARGE';
+        case 429:
+            return 'SERVICE_BUSY';
+        case 500:
+            return 'INTERNAL_SERVER_ERROR';
+        default:
+            return 'API_ERROR';
+    }
+}
+function toHeaderMap(headers) {
+    const out = {};
+    if (!headers) {
+        return out;
+    }
+    if (typeof headers.forEach === 'function') {
+        ;
+        headers.forEach((value, key) => {
+            out[String(key).toLowerCase()] = String(value);
+        });
+        return out;
+    }
+    for (const [rawKey, rawValue] of Object.entries(headers)) {
+        if (rawValue === undefined || rawValue === null) {
+            continue;
+        }
+        out[String(rawKey).toLowerCase()] = String(rawValue);
+    }
+    return out;
+}
+function parseNumber(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseBoolean(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'true') {
+        return true;
+    }
+    if (normalized === 'false') {
+        return false;
+    }
+    return undefined;
+}
+function unquote(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function parseStructuredItems(raw) {
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .map((item) => {
+        const segments = item.split(';').map((segment) => segment.trim()).filter(Boolean);
+        const [head, ...rest] = segments;
+        const params = {};
+        for (const segment of rest) {
+            const eq = segment.indexOf('=');
+            if (eq <= 0) {
+                continue;
+            }
+            const key = segment.slice(0, eq).trim();
+            const value = unquote(segment.slice(eq + 1));
+            params[key] = value;
+        }
+        return { name: unquote(head), params };
+    });
+}
+export function extractMetaFromHeaders(headers) {
+    const rawHeaders = toHeaderMap(headers);
+    const rateLimitPolicies = {};
+    const rateLimits = {};
+    for (const item of parseStructuredItems(rawHeaders['ratelimit-policy'])) {
+        rateLimitPolicies[item.name] = {
+            name: item.name,
+            quota: parseNumber(item.params.q),
+            unit: item.params['uapi-unit'],
+            windowSeconds: parseNumber(item.params.w),
+        };
+    }
+    for (const item of parseStructuredItems(rawHeaders['ratelimit'])) {
+        rateLimits[item.name] = {
+            name: item.name,
+            remaining: parseNumber(item.params.r),
+            unit: item.params['uapi-unit'],
+            resetAfterSeconds: parseNumber(item.params.t),
+        };
+    }
+    return {
+        requestId: rawHeaders['x-request-id'],
+        retryAfterSeconds: parseNumber(rawHeaders['retry-after']),
+        debitStatus: rawHeaders['uapi-debit-status'],
+        creditsRequested: parseNumber(rawHeaders['uapi-credits-requested']),
+        creditsCharged: parseNumber(rawHeaders['uapi-credits-charged']),
+        creditsPricing: rawHeaders['uapi-credits-pricing'],
+        activeQuotaBuckets: parseNumber(rawHeaders['uapi-quota-active-buckets']),
+        stopOnEmpty: parseBoolean(rawHeaders['uapi-stop-on-empty']),
+        rateLimitPolicyRaw: rawHeaders['ratelimit-policy'],
+        rateLimitRaw: rawHeaders['ratelimit'],
+        rateLimitPolicies,
+        rateLimits,
+        balanceLimitCents: rateLimitPolicies['billing-balance']?.quota,
+        balanceRemainingCents: rateLimits['billing-balance']?.remaining,
+        quotaLimitCredits: rateLimitPolicies['billing-quota']?.quota,
+        quotaRemainingCredits: rateLimits['billing-quota']?.remaining,
+        visitorQuotaLimitCredits: rateLimitPolicies['visitor-quota']?.quota,
+        visitorQuotaRemainingCredits: rateLimits['visitor-quota']?.remaining,
+        rawHeaders,
+    };
+}
+function pickDetails(body) {
+    if (!body || typeof body !== 'object') {
+        return undefined;
+    }
+    const payload = body;
+    if (payload.details !== undefined) {
+        return payload.details;
+    }
+    if (payload.quota !== undefined) {
+        return payload.quota;
+    }
+    if (payload.docs !== undefined) {
+        return payload.docs;
+    }
+    return undefined;
+}
+export function mapError(res, body) {
+    const payload = body && typeof body === 'object' ? body : undefined;
+    const code = String(payload?.code || payload?.error || defaultCode(res.status)).toUpperCase();
+    const message = payload?.message ||
+        payload?.errMsg ||
+        (typeof body === 'string' ? body : '') ||
+        res.statusText ||
+        'Request failed';
+    const meta = extractMetaFromHeaders(res.headers);
+    const table = {
+        "API_ERROR": ApiErrorError,
+        "AVATAR_NOT_FOUND": AvatarNotFoundError,
+        "CONVERSION_FAILED": ConversionFailedError,
+        "FILE_OPEN_ERROR": FileOpenErrorError,
+        "FILE_REQUIRED": FileRequiredError,
+        "INSUFFICIENT_CREDITS": InsufficientCreditsError,
+        "INTERNAL_SERVER_ERROR": InternalServerErrorError,
+        "INVALID_PARAMETER": InvalidParameterError,
+        "INVALID_PARAMS": InvalidParamsError,
+        "NOT_FOUND": NotFoundError,
+        "NO_MATCH": NoMatchError,
+        "NO_TRACKING_DATA": NoTrackingDataError,
+        "PHONE_INFO_FAILED": PhoneInfoFailedError,
+        "RECOGNITION_FAILED": RecognitionFailedError,
+        "REQUEST_ENTITY_TOO_LARGE": RequestEntityTooLargeError,
+        "SERVICE_BUSY": ServiceBusyError,
+        "TIMEZONE_NOT_FOUND": TimezoneNotFoundError,
+        "UNAUTHORIZED": UnauthorizedError,
+        "UNSUPPORTED_CARRIER": UnsupportedCarrierError,
+        "UNSUPPORTED_FORMAT": UnsupportedFormatError,
+        "VISITOR_MONTHLY_QUOTA_EXHAUSTED": VisitorMonthlyQuotaExhaustedError,
+    };
+    const fallback = res.status === 401
+        ? UnauthorizedError
+        : res.status === 402
+            ? InsufficientCreditsError
+            : res.status === 404
+                ? NotFoundError
+                : res.status === 429
+                    ? ServiceBusyError
+                    : res.status >= 500
+                        ? InternalServerErrorError
+                        : UapiError;
+    const Ctor = table[code] || fallback;
+    return new Ctor(code, res.status, message, pickDetails(payload), payload ?? body, meta);
+}

package/dist/src/index.d.ts

@@ -1,10 +1,7 @@
 import type * as Internal from '../internal/src/index.js';
-export declare class UapiError extends Error {
-    code: string;
-    status: number;
-    details?: unknown | undefined;
-    constructor(code: string, status: number, details?: unknown | undefined);
-}
+import { type ResponseMeta } from './errors.js';
+export { UapiError, mapError, extractMetaFromHeaders } from './errors.js';
+export type { RateLimitPolicyEntry, RateLimitStateEntry, ResponseMeta } from './errors.js';
 export type GetClipzyGetResponse = Internal.GetClipzyGet200Response;
 export interface GetClipzyGetArgs {
     /** 片段的唯一 ID。 */
@@ -711,6 +708,7 @@ export interface PostSearchAggregateArgs {
 export declare class UapiClient {
     private baseURL;
     private token?;
+    private _lastResponseMeta?;
     readonly clipzyZaiXianJianTieBan: ClipzyZaiXianJianTieBanApi;
     readonly "Clipzy 在线剪贴板": ClipzyZaiXianJianTieBanApi;
     readonly convert: ConvertApi;
@@ -744,6 +742,7 @@ export declare class UapiClient {
     readonly zhiNengSouSuo: ZhiNengSouSuoApi;
     readonly "智能搜索": ZhiNengSouSuoApi;
     constructor(baseURL: string, token?: string);
+    get lastResponseMeta(): ResponseMeta | undefined;
     _request(method: string, path: string, params?: Record<string, unknown>, body?: Record<string, unknown>, headers?: Record<string, string>, responseKind?: 'json' | 'text' | 'arrayBuffer'): Promise<any>;
 }
 export declare class ClipzyZaiXianJianTieBanApi {

package/dist/src/index.js

@@ -1,11 +1,5 @@
-export class UapiError extends Error {
-    constructor(code, status, details) {
-        super(`${status} ${code}`);
-        this.code = code;
-        this.status = status;
-        this.details = details;
-    }
-}
+import { extractMetaFromHeaders, mapError } from './errors.js';
+export { UapiError, mapError, extractMetaFromHeaders } from './errors.js';
 export class UapiClient {
     constructor(baseURL, token) {
         this.baseURL = baseURL;
@@ -59,6 +53,9 @@ export class UapiClient {
         this.zhiNengSouSuo = zhiNengSouSuo;
         this["智能搜索"] = zhiNengSouSuo;
     }
+    get lastResponseMeta() {
+        return this._lastResponseMeta;
+    }
     async _request(method, path, params, body, headers, responseKind = 'json') {
         const url = new URL(this.baseURL.replace(/\/$/, '') + path);
         if (params) {
@@ -83,9 +80,11 @@ export class UapiClient {
                 data = await res.json();
             }
             catch { }
-            const code = typeof data === 'object' && data && 'code' in data ? String(data.code ?? 'API_ERROR').toUpperCase() : 'API_ERROR';
-            throw new UapiError(code, res.status, data);
+            const mapped = mapError(res, data);
+            this._lastResponseMeta = mapped.meta;
+            throw mapped;
         }
+        this._lastResponseMeta = extractMetaFromHeaders(res.headers);
         if (responseKind === 'arrayBuffer') {
             return res.arrayBuffer();
         }

package/internal/.openapi-generator/VERSION

@@ -1 +1 @@
-7.21.0
+7.17.0

package/internal/src/apis/ClipzyApi.ts

@@ -65,9 +65,10 @@ export interface PostClipzyStoreOperationRequest {
 export class ClipzyApi extends runtime.BaseAPI {
 
     /**
-     * Creates request options for getClipzyGet without sending the request
+     * **此接口用于“最高安全等级”方法。**  您提供第一步中获得的ID，它会返回存储在服务器上的**加密数据**。您需要在自己的客户端中，使用您自己保管的密钥来解密它。
+     * 步骤2 (方法一): 获取加密数据
      */
-    async getClipzyGetRequestOpts(requestParameters: GetClipzyGetRequest): Promise<runtime.RequestOpts> {
+    async getClipzyGetRaw(requestParameters: GetClipzyGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetClipzyGet200Response>> {
         if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
                 'id',
@@ -86,21 +87,12 @@ export class ClipzyApi extends runtime.BaseAPI {
 
         let urlPath = `/api/get`;
 
-        return {
+        const response = await this.request({
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        };
-    }
-
-    /**
-     * **此接口用于“最高安全等级”方法。**  您提供第一步中获得的ID，它会返回存储在服务器上的**加密数据**。您需要在自己的客户端中，使用您自己保管的密钥来解密它。
-     * 步骤2 (方法一): 获取加密数据
-     */
-    async getClipzyGetRaw(requestParameters: GetClipzyGetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetClipzyGet200Response>> {
-        const requestOptions = await this.getClipzyGetRequestOpts(requestParameters);
-        const response = await this.request(requestOptions, initOverrides);
+        }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => GetClipzyGet200ResponseFromJSON(jsonValue));
     }
@@ -115,9 +107,10 @@ export class ClipzyApi extends runtime.BaseAPI {
     }
 
     /**
-     * Creates request options for getClipzyRaw without sending the request
+     * **此接口用于“方便自动化”方法。**  您提供第一步获得的ID，并附上您自己保管的**解密密钥**作为 `key` 参数。服务器会直接为您解密，并返回纯文本内容。  > [!IMPORTANT] > 查看文档首页的 **cURL 示例**，了解此接口最典型的用法。
+     * 步骤2 (方法二): 获取原始文本
      */
-    async getClipzyRawRequestOpts(requestParameters: GetClipzyRawRequest): Promise<runtime.RequestOpts> {
+    async getClipzyRawRaw(requestParameters: GetClipzyRawRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
         if (requestParameters['id'] == null) {
             throw new runtime.RequiredError(
                 'id',
@@ -144,21 +137,12 @@ export class ClipzyApi extends runtime.BaseAPI {
         let urlPath = `/api/raw/{id}`;
         urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
 
-        return {
+        const response = await this.request({
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        };
-    }
-
-    /**
-     * **此接口用于“方便自动化”方法。**  您提供第一步获得的ID，并附上您自己保管的**解密密钥**作为 `key` 参数。服务器会直接为您解密，并返回纯文本内容。  > [!IMPORTANT] > 查看文档首页的 **cURL 示例**，了解此接口最典型的用法。
-     * 步骤2 (方法二): 获取原始文本
-     */
-    async getClipzyRawRaw(requestParameters: GetClipzyRawRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
-        const requestOptions = await this.getClipzyRawRequestOpts(requestParameters);
-        const response = await this.request(requestOptions, initOverrides);
+        }, initOverrides);
 
         if (this.isJsonMime(response.headers.get('content-type'))) {
             return new runtime.JSONApiResponse<string>(response);
@@ -177,9 +161,10 @@ export class ClipzyApi extends runtime.BaseAPI {
     }
 
     /**
-     * Creates request options for postClipzyStore without sending the request
+     * 这是所有流程的第一步。您的客户端应用需要先在本地准备好 **加密后的数据**，然后调用此接口进行上传。成功后，您会得到一个用于后续操作的唯一ID。  > [!NOTE] > 您发送给此接口的应该是**密文**，而不是原始文本。请参考文档首页的JavaScript示例来了解如何在客户端进行加密。
+     * 步骤1：上传加密数据
      */
-    async postClipzyStoreRequestOpts(requestParameters: PostClipzyStoreOperationRequest): Promise<runtime.RequestOpts> {
+    async postClipzyStoreRaw(requestParameters: PostClipzyStoreOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PostClipzyStore200Response>> {
         if (requestParameters['postClipzyStoreRequest'] == null) {
             throw new runtime.RequiredError(
                 'postClipzyStoreRequest',
@@ -196,22 +181,13 @@ export class ClipzyApi extends runtime.BaseAPI {
 
         let urlPath = `/api/store`;
 
-        return {
+        const response = await this.request({
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: PostClipzyStoreRequestToJSON(requestParameters['postClipzyStoreRequest']),
-        };
-    }
-
-    /**
-     * 这是所有流程的第一步。您的客户端应用需要先在本地准备好 **加密后的数据**，然后调用此接口进行上传。成功后，您会得到一个用于后续操作的唯一ID。  > [!NOTE] > 您发送给此接口的应该是**密文**，而不是原始文本。请参考文档首页的JavaScript示例来了解如何在客户端进行加密。
-     * 步骤1：上传加密数据
-     */
-    async postClipzyStoreRaw(requestParameters: PostClipzyStoreOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PostClipzyStore200Response>> {
-        const requestOptions = await this.postClipzyStoreRequestOpts(requestParameters);
-        const response = await this.request(requestOptions, initOverrides);
+        }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => PostClipzyStore200ResponseFromJSON(jsonValue));
     }

package/internal/src/apis/ConvertApi.ts

@@ -48,9 +48,10 @@ export interface PostConvertJsonOperationRequest {
 export class ConvertApi extends runtime.BaseAPI {
 
     /**
-     * Creates request options for getConvertUnixtime without sending the request
+     * 时间戳和日期字符串，哪个用着更顺手？别纠结了，这个接口让你轻松拥有两种格式！  ## 功能概述 这是一个非常智能的转换器。你给它一个 Unix 时间戳，它还你一个人类可读的日期时间；你给它一个日期时间字符串，它还你一个 Unix 时间戳。它会自动识别你输入的是哪种格式。  ## 使用须知 这个接口非常智能，能够自动识别输入格式：  - **输入时间戳**：支持10位秒级（如 `1672531200`）和13位毫秒级（如 `1672531200000`）。 - **输入日期字符串**：为了确保准确性，推荐使用 `YYYY-MM-DD HH:mm:ss` 标准格式（如 `2023-01-01 08:00:00`）。  > [!TIP] > 无论你输入哪种格式，响应中都会同时包含标准日期字符串和秒级Unix时间戳，方便你按需取用。  ## 错误处理指南 - **400 Bad Request**: 如果你提供的 `time` 参数既不是有效的时间戳，也不是我们支持的日期格式，就会收到这个错误。请检查你的输入值。
+     * 时间戳转换
      */
-    async getConvertUnixtimeRequestOpts(requestParameters: GetConvertUnixtimeRequest): Promise<runtime.RequestOpts> {
+    async getConvertUnixtimeRaw(requestParameters: GetConvertUnixtimeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetConvertUnixtime200Response>> {
         if (requestParameters['time'] == null) {
             throw new runtime.RequiredError(
                 'time',
@@ -69,21 +70,12 @@ export class ConvertApi extends runtime.BaseAPI {
 
         let urlPath = `/convert/unixtime`;
 
-        return {
+        const response = await this.request({
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        };
-    }
-
-    /**
-     * 时间戳和日期字符串，哪个用着更顺手？别纠结了，这个接口让你轻松拥有两种格式！  ## 功能概述 这是一个非常智能的转换器。你给它一个 Unix 时间戳，它还你一个人类可读的日期时间；你给它一个日期时间字符串，它还你一个 Unix 时间戳。它会自动识别你输入的是哪种格式。  ## 使用须知 这个接口非常智能，能够自动识别输入格式：  - **输入时间戳**：支持10位秒级（如 `1672531200`）和13位毫秒级（如 `1672531200000`）。 - **输入日期字符串**：为了确保准确性，推荐使用 `YYYY-MM-DD HH:mm:ss` 标准格式（如 `2023-01-01 08:00:00`）。  > [!TIP] > 无论你输入哪种格式，响应中都会同时包含标准日期字符串和秒级Unix时间戳，方便你按需取用。  ## 错误处理指南 - **400 Bad Request**: 如果你提供的 `time` 参数既不是有效的时间戳，也不是我们支持的日期格式，就会收到这个错误。请检查你的输入值。
-     * 时间戳转换
-     */
-    async getConvertUnixtimeRaw(requestParameters: GetConvertUnixtimeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetConvertUnixtime200Response>> {
-        const requestOptions = await this.getConvertUnixtimeRequestOpts(requestParameters);
-        const response = await this.request(requestOptions, initOverrides);
+        }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => GetConvertUnixtime200ResponseFromJSON(jsonValue));
     }
@@ -98,9 +90,10 @@ export class ConvertApi extends runtime.BaseAPI {
     }
 
     /**
-     * Creates request options for postConvertJson without sending the request
+     * 还在为一团乱麻的 JSON 字符串头疼吗？这个接口能瞬间让它变得井井有条，赏心悦目。  ## 功能概述 你只需要提供一个原始的、可能是压缩过的或者格式混乱的 JSON 字符串，这个 API 就会返回一个经过美化（带标准缩进和换行）的版本。这在调试 API 响应、或者需要在前端界面清晰展示 JSON 数据时非常有用。  ## 使用须知 > [!NOTE] > **请求格式** > 请注意，待格式化的 JSON 字符串需要被包裹在另一个 JSON 对象中，作为 `content` 字段的值提交。具体格式请参考请求体示例。  ## 错误处理指南 - **400 Bad Request**: 最常见的原因是你提供的 `content` 字符串本身不是一个有效的 JSON。请仔细检查括号、引号是否正确闭合，或者有没有多余的逗号等语法错误。
+     * JSON 格式化
      */
-    async postConvertJsonRequestOpts(requestParameters: PostConvertJsonOperationRequest): Promise<runtime.RequestOpts> {
+    async postConvertJsonRaw(requestParameters: PostConvertJsonOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PostConvertJson200Response>> {
         if (requestParameters['postConvertJsonRequest'] == null) {
             throw new runtime.RequiredError(
                 'postConvertJsonRequest',
@@ -117,22 +110,13 @@ export class ConvertApi extends runtime.BaseAPI {
 
         let urlPath = `/convert/json`;
 
-        return {
+        const response = await this.request({
             path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: PostConvertJsonRequestToJSON(requestParameters['postConvertJsonRequest']),
-        };
-    }
-
-    /**
-     * 还在为一团乱麻的 JSON 字符串头疼吗？这个接口能瞬间让它变得井井有条，赏心悦目。  ## 功能概述 你只需要提供一个原始的、可能是压缩过的或者格式混乱的 JSON 字符串，这个 API 就会返回一个经过美化（带标准缩进和换行）的版本。这在调试 API 响应、或者需要在前端界面清晰展示 JSON 数据时非常有用。  ## 使用须知 > [!NOTE] > **请求格式** > 请注意，待格式化的 JSON 字符串需要被包裹在另一个 JSON 对象中，作为 `content` 字段的值提交。具体格式请参考请求体示例。  ## 错误处理指南 - **400 Bad Request**: 最常见的原因是你提供的 `content` 字符串本身不是一个有效的 JSON。请仔细检查括号、引号是否正确闭合，或者有没有多余的逗号等语法错误。
-     * JSON 格式化
-     */
-    async postConvertJsonRaw(requestParameters: PostConvertJsonOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PostConvertJson200Response>> {
-        const requestOptions = await this.postConvertJsonRequestOpts(requestParameters);
-        const response = await this.request(requestOptions, initOverrides);
+        }, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => PostConvertJson200ResponseFromJSON(jsonValue));
     }

package/internal/src/apis/DailyApi.ts

@@ -31,9 +31,10 @@ import {
 export class DailyApi extends runtime.BaseAPI {
 
     /**
-     * Creates request options for getDailyNewsImage without sending the request
+     * 想用一张图快速了解天下大事？这个接口为你一键生成今日新闻摘要，非常适合用在早报、数字看板或应用首页等场景。  ## 功能概述 此接口会实时抓取各大平台的热点新闻，并动态地将它们渲染成一张清晰、美观的摘要图片。你调用接口，直接就能得到一张可以展示的图片。  ## 使用须知 调用此接口时，请务必注意以下两点：  1.  **响应格式是图片**：接口成功时直接返回 `image/jpeg` 格式的二进制数据，而非 JSON。请确保你的客户端能正确处理二进制流，例如直接在 `<img>` 标签中显示，或保存为 `.jpg` 文件。  2.  **设置合理超时**：由于涉及实时新闻抓取和图片渲染，处理过程可能耗时数秒。建议将客户端请求超时时间设置为至少10秒，以防止因等待过久而失败。  > [!IMPORTANT] > 未能正确处理图片响应或超时设置过短，是导致调用失败的最常见原因。
+     * 每日新闻图
      */
-    async getDailyNewsImageRequestOpts(): Promise<runtime.RequestOpts> {
+    async getDailyNewsImageRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blob>> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -41,21 +42,12 @@ export class DailyApi extends runtime.BaseAPI {
 
         let urlPath = `/daily/news-image`;
 
-        return {
+        const response = await this.request({
             path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        };
-    }
-
-    /**
-     * 想用一张图快速了解天下大事？这个接口为你一键生成今日新闻摘要，非常适合用在早报、数字看板或应用首页等场景。  ## 功能概述 此接口会实时抓取各大平台的热点新闻，并动态地将它们渲染成一张清晰、美观的摘要图片。你调用接口，直接就能得到一张可以展示的图片。  ## 使用须知 调用此接口时，请务必注意以下两点：  1.  **响应格式是图片**：接口成功时直接返回 `image/jpeg` 格式的二进制数据，而非 JSON。请确保你的客户端能正确处理二进制流，例如直接在 `<img>` 标签中显示，或保存为 `.jpg` 文件。  2.  **设置合理超时**：由于涉及实时新闻抓取和图片渲染，处理过程可能耗时数秒。建议将客户端请求超时时间设置为至少10秒，以防止因等待过久而失败。  > [!IMPORTANT] > 未能正确处理图片响应或超时设置过短，是导致调用失败的最常见原因。
-     * 每日新闻图
-     */
-    async getDailyNewsImageRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blob>> {
-        const requestOptions = await this.getDailyNewsImageRequestOpts();
-        const response = await this.request(requestOptions, initOverrides);
+        }, initOverrides);
 
         return new runtime.BlobApiResponse(response);
     }