@wix/cli-app 1.0.66 → 1.0.67

package/build/index.d.ts

@@ -1,1062 +0,0 @@
-declare 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>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
-    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 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> = {
-        [k in Exclude<keyof U, keyof V>]: U[k];
-    } & V;
-    type requiredKeys<T extends object> = {
-        [k in keyof T]: undefined extends T[k] ? never : k;
-    }[keyof T];
-    export type addQuestionMarks<T extends object, R extends keyof T = requiredKeys<T>> = Pick<Required<T>, R> & Partial<T>;
-    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, B> = flatten<Omit<A, keyof B> & B>;
-    export {};
-}
-declare const ZodParsedType: {
-    function: "function";
-    number: "number";
-    string: "string";
-    nan: "nan";
-    integer: "integer";
-    float: "float";
-    boolean: "boolean";
-    date: "date";
-    bigint: "bigint";
-    symbol: "symbol";
-    undefined: "undefined";
-    null: "null";
-    array: "array";
-    object: "object";
-    unknown: "unknown";
-    promise: "promise";
-    void: "void";
-    never: "never";
-    map: "map";
-    set: "set";
-};
-declare type ZodParsedType = keyof typeof ZodParsedType;
-
-declare type allKeys<T> = T extends any ? keyof T : never;
-declare 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";
-};
-declare type ZodIssueCode = keyof typeof ZodIssueCode;
-declare type ZodIssueBase = {
-    path: (string | number)[];
-    message?: string;
-};
-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;
-}
-declare type StringValidation = "email" | "url" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | {
-    includes: string;
-    position?: number;
-} | {
-    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;
-    };
-}
-declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
-declare type ZodIssue = ZodIssueOptionalMessage & {
-    fatal?: boolean;
-    message: string;
-};
-declare 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;
-declare 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>;
-    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>;
-}
-declare type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
-declare type IssueData = stripPath<ZodIssueOptionalMessage> & {
-    path?: (string | number)[];
-    fatal?: boolean;
-};
-declare type ErrorMapCtx = {
-    defaultError: string;
-    data: any;
-};
-declare type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
-    message: string;
-};
-
-declare type ParseParams = {
-    path: (string | number)[];
-    errorMap: ZodErrorMap;
-    async: boolean;
-};
-declare type ParsePathComponent = string | number;
-declare type ParsePath = ParsePathComponent[];
-interface ParseContext {
-    readonly common: {
-        readonly issues: ZodIssue[];
-        readonly contextualErrorMap?: ZodErrorMap;
-        readonly async: boolean;
-    };
-    readonly path: ParsePath;
-    readonly schemaErrorMap?: ZodErrorMap;
-    readonly parent: ParseContext | null;
-    readonly data: any;
-    readonly parsedType: ZodParsedType;
-}
-declare 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;
-}
-declare type INVALID = {
-    status: "aborted";
-};
-declare const INVALID: INVALID;
-declare type DIRTY<T> = {
-    status: "dirty";
-    value: T;
-};
-declare const DIRTY: <T>(value: T) => DIRTY<T>;
-declare type OK<T> = {
-    status: "valid";
-    value: T;
-};
-declare const OK: <T>(value: T) => OK<T>;
-declare type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
-declare type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
-declare 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;
-    };
-    const errToObj: (message?: ErrMessage | undefined) => {
-        message?: string | undefined;
-    };
-    const toString: (message?: ErrMessage | undefined) => 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;
-}
-
-declare type RefinementCtx = {
-    addIssue: (arg: IssueData) => void;
-    path: (string | number)[];
-};
-declare type ZodRawShape = {
-    [k: string]: ZodTypeAny;
-};
-declare type ZodTypeAny = ZodType<any, any, any>;
-declare type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
-declare type input<T extends ZodType<any, any, any>> = T["_input"];
-declare type output<T extends ZodType<any, any, any>> = T["_output"];
-
-declare type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
-interface ZodTypeDef {
-    errorMap?: ZodErrorMap;
-    description?: string;
-}
-declare type RawCreateParams = {
-    errorMap?: ZodErrorMap;
-    invalid_type_error?: string;
-    required_error?: string;
-    description?: string;
-} | undefined;
-declare type SafeParseSuccess<Output> = {
-    success: true;
-    data: Output;
-};
-declare type SafeParseError<Input> = {
-    success: false;
-    error: ZodError<Input>;
-};
-declare 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;
-    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?: Partial<ParseParams>): Output;
-    safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
-    parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
-    safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
-    spa: (data: unknown, params?: Partial<ParseParams> | undefined) => 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>;
-    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>;
-    isOptional(): boolean;
-    isNullable(): boolean;
-}
-declare type IpVersion = "v4" | "v6";
-declare type ZodStringCheck = {
-    kind: "min";
-    value: number;
-    message?: string;
-} | {
-    kind: "max";
-    value: number;
-    message?: string;
-} | {
-    kind: "length";
-    value: number;
-    message?: string;
-} | {
-    kind: "email";
-    message?: string;
-} | {
-    kind: "url";
-    message?: string;
-} | {
-    kind: "emoji";
-    message?: string;
-} | {
-    kind: "uuid";
-    message?: string;
-} | {
-    kind: "cuid";
-    message?: string;
-} | {
-    kind: "includes";
-    value: string;
-    position?: number;
-    message?: string;
-} | {
-    kind: "cuid2";
-    message?: string;
-} | {
-    kind: "ulid";
-    message?: string;
-} | {
-    kind: "startsWith";
-    value: string;
-    message?: string;
-} | {
-    kind: "endsWith";
-    value: string;
-    message?: string;
-} | {
-    kind: "regex";
-    regex: RegExp;
-    message?: string;
-} | {
-    kind: "trim";
-    message?: string;
-} | {
-    kind: "toLowerCase";
-    message?: string;
-} | {
-    kind: "toUpperCase";
-    message?: string;
-} | {
-    kind: "datetime";
-    offset: boolean;
-    precision: number | null;
-    message?: string;
-} | {
-    kind: "ip";
-    version?: IpVersion;
-    message?: string;
-};
-interface ZodStringDef extends ZodTypeDef {
-    checks: ZodStringCheck[];
-    typeName: ZodFirstPartyTypeKind.ZodString;
-    coerce: boolean;
-}
-declare class ZodString extends ZodType<string, ZodStringDef> {
-    _parse(input: ParseInput): ParseReturnType<string>;
-    protected _regex: (regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage | undefined) => 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;
-    cuid(message?: errorUtil.ErrMessage): ZodString;
-    cuid2(message?: errorUtil.ErrMessage): ZodString;
-    ulid(message?: errorUtil.ErrMessage): ZodString;
-    ip(options?: string | {
-        version?: "v4" | "v6";
-        message?: string;
-    }): ZodString;
-    datetime(options?: string | {
-        message?: string | undefined;
-        precision?: number | null;
-        offset?: boolean;
-    }): 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;
-    nonempty: (message?: errorUtil.ErrMessage | undefined) => ZodString;
-    trim: () => ZodString;
-    toLowerCase: () => ZodString;
-    toUpperCase: () => ZodString;
-    get isDatetime(): boolean;
-    get isEmail(): boolean;
-    get isURL(): boolean;
-    get isEmoji(): boolean;
-    get isUUID(): boolean;
-    get isCUID(): boolean;
-    get isCUID2(): boolean;
-    get isULID(): boolean;
-    get isIP(): boolean;
-    get minLength(): number | null;
-    get maxLength(): number | null;
-    static create: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: true | undefined;
-    }) | undefined) => ZodString;
-}
-declare type ZodNumberCheck = {
-    kind: "min";
-    value: number;
-    inclusive: boolean;
-    message?: string;
-} | {
-    kind: "max";
-    value: number;
-    inclusive: boolean;
-    message?: string;
-} | {
-    kind: "int";
-    message?: string;
-} | {
-    kind: "multipleOf";
-    value: number;
-    message?: string;
-} | {
-    kind: "finite";
-    message?: string;
-};
-interface ZodNumberDef extends ZodTypeDef {
-    checks: ZodNumberCheck[];
-    typeName: ZodFirstPartyTypeKind.ZodNumber;
-    coerce: boolean;
-}
-declare class ZodNumber extends ZodType<number, ZodNumberDef> {
-    _parse(input: ParseInput): ParseReturnType<number>;
-    static create: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: boolean | undefined;
-    }) | undefined) => ZodNumber;
-    gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    min: (value: number, message?: errorUtil.ErrMessage | undefined) => ZodNumber;
-    gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    max: (value: number, message?: errorUtil.ErrMessage | undefined) => 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 | undefined) => 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> {
-    _parse(input: ParseInput): ParseReturnType<boolean>;
-    static create: (params?: ({
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        description?: string | undefined;
-    } & {
-        coerce?: boolean | undefined;
-    }) | undefined) => ZodBoolean;
-}
-interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    type: T;
-    typeName: ZodFirstPartyTypeKind.ZodArray;
-    exactLength: {
-        value: number;
-        message?: string;
-    } | null;
-    minLength: {
-        value: number;
-        message?: string;
-    } | null;
-    maxLength: {
-        value: number;
-        message?: string;
-    } | null;
-}
-declare type ArrayCardinality = "many" | "atleastone";
-declare 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: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
-}
-declare 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;
-}
-declare type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
-declare type baseObjectOutputType<Shape extends ZodRawShape> = {
-    [k in keyof Shape]: Shape[k]["_output"];
-};
-declare type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
-declare type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
-    [k in keyof Shape]: Shape[k]["_input"];
-}>;
-declare type CatchallOutput<T extends ZodTypeAny> = ZodTypeAny extends T ? unknown : {
-    [k: string]: T["_output"];
-};
-declare type CatchallInput<T extends ZodTypeAny> = ZodTypeAny extends T ? unknown : {
-    [k: string]: T["_input"];
-};
-declare type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
-    [k: string]: unknown;
-} : unknown;
-declare 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>;
-    nonstrict: () => ZodObject<T, "passthrough", Catchall>;
-    extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
-    augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k]; }, UnknownKeys, Catchall, objectOutputType<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k]; }, Catchall, UnknownKeys>, objectInputType<{ [k in keyof (Omit<T, keyof Augmentation> & Augmentation)]: (Omit<T, keyof Augmentation> & Augmentation)[k]; }, Catchall, UnknownKeys>>;
-    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 {
-        [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
-    omit<Mask extends {
-        [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
-    deepPartial(): partialUtil.DeepPartial<this>;
-    partial(): ZodObject<{
-        [k in keyof T]: ZodOptional<T[k]>;
-    }, UnknownKeys, Catchall>;
-    partial<Mask extends {
-        [k in keyof T]?: true;
-    }>(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 {
-        [k in keyof T]?: true;
-    }>(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: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2]; }>;
-    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2]; }>;
-    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2]; }>;
-}
-declare type AnyZodObject = ZodObject<any, any, any>;
-declare 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: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
-}
-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: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
-}
-declare type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
-declare type AssertArray<T> = T extends any[] ? T : never;
-declare type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
-    [k in keyof T]: T[k] extends ZodType<any, any> ? T[k]["_output"] : never;
-}>;
-declare type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
-declare type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
-    [k in keyof T]: T[k] extends ZodType<any, any> ? T[k]["_input"] : never;
-}>;
-declare 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 [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], 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<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
-    static create: <T_1 extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
-}
-declare type EnumValues = [string, ...string[]];
-declare type Values<T extends EnumValues> = {
-    [k in T[number]]: k;
-};
-interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
-    values: T;
-    typeName: ZodFirstPartyTypeKind.ZodEnum;
-}
-declare type Writeable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-declare type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
-declare 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>> {
-    _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): ZodEnum<Writeable<ToExtract>>;
-    exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude): 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: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
-}
-declare type RefinementEffect<T> = {
-    type: "refinement";
-    refinement: (arg: T, ctx: RefinementCtx) => any;
-};
-declare type TransformEffect<T> = {
-    type: "transform";
-    transform: (arg: T, ctx: RefinementCtx) => any;
-};
-declare type PreprocessEffect<T> = {
-    type: "preprocess";
-    transform: (arg: T) => any;
-};
-declare 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"], input<I>>;
-    static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown) => 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: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
-}
-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: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
-}
-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: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        description?: string | undefined;
-    } & {
-        default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
-    }) => ZodDefault<T_1>;
-}
-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: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        description?: string | undefined;
-    } & {
-        catch: T_1["_output"] | (() => T_1["_output"]);
-    }) => ZodCatch<T_1>;
-}
-interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
-    type: T;
-    typeName: ZodFirstPartyTypeKind.ZodBranded;
-}
-declare const BRAND: unique symbol;
-declare 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<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
-}
-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"
-}
-
-declare const wixConfigSchema: ZodObject<{
-    appId: ZodString;
-    trusted: ZodDefault<ZodBoolean>;
-}, "strip", ZodTypeAny, {
-    appId: string;
-    trusted: boolean;
-}, {
-    appId: string;
-    trusted?: boolean | undefined;
-}>;
-type WixConfig = TypeOf<typeof wixConfigSchema>;
-declare const dashboardPageConfigSchema: ZodObject<{
-    id: ZodString;
-    title: ZodString;
-    fullPage: ZodOptional<ZodBoolean>;
-    hideInSidebar: ZodOptional<ZodBoolean>;
-    priority: ZodOptional<ZodNumber>;
-}, "strip", ZodTypeAny, {
-    id: string;
-    title: string;
-    fullPage?: boolean | undefined;
-    hideInSidebar?: boolean | undefined;
-    priority?: number | undefined;
-}, {
-    id: string;
-    title: string;
-    fullPage?: boolean | undefined;
-    hideInSidebar?: boolean | undefined;
-    priority?: number | undefined;
-}>;
-type DashboardPageConfig = TypeOf<typeof dashboardPageConfigSchema>;
-
-interface DashboardPageComponent extends DashboardPageConfig {
-    relativePath: string;
-    route: string;
-}
-
-type ProjectModel = {
-    config: WixConfig;
-    projectFolder: string;
-    components: DashboardPageComponent[];
-};
-declare function loadProjectModel(projectFolder: string): Promise<ProjectModel>;
-
-declare const authDataSchema: ZodObject<{
-    username: ZodString;
-    authToken: ZodString;
-    userGuid: ZodOptional<ZodString>;
-    aci: ZodOptional<ZodString>;
-}, "strip", ZodTypeAny, {
-    username: string;
-    authToken: string;
-    userGuid?: string | undefined;
-    aci?: string | undefined;
-}, {
-    username: string;
-    authToken: string;
-    userGuid?: string | undefined;
-    aci?: string | undefined;
-}>;
-type AuthData = TypeOf<typeof authDataSchema>;
-
-interface Url extends String {}
- interface GUID extends String {}
- interface DateTime extends Number {}
-
-interface Base {
-  src?: string | number;
-  evid?: string | number;
-}
-
-type BiEvent = Base & {
-  [property: string]: string | number | boolean | object;
-}
-
-interface BiEventMap {
-  [key: string]: BiEvent;
-}
-
-interface BiValidator {
-  match: (event: BiEvent) => boolean;
-  execute: (event: BiEvent) => void;
-}
-
-interface ReportParams {
-  src: number;
-  evid: number;
-  params: Record<string, string | number | boolean | DateTime | GUID | Url | undefined>;
-  useBatch?: boolean;
-}
-
-type BiPublisher<T> = (event: BiEvent, context: T) => Promise<void>
-
-type BiEventDefaults = BiEvent | Promise<BiEvent> | (() => BiEvent) | (() => Promise<BiEvent>)
-
-interface BiLoggerOptions<T> {
-  publishers: BiPublisher<T>[];
-  validators: BiValidator[];
-  defaults: BiEventDefaults;
-  events: BiEventMap;
-  defaultValueTimeout?: number;
-  defaultContinueOnFail?: boolean;
-}
-
-declare class BiLogger<T = object> {
-  constructor(options: BiLoggerOptions<T>, context: T);
-  report(event: ReportParams): Promise<void>;
-  log(event: BiEvent, contextOverrides?: T): Promise<void>;
-  log(eventKey: string): Promise<void>;
-  log(eventKey: string, eventOverrides: BiEvent, contextOverrides?: T): Promise<void>;
-  flush(): Promise<void>;
-  updateDefaults(defaults: BiEventDefaults): BiLogger<T>;
-}
-
-declare function getDefaultBiFields({ authData, model, }?: {
-    authData?: AuthData | null;
-    model?: ProjectModel | null;
-}): Record<string, string>;
-
-interface ErrorReporterOptions {
-    dsn: string;
-    release: string;
-}
-type ErrorReporter = ReturnType<typeof createErrorReporter>;
-declare function createErrorReporter({ dsn, release }: ErrorReporterOptions): {
-    reportError: (error: unknown, { data }?: {
-        data?: unknown;
-    }) => void;
-};
-
-interface CommandServices {
-    errorReporter: ErrorReporter;
-    biLogger: BiLogger;
-}
-
-declare function dev(services: CommandServices): Promise<void>;
-
-declare function build(_services: CommandServices): Promise<void>;
-
-declare function serve(services: CommandServices): Promise<void>;
-
-declare function preview(options: {
-    site?: string;
-}, services: CommandServices): Promise<void>;
-
-declare function createVersion(options: {
-    versionType?: string;
-    approvePreview?: boolean;
-}, services: CommandServices): Promise<void>;
-
-export { build, createVersion, dev, getDefaultBiFields, loadProjectModel, preview, serve };