@turinhub/tale-js-sdk 2.2.0 → 2.3.0

package/README.md

@@ -24,33 +24,25 @@ yarn add @turinhub/tale-js-sdk
 
 ```ts
 import {
-  getAppToken,
-  getCurrentUser,
-  listAppsByOrg,
-  listFiles,
+  createTaleAdminClient,
+  createTaleAppClient,
 } from "@turinhub/tale-js-sdk";
 
-const appToken = await getAppToken({
+const admin = createTaleAdminClient({
   baseUrl: "https://api.tale.example",
-  appKey: process.env.TALE_APP_KEY,
-  appSecret: process.env.TALE_APP_SECRET,
+  taleToken: "tale-user-token",
 });
 
-const files = await listFiles({
-  baseUrl: "https://api.tale.example",
-  appToken,
-  folderId: "folder-id",
-});
+const currentUser = await admin.currentUser.get();
+const apps = await admin.apps.listByOrg(currentUser.app.orgId);
+const issued = await admin.appTokens.issue({ appKey: "oa_xxx" });
 
-const currentUser = await getCurrentUser({
+const app = createTaleAppClient({
   baseUrl: "https://api.tale.example",
-  taleToken: "tale-user-token",
+  appToken: issued.token,
 });
 
-const apps = await listAppsByOrg(currentUser.app.orgId, {
-  baseUrl: "https://api.tale.example",
-  taleToken: "tale-user-token",
-});
+const files = await app.cms.listFiles({ folderId: "folder-id" });
 ```
 
 ## 认证与 Token
@@ -61,9 +53,67 @@ SDK 中常见的鉴权选项都通过 `x-t-token` 发送到 Tale 后端：
 - `taleToken`：Tale 用户 Token，适用于平台级 App 管理 API，例如获取当前用户、应用列表、应用详情、App Secret，以及按 App Key 换发 App Token。
 - `baseUrl`：Tale 后端服务基础 URL；未显式传入时会读取环境变量。
 
-服务端可使用 `getAppToken()` 通过 `TALE_APP_KEY` 与 `TALE_APP_SECRET` 获取应用 Token。浏览器端的 Cookie、缓存、自动续期和多应用切换策略不由 SDK 核心管理，调用方可基于 `issueAppToken()` 自行封装。
+服务端可使用 `getAppToken()` 通过 `TALE_APP_KEY` 与 `TALE_APP_SECRET` 获取应用 Token。`getAppToken()` 是 server-only helper，不应在浏览器代码中调用或暴露 `TALE_APP_SECRET`。浏览器端的 Cookie、缓存、自动续期和多应用切换策略不由 SDK 核心管理，调用方可基于 `createTaleAdminClient().appTokens.issue()` 或业务后端代理自行封装。
 
-## App 与 App Token API
+## Admin 与 App Client
+
+也可以从子路径导入两个客户端入口：
+
+```ts
+import { createTaleAdminClient } from "@turinhub/tale-js-sdk/admin";
+import { createTaleAppClient } from "@turinhub/tale-js-sdk/app";
+```
+
+Admin client 只接收 `taleToken`，用于平台级应用管理：
+
+```ts
+const admin = createTaleAdminClient({ baseUrl, taleToken });
+
+await admin.currentUser.get();
+await admin.apps.listByOrg("org_1");
+await admin.apps.create({ appName: "Demo", orgId: "org_1" });
+await admin.apps.getDetail("oa_xxx");
+await admin.apps.update({ appId: "app_1", appName: "Demo" });
+await admin.appTokens.getSecret("oa_xxx");
+await admin.appTokens.issue({ appKey: "oa_xxx" });
+```
+
+App client 只接收 `appToken`，用于单应用内资源：
+
+```ts
+const app = createTaleAppClient({ baseUrl, appToken });
+
+await app.cms.listFiles({ folderId: "folder_1" });
+await app.users.list({ page: 0, size: 20 });
+await app.tasks.create({ openId: "ou_xxx", taskTypeId: "type_1" });
+await app.rbac.listRoles();
+await app.acl.listRecords();
+await app.attachments.listByRef({ refType: "task", refId: "task_1" });
+await app.appTokens.list({ page: 0, size: 20 });
+```
+
+## Legacy-compatible 函数导入
+
+已有项目可以继续从根入口直接导入函数。该方式在 2.x 内保持兼容，但新项目建议优先使用 Admin/App client。
+
+```ts
+import {
+  getAppToken,
+  getCurrentUser,
+  listAppsByOrg,
+  listFiles,
+} from "@turinhub/tale-js-sdk";
+
+const appToken = await getAppToken({
+  baseUrl,
+  appKey: process.env.TALE_APP_KEY,
+  appSecret: process.env.TALE_APP_SECRET,
+});
+
+const files = await listFiles({ baseUrl, appToken, folderId: "folder-id" });
+const currentUser = await getCurrentUser({ baseUrl, taleToken });
+const apps = await listAppsByOrg(currentUser.app.orgId, { baseUrl, taleToken });
+```
 
 AppTS 模块提供平台应用相关方法：
 

package/dist/admin.d.ts

@@ -0,0 +1,24 @@
+import { createApp, getAppDetail, listAppsByOrg, updateApp } from "./app/index.js";
+import { getAppSecret, issueAppToken } from "./app-token/index.js";
+export interface TaleAdminClientOptions {
+    baseUrl?: string;
+    taleToken: string;
+}
+type IssueAppTokenRequestWithoutAuth = Omit<Parameters<typeof issueAppToken>[0], keyof TaleAdminClientOptions | "appToken">;
+export declare function createTaleAdminClient(options: TaleAdminClientOptions): {
+    currentUser: {
+        get: () => Promise<import("./app/types.js").CurrentAppUser>;
+    };
+    apps: {
+        listByOrg: (orgId: Parameters<typeof listAppsByOrg>[0]) => Promise<import("./app/types.js").AppInfo[]>;
+        create: (request: Parameters<typeof createApp>[0]) => Promise<import("./app/types.js").CreateAppResponse>;
+        getDetail: (appKey: Parameters<typeof getAppDetail>[0]) => Promise<import("./app/types.js").AppDetail>;
+        update: (request: Parameters<typeof updateApp>[0]) => Promise<import("./app/types.js").AppDetail>;
+    };
+    appTokens: {
+        getSecret: (appKey: Parameters<typeof getAppSecret>[0]) => Promise<string>;
+        issue: (request: IssueAppTokenRequestWithoutAuth) => Promise<import("./app-token/types.js").IssueAppTokenResponse>;
+    };
+};
+export type TaleAdminClient = ReturnType<typeof createTaleAdminClient>;
+export {};

package/dist/admin.js

@@ -0,0 +1,20 @@
+import { createApp, getAppDetail, getCurrentUser, listAppsByOrg, updateApp, } from "./app/index.js";
+import { getAppSecret, issueAppToken } from "./app-token/index.js";
+export function createTaleAdminClient(options) {
+    const adminOptions = () => ({ ...options });
+    return {
+        currentUser: {
+            get: () => getCurrentUser(adminOptions()),
+        },
+        apps: {
+            listByOrg: (orgId) => listAppsByOrg(orgId, adminOptions()),
+            create: (request) => createApp(request, adminOptions()),
+            getDetail: (appKey) => getAppDetail(appKey, adminOptions()),
+            update: (request) => updateApp(request, adminOptions()),
+        },
+        appTokens: {
+            getSecret: (appKey) => getAppSecret(appKey, adminOptions()),
+            issue: (request) => issueAppToken({ ...request, ...adminOptions() }),
+        },
+    };
+}

package/dist/app-client.d.ts

@@ -0,0 +1,228 @@
+import * as Acl from "./acl/index.js";
+import * as AppToken from "./app-token/index.js";
+import * as Attachment from "./attachment/index.js";
+import * as AttachmentType from "./attachment-type/index.js";
+import * as Auth from "./auth/index.js";
+import * as Cms from "./cms/index.js";
+import * as Dashboard from "./dashboard/index.js";
+import * as Rbac from "./rbac/index.js";
+import * as Task from "./task/index.js";
+import * as TaskType from "./task-type/index.js";
+import * as User from "./user/index.js";
+import * as UserAttribute from "./user-attribute/index.js";
+import * as UserGroup from "./user-group/index.js";
+export interface TaleAppClientOptions {
+    baseUrl?: string;
+    appToken: string;
+}
+type StripAuth<T> = T extends object ? Omit<T, keyof TaleAppClientOptions | "taleToken" | "appKey" | "appSecret"> : T;
+type Request<T extends (...args: any[]) => unknown, Index extends number> = StripAuth<NonNullable<Parameters<T>[Index]>>;
+type OptionalRequest<T extends (...args: any[]) => unknown, Index extends number> = Request<T, Index> | undefined;
+export declare function createTaleAppClient(options: TaleAppClientOptions): {
+    auth: {
+        login: (credentials: Parameters<typeof Auth.login>[0], request?: OptionalRequest<typeof Auth.login, 1>) => Promise<Auth.LoginResponse>;
+        validateToken: (token: Parameters<typeof Auth.validateToken>[0], request?: OptionalRequest<typeof Auth.validateToken, 1>) => Promise<boolean>;
+        loginWithSms: (phone: Parameters<typeof Auth.loginWithSms>[0]) => Promise<Auth.SendSmsResponse>;
+        verifySmsCode: (request: Parameters<typeof Auth.verifySmsCode>[0], optionsOverride?: OptionalRequest<typeof Auth.verifySmsCode, 1>) => Promise<Auth.SmsLoginResponse>;
+        registerWithSms: (request: Parameters<typeof Auth.registerWithSms>[0], optionsOverride?: OptionalRequest<typeof Auth.registerWithSms, 1>) => Promise<Auth.SmsLoginResponse>;
+    };
+    users: {
+        create: (request: Parameters<typeof User.createUser>[0]) => Promise<User.CreateUserResponse>;
+        getById: (userId?: Parameters<typeof User.getUserById>[0], request?: OptionalRequest<typeof User.getUserById, 1>) => Promise<User.CreateUserResponse>;
+        delete: (userId: Parameters<typeof User.deleteUser>[0]) => Promise<User.DeleteUserResponse>;
+        list: (request?: OptionalRequest<typeof User.listUsers, 0>) => Promise<User.ListUsersResponse>;
+        update: (userId: Parameters<typeof User.updateUser>[0], request: Parameters<typeof User.updateUser>[1]) => Promise<User.UpdateUserResponse>;
+        updatePassword: (request: Parameters<typeof User.updateUserPassword>[0]) => Promise<User.UpdateUserPasswordResponse>;
+        uploadAvatar: (userId: Parameters<typeof User.uploadAvatar>[0], file: Parameters<typeof User.uploadAvatar>[1]) => Promise<User.UploadAvatarResponse>;
+        getAvatarPresignedUrl: (userId: Parameters<typeof User.getAvatarPresignedUrl>[0]) => Promise<User.AvatarPresignedUrlResponse>;
+        updateFrozenStatus: (userId: Parameters<typeof User.updateUserFrozenStatus>[0], isFrozen: Parameters<typeof User.updateUserFrozenStatus>[1]) => Promise<User.UserFrozenStatusResponse>;
+        getFrozenStatus: (userId: Parameters<typeof User.getUserFrozenStatus>[0]) => Promise<User.UserFrozenStatusResponse>;
+    };
+    userGroups: {
+        get: (groupId: Parameters<typeof UserGroup.getUserGroup>[0]) => Promise<UserGroup.UserGroupInfo>;
+        list: (request?: OptionalRequest<typeof UserGroup.listUserGroups, 0>) => Promise<AppToken.PageResponse<UserGroup.UserGroupInfo>>;
+        create: (request: Parameters<typeof UserGroup.createUserGroup>[0]) => Promise<UserGroup.UserGroupInfo>;
+        update: (groupId: Parameters<typeof UserGroup.updateUserGroup>[0], request: Parameters<typeof UserGroup.updateUserGroup>[1]) => Promise<UserGroup.UserGroupInfo>;
+        delete: (groupId: Parameters<typeof UserGroup.deleteUserGroup>[0]) => Promise<void>;
+        listMembers: (groupId: Parameters<typeof UserGroup.listUserGroupMembers>[0], request?: OptionalRequest<typeof UserGroup.listUserGroupMembers, 1>) => Promise<AppToken.PageResponse<UserGroup.UserGroupMember>>;
+        addMembers: (groupId: Parameters<typeof UserGroup.addUserGroupMembers>[0], request: Parameters<typeof UserGroup.addUserGroupMembers>[1]) => Promise<void>;
+        removeMembers: (groupId: Parameters<typeof UserGroup.removeUserGroupMembers>[0], request: Parameters<typeof UserGroup.removeUserGroupMembers>[1]) => Promise<void>;
+        getUserGroups: (userId: Parameters<typeof UserGroup.getUserGroups>[0], request?: OptionalRequest<typeof UserGroup.getUserGroups, 1>) => Promise<UserGroup.UserGroupInfo[]>;
+    };
+    userAttributes: {
+        createDefinition: (request: Parameters<typeof UserAttribute.createUserAttributeDefinition>[0]) => Promise<UserAttribute.UserAttributeDefinition>;
+        updateDefinition: (definitionId: Parameters<typeof UserAttribute.updateUserAttributeDefinition>[0], request: Parameters<typeof UserAttribute.updateUserAttributeDefinition>[1]) => Promise<UserAttribute.UserAttributeDefinition>;
+        deleteDefinition: (definitionId: Parameters<typeof UserAttribute.deleteUserAttributeDefinition>[0]) => Promise<void>;
+        getDefinition: (definitionId: Parameters<typeof UserAttribute.getUserAttributeDefinition>[0]) => Promise<UserAttribute.UserAttributeDefinition>;
+        listDefinitions: (request?: OptionalRequest<typeof UserAttribute.listUserAttributeDefinitions, 0>) => Promise<AppToken.PageResponse<UserAttribute.UserAttributeDefinition>>;
+        listEnabledDefinitions: (request?: OptionalRequest<typeof UserAttribute.listEnabledUserAttributeDefinitions, 0>) => Promise<UserAttribute.UserAttributeDefinition[]>;
+        toggleDefinitionStatus: (definitionId: Parameters<typeof UserAttribute.toggleUserAttributeDefinitionStatus>[0], enabled: Parameters<typeof UserAttribute.toggleUserAttributeDefinitionStatus>[1]) => Promise<UserAttribute.UserAttributeDefinition>;
+        set: (userId: Parameters<typeof UserAttribute.setUserAttribute>[0], attributeDefinitionId: Parameters<typeof UserAttribute.setUserAttribute>[1], request: Parameters<typeof UserAttribute.setUserAttribute>[2]) => Promise<UserAttribute.UserAttributeDTO>;
+        get: (userId: Parameters<typeof UserAttribute.getUserAttribute>[0], definitionId: Parameters<typeof UserAttribute.getUserAttribute>[1]) => Promise<UserAttribute.UserAttributeDTO>;
+        delete: (userId: Parameters<typeof UserAttribute.deleteUserAttribute>[0], definitionId: Parameters<typeof UserAttribute.deleteUserAttribute>[1]) => Promise<void>;
+        getUserAttributes: (userId: Parameters<typeof UserAttribute.getUserAttributes>[0]) => Promise<UserAttribute.UserAttributeDTO[]>;
+        listUserAttributes: (userId: Parameters<typeof UserAttribute.listUserAttributes>[0], request?: OptionalRequest<typeof UserAttribute.listUserAttributes, 1>) => Promise<AppToken.PageResponse<UserAttribute.UserAttributeDTO>>;
+        listAttributeUsers: (definitionId: Parameters<typeof UserAttribute.listAttributeUsers>[0], request?: OptionalRequest<typeof UserAttribute.listAttributeUsers, 1>) => Promise<AppToken.PageResponse<UserAttribute.UserAttributeDTO>>;
+        listAll: (request?: OptionalRequest<typeof UserAttribute.listAllUserAttributes, 0>) => Promise<AppToken.PageResponse<UserAttribute.UserAttributeGroupedDTO>>;
+    };
+    cms: {
+        getFolder: (folderId: Parameters<typeof Cms.getFolder>[0]) => Promise<Cms.Folder>;
+        listFolders: (request?: OptionalRequest<typeof Cms.listFolders, 0>) => Promise<AppToken.PageResponse<Cms.Folder>>;
+        createFolder: (request: Parameters<typeof Cms.createFolder>[0]) => Promise<Cms.Folder>;
+        updateFolder: (folderId: Parameters<typeof Cms.updateFolder>[0], request: Parameters<typeof Cms.updateFolder>[1]) => Promise<Cms.Folder>;
+        deleteFolder: (folderId: Parameters<typeof Cms.deleteFolder>[0]) => Promise<void>;
+        getFile: (fileId: Parameters<typeof Cms.getFile>[0]) => Promise<Cms.File>;
+        listFiles: (request?: OptionalRequest<typeof Cms.listFiles, 0>) => Promise<AppToken.PageResponse<Cms.File>>;
+        createFile: (request: Parameters<typeof Cms.createFile>[0]) => Promise<Cms.File>;
+        updateFile: (fileId: Parameters<typeof Cms.updateFile>[0], request: Parameters<typeof Cms.updateFile>[1]) => Promise<Cms.File>;
+        updateFileContent: (fileId: Parameters<typeof Cms.updateFileContent>[0], content: Parameters<typeof Cms.updateFileContent>[1]) => Promise<Cms.File>;
+        deleteFile: (fileId: Parameters<typeof Cms.deleteFile>[0]) => Promise<void>;
+        getFilePresignedUrl: (fileId: Parameters<typeof Cms.getFilePresignedUrl>[0], expireTimeInSeconds?: Parameters<typeof Cms.getFilePresignedUrl>[1]) => Promise<{
+            fileId: string;
+            fileName: string;
+            ossKey: string;
+            presignedUrl: string;
+            expireTimeInSeconds: number;
+        }>;
+        batchGetFilePresignedUrl: (fileIds: Parameters<typeof Cms.batchGetFilePresignedUrl>[0], expireTimeInSeconds?: Parameters<typeof Cms.batchGetFilePresignedUrl>[1]) => Promise<{
+            fileId: string;
+            fileName?: string;
+            ossKey?: string;
+            presignedUrl?: string;
+            expireTimeInSeconds?: number;
+            error?: string;
+        }[]>;
+        getOssMetadata: (fileId: Parameters<typeof Cms.getOssMetadata>[0]) => Promise<{
+            ossKey: string;
+            contentType?: string;
+            contentLength?: number;
+            lastModified?: string;
+            etag?: string;
+            metadata?: Record<string, string>;
+        }>;
+        getUploadAuthorization: (request: Parameters<typeof Cms.getUploadAuthorization>[0]) => Promise<{
+            ossKey: string;
+            presignedUrl: string;
+            fileName: string;
+            fileType: string;
+            expireTimeInSeconds: number;
+            fileId: string;
+        }>;
+        getFileStsCredentials: (fileId: Parameters<typeof Cms.getFileStsCredentials>[0], fileExtension: Parameters<typeof Cms.getFileStsCredentials>[1], durationSeconds?: Parameters<typeof Cms.getFileStsCredentials>[2]) => Promise<{
+            credentials: {
+                tmpSecretId: string;
+                tmpSecretKey: string;
+                sessionToken: string;
+                bucket: string;
+                region: string;
+            };
+            startTime: number;
+            expiredTime: number;
+            bucket: string;
+            region: string;
+            allowPrefix: string;
+        }>;
+        fileUploadComplete: (fileId: Parameters<typeof Cms.fileUploadComplete>[0], request: Parameters<typeof Cms.fileUploadComplete>[1]) => Promise<{
+            message: string;
+            fileId: string;
+        }>;
+        setFilePreviewImage: (fileId: Parameters<typeof Cms.setFilePreviewImage>[0], request: Parameters<typeof Cms.setFilePreviewImage>[1]) => Promise<Cms.File>;
+        listFileAttachments: (fileId: Parameters<typeof Cms.listFileAttachments>[0], request?: OptionalRequest<typeof Cms.listFileAttachments, 1>) => Promise<AppToken.PageResponse<Cms.FileAttachment>>;
+        getFileAttachment: (fileId: Parameters<typeof Cms.getFileAttachment>[0], attachmentId: Parameters<typeof Cms.getFileAttachment>[1]) => Promise<Cms.FileAttachment>;
+        uploadFileAttachment: (fileId: Parameters<typeof Cms.uploadFileAttachment>[0], attachmentTypeId: Parameters<typeof Cms.uploadFileAttachment>[1], file: Parameters<typeof Cms.uploadFileAttachment>[2], remark?: Parameters<typeof Cms.uploadFileAttachment>[3]) => Promise<Cms.FileAttachment>;
+        deleteFileAttachment: (fileId: Parameters<typeof Cms.deleteFileAttachment>[0], attachmentId: Parameters<typeof Cms.deleteFileAttachment>[1]) => Promise<void>;
+    };
+    tasks: {
+        create: (request: Parameters<typeof Task.createUserTask>[0]) => Promise<Task.UserTask>;
+        batchCreate: (request: Parameters<typeof Task.batchCreateUserTasks>[0]) => Promise<Task.BatchCreateUserTasksResponse>;
+        get: (taskId: Parameters<typeof Task.getUserTask>[0]) => Promise<Task.UserTask>;
+        batchGet: (request: Parameters<typeof Task.batchGetUserTasks>[0]) => Promise<Task.UserTask[]>;
+        list: (request?: OptionalRequest<typeof Task.listUserTasks, 0>) => Promise<AppToken.PageResponse<Task.UserTask>>;
+        update: (taskId: Parameters<typeof Task.updateUserTask>[0], request: Parameters<typeof Task.updateUserTask>[1]) => Promise<Task.UserTask>;
+        delete: (taskId: Parameters<typeof Task.deleteUserTask>[0]) => Promise<void>;
+        getInput: (taskId: Parameters<typeof Task.getTaskInput>[0]) => Promise<Record<string, unknown>>;
+        getOutput: (taskId: Parameters<typeof Task.getTaskOutput>[0]) => Promise<Record<string, unknown>>;
+        updateInput: (taskId: Parameters<typeof Task.updateTaskInput>[0], input: Parameters<typeof Task.updateTaskInput>[1]) => Promise<Task.UserTask>;
+        updateOutput: (taskId: Parameters<typeof Task.updateTaskOutput>[0], output: Parameters<typeof Task.updateTaskOutput>[1]) => Promise<Task.UserTask>;
+        getStatus: (taskId: Parameters<typeof Task.getTaskStatus>[0]) => Promise<string>;
+        updateStatus: (taskId: Parameters<typeof Task.updateTaskStatus>[0], status: Parameters<typeof Task.updateTaskStatus>[1]) => Promise<Task.UserTask>;
+        getStatistics: (userId?: Parameters<typeof Task.getTaskStatistics>[0]) => Promise<Task.TaskStatistics>;
+        getFrozenStatus: (taskId: Parameters<typeof Task.getTaskFrozenStatus>[0]) => Promise<Task.TaskFrozenStatusResponse>;
+        updateFrozenStatus: (taskId: Parameters<typeof Task.updateTaskFrozenStatus>[0], isFrozen: Parameters<typeof Task.updateTaskFrozenStatus>[1]) => Promise<Task.TaskFrozenStatusResponse>;
+        listAttachments: (taskId: Parameters<typeof Task.listTaskAttachments>[0], request?: OptionalRequest<typeof Task.listTaskAttachments, 1>) => Promise<AppToken.PageResponse<Attachment.Attachment>>;
+        getAttachment: (taskId: Parameters<typeof Task.getTaskAttachment>[0], attachmentId: Parameters<typeof Task.getTaskAttachment>[1]) => Promise<Attachment.Attachment>;
+        uploadAttachment: (taskId: Parameters<typeof Task.uploadTaskAttachment>[0], attachmentTypeId: Parameters<typeof Task.uploadTaskAttachment>[1], file: Parameters<typeof Task.uploadTaskAttachment>[2], remark?: Parameters<typeof Task.uploadTaskAttachment>[3]) => Promise<Attachment.Attachment>;
+        deleteAttachment: (taskId: Parameters<typeof Task.deleteTaskAttachment>[0], attachmentId: Parameters<typeof Task.deleteTaskAttachment>[1]) => Promise<void>;
+    };
+    taskTypes: {
+        create: (request: Parameters<typeof TaskType.createTaskType>[0]) => Promise<TaskType.TaskType>;
+        update: (taskTypeId: Parameters<typeof TaskType.updateTaskType>[0], request: Parameters<typeof TaskType.updateTaskType>[1]) => Promise<TaskType.TaskType>;
+        delete: (taskTypeId: Parameters<typeof TaskType.deleteTaskType>[0]) => Promise<void>;
+        get: (taskTypeId: Parameters<typeof TaskType.getTaskType>[0]) => Promise<TaskType.TaskType>;
+        list: (request?: OptionalRequest<typeof TaskType.listTaskTypes, 0>) => Promise<AppToken.PageResponse<TaskType.TaskType>>;
+        listEnabled: (request?: OptionalRequest<typeof TaskType.listEnabledTaskTypes, 0>) => Promise<TaskType.TaskType[]>;
+    };
+    rbac: {
+        getRole: (roleId: Parameters<typeof Rbac.getRole>[0]) => Promise<Rbac.Role>;
+        listRoles: (request?: OptionalRequest<typeof Rbac.listRoles, 0>) => Promise<AppToken.PageResponse<Rbac.Role>>;
+        createRole: (request: Parameters<typeof Rbac.createRole>[0]) => Promise<Rbac.Role>;
+        updateRole: (roleId: Parameters<typeof Rbac.updateRole>[0], request: Parameters<typeof Rbac.updateRole>[1]) => Promise<Rbac.Role>;
+        deleteRole: (roleId: Parameters<typeof Rbac.deleteRole>[0]) => Promise<void>;
+        getPrivilege: (privilegeId: Parameters<typeof Rbac.getPrivilege>[0]) => Promise<Rbac.Privilege>;
+        listPrivileges: (request?: OptionalRequest<typeof Rbac.listPrivileges, 0>) => Promise<AppToken.PageResponse<Rbac.Privilege>>;
+        createPrivilege: (request: Parameters<typeof Rbac.createPrivilege>[0]) => Promise<Rbac.Privilege>;
+        updatePrivilege: (privilegeId: Parameters<typeof Rbac.updatePrivilege>[0], request: Parameters<typeof Rbac.updatePrivilege>[1]) => Promise<Rbac.Privilege>;
+        deletePrivilege: (privilegeId: Parameters<typeof Rbac.deletePrivilege>[0]) => Promise<void>;
+        getUserRoles: (userId: Parameters<typeof Rbac.getUserRoles>[0]) => Promise<Rbac.Role[]>;
+        assignRolesToUser: (userId: Parameters<typeof Rbac.assignRolesToUser>[0], request: Parameters<typeof Rbac.assignRolesToUser>[1]) => Promise<Rbac.Role[]>;
+        unassignRolesFromUser: (userId: Parameters<typeof Rbac.unassignRolesFromUser>[0], request: Parameters<typeof Rbac.unassignRolesFromUser>[1]) => Promise<void>;
+        getUserPrivileges: (userId: Parameters<typeof Rbac.getUserPrivileges>[0]) => Promise<Rbac.Privilege[]>;
+        assignPrivilegesToUser: (userId: Parameters<typeof Rbac.assignPrivilegesToUser>[0], request: Parameters<typeof Rbac.assignPrivilegesToUser>[1]) => Promise<Rbac.Privilege[]>;
+        unassignPrivilegesFromUser: (userId: Parameters<typeof Rbac.unassignPrivilegesFromUser>[0], request: Parameters<typeof Rbac.unassignPrivilegesFromUser>[1]) => Promise<void>;
+        assignPrivilegesToRole: (roleId: Parameters<typeof Rbac.assignPrivilegesToRole>[0], request: Parameters<typeof Rbac.assignPrivilegesToRole>[1]) => Promise<Rbac.Privilege[]>;
+        unassignPrivilegesFromRole: (roleId: Parameters<typeof Rbac.unassignPrivilegesFromRole>[0], request: Parameters<typeof Rbac.unassignPrivilegesFromRole>[1]) => Promise<void>;
+    };
+    acl: {
+        getRecord: (recordId: Parameters<typeof Acl.getAclRecord>[0]) => Promise<Acl.AclRecord>;
+        listRecords: (request?: OptionalRequest<typeof Acl.listAclRecords, 0>) => Promise<AppToken.PageResponse<Acl.AclRecord>>;
+        createRecord: (request: Parameters<typeof Acl.createAclRecord>[0]) => Promise<Acl.AclRecord>;
+        batchCreateRecords: (request: Parameters<typeof Acl.batchCreateAclRecords>[0]) => Promise<Acl.AclBatchCreateResponse>;
+        updateRecord: (recordId: Parameters<typeof Acl.updateAclRecord>[0], request: Parameters<typeof Acl.updateAclRecord>[1]) => Promise<Acl.AclRecord>;
+        deleteRecord: (recordId: Parameters<typeof Acl.deleteAclRecord>[0]) => Promise<void>;
+        getTemplate: (templateId: Parameters<typeof Acl.getAclTemplate>[0]) => Promise<Acl.AclTemplate>;
+        listTemplates: (request?: OptionalRequest<typeof Acl.listAclTemplates, 0>) => Promise<AppToken.PageResponse<Acl.AclTemplate>>;
+        createTemplate: (request: Parameters<typeof Acl.createAclTemplate>[0]) => Promise<Acl.AclTemplate>;
+        updateTemplate: (templateId: Parameters<typeof Acl.updateAclTemplate>[0], request: Parameters<typeof Acl.updateAclTemplate>[1]) => Promise<Acl.AclTemplate>;
+        deleteTemplate: (templateId: Parameters<typeof Acl.deleteAclTemplate>[0]) => Promise<void>;
+        listRecordAttachments: (recordId: Parameters<typeof Acl.listAclRecordAttachments>[0], request?: OptionalRequest<typeof Acl.listAclRecordAttachments, 1>) => Promise<AppToken.PageResponse<Attachment.Attachment>>;
+        getRecordAttachment: (recordId: Parameters<typeof Acl.getAclRecordAttachment>[0], attachmentId: Parameters<typeof Acl.getAclRecordAttachment>[1]) => Promise<Attachment.Attachment>;
+        uploadRecordAttachment: (recordId: Parameters<typeof Acl.uploadAclRecordAttachment>[0], attachmentTypeId: Parameters<typeof Acl.uploadAclRecordAttachment>[1], file: Parameters<typeof Acl.uploadAclRecordAttachment>[2], remark?: Parameters<typeof Acl.uploadAclRecordAttachment>[3]) => Promise<Attachment.Attachment>;
+        deleteRecordAttachment: (recordId: Parameters<typeof Acl.deleteAclRecordAttachment>[0], attachmentId: Parameters<typeof Acl.deleteAclRecordAttachment>[1]) => Promise<void>;
+    };
+    attachments: {
+        get: (attachmentId: Parameters<typeof Attachment.getAttachment>[0]) => Promise<Attachment.Attachment>;
+        listByRef: (request: Request<typeof Attachment.listAttachmentsByRef, 0>) => Promise<AppToken.PageResponse<Attachment.Attachment>>;
+        upload: (request: Parameters<typeof Attachment.uploadAttachment>[0]) => Promise<Attachment.Attachment>;
+        delete: (request: Parameters<typeof Attachment.deleteAttachment>[0]) => Promise<void>;
+        getUploadUrl: (request: Parameters<typeof Attachment.getAttachmentUploadUrl>[0]) => Promise<Attachment.UploadAuthorizationResponse>;
+        completeUpload: (attachmentId: Parameters<typeof Attachment.completeAttachmentUpload>[0], request: Parameters<typeof Attachment.completeAttachmentUpload>[1]) => Promise<Attachment.Attachment>;
+        getDownloadUrl: (request: Parameters<typeof Attachment.getAttachmentDownloadUrl>[0]) => Promise<Attachment.DownloadUrlResponse>;
+    };
+    attachmentTypes: {
+        list: (request?: OptionalRequest<typeof AttachmentType.listAttachmentTypes, 0>) => Promise<AppToken.PageResponse<AttachmentType.AttachmentType>>;
+        listByRef: (request: Request<typeof AttachmentType.listAttachmentTypesByRef, 0>) => Promise<AppToken.PageResponse<AttachmentType.AttachmentType>>;
+        get: (typeId: Parameters<typeof AttachmentType.getAttachmentType>[0]) => Promise<AttachmentType.AttachmentType>;
+        create: (request: Parameters<typeof AttachmentType.createAttachmentType>[0]) => Promise<AttachmentType.AttachmentType>;
+        update: (typeId: Parameters<typeof AttachmentType.updateAttachmentType>[0], request: Parameters<typeof AttachmentType.updateAttachmentType>[1]) => Promise<AttachmentType.AttachmentType>;
+        delete: (typeId: Parameters<typeof AttachmentType.deleteAttachmentType>[0]) => Promise<void>;
+    };
+    dashboard: {
+        getView: (viewName: Parameters<typeof Dashboard.getDashboardView>[0], request?: OptionalRequest<typeof Dashboard.getDashboardView, 1>) => Promise<AppToken.PageResponse<Dashboard.DashboardViewRow>>;
+        queryView: (request: Parameters<typeof Dashboard.queryDashboardView>[0]) => Promise<Dashboard.DashboardViewQueryResponse>;
+    };
+    appTokens: {
+        list: (request?: OptionalRequest<typeof AppToken.listAppTokens, 0>) => Promise<AppToken.PageResponse<AppToken.AppToken>>;
+    };
+};
+export type TaleAppClient = ReturnType<typeof createTaleAppClient>;
+export {};

