@native-marketing/sdk 0.3.5 → 0.3.6

package/dist/index.js

@@ -5922,7 +5922,8 @@ var knowledgeDiscoveryDescriptionSchema = z79.object({
   checkedAt: z79.string().datetime()
 }).strict();
 var knowledgeAdoptionCommandSchema = knowledgeDiscoveryReadQuerySchema.required().extend({
-  requestId: z79.string().min(1).max(128)
+  requestId: z79.string().min(1).max(128),
+  ref: knowledgeRemoteRefSchema.max(2048)
 }).strict();
 var knowledgeAdoptionResultSchema = z79.object({ result: sourceRefSchema, replayed: z79.boolean() }).strict();
 var knowledgeAdoptionReceiptQuerySchema = z79.object({ requestId: z79.string().min(1).max(128) }).strict();
@@ -5938,6 +5939,15 @@ var adoptedKnowledgeResourceSchema = z79.object({
   ref: knowledgeRemoteRefSchema,
   identityHash: z79.string().regex(/^sha256:[a-f0-9]{64}$/)
 }).strict();
+var knowledgeResourceDescriptorSchema = knowledgeDiscoveryItemSchema.pick({
+  ref: true,
+  identityHash: true,
+  ownerTenantId: true,
+  resourceType: true,
+  kind: true,
+  classification: true,
+  title: true
+}).extend({ schemaVersion: z79.literal(1) }).strict();
 
 // packages/contracts/src/material-verification.ts
 import { z as z80 } from "zod";
