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

package/src/gatewayFacades.ts

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