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_deploy = require('./image-deploy.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(),
	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()
});
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(),
	domain: zod.string().optional(),
	env: zod.enum(["production", "staging"]).default("production"),
	registry: zod.string().optional(),
	configPath: zod.string().optional()
});
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)
});
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) });
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)
});
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(),
	as: zod.string().optional(),
	production: zod.string().optional()
});
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(),
	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(),
	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()
});
const PublishOptionsSchema = zod.object({
	dryRun: zod.boolean().default(false),
	verbose: zod.boolean().default(false),
	network: zod.enum(["mainnet", "testnet"]).optional(),
	privateKey: zod.string().optional(),
	wallet: zod.boolean().default(false),
	env: zod.enum(["production", "staging"]).default("production"),
	registry: zod.string().optional()
});
const RollbackOptionsSchema = zod.object({
	listOnly: zod.boolean().default(false),
	version: zod.string().optional(),
	previous: zod.boolean().default(false),
	force: zod.boolean().default(false),
	limit: zod.number().int().min(1).max(200).default(20),
	dryRun: zod.boolean().default(false),
	verbose: zod.boolean().default(false),
	network: zod.enum(["mainnet", "testnet"]).optional(),
	privateKey: zod.string().optional(),
	wallet: zod.boolean().default(false),
	env: zod.enum(["production", "staging"]).default("production"),
	registry: zod.string().optional()
});
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"),
	build: zod.boolean().default(true),
	dryRun: zod.boolean().default(false),
	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(),
	privateKey: zod.string().optional(),
	service: zod.string().optional(),
	registry: zod.string().optional(),
	imageDigest: zod.string().optional().refine((digest) => digest === void 0 || require_image_deploy.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")
});
const DeployManifestListEntrySchema = zod.object({
	key: zod.string(),
	blockHeight: zod.number(),
	blockTimestamp: zod.string(),
	txHash: zod.string().optional(),
	publishedAt: 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(),
	error: zod.string().optional(),
	deployResults: zod.array(WorkspaceDeployResultSchema).optional()
});
function parseNearAmount(value) {
	const match = value.replace(/[\s_,]/g, "").match(/^(\d+(?:\.\d+)?)near$/i);
	if (!match) return NaN;
	return Number.parseFloat(match[1]);
}
const MIN_PUBLISH_ALLOWANCE_NEAR = .3;
const KeyPublishOptionsSchema = zod.object({
	allowance: zod.string().default("1NEAR").refine((val) => {
		const amount = parseNearAmount(val);
		return !Number.isNaN(amount) && amount >= MIN_PUBLISH_ALLOWANCE_NEAR;
	}, { message: `Allowance must be at least ${MIN_PUBLISH_ALLOWANCE_NEAR} NEAR to cover the transaction cost` }),
	env: zod.enum(["production", "staging"]).default("production"),
	registry: zod.string().optional(),
	removeOldKeys: zod.boolean().optional()
});
const KeyPublishResultSchema = zod.object({
	status: zod.enum(["published", "error"]),
	account: zod.string(),
	network: zod.enum(["mainnet", "testnet"]),
	env: zod.enum(["production", "staging"]),
	contract: zod.string(),
	allowance: zod.string(),
	functionNames: zod.array(zod.string()),
	publicKey: zod.string().optional(),
	privateKey: zod.string().optional(),
	error: zod.string().optional()
});
const OverrideSectionSchema = zod.enum([
	"ui",
	"api",
	"host",
	"plugins"
]);
const DEFAULT_LOGIN_EXPIRES_IN_SECONDS = 7776e3;
const LoginOptionsSchema = zod.object({
	key: zod.boolean().default(false),
	site: zod.string().optional(),
	expiresIn: zod.number().int().positive().default(DEFAULT_LOGIN_EXPIRES_IN_SECONDS),
	device: zod.string().optional(),
	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(),
	warning: zod.string().nullish(),
	error: zod.string().optional()
});
const LogoutOptionsSchema = zod.object({ configDir: zod.string().optional() });
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(),
	directory: zod.string().optional(),
	account: zod.string().optional(),
	domain: zod.string().optional(),
	source: zod.string().optional(),
	plugins: zod.array(zod.string()).optional(),
	overrides: zod.array(OverrideSectionSchema).optional(),
	level: require_types.StarterLevelSchema.optional(),
	noInteractive: zod.boolean().default(false),
	noInstall: zod.boolean().default(false)
});
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 SyncOptionsSchema = zod.object({
	dryRun: zod.boolean().default(false),
	noInstall: zod.boolean().default(false),
	json: zod.boolean().default(false)
});
const SyncResultSchema = zod.object({
	status: zod.enum([
		"synced",
		"dry-run",
		"error"
	]),
	updated: zod.array(zod.string()),
	skipped: zod.array(zod.string()),
	added: zod.array(zod.string()),
	conflicted: zod.array(zod.string()).default([]),
	/** retired stub files deleted silently (unmodified) — ADR 0023 migration */
	retired: zod.array(zod.string()).optional(),
	/** retired stub files that were hand-modified — backed up, then deleted */
	retiredConflicted: zod.array(zod.string()).optional(),
	/** where the retired hand-modified copies were backed up */
	retiredBackupDir: zod.string().optional(),
	backupDir: zod.string().optional(),
	error: zod.string().optional()
});
const UpgradeOptionsSchema = zod.object({
	dryRun: zod.boolean().default(false),
	noInstall: zod.boolean().default(false),
	noSync: zod.boolean().default(false),
	json: zod.boolean().default(false),
	migrationsOnly: zod.boolean().default(false)
});
const UpgradeResultSchema = zod.object({
	status: zod.enum([
		"upgraded",
		"dry-run",
		"error"
	]),
	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(),
	selectedPlugins: 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(),
	dryRun: zod.boolean().default(false),
	remotePlugins: zod.array(zod.string()).optional()
});
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") });
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() });
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(),
	mode: zod.enum(["history-reset", "recreate"]).default("history-reset"),
	yes: zod.boolean().optional()
});
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(),
	tail: zod.number().int().positive().max(1e5).optional(),
	follow: zod.boolean().optional()
});
const LogsResultSchema = zod.object({
	logFile: zod.string(),
	lines: zod.array(zod.string())
});
const KillOptionsSchema = zod.object({
	configDir: zod.string().optional(),
	signal: zod.enum(["SIGTERM", "SIGKILL"]).default("SIGTERM"),
	all: zod.boolean().default(false)
});
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") });
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 InfraExportServiceSchema = zod.object({
	key: zod.string(),
	image: zod.string(),
	env: zod.record(zod.string(), zod.string()).default({}),
	ports: zod.array(zod.string()),
	healthcheck: zod.object({
		test: zod.array(zod.string()),
		interval: zod.string(),
		timeout: zod.string(),
		retries: zod.number()
	}).optional(),
	volumes: zod.array(zod.string()).default([])
});
const InfraExportOptionsSchema = zod.object({
	target: zod.enum(["ci", "local"]).default("ci"),
	network: zod.enum(["mainnet", "testnet"]).optional(),
	configDir: zod.string().optional()
});
const InfraExportResultSchema = zod.object({
	env: zod.record(zod.string(), zod.string()),
	services: zod.array(InfraExportServiceSchema),
	generatedAt: zod.string(),
	project: zod.string(),
	account: zod.string(),
	gateway: zod.string()
});
const MfCheckOptionsSchema = zod.object({ timeoutMs: zod.number().default(15e3) });
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 MfCheckResultSchema = zod.object({
	status: zod.enum(["ok", "fail"]),
	hostVersion: zod.string().nullable(),
	hostReachable: zod.boolean(),
	hostReason: zod.string().optional(),
	remotes: zod.array(MfCheckRemoteResultSchema)
});
const commandOptionSchemas = {
	dev: DevOptionsSchema,
	start: StartOptionsSchema,
	build: BuildOptionsSchema,
	config: ConfigOptionsSchema,
	registryUse: RegistryUseOptionsSchema,
	pluginAdd: PluginAddOptionsSchema,
	pluginRemove: PluginRemoveOptionsSchema,
	pluginPublish: PluginPublishOptionsSchema,
	publish: PublishOptionsSchema,
	rollback: RollbackOptionsSchema,
	deploy: DeployOptionsSchema,
	keyPublish: KeyPublishOptionsSchema,
	login: LoginOptionsSchema,
	logout: LogoutOptionsSchema,
	init: InitOptionsSchema,
	sync: SyncOptionsSchema,
	upgrade: UpgradeOptionsSchema,
	typecheck: TypecheckOptionsSchema,
	mfCheck: MfCheckOptionsSchema,
	infraExport: InfraExportOptionsSchema,
	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),
	keyPublish: _orpc_contract.oc.route({
		method: "POST",
		path: "/key/publish"
	}).input(KeyPublishOptionsSchema).output(KeyPublishResultSchema),
	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),
	sync: _orpc_contract.oc.route({
		method: "POST",
		path: "/sync"
	}).input(SyncOptionsSchema).output(SyncResultSchema),
	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),
	infraExport: _orpc_contract.oc.route({
		method: "POST",
		path: "/infra/export"
	}).input(InfraExportOptionsSchema).output(InfraExportResultSchema)
});

