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

package/src/gatewayFacades.ts

@@ -0,0 +1,1666 @@
+import {
+  createGatewayRequestClient,
+  randomIdempotencyKey,
+  toQueryString,
+  type GatewayClientConfig,
+  type PlatformGatewaySuccess,
+} from "./coreClient";
+import {
+  createOntologyClient,
+  type OntologyBindingInput,
+} from "./ontologyClient";
+import { createGraphClient } from "./graphClient";
+import { createIdentityClient } from "./identityClient";
+import {
+  createTopicsClient,
+  type TopicBulkCreateInput,
+  type TopicCreateInput,
+  type TopicCoverageQuery,
+  type TopicListInput,
+  type TopicTreeQuery,
+  type TopicUpdateInput,
+} from "./topicsClient";
+import type { GraphAnalyticsMetric, JsonObject } from "./types";
+
+type GatewayRecord = Record<string, unknown>;
+type GatewayList = GatewayRecord & { cursor?: string; total?: number };
+
+type BeliefRecord = GatewayRecord & {
+  id?: string;
+  beliefId?: string;
+  nodeId?: string;
+};
+
+type BeliefsListResult = GatewayList & {
+  beliefs?: BeliefRecord[];
+};
+
+type BeliefsLineageResult = GatewayRecord & {
+  beliefId?: string;
+  lineage?: GatewayRecord[];
+};
+
+type SearchResult = GatewayList & {
+  beliefs?: GatewayRecord[];
+  results?: GatewayRecord[];
+};
+
+type GraphNeighborhoodInput = {
+  globalId?: string;
+  globalIds?: string | string[];
+  maxDepth?: number;
+};
+
+type GraphTraverseInput = {
+  startNode: string;
+  direction?: string;
+  maxDepth?: number;
+  topicId?: string;
+};
+
+type GraphAnalyzeInput = {
+  topicId?: string;
+  metric?: GraphAnalyticsMetric;
+  limit?: number;
+};
+
+type GraphBiasInput = {
+  topicId?: string;
+  threshold?: number;
+  limit?: number;
+};
+
+type GraphGapsInput = {
+  topicId?: string;
+  minConfidence?: number;
+};
+
+type GraphFalsifyInput = {
+  topicId?: string;
+  beliefId?: string;
+  beliefIds?: string[];
+  minConfidence?: number;
+};
+
+type EventsListResult = GatewayList & {
+  events?: GatewayRecord[];
+};
+
+type WebhooksListResult = GatewayList & {
+  webhooks?: GatewayRecord[];
+};
+
+type QuestionsListResult = GatewayList & {
+  questions?: Array<GatewayRecord & { priority?: string }>;
+};
+
+type ContradictionsListResult = GatewayList & {
+  contradictions?: GatewayRecord[];
+};
+
+type WorktreesListResult = GatewayList & {
+  worktrees?: GatewayRecord[];
+};
+
+type TaskListResult = GatewayList & {
+  tasks?: GatewayRecord[];
+};
+
+type EvidenceCreateResult = GatewayRecord & {
+  id?: string;
+};
+
+type EvidenceLinkResult = GatewayRecord & {
+  edgeId?: string;
+};
+
+type BeliefCreateInput = {
+  topicId: string;
+  text: string;
+  rationale?: string;
+  worktreeId?: string;
+  pillar?: string;
+  sourceBeliefIds?: string[];
+  sourceType?: string;
+  beliefType?: string;
+  reversibility?: string;
+  predictionMeta?: JsonObject;
+  metadata?: JsonObject;
+};
+
+type BeliefsListQuery = {
+  topicId?: string;
+  status?: string;
+  worktreeId?: string;
+  minConfidence?: number;
+  limit?: number;
+  cursor?: string;
+};
+
+type BeliefRefineInput = {
+  text: string;
+  rationale?: string;
+};
+
+type BeliefForkInput = {
+  text: string;
+  forkReason?: string;
+  rationale?: string;
+};
+
+type BeliefConfidenceInput = {
+  confidence: number;
+  trigger?: string;
+  rationale: string;
+  certainty?: number;
+  maxInlinePropagationTargets?: number;
+};
+
+type BeliefArchiveInput = {
+  reason?: string;
+  rationale?: string;
+};
+
+type BeliefContractInput = GatewayRecord;
+
+type BeliefBisectInput = {
+  expectedDirection: "overconfident" | "underconfident";
+  timeRange?: {
+    start: number;
+    end: number;
+  };
+};
+
+type EdgeCreateInput = {
+  sourceId: string;
+  targetId: string;
+  edgeType: string;
+  topicId?: string;
+  confidence?: number;
+  weight?: number;
+  context?: string;
+  reasoning?: string;
+};
+
+type EdgeListQuery = {
+  sourceId?: string;
+  edgeType?: string;
+  limit?: number;
+  cursor?: string;
+};
+
+type EdgeTraverseInput = {
+  startNode: string;
+  direction?: string;
+  maxDepth?: number;
+  topicId?: string;
+};
+
+type EvidenceCreateInput = {
+  topicId: string;
+  text: string;
+  source?: string;
+  targetId?: string;
+  weight?: number;
+  metadata?: JsonObject;
+  title?: string;
+  content?: string;
+  contentType?: string;
+  kind?: string;
+};
+
+type EvidenceListQuery = {
+  topicId?: string;
+  targetId?: string;
+  limit?: number;
+  cursor?: string;
+};
+
+type EvidenceSearchInput = {
+  q: string;
+  topicId?: string;
+  targetId?: string;
+  methodology?: string;
+  limit?: number;
+  cursor?: string;
+};
+
+type EvidenceLinkInput = {
+  evidenceId: string;
+  targetId: string;
+  targetType?: "belief" | "question";
+  weight?: number;
+  rationale?: string;
+};
+
+type QuestionsListQuery = {
+  topicId?: string;
+  status?: string;
+  priority?: string;
+  worktreeId?: string;
+  limit?: number;
+  cursor?: string;
+};
+
+type QuestionCreateInput = {
+  topicId: string;
+  text: string;
+  priority?: string;
+  linkedBeliefId?: string;
+  metadata?: JsonObject;
+};
+
+type QuestionAnswerInput = {
+  text: string;
+  confidence?: string;
+  evidenceIds?: string[];
+  rationale?: string;
+};
+
+type QuestionRefineInput = {
+  text: string;
+  rationale?: string;
+};
+
+type QuestionArchiveInput = {
+  reason?: string;
+  rationale?: string;
+};
+
+type QuestionStatusInput = {
+  status: string;
+  rationale?: string;
+};
+
+type SearchQueryInput = {
+  q?: string;
+  query?: string;
+  topicId?: string;
+  types?: string[];
+  status?: string;
+  minConfidence?: number;
+  limit?: number;
+  cursor?: string;
+};
+
+type TaskCreateInput = {
+  topicId?: string;
+  title: string;
+  description?: string;
+  taskType?: string;
+  priority?: string;
+  linkedBeliefId?: string;
+  linkedQuestionId?: string;
+  linkedWorktreeId?: string;
+};
+
+type TaskUpdateInput = {
+  id: string;
+  title?: string;
+  description?: string;
+  priority?: string;
+  status?: string;
+  linkedBeliefId?: string;
+  linkedQuestionId?: string;
+  linkedWorktreeId?: string;
+  metadata?: JsonObject;
+};
+
+type TaskCompleteInput = {
+  id: string;
+  outputSummary: string;
+};
+
+type TaskListQuery = {
+  topicId?: string;
+  worktreeId?: string;
+  status?: string;
+  limit?: number;
+};
+
+type WorktreeCreateInput = {
+  title: string;
+  topicId?: string;
+  objective?: string;
+  hypothesis?: string;
+  beliefIds?: string[];
+  autoShape?: boolean;
+  domainPackId?: string;
+  executionOrder?: number;
+  dependsOn?: string[];
+  blocks?: string[];
+  gate?: string;
+  proofArtifacts?: unknown[];
+  staffingHint?: string;
+  lastReconciledAt?: number;
+  autoFixPolicy?: unknown;
+};
+
+type WorktreeListQuery = {
+  topicId?: string;
+  status?: string;
+  limit?: number;
+};
+
+type WorktreeActivateInput = {
+  id: string;
+};
+
+type WorktreeUpdateInput = {
+  id: string;
+  objective?: string;
+  hypothesis?: string;
+  rationale?: string;
+  track?: string;
+  trackPosition?: number;
+  executionBand?: number;
+  executionOrder?: number;
+  dependsOn?: string[];
+  blocks?: string[];
+  gate?: string;
+  status?: string;
+  topicId?: string;
+  additionalTopicIds?: string[];
+  proofArtifacts?: unknown[];
+  staffingHint?: string;
+  lastReconciledAt?: number;
+  autoFixPolicy?: unknown;
+  lensId?: string;
+};
+
+type WorktreeMergeInput = {
+  id: string;
+  summary?: string;
+  outcomes: Array<{
+    beliefId: string;
+    confidence: number;
+    rationale: string;
+  }>;
+};
+
+type WorktreeTargetsInput = {
+  id: string;
+  addBeliefIds?: string[];
+  addQuestionIds?: string[];
+  removeBeliefIds?: string[];
+  removeQuestionIds?: string[];
+};
+
+type OntologyListInput = {
+  tenantId?: string;
+  tier?: string;
+  status?: string;
+};
+
+type OntologyMatchInput = GatewayRecord;
+
+type WebhookCreateInput = GatewayRecord;
+type WebhookUpdateInput = GatewayRecord;
+type WebhookListQuery = {
+  topicId?: string;
+};
+type WebhookTestInput = {
+  topicId?: string;
+};
+type WebhookDeliveriesQuery = {
+  limit?: number;
+};
+
+type EventsListQuery = {
+  topicId?: string;
+  after?: string;
+  types?: string[];
+  startTime?: number;
+  endTime?: number;
+  limit?: number;
+};
+
+type ReplayEventsInput = GatewayRecord;
+
+function serializeTypes(types: string[] | undefined) {
+  return Array.isArray(types) && types.length > 0 ? types.join(",") : undefined;
+}
+
+export function createBeliefsFacade(config: GatewayClientConfig = {}) {
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async create(
+      input: BeliefCreateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<BeliefRecord>> {
+      return gateway.request<BeliefRecord>({
+        path: "/api/platform/v1/beliefs",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async get(id: string): Promise<PlatformGatewaySuccess<BeliefRecord>> {
+      return gateway.request<BeliefRecord>({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}`,
+      });
+    },
+
+    async list(
+      query: BeliefsListQuery
+    ): Promise<PlatformGatewaySuccess<BeliefsListResult>> {
+      return gateway.request<BeliefsListResult>({
+        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: string,
+      input: BeliefRefineInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<BeliefRecord>> {
+      return gateway.request<BeliefRecord>({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}`,
+        method: "PATCH",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async fork(
+      id: string,
+      input: BeliefForkInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<BeliefRecord>> {
+      return gateway.request<BeliefRecord>({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/fork`,
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async updateConfidence(
+      id: string,
+      input: BeliefConfidenceInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/confidence`,
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async updateStatus(
+      input: {
+        id?: string;
+        nodeId?: string;
+        beliefId?: string;
+        status: "active" | "superseded" | "archived";
+        reason?: string;
+      },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/beliefs/update-status",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async updateRationale(
+      input: {
+        id?: string;
+        nodeId?: string;
+        beliefId?: string;
+        rationale?: string;
+      },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/beliefs/update-rationale",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async linkBeliefs(
+      input: {
+        fromNodeId: string;
+        toNodeId: string;
+        edgeType: string;
+        weight?: number;
+        context?: string;
+      },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/beliefs/link",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async unlinkEvidence(
+      input: {
+        beliefNodeId?: string;
+        beliefId?: string;
+        insightId?: string;
+        evidenceId?: string;
+      },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/beliefs/unlink-evidence",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async updateCriticality(
+      input: {
+        id?: string;
+        nodeId?: string;
+        beliefId?: string;
+        criticality: string;
+      },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/beliefs/update-criticality",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async batchUpdateCriticality(
+      input: {
+        updates: GatewayRecord[];
+      },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/beliefs/batch-update-criticality",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async reassignTopic(
+      input: {
+        beliefNodeIds?: string[];
+        beliefIds?: string[];
+        targetTopicId: string;
+        reason?: string;
+      },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/beliefs/reassign-topic",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async archive(
+      id: string,
+      input: BeliefArchiveInput = {},
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}`,
+        method: "DELETE",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async lineage(
+      id: string
+    ): Promise<PlatformGatewaySuccess<BeliefsLineageResult>> {
+      return gateway.request<BeliefsLineageResult>({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/lineage`,
+      });
+    },
+
+    async confidenceHistory(
+      id: string
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/confidence-history`,
+      });
+    },
+
+    async createContract(
+      id: string,
+      input: BeliefContractInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/contracts`,
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async bisect(
+      id: string,
+      input: BeliefBisectInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/beliefs/${encodeURIComponent(id)}/bisect`,
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+  };
+}
+
+export function createContradictionsFacade(config: GatewayClientConfig = {}) {
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async flag(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/contradictions",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async list(
+      query: {
+        topicId?: string;
+        status?: string;
+        limit?: number;
+        cursor?: string;
+      }
+    ): Promise<PlatformGatewaySuccess<ContradictionsListResult>> {
+      return gateway.request<ContradictionsListResult>({
+        path: `/api/platform/v1/contradictions${toQueryString({
+          topicId: query.topicId,
+          status: query.status,
+          limit: query.limit,
+          cursor: query.cursor,
+        })}`,
+      });
+    },
+
+    async get(id: string): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/contradictions/${encodeURIComponent(id)}`,
+      });
+    },
+  };
+}
+
+export function createEdgesFacade(config: GatewayClientConfig = {}) {
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async create(
+      input: EdgeCreateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/edges",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async list(
+      query: EdgeListQuery
+    ): Promise<PlatformGatewaySuccess<GatewayList>> {
+      return gateway.request<GatewayList>({
+        path: `/api/platform/v1/edges${toQueryString({
+          sourceId: query.sourceId,
+          edgeType: query.edgeType,
+          limit: query.limit,
+          cursor: query.cursor,
+        })}`,
+      });
+    },
+
+    async traverse(
+      input: EdgeTraverseInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/edges/traverse",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async update(
+      input: {
+        edgeId: string;
+        weight?: number;
+        confidence?: number;
+        context?: string;
+        derivationType?: string;
+      },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/edges/update",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async remove(
+      input: { edgeId: string },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/edges/remove",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async removeBetween(
+      input: {
+        fromNodeId: string;
+        toNodeId: string;
+        edgeType?: string;
+      },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/edges/remove-between",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async batchCreate(
+      input: {
+        edges: GatewayRecord[];
+        skipLayerValidation?: boolean;
+      },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/edges/batch",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async delete(
+      input: { edgeIds: string[] },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/edges/delete",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+  };
+}
+
+export function createEvidenceFacade(config: GatewayClientConfig = {}) {
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async create(
+      input: EvidenceCreateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<EvidenceCreateResult>> {
+      return gateway.request<EvidenceCreateResult>({
+        path: "/api/platform/v1/evidence",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async get(id: string): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/evidence/${encodeURIComponent(id)}`,
+      });
+    },
+
+    async list(
+      query: EvidenceListQuery
+    ): Promise<PlatformGatewaySuccess<GatewayList>> {
+      return gateway.request<GatewayList>({
+        path: `/api/platform/v1/evidence${toQueryString({
+          topicId: query.topicId,
+          targetId: query.targetId,
+          limit: query.limit,
+          cursor: query.cursor,
+        })}`,
+      });
+    },
+
+    async link(
+      input: EvidenceLinkInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<EvidenceLinkResult>> {
+      return gateway.request<EvidenceLinkResult>({
+        path: `/api/platform/v1/evidence/${encodeURIComponent(input.evidenceId)}/link`,
+        method: "POST",
+        body: {
+          targetId: input.targetId,
+          targetType: input.targetType,
+          weight: input.weight,
+          rationale: input.rationale,
+        } as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async search(
+      query: EvidenceSearchInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayList>> {
+      return gateway.request<GatewayList>({
+        path: "/api/platform/v1/evidence/search",
+        method: "POST",
+        body: query as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async updateStatus(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/evidence/update-status",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async update(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/evidence/update",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async flagIncorrect(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/evidence/flag-incorrect",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async remove(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/evidence/remove",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async updateVerificationStatus(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/evidence/update-verification-status",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+  };
+}
+
+export function createEventsFacade(config: GatewayClientConfig = {}) {
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async list(
+      query: EventsListQuery = {}
+    ): Promise<PlatformGatewaySuccess<EventsListResult>> {
+      return gateway.request<EventsListResult>({
+        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: ReplayEventsInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/events/replay",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+  };
+}
+
+export function createGraphFacade(config: GatewayClientConfig = {}) {
+  const graphClient = createGraphClient(config);
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async neighborhood(input: GraphNeighborhoodInput) {
+      return graphClient.neighborhood({
+        globalId: input.globalId,
+        globalIds: Array.isArray(input.globalIds)
+          ? input.globalIds.join(",")
+          : input.globalIds,
+        maxDepth: input.maxDepth,
+      });
+    },
+
+    async traverse(input: GraphTraverseInput) {
+      return graphClient.traverse(input);
+    },
+
+    async analyze(input: GraphAnalyzeInput = {}) {
+      return graphClient.analyze(input);
+    },
+
+    async bias(input: GraphBiasInput = {}) {
+      return graphClient.bias(input);
+    },
+
+    async gaps(input: GraphGapsInput) {
+      return graphClient.gaps(input);
+    },
+
+    async falsify(
+      input: GraphFalsifyInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/graph/falsify",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+  };
+}
+
+export function createIdentityFacade(config: GatewayClientConfig = {}) {
+  const identityClient = createIdentityClient(config);
+
+  return {
+    async whoami() {
+      const response = await identityClient.whoami();
+      return Object.assign({}, response, response.data);
+    },
+  };
+}
+
+export function createOntologiesFacade(config: GatewayClientConfig = {}) {
+  const ontologyClient = createOntologyClient(config);
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async get(id: string): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/ontologies/${encodeURIComponent(id)}`,
+      });
+    },
+
+    async list(query: OntologyListInput = {}) {
+      return ontologyClient.list(query);
+    },
+
+    async bind(
+      input: OntologyBindingInput,
+      idempotencyKey?: string
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/ontologies/${encodeURIComponent(input.ontologyId)}/bind`,
+        method: "POST",
+        body: {
+          topicId: input.topicId,
+        } as JsonObject,
+        idempotencyKey: idempotencyKey ?? randomIdempotencyKey(),
+      });
+    },
+
+    async match(
+      input: OntologyMatchInput,
+      idempotencyKey?: string
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/ontologies/match",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+  };
+}
+
+export function createQuestionsFacade(config: GatewayClientConfig = {}) {
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async create(
+      input: QuestionCreateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/questions",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async get(id: string): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/questions/${encodeURIComponent(id)}`,
+      });
+    },
+
+    async list(
+      query: QuestionsListQuery
+    ): Promise<PlatformGatewaySuccess<QuestionsListResult>> {
+      return gateway.request<QuestionsListResult>({
+        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: string,
+      input: QuestionAnswerInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/questions/${encodeURIComponent(id)}/answer`,
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async refine(
+      id: string,
+      input: QuestionRefineInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/questions/${encodeURIComponent(id)}/refine`,
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async archive(
+      id: string,
+      input: QuestionArchiveInput = {},
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/questions/${encodeURIComponent(id)}`,
+        method: "DELETE",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async updateStatus(
+      id: string,
+      input: QuestionStatusInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/questions/${encodeURIComponent(id)}/status`,
+        method: "PATCH",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async batchCreate(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/questions/batch",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async add(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/questions/add",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async updatePriority(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/questions/update-priority",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async advanceToConviction(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/questions/advance-to-conviction",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async updateConviction(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/questions/update-conviction",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async finalizeConviction(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/questions/finalize-conviction",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async update(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/questions/update",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async delete(
+      input: GatewayRecord,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/questions/delete",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+  };
+}
+
+export function createSearchFacade(config: GatewayClientConfig = {}) {
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async query(
+      input: SearchQueryInput
+    ): Promise<PlatformGatewaySuccess<SearchResult>> {
+      return gateway.request<SearchResult>({
+        path: "/api/platform/v1/search",
+        method: "POST",
+        body: input as JsonObject,
+      });
+    },
+  };
+}
+
+export function createTasksFacade(config: GatewayClientConfig = {}) {
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async create(
+      input: TaskCreateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/tasks",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async update(
+      input: TaskUpdateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        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,
+        } as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async complete(
+      input: TaskCompleteInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/tasks/${encodeURIComponent(input.id)}/complete`,
+        method: "POST",
+        body: {
+          outputSummary: input.outputSummary,
+        } as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async list(
+      query: TaskListQuery
+    ): Promise<PlatformGatewaySuccess<TaskListResult>> {
+      return gateway.request<TaskListResult>({
+        path: `/api/platform/v1/tasks${toQueryString({
+          topicId: query.topicId,
+          worktreeId: query.worktreeId,
+          status: query.status,
+          limit: query.limit,
+        })}`,
+      });
+    },
+  };
+}
+
+export function createTopicsFacade(config: GatewayClientConfig = {}) {
+  const topicsClient = createTopicsClient(config);
+
+  return {
+    async create(input: TopicCreateInput, idempotencyKey?: string) {
+      return topicsClient.create(input, idempotencyKey);
+    },
+
+    async get(id: string) {
+      return topicsClient.get(id);
+    },
+
+    async list(query: TopicListInput = {}) {
+      return topicsClient.list(query);
+    },
+
+    async update(
+      input: TopicUpdateInput & { id: string },
+      idempotencyKey?: string
+    ) {
+      const { id, ...rest } = input;
+      return topicsClient.update(id, rest, idempotencyKey);
+    },
+
+    async tree(input: TopicTreeQuery & { id: string }) {
+      return topicsClient.getTree(input.id, {
+        maxDepth: input.maxDepth,
+      });
+    },
+
+    async coverage(input: TopicCoverageQuery & { id: string }) {
+      return topicsClient.getCoverage(input.id, {
+        includeDescendants: input.includeDescendants,
+        maxDepth: input.maxDepth,
+      });
+    },
+
+    async remove(id: string, idempotencyKey = randomIdempotencyKey()) {
+      return topicsClient.remove(id, idempotencyKey);
+    },
+
+    async bulkCreate(
+      input: TopicBulkCreateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ) {
+      return topicsClient.bulkCreate(input, idempotencyKey);
+    },
+  };
+}
+
+export function createWebhooksFacade(config: GatewayClientConfig = {}) {
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async create(
+      input: WebhookCreateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/webhooks",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async list(
+      query: WebhookListQuery = {}
+    ): Promise<PlatformGatewaySuccess<WebhooksListResult>> {
+      return gateway.request<WebhooksListResult>({
+        path: `/api/platform/v1/webhooks${toQueryString({
+          topicId: query.topicId,
+        })}`,
+      });
+    },
+
+    async get(id: string): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}`,
+      });
+    },
+
+    async update(
+      id: string,
+      input: WebhookUpdateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}`,
+        method: "PATCH",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async delete(
+      id: string,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}`,
+        method: "DELETE",
+        idempotencyKey,
+      });
+    },
+
+    async test(
+      id: string,
+      input: WebhookTestInput = {},
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}/test`,
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async deliveries(
+      id: string,
+      query: WebhookDeliveriesQuery = {}
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}/deliveries${toQueryString({
+          limit: query.limit,
+        })}`,
+      });
+    },
+
+    async health(id: string): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/webhooks/${encodeURIComponent(id)}/health`,
+      });
+    },
+  };
+}
+
+export function createWorktreesFacade(config: GatewayClientConfig = {}) {
+  const gateway = createGatewayRequestClient(config);
+
+  return {
+    async create(
+      input: WorktreeCreateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/worktrees",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async list(
+      query: WorktreeListQuery
+    ): Promise<PlatformGatewaySuccess<WorktreesListResult>> {
+      return gateway.request<WorktreesListResult>({
+        path: `/api/platform/v1/worktrees${toQueryString({
+          topicId: query.topicId,
+          status: query.status,
+          limit: query.limit,
+        })}`,
+      });
+    },
+
+    async activate(
+      input: WorktreeActivateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/worktrees/${encodeURIComponent(input.id)}/activate`,
+        method: "POST",
+        body: {} as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async update(
+      input: WorktreeUpdateInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        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,
+        } as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async merge(
+      input: WorktreeMergeInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/worktrees/${encodeURIComponent(input.id)}/merge`,
+        method: "POST",
+        body: {
+          summary: input.summary,
+          outcomes: input.outcomes,
+        } as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async updateTargets(
+      input: WorktreeTargetsInput,
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: `/api/platform/v1/worktrees/${encodeURIComponent(input.id)}/targets`,
+        method: "POST",
+        body: {
+          addBeliefIds: input.addBeliefIds,
+          addQuestionIds: input.addQuestionIds,
+          removeBeliefIds: input.removeBeliefIds,
+          removeQuestionIds: input.removeQuestionIds,
+        } as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async complete(
+      input: {
+        worktreeId: string;
+        keyFindings?: string[];
+        decisionsReached?: string[];
+        nextSteps?: string[];
+      },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/worktrees/complete",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async advancePhase(
+      input: { worktreeId: string },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/worktrees/advance-phase",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async setPhase(
+      input: { worktreeId: string; phase: string },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/worktrees/set-phase",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async patchState(
+      input: { worktreeId: string; patch: GatewayRecord },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/worktrees/patch-state",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+
+    async bulkCreate(
+      input: { worktrees: unknown[] },
+      idempotencyKey = randomIdempotencyKey()
+    ): Promise<PlatformGatewaySuccess<GatewayRecord>> {
+      return gateway.request<GatewayRecord>({
+        path: "/api/platform/v1/worktrees/bulk",
+        method: "POST",
+        body: input as JsonObject,
+        idempotencyKey,
+      });
+    },
+  };
+}