everything-dev/dist/contract.cjs

A consolidated product package for building Module Federation apps with oRPC APIs.

const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
const require_types = require('./types.cjs');
const require_image = require('./services/deploy/image.cjs');
let zod = require("zod");
zod = require_runtime.__toESM(zod, 1);
require("@orpc/openapi/extensions/route");
let _orpc_contract = require("@orpc/contract");

//#region src/contract.ts
const PhaseTimingSchema = zod.object({
	name: zod.string(),
	durationMs: zod.number()
});
const DevOptionsSchema = zod.object({
	host: require_types.SourceModeSchema.default("local"),
	ui: require_types.SourceModeSchema.default("local"),
	api: require_types.SourceModeSchema.default("local"),
	auth: require_types.SourceModeSchema.default("local"),
	remotePlugins: zod.array(zod.string()).optional().describe("Comma-separated plugin IDs to force remote (e.g. --remote-plugins auth,registry)"),
	proxy: zod.boolean().default(false),
	ssr: zod.boolean().default(false),
	port: zod.number().optional(),
	apiPort: zod.number().optional(),
	uiPort: zod.number().optional(),
	authPort: zod.number().optional(),
	pluginPortStart: zod.number().optional(),
	interactive: zod.boolean().optional(),
	logLevel: zod.enum([
		"error",
		"warn",
		"info",
		"debug"
	]).optional().describe("Log tail level: error, warn (default), info, or debug (overrides BOS_LOG_LEVEL; the file always gets everything)")
});
const DevResultSchema = zod.object({
	status: zod.enum(["started", "error"]),
	description: zod.string(),
	processes: zod.array(zod.string()),
	timings: zod.array(PhaseTimingSchema).optional(),
	session: zod.custom().optional()
});
const StartOptionsSchema = zod.object({
	port: zod.number().optional(),
	interactive: zod.boolean().optional(),
	account: zod.string().optional().describe("New project NEAR account (auto-derived from extends)"),
	domain: zod.string().optional(),
	env: zod.enum(["production", "staging"]).default("production").describe("Environment: production or staging"),
	registry: zod.string().optional().describe("Override FastKV registry contract account (defaults: dev.everything.near / dev.allthethings.testnet)"),
	configPath: zod.string().optional().describe("Boot from a local bos config file — skips FastKV resolution and SRI integrity verification")
});
const StartResultSchema = zod.object({
	status: zod.enum(["running", "error"]),
	url: zod.string(),
	error: zod.string().optional(),
	session: zod.custom().optional(),
	summary: zod.custom().optional()
});
const BuildOptionsSchema = zod.object({
	packages: zod.string().default("all").describe("Comma-separated keys, 'all' (default), or 'local' (only this repo's local plugins hosted via 'local:…')"),
	force: zod.boolean().default(false).describe("Allow pre-Phase-A snapshots without verifiable manifest pins (their bytes were overwritten in place)")
});
const BuildResultSchema = zod.object({
	status: zod.enum(["success", "error"]),
	error: zod.string().optional(),
	built: zod.array(zod.string()),
	skipped: zod.array(zod.string()).optional()
});
const ConfigOptionsSchema = zod.object({ full: zod.boolean().default(false).describe("Print the fully resolved configuration") });
const ConfigResultSchema = zod.object({
	config: zod.union([require_types.BosConfigInputSchema, require_types.BosConfigSchema]).nullable(),
	packages: zod.array(zod.string()),
	remotes: zod.array(zod.string()),
	full: zod.boolean().default(false)
});
const RegistryUseOptionsSchema = zod.object({
	from: zod.string().describe("Published runtime to compose from (account/gateway or bos:// URL)"),
	sections: zod.array(zod.string()).min(1).describe("Sections to compose: app.ui, app.host, app.api, app.auth, plugins.<key>"),
	dryRun: zod.boolean().default(false).describe("Preview the merged config without writing")
});
const RegistryUseResultSchema = zod.object({
	status: zod.enum([
		"updated",
		"dry-run",
		"error"
	]),
	from: zod.string(),
	applied: zod.array(zod.string()),
	configPath: zod.string().optional(),
	error: zod.string().optional()
});
const PluginAddOptionsSchema = zod.object({
	source: zod.string().describe("Plugin source (local:path, bos://account/domain, or URL)"),
	as: zod.string().optional().describe("Plugin alias"),
	production: zod.string().optional().describe("Production URL override")
});
const PluginAddResultSchema = zod.object({
	status: zod.enum(["added", "error"]),
	key: zod.string(),
	development: zod.string().optional(),
	production: zod.string().optional(),
	integrity: zod.string().optional(),
	version: zod.string().optional().describe("Block height (or timestamp) of the snapshot from the listing"),
	error: zod.string().optional()
});
const PluginRemoveOptionsSchema = zod.object({ key: zod.string() });
const PluginRemoveResultSchema = zod.object({
	status: zod.enum(["removed", "error"]),
	key: zod.string(),
	error: zod.string().optional()
});
const PluginListResultSchema = zod.object({
	status: zod.enum(["listed", "error"]),
	plugins: zod.array(zod.object({
		key: zod.string(),
		development: zod.string().optional(),
		production: zod.string().optional(),
		localPath: zod.string().optional(),
		source: zod.enum(["local", "remote"]),
		integrity: zod.string().optional(),
		version: zod.string().optional(),
		name: zod.string().optional()
	})),
	error: zod.string().optional()
});
const PluginPublishOptionsSchema = zod.object({ key: zod.string() });
const PluginPublishResultSchema = zod.object({
	status: zod.enum(["published", "error"]),
	key: zod.string(),
	path: zod.string().optional(),
	production: zod.string().optional(),
	version: zod.string().optional().describe("Block height (or timestamp) of the snapshot from the listing"),
	fingerprint: zod.string().optional(),
	error: zod.string().optional()
});
const WorkspaceDeployResultSchema = zod.object({
	key: zod.string(),
	kind: zod.enum(["app", "plugin"]),
	success: zod.boolean(),
	error: zod.string().optional(),
	durationMs: zod.number().optional(),
	/** Build warnings captured from the workspace's own build output —
	* attributed here, never streamed as raw interleaved stderr. */
	warnings: zod.array(zod.string()).default([])
});
const PublishOptionsSchema = zod.object({
	dryRun: zod.boolean().default(false).describe("Preview what would be published without writing"),
	verbose: zod.boolean().default(false).describe("Show full build output instead of clean summary"),
	network: zod.enum(["mainnet", "testnet"]).optional().describe("NEAR network: mainnet or testnet"),
	privateKey: zod.string().optional(),
	wallet: zod.boolean().default(false).describe("Publish gaslessly with a one-time wallet approval (NEP-366 delegate action relayed by the platform relayer)"),
	env: zod.enum(["production", "staging"]).default("production").describe("Environment: production or staging"),
	registry: zod.string().optional().describe("Override FastKV registry contract account (defaults: dev.everything.near / dev.allthethings.testnet)")
});
const RollbackOptionsSchema = zod.object({
	listOnly: zod.boolean().default(false),
	version: zod.string().optional(),
	previous: zod.boolean().default(false).describe("Roll back to the write immediately before the current one"),
	force: zod.boolean().default(false).describe("Allow pre-Phase-A snapshots without verifiable manifest pins (their bytes were overwritten in place)"),
	limit: zod.number().int().min(1).max(200).default(20).describe("Listing depth (1-200, default 20)"),
	dryRun: zod.boolean().default(false).describe("Preview the rollback without publishing"),
	verbose: zod.boolean().default(false).describe("Show full build output instead of clean summary"),
	network: zod.enum(["mainnet", "testnet"]).optional().describe("NEAR network: mainnet or testnet"),
	privateKey: zod.string().optional(),
	wallet: zod.boolean().default(false).describe("Publish gaslessly with a one-time wallet approval (NEP-366 delegate action relayed by the platform relayer)"),
	env: zod.enum(["production", "staging"]).default("production").describe("Environment: production or staging"),
	registry: zod.string().optional().describe("Override FastKV registry contract account (defaults: dev.everything.near / dev.allthethings.testnet)")
});
const RollbackHistoryEntrySchema = zod.object({
	blockHeight: zod.number(),
	blockTimestamp: zod.string(),
	txHash: zod.string().optional(),
	summary: zod.string()
});
const RollbackSlotCheckSchema = zod.object({
	slot: zod.string(),
	ok: zod.boolean(),
	reason: zod.string().optional()
});
const RollbackResultSchema = zod.object({
	status: zod.enum([
		"published",
		"error",
		"dry-run",
		"list"
	]),
	registryUrl: zod.string(),
	txHash: zod.string().optional(),
	error: zod.string().optional(),
	history: zod.array(RollbackHistoryEntrySchema).optional(),
	verification: zod.array(RollbackSlotCheckSchema).optional()
});
const PublishResultSchema = zod.object({
	status: zod.enum([
		"published",
		"error",
		"dry-run"
	]),
	registryUrl: zod.string(),
	txHash: zod.string().optional(),
	fingerprint: zod.string().optional(),
	slotPins: zod.record(zod.string(), zod.string()).optional(),
	error: zod.string().optional(),
	built: zod.array(zod.string()).optional(),
	skipped: zod.array(zod.string()).optional(),
	deployResults: zod.array(WorkspaceDeployResultSchema).optional()
});
const DeployOptionsSchema = zod.object({
	statusList: zod.boolean().default(false),
	env: zod.enum(["production", "staging"]).default("production").describe("Environment: production or staging"),
	build: zod.boolean().default(true).describe("Build and deploy workspaces before publish (default: true)"),
	dryRun: zod.boolean().default(false).describe("Preview what would be deployed without writing"),
	verbose: zod.boolean().default(false),
	packages: zod.string().default("all").describe("Comma-separated keys, 'all' (default), or 'local' (only this repo's local plugins hosted via 'local:…')"),
	network: zod.enum(["mainnet", "testnet"]).optional().describe("NEAR network: mainnet or testnet"),
	privateKey: zod.string().optional(),
	service: zod.string().optional().describe("Override Railway service name from config"),
	registry: zod.string().optional().describe("Override FastKV registry contract account (defaults: dev.everything.near / dev.allthethings.testnet)"),
	imageDigest: zod.string().optional().refine((digest) => digest === void 0 || require_image.isValidImageDigest(digest), { message: "image digest must be sha256:<64 hex characters>" }).describe("Digest (sha256:…) of a pre-pushed runtime image — skips the image build/push leg and pins Railway to this digest"),
	fullUpload: zod.boolean().default(false).describe("Re-upload every dist file instead of diffing unchanged files against the previous deploy"),
	forceBuild: zod.boolean().default(false).describe("Force every prerequisite workspace rebuild even when the content-hash staleness oracle judges them fresh"),
	smoke: zod.boolean().default(false).describe("After publish, boot the runtime image against the just-published config and gate the Railway promotion on it — a red smoke rolls the config back to the previous snapshot")
});
const DeployManifestListEntrySchema = zod.object({
	key: zod.string(),
	blockHeight: zod.number(),
	blockTimestamp: zod.string(),
	txHash: zod.string().optional(),
	publishedAt: zod.string().optional()
});
const DeployLegOutcomeSchema = zod.object({
	status: zod.enum([
		"ok",
		"skipped",
		"failed"
	]),
	detail: zod.string().optional()
});
const DeployResultSchema = zod.object({
	status: zod.enum([
		"deployed",
		"published",
		"error",
		"dry-run",
		"list"
	]),
	registryUrl: zod.string(),
	txHash: zod.string().optional(),
	fingerprint: zod.string().optional(),
	slotPins: zod.record(zod.string(), zod.string()).optional(),
	history: zod.array(DeployManifestListEntrySchema).optional(),
	built: zod.array(zod.string()).optional(),
	skipped: zod.array(zod.string()).optional(),
	image: zod.string().optional(),
	service: zod.string().optional(),
	legs: zod.object({
		image: DeployLegOutcomeSchema.optional(),
		smoke: DeployLegOutcomeSchema.optional(),
		railway: DeployLegOutcomeSchema.optional()
	}).optional(),
	error: zod.string().optional(),
	deployResults: zod.array(WorkspaceDeployResultSchema).optional()
});
const SmokeOptionsSchema = zod.object({
	image: zod.string().optional().describe("Runtime image ref to boot — required unless defaulted by the deploy train"),
	port: zod.number().int().default(3e3).describe("Host port to publish the container on (default: 3000)"),
	keep: zod.boolean().default(false).describe("Keep the container after the run (debugging)"),
	account: zod.string().optional().describe("Registry identity — defaults to the resolved session config"),
	gateway: zod.string().optional(),
	apiDatabaseUrl: zod.string().optional(),
	authDatabaseUrl: zod.string().optional(),
	env: zod.enum(["production", "staging"]).default("production").describe("Environment: production or staging"),
	registry: zod.string().optional().describe("Override FastKV registry contract account (defaults: dev.everything.near / dev.allthethings.testnet)")
});
const SmokeResultSchema = zod.object({
	status: zod.enum(["ok", "error"]),
	image: zod.string().optional(),
	summary: zod.string().optional(),
	diagnosis: zod.string().optional(),
	error: zod.string().optional()
});
const OverrideSectionSchema = zod.enum([
	"ui",
	"api",
	"host",
	"plugins"
]);
const DEFAULT_LOGIN_EXPIRES_IN_SECONDS = 7776e3;
const DEFAULT_DEPLOY_KEY_EXPIRES_IN_SECONDS = 31536e3;
const LoginOptionsSchema = zod.object({
	key: zod.boolean().default(false).describe("Mint a scoped deploy key (bundles:write for the config's account/gateway), store it as the session credential, and print it for BOS_STORAGE_API_KEY — plus export the publish key for headless/CI use"),
	custody: zod.boolean().default(false).describe("Also register an OutLayer custody wallet for custody publishes"),
	site: zod.string().optional().describe("Override site URL hosting the CLI login page"),
	expiresIn: zod.number().int().positive().optional().describe("Credential lifetime in seconds (default: 90 days; deploy keys with --key: 365 days)"),
	device: zod.string().optional().describe("Device label recorded on the credential (default: hostname)"),
	env: zod.enum(["production", "staging"]).default("production"),
	registry: zod.string().optional()
});
const LoginResultSchema = zod.object({
	status: zod.enum(["logged-in", "error"]),
	siteUrl: zod.string(),
	accountId: zod.string().nullish(),
	expiresAt: zod.string().nullish(),
	loginUrl: zod.string().nullish(),
	publishKey: zod.object({
		publicKey: zod.string(),
		network: zod.enum(["mainnet", "testnet"]),
		contract: zod.string(),
		exportedTo: zod.string()
	}).nullish(),
	deployKey: zod.object({
		key: zod.string(),
		account: zod.string(),
		gateway: zod.string()
	}).nullish(),
	custodyWallet: zod.object({
		walletId: zod.string(),
		nearAccountId: zod.string(),
		network: zod.enum(["mainnet", "testnet"]),
		handoffUrl: zod.string().nullish()
	}).nullish(),
	outlayerCli: zod.object({
		status: zod.enum([
			"linked",
			"cli-missing",
			"error"
		]),
		network: zod.enum(["mainnet", "testnet"]),
		detail: zod.string().nullish()
	}).nullish(),
	warning: zod.string().nullish(),
	error: zod.string().optional()
});
const LogoutOptionsSchema = zod.object({ configDir: zod.string().optional().describe("Override config directory") });
const LogoutResultSchema = zod.object({
	status: zod.enum(["logged-out", "error"]),
	revokedApiKey: zod.boolean(),
	removedPublishKey: zod.boolean(),
	warning: zod.string().nullish(),
	error: zod.string().optional()
});
const RuntimeOverrideTargetBaseSchema = zod.enum([
	"ui",
	"api",
	"plugins"
]);
const RuntimeOverrideTargetSchema = zod.union([RuntimeOverrideTargetBaseSchema, zod.string().regex(/^plugins\.(\*|[a-z0-9_-]+)$/)]);
const InitOptionsSchema = zod.object({
	extends: zod.string().optional().describe("Parent to extend from (e.g. bos://account/gateway or account/gateway)"),
	directory: zod.string().optional().describe("Target directory (auto-derived from domain)"),
	account: zod.string().optional().describe("New project NEAR account (auto-derived from extends)"),
	domain: zod.string().optional().describe("New project domain (e.g. myapp.everything.dev)"),
	source: zod.string().optional().describe("Local source dir (skips GitHub download)"),
	plugins: zod.array(zod.string()).optional().describe("Comma-separated plugin keys to include (requires --overrides=plugins)"),
	overrides: zod.array(OverrideSectionSchema).optional().describe("Comma-separated sections to customize locally: ui,api,host,plugins"),
	level: require_types.StarterLevelSchema.optional().describe("Starter complexity: simple (public shell) or advanced (adds dashboard, orgs, admin)"),
	noInteractive: zod.boolean().default(false).describe("Skip prompts, use flags only"),
	noInstall: zod.boolean().default(false).describe("Skip pnpm install")
});
const InitResultSchema = zod.object({
	status: zod.enum(["initialized", "error"]),
	directory: zod.string(),
	extendsRef: zod.string(),
	account: zod.string().optional(),
	domain: zod.string().optional(),
	extends: zod.string(),
	plugins: zod.array(zod.string()).optional(),
	overrides: zod.array(OverrideSectionSchema).optional(),
	filesCopied: zod.number(),
	timings: zod.array(PhaseTimingSchema).optional(),
	targetDir: zod.string().optional(),
	error: zod.string().optional()
});
const SyncResultSchema = zod.object({
	status: zod.enum([
		"synced",
		"dry-run",
		"conflicted",
		"error"
	]),
	updated: zod.array(zod.string()),
	skipped: zod.array(zod.string()),
	added: zod.array(zod.string()),
	conflicted: zod.array(zod.string()).default([]),
	backupDir: zod.string().optional(),
	error: zod.string().optional()
});
const ImportOptionsSchema = zod.object({
	workspace: zod.string().describe("Workspace subtree path (e.g. plugins/auth)"),
	/** omitted → resolve the upstream from the authored config's extends chain */
	from: zod.string().optional().describe("Upstream source: bos://<account>/<gateway>, <owner>/<repo>[@<ref>], GitHub URL, or local directory — defaults to the authored config's extends chain"),
	yes: zod.boolean().default(false).describe("Apply upstream over conflicting files without prompting"),
	dryRun: zod.boolean().default(false).describe("Preview classification and report without writing files"),
	noInstall: zod.boolean().default(false).describe("Skip pnpm install"),
	json: zod.boolean().default(false)
});
const ImportRouteDeltaSchema = zod.object({
	oursOnly: zod.array(zod.string()),
	theirsOnly: zod.array(zod.string())
});
const ImportMigrationCollisionSchema = zod.object({
	kind: zod.literal("tag-mismatch"),
	idx: zod.number(),
	localTag: zod.string().optional(),
	upstreamTag: zod.string().optional(),
	message: zod.string()
});
const ImportMigrationAppendSchema = zod.object({
	idx: zod.number(),
	fromTag: zod.string(),
	toTag: zod.string()
});
const ImportMigrationReconciliationSchema = zod.object({
	/** local journal tags kept verbatim (already applied, never renumbered) */
	kept: zod.array(zod.string()),
	/** upstream migrations renumbered and appended after the local tail */
	appended: zod.array(ImportMigrationAppendSchema),
	/** upstream migrations matched to local entries by SQL content hash */
	contentMatched: zod.array(zod.string())
});
const ImportResultSchema = zod.object({
	status: zod.enum([
		"imported",
		"dry-run",
		"conflicts",
		"error"
	]),
	workspace: zod.string(),
	from: zod.string(),
	ref: zod.string(),
	resolvedSha: zod.string().optional(),
	/** the dereferenced upstream repository when the source was chain-resolved */
	sourceRepository: zod.string().optional(),
	/** resolution notes (e.g. HEAD fallback when no git sha is pinned) */
	warnings: zod.array(zod.string()).default([]),
	added: zod.array(zod.string()),
	updated: zod.array(zod.string()),
	unchanged: zod.array(zod.string()).default([]),
	preservedLocal: zod.array(zod.string()).default([]),
	merged: zod.array(zod.string()).default([]),
	conflicts: zod.array(zod.string()).default([]),
	heldBackMigrations: zod.array(zod.string()).default([]),
	routeDelta: ImportRouteDeltaSchema.optional(),
	migrationCollisions: zod.array(ImportMigrationCollisionSchema).default([]),
	migrationReconciliation: ImportMigrationReconciliationSchema.optional(),
	backupDir: zod.string().optional(),
	reportPath: zod.string().optional(),
	error: zod.string().optional()
});
const UpgradeOptionsSchema = zod.object({
	dryRun: zod.boolean().default(false).describe("Preview changes without writing"),
	check: zod.boolean().default(false).describe("CI check — exit 1 when updates are available"),
	/** Overwrite conflicted template files (with a backup) instead of refusing. */
	force: zod.boolean().default(false),
	noInstall: zod.boolean().default(false).describe("Skip pnpm install"),
	noSync: zod.boolean().default(false).describe("Only upgrade packages, skip template sync"),
	from: zod.enum(["v1"]).optional().describe("v1 train: audit upgrade readiness and rewrite the pre-v2 tree in place"),
	audit: zod.boolean().default(false).describe("With --from v1: audit only — emit .bos/v2-upgrade-manifest.json, write nothing"),
	maintain: zod.array(zod.enum([
		"port-route-guards",
		"db-topology",
		"i18n-seam",
		"compose-seam"
	])).optional().describe("With --from v1: re-run post-upgrade maintenance steps (regression guards after sync)"),
	json: zod.boolean().default(false),
	migrationsOnly: zod.boolean().default(false)
});
const UpgradeAuditFindingSchema = zod.object({
	check: zod.string(),
	path: zod.string(),
	severity: zod.enum(["blocker", "warn"]),
	message: zod.string()
});
const UpgradeAuditManifestSchema = zod.object({
	tier: zod.enum(["A", "B"]),
	blockerCount: zod.number(),
	warnCount: zod.number(),
	deleteFiles: zod.array(zod.string()).readonly(),
	importRewrites: zod.array(zod.object({
		from: zod.string(),
		to: zod.string(),
		files: zod.array(zod.string()).readonly()
	})).readonly(),
	configKeys: zod.array(zod.string()).readonly(),
	routerSeam: zod.enum([
		"monolithic",
		"authored-seam",
		"unknown",
		"absent"
	]),
	authoredConfigTarget: zod.string(),
	plugins: zod.array(zod.object({
		name: zod.string(),
		hasBackend: zod.boolean(),
		hasWeb: zod.boolean(),
		extendsParent: zod.boolean(),
		variables: zod.array(zod.string()).readonly(),
		secrets: zod.array(zod.string()).readonly()
	})).readonly(),
	db: zod.object({
		schemaFile: zod.string().nullable(),
		migrationsDir: zod.string().nullable()
	})
});
const UpgradeResultSchema = zod.object({
	status: zod.enum([
		"upgraded",
		"dry-run",
		"error",
		"already-upgraded",
		"gate-blocked",
		"audit"
	]),
	packages: zod.array(zod.object({
		name: zod.string(),
		from: zod.string().optional(),
		to: zod.string()
	})),
	sync: SyncResultSchema.optional(),
	migrated: zod.array(zod.string()).optional(),
	availablePlugins: zod.array(zod.string()).optional(),
	/** The resolved platform release manifest when one publishes (ADR 0034). */
	platform: zod.object({
		resolved: zod.string(),
		source: zod.string(),
		fromCache: zod.boolean()
	}).optional(),
	/** Dry-run/check only: whether any update is available. */
	updatesAvailable: zod.boolean().optional(),
	selectedPlugins: zod.array(zod.string()).optional(),
	audit: zod.object({
		tier: zod.enum(["A", "B"]),
		findings: zod.array(UpgradeAuditFindingSchema).readonly(),
		manifest: UpgradeAuditManifestSchema
	}).optional(),
	blockers: zod.array(UpgradeAuditFindingSchema).readonly().optional(),
	notes: zod.array(zod.string()).optional(),
	timings: zod.array(PhaseTimingSchema).optional(),
	changelogUrl: zod.string().optional(),
	error: zod.string().optional()
});
const DeployedVersionStatusSchema = zod.object({
	publishedFingerprint: zod.string(),
	servedFingerprint: zod.string().optional(),
	inSync: zod.boolean(),
	error: zod.string().optional()
});
const StatusResultSchema = zod.object({
	status: zod.enum(["ok", "error"]),
	deployedVersion: DeployedVersionStatusSchema.optional(),
	extends: zod.string().optional(),
	account: zod.string().optional(),
	domain: zod.string().optional(),
	packages: zod.array(zod.object({
		name: zod.string(),
		installed: zod.string().optional(),
		latest: zod.string().optional(),
		isLinked: zod.boolean().optional(),
		specifier: zod.string().optional()
	})),
	lastSync: zod.string().optional(),
	envFile: zod.enum([
		"found",
		"missing",
		"example-only"
	]),
	parentReachable: zod.boolean().optional(),
	error: zod.string().optional()
});
const TypesGenOptionsSchema = zod.object({
	env: zod.enum(["development", "production"]).optional().describe("Environment: development (default) or production"),
	dryRun: zod.boolean().default(false).describe("Preview what would be fetched without writing files"),
	remotePlugins: zod.array(zod.string()).optional().describe("Comma-separated plugin IDs to fetch contract types remotely (e.g. --remote-plugins auth,registry)")
});
const TypesGenResultSchema = zod.object({
	status: zod.enum(["success", "error"]),
	generated: zod.array(zod.string()),
	fetched: zod.array(zod.string()),
	skipped: zod.array(zod.string()),
	failed: zod.array(zod.string()),
	error: zod.string().optional()
});
const DbStudioOptionsSchema = zod.object({ plugin: zod.string().default("api").describe("Plugin key: api, auth, or a plugin name (default: api)") });
const DbStudioResultSchema = zod.object({
	status: zod.enum(["success", "error"]),
	plugin: zod.string(),
	source: zod.enum(["local", "remote"]),
	section: zod.string(),
	databaseSecret: zod.string().optional(),
	databaseUrl: zod.string().optional(),
	workspaceDir: zod.string().optional(),
	error: zod.string().optional()
});
const DbDoctorOptionsSchema = zod.object({ plugin: zod.string().describe("Plugin key: api, auth, or a plugin name") });
const DbDoctorResultSchema = zod.object({
	status: zod.enum(["success", "error"]),
	plugin: zod.string(),
	slug: zod.string(),
	journalTable: zod.string(),
	journalSchema: zod.string(),
	diagnosis: zod.string(),
	localMigrationCount: zod.number(),
	appliedHashCount: zod.number(),
	expectedTables: zod.array(zod.string()),
	missingTables: zod.array(zod.string()),
	workspaceDir: zod.string().optional(),
	dbSecret: zod.string().optional(),
	dbUrl: zod.string().optional(),
	error: zod.string().optional()
});
const DbRepairOptionsSchema = zod.object({
	plugin: zod.string().describe("Plugin key: api, auth, or a plugin name"),
	mode: zod.enum(["history-reset", "recreate"]).default("history-reset").describe("Repair mode: history-reset (default) or recreate (not yet supported)"),
	yes: zod.boolean().optional().describe("Skip confirmation prompt")
});
const DbRepairResultSchema = zod.object({
	status: zod.enum([
		"repaired",
		"refused",
		"error"
	]),
	message: zod.string(),
	diagnosis: zod.any(),
	error: zod.string().optional()
});
const ProcessRoleSchema = zod.enum([
	"standalone",
	"workspace-parent",
	"workspace-child"
]);
const PidEntrySchema = zod.object({
	pid: zod.number(),
	configDir: zod.string(),
	parentPid: zod.number().optional(),
	role: ProcessRoleSchema,
	ports: zod.object({
		host: zod.number().optional(),
		api: zod.number().optional(),
		ui: zod.number().optional(),
		auth: zod.number().optional()
	}).default({}),
	budget: zod.object({
		min: zod.number(),
		max: zod.number()
	}).optional(),
	startedAt: zod.number(),
	description: zod.string()
});
const PsResultSchema = zod.object({
	status: zod.enum(["ok", "error"]),
	entries: zod.array(PidEntrySchema),
	error: zod.string().optional()
});
const LogsOptionsSchema = zod.object({
	service: zod.string().optional().describe("Filter by service name (e.g. host, api, auth, ui, plugin:votes)"),
	tail: zod.number().int().positive().max(1e5).optional().describe("Show only the last N lines"),
	follow: zod.boolean().optional().describe("Stream the log as lines are appended")
});
const LogsResultSchema = zod.object({
	logFile: zod.string(),
	lines: zod.array(zod.string())
});
const KillOptionsSchema = zod.object({
	configDir: zod.string().optional().describe("Kill processes owned by a config directory (defaults to cwd)"),
	signal: zod.enum(["SIGTERM", "SIGKILL"]).default("SIGTERM").describe("Signal: SIGTERM (default) or SIGKILL"),
	all: zod.boolean().default(false).describe("Kill processes across all config directories")
});
const KillResultSchema = zod.object({
	status: zod.enum(["killed", "error"]),
	killed: zod.array(zod.object({
		pid: zod.number(),
		configDir: zod.string()
	})),
	skipped: zod.array(zod.object({
		pid: zod.number(),
		reason: zod.string()
	})),
	error: zod.string().optional()
});
const TypecheckOptionsSchema = zod.object({ packages: zod.string().default("all").describe("Comma-separated workspace list (default: all)") });
const TypecheckWorkspaceResultSchema = zod.object({
	workspace: zod.string(),
	passed: zod.boolean(),
	output: zod.string().optional(),
	error: zod.string().optional()
});
const TypecheckResultSchema = zod.object({
	status: zod.enum(["success", "error"]),
	checked: zod.array(zod.string()),
	skipped: zod.array(zod.string()),
	results: zod.array(TypecheckWorkspaceResultSchema),
	error: zod.string().optional()
});
const MfCheckOptionsSchema = zod.object({ timeoutMs: zod.number().default(15e3) });
const PlatformCompatViolationSchema = zod.object({
	kind: zod.enum(["minChild", "shared-dep"]),
	name: zod.string().optional(),
	message: zod.string()
});
const MfCheckRemoteResultSchema = zod.object({
	role: zod.string(),
	url: zod.string(),
	reachable: zod.boolean(),
	pluginVersion: zod.string().nullable(),
	ok: zod.boolean(),
	reason: zod.string().optional()
});
const MfCheckUiSlotSchema = zod.object({
	slot: zod.string(),
	url: zod.string(),
	reachable: zod.boolean(),
	ok: zod.boolean(),
	reason: zod.string().optional()
});
const MfCheckResultSchema = zod.object({
	status: zod.enum(["ok", "fail"]),
	hostVersion: zod.string().nullable(),
	hostReachable: zod.boolean(),
	hostReason: zod.string().optional(),
	remotes: zod.array(MfCheckRemoteResultSchema),
	/** The UI composition compat gate (#546) — present when UI slots exist. */
	ui: zod.object({
		ok: zod.boolean(),
		slots: zod.array(MfCheckUiSlotSchema)
	}).optional(),
	/** The platform compat gate (ADR 0034 pt 5) — present when a release manifest resolves. */
	platform: zod.object({
		ok: zod.boolean(),
		violations: zod.array(PlatformCompatViolationSchema)
	}).optional()
});
const PlatformManifestOptionsSchema = zod.object({ check: zod.boolean().default(false).describe("Also run the platform compat check against the local workspace") });
const PlatformManifestResultSchema = zod.object({
	status: zod.enum([
		"ok",
		"absent",
		"fail"
	]),
	version: zod.string().nullable(),
	source: zod.string().optional(),
	fromCache: zod.boolean().optional(),
	error: zod.string().optional(),
	/** Set when the authored `platform` pin no longer matches anything in the
	* extends chain — the root republished past it (issue #546). */
	drift: zod.object({
		pinned: zod.string(),
		published: zod.string()
	}).optional(),
	compat: zod.object({
		ok: zod.boolean(),
		violations: zod.array(PlatformCompatViolationSchema)
	}).optional()
});
const SecretsSetOptionsSchema = zod.object({
	name: zod.string().describe("Secret name (UPPER_SNAKE_CASE; BOS_* and PORT are reserved)"),
	value: zod.string().optional().describe("Secret value — omitted: hidden prompt (TTY)"),
	site: zod.string().optional().describe("Override the vault site (default: the session credential's site)")
});
const SecretsSetResultSchema = zod.object({
	status: zod.enum(["set", "error"]),
	name: zod.string().optional(),
	siteUrl: zod.string().optional(),
	warning: zod.string().optional(),
	error: zod.string().optional()
});
const SecretsListOptionsSchema = zod.object({
	account: zod.string().optional().describe("Target runtime account (default: the declared config)"),
	gateway: zod.string().optional().describe("Target runtime gateway (default: the declared domain)"),
	site: zod.string().optional()
});
const SecretsListResultSchema = zod.object({
	status: zod.enum(["listed", "error"]),
	secrets: zod.array(zod.object({
		name: zod.string(),
		state: zod.enum([
			"set",
			"missing",
			"undeclared"
		])
	})).optional(),
	missing: zod.array(zod.string()).optional(),
	siteUrl: zod.string().optional(),
	warning: zod.string().optional(),
	error: zod.string().optional()
});
const SecretsRemoveOptionsSchema = zod.object({
	name: zod.string().describe("Secret name to remove"),
	yes: zod.boolean().default(false).describe("Skip the confirmation prompt")
});
const SecretsRemoveResultSchema = zod.object({
	status: zod.enum([
		"removed",
		"not-found",
		"error"
	]),
	name: zod.string().optional(),
	error: zod.string().optional()
});
const commandOptionSchemas = {
	dev: DevOptionsSchema,
	start: StartOptionsSchema,
	build: BuildOptionsSchema,
	config: ConfigOptionsSchema,
	registryUse: RegistryUseOptionsSchema,
	pluginAdd: PluginAddOptionsSchema,
	pluginRemove: PluginRemoveOptionsSchema,
	pluginPublish: PluginPublishOptionsSchema,
	publish: PublishOptionsSchema,
	rollback: RollbackOptionsSchema,
	deploy: DeployOptionsSchema,
	smoke: SmokeOptionsSchema,
	login: LoginOptionsSchema,
	logout: LogoutOptionsSchema,
	init: InitOptionsSchema,
	import: ImportOptionsSchema,
	upgrade: UpgradeOptionsSchema,
	typecheck: TypecheckOptionsSchema,
	typesGen: TypesGenOptionsSchema,
	mfCheck: MfCheckOptionsSchema,
	platformManifest: PlatformManifestOptionsSchema,
	secretsSet: SecretsSetOptionsSchema,
	secretsList: SecretsListOptionsSchema,
	secretsRemove: SecretsRemoveOptionsSchema,
	dbStudio: DbStudioOptionsSchema,
	dbDoctor: DbDoctorOptionsSchema,
	dbRepair: DbRepairOptionsSchema,
	logs: LogsOptionsSchema,
	kill: KillOptionsSchema
};
const bosContract = _orpc_contract.oc.router({
	dev: _orpc_contract.oc.route({
		method: "POST",
		path: "/dev"
	}).input(DevOptionsSchema).output(DevResultSchema),
	start: _orpc_contract.oc.route({
		method: "POST",
		path: "/start"
	}).input(StartOptionsSchema).output(StartResultSchema),
	build: _orpc_contract.oc.route({
		method: "POST",
		path: "/build"
	}).input(BuildOptionsSchema).output(BuildResultSchema),
	config: _orpc_contract.oc.route({
		method: "GET",
		path: "/config"
	}).input(ConfigOptionsSchema).output(ConfigResultSchema),
	registryUse: _orpc_contract.oc.route({
		method: "POST",
		path: "/registry/use"
	}).input(RegistryUseOptionsSchema).output(RegistryUseResultSchema),
	pluginAdd: _orpc_contract.oc.route({
		method: "POST",
		path: "/plugin/add"
	}).input(PluginAddOptionsSchema).output(PluginAddResultSchema),
	pluginRemove: _orpc_contract.oc.route({
		method: "POST",
		path: "/plugin/remove"
	}).input(PluginRemoveOptionsSchema).output(PluginRemoveResultSchema),
	pluginList: _orpc_contract.oc.route({
		method: "GET",
		path: "/plugin/list"
	}).output(PluginListResultSchema),
	pluginPublish: _orpc_contract.oc.route({
		method: "POST",
		path: "/plugin/publish"
	}).input(PluginPublishOptionsSchema).output(PluginPublishResultSchema),
	publish: _orpc_contract.oc.route({
		method: "POST",
		path: "/publish"
	}).input(PublishOptionsSchema).output(PublishResultSchema),
	rollback: _orpc_contract.oc.route({
		method: "POST",
		path: "/rollback"
	}).input(RollbackOptionsSchema).output(RollbackResultSchema),
	deploy: _orpc_contract.oc.route({
		method: "POST",
		path: "/deploy"
	}).input(DeployOptionsSchema).output(DeployResultSchema),
	smoke: _orpc_contract.oc.route({
		method: "POST",
		path: "/smoke"
	}).input(SmokeOptionsSchema).output(SmokeResultSchema),
	login: _orpc_contract.oc.route({
		method: "POST",
		path: "/login"
	}).input(LoginOptionsSchema).output(LoginResultSchema),
	logout: _orpc_contract.oc.route({
		method: "POST",
		path: "/logout"
	}).input(LogoutOptionsSchema).output(LogoutResultSchema),
	init: _orpc_contract.oc.route({
		method: "POST",
		path: "/init"
	}).input(InitOptionsSchema).output(InitResultSchema),
	import: _orpc_contract.oc.route({
		method: "POST",
		path: "/import"
	}).input(ImportOptionsSchema).output(ImportResultSchema),
	upgrade: _orpc_contract.oc.route({
		method: "POST",
		path: "/upgrade"
	}).input(UpgradeOptionsSchema).output(UpgradeResultSchema),
	status: _orpc_contract.oc.route({
		method: "GET",
		path: "/status"
	}).output(StatusResultSchema),
	typesGen: _orpc_contract.oc.route({
		method: "POST",
		path: "/types/gen"
	}).input(TypesGenOptionsSchema).output(TypesGenResultSchema),
	dbStudio: _orpc_contract.oc.route({
		method: "POST",
		path: "/db/studio"
	}).input(DbStudioOptionsSchema).output(DbStudioResultSchema),
	dbDoctor: _orpc_contract.oc.route({
		method: "POST",
		path: "/db/doctor"
	}).input(DbDoctorOptionsSchema).output(DbDoctorResultSchema),
	dbRepair: _orpc_contract.oc.route({
		method: "POST",
		path: "/db/repair"
	}).input(DbRepairOptionsSchema).output(DbRepairResultSchema),
	ps: _orpc_contract.oc.route({
		method: "GET",
		path: "/ps"
	}).output(PsResultSchema),
	logs: _orpc_contract.oc.route({
		method: "GET",
		path: "/logs"
	}).input(LogsOptionsSchema).output(LogsResultSchema),
	kill: _orpc_contract.oc.route({
		method: "POST",
		path: "/kill"
	}).input(KillOptionsSchema).output(KillResultSchema),
	typecheck: _orpc_contract.oc.route({
		method: "POST",
		path: "/typecheck"
	}).input(TypecheckOptionsSchema).output(TypecheckResultSchema),
	mfCheck: _orpc_contract.oc.route({
		method: "POST",
		path: "/mf/check"
	}).input(MfCheckOptionsSchema).output(MfCheckResultSchema),
	platformManifest: _orpc_contract.oc.route({
		method: "POST",
		path: "/platform/manifest"
	}).input(PlatformManifestOptionsSchema).output(PlatformManifestResultSchema),
	secretsSet: _orpc_contract.oc.route({
		method: "POST",
		path: "/secrets/set"
	}).input(SecretsSetOptionsSchema).output(SecretsSetResultSchema),
	secretsList: _orpc_contract.oc.route({
		method: "POST",
		path: "/secrets/list"
	}).input(SecretsListOptionsSchema).output(SecretsListResultSchema),
	secretsRemove: _orpc_contract.oc.route({
		method: "POST",
		path: "/secrets/remove"
	}).input(SecretsRemoveOptionsSchema).output(SecretsRemoveResultSchema)
});
const cliCommandMeta = {
	dev: {
		commandPath: ["dev"],
		summary: "Start a development session",
		interactive: true,
		longRunning: true
	},
	start: {
		commandPath: ["start"],
		summary: "Start the production host",
		interactive: false,
		longRunning: true
	},
	build: {
		commandPath: ["build"],
		summary: "Build selected workspaces",
		interactive: false,
		fields: { packages: { positional: true } }
	},
	config: {
		commandPath: ["config"],
		summary: "Print the loaded BOS configuration",
		interactive: false
	},
	registryUse: {
		commandPath: ["registry", "use"],
		summary: "Compose app.ui/app.host/app.api/plugins.<key> sections from a published runtime into bos.config.json",
		interactive: false,
		fields: { from: { positional: true } }
	},
	pluginAdd: {
		commandPath: ["plugin", "add"],
		summary: "Add a plugin attachment",
		interactive: false,
		fields: { source: { positional: true } }
	},
	pluginRemove: {
		commandPath: ["plugin", "remove"],
		summary: "Remove a plugin attachment",
		interactive: false
	},
	pluginList: {
		commandPath: ["plugin", "list"],
		summary: "List configured plugins",
		interactive: false
	},
	pluginPublish: {
		commandPath: ["plugin", "publish"],
		summary: "Publish a single plugin",
		interactive: false
	},
	publish: {
		commandPath: ["publish"],
		summary: "Publish the current workspace configuration (no build — use bos deploy for the full train)",
		interactive: false
	},
	rollback: {
		commandPath: ["rollback"],
		summary: "Republish an earlier config snapshot from the registry publish history",
		interactive: true
	},
	deploy: {
		commandPath: ["deploy"],
		summary: "Deploy train: preflight → build → upload bundles → publish config → runtime image (pre-pushed digest or local docker build) → post-publish smoke (optional) → Railway (image-backed, no build)",
		interactive: false
	},
	smoke: {
		commandPath: ["smoke"],
		summary: "Boot a runtime image the way production boots (identity-driven, published config) and assert the boot surface: /health, SSR, OpenAPI spec, in-image mf check",
		interactive: false
	},
	login: {
		commandPath: ["login"],
		summary: "Sign in with your NEAR account via the hosted site (wallet, passkey, or social login)",
		interactive: true
	},
	logout: {
		commandPath: ["logout"],
		summary: "Revoke the stored CLI session and delete the exported publish key",
		interactive: false
	},
	init: {
		commandPath: ["init"],
		summary: "Scaffold a new project by extending a deployed app or template",
		interactive: true,
		fields: { domain: { positional: true } }
	},
	import: {
		commandPath: ["import"],
		summary: "Import a workspace subtree from an upstream repo without cloning",
		interactive: true,
		fields: { workspace: { positional: true } }
	},
	upgrade: {
		commandPath: ["upgrade"],
		summary: "Upgrade framework packages and sync template files",
		interactive: true
	},
	typesGen: {
		commandPath: ["types", "gen"],
		summary: "Generate type definitions from configured API and plugin contracts",
		interactive: false
	},
	typecheck: {
		commandPath: ["typecheck"],
		summary: "Run TypeScript type checking across all local workspaces",
		interactive: false,
		fields: { packages: { positional: true } }
	},
	mfCheck: {
		commandPath: ["mf", "check"],
		summary: "Verify Module Federation runtime compatibility across published host + plugin bundles",
		interactive: false
	},
	platformManifest: {
		commandPath: ["platform", "manifest"],
		summary: "Show the platform release manifest — the booted host or the resolved release self-describes (ADR 0034)",
		interactive: false
	},
	secretsSet: {
		commandPath: ["secrets", "set"],
		summary: "Store a runtime secret in the deploy console's vault — sealed at rest, never echoed back",
		interactive: true,
		fields: { name: { positional: true } }
	},
	secretsList: {
		commandPath: ["secrets", "list"],
		summary: "List the runtime's secrets as names + set/missing status against the declared config (never values)",
		interactive: false
	},
	secretsRemove: {
		commandPath: ["secrets", "remove"],
		summary: "Remove a runtime secret from the vault",
		interactive: true,
		fields: { name: { positional: true } }
	},
	dbStudio: {
		commandPath: ["db", "studio"],
		summary: "Open Drizzle Studio for a plugin's database",
		fields: { plugin: { positional: true } }
	},
	dbDoctor: {
		commandPath: ["db", "doctor"],
		summary: "Diagnose migration health for a plugin's database",
		fields: { plugin: { positional: true } }
	},
	dbRepair: {
		commandPath: ["db", "repair"],
		summary: "Reset migration history and reapply migrations for a plugin",
		fields: { plugin: { positional: true } }
	},
	status: {
		commandPath: ["status"],
		summary: "Show project health, versions, and update availability",
		interactive: false
	},
	ps: {
		commandPath: ["ps"],
		summary: "List tracked development processes",
		interactive: false
	},
	logs: {
		commandPath: ["logs"],
		summary: "Read dev session logs (.bos/logs/dev-latest.log)",
		interactive: false
	},
	kill: {
		commandPath: ["kill"],
		summary: "Stop tracked development processes",
		interactive: false
	}
};

