@native-knowledge/knowledge-sdk 0.0.0-stage → 0.1.0-rc.1

package/dist/types/serving-contracts/tenant-governance.d.ts

@@ -0,0 +1,236 @@
+/** 显式 native consumer；旧 profile/Provider/Workflow schema 1 不自动升级。 */
+import { z } from 'zod';
+export declare const tenantConsumerProfileSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    acceptedCurrentnessBases: z.ZodArray<z.ZodLiteral<"RETAINED_SNAPSHOT">>;
+    legacySourcePolicy: z.ZodOptional<z.ZodLiteral<"PROJECT_POLICY_V1">>;
+    consumerKey: z.ZodString;
+    acceptedArtifactKinds: z.ZodArray<z.ZodEnum<{
+        SIGNAL_GENERATION: "SIGNAL_GENERATION";
+        RESEARCH: "RESEARCH";
+        REVIEW: "REVIEW";
+        KNOWLEDGE: "KNOWLEDGE";
+        INSIGHT: "INSIGHT";
+    }>>;
+    acceptedAccess: z.ZodArray<z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>>;
+    contentAccess: z.ZodArray<z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PUBLIC_METADATA: "PUBLIC_METADATA";
+        TENANT: "TENANT";
+        INTERNAL: "INTERNAL";
+        FDE_INTERNAL: "FDE_INTERNAL";
+        ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+        UNKNOWN: "UNKNOWN";
+    }>>;
+    acceptedReferenceTypes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type TenantConsumerProfile = z.infer<typeof tenantConsumerProfileSchema>;
+export declare const tenantWorkflowPlanInputSchema: z.ZodObject<{
+    ref: z.ZodString;
+}, z.core.$strict>;
+export declare const tenantWorkflowAdvanceInputSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    ref: z.ZodString;
+    expectedVersion: z.ZodNumber;
+    action: z.ZodEnum<{
+        SUBMIT_REVIEW: "SUBMIT_REVIEW";
+        FINALIZE_REVIEW: "FINALIZE_REVIEW";
+    }>;
+    reviewRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const tenantWorkflowPlanSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    tenantId: z.ZodString;
+    ref: z.ZodString;
+    contentHash: z.ZodString;
+    resourceType: z.ZodString;
+    kind: z.ZodString;
+    version: z.ZodNumber;
+    status: z.ZodUnion<[z.ZodEnum<{
+        GENERATED: "GENERATED";
+        DRAFT: "DRAFT";
+        READY_FOR_REVIEW: "READY_FOR_REVIEW";
+        REWORK_REQUIRED: "REWORK_REQUIRED";
+        APPROVED: "APPROVED";
+        REJECTED: "REJECTED";
+        SUPERSEDED: "SUPERSEDED";
+    }>, z.ZodEnum<{
+        RAW_MATERIAL: "RAW_MATERIAL";
+        RAW_EVIDENCE: "RAW_EVIDENCE";
+        REFERENCE_SNAPSHOT: "REFERENCE_SNAPSHOT";
+        REGISTERED_MATERIAL: "REGISTERED_MATERIAL";
+    }>]>;
+    productionPhase: z.ZodLiteral<"REGISTERED">;
+    readiness: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<2>;
+        profile: z.ZodEnum<{
+            HUMAN_ARTICLE_V1: "HUMAN_ARTICLE_V1";
+            KNOWLEDGE_CARD_V1: "KNOWLEDGE_CARD_V1";
+        }>;
+        ready: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodEnum<{
+            ROLE_MISMATCH: "ROLE_MISMATCH";
+            TITLE_REQUIRED: "TITLE_REQUIRED";
+            SUMMARY_REQUIRED: "SUMMARY_REQUIRED";
+            TEXT_TOO_SHORT: "TEXT_TOO_SHORT";
+            STRUCTURE_TOO_THIN: "STRUCTURE_TOO_THIN";
+            CITATION_COVERAGE_REQUIRED: "CITATION_COVERAGE_REQUIRED";
+            MEDIA_UNAVAILABLE: "MEDIA_UNAVAILABLE";
+            SOURCE_REQUIRED: "SOURCE_REQUIRED";
+            SOURCE_MISMATCH: "SOURCE_MISMATCH";
+        }>>;
+        metrics: z.ZodObject<{
+            textCharacters: z.ZodNumber;
+            blockCount: z.ZodNumber;
+            textBlockCount: z.ZodNumber;
+            mediaBlockCount: z.ZodNumber;
+            sourceCount: z.ZodNumber;
+            mediaEvidenceCount: z.ZodNumber;
+            citationCount: z.ZodNumber;
+            citedBlockCount: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    currentness: z.ZodNullable<z.ZodObject<{
+        observedAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+        sourceRevisionRef: z.ZodOptional<z.ZodString>;
+        lastAttemptAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+        assessedAt: z.ZodISODateTime;
+        state: z.ZodEnum<{
+            UNKNOWN: "UNKNOWN";
+            DUE: "DUE";
+            CURRENT: "CURRENT";
+            STALE: "STALE";
+            BLOCKED: "BLOCKED";
+        }>;
+        action: z.ZodEnum<{
+            ALLOW: "ALLOW";
+            REVIEW_REQUIRED: "REVIEW_REQUIRED";
+            DENY: "DENY";
+        }>;
+        reasonCode: z.ZodEnum<{
+            CURRENT_WITHIN_CADENCE: "CURRENT_WITHIN_CADENCE";
+            REFRESH_DUE: "REFRESH_DUE";
+            STALE_AFTER_THRESHOLD: "STALE_AFTER_THRESHOLD";
+            SOURCE_BLOCKED: "SOURCE_BLOCKED";
+            SOURCE_CONTENT_CHANGED: "SOURCE_CONTENT_CHANGED";
+            NO_SUCCESSFUL_OBSERVATION: "NO_SUCCESSFUL_OBSERVATION";
+        }>;
+        policy: z.ZodObject<{
+            schemaVersion: z.ZodLiteral<1>;
+            dueAfterSeconds: z.ZodNumber;
+            staleAfterSeconds: z.ZodNumber;
+            staleAction: z.ZodDefault<z.ZodEnum<{
+                ALLOW: "ALLOW";
+                REVIEW_REQUIRED: "REVIEW_REQUIRED";
+                DENY: "DENY";
+            }>>;
+            unknownAction: z.ZodDefault<z.ZodEnum<{
+                ALLOW: "ALLOW";
+                REVIEW_REQUIRED: "REVIEW_REQUIRED";
+                DENY: "DENY";
+            }>>;
+            blockedAction: z.ZodDefault<z.ZodEnum<{
+                ALLOW: "ALLOW";
+                REVIEW_REQUIRED: "REVIEW_REQUIRED";
+                DENY: "DENY";
+            }>>;
+        }, z.core.$strict>;
+        lastSuccessAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+        dueAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+        staleAt: z.ZodDefault<z.ZodNullable<z.ZodISODateTime>>;
+        ageSeconds: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        basis: z.ZodLiteral<"RETAINED_SNAPSHOT">;
+        basisRef: z.ZodString;
+        declarationRef: z.ZodString;
+        tenantId: z.ZodString;
+        subjectRef: z.ZodString;
+        resourceType: z.ZodString;
+        contentHash: z.ZodString;
+        schemaVersion: z.ZodLiteral<2>;
+        subjectKind: z.ZodLiteral<"MATERIAL">;
+    }, z.core.$strict>>;
+    governedPolicyReady: z.ZodBoolean;
+    consumerReadDecision: z.ZodNullable<z.ZodObject<{
+        action: z.ZodEnum<{
+            ALLOW: "ALLOW";
+            REVIEW_REQUIRED: "REVIEW_REQUIRED";
+            DENY: "DENY";
+        }>;
+        reasonCodes: z.ZodArray<z.ZodString>;
+        authority: z.ZodEnum<{
+            AUTHENTICATED_READER: "AUTHENTICATED_READER";
+            LOCAL_PROFILE_SIMULATION: "LOCAL_PROFILE_SIMULATION";
+        }>;
+    }, z.core.$strict>>;
+    externalReady: z.ZodBoolean;
+    successorRef: z.ZodNullable<z.ZodString>;
+    blockers: z.ZodArray<z.ZodString>;
+    nextActions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        tool: z.ZodNullable<z.ZodString>;
+        arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        requiredScopes: z.ZodArray<z.ZodString>;
+        missingScopes: z.ZodArray<z.ZodString>;
+        missingFields: z.ZodArray<z.ZodString>;
+        canExecute: z.ZodBoolean;
+        automatic: z.ZodBoolean;
+        reasonCode: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TenantWorkflowPlan = z.infer<typeof tenantWorkflowPlanSchema>;
+export declare const tenantGovernedReadResultSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    tenantId: z.ZodString;
+    ref: z.ZodString;
+    decision: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        action: z.ZodEnum<{
+            ALLOW: "ALLOW";
+            REVIEW_REQUIRED: "REVIEW_REQUIRED";
+            DENY: "DENY";
+        }>;
+        reasonCodes: z.ZodArray<z.ZodEnum<{
+            NOT_FOUND: "NOT_FOUND";
+            ACCESS_DENIED: "ACCESS_DENIED";
+            CONTENT_ACCESS_DENIED: "CONTENT_ACCESS_DENIED";
+            ARTIFACT_NOT_APPROVED: "ARTIFACT_NOT_APPROVED";
+            ARTIFACT_SUPERSEDED: "ARTIFACT_SUPERSEDED";
+            SEMANTIC_REVIEW_REQUIRED: "SEMANTIC_REVIEW_REQUIRED";
+            SEMANTIC_DENIED: "SEMANTIC_DENIED";
+            SEMANTIC_ADMISSION_MISSING: "SEMANTIC_ADMISSION_MISSING";
+            CURRENTNESS_MISSING: "CURRENTNESS_MISSING";
+            CURRENTNESS_REVIEW_REQUIRED: "CURRENTNESS_REVIEW_REQUIRED";
+            CURRENTNESS_DENIED: "CURRENTNESS_DENIED";
+            STALE: "STALE";
+            VALIDITY_EXPIRED: "VALIDITY_EXPIRED";
+            CLAIM_REVIEW_REQUIRED: "CLAIM_REVIEW_REQUIRED";
+            CLAIM_DENIED: "CLAIM_DENIED";
+            CLAIM_NOT_EFFECTIVE: "CLAIM_NOT_EFFECTIVE";
+            REFERENCE_NOT_COVERED: "REFERENCE_NOT_COVERED";
+            REFERENCE_NOT_EFFECTIVE: "REFERENCE_NOT_EFFECTIVE";
+            REFERENCE_VALIDITY_EXPIRED: "REFERENCE_VALIDITY_EXPIRED";
+            REFERENCE_STALE: "REFERENCE_STALE";
+            REFERENCE_UNAVAILABLE: "REFERENCE_UNAVAILABLE";
+            REFERENCE_REVIEW_REQUIRED: "REFERENCE_REVIEW_REQUIRED";
+            REFERENCE_DENIED: "REFERENCE_DENIED";
+            UNSUPPORTED_RESOURCE: "UNSUPPORTED_RESOURCE";
+            GOVERNANCE_NOT_CONFIGURED: "GOVERNANCE_NOT_CONFIGURED";
+            UNAVAILABLE: "UNAVAILABLE";
+            INTEGRITY_MISMATCH: "INTEGRITY_MISMATCH";
+        }>>;
+        assessedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    descriptor: z.ZodNullable<z.ZodObject<{
+        contentHash: z.ZodString;
+        mediaType: z.ZodString;
+        byteLength: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;