qing-client 0.0.38 → 0.0.40

package/lib/client/BaseClient.js

@@ -163,6 +163,7 @@ class BaseClient {
             case "providers": return this.config.providerServiceUrl;
             case "org": return this.config.orgServiceUrl; // 组织感知服务
             case "gateway-h5": return this.config.gatewayH5ServiceUrl;
+            case "ez-ability": return this.config.ezAbilityServiceUrl; // EzAI 能力服务
             default: throw new Error(`Unsupported service: ${this.serviceName}`);
         }
     }

package/lib/client/index.d.ts

@@ -9,6 +9,8 @@ import { ProviderService } from "../service/ProviderService";
 import { UsageService } from "../service/UsageService";
 import { FrontHostService } from "../service/FrontHostService";
 import { OrgService } from "../service/OrgService";
+import { DeliveryStreamService } from "../service/DeliveryStreamService";
+import { EzAbilityService } from "../service/EzAbilityService";
 import { ClientConfig, UserContext } from "../types";
 export declare class Client {
     protected config: ClientConfig;
@@ -23,6 +25,8 @@ export declare class Client {
     readonly usage: UsageService;
     readonly frontHost: FrontHostService;
     readonly org: OrgService;
+    readonly deliveryStream: DeliveryStreamService;
+    readonly ezAbility: EzAbilityService;
     protected isFrontendMode: boolean;
     constructor(config: ClientConfig);
     setUserContext(context: UserContext): this;

package/lib/client/index.js

@@ -12,6 +12,8 @@ const ProviderService_1 = require("../service/ProviderService");
 const UsageService_1 = require("../service/UsageService");
 const FrontHostService_1 = require("../service/FrontHostService");
 const OrgService_1 = require("../service/OrgService");
+const DeliveryStreamService_1 = require("../service/DeliveryStreamService");
+const EzAbilityService_1 = require("../service/EzAbilityService");
 class Client {
     constructor(config) {
         this.config = config;
@@ -27,6 +29,8 @@ class Client {
         this.usage = new UsageService_1.UsageService(config);
         this.frontHost = new FrontHostService_1.FrontHostService(config);
         this.org = new OrgService_1.OrgService(config);
+        this.deliveryStream = new DeliveryStreamService_1.DeliveryStreamService(config);
+        this.ezAbility = new EzAbilityService_1.EzAbilityService(config);
     }
     // 后端模式：设置用户上下文
     setUserContext(context) {
@@ -42,6 +46,8 @@ class Client {
             this.usage.setUserContext(context);
             this.frontHost.setUserContext(context);
             this.org.setUserContext(context);
+            this.deliveryStream.setUserContext(context);
+            this.ezAbility.setUserContext(context);
         }
         else {
             console.warn("setUserContext() 仅在后端模式下有效");
@@ -62,6 +68,8 @@ class Client {
             this.usage.setProjectId(projectId);
             this.frontHost.setProjectId(projectId);
             this.org.setProjectId(projectId);
+            this.deliveryStream.setProjectId(projectId);
+            this.ezAbility.setProjectId(projectId);
         }
         else {
             console.warn("setProjectId() 仅在前端模式下有效");
@@ -82,6 +90,8 @@ class Client {
             this.usage.setAppId(appId);
             this.frontHost.setAppId(appId);
             this.org.setAppId(appId);
+            this.deliveryStream.setAppId(appId);
+            this.ezAbility.setAppId(appId);
         }
         else {
             console.warn("setAppId() 仅在前端模式下有效");
@@ -102,6 +112,8 @@ class Client {
             this.usage.setProjectAndApp(projectId, appId);
             this.frontHost.setProjectAndApp(projectId, appId);
             this.org.setProjectAndApp(projectId, appId);
+            this.deliveryStream.setProjectAndApp(projectId, appId);
+            this.ezAbility.setProjectAndApp(projectId, appId);
         }
         else {
             console.warn("setProjectAndApp() 仅在前端模式下有效");
@@ -121,6 +133,8 @@ class Client {
         await this.usage.setToken(token);
         await this.frontHost.setToken(token);
         await this.org.setToken(token);
+        await this.deliveryStream.setToken(token);
+        await this.ezAbility.setToken(token);
     }
     // 清除认证令牌（两种模式都需要）
     async clearToken() {
@@ -135,6 +149,8 @@ class Client {
         await this.usage.clearToken();
         await this.frontHost.clearToken();
         await this.org.clearToken();
+        await this.deliveryStream.clearToken();
+        await this.ezAbility.clearToken();
     }
 }
 exports.Client = Client;

package/lib/index.d.ts

@@ -10,6 +10,8 @@ export { FrontHostService } from "./service/FrontHostService";
 export { ProviderService } from "./service/ProviderService";
 export { UsageService } from "./service/UsageService";
 export { OrgService } from "./service/OrgService";
+export { DeliveryStreamService } from "./service/DeliveryStreamService";
+export { EzAbilityService } from "./service/EzAbilityService";
 export * from './types';
 export * from './types/msg';
 export * from './types/token';
@@ -23,3 +25,5 @@ export { BaseClient } from './client/BaseClient';
 export * from "./types/provider";
 export * from "./types/usage";
 export * from "./types/org";
+export * from "./types/delivery-stream";
+export * from "./types/ez-ability";

package/lib/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseClient = exports.OrgService = exports.UsageService = exports.ProviderService = exports.FrontHostService = exports.AuditLogService = exports.AigcService = exports.FileService = exports.UserService = exports.TokenService = exports.MsgService = exports.AuthService = exports.Client = void 0;
+exports.BaseClient = exports.EzAbilityService = exports.DeliveryStreamService = exports.OrgService = exports.UsageService = exports.ProviderService = exports.FrontHostService = exports.AuditLogService = exports.AigcService = exports.FileService = exports.UserService = exports.TokenService = exports.MsgService = exports.AuthService = exports.Client = void 0;
 // 导出核心客户端类
 var client_1 = require("./client");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
@@ -41,6 +41,10 @@ var UsageService_1 = require("./service/UsageService");
 Object.defineProperty(exports, "UsageService", { enumerable: true, get: function () { return UsageService_1.UsageService; } });
 var OrgService_1 = require("./service/OrgService");
 Object.defineProperty(exports, "OrgService", { enumerable: true, get: function () { return OrgService_1.OrgService; } });
+var DeliveryStreamService_1 = require("./service/DeliveryStreamService");
+Object.defineProperty(exports, "DeliveryStreamService", { enumerable: true, get: function () { return DeliveryStreamService_1.DeliveryStreamService; } });
+var EzAbilityService_1 = require("./service/EzAbilityService");
+Object.defineProperty(exports, "EzAbilityService", { enumerable: true, get: function () { return EzAbilityService_1.EzAbilityService; } });
 // 导出所有类型定义
 __exportStar(require("./types"), exports);
 __exportStar(require("./types/msg"), exports);
@@ -55,3 +59,5 @@ Object.defineProperty(exports, "BaseClient", { enumerable: true, get: function (
 __exportStar(require("./types/provider"), exports);
 __exportStar(require("./types/usage"), exports);
 __exportStar(require("./types/org"), exports);
+__exportStar(require("./types/delivery-stream"), exports);
+__exportStar(require("./types/ez-ability"), exports);

package/lib/service/DeliveryStreamService.d.ts

@@ -0,0 +1,80 @@
+import { BaseClient } from "../client/BaseClient";
+import { ClientConfig, RequestOptions, PaginatedResponse } from "../types";
+import { Stream, CreateStreamRequest, UpdateStreamRequest, StreamListQuery, Requirement, CreateRequirementRequest, UpdateRequirementRequest, RequirementListQuery } from "../types/delivery-stream";
+/**
+ * Delivery Stream Service SDK
+ *
+ * 业务交付建模服务 - Stream（业务演进容器）& Requirement（需求池）
+ *
+ * MVP 特性：
+ * - scopeMode = personal（个人可见性）
+ * - Requirement 必须绑定 Stream
+ * - 软删除策略
+ */
+export declare class DeliveryStreamService extends BaseClient {
+    constructor(config: ClientConfig);
+    /**
+     * 创建 Stream
+     * POST /api/delivery-stream/streams (网关转发到 /api/v1/streams)
+     */
+    createStream(request: CreateStreamRequest, options?: RequestOptions): Promise<Stream>;
+    /**
+     * 获取 Stream 详情
+     * GET /api/delivery-stream/streams/:id
+     */
+    getStream(streamId: string, options?: RequestOptions): Promise<Stream>;
+    /**
+     * 获取 Stream 列表
+     * GET /api/delivery-stream/streams
+     *
+     * 注意：只能查看自己创建的 Stream（personal 可见性）
+     */
+    listStreams(query?: StreamListQuery, options?: RequestOptions): Promise<PaginatedResponse<Stream>>;
+    /**
+     * 更新 Stream
+     * PUT /api/delivery-stream/streams/:id
+     */
+    updateStream(streamId: string, request: UpdateStreamRequest, options?: RequestOptions): Promise<Stream>;
+    /**
+     * 删除 Stream（软删除）
+     * DELETE /api/delivery-stream/streams/:id
+     */
+    deleteStream(streamId: string, options?: RequestOptions): Promise<null>;
+    /**
+     * 创建 Requirement
+     * POST /api/delivery-stream/streams/:streamId/requirements
+     */
+    createRequirement(streamId: string, request: CreateRequirementRequest, options?: RequestOptions): Promise<Requirement>;
+    /**
+     * 获取 Requirement 详情
+     * GET /api/delivery-stream/streams/:streamId/requirements/:id
+     */
+    getRequirement(streamId: string, requirementId: string, options?: RequestOptions): Promise<Requirement>;
+    /**
+     * 获取 Requirement 列表
+     * GET /api/delivery-stream/streams/:streamId/requirements
+     */
+    listRequirements(streamId: string, query?: RequirementListQuery, options?: RequestOptions): Promise<PaginatedResponse<Requirement>>;
+    /**
+     * 更新 Requirement
+     * PUT /api/delivery-stream/streams/:streamId/requirements/:id
+     */
+    updateRequirement(streamId: string, requirementId: string, request: UpdateRequirementRequest, options?: RequestOptions): Promise<Requirement>;
+    /**
+     * 删除 Requirement（软删除）
+     * DELETE /api/delivery-stream/streams/:streamId/requirements/:id
+     */
+    deleteRequirement(streamId: string, requirementId: string, options?: RequestOptions): Promise<null>;
+    /**
+     * 检查 Stream 是否存在
+     */
+    streamExists(streamId: string, options?: RequestOptions): Promise<boolean>;
+    /**
+     * 归档 Stream（快捷方法）
+     */
+    archiveStream(streamId: string, options?: RequestOptions): Promise<Stream>;
+    /**
+     * 激活 Stream（快捷方法）
+     */
+    activateStream(streamId: string, options?: RequestOptions): Promise<Stream>;
+}

package/lib/service/DeliveryStreamService.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeliveryStreamService = void 0;
+const BaseClient_1 = require("../client/BaseClient");
+/**
+ * Delivery Stream Service SDK
+ *
+ * 业务交付建模服务 - Stream（业务演进容器）& Requirement（需求池）
+ *
+ * MVP 特性：
+ * - scopeMode = personal（个人可见性）
+ * - Requirement 必须绑定 Stream
+ * - 软删除策略
+ */
+class DeliveryStreamService extends BaseClient_1.BaseClient {
+    constructor(config) {
+        super(config, 'delivery-stream');
+    }
+    // ==================== Stream CRUD ====================
+    /**
+     * 创建 Stream
+     * POST /api/delivery-stream/streams (网关转发到 /api/v1/streams)
+     */
+    async createStream(request, options) {
+        return this.request('/streams', {
+            ...options,
+            method: 'POST',
+            body: request
+        });
+    }
+    /**
+     * 获取 Stream 详情
+     * GET /api/delivery-stream/streams/:id
+     */
+    async getStream(streamId, options) {
+        return this.request(`/streams/${streamId}`, {
+            ...options,
+            method: 'GET'
+        });
+    }
+    /**
+     * 获取 Stream 列表
+     * GET /api/delivery-stream/streams
+     *
+     * 注意：只能查看自己创建的 Stream（personal 可见性）
+     */
+    async listStreams(query, options) {
+        const params = {};
+        if (query?.status !== undefined) {
+            params.status = query.status;
+        }
+        if (query?.page !== undefined) {
+            params.page = query.page;
+        }
+        if (query?.limit !== undefined) {
+            params.limit = query.limit;
+        }
+        return this.paginatedRequest('/streams', {
+            ...options,
+            method: 'GET',
+            params
+        });
+    }
+    /**
+     * 更新 Stream
+     * PUT /api/delivery-stream/streams/:id
+     */
+    async updateStream(streamId, request, options) {
+        return this.request(`/streams/${streamId}`, {
+            ...options,
+            method: 'PUT',
+            body: request
+        });
+    }
+    /**
+     * 删除 Stream（软删除）
+     * DELETE /api/delivery-stream/streams/:id
+     */
+    async deleteStream(streamId, options) {
+        return this.request(`/streams/${streamId}`, {
+            ...options,
+            method: 'DELETE'
+        });
+    }
+    // ==================== Requirement CRUD ====================
+    // Requirement 是 Stream 的嵌套资源，所有操作都需要 streamId
+    /**
+     * 创建 Requirement
+     * POST /api/delivery-stream/streams/:streamId/requirements
+     */
+    async createRequirement(streamId, request, options) {
+        return this.request(`/streams/${streamId}/requirements`, {
+            ...options,
+            method: 'POST',
+            body: request
+        });
+    }
+    /**
+     * 获取 Requirement 详情
+     * GET /api/delivery-stream/streams/:streamId/requirements/:id
+     */
+    async getRequirement(streamId, requirementId, options) {
+        return this.request(`/streams/${streamId}/requirements/${requirementId}`, {
+            ...options,
+            method: 'GET'
+        });
+    }
+    /**
+     * 获取 Requirement 列表
+     * GET /api/delivery-stream/streams/:streamId/requirements
+     */
+    async listRequirements(streamId, query, options) {
+        const params = {};
+        if (query?.status !== undefined) {
+            params.status = query.status;
+        }
+        if (query?.page !== undefined) {
+            params.page = query.page;
+        }
+        if (query?.limit !== undefined) {
+            params.limit = query.limit;
+        }
+        return this.paginatedRequest(`/streams/${streamId}/requirements`, {
+            ...options,
+            method: 'GET',
+            params
+        });
+    }
+    /**
+     * 更新 Requirement
+     * PUT /api/delivery-stream/streams/:streamId/requirements/:id
+     */
+    async updateRequirement(streamId, requirementId, request, options) {
+        return this.request(`/streams/${streamId}/requirements/${requirementId}`, {
+            ...options,
+            method: 'PUT',
+            body: request
+        });
+    }
+    /**
+     * 删除 Requirement（软删除）
+     * DELETE /api/delivery-stream/streams/:streamId/requirements/:id
+     */
+    async deleteRequirement(streamId, requirementId, options) {
+        return this.request(`/streams/${streamId}/requirements/${requirementId}`, {
+            ...options,
+            method: 'DELETE'
+        });
+    }
+    // ==================== 便捷方法 ====================
+    /**
+     * 检查 Stream 是否存在
+     */
+    async streamExists(streamId, options) {
+        try {
+            await this.getStream(streamId, options);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 归档 Stream（快捷方法）
+     */
+    async archiveStream(streamId, options) {
+        return this.updateStream(streamId, { status: 'Archived' }, options);
+    }
+    /**
+     * 激活 Stream（快捷方法）
+     */
+    async activateStream(streamId, options) {
+        return this.updateStream(streamId, { status: 'Active' }, options);
+    }
+}
+exports.DeliveryStreamService = DeliveryStreamService;

package/lib/service/EzAbilityService.d.ts

@@ -0,0 +1,58 @@
+import { BaseClient } from "../client/BaseClient";
+import { ClientConfig } from "../types";
+import { EnumerateRequirementsRequest, EnumerateRequirementsResponse, TaskQueryResponse } from "../types/ez-ability";
+/**
+ * EzAbility 服务 - AI 能力服务客户端
+ *
+ * 功能：
+ * - 需求枚举（异步任务）
+ * - 任务状态查询
+ * - 任务取消
+ *
+ * 注意：任务进度通过 WebSocket 网关推送，不在此 SDK 中处理
+ */
+export declare class EzAbilityService extends BaseClient {
+    constructor(config: ClientConfig);
+    /**
+     * 创建需求枚举任务
+     *
+     * 异步任务，立即返回 taskId
+     * 进度通过 WebSocket 推送
+     *
+     * @param request 需求描述
+     * @returns 任务信息
+     */
+    enumerateRequirements(request: EnumerateRequirementsRequest): Promise<EnumerateRequirementsResponse>;
+    /**
+     * 查询任务状态
+     *
+     * 用于轮询或重连后恢复任务状态
+     *
+     * @param taskId 任务ID
+     * @returns 任务详情
+     */
+    getTask(taskId: string): Promise<TaskQueryResponse>;
+    /**
+     * 取消任务
+     *
+     * @param taskId 任务ID
+     * @returns 取消结果
+     */
+    cancelTask(taskId: string): Promise<{
+        message: string;
+    }>;
+    /**
+     * 等待任务完成（轮询方式）
+     *
+     * 注意：推荐使用 WebSocket 接收进度，此方法仅用于简单场景
+     *
+     * @param taskId 任务ID
+     * @param options 轮询选项
+     * @returns 任务结果
+     */
+    waitForTask(taskId: string, options?: {
+        pollInterval?: number;
+        timeout?: number;
+        onProgress?: (task: TaskQueryResponse) => void;
+    }): Promise<TaskQueryResponse>;
+}

package/lib/service/EzAbilityService.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EzAbilityService = void 0;
+// npm/src/service/EzAbilityService.ts
+const BaseClient_1 = require("../client/BaseClient");
+/**
+ * EzAbility 服务 - AI 能力服务客户端
+ *
+ * 功能：
+ * - 需求枚举（异步任务）
+ * - 任务状态查询
+ * - 任务取消
+ *
+ * 注意：任务进度通过 WebSocket 网关推送，不在此 SDK 中处理
+ */
+class EzAbilityService extends BaseClient_1.BaseClient {
+    constructor(config) {
+        super(config, "ez-ability");
+    }
+    // ==================== 需求枚举 ====================
+    /**
+     * 创建需求枚举任务
+     *
+     * 异步任务，立即返回 taskId
+     * 进度通过 WebSocket 推送
+     *
+     * @param request 需求描述
+     * @returns 任务信息
+     */
+    async enumerateRequirements(request) {
+        return this.request("/requirements/enumerate", {
+            method: "POST",
+            body: request,
+        });
+    }
+    // ==================== 任务管理 ====================
+    /**
+     * 查询任务状态
+     *
+     * 用于轮询或重连后恢复任务状态
+     *
+     * @param taskId 任务ID
+     * @returns 任务详情
+     */
+    async getTask(taskId) {
+        return this.request(`/requirements/tasks/${taskId}`, { method: "GET" });
+    }
+    /**
+     * 取消任务
+     *
+     * @param taskId 任务ID
+     * @returns 取消结果
+     */
+    async cancelTask(taskId) {
+        return this.request(`/requirements/tasks/${taskId}`, { method: "DELETE" });
+    }
+    // ==================== 便捷方法 ====================
+    /**
+     * 等待任务完成（轮询方式）
+     *
+     * 注意：推荐使用 WebSocket 接收进度，此方法仅用于简单场景
+     *
+     * @param taskId 任务ID
+     * @param options 轮询选项
+     * @returns 任务结果
+     */
+    async waitForTask(taskId, options) {
+        const pollInterval = options?.pollInterval || 2000;
+        const timeout = options?.timeout || 300000;
+        const startTime = Date.now();
+        while (true) {
+            const task = await this.getTask(taskId);
+            // 回调进度
+            if (options?.onProgress) {
+                options.onProgress(task);
+            }
+            // 任务完成
+            if (task.status === 'completed' || task.status === 'failed' || task.status === 'cancelled') {
+                return task;
+            }
+            // 检查超时
+            if (Date.now() - startTime > timeout) {
+                throw new Error(`Task ${taskId} timeout after ${timeout}ms`);
+            }
+            // 等待下次轮询
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+        }
+    }
+}
+exports.EzAbilityService = EzAbilityService;

package/lib/types/delivery-stream.d.ts

@@ -0,0 +1,66 @@
+export type StreamStatus = 'Draft' | 'Active' | 'Archived';
+export interface Stream {
+    id: string;
+    name: string;
+    status: StreamStatus;
+    description?: string;
+    owner?: string;
+    projectId: string;
+    userId: string;
+    visibilityScope: 'personal';
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateStreamRequest {
+    name: string;
+    status?: StreamStatus;
+    description?: string;
+    owner?: string;
+}
+export interface UpdateStreamRequest {
+    name?: string;
+    status?: StreamStatus;
+    description?: string;
+    owner?: string;
+}
+export interface StreamListQuery {
+    status?: StreamStatus;
+    page?: number;
+    limit?: number;
+}
+export type RequirementStatus = 'New' | 'Accepted' | 'Planned' | 'Released' | 'Dropped';
+export interface Requirement {
+    id: string;
+    title: string;
+    content: string;
+    source: string;
+    status: RequirementStatus;
+    streamId: string;
+    expectedRelease?: string;
+    actualRelease?: string;
+    projectId: string;
+    userId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateRequirementRequest {
+    title: string;
+    content: string;
+    source: string;
+    status?: RequirementStatus;
+    expectedRelease?: string;
+    actualRelease?: string;
+}
+export interface UpdateRequirementRequest {
+    title?: string;
+    content?: string;
+    source?: string;
+    status?: RequirementStatus;
+    expectedRelease?: string;
+    actualRelease?: string;
+}
+export interface RequirementListQuery {
+    status?: RequirementStatus;
+    page?: number;
+    limit?: number;
+}

package/lib/types/delivery-stream.js

@@ -0,0 +1,4 @@
+"use strict";
+// client/npm/src/types/delivery-stream.ts
+// Delivery Stream Service 类型定义
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/ez-ability.d.ts

@@ -0,0 +1,51 @@
+export type TaskStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+export interface TaskProgressEvent {
+    taskId: string;
+    type: string;
+    status: TaskStatus;
+    progress: number;
+    currentStep?: string;
+    delta?: any;
+    result?: any;
+    error?: string;
+    timestamp: number;
+}
+export interface EnumerateRequirementsRequest {
+    /** 需求描述（用户的原始需求文本） */
+    userRequest: string;
+    /** 枚举轮数（1-10），轮数越多需求越全面，默认 5 */
+    maxRounds?: number;
+    /** 指定使用的模型（不传则使用服务默认模型） */
+    model?: string;
+}
+export interface EnumerateRequirementsResponse {
+    taskId: string;
+    status: TaskStatus;
+    message: string;
+}
+export interface EnumerateRequirementsResult {
+    requirements: string[];
+    totalRounds: number;
+    totalCount: number;
+}
+export interface TaskQueryResponse {
+    taskId: string;
+    type: string;
+    status: TaskStatus;
+    progress: number;
+    currentStep?: string;
+    output?: any;
+    error?: string;
+    createdAt: string;
+    startedAt?: string;
+    completedAt?: string;
+}
+export interface AbilityCallRequest {
+    abilityId: string;
+    params: Record<string, any>;
+}
+export interface AbilityCallResponse {
+    taskId: string;
+    status: TaskStatus;
+    message: string;
+}

package/lib/types/ez-ability.js

@@ -0,0 +1,4 @@
+"use strict";
+// npm/src/types/ez-ability.ts
+// EzAbility 服务类型定义
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/index.d.ts

@@ -33,6 +33,8 @@ export interface ClientConfig {
     providerServiceUrl?: string;
     gatewayH5ServiceUrl?: string;
     orgServiceUrl?: string;
+    deliveryStreamServiceUrl?: string;
+    ezAbilityServiceUrl?: string;
     tokenStorage?: TokenStorage;
     projectId?: string;
     orgId?: string;
@@ -61,3 +63,4 @@ export interface RequestOptions {
 export * from "./provider";
 export * from "./usage";
 export * from "./audit";
+export * from "./ez-ability";

package/lib/types/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./provider"), exports);
 __exportStar(require("./usage"), exports);
 __exportStar(require("./audit"), exports);
+__exportStar(require("./ez-ability"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qing-client",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {