@appthen/sdk-core 0.0.0

package/dist-cjs/index.js

@@ -0,0 +1,802 @@
+"use strict";
+/**
+ * @appthen/sdk-core
+ *
+ * 平台无关的 Conversation Hub SDK 核心。
+ *
+ * V0 先对齐目前已经落地的 Hub API：
+ * - open-platform/token
+ * - subject-directory/open/*
+ * - conversation-runtime/open/*
+ * - 内部 JWT 保护的查询接口（messages / conversations）
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformApi = exports.ChatHubAppRuntime = exports.ChatHubClient = exports.MessagesApi = exports.ConversationsApi = exports.ConversationTypesApi = exports.SubjectDirectoryApi = exports.OpenPlatformApi = exports.SDK_VERSION = void 0;
+exports.resolveChatHubMessagePolicy = resolveChatHubMessagePolicy;
+exports.createChatHubAppRuntime = createChatHubAppRuntime;
+exports.SDK_VERSION = '0.1.0';
+function resolveChatHubMessagePolicy(value) {
+    const policy = value && typeof value === 'object' ? value : {};
+    return {
+        allowRichText: policy.allowRichText !== false,
+        allowCopy: policy.allowCopy !== false,
+        allowReply: policy.allowReply !== false,
+        allowForward: policy.allowForward !== false,
+        allowMultiForwardSelection: policy.allowMultiForwardSelection !== false,
+        allowDelete: policy.allowDelete === true,
+        allowRevoke: policy.allowRevoke === true,
+    };
+}
+function withBearerToken(headers, token) {
+    if (!token) {
+        return headers || {};
+    }
+    return {
+        ...(headers || {}),
+        Authorization: `Bearer ${token}`,
+    };
+}
+class BaseApi {
+    constructor(http, auth) {
+        this.http = http;
+        this.auth = auth;
+    }
+    async request(options) {
+        const token = await this.auth.getToken();
+        const response = await this.http.request({
+            ...options,
+            headers: withBearerToken(options.headers, token),
+        });
+        return response.data;
+    }
+}
+class OpenPlatformApi extends BaseApi {
+    async issueToken(input) {
+        return this.request({
+            method: 'POST',
+            path: '/open-platform/token',
+            body: input,
+        });
+    }
+    async getCurrentTokenPayload() {
+        return this.request({
+            method: 'GET',
+            path: '/open-platform/token/current',
+        });
+    }
+}
+exports.OpenPlatformApi = OpenPlatformApi;
+class SubjectDirectoryApi extends BaseApi {
+    async createSubject(input) {
+        return this.request({
+            method: 'POST',
+            path: '/subject-directory/open/subjects',
+            body: input,
+        });
+    }
+    async createSubjectClass(input) {
+        return this.request({
+            method: 'POST',
+            path: '/subject-directory/open/subject-classes',
+            body: input,
+        });
+    }
+    async createSubjectInternal(input) {
+        return this.request({
+            method: 'POST',
+            path: '/subject-directory/subjects',
+            body: input,
+        });
+    }
+    async createSubjectClassInternal(input) {
+        return this.request({
+            method: 'POST',
+            path: '/subject-directory/subject-classes',
+            body: input,
+        });
+    }
+    async createExternalIdentity(input) {
+        return this.request({
+            method: 'POST',
+            path: '/subject-directory/open/external-identities',
+            body: input,
+        });
+    }
+    async findSubjectByExternalIdentity(query) {
+        return this.request({
+            method: 'GET',
+            path: '/subject-directory/open/subjects/by-external-identity',
+            query,
+        });
+    }
+    async getSubjectContext(subjectId) {
+        return this.request({
+            method: 'GET',
+            path: `/subject-directory/open/subjects/${encodeURIComponent(subjectId)}/context`,
+        });
+    }
+    async listSubjects(query) {
+        return this.request({
+            method: 'GET',
+            path: '/subject-directory/subjects',
+            query: { ...query },
+        });
+    }
+    async getSubjectContextInternal(tenantId, subjectId) {
+        return this.request({
+            method: 'GET',
+            path: `/subject-directory/subjects/${encodeURIComponent(subjectId)}/context`,
+            query: { tenantId },
+        });
+    }
+}
+exports.SubjectDirectoryApi = SubjectDirectoryApi;
+class ConversationTypesApi extends BaseApi {
+    async create(input) {
+        return this.request({
+            method: 'POST',
+            path: '/conversation-runtime/open/types',
+            body: input,
+        });
+    }
+    async resolveCapabilities(typeId, query = {}) {
+        return this.request({
+            method: 'GET',
+            path: `/conversation-runtime/open/types/${encodeURIComponent(typeId)}/capabilities`,
+            query,
+        });
+    }
+    async createInternal(input) {
+        return this.request({
+            method: 'POST',
+            path: '/conversation-runtime/types',
+            body: input,
+        });
+    }
+    async listInternal(query) {
+        return this.request({
+            method: 'GET',
+            path: '/conversation-runtime/types',
+            query: { ...query },
+        });
+    }
+}
+exports.ConversationTypesApi = ConversationTypesApi;
+class ConversationsApi extends BaseApi {
+    async create(input) {
+        return this.request({
+            method: 'POST',
+            path: '/conversation-runtime/open/conversations',
+            body: input,
+        });
+    }
+    async createInternal(input) {
+        return this.request({
+            method: 'POST',
+            path: '/conversation-runtime/conversations',
+            body: input,
+        });
+    }
+    async list(query = {}) {
+        return this.request({
+            method: 'GET',
+            path: '/conversation-runtime/conversations',
+            query: query,
+        });
+    }
+    async addParticipant(input) {
+        return this.request({
+            method: 'POST',
+            path: '/conversation-runtime/participants',
+            body: input,
+        });
+    }
+    async addParticipantInternal(input) {
+        return this.request({
+            method: 'POST',
+            path: '/conversation-runtime/participants',
+            body: input,
+        });
+    }
+    async listParticipants(query) {
+        return this.request({
+            method: 'GET',
+            path: '/conversation-runtime/participants',
+            query: { ...query },
+        });
+    }
+}
+exports.ConversationsApi = ConversationsApi;
+class MessagesApi extends BaseApi {
+    async create(input) {
+        return this.request({
+            method: 'POST',
+            path: '/conversation-runtime/open/messages',
+            body: input,
+        });
+    }
+    async createInternal(input) {
+        return this.request({
+            method: 'POST',
+            path: '/conversation-runtime/messages',
+            body: input,
+        });
+    }
+    async list(query) {
+        return this.request({
+            method: 'GET',
+            path: '/conversation-runtime/messages',
+            query: { ...query },
+        });
+    }
+    async updateInternal(messageId, input) {
+        return this.request({
+            method: 'PATCH',
+            path: `/conversation-runtime/messages/${messageId}`,
+            query: {
+                tenantId: input.tenantId,
+            },
+            body: {
+                status: input.status,
+                content: input.content,
+                metadata: input.metadata,
+                actorSubjectId: input.actorSubjectId,
+            },
+        });
+    }
+}
+exports.MessagesApi = MessagesApi;
+function stableUnique(items) {
+    return Array.from(new Set(items));
+}
+function createRuntimeMessageId() {
+    return `message-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function createRuntimeConversationId() {
+    return `conversation-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function resolveMessagePageCursor(message) {
+    if (!message) {
+        return undefined;
+    }
+    if (typeof message.createdAt === 'string') {
+        return message.createdAt;
+    }
+    if (typeof message.updatedAt === 'string') {
+        return message.updatedAt;
+    }
+    return undefined;
+}
+class ChatHubClient {
+    constructor(options) {
+        this.options = options;
+        this.openPlatform = new OpenPlatformApi(options.http, options.auth);
+        this.subjects = new SubjectDirectoryApi(options.http, options.auth);
+        this.conversationTypes = new ConversationTypesApi(options.http, options.auth);
+        this.conversations = new ConversationsApi(options.http, options.auth);
+        this.messages = new MessagesApi(options.http, options.auth);
+        this.realtime = options.realtime;
+    }
+    async setToken(token) {
+        await this.options.auth.setToken(token);
+    }
+    async getToken() {
+        return this.options.auth.getToken();
+    }
+    async issueAppToken(input) {
+        const result = await this.openPlatform.issueToken(input);
+        if (result.token) {
+            await this.setToken(result.token);
+        }
+        return result;
+    }
+    async connectRealtime() {
+        if (!this.realtime?.connect) {
+            return;
+        }
+        await this.realtime.connect(await this.getToken());
+    }
+    async disconnectRealtime() {
+        if (!this.realtime?.disconnect) {
+            return;
+        }
+        await this.realtime.disconnect();
+    }
+}
+exports.ChatHubClient = ChatHubClient;
+class ChatHubAppRuntime {
+    constructor(client, config) {
+        this.client = client;
+        this.config = config;
+    }
+    get tenantId() {
+        return this.config.tenant.tenantId;
+    }
+    get appConfig() {
+        return this.config;
+    }
+    /** 暴露底层实时适配器，供宿主加入自定义房间 / 监听全局事件（跨设备同步等）。 */
+    get realtime() {
+        return this.client.realtime;
+    }
+    async connectRealtime() {
+        await this.client.connectRealtime();
+    }
+    async disconnectRealtime() {
+        await this.client.disconnectRealtime();
+    }
+    async subscribeConversation(conversationId) {
+        try {
+            await this.ensureAuthenticated();
+            await this.client.connectRealtime();
+            if (!this.client.realtime?.subscribeConversation) {
+                console.warn('[chat-hub-sdk] subscribeConversation: no realtime adapter');
+                return null;
+            }
+            const sub = await this.client.realtime.subscribeConversation(conversationId);
+            console.info('[chat-hub-sdk] subscribeConversation ok', conversationId, Boolean(sub));
+            return sub;
+        }
+        catch (error) {
+            console.warn('[chat-hub-sdk] subscribeConversation failed', conversationId, error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+    }
+    async publishConversationEvent(conversationId, event) {
+        await this.ensureAuthenticated();
+        await this.client.connectRealtime();
+        if (!this.client.realtime?.publishConversationEvent) {
+            return;
+        }
+        await this.client.realtime.publishConversationEvent(conversationId, event);
+    }
+    async updateConversationTyping(input) {
+        await this.publishConversationEvent(input.conversationId, {
+            eventName: 'conversation.typing.updated',
+            conversationId: input.conversationId,
+            isTyping: input.isTyping,
+            senderSubjectId: input.senderSubjectId,
+            metadata: input.metadata,
+        });
+    }
+    async updateConversationRead(input) {
+        await this.publishConversationEvent(input.conversationId, {
+            eventName: 'conversation.read.updated',
+            conversationId: input.conversationId,
+            messageId: input.messageId,
+            readAt: new Date().toISOString(),
+            metadata: input.metadata,
+        });
+    }
+    async ensureAuthenticated() {
+        if (this.config.auth.mode !== 'tenant_app_token') {
+            return;
+        }
+        if (!this.config.auth.appTokenInput) {
+            throw new Error('tenant_app_token mode requires appTokenInput');
+        }
+        const token = await this.client.getToken();
+        if (token) {
+            return;
+        }
+        await this.client.issueAppToken(this.config.auth.appTokenInput);
+    }
+    async bootstrapConversation() {
+        await this.ensureAuthenticated();
+        await this.ensureSubjectClasses();
+        await this.ensureSubjects();
+        await this.ensureConversationType();
+        const conversation = await this.createConversationFromPreset();
+        return {
+            tenantId: this.tenantId,
+            subjectClassIds: stableUnique((this.config.subjectClasses || []).map((item) => item.classId)),
+            subjectIds: stableUnique((this.config.subjects || []).map((item) => item.subjectId)),
+            conversationTypeId: this.config.conversationType?.typeId,
+            conversation,
+        };
+    }
+    async listConversations(subjectId) {
+        await this.ensureAuthenticated();
+        const resolvedSubjectId = subjectId || this.config.subjects?.[0]?.subjectId || undefined;
+        const conversations = await this.client.conversations.list({
+            tenantId: this.tenantId,
+            typeId: this.config.conversationType?.typeId,
+            subjectId: resolvedSubjectId,
+        });
+        // Participants are intentionally NOT fetched here: doing so would fan out
+        // one `/conversation-runtime/participants` HTTP request per conversation
+        // (N+1) on the conversation-list path, which on open produced dozens of
+        // concurrent requests. The timeline view loads participants on demand for
+        // the selected conversation only (see ConversationHubView).
+        return conversations;
+    }
+    async listMessages(input) {
+        await this.ensureAuthenticated();
+        const query = typeof input === 'string'
+            ? {
+                conversationId: input,
+            }
+            : input;
+        return this.client.messages.list({
+            tenantId: this.tenantId,
+            conversationId: query.conversationId,
+            limit: query.limit,
+            beforeCreatedAt: query.beforeCreatedAt,
+            afterSequence: query.afterSequence,
+        });
+    }
+    async listMessagesPage(input) {
+        await this.ensureAuthenticated();
+        const query = typeof input === 'string'
+            ? {
+                conversationId: input,
+            }
+            : input;
+        const normalizedLimit = typeof query.limit === 'number' && Number.isFinite(query.limit)
+            ? Math.min(Math.max(Math.floor(query.limit), 1), 100)
+            : undefined;
+        if (!normalizedLimit) {
+            const items = await this.client.messages.list({
+                tenantId: this.tenantId,
+                conversationId: query.conversationId,
+                beforeCreatedAt: query.beforeCreatedAt,
+                afterSequence: query.afterSequence,
+            });
+            return {
+                items,
+                hasMore: false,
+                nextBeforeCreatedAt: resolveMessagePageCursor(items[0]),
+            };
+        }
+        const records = await this.client.messages.list({
+            tenantId: this.tenantId,
+            conversationId: query.conversationId,
+            limit: Math.min(normalizedLimit + 1, 100),
+            beforeCreatedAt: query.beforeCreatedAt,
+            afterSequence: query.afterSequence,
+        });
+        const hasMore = records.length > normalizedLimit;
+        const items = hasMore ? records.slice(records.length - normalizedLimit) : records;
+        return {
+            items,
+            hasMore,
+            nextBeforeCreatedAt: resolveMessagePageCursor(items[0]),
+        };
+    }
+    async ensureParticipant(input) {
+        await this.ensureAuthenticated();
+        await this.ensureSubjectClasses();
+        await this.ensureSubjects();
+        await this.ensureConversationType();
+        return this.client.conversations.addParticipantInternal({
+            tenantId: this.tenantId,
+            conversationId: input.conversationId,
+            subjectId: input.subjectId,
+            role: input.role,
+            status: input.status || 'active',
+            visibilityScope: input.visibilityScope,
+            capabilityScope: input.capabilityScope,
+        });
+    }
+    watchConversationMessages(options) {
+        const limit = typeof options.limit === 'number' && Number.isFinite(options.limit)
+            ? Math.min(Math.max(Math.floor(options.limit), 1), 100)
+            : 20;
+        const fallbackIntervalMs = Math.max(options.fallbackIntervalMs ?? 30000, 5000);
+        const healthcheckIntervalMs = Math.max(options.healthcheckIntervalMs ?? 120000, 15000);
+        const pauseWhenHidden = options.pauseWhenHidden !== false;
+        let closed = false;
+        let subscription = null;
+        let fallbackTimer = null;
+        let refreshPromise = null;
+        let lastSequence = typeof options.initialLastSequence === 'number' &&
+            Number.isFinite(options.initialLastSequence)
+            ? Math.max(Math.floor(options.initialLastSequence), 0)
+            : 0;
+        const timerApi = globalThis;
+        const shouldPause = () => pauseWhenHidden &&
+            typeof globalThis !== 'undefined' &&
+            Boolean(globalThis.document
+                ?.hidden);
+        const clearFallback = () => {
+            if (fallbackTimer !== null) {
+                timerApi.clearInterval?.(fallbackTimer);
+                fallbackTimer = null;
+            }
+        };
+        const ensureFallback = (intervalMs) => {
+            if (fallbackTimer !== null || closed || !timerApi.setInterval)
+                return;
+            fallbackTimer = timerApi.setInterval(() => {
+                void refresh('fallback');
+            }, intervalMs);
+        };
+        const refresh = async (reason = 'manual') => {
+            if (closed || shouldPause())
+                return;
+            if (refreshPromise) {
+                return refreshPromise;
+            }
+            const afterSequence = lastSequence;
+            refreshPromise = (async () => {
+                try {
+                    const messages = await this.listMessages({
+                        conversationId: options.conversationId,
+                        limit,
+                        afterSequence,
+                    });
+                    const maxSequence = messages.reduce((current, message) => {
+                        const sequence = typeof message.sequence === 'number' && Number.isFinite(message.sequence)
+                            ? Math.floor(message.sequence)
+                            : current;
+                        return Math.max(current, sequence);
+                    }, lastSequence);
+                    lastSequence = Math.max(lastSequence, maxSequence);
+                    await options.onMessages({ reason, messages, afterSequence });
+                }
+                catch (error) {
+                    options.onError?.(error);
+                }
+                finally {
+                    refreshPromise = null;
+                }
+            })();
+            return refreshPromise;
+        };
+        const startRealtime = async () => {
+            try {
+                console.info('[chat-hub-sdk] watch startRealtime', options.conversationId);
+                subscription = await this.subscribeConversation(options.conversationId);
+                if (!subscription) {
+                    console.warn('[chat-hub-sdk] watch no realtime subscription, fallback only');
+                    ensureFallback(fallbackIntervalMs);
+                    return;
+                }
+                console.info('[chat-hub-sdk] watch realtime subscription active');
+                ensureFallback(healthcheckIntervalMs);
+                for await (const event of subscription) {
+                    if (closed)
+                        break;
+                    await options.onEvent?.(event);
+                    const eventRecord = event && typeof event === 'object' ? event : {};
+                    const eventName = eventRecord.eventName;
+                    if (eventName === 'conversation.message.created' ||
+                        eventName === 'conversation.message.updated') {
+                        const eventConversationId = typeof eventRecord.conversationId === 'string'
+                            ? eventRecord.conversationId
+                            : '';
+                        const eventMessage = eventRecord.message;
+                        if (eventConversationId === options.conversationId &&
+                            eventMessage &&
+                            typeof eventMessage === 'object') {
+                            await options.onMessages({
+                                reason: 'realtime_event',
+                                messages: [eventMessage],
+                                afterSequence: lastSequence,
+                            });
+                        }
+                        const sequence = typeof eventRecord.sequence === 'number' &&
+                            Number.isFinite(eventRecord.sequence)
+                            ? Math.floor(eventRecord.sequence)
+                            : null;
+                        if (sequence !== null && sequence <= lastSequence) {
+                            continue;
+                        }
+                        await refresh('realtime_event');
+                    }
+                }
+            }
+            catch (error) {
+                options.onError?.(error);
+                ensureFallback(fallbackIntervalMs);
+            }
+        };
+        void startRealtime();
+        if (options.immediate !== false) {
+            void refresh('initial');
+        }
+        return {
+            refresh,
+            close: async () => {
+                closed = true;
+                clearFallback();
+                if (subscription) {
+                    await subscription.close();
+                }
+            },
+        };
+    }
+    async sendTextMessage(input) {
+        return this.sendMessage({
+            conversationId: input.conversationId,
+            senderSubjectId: input.senderSubjectId,
+            kind: 'text',
+            content: {
+                text: input.text,
+                attachments: input.attachments || [],
+            },
+            messageId: input.messageId,
+            mentionedSubjectIds: input.mentionedSubjectIds,
+            metadata: input.metadata,
+            status: input.status,
+        });
+    }
+    async sendMessage(input) {
+        await this.ensureAuthenticated();
+        return this.client.messages.createInternal({
+            tenantId: this.tenantId,
+            conversationId: input.conversationId,
+            messageId: input.messageId || createRuntimeMessageId(),
+            senderSubjectId: input.senderSubjectId,
+            kind: input.kind,
+            status: input.status || 'sent',
+            content: input.content,
+            mentionedSubjectIds: input.mentionedSubjectIds,
+            metadata: input.metadata,
+        });
+    }
+    async updateMessage(input) {
+        await this.ensureAuthenticated();
+        return this.client.messages.updateInternal(input.messageId, {
+            tenantId: this.tenantId,
+            status: input.status,
+            content: input.content,
+            metadata: input.metadata,
+            actorSubjectId: input.actorSubjectId,
+        });
+    }
+    async deleteMessage(input) {
+        return this.updateMessage({
+            ...input,
+            status: 'deleted',
+        });
+    }
+    async revokeMessage(input) {
+        return this.updateMessage({
+            ...input,
+            status: 'revoked',
+        });
+    }
+    async ensureSubjectClasses() {
+        for (const preset of this.config.subjectClasses || []) {
+            try {
+                await this.client.subjects.createSubjectClassInternal({
+                    tenantId: this.tenantId,
+                    classId: preset.classId,
+                    label: preset.label,
+                    ontology: preset.ontology,
+                    scope: preset.scope,
+                    lifecycle: preset.lifecycle,
+                    status: preset.status || 'active',
+                    instanceMatcher: preset.instanceMatcher,
+                    openRegistration: preset.openRegistration,
+                    requiredExternalIdentity: preset.requiredExternalIdentity,
+                    tags: preset.tags,
+                    notes: preset.notes,
+                });
+            }
+            catch {
+                // Reuse existing definitions when the class has already been created.
+            }
+        }
+    }
+    async ensureSubjects() {
+        for (const preset of this.config.subjects || []) {
+            // 跳过隐式构造的占位 subject：前端 shell 会把隐式 human/agent 占位
+            // （subjectId 形如 "subject-*-hub-<tenant>-default" 或 "subject-human-*"）
+            // 一并塞进 config.subjects，ensureSubjects 若持久化它们会在 subject_directory
+            // 产生脏记录，进而被后端当成真实实例反复加入新建会话参与者。
+            // 这类占位不属于用户手动创建的真实主体，不应落库。
+            const subjectId = String(preset?.subjectId || '');
+            if (/^subject-.+-hub-[0-9a-f]{24}-default$/.test(subjectId) ||
+                /^subject-(human|agent|system)-/.test(subjectId)) {
+                continue;
+            }
+            try {
+                await this.client.subjects.createSubjectInternal({
+                    tenantId: this.tenantId,
+                    subjectId: preset.subjectId,
+                    classId: preset.classId,
+                    displayName: preset.displayName,
+                    status: preset.status || 'active',
+                    avatarUrl: preset.avatarUrl,
+                    profile: preset.profile,
+                    tags: preset.tags,
+                });
+            }
+            catch {
+                // Reuse existing subject records when they already exist.
+            }
+        }
+    }
+    async ensureConversationType() {
+        const preset = this.config.conversationType;
+        if (!preset) {
+            return;
+        }
+        try {
+            await this.client.conversationTypes.createInternal({
+                tenantId: this.tenantId,
+                typeId: preset.typeId,
+                name: preset.name,
+                label: preset.label,
+                conversationKind: preset.conversationKind,
+                status: preset.status || 'active',
+                welcomeMessage: preset.welcomeMessage,
+                creatorPolicy: preset.creatorPolicy,
+                audiencePolicy: preset.audiencePolicy,
+                messagePolicy: preset.messagePolicy,
+                defaultCapabilities: preset.defaultCapabilities,
+                optionalCapabilities: preset.optionalCapabilities,
+                restrictedCapabilities: preset.restrictedCapabilities,
+                triggeredCapabilities: preset.triggeredCapabilities,
+                capabilityTiers: preset.capabilityTiers,
+                metadata: preset.metadata,
+            });
+        }
+        catch {
+            // Reuse existing type definitions when the type has already been created.
+        }
+    }
+    async createConversationFromPreset() {
+        const preset = this.config.conversation;
+        if (!preset) {
+            return undefined;
+        }
+        const conversationId = createRuntimeConversationId();
+        const conversation = await this.client.conversations.createInternal({
+            tenantId: this.tenantId,
+            conversationId,
+            typeId: preset.typeId,
+            title: preset.title,
+            createdBySubjectId: preset.createdBySubjectId,
+            parentConversationId: preset.parentConversationId,
+            relation: preset.relation,
+            status: preset.status || 'active',
+            metadata: preset.metadata,
+        });
+        await Promise.all((preset.participants || []).map((participant) => this.client.conversations.addParticipantInternal({
+            tenantId: this.tenantId,
+            conversationId,
+            subjectId: participant.subjectId,
+            role: participant.role,
+            status: participant.status || 'active',
+        })));
+        return conversation;
+    }
+}
+exports.ChatHubAppRuntime = ChatHubAppRuntime;
+function createChatHubAppRuntime(client, config) {
+    return new ChatHubAppRuntime(client, config);
+}
+class PlatformApi extends BaseApi {
+    async provisionTenant(input) {
+        return this.request({
+            method: 'POST',
+            path: '/open-platform/platform/tenants',
+            body: input,
+        });
+    }
+    async syncSubject(targetTenantId, input) {
+        return this.request({
+            method: 'POST',
+            path: '/open-platform/platform/subjects:sync',
+            body: { ...input, targetTenantId },
+        });
+    }
+    async resolveTenant(externalCorrelationId) {
+        return this.request({
+            method: 'GET',
+            path: '/open-platform/platform/tenants:resolve',
+            query: { externalCorrelationId },
+        });
+    }
+    async toggleGrant(grantId, status) {
+        return this.request({
+            method: 'POST',
+            path: `/open-platform/platform/grants/${encodeURIComponent(grantId)}/toggle`,
+            body: { status },
+        });
+    }
+}
+exports.PlatformApi = PlatformApi;