//#endregion
exports.BuildOptionsSchema = BuildOptionsSchema;
exports.BuildResultSchema = BuildResultSchema;
exports.ConfigOptionsSchema = ConfigOptionsSchema;
exports.ConfigResultSchema = ConfigResultSchema;
exports.DEFAULT_DEPLOY_KEY_EXPIRES_IN_SECONDS = DEFAULT_DEPLOY_KEY_EXPIRES_IN_SECONDS;
exports.DEFAULT_LOGIN_EXPIRES_IN_SECONDS = DEFAULT_LOGIN_EXPIRES_IN_SECONDS;
exports.DbDoctorOptionsSchema = DbDoctorOptionsSchema;
exports.DbDoctorResultSchema = DbDoctorResultSchema;
exports.DbRepairOptionsSchema = DbRepairOptionsSchema;
exports.DbRepairResultSchema = DbRepairResultSchema;
exports.DbStudioOptionsSchema = DbStudioOptionsSchema;
exports.DbStudioResultSchema = DbStudioResultSchema;
exports.DeployLegOutcomeSchema = DeployLegOutcomeSchema;
exports.DeployManifestListEntrySchema = DeployManifestListEntrySchema;
exports.DeployOptionsSchema = DeployOptionsSchema;
exports.DeployResultSchema = DeployResultSchema;
exports.DeployedVersionStatusSchema = DeployedVersionStatusSchema;
exports.DevOptionsSchema = DevOptionsSchema;
exports.DevResultSchema = DevResultSchema;
exports.ImportMigrationAppendSchema = ImportMigrationAppendSchema;
exports.ImportMigrationCollisionSchema = ImportMigrationCollisionSchema;
exports.ImportMigrationReconciliationSchema = ImportMigrationReconciliationSchema;
exports.ImportOptionsSchema = ImportOptionsSchema;
exports.ImportResultSchema = ImportResultSchema;
exports.ImportRouteDeltaSchema = ImportRouteDeltaSchema;
exports.InitOptionsSchema = InitOptionsSchema;
exports.InitResultSchema = InitResultSchema;
exports.KillOptionsSchema = KillOptionsSchema;
exports.KillResultSchema = KillResultSchema;
exports.LoginOptionsSchema = LoginOptionsSchema;
exports.LoginResultSchema = LoginResultSchema;
exports.LogoutOptionsSchema = LogoutOptionsSchema;
exports.LogoutResultSchema = LogoutResultSchema;
exports.LogsOptionsSchema = LogsOptionsSchema;
exports.LogsResultSchema = LogsResultSchema;
exports.MfCheckOptionsSchema = MfCheckOptionsSchema;
exports.MfCheckRemoteResultSchema = MfCheckRemoteResultSchema;
exports.MfCheckResultSchema = MfCheckResultSchema;
exports.MfCheckUiSlotSchema = MfCheckUiSlotSchema;
exports.OverrideSectionSchema = OverrideSectionSchema;
exports.PhaseTimingSchema = PhaseTimingSchema;
exports.PidEntrySchema = PidEntrySchema;
exports.PlatformCompatViolationSchema = PlatformCompatViolationSchema;
exports.PlatformManifestOptionsSchema = PlatformManifestOptionsSchema;
exports.PlatformManifestResultSchema = PlatformManifestResultSchema;
exports.PluginAddOptionsSchema = PluginAddOptionsSchema;
exports.PluginAddResultSchema = PluginAddResultSchema;
exports.PluginListResultSchema = PluginListResultSchema;
exports.PluginPublishOptionsSchema = PluginPublishOptionsSchema;
exports.PluginPublishResultSchema = PluginPublishResultSchema;
exports.PluginRemoveOptionsSchema = PluginRemoveOptionsSchema;
exports.PluginRemoveResultSchema = PluginRemoveResultSchema;
exports.ProcessRoleSchema = ProcessRoleSchema;
exports.PsResultSchema = PsResultSchema;
exports.PublishOptionsSchema = PublishOptionsSchema;
exports.PublishResultSchema = PublishResultSchema;
exports.RegistryUseOptionsSchema = RegistryUseOptionsSchema;
exports.RegistryUseResultSchema = RegistryUseResultSchema;
exports.RollbackHistoryEntrySchema = RollbackHistoryEntrySchema;
exports.RollbackOptionsSchema = RollbackOptionsSchema;
exports.RollbackResultSchema = RollbackResultSchema;
exports.RollbackSlotCheckSchema = RollbackSlotCheckSchema;
exports.RuntimeOverrideTargetBaseSchema = RuntimeOverrideTargetBaseSchema;
exports.RuntimeOverrideTargetSchema = RuntimeOverrideTargetSchema;
exports.SecretsListOptionsSchema = SecretsListOptionsSchema;
exports.SecretsListResultSchema = SecretsListResultSchema;
exports.SecretsRemoveOptionsSchema = SecretsRemoveOptionsSchema;
exports.SecretsRemoveResultSchema = SecretsRemoveResultSchema;
exports.SecretsSetOptionsSchema = SecretsSetOptionsSchema;
exports.SecretsSetResultSchema = SecretsSetResultSchema;
exports.SmokeOptionsSchema = SmokeOptionsSchema;
exports.SmokeResultSchema = SmokeResultSchema;
exports.StartOptionsSchema = StartOptionsSchema;
exports.StartResultSchema = StartResultSchema;
exports.StatusResultSchema = StatusResultSchema;
exports.SyncResultSchema = SyncResultSchema;
exports.TypecheckOptionsSchema = TypecheckOptionsSchema;
exports.TypecheckResultSchema = TypecheckResultSchema;
exports.TypecheckWorkspaceResultSchema = TypecheckWorkspaceResultSchema;
exports.TypesGenOptionsSchema = TypesGenOptionsSchema;
exports.TypesGenResultSchema = TypesGenResultSchema;
exports.UpgradeAuditFindingSchema = UpgradeAuditFindingSchema;
exports.UpgradeAuditManifestSchema = UpgradeAuditManifestSchema;
exports.UpgradeOptionsSchema = UpgradeOptionsSchema;
exports.UpgradeResultSchema = UpgradeResultSchema;
exports.WorkspaceDeployResultSchema = WorkspaceDeployResultSchema;
exports.bosContract = bosContract;
exports.cliCommandMeta = cliCommandMeta;
exports.commandOptionSchemas = commandOptionSchemas;
//# sourceMappingURL=contract.cjs.map