package/dist/app-client.js

@@ -0,0 +1,186 @@
+import * as Acl from "./acl/index.js";
+import * as AppToken from "./app-token/index.js";
+import * as Attachment from "./attachment/index.js";
+import * as AttachmentType from "./attachment-type/index.js";
+import * as Auth from "./auth/index.js";
+import * as Cms from "./cms/index.js";
+import * as Dashboard from "./dashboard/index.js";
+import * as Rbac from "./rbac/index.js";
+import * as Task from "./task/index.js";
+import * as TaskType from "./task-type/index.js";
+import * as User from "./user/index.js";
+import * as UserAttribute from "./user-attribute/index.js";
+import * as UserGroup from "./user-group/index.js";
+export function createTaleAppClient(options) {
+    const appOptions = () => ({ ...options });
+    const mergeRequest = (request) => ({ ...(request ?? {}), ...appOptions() });
+    return {
+        auth: {
+            login: (credentials, request) => Auth.login(credentials, {
+                ...(request ?? {}),
+                baseUrl: options.baseUrl,
+            }),
+            validateToken: (token, request) => Auth.validateToken(token, {
+                ...(request ?? {}),
+                baseUrl: options.baseUrl,
+            }),
+            loginWithSms: (phone) => Auth.loginWithSms(phone, { appToken: options.appToken }),
+            verifySmsCode: (request, optionsOverride) => Auth.verifySmsCode(request, mergeRequest(optionsOverride)),
+            registerWithSms: (request, optionsOverride) => Auth.registerWithSms(request, mergeRequest(optionsOverride)),
+        },
+        users: {
+            create: (request) => User.createUser(request, appOptions()),
+            getById: (userId, request) => User.getUserById(userId, mergeRequest(request)),
+            delete: (userId) => User.deleteUser(userId, appOptions()),
+            list: (request) => User.listUsers(mergeRequest(request)),
+            update: (userId, request) => User.updateUser(userId, request, appOptions()),
+            updatePassword: (request) => User.updateUserPassword(request, appOptions()),
+            uploadAvatar: (userId, file) => User.uploadAvatar(userId, file, appOptions()),
+            getAvatarPresignedUrl: (userId) => User.getAvatarPresignedUrl(userId, appOptions()),
+            updateFrozenStatus: (userId, isFrozen) => User.updateUserFrozenStatus(userId, isFrozen, appOptions()),
+            getFrozenStatus: (userId) => User.getUserFrozenStatus(userId, appOptions()),
+        },
+        userGroups: {
+            get: (groupId) => UserGroup.getUserGroup(groupId, appOptions()),
+            list: (request) => UserGroup.listUserGroups(mergeRequest(request)),
+            create: (request) => UserGroup.createUserGroup(request, appOptions()),
+            update: (groupId, request) => UserGroup.updateUserGroup(groupId, request, appOptions()),
+            delete: (groupId) => UserGroup.deleteUserGroup(groupId, appOptions()),
+            listMembers: (groupId, request) => UserGroup.listUserGroupMembers(groupId, mergeRequest(request)),
+            addMembers: (groupId, request) => UserGroup.addUserGroupMembers(groupId, request, appOptions()),
+            removeMembers: (groupId, request) => UserGroup.removeUserGroupMembers(groupId, request, appOptions()),
+            getUserGroups: (userId, request) => UserGroup.getUserGroups(userId, mergeRequest(request)),
+        },
+        userAttributes: {
+            createDefinition: (request) => UserAttribute.createUserAttributeDefinition(request, appOptions()),
+            updateDefinition: (definitionId, request) => UserAttribute.updateUserAttributeDefinition(definitionId, request, appOptions()),
+            deleteDefinition: (definitionId) => UserAttribute.deleteUserAttributeDefinition(definitionId, appOptions()),
+            getDefinition: (definitionId) => UserAttribute.getUserAttributeDefinition(definitionId, appOptions()),
+            listDefinitions: (request) => UserAttribute.listUserAttributeDefinitions(mergeRequest(request)),
+            listEnabledDefinitions: (request) => UserAttribute.listEnabledUserAttributeDefinitions(mergeRequest(request)),
+            toggleDefinitionStatus: (definitionId, enabled) => UserAttribute.toggleUserAttributeDefinitionStatus(definitionId, enabled, appOptions()),
+            set: (userId, attributeDefinitionId, request) => UserAttribute.setUserAttribute(userId, attributeDefinitionId, request, appOptions()),
+            get: (userId, definitionId) => UserAttribute.getUserAttribute(userId, definitionId, appOptions()),
+            delete: (userId, definitionId) => UserAttribute.deleteUserAttribute(userId, definitionId, appOptions()),
+            getUserAttributes: (userId) => UserAttribute.getUserAttributes(userId, appOptions()),
+            listUserAttributes: (userId, request) => UserAttribute.listUserAttributes(userId, mergeRequest(request)),
+            listAttributeUsers: (definitionId, request) => UserAttribute.listAttributeUsers(definitionId, mergeRequest(request)),
+            listAll: (request) => UserAttribute.listAllUserAttributes(mergeRequest(request)),
+        },
+        cms: {
+            getFolder: (folderId) => Cms.getFolder(folderId, appOptions()),
+            listFolders: (request) => Cms.listFolders(mergeRequest(request)),
+            createFolder: (request) => Cms.createFolder(request, appOptions()),
+            updateFolder: (folderId, request) => Cms.updateFolder(folderId, request, appOptions()),
+            deleteFolder: (folderId) => Cms.deleteFolder(folderId, appOptions()),
+            getFile: (fileId) => Cms.getFile(fileId, appOptions()),
+            listFiles: (request) => Cms.listFiles(mergeRequest(request)),
+            createFile: (request) => Cms.createFile(request, appOptions()),
+            updateFile: (fileId, request) => Cms.updateFile(fileId, request, appOptions()),
+            updateFileContent: (fileId, content) => Cms.updateFileContent(fileId, content, appOptions()),
+            deleteFile: (fileId) => Cms.deleteFile(fileId, appOptions()),
+            getFilePresignedUrl: (fileId, expireTimeInSeconds) => Cms.getFilePresignedUrl(fileId, expireTimeInSeconds, appOptions()),
+            batchGetFilePresignedUrl: (fileIds, expireTimeInSeconds) => Cms.batchGetFilePresignedUrl(fileIds, expireTimeInSeconds, appOptions()),
+            getOssMetadata: (fileId) => Cms.getOssMetadata(fileId, appOptions()),
+            getUploadAuthorization: (request) => Cms.getUploadAuthorization(request, appOptions()),
+            getFileStsCredentials: (fileId, fileExtension, durationSeconds) => Cms.getFileStsCredentials(fileId, fileExtension, durationSeconds, appOptions()),
+            fileUploadComplete: (fileId, request) => Cms.fileUploadComplete(fileId, request, appOptions()),
+            setFilePreviewImage: (fileId, request) => Cms.setFilePreviewImage(fileId, request, appOptions()),
+            listFileAttachments: (fileId, request) => Cms.listFileAttachments(fileId, mergeRequest(request)),
+            getFileAttachment: (fileId, attachmentId) => Cms.getFileAttachment(fileId, attachmentId, appOptions()),
+            uploadFileAttachment: (fileId, attachmentTypeId, file, remark) => Cms.uploadFileAttachment(fileId, attachmentTypeId, file, remark, appOptions()),
+            deleteFileAttachment: (fileId, attachmentId) => Cms.deleteFileAttachment(fileId, attachmentId, appOptions()),
+        },
+        tasks: {
+            create: (request) => Task.createUserTask(request, appOptions()),
+            batchCreate: (request) => Task.batchCreateUserTasks(request, appOptions()),
+            get: (taskId) => Task.getUserTask(taskId, appOptions()),
+            batchGet: (request) => Task.batchGetUserTasks(request, appOptions()),
+            list: (request) => Task.listUserTasks(mergeRequest(request)),
+            update: (taskId, request) => Task.updateUserTask(taskId, request, appOptions()),
+            delete: (taskId) => Task.deleteUserTask(taskId, appOptions()),
+            getInput: (taskId) => Task.getTaskInput(taskId, appOptions()),
+            getOutput: (taskId) => Task.getTaskOutput(taskId, appOptions()),
+            updateInput: (taskId, input) => Task.updateTaskInput(taskId, input, appOptions()),
+            updateOutput: (taskId, output) => Task.updateTaskOutput(taskId, output, appOptions()),
+            getStatus: (taskId) => Task.getTaskStatus(taskId, appOptions()),
+            updateStatus: (taskId, status) => Task.updateTaskStatus(taskId, status, appOptions()),
+            getStatistics: (userId) => Task.getTaskStatistics(userId, appOptions()),
+            getFrozenStatus: (taskId) => Task.getTaskFrozenStatus(taskId, appOptions()),
+            updateFrozenStatus: (taskId, isFrozen) => Task.updateTaskFrozenStatus(taskId, isFrozen, appOptions()),
+            listAttachments: (taskId, request) => Task.listTaskAttachments(taskId, mergeRequest(request)),
+            getAttachment: (taskId, attachmentId) => Task.getTaskAttachment(taskId, attachmentId, appOptions()),
+            uploadAttachment: (taskId, attachmentTypeId, file, remark) => Task.uploadTaskAttachment(taskId, attachmentTypeId, file, remark, appOptions()),
+            deleteAttachment: (taskId, attachmentId) => Task.deleteTaskAttachment(taskId, attachmentId, appOptions()),
+        },
+        taskTypes: {
+            create: (request) => TaskType.createTaskType(request, appOptions()),
+            update: (taskTypeId, request) => TaskType.updateTaskType(taskTypeId, request, appOptions()),
+            delete: (taskTypeId) => TaskType.deleteTaskType(taskTypeId, appOptions()),
+            get: (taskTypeId) => TaskType.getTaskType(taskTypeId, appOptions()),
+            list: (request) => TaskType.listTaskTypes(mergeRequest(request)),
+            listEnabled: (request) => TaskType.listEnabledTaskTypes(mergeRequest(request)),
+        },
+        rbac: {
+            getRole: (roleId) => Rbac.getRole(roleId, appOptions()),
+            listRoles: (request) => Rbac.listRoles(mergeRequest(request)),
+            createRole: (request) => Rbac.createRole(request, appOptions()),
+            updateRole: (roleId, request) => Rbac.updateRole(roleId, request, appOptions()),
+            deleteRole: (roleId) => Rbac.deleteRole(roleId, appOptions()),
+            getPrivilege: (privilegeId) => Rbac.getPrivilege(privilegeId, appOptions()),
+            listPrivileges: (request) => Rbac.listPrivileges(mergeRequest(request)),
+            createPrivilege: (request) => Rbac.createPrivilege(request, appOptions()),
+            updatePrivilege: (privilegeId, request) => Rbac.updatePrivilege(privilegeId, request, appOptions()),
+            deletePrivilege: (privilegeId) => Rbac.deletePrivilege(privilegeId, appOptions()),
+            getUserRoles: (userId) => Rbac.getUserRoles(userId, appOptions()),
+            assignRolesToUser: (userId, request) => Rbac.assignRolesToUser(userId, request, appOptions()),
+            unassignRolesFromUser: (userId, request) => Rbac.unassignRolesFromUser(userId, request, appOptions()),
+            getUserPrivileges: (userId) => Rbac.getUserPrivileges(userId, appOptions()),
+            assignPrivilegesToUser: (userId, request) => Rbac.assignPrivilegesToUser(userId, request, appOptions()),
+            unassignPrivilegesFromUser: (userId, request) => Rbac.unassignPrivilegesFromUser(userId, request, appOptions()),
+            assignPrivilegesToRole: (roleId, request) => Rbac.assignPrivilegesToRole(roleId, request, appOptions()),
+            unassignPrivilegesFromRole: (roleId, request) => Rbac.unassignPrivilegesFromRole(roleId, request, appOptions()),
+        },
+        acl: {
+            getRecord: (recordId) => Acl.getAclRecord(recordId, appOptions()),
+            listRecords: (request) => Acl.listAclRecords(mergeRequest(request)),
+            createRecord: (request) => Acl.createAclRecord(request, appOptions()),
+            batchCreateRecords: (request) => Acl.batchCreateAclRecords(request, appOptions()),
+            updateRecord: (recordId, request) => Acl.updateAclRecord(recordId, request, appOptions()),
+            deleteRecord: (recordId) => Acl.deleteAclRecord(recordId, appOptions()),
+            getTemplate: (templateId) => Acl.getAclTemplate(templateId, appOptions()),
+            listTemplates: (request) => Acl.listAclTemplates(mergeRequest(request)),
+            createTemplate: (request) => Acl.createAclTemplate(request, appOptions()),
+            updateTemplate: (templateId, request) => Acl.updateAclTemplate(templateId, request, appOptions()),
+            deleteTemplate: (templateId) => Acl.deleteAclTemplate(templateId, appOptions()),
+            listRecordAttachments: (recordId, request) => Acl.listAclRecordAttachments(recordId, mergeRequest(request)),
+            getRecordAttachment: (recordId, attachmentId) => Acl.getAclRecordAttachment(recordId, attachmentId, appOptions()),
+            uploadRecordAttachment: (recordId, attachmentTypeId, file, remark) => Acl.uploadAclRecordAttachment(recordId, attachmentTypeId, file, remark, appOptions()),
+            deleteRecordAttachment: (recordId, attachmentId) => Acl.deleteAclRecordAttachment(recordId, attachmentId, appOptions()),
+        },
+        attachments: {
+            get: (attachmentId) => Attachment.getAttachment(attachmentId, appOptions()),
+            listByRef: (request) => Attachment.listAttachmentsByRef(mergeRequest(request)),
+            upload: (request) => Attachment.uploadAttachment(mergeRequest(request)),
+            delete: (request) => Attachment.deleteAttachment(mergeRequest(request)),
+            getUploadUrl: (request) => Attachment.getAttachmentUploadUrl(mergeRequest(request)),
+            completeUpload: (attachmentId, request) => Attachment.completeAttachmentUpload(attachmentId, request, appOptions()),
+            getDownloadUrl: (request) => Attachment.getAttachmentDownloadUrl(mergeRequest(request)),
+        },
+        attachmentTypes: {
+            list: (request) => AttachmentType.listAttachmentTypes(mergeRequest(request)),
+            listByRef: (request) => AttachmentType.listAttachmentTypesByRef(mergeRequest(request)),
+            get: (typeId) => AttachmentType.getAttachmentType(typeId, appOptions()),
+            create: (request) => AttachmentType.createAttachmentType(request, appOptions()),
+            update: (typeId, request) => AttachmentType.updateAttachmentType(typeId, request, appOptions()),
+            delete: (typeId) => AttachmentType.deleteAttachmentType(typeId, appOptions()),
+        },
+        dashboard: {
+            getView: (viewName, request) => Dashboard.getDashboardView(viewName, mergeRequest(request)),
+            queryView: (request) => Dashboard.queryDashboardView(request, appOptions()),
+        },
+        appTokens: {
+            list: (request) => AppToken.listAppTokens(mergeRequest(request)),
+        },
+    };
+}

