@tiangong-lca/cli 0.1.0 → 0.1.2

package/dist/src/lib/dataset-maintenance-flow-identity-contract.d.ts

@@ -0,0 +1,387 @@
+import { type DatasetMaintenanceRowSnapshot, type JsonObject } from './dataset-maintenance-contract.js';
+import { type StandardStMultiLang } from './dataset-maintenance-flow-identity-wire.js';
+export declare const FLOW_IDENTITY_SOURCE_COUNT = 305;
+export declare const FLOW_IDENTITY_REFERENCE_FIELDS: readonly ['@refObjectId', '@type', '@uri', '@version', 'common:shortDescription'];
+export declare const HISTORICAL_FLOW_IDENTITY_AUTHORITY_SHA256: Set<string>;
+export type FlowIdentityDirection = 'Input' | 'Output';
+export type FlowIdentityDisposition = 'map_public' | 'pending' | 'blocker' | 'orphan';
+export type FlowIdentityArtifactSha256 = string;
+export type FlowIdentityDbOpaqueSha256 = string;
+export type FlowIdentitySharedRequestSha256 = string;
+export type FlowIdentityReference = {
+    '@refObjectId': string;
+    '@type': 'flow data set';
+    '@uri': string;
+    '@version': string;
+    'common:shortDescription': StandardStMultiLang;
+};
+export type FlowIdentityCompatibilityPolicy = {
+    schema_version: 'dataset-flow-identity-compatibility-policy.v1';
+    policy_sha256: string;
+    evidence_resolution_sha256: string;
+    approved_at_utc: string;
+    approval_text_sha256: string;
+};
+export type FlowIdentityReviewEntry = {
+    source: {
+        id: string;
+        version: string;
+    };
+    disposition: FlowIdentityDisposition;
+    target: {
+        id: string;
+        version: string;
+        reference: FlowIdentityReference;
+    } | null;
+    allowed_directions: FlowIdentityDirection[];
+    source_trace_sha256: string;
+    compartment_evidence_sha256: string;
+    decision_evidence_sha256: string;
+};
+export type FlowIdentityReviewLedger = {
+    schema_version: 'dataset-flow-identity-review-ledger.v3';
+    generated_at_utc: string;
+    source_count: 305;
+    review_evidence_sha256: string;
+    execution_authority: false;
+    entries: FlowIdentityReviewEntry[];
+    ledger_sha256: string;
+};
+export type FlowIdentityCaptureAttestation = {
+    ok: true;
+    command: 'cmd_dataset_flow_identity_capture_attest_guarded';
+    schema_version: 'dataset-flow-identity-capture-attest-result.v2';
+    proof_domain: 'dataset-flow-identity-db-proof.v2';
+    receipt_id: string;
+    receipt_proof_sha256: FlowIdentityDbOpaqueSha256;
+    operation_id: string;
+    environment: 'production' | 'preview' | 'local';
+    project_ref: string;
+    captured_at: string;
+    expires_at: string;
+    source_guard_set_sha256: FlowIdentityDbOpaqueSha256;
+    support_guard_set_sha256: FlowIdentityDbOpaqueSha256;
+    target_guard_set_sha256: FlowIdentityDbOpaqueSha256;
+    mapping_guard_set_sha256: FlowIdentityDbOpaqueSha256;
+    process_intent_set_sha256: FlowIdentityDbOpaqueSha256;
+    protected_closure_sha256: FlowIdentityDbOpaqueSha256;
+    whole_scope_proof_sha256: FlowIdentityDbOpaqueSha256;
+    policy_sha256: FlowIdentityDbOpaqueSha256;
+    policy_approval_text_sha256: FlowIdentityDbOpaqueSha256;
+    source_count: 305;
+    target_count: number;
+    support_count: number;
+    mapping_count: number;
+    process_count: number;
+    rewrite_count: number;
+    capture_request_sha256: FlowIdentitySharedRequestSha256;
+    replay: boolean;
+};
+export type FlowIdentityCaptureRequest = {
+    schema_version: 'dataset-flow-identity-capture-attest.v2';
+    request_id: string;
+    environment: 'production' | 'preview' | 'local';
+    project_ref: string;
+    actor: {
+        user_id: string;
+        email: string;
+    };
+    target_visibility: 'owner_draft';
+    operation_id: string;
+    compatibility_policy: FlowIdentityCompatibilityPolicy;
+    artifact_evidence: {
+        review_ledger_sha256: FlowIdentityArtifactSha256;
+        live_capture_artifact_sha256: FlowIdentityArtifactSha256;
+        toolchain_evidence_sha256: FlowIdentityArtifactSha256;
+    };
+    mappings: JsonObject[];
+    process_intents: JsonObject[];
+    protected_closure: JsonObject;
+};
+export type FlowIdentityCaptureCompleteness = {
+    schema_version: 'dataset-flow-identity-capture-completeness.v2';
+    source_count: 305;
+    target_count: number;
+    support_count: number;
+    owner_draft_process_count: number;
+    owner_draft_process_scan: JsonObject;
+};
+export type FlowIdentityLiveCapture = {
+    schema_version: 'dataset-flow-identity-live-capture.v2';
+    captured_at_utc: string;
+    environment: 'production' | 'preview' | 'local';
+    project_ref: string;
+    account: {
+        user_id: string;
+        email: string;
+    };
+    prerequisites: {
+        step2_readback_sha256: string;
+        step2_completed_at_utc: string;
+        issue29_target1_readback_sha256: string;
+        issue29_target1_completed_at_utc: string;
+        issue29_target2_readback_sha256: string;
+        issue29_target2_completed_at_utc: string;
+    };
+    sdk: {
+        package: '@tiangong-lca/tidas-sdk';
+        version: string;
+    };
+    artifact_evidence: {
+        review_ledger_sha256: FlowIdentityArtifactSha256;
+        live_capture_artifact_sha256: FlowIdentityArtifactSha256;
+        toolchain_evidence_sha256: FlowIdentityArtifactSha256;
+    };
+    completeness: FlowIdentityCaptureCompleteness;
+    source_rows: DatasetMaintenanceRowSnapshot[];
+    target_rows: DatasetMaintenanceRowSnapshot[];
+    support_rows: DatasetMaintenanceRowSnapshot[];
+    process_rows: DatasetMaintenanceRowSnapshot[];
+    capture_request: FlowIdentityCaptureRequest;
+    attestation: FlowIdentityCaptureAttestation;
+    capture_artifact_sha256: FlowIdentityArtifactSha256;
+};
+export type FlowIdentityMappingEndpoint = {
+    id: string;
+    version: string;
+    user_id: string;
+    state_code: number;
+    modified_at: string;
+    payload_sha256: string;
+    row_sha256: string;
+    flow_type: 'Elementary flow';
+    flow_property_id: string;
+    flow_property_version: string;
+    unit_group_id: string;
+    unit_group_version: string;
+    category_path_sha256: string;
+};
+export type FlowIdentityMapping = {
+    ordinal: number;
+    mapping_id: string;
+    source: FlowIdentityMappingEndpoint & {
+        source_trace_sha256: string;
+    };
+    target: FlowIdentityMappingEndpoint & {
+        reference: FlowIdentityReference;
+    };
+    compatibility: {
+        policy_sha256: string;
+        mode: 'identity';
+        confidence: 'approved';
+        flow_property_compatible: true;
+        unit_group_compatible: true;
+        direction_compatible: true;
+        compartment_compatible: true;
+        conversion_factor: '1';
+        evidence_sha256: string;
+        flow_schema: {
+            status: 'pass' | 'legacy_warning';
+            warning_set_sha256: string;
+        };
+        process_schema_required: 'pass';
+    };
+};
+export type FlowIdentitySupportSnapshot = {
+    ordinal: number;
+    table: 'flowproperties' | 'unitgroups';
+    id: string;
+    version: string;
+    user_id: string;
+    state_code: 0 | 100;
+    modified_at: string;
+    payload_sha256: string;
+    row_sha256: string;
+};
+export type FlowIdentityProcessManifest = {
+    ordinal: number;
+    id: string;
+    version: string;
+    user_id: string;
+    state_code: 0;
+    modified_at: string;
+    model_id: string | null;
+    rule_verification: boolean | null;
+    before_row_sha256: string;
+    before_payload_sha256: string;
+    before_exchange_set_sha256: string;
+    before_exchange_count: number;
+    desired_payload_sha256: string;
+    desired_exchange_set_sha256: string;
+    rewrite_count: number;
+    process_template_sha256: string;
+    rewrite_set_sha256: string;
+    collision_ledger_sha256: string;
+    process_schema: {
+        status: 'pass';
+        evidence_sha256: string;
+    };
+    pending_blocker_closure_sha256: string;
+};
+export type FlowIdentityRewrite = {
+    ordinal: number;
+    exchange_index: number;
+    internal_id: string;
+    direction: FlowIdentityDirection;
+    mapping_id: string;
+    source_reference: FlowIdentityReference;
+    target_reference: FlowIdentityReference;
+    before_reference_sha256: string;
+    after_reference_sha256: string;
+};
+export type FlowIdentityCollisionEntry = {
+    target_id: string;
+    target_version: string;
+    exchange_indexes: number[];
+    internal_ids: Array<string | null>;
+    mapping_ids: Array<string | null>;
+    preserve_rows: true;
+};
+export type FlowIdentityCollisionLedger = {
+    schema_version: 'dataset-flow-identity-collision-ledger.v1';
+    entries: FlowIdentityCollisionEntry[];
+};
+export type FlowIdentityOccurrence = {
+    process_id: string;
+    process_version: string;
+    exchange_index: number;
+    internal_id: string;
+    direction: FlowIdentityDirection;
+    reference_sha256: string;
+};
+export type FlowIdentityProtectedReferenceEntry = {
+    source_id: string;
+    source_version: string;
+    expected_reference_count: number;
+    occurrences: FlowIdentityOccurrence[];
+    occurrence_set_sha256: string;
+    evidence_sha256: string;
+};
+export type FlowIdentityProtectedOrphanEntry = {
+    source_id: string;
+    source_version: string;
+    evidence_sha256: string;
+};
+export type FlowIdentityProtectedClosure = {
+    schema_version: 'dataset-flow-identity-protected-closure.v1';
+    pending: FlowIdentityProtectedReferenceEntry[];
+    blockers: FlowIdentityProtectedReferenceEntry[];
+    orphans: FlowIdentityProtectedOrphanEntry[];
+    pending_set_sha256: string;
+    blocker_set_sha256: string;
+    orphan_set_sha256: string;
+    total_expected_reference_count: number;
+};
+export type FlowIdentityProcessTemplate = {
+    process: FlowIdentityProcessManifest;
+    rewrites: FlowIdentityRewrite[];
+    collision_ledger: FlowIdentityCollisionLedger;
+    desired_payload: JsonObject;
+};
+export type FlowIdentityPlan = {
+    schema_version: 'dataset-flow-identity-plan.v2';
+    generated_at_utc: string;
+    environment: FlowIdentityLiveCapture['environment'];
+    project_ref: string;
+    account: FlowIdentityLiveCapture['account'];
+    operation_id: string;
+    status: 'ready';
+    target_visibility: 'owner_draft';
+    review_ledger_sha256: string;
+    capture_artifact_sha256: FlowIdentityArtifactSha256;
+    receipt_id: string;
+    receipt_proof_sha256: FlowIdentityDbOpaqueSha256;
+    capture_request_sha256: FlowIdentitySharedRequestSha256;
+    source_guard_set_sha256: FlowIdentityDbOpaqueSha256;
+    support_guard_set_sha256: FlowIdentityDbOpaqueSha256;
+    target_guard_set_sha256: FlowIdentityDbOpaqueSha256;
+    mapping_guard_set_sha256: FlowIdentityDbOpaqueSha256;
+    process_intent_set_sha256: FlowIdentityDbOpaqueSha256;
+    receipt_protected_closure_sha256: FlowIdentityDbOpaqueSha256;
+    capture_whole_scope_proof_sha256: FlowIdentityDbOpaqueSha256;
+    source_universe_artifact_sha256: FlowIdentityArtifactSha256;
+    compatibility_policy: FlowIdentityCompatibilityPolicy;
+    support_snapshot_artifact_sha256: FlowIdentityArtifactSha256;
+    mapping_artifact_sha256: FlowIdentityArtifactSha256;
+    process_manifest_artifact_sha256: FlowIdentityArtifactSha256;
+    protected_closure_artifact_sha256: FlowIdentityArtifactSha256;
+    support_snapshots: FlowIdentitySupportSnapshot[];
+    mappings: FlowIdentityMapping[];
+    processes: FlowIdentityProcessManifest[];
+    protected_closure: FlowIdentityProtectedClosure;
+    summary: {
+        semantic_sources: 305;
+        mappings: number;
+        processes: number;
+        rewrites: number;
+        collision_entries: number;
+        pending: number;
+        blockers: number;
+        orphans: number;
+        protected_references: number;
+    };
+    artifacts: {
+        plan: 'flow-identity-plan.json';
+        live_capture: 'flow-identity-live-capture.json';
+        process_manifest: 'flow-identity-process-manifest.jsonl';
+        collision_ledger: 'flow-identity-collision-ledger.jsonl';
+        protected_closure: 'flow-identity-protected-closure.json';
+        desired_payload_dir: 'desired-processes';
+        process_request_dir: 'process-requests';
+    };
+    plan_sha256: string;
+};
+export type FlowIdentityPlanBundle = {
+    plan: FlowIdentityPlan;
+    process_templates: FlowIdentityProcessTemplate[];
+};
+declare function token(value: unknown, label: string): string;
+declare function hash(value: unknown, label: string): string;
+declare function instant(value: unknown, label: string): string;
+declare function version(value: unknown, label: string): string;
+declare function computeSelfHash(value: Record<string, unknown>, field: string): string;
+declare function hasExactKeys(value: unknown, expected: readonly string[]): boolean;
+export declare function assertCurrentFlowIdentityAuthority(value: {
+    oracleSha256?: unknown;
+    authoritySha256?: unknown;
+    approvalText?: unknown;
+    oracleGeneration?: unknown;
+    sourceCount?: unknown;
+}): void;
+export declare function computeFlowIdentityReviewLedgerSha256(ledger: FlowIdentityReviewLedger): string;
+export declare function computeFlowIdentityCaptureSha256(capture: FlowIdentityLiveCapture): string;
+export declare function computeFlowIdentityCaptureEvidenceSha256(capture: Omit<FlowIdentityLiveCapture, 'attestation' | 'capture_artifact_sha256'>): string;
+export declare function computeFlowIdentityMappingId(mapping: Omit<FlowIdentityMapping, 'mapping_id'> | FlowIdentityMapping): string;
+export declare function computeFlowIdentityProcessTemplateSha256(process: FlowIdentityProcessManifest): string;
+export declare function computeFlowIdentityPlanSha256(plan: FlowIdentityPlan): string;
+export declare function parseFlowIdentityReference(value: unknown, label: string): FlowIdentityReference;
+export declare function extractFlowIdentityReference(value: unknown, label: string): FlowIdentityReference;
+export declare function parseFlowIdentityPolicy(value: unknown): FlowIdentityCompatibilityPolicy;
+declare function parseReviewEntry(value: unknown, index: number): FlowIdentityReviewEntry;
+export declare function parseFlowIdentityReviewLedger(value: unknown): FlowIdentityReviewLedger;
+export declare function parseFlowIdentityCapture(value: unknown): FlowIdentityLiveCapture;
+declare function validOneBasedOrdinals(values: Array<{
+    ordinal: number;
+}>): boolean;
+declare function validOccurrenceEntry(entry: FlowIdentityProtectedReferenceEntry): boolean;
+declare function supportSnapshotRowSha256(snapshot: FlowIdentitySupportSnapshot): string;
+declare function validSupportSnapshot(snapshot: FlowIdentitySupportSnapshot, actorUserId: string): boolean;
+declare function validMapping(mapping: FlowIdentityMapping, actorUserId: string): boolean;
+declare function validProcess(process: FlowIdentityProcessManifest, actorUserId: string): boolean;
+export declare function parseFlowIdentityPlan(value: unknown): FlowIdentityPlan;
+export declare const __testInternals: {
+    computeSelfHash: typeof computeSelfHash;
+    hash: typeof hash;
+    hasExactKeys: typeof hasExactKeys;
+    instant: typeof instant;
+    parseReviewEntry: typeof parseReviewEntry;
+    supportSnapshotRowSha256: typeof supportSnapshotRowSha256;
+    token: typeof token;
+    validMapping: typeof validMapping;
+    validOccurrenceEntry: typeof validOccurrenceEntry;
+    validOneBasedOrdinals: typeof validOneBasedOrdinals;
+    validProcess: typeof validProcess;
+    validSupportSnapshot: typeof validSupportSnapshot;
+    version: typeof version;
+};
+export {};