storybook 10.1.0-alpha.8 → 10.1.0-beta.0

package/dist/manager-api/index.d.ts

@@ -391,7 +391,6 @@ interface SubState$5 {
     settings: API_Settings;
 }
 
-declare const isMacLike: () => boolean;
 declare const controlOrMetaSymbol: () => "⌘" | "ctrl";
 declare const controlOrMetaKey: () => "meta" | "control";
 declare const optionOrAltSymbol: () => "⌥" | "alt";
@@ -400,8 +399,15 @@ type KeyboardEventLike = Pick<KeyboardEvent, 'altKey' | 'ctrlKey' | 'metaKey' |
 declare const eventToShortcut: (e: KeyboardEventLike) => (string | string[])[] | null;
 declare const shortcutMatchesShortcut: (inputShortcut: (string | string[])[], shortcut: API_KeyCollection) => boolean;
 declare const eventMatchesShortcut: (e: KeyboardEventLike, shortcut: API_KeyCollection) => boolean;
+/**
+ * Returns a human-readable symbol for a keyboard key.
+ *
+ * @param key The key to convert to a symbol.
+ * @returns A string that a human could understand as that keyboard key.
+ */
 declare const keyToSymbol: (key: string) => string;
 declare const shortcutToHumanString: (shortcut: API_KeyCollection) => string;
