import { z } from 'zod';
/**
 * The vertical + version registry (#31 step 1; D-33's milestone one).
 *
 * Today a scope carries a nullable `vertical` STRING — a label nothing validates and
 * nothing can be pinned to. That is enough to say "this scope runs Callout" and not
 * enough to say *which Callout*, which is what dev/staging/prod and preview
 * deployments are: the same vertical at different versions.
 *
 * The registry makes a version a real record with digests, so promotion can compare
 * two of them, and an admission status, so **push is not live**.
 */
/** Where a vertical came from. `builtin` is one we ship; the others are a customer's. */
export declare const verticalSource: z.ZodEnum<{
    builtin: "builtin";
    cli: "cli";
    git: "git";
}>;
export type VerticalSource = z.infer<typeof verticalSource>;
export declare const vertical: z.ZodObject<{
    slug: z.ZodString;
    name: z.ZodString;
    source: z.ZodEnum<{
        builtin: "builtin";
        cli: "cli";
        git: "git";
    }>;
    ownerTenant: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "TenantId", "out">>;
    envSpec: z.ZodOptional<z.ZodArray<z.ZodObject<{
        key: z.ZodString;
        label: z.ZodOptional<z.ZodString>;
        description: z.ZodString;
        placeholder: z.ZodOptional<z.ZodString>;
        required: z.ZodDefault<z.ZodBoolean>;
        secret: z.ZodDefault<z.ZodBoolean>;
        default: z.ZodOptional<z.ZodString>;
        group: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    entitlements: z.ZodOptional<z.ZodArray<z.ZodString>>;
    ownerGrants: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PermissionKey", "out">>>;
    provides: z.ZodOptional<z.ZodArray<z.ZodString>>;
    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
    surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        label: z.ZodString;
    }, z.core.$strip>>>;
    listed: z.ZodDefault<z.ZodBoolean>;
    publishRequestedAt: z.ZodOptional<z.ZodNullable<z.core.$ZodBranded<z.ZodString, "Instant", "out">>>;
    installsBlocked: z.ZodDefault<z.ZodBoolean>;
    provisions: z.ZodOptional<z.ZodArray<z.ZodString>>;
    sendsEmail: z.ZodOptional<z.ZodBoolean>;
    emailSender: z.ZodDefault<z.ZodBoolean>;
    tenantProvisioner: z.ZodDefault<z.ZodBoolean>;
    servingRef: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    servingVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
    createdAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
}, z.core.$strip>;
export type Vertical = z.infer<typeof vertical>;
/**
 * What the serving script currently declares (#286) — the base the NEXT in-place
 * upload diffs against. Directory-recorded at each successful serve, so no deploy
 * ever queries Cloudflare to guess live state: `doClasses` yields the DO-class
 * migration DELTA (re-declaring a live class is an upload error), `migrationTag`
 * the `old_tag` it rides under.
 */
export declare const verticalServingState: z.ZodObject<{
    ref: z.ZodString;
    versionId: z.ZodString;
    doClasses: z.ZodArray<z.ZodString>;
    migrationTag: z.ZodString;
}, z.core.$strip>;
export type VerticalServingState = z.infer<typeof verticalServingState>;
export declare const registerVerticalInput: z.ZodObject<{
    slug: z.ZodString;
    name: z.ZodString;
    source: z.ZodEnum<{
        builtin: "builtin";
        cli: "cli";
        git: "git";
    }>;
    envSpec: z.ZodOptional<z.ZodArray<z.ZodObject<{
        key: z.ZodString;
        label: z.ZodOptional<z.ZodString>;
        description: z.ZodString;
        placeholder: z.ZodOptional<z.ZodString>;
        required: z.ZodDefault<z.ZodBoolean>;
        secret: z.ZodDefault<z.ZodBoolean>;
        default: z.ZodOptional<z.ZodString>;
        group: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>>;
    entitlements: z.ZodOptional<z.ZodArray<z.ZodString>>;
    ownerGrants: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PermissionKey", "out">>>;
    provides: z.ZodOptional<z.ZodArray<z.ZodString>>;
    requires: z.ZodOptional<z.ZodArray<z.ZodString>>;
    surfaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        label: z.ZodString;
    }, z.core.$strip>>>;
    listed: z.ZodDefault<z.ZodBoolean>;
    provisions: z.ZodOptional<z.ZodArray<z.ZodString>>;
    sendsEmail: z.ZodOptional<z.ZodBoolean>;
    ownerTenant: z.ZodDefault<z.ZodNullable<z.core.$ZodBranded<z.ZodString, "TenantId", "out">>>;
}, z.core.$strip>;
export type RegisterVerticalInput = z.input<typeof registerVerticalInput>;
/**
 * Whether a version may be bound to a scope.
 *
 * `pending` is what a push produces. The admission gates — boundary-lint, the
 * migration diff and the permission diff — decide the rest, and binding a scope is a
 * separate, reviewable step. That separation is the whole point: it is what stops a
 * push being a deploy, and it puts the two human checkpoints where the blast radius
 * is (promotion) rather than where the typing is (merge).
 */
