@odingard/guardian-sdk 0.0.0-stage → 0.2.0

package/dist-dts/contracts/lineage.d.ts

@@ -0,0 +1,218 @@
+import { z } from "zod";
+/**
+ * WO-025: guardian.lineage.v1 — derived-data lineage contract
+ * (GUA-AUTHORITY-OS-001 §17–20).
+ *
+ * Every data object records a human/policy-declared classification plus the
+ * lineage that produced it (sources, derivations, declared transformation
+ * records). Propagation is pure and deterministic:
+ *
+ *   effectiveClassification(object) =
+ *     the recorded resultClassification of the object's declared
+ *     transformation, when one exists;
+ *     otherwise the maximum of its own declared classification and the
+ *     effective classification of every recorded source.
+ *
+ * A model/agent assertion NEVER changes classification — the only path to a
+ * narrower result is a declared transformation record bound into the stored
+ * object (and into the material digest of the action that registered it).
+ * Missing lineage for a classified source fails closed.
+ */
+export declare const LINEAGE_CONTRACT_SCHEMA = "guardian.lineage.v1";
+/** Ordered data classification lattice (lowest → highest). */
+export declare const DataClassificationSchema: z.ZodEnum<{
+    financial: "financial";
+    internal: "internal";
+    public: "public";
+    pii: "pii";
+    phi: "phi";
+    credential: "credential";
+    confidential: "confidential";
+}>;
+export type DataClassification = z.infer<typeof DataClassificationSchema>;
+export declare const CLASSIFICATION_RANK: Record<DataClassification, number>;
+export declare function maxClassification(a: DataClassification, b: DataClassification): DataClassification;
+export declare function classificationExceeds(value: DataClassification, ceiling: DataClassification): boolean;
+export declare const DataSensitivitySchema: z.ZodEnum<{
+    low: "low";
+    moderate: "moderate";
+    high: "high";
+}>;
+export type DataSensitivity = z.infer<typeof DataSensitivitySchema>;
+/** A declared, policy-defined transformation record (§19). */
+export declare const DataTransformationSchema: z.ZodObject<{
+    type: z.ZodString;
+    resultClassification: z.ZodEnum<{
+        financial: "financial";
+        internal: "internal";
+        public: "public";
+        pii: "pii";
+        phi: "phi";
+        credential: "credential";
+        confidential: "confidential";
+    }>;
+}, z.core.$strict>;
+export type DataTransformation = z.infer<typeof DataTransformationSchema>;
+/** Upstream reference: another data object or the action that produced it. */
+export declare const DataSourceRefSchema: z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">, z.core.$ZodBranded<z.ZodString, "RequestId", "out">]>;
+export type DataSourceRef = z.infer<typeof DataSourceRefSchema>;
+export declare const DataObjectSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"guardian.lineage.v1">;
+    dataObjectId: z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">;
+    owner: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+    classification: z.ZodEnum<{
+        financial: "financial";
+        internal: "internal";
+        public: "public";
+        pii: "pii";
+        phi: "phi";
+        credential: "credential";
+        confidential: "confidential";
+    }>;
+    sources: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">, z.core.$ZodBranded<z.ZodString, "RequestId", "out">]>>>;
+    derivations: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">>>;
+    transformations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        resultClassification: z.ZodEnum<{
+            financial: "financial";
+            internal: "internal";
+            public: "public";
+            pii: "pii";
+            phi: "phi";
+            credential: "credential";
+            confidential: "confidential";
+        }>;
+    }, z.core.$strict>>>;
+    sensitivity: z.ZodEnum<{
+        low: "low";
+        moderate: "moderate";
+        high: "high";
+    }>;
+    authorizedUses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    authorizedDisclosures: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    retentionSeconds: z.ZodOptional<z.ZodNumber>;
+    expiryEpochMs: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodNumber;
+}, z.core.$strict>;
+export type DataObject = z.infer<typeof DataObjectSchema>;
+/** Lineage policy declared on guardian.intent.v1 (`lineage` field). */
+export declare const LineagePolicySchema: z.ZodObject<{
+    maxClassification: z.ZodOptional<z.ZodEnum<{
+        financial: "financial";
+        internal: "internal";
+        public: "public";
+        pii: "pii";
+        phi: "phi";
+        credential: "credential";
+        confidential: "confidential";
+    }>>;
+    requireApprovalAbove: z.ZodOptional<z.ZodEnum<{
+        financial: "financial";
+        internal: "internal";
+        public: "public";
+        pii: "pii";
+        phi: "phi";
+        credential: "credential";
+        confidential: "confidential";
+    }>>;
+}, z.core.$strict>;
+export type LineagePolicy = z.infer<typeof LineagePolicySchema>;
+export declare const LineageEventKindSchema: z.ZodEnum<{
+    transform: "transform";
+    derive: "derive";
+    export: "export";
+    share: "share";
+    violation: "violation";
+}>;
+export type LineageEventKind = z.infer<typeof LineageEventKindSchema>;
+export declare const LineageEventSchema: z.ZodObject<{
+    lineageEventId: z.core.$ZodBranded<z.ZodString, "LineageEventId", "out">;
+    dataObjectId: z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">;
+    kind: z.ZodEnum<{
+        transform: "transform";
+        derive: "derive";
+        export: "export";
+        share: "share";
+        violation: "violation";
+    }>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodNumber;
+}, z.core.$strict>;
+export type LineageEvent = z.infer<typeof LineageEventSchema>;
+export type LineageResolution = {
+    ok: true;
+    effectiveClassification: DataClassification;
+    sourceRefs: readonly DataSourceRef[];
+    expired: boolean;
+} | {
+    ok: false;
+    reason: "missing";
+    dataObjectId: string;
+} | {
+    ok: false;
+    reason: "cycle";
+    dataObjectId: string;
+};
+/**
+ * Resolve the effective classification of a data object over its recorded
+ * lineage. `resolve` is the read-only data-object port; it must return null
+ * for unrecorded ids so missing lineage fails closed.
+ */
+export declare function effectiveClassification(object: DataObject, resolve: (dataObjectId: string) => DataObject | null | undefined, nowEpochMs: number): LineageResolution;
+/**
+ * Async variant of `effectiveClassification` for the gateway: resolves the
+ * root object through the injected read-only port, then walks upstream.
+ * Missing lineage for a classified source fails closed ("missing").
+ */
+export declare function resolveDataObjectLineage(dataObjectId: string, get: (id: string) => Promise<DataObject | null | undefined>, nowEpochMs: number): Promise<LineageResolution>;
+export declare const LineageMatchOutcomeSchema: z.ZodObject<{
+    dataObjectId: z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">;
+    effectiveClassification: z.ZodEnum<{
+        financial: "financial";
+        internal: "internal";
+        public: "public";
+        pii: "pii";
+        phi: "phi";
+        credential: "credential";
+        confidential: "confidential";
+    }>;
+    effect: z.ZodEnum<{
+        allowed: "allowed";
+        deny: "deny";
+        require_approval: "require_approval";
+    }>;
+    expired: z.ZodBoolean;
+}, z.core.$strict>;
+export type LineageMatchOutcome = z.infer<typeof LineageMatchOutcomeSchema>;
+/**
+ * Evaluate a declared lineage policy over resolved objects. Pure: reports
+ * deny | require_approval | allowed with deterministic rule refs and never
+ * mutates authority.
+ */
+export declare function evaluateLineagePolicy(policy: LineagePolicy | undefined, resolved: readonly {
+    dataObjectId: string;
+    resolution: LineageResolution;
+}[]): {
+    verdict: "deny";
+    ruleId: string;
+    outcomes: LineageMatchOutcome[];
+} | {
+    verdict: "require_approval";
+    ruleId: string;
+    outcomes: LineageMatchOutcome[];
+} | {
+    verdict: "allowed";
+    outcomes: LineageMatchOutcome[];
+};
+/** Deterministic id for a data object registered by a derive/transform action. */
+export declare function derivedDataObjectId(input: {
+    tenantId: string;
+    actionRef: string;
+}): string;
+/** Deterministic id for a recorded lineage event row. */
+export declare function lineageEventId(input: {
+    tenantId: string;
+    actionRef: string;
+    dataObjectId: string;
+    kind: LineageEventKind;
+}): string;