+declare const shortcutToAriaKeyshortcuts: (shortcut: API_KeyCollection) => string;
 
 interface SubState$4 {
     shortcuts: API_Shortcuts;
@@ -556,6 +562,13 @@ interface SubAPI$3 {
      * @returns {API_LeafEntry} The current story's data.
      */
     getCurrentStoryData: () => API_LeafEntry;
+    /**
+     * Returns the current story index.
+     *
+     * @returns {API_PreparedStoryIndex | undefined} The current story index, or undefined if not yet
+     *   loaded.
+     */
+    getIndex: () => API_PreparedStoryIndex | undefined;
     /**
      * Sets the prepared story index to the given value.
      *
@@ -798,9 +811,15 @@ interface SubAPI$1 {
     /**
      * Returns the URL of the Storybook documentation for the current version.
      *
+     * @param options - The options for the documentation URL.
+     * @param options.asset - Links to the docs-assets directory instead of docs.
+     * @param options.subpath - The subpath of the documentation URL.
+     * @param options.versioned - Whether to include the versioned path.
+     * @param options.renderer - Whether to include the renderer path.
      * @returns {string} The URL of the Storybook Manager documentation.
      */
     getDocsUrl: (options: {
+        asset?: boolean;
         subpath?: string;
         versioned?: boolean;
         renderer?: boolean;
@@ -828,6 +847,8 @@ declare class RequestResponseError<Payload extends Record<string, any> | void> e
 }
 declare const experimental_requestResponse: <RequestPayload, ResponsePayload = void, CreateNewStoryErrorPayload extends Record<string, any> | void = void>(channel: Channel, requestEvent: string, responseEvent: string, payload: RequestPayload, timeout?: number) => Promise<ResponsePayload>;
 
+declare const isMacLike: () => boolean;
+
 declare const _default: <TObj = any>(a: TObj, ...b: Partial<TObj>[]) => TObj;
 
 declare const ActiveTabs: {
@@ -2026,4 +2047,1792 @@ declare const getTestProviderStoreById: (testProviderId: TestProviderId) => Test
 declare const useTestProviderStore: UseTestProviderStore;
 declare const universalTestProviderStore: UniversalStore<TestProviderStateByProviderId, TestProviderStoreEvent>;
 
-export { type API, type API_EventMap, ActiveTabs, AddonStore, type Combo, ManagerConsumer as Consumer, type KeyboardEventLike, ManagerContext, type ManagerProviderProps, ManagerProvider as Provider, RequestResponseError, type State, type Options as StoreOptions, addons, combineParameters, controlOrMetaKey, controlOrMetaSymbol, eventMatchesShortcut, eventToShortcut, MockUniversalStore as experimental_MockUniversalStore, UniversalStore as experimental_UniversalStore, getStatusStoreByTypeId as experimental_getStatusStore, getTestProviderStoreById as experimental_getTestProviderStore, experimental_requestResponse, useStatusStore as experimental_useStatusStore, useTestProviderStore as experimental_useTestProviderStore, useUniversalStore as experimental_useUniversalStore, fullStatusStore as internal_fullStatusStore, fullTestProviderStore as internal_fullTestProviderStore, universalStatusStore as internal_universalStatusStore, universalTestProviderStore as internal_universalTestProviderStore, isMacLike, isShortcutTaken, keyToSymbol, _default as merge, mockChannel, optionOrAltSymbol, shortcutMatchesShortcut, shortcutToHumanString, typesX as types, useAddonState, useArgTypes, useArgs, useChannel, useGlobalTypes, useGlobals, useParameter, useSharedState, useStoryPrepared, useStorybookApi, useStorybookState };
+type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+
+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";
+};
+type ZodParsedType = keyof typeof ZodParsedType;
+
+type allKeys<T> = T extends any ? keyof T : never;
+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";
+};
+type ZodIssueCode = keyof typeof ZodIssueCode;
+type ZodIssueBase = {
+    path: (string | number)[];
+    message?: string | undefined;
+};
+interface ZodInvalidTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_type;
+    expected: ZodParsedType;
+    received: ZodParsedType;
+}
+interface ZodInvalidLiteralIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_literal;
+    expected: unknown;
+    received: unknown;
+}
+interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.unrecognized_keys;
+    keys: string[];
+}
+interface ZodInvalidUnionIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union;
+    unionErrors: ZodError[];
+}
+interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union_discriminator;
+    options: Primitive[];
+}
+interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+    received: string | number;
+    code: typeof ZodIssueCode.invalid_enum_value;
+    options: (string | number)[];
+}
+interface ZodInvalidArgumentsIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_arguments;
+    argumentsError: ZodError;
+}
+interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_return_type;
+    returnTypeError: ZodError;
+}
+interface ZodInvalidDateIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_date;
+}
+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;
+};
+interface ZodInvalidStringIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_string;
+    validation: StringValidation;
+}
+interface ZodTooSmallIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_small;
+    minimum: number | bigint;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+interface ZodTooBigIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_big;
+    maximum: number | bigint;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date" | "bigint";
+}
+interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_intersection_types;
+}
+interface ZodNotMultipleOfIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_multiple_of;
+    multipleOf: number | bigint;
+}
+interface ZodNotFiniteIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_finite;
+}
+interface ZodCustomIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.custom;
+    params?: {
+        [k: string]: any;
+    };
+}
+type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+type ZodIssue = ZodIssueOptionalMessage & {
+    fatal?: boolean | undefined;
+    message: string;
+};
+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;
+type ZodFormattedError<T, U = string> = {
+    _errors: U[];
+} & recursiveZodFormattedError<NonNullable<T>>;
+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>;
+}
+type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+type IssueData = stripPath<ZodIssueOptionalMessage> & {
+    path?: (string | number)[];
+    fatal?: boolean | undefined;
+};
+type ErrorMapCtx = {
+    defaultError: string;
+    data: any;
+};
+type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+    message: string;
+};
+
+type ParseParams = {
+    path: (string | number)[];
+    errorMap: ZodErrorMap;
+    async: boolean;
+};
+type ParsePathComponent = string | number;
+type ParsePath = ParsePathComponent[];
+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;
+}
+type ParseInput = {
+    data: any;
+    path: (string | number)[];
+    parent: ParseContext;
+};
+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;
+}
+type INVALID = {
+    status: "aborted";
+};
+declare const INVALID: INVALID;
+type DIRTY<T> = {
+    status: "dirty";
+    value: T;
+};
+declare const DIRTY: <T>(value: T) => DIRTY<T>;
+type OK<T> = {
+    status: "valid";
+    value: T;
+};
+declare const OK: <T>(value: T) => OK<T>;
+type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
+type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
+type ParseReturnType<T> = SyncParseReturnType<T> | 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.
+ */
+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 {  };
+}
+
+interface RefinementCtx {
+    addIssue: (arg: IssueData) => void;
+    path: (string | number)[];
+}
+type ZodRawShape = {
+    [k: string]: ZodTypeAny;
+};
+type ZodTypeAny = ZodType<any, any, any>;
+type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
+type input<T extends ZodType<any, any, any>> = T["_input"];
+type output<T extends ZodType<any, any, any>> = T["_output"];
+
+type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
+interface ZodTypeDef {
+    errorMap?: ZodErrorMap | undefined;
+    description?: string | undefined;
+}
+type RawCreateParams = {
+    errorMap?: ZodErrorMap | undefined;
+    invalid_type_error?: string | undefined;
+    required_error?: string | undefined;
+    message?: string | undefined;
+    description?: string | undefined;
+} | undefined;
+type SafeParseSuccess<Output> = {
+    success: true;
+    data: Output;
+    error?: never;
+};
+type SafeParseError<Input> = {
+    success: false;
+    error: ZodError<Input>;
+    data?: never;
+};
+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;
+}
+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;
+};
+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;
+}
+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;
+}
+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;
+}
+type ArrayCardinality = "many" | "atleastone";
+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>;
+}
+type UnknownKeysParam = "passthrough" | "strict" | "strip";
+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;
+}
+type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
+type baseObjectOutputType<Shape extends ZodRawShape> = {
+    [k in keyof Shape]: Shape[k]["_output"];
+};
+type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
+type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
+    [k in keyof Shape]: Shape[k]["_input"];
+}>;
+type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
+    [k: string]: T["_output"];
+};
+type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
+    [k: string]: T["_input"];
+};
+type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
+    [k: string]: unknown;
+} : unknown;
+type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
+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">;
+}
+type AnyZodObject = ZodObject<any, any, any>;
+type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
+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>;
+}
+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>;
+}
+type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
+type AssertArray<T> = T extends any[] ? T : never;
+type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
+    [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never;
+}>;
+type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
+type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
+    [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never;
+}>;
+type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
+interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
+    items: T;
+    rest: Rest;
+    typeName: ZodFirstPartyTypeKind.ZodTuple;
+}
+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>;
+}
+type EnumValues<T extends string = string> = readonly [T, ...T[]];
+type Values<T extends EnumValues> = {
+    [k in T[number]]: k;
+};
+interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
+    values: T;
+    typeName: ZodFirstPartyTypeKind.ZodEnum;
+}
+type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
+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;
+}
+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>;
+}
+type RefinementEffect<T> = {
+    type: "refinement";
+    refinement: (arg: T, ctx: RefinementCtx) => any;
+};
+type TransformEffect<T> = {
+    type: "transform";
+    transform: (arg: T, ctx: RefinementCtx) => any;
+};
+type PreprocessEffect<T> = {
+    type: "preprocess";
+    transform: (arg: T, ctx: RefinementCtx) => any;
+};
+type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
+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>;
+}
+
+interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+    innerType: T;
+    typeName: ZodFirstPartyTypeKind.ZodOptional;
+}
+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>;
+}
+interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+    innerType: T;
+    typeName: ZodFirstPartyTypeKind.ZodNullable;
+}
+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>;
+}
+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>;
+}
+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>;
+}
+interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
+    type: T;
+    typeName: ZodFirstPartyTypeKind.ZodBranded;
+}
+declare const BRAND: unique symbol;
+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;
+}
+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>;
+}
+type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
+    readonly [Symbol.toStringTag]: string;
+} | Date | Error | Generator | Promise<unknown> | RegExp;
+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>;
+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;
+}
+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"
+}
+
+declare const userSettingSchema: ZodObject<{
+    version: ZodNumber;
+    userSince: ZodOptional<ZodNumber>;
+    init: ZodOptional<ZodObject<{
+        skipOnboarding: ZodOptional<ZodBoolean>;
+    }, "strip", ZodTypeAny, {
+        skipOnboarding?: boolean | undefined;
+    }, {
+        skipOnboarding?: boolean | undefined;
+    }>>;
+    checklist: ZodOptional<ZodObject<{
+        items: ZodOptional<ZodObject<{
+            accessibilityTests: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            autodocs: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            ciTests: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            controls: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            coverage: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            guidedTour: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            installA11y: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            installChromatic: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            installDocs: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            installVitest: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            mdxDocs: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            moreComponents: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            moreStories: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            onboardingSurvey: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            organizeStories: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            publishStorybook: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            renderComponent: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            runTests: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            viewports: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            visualTests: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            whatsNewStorybook10: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+            writeInteractions: ZodOptional<ZodObject<{
+                status: ZodOptional<ZodEnum<["open", "accepted", "done", "skipped"]>>;
+                mutedAt: ZodOptional<ZodNumber>;
+            }, "strict", ZodTypeAny, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }, {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            }>>;
+        }, "strip", ZodTypeAny, {
+            controls?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            autodocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            accessibilityTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            ciTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            coverage?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            guidedTour?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installA11y?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installChromatic?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installVitest?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            mdxDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreComponents?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            onboardingSurvey?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            organizeStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            publishStorybook?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            renderComponent?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            runTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            viewports?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            visualTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            whatsNewStorybook10?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            writeInteractions?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+        }, {
+            controls?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            autodocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            accessibilityTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            ciTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            coverage?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            guidedTour?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installA11y?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installChromatic?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installVitest?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            mdxDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreComponents?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            onboardingSurvey?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            organizeStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            publishStorybook?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            renderComponent?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            runTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            viewports?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            visualTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            whatsNewStorybook10?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            writeInteractions?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+        }>>;
+        widget: ZodOptional<ZodObject<{
+            disable: ZodOptional<ZodBoolean>;
+        }, "strip", ZodTypeAny, {
+            disable?: boolean | undefined;
+        }, {
+            disable?: boolean | undefined;
+        }>>;
+    }, "strip", ZodTypeAny, {
+        items?: {
+            controls?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            autodocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            accessibilityTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            ciTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            coverage?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            guidedTour?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installA11y?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installChromatic?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installVitest?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            mdxDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreComponents?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            onboardingSurvey?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            organizeStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            publishStorybook?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            renderComponent?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            runTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            viewports?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            visualTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            whatsNewStorybook10?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            writeInteractions?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+        } | undefined;
+        widget?: {
+            disable?: boolean | undefined;
+        } | undefined;
+    }, {
+        items?: {
+            controls?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            autodocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            accessibilityTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            ciTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            coverage?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            guidedTour?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installA11y?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installChromatic?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installVitest?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            mdxDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreComponents?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            onboardingSurvey?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            organizeStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            publishStorybook?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            renderComponent?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            runTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            viewports?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            visualTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            whatsNewStorybook10?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            writeInteractions?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+        } | undefined;
+        widget?: {
+            disable?: boolean | undefined;
+        } | undefined;
+    }>>;
+}, "strip", ZodTypeAny, {
+    version: number;
+    init?: {
+        skipOnboarding?: boolean | undefined;
+    } | undefined;
+    userSince?: number | undefined;
+    checklist?: {
+        items?: {
+            controls?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            autodocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            accessibilityTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            ciTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            coverage?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            guidedTour?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installA11y?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installChromatic?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installVitest?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            mdxDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreComponents?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            onboardingSurvey?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            organizeStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            publishStorybook?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            renderComponent?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            runTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            viewports?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            visualTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            whatsNewStorybook10?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            writeInteractions?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+        } | undefined;
+        widget?: {
+            disable?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    version: number;
+    init?: {
+        skipOnboarding?: boolean | undefined;
+    } | undefined;
+    userSince?: number | undefined;
+    checklist?: {
+        items?: {
+            controls?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            autodocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            accessibilityTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            ciTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            coverage?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            guidedTour?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installA11y?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installChromatic?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            installVitest?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            mdxDocs?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreComponents?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            moreStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            onboardingSurvey?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            organizeStories?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            publishStorybook?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            renderComponent?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            runTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            viewports?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            visualTests?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            whatsNewStorybook10?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+            writeInteractions?: {
+                status?: "done" | "open" | "accepted" | "skipped" | undefined;
+                mutedAt?: number | undefined;
+            } | undefined;
+        } | undefined;
+        widget?: {
+            disable?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+declare function globalSettings(filePath?: string): Promise<Settings>;
+/**
+ * A class for reading and writing settings from a JSON file. Supports nested settings with dot
+ * notation.
+ */
+declare class Settings {
+    private filePath;
+    value: TypeOf<typeof userSettingSchema>;
+    /**
+     * Create a new Settings instance
+     *
+     * @param filePath Path to the JSON settings file
+     * @param value Loaded value of settings
+     */
+    constructor(filePath: string, value: TypeOf<typeof userSettingSchema>);
+    /** Save settings to the file */
+    save(): Promise<void>;
+}
+
+/** ChecklistState is the persisted state, which may be incomplete */
+type ChecklistState = NonNullable<Awaited<ReturnType<typeof globalSettings>>['value']['checklist']>;
+/** Store uses initialState to ensure all items are present */
+type StoreState = Required<Omit<ChecklistState, 'items'>> & {
+    items: NonNullable<Required<ChecklistState['items']>>;
+    loaded?: boolean;
+};
+type ItemId = keyof StoreState['items'];
+type StoreEvent = {
+    type: 'accept';
+    payload: ItemId;
+} | {
+    type: 'done';
+    payload: ItemId;
+} | {
+    type: 'skip';
+    payload: ItemId;
+} | {
+    type: 'reset';
+    payload: ItemId;
+} | {
+    type: 'mute';
+    payload: Array<ItemId>;
+} | {
+    type: 'disable';
+    payload: boolean;
+};
+
+declare const universalChecklistStore: UniversalStore<StoreState, StoreEvent>;
+declare const checklistStore: {
+    getValue: (id: ItemId) => {
+        status?: "done" | "open" | "accepted" | "skipped" | undefined;
+        mutedAt?: number | undefined;
+    };
+    accept: (id: ItemId) => void;
+    done: (id: ItemId) => void;
+    skip: (id: ItemId) => void;
+    reset: (id: ItemId) => void;
+    mute: (itemIds: Array<ItemId>) => void;
+    disable: (value: boolean) => void;
+};
+
+export { type API, type API_EventMap, type API_KeyCollection, ActiveTabs, AddonStore, type Combo, ManagerConsumer as Consumer, type KeyboardEventLike, ManagerContext, type ManagerProviderProps, ManagerProvider as Provider, RequestResponseError, type State, type Options as StoreOptions, addons, combineParameters, controlOrMetaKey, controlOrMetaSymbol, eventMatchesShortcut, eventToShortcut, MockUniversalStore as experimental_MockUniversalStore, UniversalStore as experimental_UniversalStore, getStatusStoreByTypeId as experimental_getStatusStore, getTestProviderStoreById as experimental_getTestProviderStore, experimental_requestResponse, useStatusStore as experimental_useStatusStore, useTestProviderStore as experimental_useTestProviderStore, useUniversalStore as experimental_useUniversalStore, checklistStore as internal_checklistStore, fullStatusStore as internal_fullStatusStore, fullTestProviderStore as internal_fullTestProviderStore, universalChecklistStore as internal_universalChecklistStore, universalStatusStore as internal_universalStatusStore, universalTestProviderStore as internal_universalTestProviderStore, isMacLike, isShortcutTaken, keyToSymbol, _default as merge, mockChannel, optionOrAltSymbol, shortcutMatchesShortcut, shortcutToAriaKeyshortcuts, shortcutToHumanString, typesX as types, useAddonState, useArgTypes, useArgs, useChannel, useGlobalTypes, useGlobals, useParameter, useSharedState, useStoryPrepared, useStorybookApi, useStorybookState };