export declare const admissionStatus: z.ZodEnum<{
    admitted: "admitted";
    pending: "pending";
    rejected: "rejected";
}>;
export type AdmissionStatus = z.infer<typeof admissionStatus>;
/**
 * The `admissionNote` a PRIVATE vertical's version carries when it lands admitted
 * straight from a push (builder-plane.md §4-revised). A private vertical's blast
 * radius is its own tenant — the sandbox contract, not a staff read of an opaque
 * digest, is what protects the platform — so its versions self-admit. The note is
 * the distinction that matters at the ONE remaining staff seam: publish. Listing a
 * vertical exposes it to every tenant, so `setVerticalListed` refuses while prod
 * points at a version whose admission is only this note, and a staff `admitVersion`
 * clears it (the human vouch, recorded).
 */
export declare const AUTO_ADMISSION_NOTE = "auto-admitted: private vertical";
/**
 * One published version of a vertical.
 *
 * The three digests are what make promotion answerable. "Has the permission surface
 * changed between the version in prod and the one I am promoting?" is a string
 * comparison here, where today it is a person remembering to look — and per §4 of the
 * plan, a checkpoint that can be skipped is not a checkpoint.
 */
/**
 * Where ONE pushed version's code came from — self-reported by the CLI at push time.
 * `git` is a push from CI (the generated deploy workflow runs `substrat push` inside
 * GitHub Actions, so the CLI detects the runner and attaches the repo/commit/ref it
 * built from); `cli` is a person's terminal. Informational labeling, never authority:
 * both transports are the same authenticated push, and nothing gates on this — it
 * exists so the dashboard can answer "where did this code come from".
 */
