import { type Fs, type Ps } from "webappwiz/system"; import type { Artifact } from "./artifact/artifact.js"; import type { Bundle } from "./bundle/bundle.js"; import { type GitArtifactOptions } from "./git/git-artifact.js"; import { type CliGithubOptions } from "./github/cli-github.js"; import { type PublishWorkflowOptions } from "./publish-workflow.js"; import type { GithubActions } from "./registry/github-actions.js"; import { type NpmRegistryOptions } from "./registry/npm-registry.js"; import type { Registry } from "./registry/registry.js"; import { Release } from "./release.js"; import { type SkillArtifactOptions } from "./skill-artifact.js"; import type { Step } from "./step.js"; /** What `releases.workspace` reads the roster through; the real system by default. */ export interface WorkspaceReleaseOptions { fs?: Fs; ps?: Ps; /** Publish through GitHub Actions instead of from this machine, as `releases.npm`'s `via`. */ via?: GithubActions; } /** * Composes a release: name each package and where it goes, add the tag and * the notes, and call `release()` on the result. * * ```ts * await releases.lockstep( * releases.npm("@scope/foo"), * releases.custom("@scope/baz", new S3Registry()), * releases.git(), * releases.github(), * ).release(); * ``` */ export declare class releases { private constructor(); /** A package the npm registry carries. */ static npm(name: string, opts?: NpmRegistryOptions): Release; /** A package `registry` carries, for wherever npm is not the answer. */ static custom(name: string, registry: Registry): Release; /** A caller-defined step, composed beside artifacts and other releases. */ static step(step: Step): Release; /** * Pushes existing Git commits to origin during preflight. Place this before * other preflight steps in lockstep to push before running their gates. * This is opt-in and does not create a tag or a release commit. */ static push(opts?: GitArtifactOptions): Release; /** * Keeps the generated publish workflow current: a preflight step writes it * when it is missing or stale, so it lands in the release commit. */ static publishWorkflow(opts: PublishWorkflowOptions): Release; /** The tag, and the push that publishes it. */ static git(opts?: GitArtifactOptions): Release; /** * Building every package before any of them goes out, and clearing what that * left once the release is over. Add it to any release whose packages * publish something other than the source they were written in. */ static build(bundle?: Bundle): Release; /** * An agent skill document whose frontmatter version this release stamps, * given relative to the workspace root. The stamp lands in the release * commit, so a skill bundled into a package says the version that bundled * it rather than the one before. */ static skill(path: string, opts?: SkillArtifactOptions): Release; /** The release notes GitHub publishes for the tag. */ static github(opts?: CliGithubOptions): Release; /** * Every declaration given, at one version. Stages decide when steps run, so * packages always publish before the tag that names them, and notes come last. */ static lockstep(...declarations: Array): Release; /** * The workspace's own release: every public package around the working * directory onto npm, tagged, with GitHub release notes. This is what * `wiz dev ship` runs when nothing declares otherwise. */ static workspace(opts?: WorkspaceReleaseOptions): Promise; }