@skyramp/testbot-core 0.13.0-v3.176 → 0.13.0-v3.178

package/dist/runner-client.d.cts

@@ -0,0 +1,4160 @@
+// Generated by dts-bundle-generator v9.5.1
+
+export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+export type Scalars = Primitive | Primitive[];
+declare namespace util {
+	type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
+	export type isAny<T> = 0 extends 1 & T ? true : false;
+	export const assertEqual: <A, B>(_: AssertEqual<A, B>) => void;
+	export function assertIs<T>(_arg: T): void;
+	export function assertNever(_x: never): never;
+	export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+	export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+	export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+	export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
+	export type InexactPartial<T> = {
+		[k in keyof T]?: T[k] | undefined;
+	};
+	export const arrayToEnum: <T extends string, U extends [
+		T,
+		...T[]
+	]>(items: U) => {
+		[k in U[number]]: k;
+	};
+	export const getValidEnumValues: (obj: any) => any[];
+	export const objectValues: (obj: any) => any[];
+	export const objectKeys: ObjectConstructor["keys"];
+	export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
+	export type identity<T> = objectUtil.identity<T>;
+	export type flatten<T> = objectUtil.flatten<T>;
+	export type noUndefined<T> = T extends undefined ? never : T;
+	export const isInteger: NumberConstructor["isInteger"];
+	export function joinValues<T extends any[]>(array: T, separator?: string): string;
+	export const jsonStringifyReplacer: (_: string, value: any) => any;
+	export {};
+}
+declare namespace objectUtil {
+	export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : {
+		[k in Exclude<keyof U, keyof V>]: U[k];
+	} & V;
+	type optionalKeys<T extends object> = {
+		[k in keyof T]: undefined extends T[k] ? k : never;
+	}[keyof T];
+	type requiredKeys<T extends object> = {
+		[k in keyof T]: undefined extends T[k] ? never : k;
+	}[keyof T];
+	export type addQuestionMarks<T extends object, _O = any> = {
+		[K in requiredKeys<T>]: T[K];
+	} & {
+		[K in optionalKeys<T>]?: T[K];
+	} & {
+		[k in keyof T]?: unknown;
+	};
+	export type identity<T> = T;
+	export type flatten<T> = identity<{
+		[k in keyof T]: T[k];
+	}>;
+	export type noNeverKeys<T> = {
+		[k in keyof T]: [
+			T[k]
+		] extends [
+			never
+		] ? never : k;
+	}[keyof T];
+	export type noNever<T> = identity<{
+		[k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
+	}>;
+	export const mergeShapes: <U, T>(first: U, second: T) => T & U;
+	export type extendShape<A extends object, B extends object> = keyof A & keyof B extends never ? A & B : {
+		[K in keyof A as K extends keyof B ? never : K]: A[K];
+	} & {
+		[K in keyof B]: B[K];
+	};
+	export {};
+}
+declare const ZodParsedType: {
+	string: "string";
+	nan: "nan";
+	number: "number";
+	integer: "integer";
+	float: "float";
+	boolean: "boolean";
+	date: "date";
+	bigint: "bigint";
+	symbol: "symbol";
+	function: "function";
+	undefined: "undefined";
+	null: "null";
+	array: "array";
+	object: "object";
+	unknown: "unknown";
+	promise: "promise";
+	void: "void";
+	never: "never";
+	map: "map";
+	set: "set";
+};
+export type ZodParsedType = keyof typeof ZodParsedType;
+declare const getParsedType: (data: any) => ZodParsedType;
+export type allKeys<T> = T extends any ? keyof T : never;
+export type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
+export type typeToFlattenedError<T, U = string> = {
+	formErrors: U[];
+	fieldErrors: {
+		[P in allKeys<T>]?: U[];
+	};
+};
+declare const ZodIssueCode: {
+	invalid_type: "invalid_type";
+	invalid_literal: "invalid_literal";
+	custom: "custom";
+	invalid_union: "invalid_union";
+	invalid_union_discriminator: "invalid_union_discriminator";
+	invalid_enum_value: "invalid_enum_value";
+	unrecognized_keys: "unrecognized_keys";
+	invalid_arguments: "invalid_arguments";
+	invalid_return_type: "invalid_return_type";
+	invalid_date: "invalid_date";
+	invalid_string: "invalid_string";
+	too_small: "too_small";
+	too_big: "too_big";
+	invalid_intersection_types: "invalid_intersection_types";
+	not_multiple_of: "not_multiple_of";
+	not_finite: "not_finite";
+};
+export type ZodIssueCode = keyof typeof ZodIssueCode;
+export type ZodIssueBase = {
+	path: (string | number)[];
+	message?: string | undefined;
+};
+export interface ZodInvalidTypeIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.invalid_type;
+	expected: ZodParsedType;
+	received: ZodParsedType;
+}
+export interface ZodInvalidLiteralIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.invalid_literal;
+	expected: unknown;
+	received: unknown;
+}
+export interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.unrecognized_keys;
+	keys: string[];
+}
+export interface ZodInvalidUnionIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.invalid_union;
+	unionErrors: ZodError[];
+}
+export interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.invalid_union_discriminator;
+	options: Primitive[];
+}
+export interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+	received: string | number;
+	code: typeof ZodIssueCode.invalid_enum_value;
+	options: (string | number)[];
+}
+export interface ZodInvalidArgumentsIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.invalid_arguments;
+	argumentsError: ZodError;
+}
+export interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.invalid_return_type;
+	returnTypeError: ZodError;
+}
+export interface ZodInvalidDateIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.invalid_date;
+}
+export type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
+	includes: string;
+	position?: number | undefined;
+} | {
+	startsWith: string;
+} | {
+	endsWith: string;
+};
+export interface ZodInvalidStringIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.invalid_string;
+	validation: StringValidation;
+}
+export interface ZodTooSmallIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.too_small;
+	minimum: number | bigint;
+	inclusive: boolean;
+	exact?: boolean;
+	type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+export interface ZodTooBigIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.too_big;
+	maximum: number | bigint;
+	inclusive: boolean;
+	exact?: boolean;
+	type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+export interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.invalid_intersection_types;
+}
+export interface ZodNotMultipleOfIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.not_multiple_of;
+	multipleOf: number | bigint;
+}
+export interface ZodNotFiniteIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.not_finite;
+}
+export interface ZodCustomIssue extends ZodIssueBase {
+	code: typeof ZodIssueCode.custom;
+	params?: {
+		[k: string]: any;
+	};
+}
+export type DenormalizedError = {
+	[k: string]: DenormalizedError | string[];
+};
+export type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+export type ZodIssue = ZodIssueOptionalMessage & {
+	fatal?: boolean | undefined;
+	message: string;
+};
+declare const quotelessJson: (obj: any) => string;
+export type recursiveZodFormattedError<T> = T extends [
+	any,
+	...any[]
+] ? {
+	[K in keyof T]?: ZodFormattedError<T[K]>;
+} : T extends any[] ? {
+	[k: number]: ZodFormattedError<T[number]>;
+} : T extends object ? {
+	[K in keyof T]?: ZodFormattedError<T[K]>;
+} : unknown;
+export type ZodFormattedError<T, U = string> = {
+	_errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
+export type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
+declare class ZodError<T = any> extends Error {
+	issues: ZodIssue[];
+	get errors(): ZodIssue[];
+	constructor(issues: ZodIssue[]);
+	format(): ZodFormattedError<T>;
+	format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
+	static create: (issues: ZodIssue[]) => ZodError<any>;
+	static assert(value: unknown): asserts value is ZodError;
+	toString(): string;
+	get message(): string;
+	get isEmpty(): boolean;
+	addIssue: (sub: ZodIssue) => void;
+	addIssues: (subs?: ZodIssue[]) => void;
+	flatten(): typeToFlattenedError<T>;
+	flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
+	get formErrors(): typeToFlattenedError<T, string>;
+}
+export type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+export type IssueData = stripPath<ZodIssueOptionalMessage> & {
+	path?: (string | number)[];
+	fatal?: boolean | undefined;
+};
+export type ErrorMapCtx = {
+	defaultError: string;
+	data: any;
+};
+export type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+	message: string;
+};
+declare const errorMap: ZodErrorMap;
+declare function setErrorMap(map: ZodErrorMap): void;
+declare function getErrorMap(): ZodErrorMap;
+declare const makeIssue: (params: {
+	data: any;
+	path: (string | number)[];
+	errorMaps: ZodErrorMap[];
+	issueData: IssueData;
+}) => ZodIssue;
+export type ParseParams = {
+	path: (string | number)[];
+	errorMap: ZodErrorMap;
+	async: boolean;
+};
+export type ParsePathComponent = string | number;
+export type ParsePath = ParsePathComponent[];
+declare const EMPTY_PATH: ParsePath;
+export interface ParseContext {
+	readonly common: {
+		readonly issues: ZodIssue[];
+		readonly contextualErrorMap?: ZodErrorMap | undefined;
+		readonly async: boolean;
+	};
+	readonly path: ParsePath;
+	readonly schemaErrorMap?: ZodErrorMap | undefined;
+	readonly parent: ParseContext | null;
+	readonly data: any;
+	readonly parsedType: ZodParsedType;
+}
+export type ParseInput = {
+	data: any;
+	path: (string | number)[];
+	parent: ParseContext;
+};
+declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
+export type ObjectPair = {
+	key: SyncParseReturnType<any>;
+	value: SyncParseReturnType<any>;
+};
+declare class ParseStatus {
+	value: "aborted" | "dirty" | "valid";
+	dirty(): void;
+	abort(): void;
+	static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
+	static mergeObjectAsync(status: ParseStatus, pairs: {
+		key: ParseReturnType<any>;
+		value: ParseReturnType<any>;
+	}[]): Promise<SyncParseReturnType<any>>;
+	static mergeObjectSync(status: ParseStatus, pairs: {
+		key: SyncParseReturnType<any>;
+		value: SyncParseReturnType<any>;
+		alwaysSet?: boolean;
+	}[]): SyncParseReturnType;
+}
+export interface ParseResult {
+	status: "aborted" | "dirty" | "valid";
+	data: any;
+}
+export type INVALID = {
+	status: "aborted";
+};
+declare const INVALID: INVALID;
+export type DIRTY<T> = {
+	status: "dirty";
+	value: T;
+};
+declare const DIRTY: <T>(value: T) => DIRTY<T>;
+export type OK<T> = {
+	status: "valid";
+	value: T;
+};
+declare const OK: <T>(value: T) => OK<T>;
+export type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
+export type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
+export type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
+declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
+declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
+declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T>;
+declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;
+declare namespace enumUtil {
+	type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
+	type GetUnionLast<T> = UnionToIntersectionFn<T> extends () => infer Last ? Last : never;
+	type UnionToTuple<T, Tuple extends unknown[] = [
+	]> = [
+		T
+	] extends [
+		never
+	] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [
+		GetUnionLast<T>,
+		...Tuple
+	]>;
+	type CastToStringTuple<T> = T extends [
+		string,
+		...string[]
+	] ? T : never;
+	export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
+	export {};
+}
+declare namespace errorUtil {
+	type ErrMessage = string | {
+		message?: string | undefined;
+	};
+	const errToObj: (message?: ErrMessage) => {
+		message?: string | undefined;
+	};
+	const toString: (message?: ErrMessage) => string | undefined;
+}
+declare namespace partialUtil {
+	type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{
+		[k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>>;
+	}, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? {
+		[k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never;
+	} extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
+}
+/**
+ * The Standard Schema interface.
+ */
+export type StandardSchemaV1<Input = unknown, Output = Input> = {
+	/**
+	 * The Standard Schema properties.
+	 */
+	readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+};
+declare namespace StandardSchemaV1 {
+	/**
+	 * The Standard Schema properties interface.
+	 */
+	export interface Props<Input = unknown, Output = Input> {
+		/**
+		 * The version number of the standard.
+		 */
+		readonly version: 1;
+		/**
+		 * The vendor name of the schema library.
+		 */
+		readonly vendor: string;
+		/**
+		 * Validates unknown input values.
+		 */
+		readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+		/**
+		 * Inferred types associated with the schema.
+		 */
+		readonly types?: Types<Input, Output> | undefined;
+	}
+	/**
+	 * The result interface of the validate function.
+	 */
+	export type Result<Output> = SuccessResult<Output> | FailureResult;
+	/**
+	 * The result interface if validation succeeds.
+	 */
+	export interface SuccessResult<Output> {
+		/**
+		 * The typed output value.
+		 */
+		readonly value: Output;
+		/**
+		 * The non-existent issues.
+		 */
+		readonly issues?: undefined;
+	}
+	/**
+	 * The result interface if validation fails.
+	 */
+	export interface FailureResult {
+		/**
+		 * The issues of failed validation.
+		 */
+		readonly issues: ReadonlyArray<Issue>;
+	}
+	/**
+	 * The issue interface of the failure output.
+	 */
+	export interface Issue {
+		/**
+		 * The error message of the issue.
+		 */
+		readonly message: string;
+		/**
+		 * The path of the issue, if any.
+		 */
+		readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+	}
+	/**
+	 * The path segment interface of the issue.
+	 */
+	export interface PathSegment {
+		/**
+		 * The key representing a path segment.
+		 */
+		readonly key: PropertyKey;
+	}
+	/**
+	 * The Standard Schema types interface.
+	 */
+	export interface Types<Input = unknown, Output = Input> {
+		/**
+		 * The input type of the schema.
+		 */
+		readonly input: Input;
+		/**
+		 * The output type of the schema.
+		 */
+		readonly output: Output;
+	}
+	/**
+	 * Infers the input type of a Standard Schema.
+	 */
+	export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+	/**
+	 * Infers the output type of a Standard Schema.
+	 */
+	export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+	export {};
+}
+export interface RefinementCtx {
+	addIssue: (arg: IssueData) => void;
+	path: (string | number)[];
+}
+export type ZodRawShape = {
+	[k: string]: ZodTypeAny;
+};
+export type ZodTypeAny = ZodType<any, any, any>;
+export type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
+export type input<T extends ZodType<any, any, any>> = T["_input"];
+export type output<T extends ZodType<any, any, any>> = T["_output"];
+export type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
+export interface ZodTypeDef {
+	errorMap?: ZodErrorMap | undefined;
+	description?: string | undefined;
+}
+export type RawCreateParams = {
+	errorMap?: ZodErrorMap | undefined;
+	invalid_type_error?: string | undefined;
+	required_error?: string | undefined;
+	message?: string | undefined;
+	description?: string | undefined;
+} | undefined;
+export type ProcessedCreateParams = {
+	errorMap?: ZodErrorMap | undefined;
+	description?: string | undefined;
+};
+export type SafeParseSuccess<Output> = {
+	success: true;
+	data: Output;
+	error?: never;
+};
+export type SafeParseError<Input> = {
+	success: false;
+	error: ZodError<Input>;
+	data?: never;
+};
+export type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
+declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
+	readonly _type: Output;
+	readonly _output: Output;
+	readonly _input: Input;
+	readonly _def: Def;
+	get description(): string | undefined;
+	"~standard": StandardSchemaV1.Props<Input, Output>;
+	abstract _parse(input: ParseInput): ParseReturnType<Output>;
+	_getType(input: ParseInput): string;
+	_getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
+	_processInputParams(input: ParseInput): {
+		status: ParseStatus;
+		ctx: ParseContext;
+	};
+	_parseSync(input: ParseInput): SyncParseReturnType<Output>;
+	_parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
+	parse(data: unknown, params?: util.InexactPartial<ParseParams>): Output;
+	safeParse(data: unknown, params?: util.InexactPartial<ParseParams>): SafeParseReturnType<Input, Output>;
+	"~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
+	parseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<Output>;
+	safeParseAsync(data: unknown, params?: util.InexactPartial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
+	/** Alias of safeParseAsync */
+	spa: (data: unknown, params?: util.InexactPartial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
+	refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
+	refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
+	refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
+	refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
+	_refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
+	superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
+	superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
+	superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;
+	constructor(def: Def);
+	optional(): ZodOptional<this>;
+	nullable(): ZodNullable<this>;
+	nullish(): ZodOptional<ZodNullable<this>>;
+	array(): ZodArray<this>;
+	promise(): ZodPromise<this>;
+	or<T extends ZodTypeAny>(option: T): ZodUnion<[
+		this,
+		T
+	]>;
+	and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
+	transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
+	default(def: util.noUndefined<Input>): ZodDefault<this>;
+	default(def: () => util.noUndefined<Input>): ZodDefault<this>;
+	brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
+	catch(def: Output): ZodCatch<this>;
+	catch(def: (ctx: {
+		error: ZodError;
+		input: Input;
+	}) => Output): ZodCatch<this>;
+	describe(description: string): this;
+	pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
+	readonly(): ZodReadonly<this>;
+	isOptional(): boolean;
+	isNullable(): boolean;
+}
+export type IpVersion = "v4" | "v6";
+export type ZodStringCheck = {
+	kind: "min";
+	value: number;
+	message?: string | undefined;
+} | {
+	kind: "max";
+	value: number;
+	message?: string | undefined;
+} | {
+	kind: "length";
+	value: number;
+	message?: string | undefined;
+} | {
+	kind: "email";
+	message?: string | undefined;
+} | {
+	kind: "url";
+	message?: string | undefined;
+} | {
+	kind: "emoji";
+	message?: string | undefined;
+} | {
+	kind: "uuid";
+	message?: string | undefined;
+} | {
+	kind: "nanoid";
+	message?: string | undefined;
+} | {
+	kind: "cuid";
+	message?: string | undefined;
+} | {
+	kind: "includes";
+	value: string;
+	position?: number | undefined;
+	message?: string | undefined;
+} | {
+	kind: "cuid2";
+	message?: string | undefined;
+} | {
+	kind: "ulid";
+	message?: string | undefined;
+} | {
+	kind: "startsWith";
+	value: string;
+	message?: string | undefined;
+} | {
+	kind: "endsWith";
+	value: string;
+	message?: string | undefined;
+} | {
+	kind: "regex";
+	regex: RegExp;
+	message?: string | undefined;
+} | {
+	kind: "trim";
+	message?: string | undefined;
+} | {
+	kind: "toLowerCase";
+	message?: string | undefined;
+} | {
+	kind: "toUpperCase";
+	message?: string | undefined;
+} | {
+	kind: "jwt";
+	alg?: string;
+	message?: string | undefined;
+} | {
+	kind: "datetime";
+	offset: boolean;
+	local: boolean;
+	precision: number | null;
+	message?: string | undefined;
+} | {
+	kind: "date";
+	message?: string | undefined;
+} | {
+	kind: "time";
+	precision: number | null;
+	message?: string | undefined;
+} | {
+	kind: "duration";
+	message?: string | undefined;
+} | {
+	kind: "ip";
+	version?: IpVersion | undefined;
+	message?: string | undefined;
+} | {
+	kind: "cidr";
+	version?: IpVersion | undefined;
+	message?: string | undefined;
+} | {
+	kind: "base64";
+	message?: string | undefined;
+} | {
+	kind: "base64url";
+	message?: string | undefined;
+};
+export interface ZodStringDef extends ZodTypeDef {
+	checks: ZodStringCheck[];
+	typeName: ZodFirstPartyTypeKind.ZodString;
+	coerce: boolean;
+}
+declare function datetimeRegex(args: {
+	precision?: number | null;
+	offset?: boolean;
+	local?: boolean;
+}): RegExp;
+declare class ZodString extends ZodType<string, ZodStringDef, string> {
+	_parse(input: ParseInput): ParseReturnType<string>;
+	protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): ZodEffects<this, string, string>;
+	_addCheck(check: ZodStringCheck): ZodString;
+	email(message?: errorUtil.ErrMessage): ZodString;
+	url(message?: errorUtil.ErrMessage): ZodString;
+	emoji(message?: errorUtil.ErrMessage): ZodString;
+	uuid(message?: errorUtil.ErrMessage): ZodString;
+	nanoid(message?: errorUtil.ErrMessage): ZodString;
+	cuid(message?: errorUtil.ErrMessage): ZodString;
+	cuid2(message?: errorUtil.ErrMessage): ZodString;
+	ulid(message?: errorUtil.ErrMessage): ZodString;
+	base64(message?: errorUtil.ErrMessage): ZodString;
+	base64url(message?: errorUtil.ErrMessage): ZodString;
+	jwt(options?: {
+		alg?: string;
+		message?: string | undefined;
+	}): ZodString;
+	ip(options?: string | {
+		version?: IpVersion;
+		message?: string | undefined;
+	}): ZodString;
+	cidr(options?: string | {
+		version?: IpVersion;
+		message?: string | undefined;
+	}): ZodString;
+	datetime(options?: string | {
+		message?: string | undefined;
+		precision?: number | null;
+		offset?: boolean;
+		local?: boolean;
+	}): ZodString;
+	date(message?: string): ZodString;
+	time(options?: string | {
+		message?: string | undefined;
+		precision?: number | null;
+	}): ZodString;
+	duration(message?: errorUtil.ErrMessage): ZodString;
+	regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;
+	includes(value: string, options?: {
+		message?: string;
+		position?: number;
+	}): ZodString;
+	startsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
+	endsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
+	min(minLength: number, message?: errorUtil.ErrMessage): ZodString;
+	max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;
+	length(len: number, message?: errorUtil.ErrMessage): ZodString;
+	/**
+	 * Equivalent to `.min(1)`
+	 */
+	nonempty(message?: errorUtil.ErrMessage): ZodString;
+	trim(): ZodString;
+	toLowerCase(): ZodString;
+	toUpperCase(): ZodString;
+	get isDatetime(): boolean;
+	get isDate(): boolean;
+	get isTime(): boolean;
+	get isDuration(): boolean;
+	get isEmail(): boolean;
+	get isURL(): boolean;
+	get isEmoji(): boolean;
+	get isUUID(): boolean;
+	get isNANOID(): boolean;
+	get isCUID(): boolean;
+	get isCUID2(): boolean;
+	get isULID(): boolean;
+	get isIP(): boolean;
+	get isCIDR(): boolean;
+	get isBase64(): boolean;
+	get isBase64url(): boolean;
+	get minLength(): number | null;
+	get maxLength(): number | null;
+	static create: (params?: RawCreateParams & {
+		coerce?: true;
+	}) => ZodString;
+}
+export type ZodNumberCheck = {
+	kind: "min";
+	value: number;
+	inclusive: boolean;
+	message?: string | undefined;
+} | {
+	kind: "max";
+	value: number;
+	inclusive: boolean;
+	message?: string | undefined;
+} | {
+	kind: "int";
+	message?: string | undefined;
+} | {
+	kind: "multipleOf";
+	value: number;
+	message?: string | undefined;
+} | {
+	kind: "finite";
+	message?: string | undefined;
+};
+export interface ZodNumberDef extends ZodTypeDef {
+	checks: ZodNumberCheck[];
+	typeName: ZodFirstPartyTypeKind.ZodNumber;
+	coerce: boolean;
+}
+declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
+	_parse(input: ParseInput): ParseReturnType<number>;
+	static create: (params?: RawCreateParams & {
+		coerce?: boolean;
+	}) => ZodNumber;
+	gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+	min: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
+	gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+	lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+	max: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
+	lt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+	protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): ZodNumber;
+	_addCheck(check: ZodNumberCheck): ZodNumber;
+	int(message?: errorUtil.ErrMessage): ZodNumber;
+	positive(message?: errorUtil.ErrMessage): ZodNumber;
+	negative(message?: errorUtil.ErrMessage): ZodNumber;
+	nonpositive(message?: errorUtil.ErrMessage): ZodNumber;
+	nonnegative(message?: errorUtil.ErrMessage): ZodNumber;
+	multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;
+	step: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
+	finite(message?: errorUtil.ErrMessage): ZodNumber;
+	safe(message?: errorUtil.ErrMessage): ZodNumber;
+	get minValue(): number | null;
+	get maxValue(): number | null;
+	get isInt(): boolean;
+	get isFinite(): boolean;
+}
+export type ZodBigIntCheck = {
+	kind: "min";
+	value: bigint;
+	inclusive: boolean;
+	message?: string | undefined;
+} | {
+	kind: "max";
+	value: bigint;
+	inclusive: boolean;
+	message?: string | undefined;
+} | {
+	kind: "multipleOf";
+	value: bigint;
+	message?: string | undefined;
+};
+export interface ZodBigIntDef extends ZodTypeDef {
+	checks: ZodBigIntCheck[];
+	typeName: ZodFirstPartyTypeKind.ZodBigInt;
+	coerce: boolean;
+}
+declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {
+	_parse(input: ParseInput): ParseReturnType<bigint>;
+	_getInvalidInput(input: ParseInput): INVALID;
+	static create: (params?: RawCreateParams & {
+		coerce?: boolean;
+	}) => ZodBigInt;
+	gte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+	min: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
+	gt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+	lte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+	max: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
+	lt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+	protected setLimit(kind: "min" | "max", value: bigint, inclusive: boolean, message?: string): ZodBigInt;
+	_addCheck(check: ZodBigIntCheck): ZodBigInt;
+	positive(message?: errorUtil.ErrMessage): ZodBigInt;
+	negative(message?: errorUtil.ErrMessage): ZodBigInt;
+	nonpositive(message?: errorUtil.ErrMessage): ZodBigInt;
+	nonnegative(message?: errorUtil.ErrMessage): ZodBigInt;
+	multipleOf(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
+	get minValue(): bigint | null;
+	get maxValue(): bigint | null;
+}
+export interface ZodBooleanDef extends ZodTypeDef {
+	typeName: ZodFirstPartyTypeKind.ZodBoolean;
+	coerce: boolean;
+}
+declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {
+	_parse(input: ParseInput): ParseReturnType<boolean>;
+	static create: (params?: RawCreateParams & {
+		coerce?: boolean;
+	}) => ZodBoolean;
+}
+export type ZodDateCheck = {
+	kind: "min";
+	value: number;
+	message?: string | undefined;
+} | {
+	kind: "max";
+	value: number;
+	message?: string | undefined;
+};
+export interface ZodDateDef extends ZodTypeDef {
+	checks: ZodDateCheck[];
+	coerce: boolean;
+	typeName: ZodFirstPartyTypeKind.ZodDate;
+}
+declare class ZodDate extends ZodType<Date, ZodDateDef, Date> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	_addCheck(check: ZodDateCheck): ZodDate;
+	min(minDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+	max(maxDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+	get minDate(): Date | null;
+	get maxDate(): Date | null;
+	static create: (params?: RawCreateParams & {
+		coerce?: boolean;
+	}) => ZodDate;
+}
+export interface ZodSymbolDef extends ZodTypeDef {
+	typeName: ZodFirstPartyTypeKind.ZodSymbol;
+}
+declare class ZodSymbol extends ZodType<symbol, ZodSymbolDef, symbol> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: (params?: RawCreateParams) => ZodSymbol;
+}
+export interface ZodUndefinedDef extends ZodTypeDef {
+	typeName: ZodFirstPartyTypeKind.ZodUndefined;
+}
+declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef, undefined> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	params?: RawCreateParams;
+	static create: (params?: RawCreateParams) => ZodUndefined;
+}
+export interface ZodNullDef extends ZodTypeDef {
+	typeName: ZodFirstPartyTypeKind.ZodNull;
+}
+declare class ZodNull extends ZodType<null, ZodNullDef, null> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: (params?: RawCreateParams) => ZodNull;
+}
+export interface ZodAnyDef extends ZodTypeDef {
+	typeName: ZodFirstPartyTypeKind.ZodAny;
+}
+declare class ZodAny extends ZodType<any, ZodAnyDef, any> {
+	_any: true;
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: (params?: RawCreateParams) => ZodAny;
+}
+export interface ZodUnknownDef extends ZodTypeDef {
+	typeName: ZodFirstPartyTypeKind.ZodUnknown;
+}
+declare class ZodUnknown extends ZodType<unknown, ZodUnknownDef, unknown> {
+	_unknown: true;
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: (params?: RawCreateParams) => ZodUnknown;
+}
+export interface ZodNeverDef extends ZodTypeDef {
+	typeName: ZodFirstPartyTypeKind.ZodNever;
+}
+declare class ZodNever extends ZodType<never, ZodNeverDef, never> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: (params?: RawCreateParams) => ZodNever;
+}
+export interface ZodVoidDef extends ZodTypeDef {
+	typeName: ZodFirstPartyTypeKind.ZodVoid;
+}
+declare class ZodVoid extends ZodType<void, ZodVoidDef, void> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: (params?: RawCreateParams) => ZodVoid;
+}
+export interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	type: T;
+	typeName: ZodFirstPartyTypeKind.ZodArray;
+	exactLength: {
+		value: number;
+		message?: string | undefined;
+	} | null;
+	minLength: {
+		value: number;
+		message?: string | undefined;
+	} | null;
+	maxLength: {
+		value: number;
+		message?: string | undefined;
+	} | null;
+}
+export type ArrayCardinality = "many" | "atleastone";
+export type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [
+	T["_output"],
+	...T["_output"][]
+] : T["_output"][];
+declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [
+	T["_input"],
+	...T["_input"][]
+] : T["_input"][]> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	get element(): T;
+	min(minLength: number, message?: errorUtil.ErrMessage): this;
+	max(maxLength: number, message?: errorUtil.ErrMessage): this;
+	length(len: number, message?: errorUtil.ErrMessage): this;
+	nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
+	static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
+}
+export type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
+export type UnknownKeysParam = "passthrough" | "strict" | "strip";
+export interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	typeName: ZodFirstPartyTypeKind.ZodObject;
+	shape: () => T;
+	catchall: Catchall;
+	unknownKeys: UnknownKeys;
+}
+export type mergeTypes<A, B> = {
+	[k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never;
+};
+export type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
+export type baseObjectOutputType<Shape extends ZodRawShape> = {
+	[k in keyof Shape]: Shape[k]["_output"];
+};
+export type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
+export type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
+	[k in keyof Shape]: Shape[k]["_input"];
+}>;
+export type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
+	[k: string]: T["_output"];
+};
+export type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
+	[k: string]: T["_input"];
+};
+export type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
+	[k: string]: unknown;
+} : unknown;
+export type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
+export type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+export type noUnrecognized<Obj extends object, Shape extends object> = {
+	[k in keyof Obj]: k extends keyof Shape ? Obj[k] : never;
+};
+declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
+	private _cached;
+	_getCached(): {
+		shape: T;
+		keys: string[];
+	};
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	get shape(): T;
+	strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;
+	strip(): ZodObject<T, "strip", Catchall>;
+	passthrough(): ZodObject<T, "passthrough", Catchall>;
+	/**
+	 * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
+	 * If you want to pass through unknown properties, use `.passthrough()` instead.
+	 */
+	nonstrict: () => ZodObject<T, "passthrough", Catchall>;
+	extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
+	/**
+	 * @deprecated Use `.extend` instead
+	 *  */
+	augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
+	/**
+	 * Prior to zod@1.0.12 there was a bug in the
+	 * inferred type of merged objects. Please
+	 * upgrade if you are experiencing issues.
+	 */
+	merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
+	setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & {
+		[k in Key]: Schema;
+	}, UnknownKeys, Catchall>;
+	catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
+	pick<Mask extends util.Exactly<{
+		[k in keyof T]?: true;
+	}, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
+	omit<Mask extends util.Exactly<{
+		[k in keyof T]?: true;
+	}, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
+	/**
+	 * @deprecated
+	 */
+	deepPartial(): partialUtil.DeepPartial<this>;
+	partial(): ZodObject<{
+		[k in keyof T]: ZodOptional<T[k]>;
+	}, UnknownKeys, Catchall>;
+	partial<Mask extends util.Exactly<{
+		[k in keyof T]?: true;
+	}, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{
+		[k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k];
+	}>, UnknownKeys, Catchall>;
+	required(): ZodObject<{
+		[k in keyof T]: deoptional<T[k]>;
+	}, UnknownKeys, Catchall>;
+	required<Mask extends util.Exactly<{
+		[k in keyof T]?: true;
+	}, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{
+		[k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
+	}>, UnknownKeys, Catchall>;
+	keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
+	static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+	static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+	static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
+}
+export type AnyZodObject = ZodObject<any, any, any>;
+export type ZodUnionOptions = Readonly<[
+	ZodTypeAny,
+	...ZodTypeAny[]
+]>;
+export interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
+	ZodTypeAny,
+	ZodTypeAny,
+	...ZodTypeAny[]
+]>> extends ZodTypeDef {
+	options: T;
+	typeName: ZodFirstPartyTypeKind.ZodUnion;
+}
+declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	get options(): T;
+	static create: <Options extends Readonly<[
+		ZodTypeAny,
+		ZodTypeAny,
+		...ZodTypeAny[]
+	]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
+}
+export type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
+	[key in Discriminator]: ZodTypeAny;
+} & ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+export interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
+	discriminator: Discriminator;
+	options: Options;
+	optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;
+	typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
+}
+declare class ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[]> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	get discriminator(): Discriminator;
+	get options(): Options;
+	get optionsMap(): Map<Primitive, ZodDiscriminatedUnionOption<any>>;
+	/**
+	 * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
+	 * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
+	 * have a different value for each object in the union.
+	 * @param discriminator the name of the discriminator property
+	 * @param types an array of object schemas
+	 * @param params
+	 */
+	static create<Discriminator extends string, Types extends readonly [
+		ZodDiscriminatedUnionOption<Discriminator>,
+		...ZodDiscriminatedUnionOption<Discriminator>[]
+	]>(discriminator: Discriminator, options: Types, params?: RawCreateParams): ZodDiscriminatedUnion<Discriminator, Types>;
+}
+export interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	left: T;
+	right: U;
+	typeName: ZodFirstPartyTypeKind.ZodIntersection;
+}
+declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
+}
+export type ZodTupleItems = [
+	ZodTypeAny,
+	...ZodTypeAny[]
+];
+export type AssertArray<T> = T extends any[] ? T : never;
+export type OutputTypeOfTuple<T extends ZodTupleItems | [
+]> = AssertArray<{
+	[k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never;
+}>;
+export type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [
+], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [
+	...OutputTypeOfTuple<T>,
+	...Rest["_output"][]
+] : OutputTypeOfTuple<T>;
+export type InputTypeOfTuple<T extends ZodTupleItems | [
+]> = AssertArray<{
+	[k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never;
+}>;
+export type InputTypeOfTupleWithRest<T extends ZodTupleItems | [
+], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [
+	...InputTypeOfTuple<T>,
+	...Rest["_input"][]
+] : InputTypeOfTuple<T>;
+export interface ZodTupleDef<T extends ZodTupleItems | [
+] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
+	items: T;
+	rest: Rest;
+	typeName: ZodFirstPartyTypeKind.ZodTuple;
+}
+export type AnyZodTuple = ZodTuple<[
+	ZodTypeAny,
+	...ZodTypeAny[]
+] | [
+], ZodTypeAny | null>;
+declare class ZodTuple<T extends ZodTupleItems | [
+] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	get items(): T;
+	rest<RestSchema extends ZodTypeAny>(rest: RestSchema): ZodTuple<T, RestSchema>;
+	static create: <Items extends [
+		ZodTypeAny,
+		...ZodTypeAny[]
+	] | [
+	]>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
+}
+export interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	valueType: Value;
+	keyType: Key;
+	typeName: ZodFirstPartyTypeKind.ZodRecord;
+}
+export type KeySchema = ZodType<string | number | symbol, any, any>;
+export type RecordType<K extends string | number | symbol, V> = [
+	string
+] extends [
+	K
+] ? Record<K, V> : [
+	number
+] extends [
+	K
+] ? Record<K, V> : [
+	symbol
+] extends [
+	K
+] ? Record<K, V> : [
+	BRAND<string | number | symbol>
+] extends [
+	K
+] ? Record<K, V> : Partial<Record<K, V>>;
+declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
+	get keySchema(): Key;
+	get valueSchema(): Value;
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	get element(): Value;
+	static create<Value extends ZodTypeAny>(valueType: Value, params?: RawCreateParams): ZodRecord<ZodString, Value>;
+	static create<Keys extends KeySchema, Value extends ZodTypeAny>(keySchema: Keys, valueType: Value, params?: RawCreateParams): ZodRecord<Keys, Value>;
+}
+export interface ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	valueType: Value;
+	keyType: Key;
+	typeName: ZodFirstPartyTypeKind.ZodMap;
+}
+declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Map<Key["_output"], Value["_output"]>, ZodMapDef<Key, Value>, Map<Key["_input"], Value["_input"]>> {
+	get keySchema(): Key;
+	get valueSchema(): Value;
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
+}
+export interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	valueType: Value;
+	typeName: ZodFirstPartyTypeKind.ZodSet;
+	minSize: {
+		value: number;
+		message?: string | undefined;
+	} | null;
+	maxSize: {
+		value: number;
+		message?: string | undefined;
+	} | null;
+}
+declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Set<Value["_output"]>, ZodSetDef<Value>, Set<Value["_input"]>> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	min(minSize: number, message?: errorUtil.ErrMessage): this;
+	max(maxSize: number, message?: errorUtil.ErrMessage): this;
+	size(size: number, message?: errorUtil.ErrMessage): this;
+	nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;
+	static create: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
+}
+export interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	args: Args;
+	returns: Returns;
+	typeName: ZodFirstPartyTypeKind.ZodFunction;
+}
+export type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
+export type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
+declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> extends ZodType<OuterTypeOfFunction<Args, Returns>, ZodFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {
+	_parse(input: ParseInput): ParseReturnType<any>;
+	parameters(): Args;
+	returnType(): Returns;
+	args<Items extends Parameters<(typeof ZodTuple)["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;
+	returns<NewReturnType extends ZodType<any, any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;
+	implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
+	strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
+	validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
+	static create(): ZodFunction<ZodTuple<[
+	], ZodUnknown>, ZodUnknown>;
+	static create<T extends AnyZodTuple = ZodTuple<[
+	], ZodUnknown>>(args: T): ZodFunction<T, ZodUnknown>;
+	static create<T extends AnyZodTuple, U extends ZodTypeAny>(args: T, returns: U): ZodFunction<T, U>;
+	static create<T extends AnyZodTuple = ZodTuple<[
+	], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args: T, returns: U, params?: RawCreateParams): ZodFunction<T, U>;
+}
+export interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	getter: () => T;
+	typeName: ZodFirstPartyTypeKind.ZodLazy;
+}
+declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef<T>, input<T>> {
+	get schema(): T;
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
+}
+export interface ZodLiteralDef<T = any> extends ZodTypeDef {
+	value: T;
+	typeName: ZodFirstPartyTypeKind.ZodLiteral;
+}
+declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	get value(): T;
+	static create: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
+}
+export type ArrayKeys = keyof any[];
+export type Indices<T> = Exclude<keyof T, ArrayKeys>;
+export type EnumValues<T extends string = string> = readonly [
+	T,
+	...T[]
+];
+export type Values<T extends EnumValues> = {
+	[k in T[number]]: k;
+};
+export interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
+	values: T;
+	typeName: ZodFirstPartyTypeKind.ZodEnum;
+}
+export type Writeable<T> = {
+	-readonly [P in keyof T]: T[P];
+};
+export type FilterEnum<Values, ToExclude> = Values extends [
+] ? [
+] : Values extends [
+	infer Head,
+	...infer Rest
+] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [
+	Head,
+	...FilterEnum<Rest, ToExclude>
+] : never;
+export type typecast<A, T> = A extends T ? A : never;
+declare function createZodEnum<U extends string, T extends Readonly<[
+	U,
+	...U[]
+]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
+declare function createZodEnum<U extends string, T extends [
+	U,
+	...U[]
+]>(values: T, params?: RawCreateParams): ZodEnum<T>;
+declare class ZodEnum<T extends [
+	string,
+	...string[]
+]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
+	_cache: Set<T[number]> | undefined;
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	get options(): T;
+	get enum(): Values<T>;
+	get Values(): Values<T>;
+	get Enum(): Values<T>;
+	extract<ToExtract extends readonly [
+		T[number],
+		...T[number][]
+	]>(values: ToExtract, newDef?: RawCreateParams): ZodEnum<Writeable<ToExtract>>;
+	exclude<ToExclude extends readonly [
+		T[number],
+		...T[number][]
+	]>(values: ToExclude, newDef?: RawCreateParams): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [
+		string,
+		...string[]
+	]>>;
+	static create: typeof createZodEnum;
+}
+export interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
+	values: T;
+	typeName: ZodFirstPartyTypeKind.ZodNativeEnum;
+}
+export type EnumLike = {
+	[k: string]: string | number;
+	[nu: number]: string;
+};
+declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>, T[keyof T]> {
+	_cache: Set<T[keyof T]> | undefined;
+	_parse(input: ParseInput): ParseReturnType<T[keyof T]>;
+	get enum(): T;
+	static create: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
+}
+export interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	type: T;
+	typeName: ZodFirstPartyTypeKind.ZodPromise;
+}
+declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
+	unwrap(): T;
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
+}
+export type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
+export type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
+export type RefinementEffect<T> = {
+	type: "refinement";
+	refinement: (arg: T, ctx: RefinementCtx) => any;
+};
+export type TransformEffect<T> = {
+	type: "transform";
+	transform: (arg: T, ctx: RefinementCtx) => any;
+};
+export type PreprocessEffect<T> = {
+	type: "preprocess";
+	transform: (arg: T, ctx: RefinementCtx) => any;
+};
+export type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
+export interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	schema: T;
+	typeName: ZodFirstPartyTypeKind.ZodEffects;
+	effect: Effect<any>;
+}
+declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {
+	innerType(): T;
+	sourceType(): T;
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
+	static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
+}
+export interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	innerType: T;
+	typeName: ZodFirstPartyTypeKind.ZodOptional;
+}
+export type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
+declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	unwrap(): T;
+	static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
+}
+export interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	innerType: T;
+	typeName: ZodFirstPartyTypeKind.ZodNullable;
+}
+export type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
+declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	unwrap(): T;
+	static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
+}
+export interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	innerType: T;
+	defaultValue: () => util.noUndefined<T["_input"]>;
+	typeName: ZodFirstPartyTypeKind.ZodDefault;
+}
+declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	removeDefault(): T;
+	static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+		default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
+	}) => ZodDefault<Inner>;
+}
+export interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	innerType: T;
+	catchValue: (ctx: {
+		error: ZodError;
+		input: unknown;
+	}) => T["_input"];
+	typeName: ZodFirstPartyTypeKind.ZodCatch;
+}
+declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	removeCatch(): T;
+	static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+		catch: Inner["_output"] | (() => Inner["_output"]);
+	}) => ZodCatch<Inner>;
+}
+export interface ZodNaNDef extends ZodTypeDef {
+	typeName: ZodFirstPartyTypeKind.ZodNaN;
+}
+declare class ZodNaN extends ZodType<number, ZodNaNDef, number> {
+	_parse(input: ParseInput): ParseReturnType<any>;
+	static create: (params?: RawCreateParams) => ZodNaN;
+}
+export interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
+	type: T;
+	typeName: ZodFirstPartyTypeKind.ZodBranded;
+}
+declare const BRAND: unique symbol;
+export type BRAND<T extends string | number | symbol> = {
+	[BRAND]: {
+		[k in T]: true;
+	};
+};
+declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
+	_parse(input: ParseInput): ParseReturnType<any>;
+	unwrap(): T;
+}
+export interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
+	in: A;
+	out: B;
+	typeName: ZodFirstPartyTypeKind.ZodPipeline;
+}
+declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
+	_parse(input: ParseInput): ParseReturnType<any>;
+	static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
+}
+export type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+	readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+export type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [
+	infer Head,
+	...infer Tail
+] ? readonly [
+	Head,
+	...Tail
+] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
+export interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+	innerType: T;
+	typeName: ZodFirstPartyTypeKind.ZodReadonly;
+}
+declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
+	_parse(input: ParseInput): ParseReturnType<this["_output"]>;
+	static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
+	unwrap(): T;
+}
+export type CustomParams = CustomErrorParams & {
+	fatal?: boolean;
+};
+declare function custom<T>(check?: (data: any) => any, _params?: string | CustomParams | ((input: any) => CustomParams), 
+/**
+ * @deprecated
+ *
+ * Pass `fatal` into the params object instead:
+ *
+ * ```ts
+ * z.string().custom((val) => val.length > 5, { fatal: false })
+ * ```
+ *
+ */
+fatal?: boolean): ZodType<T, ZodTypeDef, T>;
+declare const late: {
+	object: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
+};
+declare enum ZodFirstPartyTypeKind {
+	ZodString = "ZodString",
+	ZodNumber = "ZodNumber",
+	ZodNaN = "ZodNaN",
+	ZodBigInt = "ZodBigInt",
+	ZodBoolean = "ZodBoolean",
+	ZodDate = "ZodDate",
+	ZodSymbol = "ZodSymbol",
+	ZodUndefined = "ZodUndefined",
+	ZodNull = "ZodNull",
+	ZodAny = "ZodAny",
+	ZodUnknown = "ZodUnknown",
+	ZodNever = "ZodNever",
+	ZodVoid = "ZodVoid",
+	ZodArray = "ZodArray",
+	ZodObject = "ZodObject",
+	ZodUnion = "ZodUnion",
+	ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
+	ZodIntersection = "ZodIntersection",
+	ZodTuple = "ZodTuple",
+	ZodRecord = "ZodRecord",
+	ZodMap = "ZodMap",
+	ZodSet = "ZodSet",
+	ZodFunction = "ZodFunction",
+	ZodLazy = "ZodLazy",
+	ZodLiteral = "ZodLiteral",
+	ZodEnum = "ZodEnum",
+	ZodEffects = "ZodEffects",
+	ZodNativeEnum = "ZodNativeEnum",
+	ZodOptional = "ZodOptional",
+	ZodNullable = "ZodNullable",
+	ZodDefault = "ZodDefault",
+	ZodCatch = "ZodCatch",
+	ZodPromise = "ZodPromise",
+	ZodBranded = "ZodBranded",
+	ZodPipeline = "ZodPipeline",
+	ZodReadonly = "ZodReadonly"
+}
+export type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any> | ZodReadonly<any> | ZodSymbol;
+declare abstract class Class {
+	constructor(..._: any[]);
+}
+declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
+declare const stringType: (params?: RawCreateParams & {
+	coerce?: true;
+}) => ZodString;
+declare const numberType: (params?: RawCreateParams & {
+	coerce?: boolean;
+}) => ZodNumber;
+declare const nanType: (params?: RawCreateParams) => ZodNaN;
+declare const bigIntType: (params?: RawCreateParams & {
+	coerce?: boolean;
+}) => ZodBigInt;
+declare const booleanType: (params?: RawCreateParams & {
+	coerce?: boolean;
+}) => ZodBoolean;
+declare const dateType: (params?: RawCreateParams & {
+	coerce?: boolean;
+}) => ZodDate;
+declare const symbolType: (params?: RawCreateParams) => ZodSymbol;
+declare const undefinedType: (params?: RawCreateParams) => ZodUndefined;
+declare const nullType: (params?: RawCreateParams) => ZodNull;
+declare const anyType: (params?: RawCreateParams) => ZodAny;
+declare const unknownType: (params?: RawCreateParams) => ZodUnknown;
+declare const neverType: (params?: RawCreateParams) => ZodNever;
+declare const voidType: (params?: RawCreateParams) => ZodVoid;
+declare const arrayType: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
+declare const objectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+declare const strictObjectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+declare const unionType: <Options extends Readonly<[
+	ZodTypeAny,
+	ZodTypeAny,
+	...ZodTypeAny[]
+]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
+declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
+declare const intersectionType: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
+declare const tupleType: <Items extends [
+	ZodTypeAny,
+	...ZodTypeAny[]
+] | [
+]>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
+declare const recordType: typeof ZodRecord.create;
+declare const mapType: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
+declare const setType: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
+declare const functionType: typeof ZodFunction.create;
+declare const lazyType: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
+declare const literalType: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
+declare const enumType: typeof createZodEnum;
+declare const nativeEnumType: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
+declare const promiseType: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
+declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
+declare const optionalType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
+declare const nullableType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
+declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
+declare const pipelineType: typeof ZodPipeline.create;
+declare const ostring: () => ZodOptional<ZodString>;
+declare const onumber: () => ZodOptional<ZodNumber>;
+declare const oboolean: () => ZodOptional<ZodBoolean>;
+declare const coerce: {
+	string: (typeof ZodString)["create"];
+	number: (typeof ZodNumber)["create"];
+	boolean: (typeof ZodBoolean)["create"];
+	bigint: (typeof ZodBigInt)["create"];
+	date: (typeof ZodDate)["create"];
+};
+declare const NEVER: never;
+/**
+ * The report's shape, split by who produces each part. A leaf module: the rows
+ * builder and the contract both need these types, and neither may import the
+ * other (report-contract calls buildReportRows, so the dependency runs one way).
+ */
+/**
+ * One behaviour the change introduces, and the tests that stand behind it.
+ *
+ * DERIVED, never authored — the whole chain already exists in the artifacts:
+ * analyze names each behaviour with an id and the diff line that introduces it,
+ * recommend's cases carry `from_behavior` and its maintenance entries carry
+ * `covers_behaviors`, and the rows know which of those were actually delivered.
+ * Aggregating it here is what lets a reader go from "what changed" to "the test
+ * that proves it" without reading prose.
+ */
+export interface ChangeRow {
+	/** analyze behaviour id. */
+	id: string;
+	/** What the change makes true (analyze's `statement`). */
+	text: string;
+	/** Where it comes from — analyze's `evidence`, a file:line in the diff. */
+	source: string;
+	/** Planned-case ids of tests that ran AND whose own result was Pass/Fail —
+	 *  not merely a sibling in the same file that itself came back Skipped —
+	 *  and cite this behaviour. */
+	testedBy: string[];
+	/**
+	 * Planned-case ids delivered as a real file (a newTestsCreated row exists)
+	 * and citing this behaviour, whether or not `testedBy` could prove them —
+	 * distinguishes "a test exists but did not run this time" from "nothing
+	 * was ever written for this".
+	 */
+	writtenBy: string[];
+	/**
+	 * Final paths of existing tests adapt actually acted on (its own item,
+	 * action other than `none`) that cite this behaviour — not merely files
+	 * recommend planned to touch, which a run may never have gotten to.
+	 */
+	maintainedBy: string[];
+}
+/** Counters over the rows: what the run produced and how much of it ran. */
+export interface ExecutionCoverage {
+	generated: number;
+	modified: number;
+	verified: number;
+	executed: number;
+}
+declare enum ClauseStatus {
+	/** Every test behind it that ran passed. */
+	Pass = "Pass",
+	/** A test behind it failed: the change does not do what the clause says (or a defect's test showed it). */
+	Fail = "Fail",
+	/** Tests were written for it, and none of them ran. */
+	NotRun = "Not run",
+	/** No test checks it. */
+	NotTested = "Not tested",
+	/**
+	 * A check of what the change could break that ran and passed, its test then removed (contracts/could-break-contract.ts):
+	 * it was checked and holds, though no test is kept for it.
+	 */
+	PassedNotKept = "Passed, test not kept"
+}
+export interface RequirementTestRef {
+	/** The planned case the result proves. */
+	testId: string;
+	fileName?: string;
+	/** owner/repo of `fileName` when a result row named it; absent for a file named as write wrote it. */
+	repository?: string;
+	/** The test functions behind the case, as the runner names them; empty when the run did not name them. */
+	functions: string[];
+	status: "Pass" | "Fail" | "Skipped";
+}
+export interface RequirementClauseRow {
+	id: string;
+	/** What the clause asks; absent for a Requirement reference. */
+	text?: string;
+	status: ClauseStatus;
+	tests: RequirementTestRef[];
+	/** The plan's findings against this clause or its requirement. */
+	findings: string[];
+	/** Why no test checks it (Not tested, when the plan or write said), or what the removed check showed (Passed, test not kept). */
+	notTested?: string;
+}
+export interface RequirementReportRow {
+	id: string;
+	/** How the reader knows it: the item and criterion for a Requirement reference ("PAY-184 AC2"), else its id. */
+	label: string;
+	source: string;
+	/** The requirement as the plan states it; absent for a Requirement reference. */
+	statement?: string;
+	clauses: RequirementClauseRow[];
+}
+/** The shipped report — the TestbotReport shape deliver renders into the PR. */
+export interface StagedTestbotReport {
+	schemaVersion?: 1;
+	businessCaseAnalysis: string;
+	newTestsCreated: {
+		testId: string;
+		testType: string;
+		endpoint: string;
+		fileName: string;
+		description: string;
+		reasoning: string;
+		/** owner/repo where the test lives. Absent from pre-V3 reports. */
+		repository?: string;
+	}[];
+	testMaintenance?: {
+		testType: string;
+		endpoint: string;
+		fileName: string;
+		description: string;
+		action: string;
+		beforeStatus: string;
+		beforeDetails: string;
+		afterStatus: string;
+		afterDetails: string;
+		/** owner/repo where the maintained test lives. Absent from pre-V3 reports. */
+		repository?: string;
+	}[];
+	testResults: {
+		/** The recommend case this row proves, when the file covers one. Absent
+		 *  for a row about an existing test's overall re-run (no planned case). */
+		testId?: string;
+		testType: string;
+		endpoint: string;
+		status: "Pass" | "Fail" | "Skipped";
+		details: string;
+		/** The test file this row is about. */
+		fileName?: string;
+		/** Testbot V3: `owner/repo` where the test lives. Absent from pre-V3 reports. */
+		repository?: string;
+		/** Testbot V3: `testResultId(repository, testType, path, name)`, unique within
+		 *  the report. Absent from pre-V3 reports. */
+		resultId?: string;
+		/** Testbot V3: why a Fail or Skipped row came out so, when the run's own
+		 *  records say. Absent when they do not, and never on a Pass row. */
+		failureCause?: FailureCause;
+	}[];
+	issuesFound: {
+		description: string;
+		severity?: string;
+		/** `bug`, `lint`, `type`, `config`, or for a Requirement reference `requirement_conflict` or `spec_overruled` (IssueCategory). */
+		category?: string;
+		sourceFile?: string;
+		sourceLine?: number;
+		/** The reference criteria a `requirement_conflict` or `spec_overruled` issue is about (SKYR-4920). */
+		requirements?: IssueCriterion[];
+		/** The plan's finding this issue is, when it is one. */
+		findingId?: string;
+		/** The plan's requirement or clause ids it violates. */
+		requirementIds?: string[];
+	}[];
+	nextSteps: string[];
+	/**
+	 * What the reader must know that the rows alone do not say: nothing ran, a
+	 * dependency was mocked, the app needed a corrected recipe.
+	 *
+	 * DERIVED, never authored. Every one of these is a fact the artifacts
+	 * already record, and the gate used to require the agent to restate it in
+	 * prose and then hunt for that prose with a regex — so a report could
+	 * disclose a caveat perfectly and fail on vocabulary, while one that merely
+	 * contained the word "lint" passed. Constructing the line instead makes the
+	 * disclosure a property of the report rather than of its wording.
+	 */
+	caveats?: ReportCaveat[];
+	/** Behaviour → proving test. Absent when analyze named no behaviours. */
+	changes?: ChangeRow[];
+	/** Absent when there are no rows to count. */
+	executionCoverage?: ExecutionCoverage;
+	commitMessage: string;
+	/** Testbot V3: the run's triage and sufficiency. Absent from pre-V3 reports. */
+	validation?: ReportValidation;
+	/** Testbot V3: the shared environment the run needed, as it was checked. Absent when it needed none. */
+	system?: ReportSystem;
+	/** Testbot V3: the context each runtime test ran in (SKYR-4579). Absent when the run planned no runtime test. */
+	testExecutionContexts?: TestExecutionContext[];
+	/** Testbot V3: whether the run read each Requirement reference (SKYR-4919). Only when its manifest named some. */
+	requirementReferences?: ReportedRequirementReference[];
+	/** Each requirement by its id, its clauses, and the tests and defects behind each (two-step pipeline). Derived. */
+	requirements?: RequirementReportRow[];
+	/** The recorded video of each browser test file the run wrote (context/ui-video.ts): the file by its repository and
+	 *  path there (as testResults names it) and as the write step named it (as userJourneys does), with its download link
+	 *  once uploaded. `artifactsUrl` is the run's artifacts page, set only when some file's upload succeeded. Absent when
+	 *  none was recorded. */
+	testVideos?: {
+		fileName: string;
+		repository?: string;
+		writtenAs?: string;
+		url?: string;
+		artifactsUrl?: string;
+	}[];
+	/** The user journeys the change sits on and the browser test that walks each (two-step pipeline). Absent when none were planned. */
+	userJourneys?: JourneyReportRow[];
+	/** The Testbot test packages this run's tests are in, each with the one command that runs it. Derived. */
+	testPackages?: ReportTestPackage[];
+	/** Packages this run added to an application manifest: an exception, each with its reason. Derived. */
+	dependencyChanges?: ReportDependencyChange[];
+}
+declare enum JourneyStatus {
+	Pass = "Pass",
+	Fail = "Fail",
+	NotRun = "Not run",
+	NotWritten = "Not written"
+}
+/** One planned user journey, and the browser test that walks it (contracts/journeys.ts). */
+export interface JourneyReportRow {
+	id: string;
+	name: string;
+	entry: string;
+	steps: number;
+	/** spec or pr-description when one describes the flow, else inferred. */
+	source: string;
+	fileName?: string;
+	test?: string;
+	status: JourneyStatus;
+	/** Why the test does not count as walking the journey end to end, when it does not. */
+	problems: string[];
+	/** Not covered: what the journey's test needs that could not be set up here. */
+	uncovered?: string;
+}
+/** A Testbot test package (context/test-package.ts): a self-contained folder whose entrypoint CI calls. */
+export interface ReportTestPackage {
+	directory: string;
+	runner: string;
+	entrypoint: string;
+	/** Set up by this run, else maintained from an earlier one. */
+	created: boolean;
+	/** owner/repo the package is in. */
+	repository?: string;
+}
+/** A package added to an application manifest (finalize.json dependencies.added). */
+export interface ReportDependencyChange {
+	package: string;
+	manifest: string;
+	reason?: string;
+	repository?: string;
+}
+declare enum RequirementItemSource {
+	Jira = "jira",
+	/** A Confluence page. Its key is its page id. */
+	Confluence = "confluence",
+	/**
+	 * Pasted requirement text, or an Uploaded document (SKYR-4927). It has no site. Its key is "pasted-" or "file-" and
+	 * the start of its content hash.
+	 */
+	Other = "other"
+}
+declare enum RequirementItemState {
+	Read = "read",
+	NotRead = "not_read"
+}
+declare enum RequirementNotReadReason {
+	NotFound = "not_found",
+	NoAccess = "no_access",
+	Unavailable = "unavailable",
+	AccessLost = "access_lost",
+	/** The runner could not get an Uploaded document, its bytes do not match its hash, or the agent could not open it (SKYR-4927). */
+	CannotOpen = "cannot_open"
+}
+/** An item by its source, site and key. A Jira issue and a Confluence page are on a site; pasted text has none. */
+export type RequirementItemName = {
+	source: RequirementItemSource.Jira | RequirementItemSource.Confluence;
+	site: string;
+	key: string;
+} | {
+	source: RequirementItemSource.Other;
+	site?: undefined;
+	key: string;
+};
+/** A Requirement reference as the report names it: the item and whether the run read it, never its text. */
+export type ReportedRequirementReference = RequirementItemName & ({
+	state: RequirementItemState.Read;
+	/**
+	 * Whether the item still matches what the app read on Run. False when it changed since: the run used its current
+	 * content, and Run details says it changed (SKYR-4923).
+	 */
+	contentMatches: boolean;
+	/** How the run judged each criterion of the item (SKYR-4920). Absent when the run made no plan. */
+	criteria?: ReportedCriterion[];
+} | {
+	state: RequirementItemState.NotRead;
+	reason: RequirementNotReadReason;
+});
+declare enum CriterionResult {
+	/** A covering test passed, and none failed. */
+	Met = "met",
+	/** A covering test ran and failed, for a cause other than the application. */
+	NotMet = "not_met",
+	/** The change does not touch it. It is never a test and never a failure. */
+	NotInChange = "not_in_change",
+	/** A covering test failed because the code contradicts it: a requirement_conflict. */
+	Conflict = "conflict",
+	/**
+	 * The change touches it, but no covering test ran: the plan gave it no test (for example, an Instruction narrowed
+	 * the validation), or its tests were skipped.
+	 */
+	NotTested = "not_tested"
+}
+/**
+ * One criterion of an item, numbered from 1 in the item's order. `quote` is the item's own words, for the web app
+ * only (ADR-0008 in testbot-installer-app docs/specs/testbot-v3/docs/adr/). It is left out when it holds a shape the
+ * app refuses. `coveredBy` names planned cases, as `changes[].testedBy` does.
+ */
+export interface ReportedCriterion {
+	criterion: number;
+	quote?: string;
+	coveredBy: string[];
+	result: CriterionResult;
+	/** Why the change does not touch it; only for not_in_change. */
+	note?: string;
+}
+/** The criterion an issue is about, and the version of its item the run read. */
+export type IssueCriterion = RequirementItemName & {
+	criterion: number;
+	version: string;
+};
+declare enum UploadedMediaType {
+	Pdf = "application/pdf",
+	Csv = "text/csv",
+	Docx = "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+	Xlsx = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+}
+declare enum ValidationSufficiency {
+	Sufficient = "sufficient",
+	Insufficient = "insufficient"
+}
+declare enum ActionRequiredReason {
+	RelatedChangeConflict = "related_change_conflict",
+	ReferenceOutsideTarget = "reference_outside_target",
+	SourceAccessLost = "source_access_lost",
+	ConfigurationIncomplete = "configuration_incomplete",
+	CredentialUnavailable = "credential_unavailable",
+	WorkflowBindingUnverified = "workflow_binding_unverified",
+	/** No Admin trusts the workflow host's writers, and Skyramp could not confirm that a ruleset requires a reviewed pull request on its bound branch (SKYR-4681). */
+	WorkflowRefUnprotected = "workflow_ref_unprotected",
+	/** The organization runs Testbot on AWS Bedrock, and the bound workflow does not turn Bedrock on (SKYR-5055). */
+	BedrockWorkflowRequired = "bedrock_workflow_required",
+	DeploymentReview = "deployment_review",
+	SutRevisionMismatch = "sut_revision_mismatch",
+	IsolationUnavailable = "isolation_unavailable",
+	EvidenceInsufficient = "evidence_insufficient"
+}
+declare enum EvidenceKind {
+	CiCheck = "ci_check",
+	TestReport = "test_report",
+	StaticAnalysis = "static_analysis",
+	CodeReview = "code_review",
+	Other = "other"
+}
+declare enum FailureCauseKind {
+	Application = "application",
+	Environment = "environment",
+	TestDefect = "test_defect"
+}
+declare enum EnvironmentFamily {
+	AuthToken = "auth_token",
+	Secret = "secret",
+	DataConnection = "data_connection",
+	AppNotStarted = "app_not_started",
+	Login = "login",
+	ExternalDependency = "external_dependency",
+	RecordingReplay = "recording_replay"
+}
+/** A Fail or Skipped result's cause, derived from what the run recorded. `family` goes with Environment only. */
+export interface FailureCause {
+	kind: FailureCauseKind;
+	family?: EnvironmentFamily;
+}
+/** Existing evidence the run accepted. The app refuses evidence from a repository or revision the run did not freeze. */
+export interface AcceptedEvidence {
+	kind: EvidenceKind;
+	/** `owner/repo`. */
+	repository: string;
+	/** The full commit the evidence was produced for: 40 or 64 lowercase hex characters. */
+	revision: string;
+	/** A URL or provider identifier for the evidence. */
+	reference: string;
+	summary: string;
+}
+/**
+ * The run's Validation Triage and sufficiency judgment. A run that is insufficient, or names any
+ * `actionRequired` reason, is never a validated success. The app refuses a report that breaks the rules below.
+ */
+export interface ReportValidation {
+	sufficiency: ValidationSufficiency;
+	/** Why the evidence is, or is not, enough. Never empty. */
+	rationale: string;
+	/** Required evidence that is still missing: empty exactly when `sufficient`. */
+	gaps: string[];
+	acceptedEvidence: AcceptedEvidence[];
+	/** No reason appears twice. */
+	actionRequired: ActionRequiredReason[];
+}
+declare enum RevisionStatus {
+	Verified = "verified",
+	Mismatch = "mismatch",
+	Unverifiable = "unverifiable"
+}
+declare enum RevisionSource {
+	Probe = "probe",
+	Agent = "agent"
+}
+/** The shared environment a run that needed runtime evidence checked: its existing components and shared dependencies. */
+export interface ReportSystem {
+	components: {
+		name: string;
+		/** `owner/repo` of the frozen source the component runs. */
+		repository: string;
+		url: string;
+		/** The manifest's frozen revision of `repository`. */
+		expectedRevision: string;
+		/** 7 to 64 lowercase hex characters, as the check returned them. */
+		observedRevision: string | null;
+		status: RevisionStatus;
+		source: RevisionSource;
+		/** The line of the check's answer that shows the revision (at most 300 characters), or why the check failed. */
+		evidence: string;
+	}[];
+	dependencies: {
+		name: string;
+		url: string | null;
+		version: string | null;
+		evidence: string;
+	}[];
+}
+declare enum ContextSetupKind {
+	Seed = "seed",
+	RuntimeMock = "runtime_mock",
+	EnvOverride = "env_override"
+}
+declare enum ContextMechanism {
+	TestCode = "test_code",
+	SkyrampMocker = "skyramp_mocker",
+	RecipeOverride = "recipe_override"
+}
+declare enum ContextStatus {
+	Ran = "ran",
+	SetupFailed = "setup_failed",
+	Cancelled = "cancelled",
+	Interrupted = "interrupted",
+	NotRun = "not_run"
+}
+declare enum ContextScope {
+	Disposable = "disposable",
+	Shared = "shared"
+}
+declare enum ContextExecution {
+	Serial = "serial",
+	Parallel = "parallel"
+}
+declare enum ContextCleanupStatus {
+	Done = "done",
+	Failed = "failed",
+	NotNeeded = "not_needed",
+	Skipped = "skipped"
+}
+/** The temporary setup or runtime manipulation one runtime test needed, and how it was undone. */
+export interface TestExecutionContext {
+	/** The test's resultId when it produced a result, else its repository-relative path (or the withheld case's id). */
+	test: string;
+	resultId: string | null;
+	scope: ContextScope;
+	execution: ContextExecution;
+	setup: {
+		kind: ContextSetupKind;
+		target: string;
+		mechanism: ContextMechanism;
+		detail: string;
+	}[];
+	status: ContextStatus;
+	notRunReason: ActionRequiredReason.IsolationUnavailable | null;
+	cleanup: {
+		status: ContextCleanupStatus;
+		detail: string;
+	};
+	/** The checkout `test` is in, until v3Report links it to its results and drops this. */
+	repository?: string;
+}
+declare enum CaveatKind {
+	TestsNotExecuted = "tests-not-executed",
+	DeployFailed = "deploy-failed",
+	RecipeDrift = "recipe-drift",
+	MockedDependency = "mocked-dependency",
+	FinalizeNotReady = "finalize-not-ready",
+	CiNotCovered = "ci-not-covered",
+	/** Validation Triage found no deployed behavior to validate, so no app was started. */
+	SutNotRequired = "sut-not-required",
+	/** The repo's own linter config doesn't reach this file — derived independently of CiNotCovered (whether the test RUNS at all), so the two can coexist: a file can be run but not linted, linted but not run, both, or neither. */
+	LintNotCovered = "lint-not-covered",
+	/** Analyze was salvaged: some of its claims went unconfirmed, and the plan was made from them as such. */
+	AnalysisUnverified = "analysis-unverified",
+	/** native-run selected unit tests and none of them ran: no unit result in the report is its re-run. */
+	UnitTestsNotRun = "unit-tests-not-run",
+	/** Tests the run wrote exist, but this environment could not run some of them (a missing tool, package or display). */
+	TestsCouldNotRunHere = "tests-could-not-run-here",
+	/** Checks only of what the change could break elsewhere that this run did not make: reported, not missing evidence. */
+	DownstreamNotChecked = "downstream-not-checked"
+}
+export interface ReportCaveat {
+	kind: CaveatKind;
+	/** What it is about, when the kind alone does not say — a dependency name. */
+	subject?: string;
+	/** One sentence for the PR author, in their terms. */
+	text: string;
+	/** True when it means the run is not evidence the change works. */
+	blocking: boolean;
+}
+declare enum SourceProvider {
+	GitHub = "github",
+	AzureDevOps = "azure-devops"
+}
+declare enum SelectionReason {
+	Trigger = "TRIGGER",
+	Baseline = "BASELINE",
+	AuthoritativeRelatedChange = "AUTHORITATIVE_RELATED_CHANGE",
+	ConfiguredSharedDependency = "CONFIGURED_SHARED_DEPENDENCY",
+	ManualOverride = "MANUAL_OVERRIDE"
+}
+declare enum TriggerKind {
+	PullRequest = "pull_request",
+	ReadyForReview = "ready_for_review",
+	Schedule = "schedule",
+	Manual = "manual",
+	SutSetup = "sut_setup",
+	RevisionRead = "revision_read"
+}
+declare enum ChangeKind {
+	PullRequest = "pull_request"
+}
+declare enum CredentialPurpose {
+	ModelProvider = "model_provider",
+	SutAccess = "sut_access",
+	Skyramp = "skyramp",
+	Other = "other"
+}
+declare enum DeliveryStatus {
+	None = "none",
+	Delivered = "delivered",
+	Partial = "partial",
+	Failed = "failed"
+}
+/**
+ * `RecipeUploaded`: a `sut_setup` attempt's SUT recipe reached the app; it is that run's `ReportUploaded`.
+ * `RevisionsUploaded`: a `revision_read` attempt read every component and its upload reached the app (SKYR-5225).
+ */
+export declare enum AttemptEndReason {
+	ReportUploaded = "report_uploaded",
+	NoReport = "no_report",
+	Cancelled = "cancelled",
+	RecipeUploaded = "recipe_uploaded",
+	RevisionsUploaded = "revisions_uploaded"
+}
+declare enum AttemptState {
+	Running = "running",
+	Ended = "ended"
+}
+/**
+ * Why no report reached the app. `RunnerLost` is recorded by the app itself, when an attempt passes its deadline.
+ * `CheckoutFailed`: the frozen sources could not be checked out, which the app counts as getting the Target's code,
+ * not bringing up the app (SKYR-4769). `EnvironmentUnverified`: the run could not verify what the customer's environment
+ * runs, so it is Validation Blocked, not a failed setup (SKYR-5225).
+ */
+export declare enum NoReportCause {
+	TimedOut = "timed_out",
+	AgentFailed = "agent_failed",
+	SetupFailed = "setup_failed",
+	CredentialMissing = "credential_missing",
+	RunnerLost = "runner_lost",
+	CheckoutFailed = "checkout_failed",
+	EnvironmentUnverified = "environment_unverified"
+}
+declare const SourceRefSchema: z.ZodDiscriminatedUnion<"provider", [
+	z.ZodObject<{
+		provider: z.ZodLiteral<SourceProvider.GitHub>;
+		providerAccountId: z.ZodString;
+		providerRepositoryId: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		provider: SourceProvider.GitHub;
+		providerAccountId: string;
+		providerRepositoryId: string;
+	}, {
+		provider: SourceProvider.GitHub;
+		providerAccountId: string;
+		providerRepositoryId: string;
+	}>,
+	z.ZodObject<{
+		provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+		providerAccountId: z.ZodString;
+		providerRepositoryId: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		provider: SourceProvider.AzureDevOps;
+		providerAccountId: string;
+		providerRepositoryId: string;
+	}, {
+		provider: SourceProvider.AzureDevOps;
+		providerAccountId: string;
+		providerRepositoryId: string;
+	}>
+]>;
+export type SourceRef = z.infer<typeof SourceRefSchema>;
+declare const SourceIdentitySchema: z.ZodDiscriminatedUnion<"provider", [
+	z.ZodObject<{
+		namespace: z.ZodString;
+		name: z.ZodString;
+		provider: z.ZodLiteral<SourceProvider.GitHub>;
+		providerAccountId: z.ZodString;
+		providerRepositoryId: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		name: string;
+		provider: SourceProvider.GitHub;
+		providerAccountId: string;
+		providerRepositoryId: string;
+		namespace: string;
+	}, {
+		name: string;
+		provider: SourceProvider.GitHub;
+		providerAccountId: string;
+		providerRepositoryId: string;
+		namespace: string;
+	}>,
+	z.ZodObject<{
+		namespace: z.ZodString;
+		name: z.ZodString;
+		provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+		providerAccountId: z.ZodString;
+		providerRepositoryId: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		name: string;
+		provider: SourceProvider.AzureDevOps;
+		providerAccountId: string;
+		providerRepositoryId: string;
+		namespace: string;
+	}, {
+		name: string;
+		provider: SourceProvider.AzureDevOps;
+		providerAccountId: string;
+		providerRepositoryId: string;
+		namespace: string;
+	}>
+]>;
+export type SourceIdentity = z.infer<typeof SourceIdentitySchema>;
+declare const RunManifestV1Schema: z.ZodEffects<z.ZodObject<{
+	schemaVersion: z.ZodLiteral<1>;
+	runId: z.ZodString;
+	skyrampOrgId: z.ZodString;
+	target: z.ZodObject<{
+		id: z.ZodString;
+		revision: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		id: string;
+		revision: string;
+	}, {
+		id: string;
+		revision: string;
+	}>;
+	/** Null exactly for a trigger in POLICYLESS_TRIGGERS, such as `sut_setup`. */
+	policy: z.ZodNullable<z.ZodObject<{
+		id: z.ZodString;
+		revision: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		id: string;
+		revision: string;
+	}, {
+		id: string;
+		revision: string;
+	}>>;
+	trigger: z.ZodObject<{
+		kind: z.ZodNativeEnum<typeof TriggerKind>;
+		requestedAt: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		kind: TriggerKind;
+		requestedAt: string;
+	}, {
+		kind: TriggerKind;
+		requestedAt: string;
+	}>;
+	configuration: z.ZodObject<{
+		captureId: z.ZodString;
+		revision: z.ZodNullable<z.ZodString>;
+		hash: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		revision: string | null;
+		captureId: string;
+		hash: string;
+	}, {
+		revision: string | null;
+		captureId: string;
+		hash: string;
+	}>;
+	/**
+	 * The Confirmed Baseline the run compares with. A scheduled run that has one also names each source's revision
+	 * in it (SKYR-4582), and a Rerun of that run keeps them: the runner validates the delta since then. Absent on
+	 * every other manifest. `initialBaselineId` names an Initial Baseline in its place (SKYR-5225): the heads the app
+	 * saved, without a run, when the schedule was turned on or its setup changed. It is never validated. Absent
+	 * exactly on a `revision_read` manifest, which reads what that baseline is.
+	 */
+	baseline: z.ZodOptional<z.ZodObject<{
+		confirmedRunId: z.ZodNullable<z.ZodString>;
+		initialBaselineId: z.ZodOptional<z.ZodString>;
+		sources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+			repository: z.ZodDiscriminatedUnion<"provider", [
+				z.ZodObject<{
+					provider: z.ZodLiteral<SourceProvider.GitHub>;
+					providerAccountId: z.ZodString;
+					providerRepositoryId: z.ZodString;
+				}, "strict", z.ZodTypeAny, {
+					provider: SourceProvider.GitHub;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}, {
+					provider: SourceProvider.GitHub;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}>,
+				z.ZodObject<{
+					provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+					providerAccountId: z.ZodString;
+					providerRepositoryId: z.ZodString;
+				}, "strict", z.ZodTypeAny, {
+					provider: SourceProvider.AzureDevOps;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}, {
+					provider: SourceProvider.AzureDevOps;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}>
+			]>;
+			revision: z.ZodString;
+		}, "strict", z.ZodTypeAny, {
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			revision: string;
+		}, {
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			revision: string;
+		}>, "many">>;
+	}, "strict", z.ZodTypeAny, {
+		confirmedRunId: string | null;
+		initialBaselineId?: string | undefined;
+		sources?: {
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			revision: string;
+		}[] | undefined;
+	}, {
+		confirmedRunId: string | null;
+		initialBaselineId?: string | undefined;
+		sources?: {
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			revision: string;
+		}[] | undefined;
+	}>>;
+	sources: z.ZodArray<z.ZodObject<{
+		repository: z.ZodDiscriminatedUnion<"provider", [
+			z.ZodObject<{
+				namespace: z.ZodString;
+				name: z.ZodString;
+				provider: z.ZodLiteral<SourceProvider.GitHub>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				name: string;
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+				namespace: string;
+			}, {
+				name: string;
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+				namespace: string;
+			}>,
+			z.ZodObject<{
+				namespace: z.ZodString;
+				name: z.ZodString;
+				provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				name: string;
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+				namespace: string;
+			}, {
+				name: string;
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+				namespace: string;
+			}>
+		]>;
+		revision: z.ZodString;
+		ref: z.ZodNullable<z.ZodString>;
+		reason: z.ZodNativeEnum<typeof SelectionReason>;
+		change: z.ZodNullable<z.ZodObject<{
+			kind: z.ZodNativeEnum<typeof ChangeKind>;
+			number: z.ZodString;
+			base: z.ZodOptional<z.ZodObject<{
+				ref: z.ZodString;
+				revision: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				revision: string;
+				ref: string;
+			}, {
+				revision: string;
+				ref: string;
+			}>>;
+		}, "strict", z.ZodTypeAny, {
+			number: string;
+			kind: ChangeKind;
+			base?: {
+				revision: string;
+				ref: string;
+			} | undefined;
+		}, {
+			number: string;
+			kind: ChangeKind;
+			base?: {
+				revision: string;
+				ref: string;
+			} | undefined;
+		}>>;
+		compareWith: z.ZodOptional<z.ZodObject<{
+			ref: z.ZodString;
+			revision: z.ZodString;
+		}, "strict", z.ZodTypeAny, {
+			revision: string;
+			ref: string;
+		}, {
+			revision: string;
+			ref: string;
+		}>>;
+	}, "strict", z.ZodTypeAny, {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		reason: SelectionReason;
+		revision: string;
+		ref: string | null;
+		change: {
+			number: string;
+			kind: ChangeKind;
+			base?: {
+				revision: string;
+				ref: string;
+			} | undefined;
+		} | null;
+		compareWith?: {
+			revision: string;
+			ref: string;
+		} | undefined;
+	}, {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		reason: SelectionReason;
+		revision: string;
+		ref: string | null;
+		change: {
+			number: string;
+			kind: ChangeKind;
+			base?: {
+				revision: string;
+				ref: string;
+			} | undefined;
+		} | null;
+		compareWith?: {
+			revision: string;
+			ref: string;
+		} | undefined;
+	}>, "many">;
+	execution: z.ZodObject<{
+		provider: z.ZodNativeEnum<typeof SourceProvider>;
+		repository: z.ZodDiscriminatedUnion<"provider", [
+			z.ZodObject<{
+				namespace: z.ZodString;
+				name: z.ZodString;
+				provider: z.ZodLiteral<SourceProvider.GitHub>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				name: string;
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+				namespace: string;
+			}, {
+				name: string;
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+				namespace: string;
+			}>,
+			z.ZodObject<{
+				namespace: z.ZodString;
+				name: z.ZodString;
+				provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				name: string;
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+				namespace: string;
+			}, {
+				name: string;
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+				namespace: string;
+			}>
+		]>;
+		workflowPath: z.ZodString;
+		ref: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		provider: SourceProvider;
+		ref: string;
+		workflowPath: string;
+	}, {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		provider: SourceProvider;
+		ref: string;
+		workflowPath: string;
+	}>;
+	credentials: z.ZodArray<z.ZodObject<{
+		name: z.ZodString;
+		purpose: z.ZodNativeEnum<typeof CredentialPurpose>;
+		required: z.ZodBoolean;
+	}, "strict", z.ZodTypeAny, {
+		name: string;
+		purpose: CredentialPurpose;
+		required: boolean;
+	}, {
+		name: string;
+		purpose: CredentialPurpose;
+		required: boolean;
+	}>, "many">;
+	/** The Requirement references the run validates against (SKYR-4919). Absent on a run without them. */
+	requirements: z.ZodOptional<z.ZodArray<z.ZodUnion<[
+		z.ZodObject<{
+			source: z.ZodLiteral<RequirementItemSource.Jira>;
+			site: z.ZodString;
+			key: z.ZodString;
+			updated: z.ZodString;
+			contentHash: z.ZodString;
+		}, "strict", z.ZodTypeAny, {
+			site: string;
+			source: RequirementItemSource.Jira;
+			key: string;
+			updated: string;
+			contentHash: string;
+		}, {
+			site: string;
+			source: RequirementItemSource.Jira;
+			key: string;
+			updated: string;
+			contentHash: string;
+		}>,
+		z.ZodObject<{
+			source: z.ZodLiteral<RequirementItemSource.Confluence>;
+			site: z.ZodString;
+			key: z.ZodString;
+			version: z.ZodNumber;
+			contentHash: z.ZodString;
+		}, "strict", z.ZodTypeAny, {
+			site: string;
+			source: RequirementItemSource.Confluence;
+			key: string;
+			contentHash: string;
+			version: number;
+		}, {
+			site: string;
+			source: RequirementItemSource.Confluence;
+			key: string;
+			contentHash: string;
+			version: number;
+		}>,
+		z.ZodObject<{
+			source: z.ZodLiteral<RequirementItemSource.Other>;
+			key: z.ZodString;
+			contentHash: z.ZodString;
+		}, "strict", z.ZodTypeAny, {
+			source: RequirementItemSource.Other;
+			key: string;
+			contentHash: string;
+		}, {
+			source: RequirementItemSource.Other;
+			key: string;
+			contentHash: string;
+		}>,
+		z.ZodObject<{
+			source: z.ZodLiteral<RequirementItemSource.Other>;
+			key: z.ZodString;
+			contentHash: z.ZodString;
+			fileName: z.ZodString;
+			mediaType: z.ZodNativeEnum<typeof UploadedMediaType>;
+		}, "strict", z.ZodTypeAny, {
+			source: RequirementItemSource.Other;
+			key: string;
+			contentHash: string;
+			fileName: string;
+			mediaType: UploadedMediaType;
+		}, {
+			source: RequirementItemSource.Other;
+			key: string;
+			contentHash: string;
+			fileName: string;
+			mediaType: UploadedMediaType;
+		}>
+	]>, "many">>;
+	/**
+	 * The run has Instructions (SKYR-4925): the hash of their words only. The runner reads the words from the app
+	 * (RUNNER_PATHS.requirements). Absent on a run without them.
+	 */
+	instructions: z.ZodOptional<z.ZodObject<{
+		contentHash: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		contentHash: string;
+	}, {
+		contentHash: string;
+	}>>;
+	/**
+	 * What the scheduled run that a Rerun repeats validated of each source an existing component runs (SKYR-5225,
+	 * §6.2): the runner checks each out at exactly that revision, or ends the run blocked when the environment no
+	 * longer runs it. Only on a manual run, at most one per source. Absent when nothing is pinned.
+	 */
+	deployedRevisions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+		repository: z.ZodDiscriminatedUnion<"provider", [
+			z.ZodObject<{
+				provider: z.ZodLiteral<SourceProvider.GitHub>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}, {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}>,
+			z.ZodObject<{
+				provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}, {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}>
+		]>;
+		revision: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		} | {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		revision: string;
+	}, {
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		} | {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		revision: string;
+	}>, "many">>;
+}, "strict", z.ZodTypeAny, {
+	credentials: {
+		name: string;
+		purpose: CredentialPurpose;
+		required: boolean;
+	}[];
+	schemaVersion: 1;
+	sources: {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		reason: SelectionReason;
+		revision: string;
+		ref: string | null;
+		change: {
+			number: string;
+			kind: ChangeKind;
+			base?: {
+				revision: string;
+				ref: string;
+			} | undefined;
+		} | null;
+		compareWith?: {
+			revision: string;
+			ref: string;
+		} | undefined;
+	}[];
+	runId: string;
+	skyrampOrgId: string;
+	target: {
+		id: string;
+		revision: string;
+	};
+	policy: {
+		id: string;
+		revision: string;
+	} | null;
+	trigger: {
+		kind: TriggerKind;
+		requestedAt: string;
+	};
+	configuration: {
+		revision: string | null;
+		captureId: string;
+		hash: string;
+	};
+	execution: {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		provider: SourceProvider;
+		ref: string;
+		workflowPath: string;
+	};
+	instructions?: {
+		contentHash: string;
+	} | undefined;
+	baseline?: {
+		confirmedRunId: string | null;
+		initialBaselineId?: string | undefined;
+		sources?: {
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			revision: string;
+		}[] | undefined;
+	} | undefined;
+	requirements?: ({
+		site: string;
+		source: RequirementItemSource.Jira;
+		key: string;
+		updated: string;
+		contentHash: string;
+	} | {
+		site: string;
+		source: RequirementItemSource.Confluence;
+		key: string;
+		contentHash: string;
+		version: number;
+	} | {
+		source: RequirementItemSource.Other;
+		key: string;
+		contentHash: string;
+	} | {
+		source: RequirementItemSource.Other;
+		key: string;
+		contentHash: string;
+		fileName: string;
+		mediaType: UploadedMediaType;
+	})[] | undefined;
+	deployedRevisions?: {
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		} | {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		revision: string;
+	}[] | undefined;
+}, {
+	credentials: {
+		name: string;
+		purpose: CredentialPurpose;
+		required: boolean;
+	}[];
+	schemaVersion: 1;
+	sources: {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		reason: SelectionReason;
+		revision: string;
+		ref: string | null;
+		change: {
+			number: string;
+			kind: ChangeKind;
+			base?: {
+				revision: string;
+				ref: string;
+			} | undefined;
+		} | null;
+		compareWith?: {
+			revision: string;
+			ref: string;
+		} | undefined;
+	}[];
+	runId: string;
+	skyrampOrgId: string;
+	target: {
+		id: string;
+		revision: string;
+	};
+	policy: {
+		id: string;
+		revision: string;
+	} | null;
+	trigger: {
+		kind: TriggerKind;
+		requestedAt: string;
+	};
+	configuration: {
+		revision: string | null;
+		captureId: string;
+		hash: string;
+	};
+	execution: {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		provider: SourceProvider;
+		ref: string;
+		workflowPath: string;
+	};
+	instructions?: {
+		contentHash: string;
+	} | undefined;
+	baseline?: {
+		confirmedRunId: string | null;
+		initialBaselineId?: string | undefined;
+		sources?: {
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			revision: string;
+		}[] | undefined;
+	} | undefined;
+	requirements?: ({
+		site: string;
+		source: RequirementItemSource.Jira;
+		key: string;
+		updated: string;
+		contentHash: string;
+	} | {
+		site: string;
+		source: RequirementItemSource.Confluence;
+		key: string;
+		contentHash: string;
+		version: number;
+	} | {
+		source: RequirementItemSource.Other;
+		key: string;
+		contentHash: string;
+	} | {
+		source: RequirementItemSource.Other;
+		key: string;
+		contentHash: string;
+		fileName: string;
+		mediaType: UploadedMediaType;
+	})[] | undefined;
+	deployedRevisions?: {
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		} | {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		revision: string;
+	}[] | undefined;
+}>, {
+	credentials: {
+		name: string;
+		purpose: CredentialPurpose;
+		required: boolean;
+	}[];
+	schemaVersion: 1;
+	sources: {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		reason: SelectionReason;
+		revision: string;
+		ref: string | null;
+		change: {
+			number: string;
+			kind: ChangeKind;
+			base?: {
+				revision: string;
+				ref: string;
+			} | undefined;
+		} | null;
+		compareWith?: {
+			revision: string;
+			ref: string;
+		} | undefined;
+	}[];
+	runId: string;
+	skyrampOrgId: string;
+	target: {
+		id: string;
+		revision: string;
+	};
+	policy: {
+		id: string;
+		revision: string;
+	} | null;
+	trigger: {
+		kind: TriggerKind;
+		requestedAt: string;
+	};
+	configuration: {
+		revision: string | null;
+		captureId: string;
+		hash: string;
+	};
+	execution: {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		provider: SourceProvider;
+		ref: string;
+		workflowPath: string;
+	};
+	instructions?: {
+		contentHash: string;
+	} | undefined;
+	baseline?: {
+		confirmedRunId: string | null;
+		initialBaselineId?: string | undefined;
+		sources?: {
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			revision: string;
+		}[] | undefined;
+	} | undefined;
+	requirements?: ({
+		site: string;
+		source: RequirementItemSource.Jira;
+		key: string;
+		updated: string;
+		contentHash: string;
+	} | {
+		site: string;
+		source: RequirementItemSource.Confluence;
+		key: string;
+		contentHash: string;
+		version: number;
+	} | {
+		source: RequirementItemSource.Other;
+		key: string;
+		contentHash: string;
+	} | {
+		source: RequirementItemSource.Other;
+		key: string;
+		contentHash: string;
+		fileName: string;
+		mediaType: UploadedMediaType;
+	})[] | undefined;
+	deployedRevisions?: {
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		} | {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		revision: string;
+	}[] | undefined;
+}, {
+	credentials: {
+		name: string;
+		purpose: CredentialPurpose;
+		required: boolean;
+	}[];
+	schemaVersion: 1;
+	sources: {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		reason: SelectionReason;
+		revision: string;
+		ref: string | null;
+		change: {
+			number: string;
+			kind: ChangeKind;
+			base?: {
+				revision: string;
+				ref: string;
+			} | undefined;
+		} | null;
+		compareWith?: {
+			revision: string;
+			ref: string;
+		} | undefined;
+	}[];
+	runId: string;
+	skyrampOrgId: string;
+	target: {
+		id: string;
+		revision: string;
+	};
+	policy: {
+		id: string;
+		revision: string;
+	} | null;
+	trigger: {
+		kind: TriggerKind;
+		requestedAt: string;
+	};
+	configuration: {
+		revision: string | null;
+		captureId: string;
+		hash: string;
+	};
+	execution: {
+		repository: {
+			name: string;
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		} | {
+			name: string;
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+			namespace: string;
+		};
+		provider: SourceProvider;
+		ref: string;
+		workflowPath: string;
+	};
+	instructions?: {
+		contentHash: string;
+	} | undefined;
+	baseline?: {
+		confirmedRunId: string | null;
+		initialBaselineId?: string | undefined;
+		sources?: {
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			revision: string;
+		}[] | undefined;
+	} | undefined;
+	requirements?: ({
+		site: string;
+		source: RequirementItemSource.Jira;
+		key: string;
+		updated: string;
+		contentHash: string;
+	} | {
+		site: string;
+		source: RequirementItemSource.Confluence;
+		key: string;
+		contentHash: string;
+		version: number;
+	} | {
+		source: RequirementItemSource.Other;
+		key: string;
+		contentHash: string;
+	} | {
+		source: RequirementItemSource.Other;
+		key: string;
+		contentHash: string;
+		fileName: string;
+		mediaType: UploadedMediaType;
+	})[] | undefined;
+	deployedRevisions?: {
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		} | {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		revision: string;
+	}[] | undefined;
+}>;
+export type RunManifestV1 = z.infer<typeof RunManifestV1Schema>;
+/** What a V3 run uses in place of a license file while the app has licensing on. */
+export interface RunLicense {
+	/** The organization's entitlement codes. */
+	entitlements: string[];
+	/** What Skyramp core shows the app to get the codes. */
+	runToken: string;
+}
+declare enum RequesterKind {
+	Person = "person",
+	Policy = "policy"
+}
+declare const RequestedBySchema: z.ZodObject<{
+	kind: z.ZodNativeEnum<typeof RequesterKind>;
+	name: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+	name: string;
+	kind: RequesterKind;
+}, {
+	name: string;
+	kind: RequesterKind;
+}>;
+export type RequestedBy = z.infer<typeof RequestedBySchema>;
+declare const RunnerHandshakeRequestV1Schema: z.ZodObject<{
+	schemaVersion: z.ZodLiteral<1>;
+	runId: z.ZodString;
+	execution: z.ZodDiscriminatedUnion<"provider", [
+		z.ZodObject<{
+			provider: z.ZodLiteral<SourceProvider.GitHub>;
+			repository: z.ZodObject<{
+				provider: z.ZodLiteral<SourceProvider.GitHub>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}, {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}>;
+			providerRunId: z.ZodString;
+			providerRunAttempt: z.ZodNumber;
+			workflowRef: z.ZodString;
+		}, "strict", z.ZodTypeAny, {
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			provider: SourceProvider.GitHub;
+			providerRunId: string;
+			providerRunAttempt: number;
+			workflowRef: string;
+		}, {
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			provider: SourceProvider.GitHub;
+			providerRunId: string;
+			providerRunAttempt: number;
+			workflowRef: string;
+		}>,
+		z.ZodObject<{
+			provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+			repository: z.ZodObject<{
+				provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}, {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}>;
+			providerRunId: z.ZodString;
+			providerRunAttempt: z.ZodNumber;
+			workflowRef: z.ZodString;
+		}, "strict", z.ZodTypeAny, {
+			repository: {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			provider: SourceProvider.AzureDevOps;
+			providerRunId: string;
+			providerRunAttempt: number;
+			workflowRef: string;
+		}, {
+			repository: {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+			provider: SourceProvider.AzureDevOps;
+			providerRunId: string;
+			providerRunAttempt: number;
+			workflowRef: string;
+		}>
+	]>;
+	requester: z.ZodOptional<z.ZodLiteral<true>>;
+	writeCheck: z.ZodOptional<z.ZodLiteral<true>>;
+	claudeCodePin: z.ZodOptional<z.ZodLiteral<true>>;
+	deployedPins: z.ZodOptional<z.ZodLiteral<true>>;
+}, "strict", z.ZodTypeAny, {
+	schemaVersion: 1;
+	runId: string;
+	execution: {
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		provider: SourceProvider.GitHub;
+		providerRunId: string;
+		providerRunAttempt: number;
+		workflowRef: string;
+	} | {
+		repository: {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		provider: SourceProvider.AzureDevOps;
+		providerRunId: string;
+		providerRunAttempt: number;
+		workflowRef: string;
+	};
+	requester?: true | undefined;
+	writeCheck?: true | undefined;
+	claudeCodePin?: true | undefined;
+	deployedPins?: true | undefined;
+}, {
+	schemaVersion: 1;
+	runId: string;
+	execution: {
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		provider: SourceProvider.GitHub;
+		providerRunId: string;
+		providerRunAttempt: number;
+		workflowRef: string;
+	} | {
+		repository: {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		provider: SourceProvider.AzureDevOps;
+		providerRunId: string;
+		providerRunAttempt: number;
+		workflowRef: string;
+	};
+	requester?: true | undefined;
+	writeCheck?: true | undefined;
+	claudeCodePin?: true | undefined;
+	deployedPins?: true | undefined;
+}>;
+export type RunnerHandshakeRequestV1 = z.infer<typeof RunnerHandshakeRequestV1Schema>;
+declare const GeneratedTestDeliverySchema: z.ZodDiscriminatedUnion<"status", [
+	z.ZodObject<{
+		status: z.ZodLiteral<DeliveryStatus.None>;
+	}, "strict", z.ZodTypeAny, {
+		status: DeliveryStatus.None;
+	}, {
+		status: DeliveryStatus.None;
+	}>,
+	z.ZodObject<{
+		status: z.ZodLiteral<DeliveryStatus.Delivered>;
+		pullRequests: z.ZodArray<z.ZodObject<{
+			repository: z.ZodDiscriminatedUnion<"provider", [
+				z.ZodObject<{
+					provider: z.ZodLiteral<SourceProvider.GitHub>;
+					providerAccountId: z.ZodString;
+					providerRepositoryId: z.ZodString;
+				}, "strict", z.ZodTypeAny, {
+					provider: SourceProvider.GitHub;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}, {
+					provider: SourceProvider.GitHub;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}>,
+				z.ZodObject<{
+					provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+					providerAccountId: z.ZodString;
+					providerRepositoryId: z.ZodString;
+				}, "strict", z.ZodTypeAny, {
+					provider: SourceProvider.AzureDevOps;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}, {
+					provider: SourceProvider.AzureDevOps;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}>
+			]>;
+			number: z.ZodString;
+		}, "strict", z.ZodTypeAny, {
+			number: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}, {
+			number: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}>, "many">;
+	}, "strict", z.ZodTypeAny, {
+		status: DeliveryStatus.Delivered;
+		pullRequests: {
+			number: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}[];
+	}, {
+		status: DeliveryStatus.Delivered;
+		pullRequests: {
+			number: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}[];
+	}>,
+	z.ZodObject<{
+		status: z.ZodLiteral<DeliveryStatus.Partial>;
+		pullRequests: z.ZodArray<z.ZodObject<{
+			repository: z.ZodDiscriminatedUnion<"provider", [
+				z.ZodObject<{
+					provider: z.ZodLiteral<SourceProvider.GitHub>;
+					providerAccountId: z.ZodString;
+					providerRepositoryId: z.ZodString;
+				}, "strict", z.ZodTypeAny, {
+					provider: SourceProvider.GitHub;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}, {
+					provider: SourceProvider.GitHub;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}>,
+				z.ZodObject<{
+					provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+					providerAccountId: z.ZodString;
+					providerRepositoryId: z.ZodString;
+				}, "strict", z.ZodTypeAny, {
+					provider: SourceProvider.AzureDevOps;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}, {
+					provider: SourceProvider.AzureDevOps;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}>
+			]>;
+			number: z.ZodString;
+		}, "strict", z.ZodTypeAny, {
+			number: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}, {
+			number: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}>, "many">;
+		failures: z.ZodArray<z.ZodObject<{
+			repository: z.ZodDiscriminatedUnion<"provider", [
+				z.ZodObject<{
+					provider: z.ZodLiteral<SourceProvider.GitHub>;
+					providerAccountId: z.ZodString;
+					providerRepositoryId: z.ZodString;
+				}, "strict", z.ZodTypeAny, {
+					provider: SourceProvider.GitHub;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}, {
+					provider: SourceProvider.GitHub;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}>,
+				z.ZodObject<{
+					provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+					providerAccountId: z.ZodString;
+					providerRepositoryId: z.ZodString;
+				}, "strict", z.ZodTypeAny, {
+					provider: SourceProvider.AzureDevOps;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}, {
+					provider: SourceProvider.AzureDevOps;
+					providerAccountId: string;
+					providerRepositoryId: string;
+				}>
+			]>;
+			message: z.ZodString;
+		}, "strict", z.ZodTypeAny, {
+			message: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}, {
+			message: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}>, "many">;
+	}, "strict", z.ZodTypeAny, {
+		status: DeliveryStatus.Partial;
+		pullRequests: {
+			number: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}[];
+		failures: {
+			message: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}[];
+	}, {
+		status: DeliveryStatus.Partial;
+		pullRequests: {
+			number: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}[];
+		failures: {
+			message: string;
+			repository: {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			} | {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			};
+		}[];
+	}>,
+	z.ZodObject<{
+		status: z.ZodLiteral<DeliveryStatus.Failed>;
+		message: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		status: DeliveryStatus.Failed;
+		message: string;
+	}, {
+		status: DeliveryStatus.Failed;
+		message: string;
+	}>
+]>;
+export type GeneratedTestDelivery = z.infer<typeof GeneratedTestDeliverySchema>;
+declare enum GitHubWriteKind {
+	BranchPushed = "branch_pushed",
+	PullRequestOpened = "pull_request_opened",
+	PullRequestEdited = "pull_request_edited"
+}
+declare const GitHubWriteSchema: z.ZodDiscriminatedUnion<"kind", [
+	z.ZodObject<{
+		kind: z.ZodLiteral<GitHubWriteKind.BranchPushed>;
+		repository: z.ZodDiscriminatedUnion<"provider", [
+			z.ZodObject<{
+				provider: z.ZodLiteral<SourceProvider.GitHub>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}, {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}>,
+			z.ZodObject<{
+				provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}, {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}>
+		]>;
+		branch: z.ZodString;
+		commit: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		} | {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		kind: GitHubWriteKind.BranchPushed;
+		branch: string;
+		commit: string;
+	}, {
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		} | {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		kind: GitHubWriteKind.BranchPushed;
+		branch: string;
+		commit: string;
+	}>,
+	z.ZodObject<{
+		kind: z.ZodEnum<[
+			GitHubWriteKind.PullRequestOpened,
+			GitHubWriteKind.PullRequestEdited
+		]>;
+		repository: z.ZodDiscriminatedUnion<"provider", [
+			z.ZodObject<{
+				provider: z.ZodLiteral<SourceProvider.GitHub>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}, {
+				provider: SourceProvider.GitHub;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}>,
+			z.ZodObject<{
+				provider: z.ZodLiteral<SourceProvider.AzureDevOps>;
+				providerAccountId: z.ZodString;
+				providerRepositoryId: z.ZodString;
+			}, "strict", z.ZodTypeAny, {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}, {
+				provider: SourceProvider.AzureDevOps;
+				providerAccountId: string;
+				providerRepositoryId: string;
+			}>
+		]>;
+		number: z.ZodString;
+		branch: z.ZodString;
+	}, "strict", z.ZodTypeAny, {
+		number: string;
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		} | {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		kind: GitHubWriteKind.PullRequestOpened | GitHubWriteKind.PullRequestEdited;
+		branch: string;
+	}, {
+		number: string;
+		repository: {
+			provider: SourceProvider.GitHub;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		} | {
+			provider: SourceProvider.AzureDevOps;
+			providerAccountId: string;
+			providerRepositoryId: string;
+		};
+		kind: GitHubWriteKind.PullRequestOpened | GitHubWriteKind.PullRequestEdited;
+		branch: string;
+	}>
+]>;
+export type GitHubWrite = z.infer<typeof GitHubWriteSchema>;
+declare const AttemptHeartbeatV1Schema: z.ZodObject<{
+	schemaVersion: z.ZodLiteral<1>;
+	state: z.ZodNativeEnum<typeof AttemptState>;
+	ending: z.ZodNullable<z.ZodNativeEnum<typeof AttemptEndReason>>;
+	cause: z.ZodNullable<z.ZodNativeEnum<typeof NoReportCause>>;
+	deadlineAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+	schemaVersion: 1;
+	state: AttemptState;
+	deadlineAt: string;
+	ending: AttemptEndReason | null;
+	cause: NoReportCause | null;
+}, {
+	schemaVersion: 1;
+	state: AttemptState;
+	deadlineAt: string;
+	ending: AttemptEndReason | null;
+	cause: NoReportCause | null;
+}>;
+export type AttemptHeartbeatV1 = z.infer<typeof AttemptHeartbeatV1Schema>;
+declare enum AttemptClosure {
+	Cancelled = "cancelled",
+	Expired = "expired",
+	Ended = "ended"
+}
+declare enum CommitLookup {
+	Found = "found",
+	Missing = "missing",
+	/** GitHub gave no answer. */
+	Unknown = "unknown"
+}
+/** One pull request of the Change Set, as the session reads it. */
+export interface ChangeSetPullRequest {
+	/** owner/repo. */
+	repository: string;
+	number: string;
+	title?: string;
+	body?: string;
+	/** Why the title and description are missing. */
+	note?: string;
+	/** Whether GitHub says the PR is merged. Absent when the PR could not be read. */
+	merged?: boolean;
+	/**
+	 * The commit the merge made, only for a merged PR. On an open PR GitHub fills `merge_commit_sha` with its test merge
+	 * commit, which no deployment runs.
+	 */
+	mergeCommit?: string;
+	/** The head commit the PR merged, only for a merged PR. */
+	mergedHead?: string;
+}
+/** A repository as a V3 source names it. */
+export interface SourceName {
+	namespace: string;
+	name: string;
+}
+/** A direct REST call to the job's source host: the token, minted only when the call is made, and the fetch to use. */
+export interface SourceCall {
+	token: () => Promise<string>;
+	fetch: typeof fetch;
+}
+declare enum CiPlatform {
+	GitHub = "github",
+	Azure = "azure"
+}
+/** A token a cloud role (Bedrock's) trusts, minted by the job. */
+export interface WebIdentity {
+	token(audience: string): Promise<string>;
+	/** The CI run's id, which names the role session. */
+	runId?: string;
+}
+export interface RunnerHost {
+	/** The --runner-platform this job selects when none is named; undefined outside a CI job. */
+	readonly runnerPlatform?: CiPlatform;
+	/** The job's workspace, where its checkouts are; undefined when the job names none. */
+	readonly workspace?: string;
+	/** The web base of the source host the job runs on: clone URLs and the scope of a persisted auth header. */
+	readonly serverUrl: string;
+	/** The REST API base of that host. */
+	readonly apiUrl: string;
+	/** The repository the job runs in, when the job names it. */
+	readonly repository?: {
+		id: string;
+		slug: string;
+	};
+	/** The CI run, its attempt and the job, when known: artifact names. */
+	readonly runId?: string;
+	readonly runAttempt?: string;
+	readonly job?: string;
+	/** Where the V3 handshake says this job runs. The app compares every field with the job's identity token. Throws when the job does not say. */
+	execution(): RunnerHandshakeRequestV1["execution"];
+	/**
+	 * Takes the job's identity-token credentials out of the environment and returns the only way left to mint a token
+	 * for an audience. Every process the run starts inherits process.env; with those credentials, code in any of them
+	 * could repeat the handshake.
+	 */
+	takeIdToken(): (audience: string) => Promise<string>;
+	/**
+	 * Takes the job's own token for its source host out of the environment and returns it: Azure DevOps's
+	 * System.AccessToken, which reaches the repositories the pipeline checked out. Absent where the app mints scoped tokens
+	 * instead (GitHub).
+	 */
+	takeSourceToken?(): string | undefined;
+	/** The job's web identity for a cloud role, or undefined when the job can mint none. Read when called. */
+	webIdentity(): WebIdentity | undefined;
+	/** Whether the job runs only the V3 runs the app starts: their main step uploads its files and ends its reporting. */
+	readonly v3RunsOnly: boolean;
+	/** Whether the engine assumes the Bedrock role with the job's OIDC token, because the job has no AWS step of its own. */
+	readonly assumesBedrockRole: boolean;
+	/** Whether the Skyramp MCP server needs the run's repository and provider: the job's env names neither. */
+	readonly namesSourceToMcp: boolean;
+	/** Throws when `repository` cannot be a repository on this host: its names go into paths and URLs. */
+	checkSourceName(repository: SourceName): void;
+	/** The clone URL of `repository`, which is also where gitAuthEnv sends the token. */
+	cloneUrl(repository: SourceName): string;
+	/** git's environment for one fetch from this host with `token`, which never reaches argv or git config. */
+	gitAuthEnv(token: string): Record<string, string>;
+	/** A pull request's title, description and, once merged, its merge commit and the head it merged. Throws when it cannot be read. */
+	pullRequest(repository: SourceName, number: string, call: SourceCall): Promise<Omit<ChangeSetPullRequest, "repository" | "number">>;
+	/** The full commit that `ref` names in `repository`, by its slug, or why the host answers none. */
+	commit(repository: string, ref: string, call: SourceCall): Promise<{
+		sha: string;
+	} | {
+		lookup: CommitLookup.Missing | CommitLookup.Unknown;
+	}>;
+	/** Revokes a token the app minted for this job. Absent where the job's token is its own and ends with the job. */
+	revokeToken?(token: string, fetchImpl: typeof fetch): Promise<void>;
+}
+export interface V3RunnerDeps {
+	/** The application origin, which is also the OIDC audience. */
+	origin: string;
+	/** A GitHub Actions OIDC token for the audience. */
+	idToken: (audience: string) => Promise<string>;
+	fetch?: typeof fetch;
+	now?: () => Date;
+	/** Masks a credential in the job log (core.setSecret), and receives each new token. */
+	mask?: (value: string) => void;
+	/** Writes one line to the job log (core.info). */
+	log?: (line: string) => void;
+	/** Pause between retries of a call the app did not answer (default 2 s, then 4 s). */
+	retryDelayMs?: number;
+	/**
+	 * The job's own token for its source host (RunnerHost.takeSourceToken): on Azure DevOps, System.AccessToken. The app
+	 * gives such a job no token, so the attempt uses this one for its sources.
+	 */
+	sourceToken?: string;
+}
+declare enum RunnerMethod {
+	Get = "GET",
+	Post = "POST",
+	Put = "PUT"
+}
+/** How a direct REST call to the source host is made: the fetch to use, and the job's host, which makes the call. */
+export interface SourceRestOptions {
+	fetch?: typeof fetch;
+	host?: Pick<RunnerHost, "pullRequest" | "commit" | "revokeToken" | "cloneUrl" | "gitAuthEnv">;
+}
+/** A refusal the app answered, which a retry would only repeat. */
+export declare class AppRefusal extends Error {
+	readonly status: number;
+	readonly code?: string | undefined;
+	constructor(message: string, status: number, code?: string | undefined);
+}
+/** The app did not answer on any try: a network error, a timeout, a 5xx or a 429. Trying again later may work. */
+export declare class AppUnreachable extends Error {
+}
+/** One Execution attempt of a Validation Run, bound by the handshake. */
+export declare class V3Attempt {
+	readonly attemptId: string;
+	readonly attemptNumber: number;
+	readonly deadlineAt: Date;
+	readonly manifest: RunManifestV1;
+	private readonly deps;
+	/** Absent while the app has licensing off: the run then uses the license file. */
+	readonly license?: RunLicense | undefined;
+	/** Who the run was started for. Absent when the app does not know. */
+	readonly requestedBy?: RequestedBy | undefined;
+	/** Whether the run's person may push to every source (SKYR-4882). Absent when the app did not say. */
+	readonly writeAllowed?: boolean | undefined;
+	/** The exact Claude Code version the organization pins (SKYR-5143). Absent: the latest. */
+	readonly claudeCodeVersion?: string | undefined;
+	/**
+	 * What an earlier attempt of this scheduled run read of each deployed source, which pins this attempt as a Rerun's
+	 * `deployedRevisions` pins it (ADR-0011). Empty when none did, or when the app did not say.
+	 */
+	readonly deployedPins: readonly {
+		repository: SourceRef;
+		revision: string;
+	}[];
+	constructor(attemptId: string, attemptNumber: number, deadlineAt: Date, manifest: RunManifestV1, deps: V3RunnerDeps, 
+	/** Absent while the app has licensing off: the run then uses the license file. */
+	license?: RunLicense | undefined, 
+	/** Who the run was started for. Absent when the app does not know. */
+	requestedBy?: RequestedBy | undefined, 
+	/** Whether the run's person may push to every source (SKYR-4882). Absent when the app did not say. */
+	writeAllowed?: boolean | undefined, 
+	/** The exact Claude Code version the organization pins (SKYR-5143). Absent: the latest. */
+	claudeCodeVersion?: string | undefined, 
+	/**
+	 * What an earlier attempt of this scheduled run read of each deployed source, which pins this attempt as a Rerun's
+	 * `deployedRevisions` pins it (ADR-0011). Empty when none did, or when the app did not say.
+	 */
+	deployedPins?: readonly {
+		repository: SourceRef;
+		revision: string;
+	}[]);
+	/**
+	 * The run's budget, from now: the time to the attempt deadline, less the post step's reserve. The app fixed the
+	 * deadline from the execution timeout it froze, so the `testbotTimeout` input has no say in a V3 run.
+	 */
+	budgetMs(now: Date): number;
+	/** The run's page in the app (skyrampRunPageUrl). */
+	get skyrampRunUrl(): string;
+	/** One call to an attempt route of the app. */
+	send<T>(method: RunnerMethod, route: string, body: unknown): Promise<T>;
+	/** One read of an attempt route that answers bytes (callAppBytes). */
+	readBytes(route: string, maxBytes: number): Promise<Buffer>;
+	/** Every scoped token this attempt received, for scrubbing what it uploads. */
+	readonly issuedTokens: string[];
+	/** Why the app no longer holds this attempt open, once a heartbeat said so. */
+	closure?: AttemptClosure;
+	/** The model provider key the first credentials answer carried, if any. A renewal never changes it. */
+	modelKey?: string;
+	/** The current credentials of each kind, kept and renewed apart. */
+	private readonly credentials;
+	/** The one revocation, which a later caller waits for. Once it started, the attempt mints no more tokens. */
+	private revocation?;
+	/**
+	 * A GitHub token scoped to the run's frozen sources. Concurrent callers share one request. It is renewed once less
+	 * than ten minutes of it are left: an installation token lives one hour, and a run can last longer. The first answer
+	 * also gives the attempt its modelKey.
+	 */
+	token(): Promise<string>;
+	/**
+	 * A GitHub token that only reads the run's frozen sources (`contents: read`), whoever started the run, kept and
+	 * renewed apart from `token()`. A Test Environment's deployed-revisions.sh runs with it, the scope its setup checked
+	 * it with (SKYR-5183). Fails when the app's answer grants anything more: the caller then has no token, never a wider one.
+	 * On Azure DevOps the app mints no token, so it is the job's own, as for `token()` and as in the setup's check.
+	 */
+	readOnlyToken(): Promise<string>;
+	private cachedToken;
+	/** The job's own source token, used where the app's answer carries none. */
+	private jobToken;
+	/**
+	 * The fetch of a direct REST call to the source host (GitHub, or Azure DevOps): the caller's, else the attempt's
+	 * (V3RunnerDeps), else the global one. The attempt's is the hook an eval of the runner fakes the app with, so the eval
+	 * records these calls, and a fake token never reaches the host. The action gives neither, and calls the host.
+	 */
+	sourceFetch(options: SourceRestOptions): typeof fetch;
+	/**
+	 * Revokes every token this attempt minted, each with its own credentials (DELETE /installation/token), and mints
+	 * no more. Otherwise a token that leaked during the run stays usable for up to an hour after the job ends. The
+	 * tokens it holds go at once, in parallel, and a token still being minted goes when it lands: a workflow cancel
+	 * leaves about 7.5 s before the runner's next signal ends the process. A token GitHub no longer accepts (401) has
+	 * expired, and counts as revoked. Never throws: it returns what failed, without the token. A later call waits for
+	 * the first, and gets the same answer.
+	 *
+	 * A direct REST call, like changeSetPullRequests: the main step makes it after the driver is done, with each token's
+	 * own credentials, which no RunnerPlatform method takes. It goes through sourceFetch.
+	 */
+	revokeTokens(options?: SourceRestOptions): Promise<string[]>;
+	private revokeIssued;
+	/** Revokes one token; returns why it failed, naming the token by its place, or nothing. */
+	private revokeOne;
+}
+/** The handshake. Refuses a manifest whose hash does not match, that names another run, or a source on another provider. */
+export declare function startV3Attempt(runId: string, host: Pick<RunnerHost, "execution">, deps: V3RunnerDeps): Promise<V3Attempt>;
+/** The attempt as the app holds it. */
+export declare function heartbeatV3Attempt(attempt: V3Attempt): Promise<AttemptHeartbeatV1>;
+/**
+ * Why the app closed the attempt, or null while it holds it open: what a heartbeat said, else one heartbeat now. A
+ * heartbeat the app did not answer says nothing, so the caller goes on; the app still refuses what a closed attempt sends.
+ */
+export declare function closedV3Attempt(attempt: V3Attempt, now?: () => Date): Promise<AttemptClosure | null>;
+/** One frozen source, checked out for this attempt. */
+export interface CheckedOutSource {
+	repository: SourceIdentity;
+	/** What `git rev-parse HEAD` says after the checkout: the provenance the report sends. */
+	revision: string;
+	path: string;
+	/** `namespace/name`, as the staged report names repositories. */
+	slug: string;
+}
+/** Sends the report once. Throws with the refused field named, before the app would refuse it. */
+export declare function uploadV3Report(attempt: V3Attempt, input: {
+	report: StagedTestbotReport;
+	sources: CheckedOutSource[];
+	/** The run compared with no Confirmed Baseline, though its manifest names one (checkoutSources). */
+	firstQualification?: boolean;
+	/** The working checkout's slug: where a result that names no repository lives. */
+	workingSlug: string;
+	delivery: GeneratedTestDelivery;
+	producer: {
+		testbot: string;
+		mcp: string;
+	};
+	/** Other secret values the run held, such as the credential references' values. */
+	secrets?: readonly string[];
+	/** What the run wrote to GitHub (githubWritesFromOutputs). */
+	githubWrites?: GitHubWrite[];
+}): Promise<void>;
+/** Why the attempt ended without a report: a cancellation, or one of the contract's causes. */
+export type V3EndCause = AttemptEndReason.Cancelled | NoReportCause;
+/** What the main step learned about the attempt, which the post step turns into the attempt end. */
+export interface V3AttemptState {
+	attemptId: string;
+	reportUploaded: boolean;
+	/** A `sut_setup` run's SUT recipe reached the app. */
+	recipeUploaded?: boolean;
+	/** A `revision_read` run read every component, and its upload reached the app (SKYR-5225). */
+	revisionsUploaded?: boolean;
+	/** None recorded: the agent stopped without a report for a reason the main step did not see. */
+	cause?: V3EndCause;
+}
+/**
+ * The attempt end, sent by the post step. The app derives the outcome from it and from the accepted report; the
+ * `outcome` it answers is the app's value, only logged here, so it stays the app's string rather than a runner enum.
+ */
+export declare function endV3Attempt(state: V3AttemptState, deps: V3RunnerDeps): Promise<{
+	outcome: string | null;
+}>;
+
+declare namespace z {
+	export { AnyZodObject, AnyZodTuple, ArrayCardinality, ArrayKeys, AssertArray, AsyncParseReturnType, BRAND, CatchallInput, CatchallOutput, CustomErrorParams, DIRTY, DenormalizedError, EMPTY_PATH, Effect, EnumLike, EnumValues, ErrorMapCtx, FilterEnum, INVALID, Indices, InnerTypeOfFunction, InputTypeOfTuple, InputTypeOfTupleWithRest, IpVersion, IssueData, KeySchema, NEVER, OK, ObjectPair, OuterTypeOfFunction, OutputTypeOfTuple, OutputTypeOfTupleWithRest, ParseContext, ParseInput, ParseParams, ParsePath, ParsePathComponent, ParseResult, ParseReturnType, ParseStatus, PassthroughType, PreprocessEffect, Primitive, ProcessedCreateParams, RawCreateParams, RecordType, Refinement, RefinementCtx, RefinementEffect, SafeParseError, SafeParseReturnType, SafeParseSuccess, Scalars, SomeZodObject, StringValidation, SuperRefinement, SyncParseReturnType, TransformEffect, TypeOf, TypeOf as infer, UnknownKeysParam, Values, Writeable, ZodAny, ZodAnyDef, ZodArray, ZodArrayDef, ZodBigInt, ZodBigIntCheck, ZodBigIntDef, ZodBoolean, ZodBooleanDef, ZodBranded, ZodBrandedDef, ZodCatch, ZodCatchDef, ZodCustomIssue, ZodDate, ZodDateCheck, ZodDateDef, ZodDefault, ZodDefaultDef, ZodDiscriminatedUnion, ZodDiscriminatedUnionDef, ZodDiscriminatedUnionOption, ZodEffects, ZodEffects as ZodTransformer, ZodEffectsDef, ZodEnum, ZodEnumDef, ZodError, ZodErrorMap, ZodFirstPartySchemaTypes, ZodFirstPartyTypeKind, ZodFormattedError, ZodFunction, ZodFunctionDef, ZodIntersection, ZodIntersectionDef, ZodInvalidArgumentsIssue, ZodInvalidDateIssue, ZodInvalidEnumValueIssue, ZodInvalidIntersectionTypesIssue, ZodInvalidLiteralIssue, ZodInvalidReturnTypeIssue, ZodInvalidStringIssue, ZodInvalidTypeIssue, ZodInvalidUnionDiscriminatorIssue, ZodInvalidUnionIssue, ZodIssue, ZodIssueBase, ZodIssueCode, ZodIssueOptionalMessage, ZodLazy, ZodLazyDef, ZodLiteral, ZodLiteralDef, ZodMap, ZodMapDef, ZodNaN, ZodNaNDef, ZodNativeEnum, ZodNativeEnumDef, ZodNever, ZodNeverDef, ZodNonEmptyArray, ZodNotFiniteIssue, ZodNotMultipleOfIssue, ZodNull, ZodNullDef, ZodNullable, ZodNullableDef, ZodNullableType, ZodNumber, ZodNumberCheck, ZodNumberDef, ZodObject, ZodObjectDef, ZodOptional, ZodOptionalDef, ZodOptionalType, ZodParsedType, ZodPipeline, ZodPipelineDef, ZodPromise, ZodPromiseDef, ZodRawShape, ZodReadonly, ZodReadonlyDef, ZodRecord, ZodRecordDef, ZodSet, ZodSetDef, ZodString, ZodStringCheck, ZodStringDef, ZodSymbol, ZodSymbolDef, ZodTooBigIssue, ZodTooSmallIssue, ZodTuple, ZodTupleDef, ZodTupleItems, ZodType, ZodType as Schema, ZodType as ZodSchema, ZodTypeAny, ZodTypeDef, ZodUndefined, ZodUndefinedDef, ZodUnion, ZodUnionDef, ZodUnionOptions, ZodUnknown, ZodUnknownDef, ZodUnrecognizedKeysIssue, ZodVoid, ZodVoidDef, addIssueToContext, anyType as any, arrayOutputType, arrayType as array, baseObjectInputType, baseObjectOutputType, bigIntType as bigint, booleanType as boolean, coerce, custom, dateType as date, datetimeRegex, deoptional, discriminatedUnionType as discriminatedUnion, effectsType as effect, effectsType as transformer, enumType as enum, errorMap as defaultErrorMap, functionType as function, getErrorMap, getParsedType, inferFlattenedErrors, inferFormattedError, input, instanceOfType as instanceof, intersectionType as intersection, isAborted, isAsync, isDirty, isValid, late, lazyType as lazy, literalType as literal, makeIssue, mapType as map, mergeTypes, nanType as nan, nativeEnumType as nativeEnum, neverType as never, noUnrecognized, nullType as null, nullableType as nullable, numberType as number, objectInputType, objectOutputType, objectType as object, objectUtil, oboolean, onumber, optionalType as optional, ostring, output, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, quotelessJson, recordType as record, setErrorMap, setType as set, strictObjectType as strictObject, stringType as string, symbolType as symbol, tupleType as tuple, typeToFlattenedError, typecast, undefinedType as undefined, unionType as union, unknownType as unknown, util, voidType as void };
+}
+
+export {};