import { z } from 'zod';
export declare const DappProtocolReleaseSchema: "network.xyo.dapp.protocol.release" & {
    readonly __schema: true;
};
export declare const DappProtocolReleaseAnchorSchema: "network.xyo.dapp.protocol.release.anchor" & {
    readonly __schema: true;
};
/**
 * What a release entry is allowed to be.
 *
 * The set is closed, and nothing in it can name a deployment endpoint, a
 * provider resource, or any other target state. That exclusion is structural
 * rather than advisory: decision D-025 forbids deployment material in a
 * release, so the model gives it nowhere to live instead of validating it away
 * after the fact.
 */
export declare const ProtocolReleaseEntryKindZod: z.ZodEnum<{
    schema: "schema";
    reducer: "reducer";
    paper: "paper";
    "protocol-document": "protocol-document";
    canonicalization: "canonicalization";
    "conformance-vectors": "conformance-vectors";
    verifier: "verifier";
    "headless-client": "headless-client";
    helper: "helper";
}>;
export type ProtocolReleaseEntryKind = z.infer<typeof ProtocolReleaseEntryKindZod>;
export declare const ProtocolReleaseEntryZod: z.ZodObject<{
    entryId: z.ZodString;
    kind: z.ZodEnum<{
        schema: "schema";
        reducer: "reducer";
        paper: "paper";
        "protocol-document": "protocol-document";
        canonicalization: "canonicalization";
        "conformance-vectors": "conformance-vectors";
        verifier: "verifier";
        "headless-client": "headless-client";
        helper: "helper";
    }>;
    identity: z.ZodOptional<z.ZodString>;
    path: z.ZodOptional<z.ZodString>;
    sha256: z.ZodString;
    size: z.ZodNumber;
}, z.core.$strict>;
export type ProtocolReleaseEntry = z.infer<typeof ProtocolReleaseEntryZod>;
export declare const ProtocolReleaseSourceZod: z.ZodObject<{
    remote: z.ZodOptional<z.ZodString>;
    commit: z.ZodString;
    worktree: z.ZodLiteral<"clean">;
}, z.core.$strict>;
export type ProtocolReleaseSource = z.infer<typeof ProtocolReleaseSourceZod>;
export declare const ProtocolReleasePredecessorZod: z.ZodObject<{
    releaseId: z.ZodString;
    releaseHash: z.ZodString;
}, z.core.$strict>;
export type ProtocolReleasePredecessor = z.infer<typeof ProtocolReleasePredecessorZod>;
export declare const DappProtocolReleaseZod: z.ZodObject<{
    schema: z.ZodLiteral<"network.xyo.dapp.protocol.release" & {
        readonly __schema: true;
    }>;
    schemaVersion: z.ZodLiteral<1>;
    hashAlgorithm: z.ZodLiteral<"jcs-sha256-v1">;
    dappId: z.ZodString;
    releaseId: z.ZodString;
    version: z.ZodString;
    definitionHash: z.ZodString;
    source: z.ZodObject<{
        remote: z.ZodOptional<z.ZodString>;
        commit: z.ZodString;
        worktree: z.ZodLiteral<"clean">;
    }, z.core.$strict>;
    entries: z.ZodArray<z.ZodObject<{
        entryId: z.ZodString;
        kind: z.ZodEnum<{
            schema: "schema";
            reducer: "reducer";
            paper: "paper";
            "protocol-document": "protocol-document";
            canonicalization: "canonicalization";
            "conformance-vectors": "conformance-vectors";
            verifier: "verifier";
            "headless-client": "headless-client";
            helper: "helper";
        }>;
        identity: z.ZodOptional<z.ZodString>;
        path: z.ZodOptional<z.ZodString>;
        sha256: z.ZodString;
        size: z.ZodNumber;
    }, z.core.$strict>>;
    inventoryRoot: z.ZodString;
    predecessor: z.ZodOptional<z.ZodObject<{
        releaseId: z.ZodString;
        releaseHash: z.ZodString;
    }, z.core.$strict>>;
}, z.core.$strict>;
export type DappProtocolRelease = z.infer<typeof DappProtocolReleaseZod>;
/**
 * The small declarative payload that commits a release on XL1.
 *
 * It carries no publisher field. Attribution derives from the wrapping signed
 * transaction, and a self-declared publisher would be an unsigned claim sitting
 * next to a signed one — the exact ambiguity D-025 removes.
 */
