@opengeni/contracts 0.32.0 → 0.36.0

package/dist/workspace-instruction-policies.d.ts

@@ -4,6 +4,7 @@ export declare const WORKSPACE_INSTRUCTION_POLICY_PROMPT_MAX_UTF8_BYTES = 131072
 export declare const WORKSPACE_INSTRUCTION_POLICY_REASON_MAX_CHARS = 4096;
 export declare const WORKSPACE_INSTRUCTION_POLICY_ROLE_KEY_MAX_CHARS = 64;
 export declare const WORKSPACE_INSTRUCTION_POLICY_SOURCE_ID_MAX_CHARS = 512;
+export declare const WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_SOURCE_VERSION_MAX_CHARS = 256;
 export declare const WorkspaceInstructionPolicyKind: z.ZodEnum<{
     charter: "charter";
     policy: "policy";
@@ -89,6 +90,7 @@ export declare const WorkspaceInstructionPolicyRevision: z.ZodObject<{
     id: z.ZodString;
     revision: z.ZodNumber;
     contentHash: z.ZodString;
+    operationId: z.ZodString;
     accountId: z.ZodString;
     workspaceId: z.ZodString;
     content: z.ZodString;
@@ -285,6 +287,7 @@ export declare const WorkspaceInstructionPolicyActivationEvent: z.ZodObject<{
     }>;
     roleKey: z.ZodNullable<z.ZodString>;
     id: z.ZodString;
+    operationId: z.ZodString;
     accountId: z.ZodString;
     workspaceId: z.ZodString;
     type: z.ZodEnum<{
@@ -308,6 +311,7 @@ export declare const WorkspaceInstructionPolicyActivationEvent: z.ZodObject<{
 }, z.core.$strip>;
 export type WorkspaceInstructionPolicyActivationEvent = z.infer<typeof WorkspaceInstructionPolicyActivationEvent>;
 export declare const CreateWorkspaceInstructionPolicyDraftRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
     kind: z.ZodEnum<{
         charter: "charter";
         policy: "policy";
@@ -328,6 +332,7 @@ export declare const CreateWorkspaceInstructionPolicyDraftRequest: z.ZodObject<{
 }, z.core.$strip>;
 export type CreateWorkspaceInstructionPolicyDraftRequest = z.infer<typeof CreateWorkspaceInstructionPolicyDraftRequest>;
 export declare const ImportLegacyWorkspaceInstructionPolicyDraftRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
     supersedesRevisionId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
 export type ImportLegacyWorkspaceInstructionPolicyDraftRequest = z.infer<typeof ImportLegacyWorkspaceInstructionPolicyDraftRequest>;
@@ -359,6 +364,7 @@ export declare const WorkspaceInstructionPolicyListResponse: z.ZodObject<{
         id: z.ZodString;
         revision: z.ZodNumber;
         contentHash: z.ZodString;
+        operationId: z.ZodString;
         accountId: z.ZodString;
         workspaceId: z.ZodString;
         content: z.ZodString;
@@ -403,6 +409,7 @@ export declare const WorkspaceInstructionPolicyListResponse: z.ZodObject<{
         }>;
         roleKey: z.ZodNullable<z.ZodString>;
         id: z.ZodString;
+        operationId: z.ZodString;
         accountId: z.ZodString;
         workspaceId: z.ZodString;
         type: z.ZodEnum<{
@@ -446,6 +453,7 @@ export declare const WorkspaceInstructionPolicyDiffResponse: z.ZodObject<{
         id: z.ZodString;
         revision: z.ZodNumber;
         contentHash: z.ZodString;
+        operationId: z.ZodString;
         accountId: z.ZodString;
         workspaceId: z.ZodString;
         content: z.ZodString;
@@ -475,6 +483,7 @@ export declare const WorkspaceInstructionPolicyDiffResponse: z.ZodObject<{
         id: z.ZodString;
         revision: z.ZodNumber;
         contentHash: z.ZodString;
+        operationId: z.ZodString;
         accountId: z.ZodString;
         workspaceId: z.ZodString;
         content: z.ZodString;
@@ -496,13 +505,17 @@ export declare const WorkspaceInstructionPolicyDiffResponse: z.ZodObject<{
 }, z.core.$strip>;
 export type WorkspaceInstructionPolicyDiffResponse = z.infer<typeof WorkspaceInstructionPolicyDiffResponse>;
 export declare const ActivateWorkspaceInstructionPolicyRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
     expectedCurrentRevisionId: z.ZodNullable<z.ZodString>;
+    expectedActivationVersion: z.ZodOptional<z.ZodNumber>;
     reason: z.ZodString;
 }, z.core.$strip>;
 export type ActivateWorkspaceInstructionPolicyRequest = z.infer<typeof ActivateWorkspaceInstructionPolicyRequest>;
 export declare const RollbackWorkspaceInstructionPolicyRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
     targetRevisionId: z.ZodString;
     expectedCurrentRevisionId: z.ZodString;
+    expectedActivationVersion: z.ZodOptional<z.ZodNumber>;
     reason: z.ZodString;
 }, z.core.$strip>;
 export type RollbackWorkspaceInstructionPolicyRequest = z.infer<typeof RollbackWorkspaceInstructionPolicyRequest>;
@@ -535,6 +548,7 @@ export declare const WorkspaceInstructionPolicyActivationResponse: z.ZodObject<{
         }>;
         roleKey: z.ZodNullable<z.ZodString>;
         id: z.ZodString;
+        operationId: z.ZodString;
         accountId: z.ZodString;
         workspaceId: z.ZodString;
         type: z.ZodEnum<{
@@ -580,3 +594,220 @@ export declare const WorkspaceInstructionPolicyConflictResponse: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type WorkspaceInstructionPolicyConflictResponse = z.infer<typeof WorkspaceInstructionPolicyConflictResponse>;
+export declare const WorkspaceInstructionPolicyOperationReuseResponse: z.ZodObject<{
+    code: z.ZodLiteral<"WORKSPACE_INSTRUCTION_POLICY_OPERATION_REUSED">;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOperationReuseResponse = z.infer<typeof WorkspaceInstructionPolicyOperationReuseResponse>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalSource: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    confidenceBps: z.ZodNumber;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalSource = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalSource>;
+export declare const CreateWorkspaceInstructionPolicyOnboardingProposalRequest: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
+    kind: z.ZodEnum<{
+        charter: "charter";
+        policy: "policy";
+    }>;
+    scope: z.ZodEnum<{
+        global: "global";
+        role: "role";
+    }>;
+    roleKey: z.ZodDefault<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>>;
+    content: z.ZodString;
+    sourceId: z.ZodString;
+    sourceVersion: z.ZodString;
+    confidenceBps: z.ZodNumber;
+    expectedCurrentRevisionId: z.ZodNullable<z.ZodString>;
+    expectedActivationVersion: z.ZodNumber;
+}, z.core.$strip>;
+export type CreateWorkspaceInstructionPolicyOnboardingProposalRequest = z.infer<typeof CreateWorkspaceInstructionPolicyOnboardingProposalRequest>;
+export declare const WorkspaceInstructionPolicyOnboardingProposal: z.ZodObject<{
+    kind: z.ZodEnum<{
+        charter: "charter";
+        policy: "policy";
+    }>;
+    scope: z.ZodEnum<{
+        global: "global";
+        role: "role";
+    }>;
+    roleKey: z.ZodNullable<z.ZodString>;
+    id: z.ZodString;
+    operationId: z.ZodString;
+    accountId: z.ZodString;
+    workspaceId: z.ZodString;
+    source: z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+        confidenceBps: z.ZodNumber;
+    }, z.core.$strip>;
+    baseline: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        workspaceId: z.ZodString;
+        revisionId: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+        activationVersion: z.ZodNumber;
+        activatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    draft: z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+        operationId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        content: z.ZodString;
+        provenance: z.ZodObject<{
+            source: z.ZodEnum<{
+                human: "human";
+                knowledge_proposal: "knowledge_proposal";
+                legacy_import: "legacy_import";
+                onboarding: "onboarding";
+            }>;
+            sourceId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+        supersedesRevisionId: z.ZodNullable<z.ZodString>;
+        createdBySubjectId: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>;
+    status: z.ZodLiteral<"proposed">;
+    createdBySubjectId: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposal = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposal>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalListQuery: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalListQuery = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalListQuery>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalListResponse: z.ZodObject<{
+    proposals: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        id: z.ZodString;
+        operationId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        source: z.ZodObject<{
+            id: z.ZodString;
+            version: z.ZodString;
+            confidenceBps: z.ZodNumber;
+        }, z.core.$strip>;
+        baseline: z.ZodNullable<z.ZodObject<{
+            kind: z.ZodEnum<{
+                charter: "charter";
+                policy: "policy";
+            }>;
+            scope: z.ZodEnum<{
+                global: "global";
+                role: "role";
+            }>;
+            roleKey: z.ZodNullable<z.ZodString>;
+            workspaceId: z.ZodString;
+            revisionId: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+            activationVersion: z.ZodNumber;
+            activatedAt: z.ZodString;
+        }, z.core.$strip>>;
+        draft: z.ZodObject<{
+            kind: z.ZodEnum<{
+                charter: "charter";
+                policy: "policy";
+            }>;
+            scope: z.ZodEnum<{
+                global: "global";
+                role: "role";
+            }>;
+            roleKey: z.ZodNullable<z.ZodString>;
+            id: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+            operationId: z.ZodString;
+            accountId: z.ZodString;
+            workspaceId: z.ZodString;
+            content: z.ZodString;
+            provenance: z.ZodObject<{
+                source: z.ZodEnum<{
+                    human: "human";
+                    knowledge_proposal: "knowledge_proposal";
+                    legacy_import: "legacy_import";
+                    onboarding: "onboarding";
+                }>;
+                sourceId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            supersedesRevisionId: z.ZodNullable<z.ZodString>;
+            createdBySubjectId: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$strip>;
+        status: z.ZodLiteral<"proposed">;
+        createdBySubjectId: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalListResponse = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalListResponse>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalContentErrorResponse: z.ZodObject<{
+    code: z.ZodEnum<{
+        WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_EMPTY: "WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_EMPTY";
+        WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_OVERSIZED: "WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_OVERSIZED";
+    }>;
+    message: z.ZodString;
+    maxChars: z.ZodNumber;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalContentErrorResponse = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalContentErrorResponse>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalStaleResponse: z.ZodObject<{
+    code: z.ZodLiteral<"WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_STALE">;
+    message: z.ZodString;
+    currentHead: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            charter: "charter";
+            policy: "policy";
+        }>;
+        scope: z.ZodEnum<{
+            global: "global";
+            role: "role";
+        }>;
+        roleKey: z.ZodNullable<z.ZodString>;
+        workspaceId: z.ZodString;
+        revisionId: z.ZodString;
+        revision: z.ZodNumber;
+        contentHash: z.ZodString;
+        activationVersion: z.ZodNumber;
+        activatedAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalStaleResponse = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalStaleResponse>;
+export declare const WorkspaceInstructionPolicyOnboardingProposalConflictResponse: z.ZodObject<{
+    code: z.ZodLiteral<"WORKSPACE_INSTRUCTION_POLICY_ONBOARDING_PROPOSAL_CONFLICT">;
+    message: z.ZodString;
+    existingProposalId: z.ZodString;
+    existingDraftRevisionId: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceInstructionPolicyOnboardingProposalConflictResponse = z.infer<typeof WorkspaceInstructionPolicyOnboardingProposalConflictResponse>;

package/dist/workspace-state.d.ts

@@ -6,6 +6,10 @@ export declare const WORKSPACE_STATE_MAX_GAPS = 16;
 export declare const WORKSPACE_STATE_BASE_NAME_MAX_CHARS = 160;
 export declare const WORKSPACE_STATE_TOPIC_MAX_CHARS = 96;
 export declare const WORKSPACE_STATE_MEMORY_SAMPLE_LIMIT = 100;
+export declare const WorkspaceStateQuery: z.ZodObject<{
+    attemptId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type WorkspaceStateQuery = z.infer<typeof WorkspaceStateQuery>;
 export declare const WorkspaceStateDocumentStatusCounts: z.ZodObject<{
     queued: z.ZodNumber;
     indexing: z.ZodNumber;
@@ -364,6 +368,118 @@ export declare const WorkspaceStateKnowledge: z.ZodDiscriminatedUnion<[z.ZodObje
     requiredPermission: z.ZodLiteral<"documents:search">;
 }, z.core.$strict>], "availability">;
 export type WorkspaceStateKnowledge = z.infer<typeof WorkspaceStateKnowledge>;
+export declare const WorkspaceStateGovernanceDriftStatus: z.ZodEnum<{
+    changed: "changed";
+    identical: "identical";
+    missing: "missing";
+    superseded: "superseded";
+    truncated: "truncated";
+    unavailable: "unavailable";
+}>;
+export type WorkspaceStateGovernanceDriftStatus = z.infer<typeof WorkspaceStateGovernanceDriftStatus>;
+export declare const WorkspaceStateAttemptGovernance: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"not_requested">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"unavailable">;
+    reason: z.ZodLiteral<"attempt_not_found_or_not_authorized">;
+    driftStatus: z.ZodLiteral<"unavailable">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"available">;
+    attemptId: z.ZodString;
+    executionGeneration: z.ZodNumber;
+    acceptedAt: z.ZodString;
+    policySnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        id: z.ZodString;
+        createdAt: z.ZodString;
+        entryHash: z.ZodString;
+        policyRole: z.ZodNullable<z.ZodString>;
+        roleSource: z.ZodEnum<{
+            invalid_metadata_fallback: "invalid_metadata_fallback";
+            metadata_fallback: "metadata_fallback";
+            none: "none";
+            session_binding: "session_binding";
+        }>;
+        entries: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                charter: "charter";
+                policy: "policy";
+            }>;
+            scope: z.ZodEnum<{
+                global: "global";
+                role: "role";
+            }>;
+            roleKey: z.ZodNullable<z.ZodString>;
+            revisionId: z.ZodString;
+            revision: z.ZodNumber;
+            contentHash: z.ZodString;
+            activationVersion: z.ZodNumber;
+            activatedAt: z.ZodString;
+            provenance: z.ZodObject<{
+                source: z.ZodEnum<{
+                    human: "human";
+                    knowledge_proposal: "knowledge_proposal";
+                    legacy_import: "legacy_import";
+                    onboarding: "onboarding";
+                }>;
+                sourceIdHash: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"missing">;
+    }, z.core.$strict>], "status">;
+    preferenceSnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        id: z.ZodString;
+        createdAt: z.ZodString;
+        descriptorHash: z.ZodString;
+        descriptorCount: z.ZodNumber;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"missing">;
+    }, z.core.$strict>], "status">;
+    drift: z.ZodObject<{
+        overall: z.ZodEnum<{
+            changed: "changed";
+            identical: "identical";
+            missing: "missing";
+            superseded: "superseded";
+            truncated: "truncated";
+            unavailable: "unavailable";
+        }>;
+        policy: z.ZodObject<{
+            status: z.ZodEnum<{
+                changed: "changed";
+                identical: "identical";
+                missing: "missing";
+                superseded: "superseded";
+                truncated: "truncated";
+                unavailable: "unavailable";
+            }>;
+            snapshotHash: z.ZodNullable<z.ZodString>;
+            currentHash: z.ZodNullable<z.ZodString>;
+            snapshotTargetCount: z.ZodNumber;
+            currentTargetCount: z.ZodNumber;
+        }, z.core.$strict>;
+        preferences: z.ZodObject<{
+            status: z.ZodEnum<{
+                changed: "changed";
+                identical: "identical";
+                missing: "missing";
+                superseded: "superseded";
+                truncated: "truncated";
+                unavailable: "unavailable";
+            }>;
+            snapshotHash: z.ZodNullable<z.ZodString>;
+            currentHash: z.ZodNullable<z.ZodString>;
+            snapshotDescriptorCount: z.ZodNumber;
+            currentDescriptorCount: z.ZodNumber;
+            snapshotTruncated: z.ZodBoolean;
+            currentTruncated: z.ZodBoolean;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "status">;
+export type WorkspaceStateAttemptGovernance = z.infer<typeof WorkspaceStateAttemptGovernance>;
 export declare const WorkspaceStateResponse: z.ZodObject<{
     workspaceId: z.ZodString;
     generatedAt: z.ZodString;
@@ -372,10 +488,108 @@ export declare const WorkspaceStateResponse: z.ZodObject<{
             source: z.ZodLiteral<"read_time_projection">;
             capturedAt: z.ZodString;
         }, z.core.$strict>;
-        policySnapshot: z.ZodObject<{
-            status: z.ZodLiteral<"not_captured">;
-            reason: z.ZodLiteral<"workspace_instruction_policy_snapshot_not_implemented">;
-        }, z.core.$strict>;
+        attemptGovernance: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"not_requested">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodLiteral<"attempt_not_found_or_not_authorized">;
+            driftStatus: z.ZodLiteral<"unavailable">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            attemptId: z.ZodString;
+            executionGeneration: z.ZodNumber;
+            acceptedAt: z.ZodString;
+            policySnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                id: z.ZodString;
+                createdAt: z.ZodString;
+                entryHash: z.ZodString;
+                policyRole: z.ZodNullable<z.ZodString>;
+                roleSource: z.ZodEnum<{
+                    invalid_metadata_fallback: "invalid_metadata_fallback";
+                    metadata_fallback: "metadata_fallback";
+                    none: "none";
+                    session_binding: "session_binding";
+                }>;
+                entries: z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        charter: "charter";
+                        policy: "policy";
+                    }>;
+                    scope: z.ZodEnum<{
+                        global: "global";
+                        role: "role";
+                    }>;
+                    roleKey: z.ZodNullable<z.ZodString>;
+                    revisionId: z.ZodString;
+                    revision: z.ZodNumber;
+                    contentHash: z.ZodString;
+                    activationVersion: z.ZodNumber;
+                    activatedAt: z.ZodString;
+                    provenance: z.ZodObject<{
+                        source: z.ZodEnum<{
+                            human: "human";
+                            knowledge_proposal: "knowledge_proposal";
+                            legacy_import: "legacy_import";
+                            onboarding: "onboarding";
+                        }>;
+                        sourceIdHash: z.ZodNullable<z.ZodString>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"missing">;
+            }, z.core.$strict>], "status">;
+            preferenceSnapshot: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                id: z.ZodString;
+                createdAt: z.ZodString;
+                descriptorHash: z.ZodString;
+                descriptorCount: z.ZodNumber;
+                truncated: z.ZodBoolean;
+            }, z.core.$strict>, z.ZodObject<{
+                status: z.ZodLiteral<"missing">;
+            }, z.core.$strict>], "status">;
+            drift: z.ZodObject<{
+                overall: z.ZodEnum<{
+                    changed: "changed";
+                    identical: "identical";
+                    missing: "missing";
+                    superseded: "superseded";
+                    truncated: "truncated";
+                    unavailable: "unavailable";
+                }>;
+                policy: z.ZodObject<{
+                    status: z.ZodEnum<{
+                        changed: "changed";
+                        identical: "identical";
+                        missing: "missing";
+                        superseded: "superseded";
+                        truncated: "truncated";
+                        unavailable: "unavailable";
+                    }>;
+                    snapshotHash: z.ZodNullable<z.ZodString>;
+                    currentHash: z.ZodNullable<z.ZodString>;
+                    snapshotTargetCount: z.ZodNumber;
+                    currentTargetCount: z.ZodNumber;
+                }, z.core.$strict>;
+                preferences: z.ZodObject<{
+                    status: z.ZodEnum<{
+                        changed: "changed";
+                        identical: "identical";
+                        missing: "missing";
+                        superseded: "superseded";
+                        truncated: "truncated";
+                        unavailable: "unavailable";
+                    }>;
+                    snapshotHash: z.ZodNullable<z.ZodString>;
+                    currentHash: z.ZodNullable<z.ZodString>;
+                    snapshotDescriptorCount: z.ZodNumber;
+                    currentDescriptorCount: z.ZodNumber;
+                    snapshotTruncated: z.ZodBoolean;
+                    currentTruncated: z.ZodBoolean;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "status">;
     }, z.core.$strict>;
     policy: z.ZodObject<{
         authority: z.ZodLiteral<"workspace_instruction_policy_heads">;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/contracts",
-  "version": "0.32.0",
+  "version": "0.36.0",
   "description": "Shared zod schemas and wire-contract types for the OpenGeni API.",
   "license": "Apache-2.0",
   "repository": {

package/src/google-drive.ts

@@ -72,6 +72,59 @@ export type GoogleDriveSyncCadence = z.infer<typeof GoogleDriveSyncCadence>;
 export const GoogleDriveReadPolicy = z.enum(["allow", "ask", "block"]);
 export type GoogleDriveReadPolicy = z.infer<typeof GoogleDriveReadPolicy>;
 
+export const GoogleDriveConnectionLifecycleState = z.enum([
+  "active",
+  "paused",
+  "token_revoked",
+  "app_removed",
+  "disconnected",
+  "reconnect_required",
+  "reconsent_required",
+]);
+export type GoogleDriveConnectionLifecycleState = z.infer<
+  typeof GoogleDriveConnectionLifecycleState
+>;
+
+const GoogleDriveLifecycleObservedAt = z.string().datetime({ offset: true });
+export const GoogleDriveConnectionLifecycle = z.discriminatedUnion("state", [
+  z.object({
+    state: z.literal("active"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("paused"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("token_revoked"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("app_removed"),
+    recoverable: z.literal(false),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("disconnected"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("reconnect_required"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+  z.object({
+    state: z.literal("reconsent_required"),
+    recoverable: z.literal(true),
+    observedAt: GoogleDriveLifecycleObservedAt,
+  }),
+]);
+export type GoogleDriveConnectionLifecycle = z.infer<typeof GoogleDriveConnectionLifecycle>;
+
 export const GoogleDriveSelectedSource = z.object({
   id: z.string().min(1).max(256),
   name: z.string().min(1).max(1024),
@@ -93,6 +146,7 @@ export const GoogleDriveConnectionMetadata = z
     googleDisplayName: z.string().min(1).max(512).nullable(),
     verifiedAt: z.string().datetime({ offset: true }),
     accessMode: z.enum(["metadata_readonly", "readonly"]),
+    lifecycle: GoogleDriveConnectionLifecycle.optional(),
     selectedSources: z.array(GoogleDriveSelectedSource).max(100).optional(),
     /** @deprecated Read `selectedSources`; retained while existing connections migrate. */
     selectedSource: GoogleDriveSelectedSource.nullable().optional(),
@@ -111,6 +165,18 @@ export const GoogleDriveOAuthStartResponse = z.object({
 });
 export type GoogleDriveOAuthStartResponse = z.infer<typeof GoogleDriveOAuthStartResponse>;
 
+export const GoogleDriveLifecycleActionRequest = z.object({
+  action: z.enum(["pause", "resume"]),
+  expectedVersion: z.number().int().positive(),
+});
+export type GoogleDriveLifecycleActionRequest = z.infer<typeof GoogleDriveLifecycleActionRequest>;
+
+export const GoogleDriveDisconnectRequest = z.object({
+  expectedVersion: z.number().int().positive(),
+  idempotencyKey: z.string().trim().min(1).max(200),
+});
+export type GoogleDriveDisconnectRequest = z.infer<typeof GoogleDriveDisconnectRequest>;
+
 export const GoogleDriveBrowseItem = z.object({
   id: z.string().min(1).max(256),
   name: z.string().min(1).max(1024),