@lucern/sdk 0.2.0-alpha.4 → 0.2.0-alpha.6

package/dist/lib/platform/sdk/gatewayFacades.js

@@ -0,0 +1,845 @@
+import { createGatewayRequestClient, randomIdempotencyKey, toQueryString, } from "./coreClient.js";
+import { createOntologyClient, } from "./ontologyClient.js";
+import { createGraphClient } from "./graphClient.js";
+import { createIdentityClient } from "./identityClient.js";
+import { createTopicsClient, } from "./topicsClient.js";
+function serializeTypes(types) {
+    return Array.isArray(types) && types.length > 0 ? types.join(",") : undefined;
+}
+export function createBeliefsFacade(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async create(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/beliefs",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async get(id) {
+            return gateway.request({
+                path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}`,
+            });
+        },
+        async list(query) {
+            return gateway.request({
+                path: `/api/platform/v1/beliefs${toQueryString({
+                    topicId: query.topicId,
+                    status: query.status,
+                    worktreeId: query.worktreeId,
+                    minConfidence: query.minConfidence,
+                    limit: query.limit,
+                    cursor: query.cursor,
+                })}`,
+            });
+        },
+        async refine(id, input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}`,
+                method: "PATCH",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async fork(id, input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/fork`,
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async updateConfidence(id, input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/confidence`,
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async updateStatus(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/beliefs/update-status",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async updateRationale(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/beliefs/update-rationale",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async linkBeliefs(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/beliefs/link",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async unlinkEvidence(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/beliefs/unlink-evidence",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async updateCriticality(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/beliefs/update-criticality",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async batchUpdateCriticality(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/beliefs/batch-update-criticality",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async reassignTopic(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/beliefs/reassign-topic",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async archive(id, input = {}, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}`,
+                method: "DELETE",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async lineage(id) {
+            return gateway.request({
+                path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/lineage`,
+            });
+        },
+        async confidenceHistory(id) {
+            return gateway.request({
+                path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/confidence-history`,
+            });
+        },
+        async createContract(id, input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/contracts`,
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async bisect(id, input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/bisect`,
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+    };
+}
+export function createContradictionsFacade(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async flag(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/contradictions",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async list(query) {
+            return gateway.request({
+                path: `/api/platform/v1/contradictions${toQueryString({
+                    topicId: query.topicId,
+                    status: query.status,
+                    limit: query.limit,
+                    cursor: query.cursor,
+                })}`,
+            });
+        },
+        async get(id) {
+            return gateway.request({
+                path: `/api/platform/v1/contradictions/${encodeURIComponent(id)}`,
+            });
+        },
+    };
+}
+export function createEdgesFacade(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async create(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/edges",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async list(query) {
+            return gateway.request({
+                path: `/api/platform/v1/edges${toQueryString({
+                    sourceId: query.sourceId,
+                    edgeType: query.edgeType,
+                    limit: query.limit,
+                    cursor: query.cursor,
+                })}`,
+            });
+        },
+        async traverse(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/edges/traverse",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async update(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/edges/update",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async remove(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/edges/remove",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async removeBetween(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/edges/remove-between",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async batchCreate(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/edges/batch",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async delete(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/edges/delete",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+    };
+}
+export function createEvidenceFacade(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async create(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/evidence",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async get(id) {
+            return gateway.request({
+                path: `/api/platform/v1/evidence/${encodeURIComponent(id)}`,
+            });
+        },
+        async list(query) {
+            return gateway.request({
+                path: `/api/platform/v1/evidence${toQueryString({
+                    topicId: query.topicId,
+                    targetId: query.targetId,
+                    limit: query.limit,
+                    cursor: query.cursor,
+                })}`,
+            });
+        },
+        async link(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/evidence/${encodeURIComponent(input.evidenceId)}/link`,
+                method: "POST",
+                body: {
+                    targetId: input.targetId,
+                    targetType: input.targetType,
+                    weight: input.weight,
+                    rationale: input.rationale,
+                },
+                idempotencyKey,
+            });
+        },
+        async search(query, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/evidence/search",
+                method: "POST",
+                body: query,
+                idempotencyKey,
+            });
+        },
+        async updateStatus(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/evidence/update-status",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async update(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/evidence/update",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async flagIncorrect(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/evidence/flag-incorrect",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async remove(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/evidence/remove",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async updateVerificationStatus(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/evidence/update-verification-status",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+    };
+}
+export function createEventsFacade(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async list(query = {}) {
+            return gateway.request({
+                path: `/api/platform/v1/events${toQueryString({
+                    topicId: query.topicId,
+                    after: query.after,
+                    types: serializeTypes(query.types),
+                    startTime: query.startTime,
+                    endTime: query.endTime,
+                    limit: query.limit,
+                })}`,
+            });
+        },
+        async replay(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/events/replay",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+    };
+}
+export function createGraphFacade(config = {}) {
+    const graphClient = createGraphClient(config);
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async neighborhood(input) {
+            return graphClient.neighborhood({
+                globalId: input.globalId,
+                globalIds: Array.isArray(input.globalIds)
+                    ? input.globalIds.join(",")
+                    : input.globalIds,
+                maxDepth: input.maxDepth,
+            });
+        },
+        async traverse(input) {
+            return graphClient.traverse(input);
+        },
+        async analyze(input = {}) {
+            return graphClient.analyze(input);
+        },
+        async bias(input = {}) {
+            return graphClient.bias(input);
+        },
+        async gaps(input) {
+            return graphClient.gaps(input);
+        },
+        async falsify(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/graph/falsify",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+    };
+}
+export function createIdentityFacade(config = {}) {
+    const identityClient = createIdentityClient(config);
+    return {
+        async whoami() {
+            const response = await identityClient.whoami();
+            return Object.assign({}, response, response.data);
+        },
+    };
+}
+export function createOntologiesFacade(config = {}) {
+    const ontologyClient = createOntologyClient(config);
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async get(id) {
+            return gateway.request({
+                path: `/api/platform/v1/ontologies/${encodeURIComponent(id)}`,
+            });
+        },
+        async list(query = {}) {
+            return ontologyClient.list(query);
+        },
+        async bind(input, idempotencyKey) {
+            return gateway.request({
+                path: `/api/platform/v1/ontologies/${encodeURIComponent(input.ontologyId)}/bind`,
+                method: "POST",
+                body: {
+                    topicId: input.topicId,
+                },
+                idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+            });
+        },
+        async match(input, idempotencyKey) {
+            return gateway.request({
+                path: "/api/platform/v1/ontologies/match",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+    };
+}
+export function createQuestionsFacade(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async create(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/questions",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async get(id) {
+            return gateway.request({
+                path: `/api/platform/v1/questions/${encodeURIComponent(id)}`,
+            });
+        },
+        async list(query) {
+            return gateway.request({
+                path: `/api/platform/v1/questions${toQueryString({
+                    topicId: query.topicId,
+                    status: query.status,
+                    priority: query.priority,
+                    worktreeId: query.worktreeId,
+                    limit: query.limit,
+                    cursor: query.cursor,
+                })}`,
+            });
+        },
+        async answer(id, input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/questions/${encodeURIComponent(id)}/answer`,
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async refine(id, input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/questions/${encodeURIComponent(id)}/refine`,
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async archive(id, input = {}, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/questions/${encodeURIComponent(id)}`,
+                method: "DELETE",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async updateStatus(id, input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/questions/${encodeURIComponent(id)}/status`,
+                method: "PATCH",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async batchCreate(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/questions/batch",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async add(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/questions/add",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async updatePriority(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/questions/update-priority",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async advanceToConviction(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/questions/advance-to-conviction",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async updateConviction(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/questions/update-conviction",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async finalizeConviction(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/questions/finalize-conviction",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async update(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/questions/update",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async delete(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/questions/delete",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+    };
+}
+export function createSearchFacade(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async query(input) {
+            return gateway.request({
+                path: "/api/platform/v1/search",
+                method: "POST",
+                body: input,
+            });
+        },
+    };
+}
+export function createTasksFacade(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async create(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/tasks",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async update(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/tasks/${encodeURIComponent(input.id)}`,
+                method: "PATCH",
+                body: {
+                    title: input.title,
+                    description: input.description,
+                    priority: input.priority,
+                    status: input.status,
+                    linkedBeliefId: input.linkedBeliefId,
+                    linkedQuestionId: input.linkedQuestionId,
+                    linkedWorktreeId: input.linkedWorktreeId,
+                    metadata: input.metadata,
+                },
+                idempotencyKey,
+            });
+        },
+        async complete(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/tasks/${encodeURIComponent(input.id)}/complete`,
+                method: "POST",
+                body: {
+                    outputSummary: input.outputSummary,
+                },
+                idempotencyKey,
+            });
+        },
+        async list(query) {
+            return gateway.request({
+                path: `/api/platform/v1/tasks${toQueryString({
+                    topicId: query.topicId,
+                    worktreeId: query.worktreeId,
+                    status: query.status,
+                    limit: query.limit,
+                })}`,
+            });
+        },
+    };
+}
+export function createTopicsFacade(config = {}) {
+    const topicsClient = createTopicsClient(config);
+    return {
+        async create(input, idempotencyKey) {
+            return topicsClient.create(input, idempotencyKey);
+        },
+        async get(id) {
+            return topicsClient.get(id);
+        },
+        async list(query = {}) {
+            return topicsClient.list(query);
+        },
+        async update(input, idempotencyKey) {
+            const { id, ...rest } = input;
+            return topicsClient.update(id, rest, idempotencyKey);
+        },
+        async tree(input) {
+            return topicsClient.getTree(input.id, {
+                maxDepth: input.maxDepth,
+            });
+        },
+        async coverage(input) {
+            return topicsClient.getCoverage(input.id, {
+                includeDescendants: input.includeDescendants,
+                maxDepth: input.maxDepth,
+            });
+        },
+        async remove(id, idempotencyKey = randomIdempotencyKey()) {
+            return topicsClient.remove(id, idempotencyKey);
+        },
+        async bulkCreate(input, idempotencyKey = randomIdempotencyKey()) {
+            return topicsClient.bulkCreate(input, idempotencyKey);
+        },
+    };
+}
+export function createWebhooksFacade(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async create(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/webhooks",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async list(query = {}) {
+            return gateway.request({
+                path: `/api/platform/v1/webhooks${toQueryString({
+                    topicId: query.topicId,
+                })}`,
+            });
+        },
+        async get(id) {
+            return gateway.request({
+                path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}`,
+            });
+        },
+        async update(id, input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}`,
+                method: "PATCH",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async delete(id, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}`,
+                method: "DELETE",
+                idempotencyKey,
+            });
+        },
+        async test(id, input = {}, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}/test`,
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async deliveries(id, query = {}) {
+            return gateway.request({
+                path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}/deliveries${toQueryString({
+                    limit: query.limit,
+                })}`,
+            });
+        },
+        async health(id) {
+            return gateway.request({
+                path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}/health`,
+            });
+        },
+    };
+}
+export function createWorktreesFacade(config = {}) {
+    const gateway = createGatewayRequestClient(config);
+    return {
+        async create(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/worktrees",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async list(query) {
+            return gateway.request({
+                path: `/api/platform/v1/worktrees${toQueryString({
+                    topicId: query.topicId,
+                    status: query.status,
+                    limit: query.limit,
+                })}`,
+            });
+        },
+        async activate(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/worktrees/${encodeURIComponent(input.id)}/activate`,
+                method: "POST",
+                body: {},
+                idempotencyKey,
+            });
+        },
+        async update(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/worktrees/${encodeURIComponent(input.id)}`,
+                method: "PATCH",
+                body: {
+                    objective: input.objective,
+                    hypothesis: input.hypothesis,
+                    rationale: input.rationale,
+                    track: input.track,
+                    trackPosition: input.trackPosition,
+                    executionBand: input.executionBand,
+                    executionOrder: input.executionOrder,
+                    dependsOn: input.dependsOn,
+                    blocks: input.blocks,
+                    gate: input.gate,
+                    status: input.status,
+                    topicId: input.topicId,
+                    additionalTopicIds: input.additionalTopicIds,
+                    proofArtifacts: input.proofArtifacts,
+                    staffingHint: input.staffingHint,
+                    lastReconciledAt: input.lastReconciledAt,
+                    autoFixPolicy: input.autoFixPolicy,
+                    lensId: input.lensId,
+                },
+                idempotencyKey,
+            });
+        },
+        async merge(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/worktrees/${encodeURIComponent(input.id)}/merge`,
+                method: "POST",
+                body: {
+                    summary: input.summary,
+                    outcomes: input.outcomes,
+                },
+                idempotencyKey,
+            });
+        },
+        async updateTargets(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: `/api/platform/v1/worktrees/${encodeURIComponent(input.id)}/targets`,
+                method: "POST",
+                body: {
+                    addBeliefIds: input.addBeliefIds,
+                    addQuestionIds: input.addQuestionIds,
+                    removeBeliefIds: input.removeBeliefIds,
+                    removeQuestionIds: input.removeQuestionIds,
+                },
+                idempotencyKey,
+            });
+        },
+        async complete(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/worktrees/complete",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async advancePhase(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/worktrees/advance-phase",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async setPhase(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/worktrees/set-phase",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async patchState(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/worktrees/patch-state",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+        async bulkCreate(input, idempotencyKey = randomIdempotencyKey()) {
+            return gateway.request({
+                path: "/api/platform/v1/worktrees/bulk",
+                method: "POST",
+                body: input,
+                idempotencyKey,
+            });
+        },
+    };
+}