export declare const DappProtocolReleaseAnchorZod: z.ZodObject<{
    schema: z.ZodLiteral<"network.xyo.dapp.protocol.release.anchor" & {
        readonly __schema: true;
    }>;
    schemaVersion: z.ZodLiteral<1>;
    dappId: z.ZodString;
    releaseId: z.ZodString;
    releaseHash: z.ZodString;
    manifestContentHash: z.ZodString;
    definitionHash: z.ZodString;
    sourceCommit: z.ZodString;
    predecessorReleaseHash: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
export type DappProtocolReleaseAnchor = z.infer<typeof DappProtocolReleaseAnchorZod>;
export declare function normalizeProtocolReleaseEntries(entriesValue: readonly ProtocolReleaseEntry[]): ProtocolReleaseEntry[];
export declare function hashProtocolReleaseInventory(entriesValue: unknown): string;
export declare function normalizeDappProtocolRelease(value: unknown): DappProtocolRelease;
export declare function hashDappProtocolRelease(value: unknown): import("./canonicalDocument.ts").HashedDappDocument<{
    schema: "network.xyo.dapp.protocol.release" & {
        readonly __schema: true;
    };
    schemaVersion: 1;
    hashAlgorithm: "jcs-sha256-v1";
    dappId: string;
    releaseId: string;
    version: string;
    definitionHash: string;
    source: {
        commit: string;
        worktree: "clean";
        remote?: string | undefined;
    };
    entries: {
        entryId: string;
        kind: "schema" | "reducer" | "paper" | "protocol-document" | "canonicalization" | "conformance-vectors" | "verifier" | "headless-client" | "helper";
        sha256: string;
        size: number;
        identity?: string | undefined;
        path?: string | undefined;
    }[];
    inventoryRoot: string;
    predecessor?: {
        releaseId: string;
        releaseHash: string;
    } | undefined;
}>;
/**
 * Derive the anchor from the release rather than accepting one alongside it, so
 * an anchor cannot disagree with the manifest it claims to commit.
 */
export declare function protocolReleaseAnchorFor(releaseValue: unknown, manifestContentHash: string): DappProtocolReleaseAnchor;
export declare const ProtocolReleaseIssueCodes: readonly ["anchor-content-mismatch", "anchor-definition-mismatch", "anchor-identity-mismatch", "anchor-predecessor-mismatch", "anchor-release-hash-mismatch", "anchor-source-mismatch", "succession-dapp-mismatch", "succession-predecessor-absent", "succession-predecessor-mismatch", "succession-source-unchanged", "succession-version-not-newer"];
export type ProtocolReleaseIssueCode = typeof ProtocolReleaseIssueCodes[number];
/**
 * Check an anchor against the manifest and stored bytes it commits. A consumer
 * runs this after resolving the manifest by hash, so a mismatch is a refusal
 * rather than a preference for whichever document arrived first.
 */
export declare function verifyProtocolReleaseAnchor(anchorValue: unknown, releaseValue: unknown, manifestContentHash: string): readonly ProtocolReleaseIssueCode[];
/**
 * Check that one release properly supersedes another: same dApp, an explicit
 * predecessor naming the earlier release hash, a newer version, and different
 * source. Supersession is the only revocation this model expresses; anything
 * stronger belongs to curated listing state, per D-025.
 */
export declare function validateProtocolReleaseSuccession(previousValue: unknown, nextValue: unknown): readonly ProtocolReleaseIssueCode[];
//# sourceMappingURL=protocolRelease.d.ts.map