package/dist/index.d.ts

@@ -14,6 +14,8 @@ export * from "./attachment-type/index.js";
 export * from "./app/index.js";
 export * from "./app-token/index.js";
 export * from "./dashboard/index.js";
+export * from "./admin.js";
+export * from "./app-client.js";
 export * from "./errors.js";
 export type { CommonOptions, PageResponse, UserGroup, Role, Privilege, AppInfo, User, } from "./common/types.js";
 export type { Attachment, AttachmentRefType, ListAttachmentsByRefRequest, UploadAttachmentRequest, UploadAuthorizationRequest, CompleteUploadRequest, DeleteAttachmentRequest, DownloadAttachmentUrlRequest, DownloadUrlResponse, AttachmentOptions, } from "./attachment/types.js";

package/dist/index.js

@@ -14,4 +14,6 @@ export * from "./attachment-type/index.js";
 export * from "./app/index.js";
 export * from "./app-token/index.js";
 export * from "./dashboard/index.js";
+export * from "./admin.js";
+export * from "./app-client.js";
 export * from "./errors.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turinhub/tale-js-sdk",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Official TypeScript SDK for Tale backend services",
   "keywords": [
     "tale",
@@ -22,6 +22,21 @@
   "author": "Turinhub <dev@turinhub.com>",
   "type": "module",
   "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./admin": {
+      "types": "./dist/admin.d.ts",
+      "import": "./dist/admin.js"
+    },
+    "./app": {
+      "types": "./dist/app-client.d.ts",
+      "import": "./dist/app-client.js"
+    },
+    "./dist/*": "./dist/*"
+  },
   "scripts": {
     "test": "pnpm run build && node --env-file=.env --experimental-vm-modules ./node_modules/jest/bin/jest.js",
     "test:unit": "pnpm run build && node --env-file=.env --experimental-vm-modules ./node_modules/jest/bin/jest.js --testPathIgnorePatterns='integration'",