export declare const versionOrigin: z.ZodObject<{
    source: z.ZodEnum<{
        cli: "cli";
        git: "git";
    }>;
    gitRepo: z.ZodOptional<z.ZodString>;
    gitCommit: z.ZodOptional<z.ZodString>;
    gitRef: z.ZodOptional<z.ZodString>;
    gate: z.ZodOptional<z.ZodEnum<{
        none: "none";
        passed: "passed";
        skipped: "skipped";
    }>>;
}, z.core.$strip>;
export type VersionOrigin = z.infer<typeof versionOrigin>;
export declare const verticalVersion: z.ZodObject<{
    id: z.ZodString;
    verticalSlug: z.ZodString;
    version: z.ZodString;
    manifestDigest: z.ZodString;
    permissionDigest: z.ZodString;
    migrationDigest: z.ZodString;
    deploymentRef: z.ZodNullable<z.ZodString>;
    admission: z.ZodEnum<{
        admitted: "admitted";
        pending: "pending";
        rejected: "rejected";
    }>;
    admissionNote: z.ZodNullable<z.ZodString>;
    origin: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        source: z.ZodEnum<{
            cli: "cli";
            git: "git";
        }>;
        gitRepo: z.ZodOptional<z.ZodString>;
        gitCommit: z.ZodOptional<z.ZodString>;
        gitRef: z.ZodOptional<z.ZodString>;
        gate: z.ZodOptional<z.ZodEnum<{
            none: "none";
            passed: "passed";
            skipped: "skipped";
        }>>;
    }, z.core.$strip>>>;
    outbound: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
    createdAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
}, z.core.$strip>;
export type VerticalVersion = z.infer<typeof verticalVersion>;
export declare const publishVersionInput: z.ZodObject<{
    id: z.ZodString;
    verticalSlug: z.ZodString;
    version: z.ZodString;
    manifestDigest: z.ZodString;
    permissionDigest: z.ZodString;
    migrationDigest: z.ZodString;
    deploymentRef: z.ZodNullable<z.ZodString>;
    origin: z.ZodOptional<z.ZodNullable<z.ZodObject<{
        source: z.ZodEnum<{
            cli: "cli";
            git: "git";
        }>;
        gitRepo: z.ZodOptional<z.ZodString>;
        gitCommit: z.ZodOptional<z.ZodString>;
        gitRef: z.ZodOptional<z.ZodString>;
        gate: z.ZodOptional<z.ZodEnum<{
            none: "none";
            passed: "passed";
            skipped: "skipped";
        }>>;
    }, z.core.$strip>>>;
    manifestJson: z.ZodOptional<z.ZodNullable<z.ZodString>>;
}, z.core.$strip>;
export type PublishVersionInput = z.infer<typeof publishVersionInput>;
/**
 * Where a version is promoted to (#31 step 2).
 *
 * A vertical has exactly ONE channel — `prod`, the serving pointer: the version an
 * install runs. The old `dev`/`staging` pointers were write-only (nothing ever served
 * or read them), so they were retired (#509): a non-prod environment is a *scope with
 * data* — a preview (`substrat preview create`), not a second pointer at the same code.
 * `prod` stays the wire name so `--promote prod`, generated CI, and existing history
 * rows keep working unchanged; the enum is what keeps it from becoming stringly-typed.
 */
export declare const channelName: z.ZodEnum<{
    prod: "prod";
}>;
export type ChannelName = z.infer<typeof channelName>;
export declare const verticalChannel: z.ZodObject<{
    verticalSlug: z.ZodString;
    channel: z.ZodEnum<{
        prod: "prod";
    }>;
    versionId: z.ZodString;
    updatedAt: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
    servingVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
}, z.core.$strip>;
export type VerticalChannel = z.infer<typeof verticalChannel>;
/**
 * One promotion, kept forever (append-only). The channel row is a pointer — it
 * remembers only where it points now. History is what makes rollback a *choice
 * among moments* rather than an archaeology dig through the admin log: each entry
 * names what went live, what it replaced, who moved the pointer and exactly when.
 *
 * `at` doubles as the data-recovery anchor: it is the instant to hand to the DO
 * storage PITR API (`getBookmarkForTime`, preview-and-snapshots.md §7) when a
 * rollback needs the database as it was *before* this go-live — which is why the
 * moment is recorded here, at promotion, and not reconstructed later.
 */
export declare const channelHistoryEntry: z.ZodObject<{
    id: z.ZodString;
    verticalSlug: z.ZodString;
    channel: z.ZodEnum<{
        prod: "prod";
    }>;
    versionId: z.ZodString;
    fromVersionId: z.ZodNullable<z.ZodString>;
    actor: z.ZodString;
    at: z.core.$ZodBranded<z.ZodString, "Instant", "out">;
}, z.core.$strip>;
export type ChannelHistoryEntry = z.infer<typeof channelHistoryEntry>;
/**
 * What a promoter must acknowledge, per §4's two human checkpoints.
 *
 * Today the migration and permission diffs are a MERGE-time convention: CI renders
 * them and a human is expected to read them, but nothing connects that reading to
 * the moment the change reaches anyone. Promotion is that moment — the blast radius
 * is here, not at the merge.
 *
 * So promotion refuses when a digest differs and the corresponding flag is unset,
 * naming both digests in the error. The flag is one deliberate act rather than a
 * gate that can be passed by not noticing, and the acknowledgement lands in the
 * admin log — which turns "someone reviewed it" from a claim into evidence.
 */
export declare const promotionAcknowledgement: z.ZodObject<{
    permissionChange: z.ZodOptional<z.ZodBoolean>;
    migrationChange: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
export type PromotionAcknowledgement = z.infer<typeof promotionAcknowledgement>;
//# sourceMappingURL=registry.d.ts.map