@@ -6924,7 +6934,21 @@ var surveyRejections = [
   "PERSONAL_SURVEY_DRAFT_TRANSITION_IMMUTABLE"
 ];
 function isKnownCapabilityRejection(code2, name) {
-  return capabilityRejectedErrorCodes.includes(code2) || name === "cf_adopt_discovered_knowledge" && [
+  return capabilityRejectedErrorCodes.includes(code2) || name === "cf_repair_knowledge_reference" && [
+    "KNOWLEDGE_REFERENCE_REPAIR_CONFLICT",
+    "KNOWLEDGE_REFERENCE_REPAIR_NOT_SUPPORTED",
+    "KNOWLEDGE_REFERENCE_REPAIR_IDENTITY_MISMATCH",
+    "KNOWLEDGE_DISCOVERY_IDENTITY_CHANGED",
+    "KNOWLEDGE_DISCOVERY_FORBIDDEN",
+    "KNOWLEDGE_DISCOVERY_UNAVAILABLE",
+    "KNOWLEDGE_CATALOG_UNAVAILABLE",
+    "KNOWLEDGE_TENANT_IDENTITY_CHANGED",
+    "KNOWLEDGE_CATALOG_SCOPE_NOT_CONFIGURED",
+    "KNOWLEDGE_PROVIDER_AUTH_REQUIRED",
+    "KNOWLEDGE_ARTIFACT_ACCESS_DENIED",
+    "KNOWLEDGE_ARTIFACT_TOO_LARGE",
+    "KNOWLEDGE_ARTIFACT_DOWNLOAD_BUSY"
+  ].includes(code2) || name === "cf_adopt_discovered_knowledge" && [
     "KNOWLEDGE_DISCOVERY_IDENTITY_CHANGED",
     "KNOWLEDGE_DISCOVERY_FORBIDDEN",
     "KNOWLEDGE_DISCOVERY_TEXT_TOO_LARGE",
@@ -7261,6 +7285,26 @@ var eventExchangePageSchema = z101.object({
   nextAfter: z101.string().max(256).nullable()
 }).strict();
 
+// packages/contracts/src/knowledge-reference-repair.ts
+import { z as z102 } from "zod";
+var knowledgeReferenceRepairQuerySchema = z102.object({
+  sourceRef: stableRefSchema.refine((value) => value.startsWith("cf://source/"))
+}).strict();
+var knowledgeReferenceRepairPreviewSchema = z102.object({
+  sourceRef: knowledgeReferenceRepairQuerySchema.shape.sourceRef,
+  remoteRef: z102.string().min(1).max(2048),
+  basisHash: z102.string().regex(/^sha256:[a-f0-9]{64}$/),
+  sourceTenantId: z102.string().min(1).max(256),
+  item: knowledgeDiscoveryItemSchema,
+  byteLength: z102.number().int().nonnegative().safe(),
+  verified: z102.literal(true)
+}).strict();
+var knowledgeReferenceRepairCommandSchema = knowledgeReferenceRepairQuerySchema.extend({
+  requestId: z102.string().min(1).max(128),
+  expectedBasisHash: knowledgeReferenceRepairPreviewSchema.shape.basisHash
+}).strict();
+var knowledgeReferenceRepairReceiptQuerySchema = knowledgeAdoptionReceiptQuerySchema;
+
 // packages/contracts/src/agent/capability-receipts.ts
 var rule = (capability, schema2, operation, keys = [], field) => ({ capability, schema: schema2, operation, keys, field });
 var foundation = (operation, field) => rule(
@@ -7282,6 +7326,10 @@ var execution = (family, operation) => ({
 });
 var learning = (op) => rule("cf_get_learning_command_receipt", learningReceiptSchema, op);
 var rules = {
+  cf_repair_knowledge_reference: rule(
+    "cf_get_knowledge_reference_repair_receipt",
+    knowledgeReferenceRepairReceiptQuerySchema
+  ),
   cf_configure_event_exchange: rule(
     "cf_get_event_exchange_receipt",
     eventExchangeReceiptQuerySchema
@@ -7505,7 +7553,7 @@ function capabilityReceiptRead(name, input) {
 }
 
 // packages/contracts/src/agent/capability-status.ts
-import { z as z102 } from "zod";
+import { z as z103 } from "zod";
 var verification = {
   capability: "cf_material_verification_status",
   schema: materialVerificationIdSchema,
@@ -7523,7 +7571,7 @@ var rules2 = {
   },
   cf_tenant_material_scan_advance: {
     capability: "cf_tenant_material_scan_status",
-    schema: z102.object({}).strict()
+    schema: z103.object({}).strict()
   },
   cf_sync_materials: {
     capability: "cf_reconcile_materials",
@@ -9254,6 +9302,9 @@ var commandTools = {
   "knowledge discover": "cf_discover_knowledge",
   "knowledge adopt": "cf_adopt_discovered_knowledge",
   "knowledge adoption-receipt": "cf_get_knowledge_adoption_receipt",
+  "knowledge repair-preview": "cf_preview_knowledge_reference_repair",
+  "knowledge repair-reference": "cf_repair_knowledge_reference",
+  "knowledge repair-receipt": "cf_get_knowledge_reference_repair_receipt",
   "knowledge read-discovered": "cf_read_discovered_knowledge",
   "knowledge describe-discovered": "cf_describe_discovered_knowledge",
   "knowledge materials": "cf_list_materials",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@native-marketing/sdk",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "type": "module",
   "license": "Apache-2.0",
   "engines": {

package/release.json

@@ -1,7 +1,7 @@
 {
-  "sourceCommit": "667f36fbe201292e233c4be3cc8ba84483867fd9",
+  "sourceCommit": "40463e01d4112b05570b24ec7da538ed5f489d0d",
   "workingTreeDirty": false,
-  "version": "0.3.5",
-  "openapiTypesSha256": "4cf54da717c27d1df685ee4756f78c5094e90fe72c3d3047e7b901b7e8b6c1b8",
+  "version": "0.3.6",
+  "openapiTypesSha256": "e79e0abf034cae01174e67464aea55f16d40895c86199eff93897ec892ea82f4",
   "localBuild": true
 }

package/types/contracts/human-knowledge.d.ts

@@ -507,6 +507,8 @@ export declare const humanKnowledgeItemDetailSchema: z.ZodObject<{
     contentAvailable: z.ZodBoolean;
     projectBound: z.ZodNullable<z.ZodBoolean>;
     selected: z.ZodBoolean;
+    referenceRepairRequired: z.ZodOptional<z.ZodBoolean>;
+    resourceLinked: z.ZodOptional<z.ZodBoolean>;
     originalUrl: z.ZodNullable<z.ZodString>;
     evidenceRefs: z.ZodArray<z.ZodString>;
     relatedRefs: z.ZodArray<z.ZodString>;

package/types/contracts/index.d.ts

@@ -107,6 +107,7 @@ export * from './business-command-receipt.js';
 export * from './operating-command-receipts.js';
 export * from './feedback-facts.js';
 export * from './knowledge-discovery.js';
+export * from './knowledge-reference-repair.js';
 export * from './event-exchange.js';
 export * from './event-exchange-browser.js';
 export { EVENTSDK_WORKER_OBSERVATION_MAX_AGE_MS, eventDeliveryPageQuerySchema, eventDeliveryPageSchema, eventDeliveryRecoveryResultSchema, eventDeliveryRecoveryReceiptSchema, } from './event-delivery.js';

package/types/contracts/knowledge-discovery.d.ts

@@ -133,9 +133,9 @@ export declare const knowledgeDiscoveryDescriptionSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type KnowledgeDiscoveryDescription = z.infer<typeof knowledgeDiscoveryDescriptionSchema>;
 export declare const knowledgeAdoptionCommandSchema: z.ZodObject<{
-    ref: z.ZodNonOptional<z.ZodString>;
     expectedContentHash: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
     requestId: z.ZodString;
+    ref: z.ZodString;
 }, z.core.$strict>;
 export declare const knowledgeAdoptionResultSchema: z.ZodObject<{
     result: z.ZodObject<{
@@ -213,3 +213,13 @@ export declare const adoptedKnowledgeResourceSchema: z.ZodObject<{
     identityHash: z.ZodString;
 }, z.core.$strict>;
 export type KnowledgeAdoptionCommand = z.infer<typeof knowledgeAdoptionCommandSchema>;
+export declare const knowledgeResourceDescriptorSchema: z.ZodObject<{
+    ref: z.ZodString;
+    ownerTenantId: z.ZodString;
+    resourceType: z.ZodString;
+    identityHash: z.ZodString;
+    kind: z.ZodString;
+    classification: z.ZodString;
+    title: z.ZodString;
+    schemaVersion: z.ZodLiteral<1>;
+}, z.core.$strict>;

package/types/contracts/knowledge-reference-repair.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+export declare const knowledgeReferenceRepairQuerySchema: z.ZodObject<{
+    sourceRef: z.ZodString;
+}, z.core.$strict>;
+export declare const knowledgeReferenceRepairPreviewSchema: z.ZodObject<{
+    sourceRef: z.ZodString;
+    remoteRef: z.ZodString;
+    basisHash: z.ZodString;
+    sourceTenantId: z.ZodString;
+    item: z.ZodObject<{
+        ref: z.ZodString;
+        ownerTenantId: z.ZodString;
+        resourceType: z.ZodString;
+        originType: z.ZodEnum<{
+            LEGACY_PROJECT: "LEGACY_PROJECT";
+            TENANT_AUTHOR: "TENANT_AUTHOR";
+            TENANT_SOURCE: "TENANT_SOURCE";
+        }>;
+        identityHash: z.ZodString;
+        identityKind: z.ZodEnum<{
+            CAS_BYTES: "CAS_BYTES";
+            REFERENCE_RECORD_DIGEST: "REFERENCE_RECORD_DIGEST";
+        }>;
+        kind: z.ZodString;
+        classification: z.ZodString;
+        mediaType: z.ZodString;
+        title: z.ZodString;
+        summary: z.ZodString;
+        readable: z.ZodBoolean;
+        reasonCodes: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    byteLength: z.ZodNumber;
+    verified: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export declare const knowledgeReferenceRepairCommandSchema: z.ZodObject<{
+    sourceRef: z.ZodString;
+    requestId: z.ZodString;
+    expectedBasisHash: z.ZodString;
+}, z.core.$strict>;
+export declare const knowledgeReferenceRepairResultSchema: z.ZodObject<{
+    result: z.ZodObject<{
+        id: z.ZodString;
+        ref: z.ZodString;
+        tenantId: z.ZodString;
+        sourceType: z.ZodEnum<{
+            CASE_EVIDENCE: "CASE_EVIDENCE";
+            EXTERNAL_REFERENCE: "EXTERNAL_REFERENCE";
+            HOT_TOPIC: "HOT_TOPIC";
+            HUMAN_IDEA: "HUMAN_IDEA";
+            INSIGHT: "INSIGHT";
+            KNOWLEDGE: "KNOWLEDGE";
+            NEWS: "NEWS";
+            TREND: "TREND";
+            WORLD_FACT: "WORLD_FACT";
+        }>;
+        sourceRef: z.ZodString;
+        sourceAuthority: z.ZodString;
+        observedAt: z.ZodNullable<z.ZodString>;
+        validUntil: z.ZodNullable<z.ZodString>;
+        evidenceRef: z.ZodNullable<z.ZodString>;
+        snapshotHash: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
+    replayed: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const knowledgeReferenceRepairReceiptQuerySchema: z.ZodObject<{
+    requestId: z.ZodString;
+}, z.core.$strict>;
+export declare const knowledgeReferenceRepairReceiptSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    state: z.ZodLiteral<"FOUND">;
+    result: z.ZodObject<{
+        id: z.ZodString;
+        ref: z.ZodString;
+        tenantId: z.ZodString;
+        sourceType: z.ZodEnum<{
+            CASE_EVIDENCE: "CASE_EVIDENCE";
+            EXTERNAL_REFERENCE: "EXTERNAL_REFERENCE";
+            HOT_TOPIC: "HOT_TOPIC";
+            HUMAN_IDEA: "HUMAN_IDEA";
+            INSIGHT: "INSIGHT";
+            KNOWLEDGE: "KNOWLEDGE";
+            NEWS: "NEWS";
+            TREND: "TREND";
+            WORLD_FACT: "WORLD_FACT";
+        }>;
+        sourceRef: z.ZodString;
+        sourceAuthority: z.ZodString;
+        observedAt: z.ZodNullable<z.ZodString>;
+        validUntil: z.ZodNullable<z.ZodString>;
+        evidenceRef: z.ZodNullable<z.ZodString>;
+        snapshotHash: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>, z.ZodObject<{
+    state: z.ZodLiteral<"NOT_FOUND">;
+    result: z.ZodNull;
+}, z.core.$strict>, z.ZodObject<{
+    state: z.ZodLiteral<"REJECTED">;
+    result: z.ZodNull;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        outcome: z.ZodLiteral<"REJECTED">;
+        recovery: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>], "state">;
+export type KnowledgeReferenceRepairPreview = z.infer<typeof knowledgeReferenceRepairPreviewSchema>;

package/types/http/generated/schema.d.ts

@@ -13326,6 +13326,8 @@ export interface paths {
               contentAvailable: boolean;
               projectBound: boolean | null;
               selected: boolean;
+              referenceRepairRequired?: boolean;
+              resourceLinked?: boolean;
               /** Format: uri */
               originalUrl: string | null;
               evidenceRefs: string[];
@@ -13491,6 +13493,8 @@ export interface paths {
               contentAvailable: boolean;
               projectBound: boolean | null;
               selected: boolean;
+              referenceRepairRequired?: boolean;
+              resourceLinked?: boolean;
               /** Format: uri */
               originalUrl: string | null;
               evidenceRefs: string[];
@@ -72738,6 +72742,645 @@ export interface paths {
     patch?: never;
     trace?: never;
   };
+  '/tenants/{tenantCode}/knowledge/reference-repair/preview': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get: {
+      parameters: {
+        query: {
+          sourceRef: string;
+        };
+        header?: never;
+        path: {
+          tenantCode: string;
+        };
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Default Response */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              sourceRef: string;
+              remoteRef: string;
+              basisHash: string;
+              sourceTenantId: string;
+              item: {
+                ref: string;
+                ownerTenantId: string;
+                resourceType: string;
+                /** @enum {string} */
+                originType: 'LEGACY_PROJECT' | 'TENANT_AUTHOR' | 'TENANT_SOURCE';
+                identityHash: string;
+                /** @enum {string} */
+                identityKind: 'CAS_BYTES' | 'REFERENCE_RECORD_DIGEST';
+                kind: string;
+                classification: string;
+                mediaType: string;
+                title: string;
+                summary: string;
+                readable: boolean;
+                reasonCodes: string[];
+              };
+              byteLength: number;
+              /** @enum {boolean} */
+              verified: true;
+            };
+          };
+        };
+        /** @description Default Response */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        409: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        413: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        415: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        502: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        503: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/tenants/{tenantCode}/knowledge/reference-repair': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path: {
+          tenantCode: string;
+        };
+        cookie?: never;
+      };
+      requestBody: {
+        content: {
+          'application/json': {
+            sourceRef: string;
+            requestId: string;
+            expectedBasisHash: string;
+          };
+        };
+      };
+      responses: {
+        /** @description Default Response */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              result: {
+                /** Format: uuid */
+                id: string;
+                ref: string;
+                /** Format: uuid */
+                tenantId: string;
+                /** @enum {string} */
+                sourceType:
+                  | 'KNOWLEDGE'
+                  | 'INSIGHT'
+                  | 'TREND'
+                  | 'HOT_TOPIC'
+                  | 'WORLD_FACT'
+                  | 'NEWS'
+                  | 'CASE_EVIDENCE'
+                  | 'HUMAN_IDEA'
+                  | 'EXTERNAL_REFERENCE';
+                sourceRef: string;
+                sourceAuthority: string;
+                /** Format: date-time */
+                observedAt: string | null;
+                /** Format: date-time */
+                validUntil: string | null;
+                evidenceRef: string | null;
+                snapshotHash: string | null;
+                metadata: {
+                  [key: string]: unknown;
+                };
+                /** Format: date-time */
+                createdAt: string;
+              };
+              replayed: boolean;
+            };
+          };
+        };
+        /** @description Default Response */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        409: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        413: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        415: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        502: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        503: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/tenants/{tenantCode}/knowledge/reference-repair/receipt': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get: {
+      parameters: {
+        query: {
+          requestId: string;
+        };
+        header?: never;
+        path: {
+          tenantCode: string;
+        };
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Default Response */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json':
+              | {
+                  /** @enum {string} */
+                  state: 'FOUND';
+                  result: {
+                    /** Format: uuid */
+                    id: string;
+                    ref: string;
+                    /** Format: uuid */
+                    tenantId: string;
+                    /** @enum {string} */
+                    sourceType:
+                      | 'KNOWLEDGE'
+                      | 'INSIGHT'
+                      | 'TREND'
+                      | 'HOT_TOPIC'
+                      | 'WORLD_FACT'
+                      | 'NEWS'
+                      | 'CASE_EVIDENCE'
+                      | 'HUMAN_IDEA'
+                      | 'EXTERNAL_REFERENCE';
+                    sourceRef: string;
+                    sourceAuthority: string;
+                    /** Format: date-time */
+                    observedAt: string | null;
+                    /** Format: date-time */
+                    validUntil: string | null;
+                    evidenceRef: string | null;
+                    snapshotHash: string | null;
+                    metadata: {
+                      [key: string]: unknown;
+                    };
+                    /** Format: date-time */
+                    createdAt: string;
+                  };
+                }
+              | {
+                  /** @enum {string} */
+                  state: 'NOT_FOUND';
+                  /** @enum {string|null} */
+                  result: null;
+                }
+              | {
+                  /** @enum {string} */
+                  state: 'REJECTED';
+                  /** @enum {string|null} */
+                  result: null;
+                  error: {
+                    code: string;
+                    /** @enum {string} */
+                    outcome: 'REJECTED';
+                    recovery: string;
+                  };
+                };
+          };
+        };
+        /** @description Default Response */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        403: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        409: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        413: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        415: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        502: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+        /** @description Default Response */
+        503: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': {
+              error: {
+                code: string;
+                message: string;
+                requestId?: string;
+              };
+            };
+          };
+        };
+      };
+    };
+    put?: never;
+    post?: never;
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
 }
 export type webhooks = Record<string, never>;
 export interface components {