@lucern/sdk 1.0.29 → 1.0.30

package/dist/clientLocalHelpers.d.ts

@@ -1,24 +1,42 @@
 import { type OpinionHistoryEntry } from "./beliefsClient";
-import { type EvidenceCompatInput } from "./clientEvidenceCompat";
-import type { ClientNamespaceContext } from "./clientAssemblyTypes";
-import type { CustomToolInput, CustomToolNamespace } from "./clientConfig";
+import type { ClientLocalHelperContext } from "./client-assembly-types";
+import type { CustomToolInput, CustomToolNamespace } from "./client-config";
+import { type EvidenceCompatInput } from "./client-evidence-compat";
 import { type PlatformGatewaySuccess } from "./coreClient";
 import type { FunctionSurfaceInput } from "./generated/functionSurface";
 import type { JsonObject } from "./types";
-export declare function createClientLocalHelpers(ctx: ClientNamespaceContext): {
+export declare function createClientLocalHelpers(ctx: ClientLocalHelperContext): {
     addEvidence: (args: EvidenceCompatInput) => Promise<Record<string, unknown>>;
-    archiveOntologyCompat: (input?: JsonObject) => Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+    archiveOntologyCompat: (input?: JsonObject) => Promise<{
+        correlationId: string;
+        data: Record<string, unknown>;
+        idempotentReplay: boolean;
+        policyTraceId: string | null;
+        success: true;
+    }>;
     bisectConfidence: (nodeId: string, args: {
         expectedDirection: "overconfident" | "underconfident";
-    }) => Promise<any>;
-    createContractCompat: (input?: JsonObject) => Promise<any>;
+    }) => Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+    createContractCompat: (input?: JsonObject) => Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     createEvidence: (args: EvidenceCompatInput) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
-    createOntologyCompat: (input?: JsonObject) => Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-    createOntologyVersionCompat: (input?: JsonObject) => Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
-    deprecateOntologyVersionCompat: (input?: JsonObject) => Promise<any>;
-    discoverEntityConnections: (input?: JsonObject) => Promise<any>;
-    discoverTopics: (input?: JsonObject) => Promise<any>;
-    evaluateContractCompat: (input?: JsonObject) => Promise<any>;
+    createOntologyCompat: (input?: JsonObject) => Promise<{
+        correlationId: string;
+        data: Record<string, unknown>;
+        idempotentReplay: boolean;
+        policyTraceId: string | null;
+        success: true;
+    }>;
+    createOntologyVersionCompat: (input?: JsonObject) => Promise<{
+        correlationId: string;
+        data: Record<string, unknown>;
+        idempotentReplay: boolean;
+        policyTraceId: string | null;
+        success: true;
+    }>;
+    deprecateOntologyVersionCompat: (input?: JsonObject) => Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+    discoverEntityConnections: (input?: JsonObject) => Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+    discoverTopics: (input?: JsonObject) => Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+    evaluateContractCompat: (input?: JsonObject) => Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     extensionNamespaces: Record<string, CustomToolNamespace>;
     findContradictions: (args: {
         topicId?: string;
@@ -40,12 +58,12 @@ export declare function createClientLocalHelpers(ctx: ClientNamespaceContext): {
             actor: string;
             timestamp: number;
             rationale: string;
-            before: string | number | boolean | import("./types").JsonArray | JsonObject | null;
-            after: string | number | boolean | import("./types").JsonArray | JsonObject | null;
+            before: string | number | boolean | JsonObject | import("./types").JsonArray | null;
+            after: string | number | boolean | JsonObject | import("./types").JsonArray | null;
         }[];
     }>;
-    getConfidenceHistory: (nodeId: string) => Promise<any>;
-    getContractStatusCompat: (input?: JsonObject) => Promise<any>;
+    getConfidenceHistory: (nodeId: string) => Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").GatewayRecord>>;
+    getContractStatusCompat: (input?: JsonObject) => Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     getCustomNamespace: (namespace: string) => CustomToolNamespace;
     getOpinionHistory: (nodeId: string) => Promise<OpinionHistoryEntry[]>;
     invokeCustomTool: (fullName: string, input?: CustomToolInput) => Promise<unknown>;
@@ -56,17 +74,17 @@ export declare function createClientLocalHelpers(ctx: ClientNamespaceContext): {
         minConfidence?: number;
         limit?: number;
         cursor?: string;
-    }) => Promise<any>;
-    listContractsCompat: (input?: JsonObject) => Promise<any>;
+    }) => Promise<import("./gatewayFacades").BeliefRecord[]>;
+    listContractsCompat: (input?: JsonObject) => Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     nodesNamespace: {
-        list: (...args: any[]) => any;
-        get(input: string | Parameters<(...args: any[]) => any>[0]): any;
-        create(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        createEpistemicNode(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        update(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        updateEpistemicNode(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        batchCreate(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        batchCreateEpistemicNodes(input: FunctionSurfaceInput, idempotencyKey?: string): any;
+        list: (query: import("./graphClient").ListNodesInput) => Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./types").PlatformGraphNode, "nodes">>>;
+        get(input: string | Parameters<(query: import("./graphClient").GetNodeInput) => Promise<PlatformGatewaySuccess<import("./types").PlatformGraphNode>>>[0]): Promise<PlatformGatewaySuccess<import("./types").PlatformGraphNode>>;
+        create(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        createEpistemicNode(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        update(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        updateEpistemicNode(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        batchCreate(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        batchCreateEpistemicNodes(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
         listByTopicAndType(input: {
             topicId?: string;
             projectId?: string;
@@ -76,7 +94,7 @@ export declare function createClientLocalHelpers(ctx: ClientNamespaceContext): {
             sourceText?: string;
             limit?: number;
             cursor?: string;
-        }): Promise<any>;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
         countByTopicAndType(input: {
             topicId?: string;
             projectId?: string;
@@ -84,32 +102,37 @@ export declare function createClientLocalHelpers(ctx: ClientNamespaceContext): {
             nodeTypes?: string[];
             query?: string;
             limit?: number;
-        }): Promise<any>;
-        supersede(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        verify(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        archive(input: FunctionSurfaceInput, idempotencyKey?: string): any;
-        hardDelete: (...args: any[]) => any;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        supersede(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        verify(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        archive(input: FunctionSurfaceInput, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<unknown>>;
+        hardDelete: (input: import("./graphClient").HardDeleteNodeInput, idempotencyKey?: string) => Promise<PlatformGatewaySuccess<Record<string, unknown>>>;
     };
     ontologyLinksNamespace: {
-        resolveThemeSource(input: JsonObject): Promise<any>;
-        create: (...args: any[]) => any;
-        link: (...args: any[]) => any;
+        resolveThemeSource(input: JsonObject): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        createLink(input: import("./ontologyLinksClient").OntologyLinkWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./ontologyLinksClient").OntologyLinkRecord>>;
+        upsertLink(input: import("./ontologyLinksClient").OntologyLinkWriteInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./ontologyLinksClient").OntologyLinkRecord>>;
+        listLinksForNode(input: import("./ontologyLinksClient").ListOntologyLinksForNodeInput): Promise<PlatformGatewaySuccess<import("./types").ListResult<import("./ontologyLinksClient").OntologyLinkRecord, "links">>>;
+        updateLinkStatus(input: import("./ontologyLinksClient").UpdateOntologyLinkStatusInput, idempotencyKey?: string): Promise<PlatformGatewaySuccess<import("./ontologyLinksClient").OntologyLinkRecord>>;
     };
     publicationNamespace: {
-        create(input: JsonObject, idempotencyKey?: string): Promise<any>;
-        update(publicationId: string, input: JsonObject, idempotencyKey?: string): Promise<any>;
-        list(input?: JsonObject): Promise<any>;
+        create(input: JsonObject, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        update(publicationId: string, input: JsonObject, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        list(input?: JsonObject): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
         getByTopic(input: string | {
             topicId: string;
             workspaceId?: string;
-        }): Promise<any>;
-        publish(publicationId: string, input?: JsonObject, idempotencyKey?: string): Promise<any>;
-        unpublish(publicationId: string, input?: JsonObject, idempotencyKey?: string): Promise<any>;
-        remove(publicationId: string, input?: JsonObject): Promise<any>;
+        }): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        publish(publicationId: string, input?: JsonObject, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        unpublish(publicationId: string, input?: JsonObject, idempotencyKey?: string): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+        remove(publicationId: string, input?: JsonObject): Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     };
-    publishOntologyVersionCompat: (input?: JsonObject) => Promise<any>;
+    publishOntologyVersionCompat: (input?: JsonObject) => Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     queryLineage: (nodeId: string, depth?: number) => Promise<{
-        chain: any;
+        chain: {
+            nodeId: {};
+            relation: string;
+        }[];
         forkTree: {
             nodeId: string;
             parentCount: number;
@@ -117,10 +140,10 @@ export declare function createClientLocalHelpers(ctx: ClientNamespaceContext): {
             children: never[];
         };
         depth: number;
-        beliefId: any;
-        lineage: any;
+        beliefId: string | undefined;
+        lineage: Record<string, unknown>[];
     }>;
-    resolveEffectiveOntologyCompat: (input?: JsonObject) => Promise<any>;
+    resolveEffectiveOntologyCompat: (input?: JsonObject) => Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
     searchBeliefs: (args: {
         query: string;
         topicId?: string;
@@ -137,9 +160,15 @@ export declare function createClientLocalHelpers(ctx: ClientNamespaceContext): {
         minConfidence?: number;
         limit?: number;
         cursor?: string;
-    }) => Promise<any>;
-    traceEntityImpactCompat: (input?: JsonObject) => Promise<any>;
-    triggerBeliefReview: (input?: JsonObject) => Promise<any>;
-    updateOntologyCompat: (input?: JsonObject) => Promise<PlatformGatewaySuccess<Record<string, unknown>> & Record<string, unknown>>;
+    }) => Promise<import("./client-config").GatewayDataEnvelope<import("./gatewayFacades").SearchResult>>;
+    traceEntityImpactCompat: (input?: JsonObject) => Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+    triggerBeliefReview: (input?: JsonObject) => Promise<import("./client-config").GatewayDataEnvelope<Record<string, unknown>>>;
+    updateOntologyCompat: (input?: JsonObject) => Promise<{
+        correlationId: string;
+        data: Record<string, unknown>;
+        idempotentReplay: boolean;
+        policyTraceId: string | null;
+        success: true;
+    }>;
 };
 //# sourceMappingURL=clientLocalHelpers.d.ts.map

package/dist/clientLocalHelpers.js

@@ -1,12 +1,159 @@
-import { mapOpinionHistoryEntriesFromGatewayData } from "./beliefsClient.js";
-import { addEvidenceCompat, createEvidenceCompat, } from "./clientEvidenceCompat.js";
+// biome-ignore-all lint/style/useFilenamingConvention: This file is an @lucern/sdk public import ABI / package subpath compatibility surface; the camelCase filename is intentional.
+import { mapOpinionHistoryEntriesFromGatewayData, } from "./beliefsClient.js";
+import { addEvidenceCompat, createEvidenceCompat, } from "./client-evidence-compat.js";
 import { asNodeArray, matchesAuditNodeReference, normalizeCustomNamespace, normalizeCustomToolPayload, requireTopicId, requireTopicOrProjectId, sdkQueryString, } from "./clientHelpers.js";
 import { randomIdempotencyKey, toQueryString, } from "./coreClient.js";
-import { invokeRegisteredCustomTool, } from "./customTools.js";
+import { invokeRegisteredCustomTool } from "./customTools.js";
 import { asListItems, resolveTopicId } from "./sdkSurface.js";
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalStringField(input, fieldName) {
+    const value = input[fieldName];
+    return typeof value === "string" ? value : undefined;
+}
+function requiredStringField(input, fieldName, context) {
+    const value = optionalStringField(input, fieldName);
+    if (!value) {
+        throw new Error(`${context} requires string field ${fieldName}`);
+    }
+    return value;
+}
+function optionalStringArrayField(input, fieldName, context) {
+    const value = input[fieldName];
+    if (value === undefined) {
+        return;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${context} field ${fieldName} must be a string array`);
+    }
+    return value.map((item, index) => {
+        if (typeof item !== "string") {
+            throw new Error(`${context} field ${fieldName}[${index}] must be a string`);
+        }
+        return item;
+    });
+}
+function requiredObjectArrayField(input, fieldName, context) {
+    const value = input[fieldName];
+    if (!Array.isArray(value)) {
+        throw new Error(`${context} requires object array field ${fieldName}`);
+    }
+    return value.map((item, index) => {
+        if (!isJsonObject(item)) {
+            throw new Error(`${context} field ${fieldName}[${index}] must be an object`);
+        }
+        return item;
+    });
+}
+function optionalJsonObjectField(input, fieldName, context) {
+    const value = input[fieldName];
+    if (value === undefined) {
+        return;
+    }
+    if (!isJsonObject(value)) {
+        throw new Error(`${context} field ${fieldName} must be an object`);
+    }
+    return value;
+}
+function readOntologyTier(input) {
+    const value = input.tier;
+    if (value === "platform" || value === "pack" || value === "tenant") {
+        return value;
+    }
+    if (value === undefined) {
+        return;
+    }
+    throw new Error("Ontology definition field tier must be platform, pack, or tenant");
+}
+function readOntologyStatus(input) {
+    const value = input.status;
+    if (value === "draft" || value === "active" || value === "deprecated") {
+        return value;
+    }
+    if (value === undefined) {
+        return;
+    }
+    throw new Error("Ontology update field status must be draft, active, or deprecated");
+}
+function readConstraintSeverity(input, context) {
+    const value = input.constraintSeverity;
+    if (value === "info" || value === "warn" || value === undefined) {
+        return value;
+    }
+    throw new Error(`${context} field constraintSeverity must be info or warn`);
+}
+function readOntologySubtypes(input, context) {
+    const value = input.subtypes;
+    if (value === undefined) {
+        return;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${context} field subtypes must be an object array`);
+    }
+    return value.map((item, index) => {
+        if (!isJsonObject(item)) {
+            throw new Error(`${context} field subtypes[${index}] must be an object`);
+        }
+        const subtypeContext = `${context}.subtypes[${index}]`;
+        return {
+            value: requiredStringField(item, "value", subtypeContext),
+            label: requiredStringField(item, "label", subtypeContext),
+            description: optionalStringField(item, "description"),
+        };
+    });
+}
+function readOntologyDefinitionInput(input) {
+    return {
+        ontologyKey: requiredStringField(input, "ontologyKey", "Ontology definition"),
+        name: requiredStringField(input, "name", "Ontology definition"),
+        description: optionalStringField(input, "description"),
+        tenantId: optionalStringField(input, "tenantId"),
+        tier: readOntologyTier(input),
+        workspaceId: optionalStringField(input, "workspaceId"),
+    };
+}
+function readOntologyDefinitionUpdateInput(input) {
+    return {
+        name: optionalStringField(input, "name"),
+        description: optionalStringField(input, "description"),
+        status: readOntologyStatus(input),
+        tenantId: optionalStringField(input, "tenantId"),
+        workspaceId: optionalStringField(input, "workspaceId"),
+    };
+}
+function readOntologyVersionInput(input) {
+    return {
+        version: requiredStringField(input, "version", "Ontology version"),
+        entityTypes: requiredObjectArrayField(input, "entityTypes", "Ontology version").map((entityType, index) => {
+            const context = `Ontology version entityTypes[${index}]`;
+            return {
+                value: requiredStringField(entityType, "value", context),
+                label: requiredStringField(entityType, "label", context),
+                description: optionalStringField(entityType, "description"),
+                schema: optionalJsonObjectField(entityType, "schema", context),
+                subtypes: readOntologySubtypes(entityType, context),
+            };
+        }),
+        edgeTypes: requiredObjectArrayField(input, "edgeTypes", "Ontology version").map((edgeType, index) => {
+            const context = `Ontology version edgeTypes[${index}]`;
+            return {
+                value: requiredStringField(edgeType, "value", context),
+                label: requiredStringField(edgeType, "label", context),
+                description: optionalStringField(edgeType, "description"),
+                sourceTypes: optionalStringArrayField(edgeType, "sourceTypes", context),
+                targetTypes: optionalStringArrayField(edgeType, "targetTypes", context),
+                constraintSeverity: readConstraintSeverity(edgeType, context),
+            };
+        }),
+        releaseNotes: optionalStringField(input, "releaseNotes"),
+        tenantId: optionalStringField(input, "tenantId"),
+        workspaceId: optionalStringField(input, "workspaceId"),
+    };
+}
 export function createClientLocalHelpers(ctx) {
-    const { auditClient, beliefsFacade, customNamespaceCache, evidenceFacade, exposeGatewayData, graphClient, graphFacade, gateway, functionSurfaceClient, ontologyClient, ontologyLinksClient, searchFacade, } = ctx;
-    const invokeCustomTool = async (fullName, input = {}) => {
+    const { auditClient, beliefsFacade, customNamespaceCache, evidenceFacade, exposeGatewayData, graphClient, gateway, functionSurfaceClient, ontologyClient, ontologyLinksClient, searchFacade, } = ctx;
+    const invokeCustomTool = (fullName, input = {}) => {
         const payload = normalizeCustomToolPayload(input);
         return invokeRegisteredCustomTool(fullName, payload, { source: "sdk" });
     };
@@ -73,7 +220,7 @@ export function createClientLocalHelpers(ctx) {
             : mergedResults.filter((result) => result.type === "belief");
         return { results };
     }
-    async function searchResources(query, options = {}) {
+    function searchResources(query, options = {}) {
         const topicId = resolveTopicId(options);
         if (!topicId) {
             throw new Error("topicId is required");
@@ -92,22 +239,29 @@ export function createClientLocalHelpers(ctx) {
     }
     async function findContradictions(args) {
         const topicId = resolveTopicId(args);
-        const response = topicId
-            ? await graphClient.listNodes({
+        let response;
+        if (topicId) {
+            response = await graphClient.listNodes({
                 topicId,
                 nodeType: "contradiction",
                 limit: 500,
-            })
-            : args.nodeId
-                ? await graphClient.listNodes({ nodeId: args.nodeId })
-                : { data: [] };
+            });
+        }
+        else if (args.nodeId) {
+            response = await graphClient.listNodes({ nodeId: args.nodeId });
+        }
+        else {
+            response = { data: [] };
+        }
         const contradictions = asNodeArray(response.data)
             .filter((node) => {
-            const status = typeof node.metadata?.status === "string"
-                ? node.metadata.status
-                : typeof node.status === "string"
-                    ? node.status
-                    : "unresolved";
+            let status = "unresolved";
+            if (typeof node.metadata?.status === "string") {
+                status = node.metadata.status;
+            }
+            else if (typeof node.status === "string") {
+                status = node.status;
+            }
             if (args.status && status !== args.status) {
                 return false;
             }
@@ -135,13 +289,9 @@ export function createClientLocalHelpers(ctx) {
     }
     async function queryLineage(nodeId, depth = 5) {
         const response = await beliefsFacade.lineage(nodeId);
-        const lineage = Array.isArray(response.data.lineage)
-            ? response.data.lineage
-            : [];
+        const lineage = (Array.isArray(response.data.lineage) ? response.data.lineage : []);
         const chain = lineage.length > 0
-            ? lineage
-                .slice(0, depth + 1)
-                .map((entry, index) => ({
+            ? lineage.slice(0, depth + 1).map((entry, index) => ({
                 nodeId: entry.nodeId ?? entry.beliefId ?? "",
                 relation: index === 0 ? "self" : "ancestor",
             }))
@@ -159,7 +309,7 @@ export function createClientLocalHelpers(ctx) {
             lineage,
         };
     }
-    async function getConfidenceHistory(nodeId) {
+    function getConfidenceHistory(nodeId) {
         return beliefsFacade.confidenceHistory(nodeId).then(exposeGatewayData);
     }
     async function getOpinionHistory(nodeId) {
@@ -186,10 +336,10 @@ export function createClientLocalHelpers(ctx) {
         });
         return { entries };
     }
-    async function bisectConfidence(nodeId, args) {
+    function bisectConfidence(nodeId, args) {
         return beliefsFacade.bisect(nodeId, args).then(exposeGatewayData);
     }
-    async function discoverTopics(input = {}) {
+    function discoverTopics(input = {}) {
         return gateway
             .request({
             path: "/api/platform/v1/context/discover",
@@ -198,7 +348,7 @@ export function createClientLocalHelpers(ctx) {
         })
             .then(exposeGatewayData);
     }
-    async function discoverEntityConnections(input = {}) {
+    function discoverEntityConnections(input = {}) {
         return gateway
             .request({
             path: "/api/platform/v1/context/entity-connections",
@@ -207,7 +357,7 @@ export function createClientLocalHelpers(ctx) {
         })
             .then(exposeGatewayData);
     }
-    async function triggerBeliefReview(input = {}) {
+    function triggerBeliefReview(input = {}) {
         return gateway
             .request({
             path: "/api/platform/v1/context/belief-review",
@@ -217,7 +367,7 @@ export function createClientLocalHelpers(ctx) {
         })
             .then(exposeGatewayData);
     }
-    async function createContractCompat(input = {}) {
+    function createContractCompat(input = {}) {
         return gateway
             .request({
             path: "/api/platform/v1/contracts",
@@ -227,7 +377,7 @@ export function createClientLocalHelpers(ctx) {
         })
             .then(exposeGatewayData);
     }
-    async function evaluateContractCompat(input = {}) {
+    function evaluateContractCompat(input = {}) {
         return gateway
             .request({
             path: "/api/platform/v1/contracts/evaluate",
@@ -237,7 +387,7 @@ export function createClientLocalHelpers(ctx) {
         })
             .then(exposeGatewayData);
     }
-    async function getContractStatusCompat(input = {}) {
+    function getContractStatusCompat(input = {}) {
         return gateway
             .request({
             path: "/api/platform/v1/contracts/status",
@@ -246,7 +396,7 @@ export function createClientLocalHelpers(ctx) {
         })
             .then(exposeGatewayData);
     }
-    async function listContractsCompat(input = {}) {
+    function listContractsCompat(input = {}) {
         return gateway
             .request({
             path: `/api/platform/v1/contracts${toQueryString({
@@ -260,31 +410,31 @@ export function createClientLocalHelpers(ctx) {
             .then(exposeGatewayData);
     }
     async function createOntologyCompat(input = {}) {
-        const response = await ontologyClient.createDefinition(input);
+        const response = await ontologyClient.createDefinition(readOntologyDefinitionInput(input));
         const envelope = response;
-        return Object.assign({}, envelope, envelope.data);
+        return { ...envelope, ...envelope.data };
     }
     async function updateOntologyCompat(input = {}) {
         const id = typeof input.id === "string" ? input.id : "";
         const { id: _id, ...rest } = input;
-        const response = await ontologyClient.updateDefinition(id, rest);
+        const response = await ontologyClient.updateDefinition(id, readOntologyDefinitionUpdateInput(rest));
         const envelope = response;
-        return Object.assign({}, envelope, envelope.data);
+        return { ...envelope, ...envelope.data };
     }
     async function archiveOntologyCompat(input = {}) {
         const id = typeof input.id === "string" ? input.id : "";
         const response = await ontologyClient.archiveDefinition(id);
         const envelope = response;
-        return Object.assign({}, envelope, envelope.data);
+        return { ...envelope, ...envelope.data };
     }
     async function createOntologyVersionCompat(input = {}) {
         const ontologyId = typeof input.ontologyId === "string" ? input.ontologyId : "";
         const { ontologyId: _ontologyId, ...rest } = input;
-        const response = await ontologyClient.createVersion(ontologyId, rest);
+        const response = await ontologyClient.createVersion(ontologyId, readOntologyVersionInput(rest));
         const envelope = response;
-        return Object.assign({}, envelope, envelope.data);
+        return { ...envelope, ...envelope.data };
     }
-    async function publishOntologyVersionCompat(input = {}) {
+    function publishOntologyVersionCompat(input = {}) {
         return gateway
             .request({
             path: "/api/platform/v1/ontologies/versions/publish",
@@ -294,7 +444,7 @@ export function createClientLocalHelpers(ctx) {
         })
             .then(exposeGatewayData);
     }
-    async function deprecateOntologyVersionCompat(input = {}) {
+    function deprecateOntologyVersionCompat(input = {}) {
         return gateway
             .request({
             path: "/api/platform/v1/ontologies/versions/deprecate",
@@ -304,7 +454,7 @@ export function createClientLocalHelpers(ctx) {
         })
             .then(exposeGatewayData);
     }
-    async function resolveEffectiveOntologyCompat(input = {}) {
+    function resolveEffectiveOntologyCompat(input = {}) {
         return gateway
             .request({
             path: "/api/platform/v1/ontologies/effective",
@@ -313,7 +463,7 @@ export function createClientLocalHelpers(ctx) {
         })
             .then(exposeGatewayData);
     }
-    async function traceEntityImpactCompat(input = {}) {
+    function traceEntityImpactCompat(input = {}) {
         return gateway
             .request({
             path: "/api/platform/v1/graph/trace-entity-impact",