//#endregion
exports.BuildOptionsSchema = BuildOptionsSchema;
exports.BuildResultSchema = BuildResultSchema;
exports.ConfigOptionsSchema = ConfigOptionsSchema;
exports.ConfigResultSchema = ConfigResultSchema;
exports.DbDoctorOptionsSchema = DbDoctorOptionsSchema;
exports.DbDoctorResultSchema = DbDoctorResultSchema;
exports.DbRepairOptionsSchema = DbRepairOptionsSchema;
exports.DbRepairResultSchema = DbRepairResultSchema;
exports.DbStudioOptionsSchema = DbStudioOptionsSchema;
exports.DbStudioResultSchema = DbStudioResultSchema;
exports.DeployManifestListEntrySchema = DeployManifestListEntrySchema;
exports.DeployOptionsSchema = DeployOptionsSchema;
exports.DeployResultSchema = DeployResultSchema;
exports.DeployedVersionStatusSchema = DeployedVersionStatusSchema;
exports.DevOptionsSchema = DevOptionsSchema;
exports.DevResultSchema = DevResultSchema;
exports.InfraExportOptionsSchema = InfraExportOptionsSchema;
exports.InfraExportResultSchema = InfraExportResultSchema;
exports.InfraExportServiceSchema = InfraExportServiceSchema;
exports.InitOptionsSchema = InitOptionsSchema;
exports.InitResultSchema = InitResultSchema;
exports.KeyPublishOptionsSchema = KeyPublishOptionsSchema;
exports.KeyPublishResultSchema = KeyPublishResultSchema;
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.OverrideSectionSchema = OverrideSectionSchema;
exports.PhaseTimingSchema = PhaseTimingSchema;
exports.PidEntrySchema = PidEntrySchema;
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.StartOptionsSchema = StartOptionsSchema;
exports.StartResultSchema = StartResultSchema;
exports.StatusResultSchema = StatusResultSchema;
exports.SyncOptionsSchema = SyncOptionsSchema;
exports.SyncResultSchema = SyncResultSchema;
exports.TypecheckOptionsSchema = TypecheckOptionsSchema;
exports.TypecheckResultSchema = TypecheckResultSchema;
exports.TypecheckWorkspaceResultSchema = TypecheckWorkspaceResultSchema;
exports.TypesGenOptionsSchema = TypesGenOptionsSchema;
exports.TypesGenResultSchema = TypesGenResultSchema;
exports.UpgradeOptionsSchema = UpgradeOptionsSchema;
exports.UpgradeResultSchema = UpgradeResultSchema;
exports.WorkspaceDeployResultSchema = WorkspaceDeployResultSchema;
exports.bosContract = bosContract;
exports.commandOptionSchemas = commandOptionSchemas;
//# sourceMappingURL=contract.cjs.map