package/dist-dts/contracts/local.d.ts

@@ -0,0 +1,101 @@
+import { z } from "zod";
+export declare const LOCAL_EXEC_PARAMETERS_SCHEMA_ID = "odingard.guardian.local.exec.v1";
+export declare const LOCAL_EGRESS_PARAMETERS_SCHEMA_ID = "odingard.guardian.local.egress.v1";
+export declare const LOCAL_BROWSE_PARAMETERS_SCHEMA_ID = "odingard.guardian.local.browse.v1";
+export declare const LocalExecParametersV1Schema: z.ZodObject<{
+    schema: z.ZodLiteral<"odingard.guardian.local.exec.v1">;
+    connectionId: z.core.$ZodBranded<z.ZodString, "ConnectionId", "out">;
+    command: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type LocalExecParametersV1 = z.infer<typeof LocalExecParametersV1Schema>;
+export declare const LocalEgressParametersV1Schema: z.ZodObject<{
+    schema: z.ZodLiteral<"odingard.guardian.local.egress.v1">;
+    connectionId: z.core.$ZodBranded<z.ZodString, "ConnectionId", "out">;
+    url: z.ZodString;
+    method: z.ZodDefault<z.ZodEnum<{
+        GET: "GET";
+        HEAD: "HEAD";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+        DELETE: "DELETE";
+        OPTIONS: "OPTIONS";
+    }>>;
+}, z.core.$strict>;
+export type LocalEgressParametersV1 = z.infer<typeof LocalEgressParametersV1Schema>;
+export declare const LocalBrowseParametersV1Schema: z.ZodObject<{
+    schema: z.ZodLiteral<"odingard.guardian.local.browse.v1">;
+    connectionId: z.core.$ZodBranded<z.ZodString, "ConnectionId", "out">;
+    url: z.ZodString;
+}, z.core.$strict>;
+export type LocalBrowseParametersV1 = z.infer<typeof LocalBrowseParametersV1Schema>;
+export declare const LocalCommandClassSchema: z.ZodEnum<{
+    routine: "routine";
+    publish: "publish";
+    destructive: "destructive";
+}>;
+export type LocalCommandClass = z.infer<typeof LocalCommandClassSchema>;
+/**
+ * Deterministic shell command classifier for local.exec mediation.
+ *
+ * The mediator routes each intercepted command to the class-scoped action
+ * (local.exec / local.exec.publish / local.exec.destroy); the definition's
+ * validateBinding re-derives the class from the same function, so an agent
+ * cannot smuggle a destructive command through a lower-class action.
+ *
+ * Semantics (kept deliberately small and auditable):
+ *  - The command is split on `&&`, `||`, `;`, `|`, and newlines; the result is
+ *    the MOST restrictive class of any segment.
+ *  - Leading `NAME=value` assignments and `sudo`/`doas`/`env`/`nice`/`ionice`/
+ *    `nohup`/`timeout`/`time` wrappers (plus their flag arguments) are stripped
+ *    so `sudo rm -rf /` still classifies on `rm`.
+ *  - Anything the classifier cannot fully inspect fails conservative:
+ *    a nested shell (`bash`, `sh -c`, `zsh`), `eval`, `exec`, `source`, inline
+ *    interpreters (`python -c`, `node -e`, …) and `xargs` are destructive;
+ *    command substitution `$(...)` / backticks and output redirections raise
+ *    the floor to publish; unknown programs are publish.
+ *  - `destructive` programs (rm, dd, mkfs, shred, kill*, shutdown, iptables,
+ *    `terraform destroy|apply`, `kubectl delete`, `docker rm|prune`, …) and
+ *    destructive git forms (`git reset`, `git clean`, `git push --force`,
+ *    `git branch -D`) are destructive.
+ *  - `publish` programs are outbound mutations: network tools (curl, wget,
+ *    ssh, scp, rsync, gh, browsers), package installs (`npm install`), and
+ *    git subcommands that mutate or reach a remote (push, commit, merge, …).
+ *  - `routine` is a closed list of dev-toolchain and read-only utilities
+ *    (build/test/lint commands, ls/cat/grep/find/ps, `npm test`, read-only
+ *    git subcommands like status/log/diff).
+ */
+export declare function classifyLocalCommand(command: string): LocalCommandClass;
+type BindingResult = Readonly<{
+    ok: true;
+}> | Readonly<{
+    ok: false;
+    reasonCode: string;
+}>;
+type LocalConnectionFacts = Readonly<{
+    provider: string;
+    endpointAllowlist?: readonly string[];
+}>;
+/**
+ * The class-scoped binding for local.exec*: the classified command must equal
+ * the action's declared class. Re-derived here so a misrouted action id (e.g.
+ * a destructive command proposed as `local.exec`) fails closed.
+ */
+export declare function localExecBinding(expected: LocalCommandClass): (input: {
+    params: LocalExecParametersV1;
+    connection: LocalConnectionFacts;
+}) => BindingResult;
+export declare function localEndpointBinding(input: {
+    params: {
+        url: string;
+    };
+    connection: LocalConnectionFacts;
+}): BindingResult;
+export declare function localExecVerificationProjection(input: LocalExecParametersV1): unknown;
+export declare function localExecEnvelopeProjection(input: LocalExecParametersV1): unknown;
+export declare function localEgressVerificationProjection(input: LocalEgressParametersV1): unknown;
+export declare function localEgressEnvelopeProjection(input: LocalEgressParametersV1): unknown;
+export declare function localBrowseVerificationProjection(input: LocalBrowseParametersV1): unknown;
+export declare function localBrowseEnvelopeProjection(input: LocalBrowseParametersV1): unknown;
+export {};

package/dist-dts/contracts/multi-principal.d.ts

@@ -0,0 +1,292 @@
+import { z } from "zod";
+/**
+ * WO-019 — multi-principal authority relationships.
+ *
+ * A shared scope groups principals into a household or team. Memberships carry
+ * three independent axes, never blended:
+ *   - principalClass: what authority the principal may hold (a child never
+ *     holds adult-scope authority);
+ *   - role: what the member may DO inside the scope (approve vs only view);
+ *   - relationshipKind: descriptive family/workspace label carried for display
+ *     and audit; it never confers authority by itself.
+ *
+ * Scope kinds are deliberately limited to household/team: organization-level
+ * directory management is enterprise IAM and out of scope (WO-019 stop
+ * condition).
+ */
+export declare const PrincipalClassSchema: z.ZodEnum<{
+    adult: "adult";
+    child: "child";
+}>;
+export declare const ScopeKindSchema: z.ZodEnum<{
+    household: "household";
+    team: "team";
+}>;
+export declare const RelationshipKindSchema: z.ZodEnum<{
+    child: "child";
+    spouse: "spouse";
+    parent: "parent";
+    caregiver: "caregiver";
+    workspace: "workspace";
+}>;
+export declare const ScopeMemberRoleSchema: z.ZodEnum<{
+    owner: "owner";
+    approver: "approver";
+    viewer: "viewer";
+}>;
+/**
+ * Step-up levels a single human can present. "multi-approver" is a required
+ * level only — no single human can present it; it is satisfied by a quorum of
+ * distinct approvers (WO-019 step-up ladder).
+ */
+export declare const StepUpLevelSchema: z.ZodEnum<{
+    tap: "tap";
+    passkey: "passkey";
+    biometric: "biometric";
+    "second-device": "second-device";
+    "multi-approver": "multi-approver";
+}>;
+/** The factor one human actually presents with a decision. */
+export declare const ApprovalFactorSchema: z.ZodEnum<{
+    tap: "tap";
+    passkey: "passkey";
+    biometric: "biometric";
+    "second-device": "second-device";
+}>;
+/** Ordering of the single-human step-up levels, lowest first. */
+export declare const APPROVAL_FACTOR_RANK: Record<z.infer<typeof ApprovalFactorSchema>, number>;
+/**
+ * Ordering of the step-up levels an approval may require, lowest first;
+ * "multi-approver" sits above every single-human factor.
+ */
+export declare const STEP_UP_LEVEL_RANK: Record<z.infer<typeof StepUpLevelSchema>, number>;
+/** The stricter of two required step-up levels. */
+export declare function strictestStepUpLevel(current: z.infer<typeof StepUpLevelSchema>, candidate: z.infer<typeof StepUpLevelSchema>): z.infer<typeof StepUpLevelSchema>;
+/**
+ * True when the presented factor meets the required step-up level.
+ * "multi-approver" can never be met by one presented factor — it is satisfied
+ * by the endorsement quorum the approval service enforces.
+ */
+export declare function approvalFactorSatisfies(presented: z.infer<typeof ApprovalFactorSchema>, required: z.infer<typeof StepUpLevelSchema>): boolean;
+export declare const SharedScopeSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    scopeId: z.core.$ZodBranded<z.ZodString, "ScopeId", "out">;
+    tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+    kind: z.ZodEnum<{
+        household: "household";
+        team: "team";
+    }>;
+    label: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        dissolved: "dissolved";
+    }>;
+    version: z.ZodNumber;
+    createdAtEpochMs: z.ZodNumber;
+    createdByPrincipalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+}, z.core.$strict>;
+export declare const ScopeMembershipSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    membershipId: z.core.$ZodBranded<z.ZodString, "MembershipId", "out">;
+    scopeId: z.core.$ZodBranded<z.ZodString, "ScopeId", "out">;
+    tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+    principalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+    principalClass: z.ZodEnum<{
+        adult: "adult";
+        child: "child";
+    }>;
+    role: z.ZodEnum<{
+        owner: "owner";
+        approver: "approver";
+        viewer: "viewer";
+    }>;
+    relationshipKind: z.ZodEnum<{
+        child: "child";
+        spouse: "spouse";
+        parent: "parent";
+        caregiver: "caregiver";
+        workspace: "workspace";
+    }>;
+    status: z.ZodEnum<{
+        active: "active";
+        removed: "removed";
+    }>;
+    version: z.ZodNumber;
+    addedAtEpochMs: z.ZodNumber;
+    addedByPrincipalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+}, z.core.$strict>;
+/** Links one member's agent into the scope so co-principals can see/decide. */
+export declare const ScopeAgentLinkSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    scopeId: z.core.$ZodBranded<z.ZodString, "ScopeId", "out">;
+    tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+    agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+    ownerPrincipalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+    status: z.ZodEnum<{
+        active: "active";
+        unlinked: "unlinked";
+    }>;
+    version: z.ZodNumber;
+    linkedAtEpochMs: z.ZodNumber;
+    linkedByPrincipalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+}, z.core.$strict>;
+/**
+ * Per-scope approval policy: the step-up level and approver quorum every new
+ * approval on a linked agent must satisfy. factorByRiskClass can raise (never
+ * lower) the level for higher-risk actions.
+ */
+export declare const ScopeApprovalPolicySchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    scopeId: z.core.$ZodBranded<z.ZodString, "ScopeId", "out">;
+    tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+    requiredFactor: z.ZodEnum<{
+        tap: "tap";
+        passkey: "passkey";
+        biometric: "biometric";
+        "second-device": "second-device";
+        "multi-approver": "multi-approver";
+    }>;
+    requiredApprovals: z.ZodNumber;
+    factorByRiskClass: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
+        R0: "R0";
+        R1: "R1";
+        R2: "R2";
+        R3: "R3";
+        R4: "R4";
+        R5: "R5";
+    }>, z.ZodEnum<{
+        tap: "tap";
+        passkey: "passkey";
+        biometric: "biometric";
+        "second-device": "second-device";
+        "multi-approver": "multi-approver";
+    }>>>;
+    status: z.ZodEnum<{
+        active: "active";
+    }>;
+    version: z.ZodNumber;
+    updatedAtEpochMs: z.ZodNumber;
+    updatedByPrincipalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+    approvalStructure: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodLiteral<"guardian.multiparty.v1">;
+        structureId: z.ZodString;
+        members: z.ZodArray<z.ZodObject<{
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        requirement: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"single">;
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"nOfM">;
+            n: z.ZodNumber;
+            members: z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unanimous">;
+            members: z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"roleQuorum">;
+            role: z.ZodString;
+            n: z.ZodNumber;
+            m: z.ZodNumber;
+        }, z.core.$strict>], "kind">;
+        specificRequired: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>>;
+        veto: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>>;
+        separationOfDuties: z.ZodOptional<z.ZodObject<{
+            mutuallyExclusive: z.ZodArray<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        temporaryApprovers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            expiresAtEpochMs: z.ZodNumber;
+        }, z.core.$strict>>>;
+        delegatedApprovers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            delegatedBy: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        }, z.core.$strict>>>;
+        emergencyApprovers: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>>;
+        coolingPeriod: z.ZodOptional<z.ZodObject<{
+            seconds: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * The requirement resolved when an approval is opened on a scope-linked agent:
+ * the bound approver set, the required step-up level, and the quorum. It is
+ * frozen into the approval binding at creation so consent cannot widen later.
+ */
+export declare const ApprovalRequirementSchema: z.ZodObject<{
+    scopeId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "ScopeId", "out">>;
+    eligiblePrincipalIds: z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>;
+    requiredFactor: z.ZodEnum<{
+        tap: "tap";
+        passkey: "passkey";
+        biometric: "biometric";
+        "second-device": "second-device";
+        "multi-approver": "multi-approver";
+    }>;
+    requiredApprovals: z.ZodNumber;
+    structure: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodLiteral<"guardian.multiparty.v1">;
+        structureId: z.ZodString;
+        members: z.ZodArray<z.ZodObject<{
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        requirement: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"single">;
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"nOfM">;
+            n: z.ZodNumber;
+            members: z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unanimous">;
+            members: z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"roleQuorum">;
+            role: z.ZodString;
+            n: z.ZodNumber;
+            m: z.ZodNumber;
+        }, z.core.$strict>], "kind">;
+        specificRequired: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>>;
+        veto: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>>;
+        separationOfDuties: z.ZodOptional<z.ZodObject<{
+            mutuallyExclusive: z.ZodArray<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        temporaryApprovers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            expiresAtEpochMs: z.ZodNumber;
+        }, z.core.$strict>>>;
+        delegatedApprovers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            delegatedBy: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        }, z.core.$strict>>>;
+        emergencyApprovers: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>>;
+        coolingPeriod: z.ZodOptional<z.ZodObject<{
+            seconds: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** One approver's recorded assent toward a multi-approver quorum. */
+export declare const ApprovalEndorsementSchema: z.ZodObject<{
+    principalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+    factor: z.ZodEnum<{
+        tap: "tap";
+        passkey: "passkey";
+        biometric: "biometric";
+        "second-device": "second-device";
+    }>;
+    atEpochMs: z.ZodNumber;
+}, z.core.$strict>;
+export type PrincipalClass = z.infer<typeof PrincipalClassSchema>;
+export type ScopeKind = z.infer<typeof ScopeKindSchema>;
+export type RelationshipKind = z.infer<typeof RelationshipKindSchema>;
+export type ScopeMemberRole = z.infer<typeof ScopeMemberRoleSchema>;
+export type StepUpLevel = z.infer<typeof StepUpLevelSchema>;
+export type ApprovalFactor = z.infer<typeof ApprovalFactorSchema>;
+export type SharedScope = z.infer<typeof SharedScopeSchema>;
+export type ScopeMembership = z.infer<typeof ScopeMembershipSchema>;
+export type ScopeAgentLink = z.infer<typeof ScopeAgentLinkSchema>;
+export type ScopeApprovalPolicy = z.infer<typeof ScopeApprovalPolicySchema>;
+export type ApprovalRequirement = z.infer<typeof ApprovalRequirementSchema>;
+export type ApprovalEndorsement = z.infer<typeof ApprovalEndorsementSchema>;