@lucern/sdk 0.2.0-alpha.5 → 0.2.0-alpha.7

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

@@ -1,845 +0,0 @@
-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,
-            });
-        },
-    };
-}