import type { RequestParams, Success, Fail } from './types';
/**
 * 解析 H5 环境下的 SSE 数据流
 * @param {Object} params - 参数对象
 * @param {Function} params.success - 成功回调函数
 * @param {Function} params.fail - 失败回调函数
 * @param {Function} params.complete - 完成回调函数
 * @param {Response} params.response - 响应对象
 * @returns {Promise} 返回一个 Promise，处理 SSE 数据流
 * @example
 * ```ts
 * const response = await fetch('/api/sse', { method: 'POST' });
 * await parseSSEChunkInH5({
 *   response,
 *   success: (chunk, line) => console.log(chunk),
 *   fail: ({ response }) => console.error(response.status),
 *   complete: () => console.log('finish'),
 * });
 * ```
 */
export declare const parseSSEChunkInH5: ({ success, fail, complete, response, }: {
    success: RequestParams['success'];
    fail: RequestParams['fail'];
    complete: RequestParams['complete'];
    response: Response;
}) => Promise<void>;
/**
 * 在 H5 环境下发起 SSE 请求的核心函数
 * @param {Object} params - 参数对象
 * @param {string} params.url - 请求 URL
 * @param {any} params.data - 请求数据
 * @param {Function} params.success - 成功回调函数
 * @param {Function} params.fail - 失败回调函数
 * @param {Function} params.complete - 完成回调函数
 * @returns {Promise} 返回一个 Promise，包含响应对象
 * @example
 * ```ts
 * fetchSSECoreInH5({
 *   url: 'https://example.com/sse',
 *   data: { input: 'hello' },
 *   success: (chunk) => console.log(chunk),
 *   fail: ({ response }) => console.error('failed'),
 *   complete: () => console.log('done'),
 * });
 * ```
 */
export declare function fetchSSECoreInH5({ url, data, success, fail, complete, }: Pick<RequestParams, 'url' | 'data' | 'success' | 'fail' | 'complete'>): Promise<unknown>;
/**
 * 解析 MP 环境下的 SSE 数据块
 * @param {Object} params - 参数对象
 * @param {string} params.chunk - 数据块
 * @param {Fail} [params.fail] - 失败回调函数
 * @param {Success} [params.success] - 成功回调函数
 * @example
 * ```ts
 * parseSSEChunkInMP({
 *   chunk: 'data: hello\ndata: world\n',
 *   success: (data, line) => console.log(data),
 *   fail: () => console.error('parse error'),
 * });
 * ```
 */
export declare const parseSSEChunkInMP: ({ chunk, fail, success, }: {
    chunk: string;
    fail?: Fail | undefined;
    success?: Success | undefined;
}) => void;
/**
 * 在 MP 环境下发起 SSE 请求的核心函数
 * @param {RequestParams} params - 请求参数
 * @returns {Promise} 返回一个 Promise，包含请求任务对象
 * @example
 * ```ts
 * fetchSSECoreInMP({
 *   url: 'https://example.com/sse',
 *   data: { input: 'hello' },
 *   success: (data) => console.log(data),
 *   fail: (err) => console.error(err),
 *   complete: () => console.log('done'),
 *   isTestEnv: () => false,
 * });
 * ```
 */
export declare function fetchSSECoreInMP({ url, data, success, fail, complete, isTestEnv, }: RequestParams): Promise<unknown>;
/**
 * 发起 SSE 请求的核心函数，根据环境自动选择 H5 或 MP 实现
 * @param {RequestParams} params - 请求参数
 * @param {string} params.url - 请求地址
 * @param {Object} params.data - 请求数据
 * @param {Function} params.success - 成功回调
 * @param {Function} params.fail - 失败回调
 * @param {Function} params.complete - 完成回调
 * @returns {Promise} 返回一个 Promise，包含请求任务或响应对象
 * @example
 * ```ts
 * import { safeJsonParse } from 't-comm/es/json';
 *
 * import { fetchSSECore, type RequestParams } from 't-comm/es/sse';
 *
 * // 检查是否结束，业务自定义
 * function checkFinish(str) {
 *   const data: any = safeJsonParse(str);
 *   return data?.status === 3;
 * }
 *
 * // 业务二次封装，把自己的请求数据、自定义的处理数据的逻辑放进去
 * export function sendChatMessage({
 *   input,
 *   sessionId,
 *   extraInfo,
 *   expectedOp,
 *
 *   success,
 *   fail,
 *   complete,
 * }: {
 *   input: string;
 *   sessionId?: string;
 *   extraInfo?: string;
 *   expectedOp?: Record<string, any>;
 *
 *   success?: (data: any) => void;
 *   fail?: RequestParams['fail'];
 *   complete?: RequestParams['complete'];
 * }) {
 *   const origin = isTestEnv() ? 'https://xx.com' : 'https://xx.com';
 *   const url = `${origin}/xx.xx.xx.xx/xx?g_app_tk=${cookie.get('tip_token')}&tstamp=${Date.now()}`;
 *   const reqData = {
 *     input,
 *     session_id: sessionId,
 *     extra_info: extraInfo,
 *     expected_op: expectedOp,
 *   };
 *
 *   const parsedSuccess = (str, fullStr) => {
 *     const data: any = safeJsonParse(str);
 *     const fullData: any = safeJsonParse(fullStr);
 *
 *     if (checkFinish(str)) {
 *       complete?.(str);
 *       return;
 *     }
 *
 *     // 检查是否失败，业务自定义
 *     if (fullData?.err_msg) {
 *       fail?.(data);
 *       return;
 *     }
 *
 *     success?.(data);
 *   };
 *
 *   return fetchSSECore({
 *     url,
 *     data: reqData,
 *     success: parsedSuccess,
 *     fail,
 *     complete,
 *     isTestEnv,
 *   });
 * }
 *
 * ```
 */
export declare function fetchSSECore({ url, data, success, fail, complete, isTestEnv, }: RequestParams): Promise<unknown>;
