@blocklet/pages-kit 0.6.18 → 0.6.20

package/lib/esm/utils/builtin.js

@@ -2,6 +2,7 @@ import * as component from '@blocklet/sdk/lib/component';
 import * as dayjs from '../builtin/dayjs';
 import * as stream from '../builtin/stream';
 import * as utils from '../builtin/utils';
+import * as zod from '../builtin/zod';
 export const BuiltinModules = {
     React: {},
     ReactDOM: {},
@@ -42,4 +43,5 @@ export const BuiltinModules = {
     '@blocklet/pages-kit/builtin/dayjs': dayjs,
     '@blocklet/pages-kit/builtin/utils': utils,
     '@blocklet/pages-kit/builtin/stream': stream,
+    '@blocklet/pages-kit/builtin/zod': zod,
 };

package/lib/esm/utils/inject-global-components.js

@@ -26,6 +26,7 @@ import * as session from '../builtin/session';
 import * as stream from '../builtin/stream';
 import * as uploader from '../builtin/uploader';
 import * as utils from '../builtin/utils';
+import * as zod from '../builtin/zod';
 import * as zustand from '../builtin/zustand';
 import * as zustandMiddlewareImmer from '../builtin/zustand/middleware/immer';
 import CustomComponentRenderer from '../components/CustomComponentRenderer';
@@ -83,6 +84,7 @@ export function injectGlobalComponents() {
         '@blocklet/pages-kit/builtin/async/image-preview': imagePreview,
         '@blocklet/pages-kit/builtin/async/ai-runtime': import('../builtin/async/ai-runtime'),
         '@blocklet/pages-kit/builtin/event-bus': eventBus,
+        '@blocklet/pages-kit/builtin/zod': zod,
     };
     // set global variable
     win[BuiltinModulesGlobalVariableName] = {

package/lib/esm/utils/style.js

@@ -20,7 +20,10 @@ const blockletTheme = createTheme({
     },
 });
 export function isGradient(color) {
-    if (color?.trim()) {
+    if (typeof color !== 'string') {
+        return false;
+    }
+    if (color?.trim?.()) {
         try {
             gradient.parse(color);
             return true;
@@ -48,6 +51,9 @@ export function isColorString(color) {
  * 处理渐变的解析，并转换为rgba格式
  */
 export function getSafeGradient(color) {
+    if (typeof color !== 'string') {
+        return '';
+    }
     try {
         const colorAst = gradient.parse(color);
         const safeAst = colorAst.map((astItem) => {

package/lib/types/builtin/color-picker.d.ts

@@ -1,8 +1,18 @@
+export interface TabItem {
+    key: string;
+    label: string;
+    component: React.ComponentType<{
+        value?: any;
+        onChange: (value: any, extra?: any) => void;
+    }>;
+    showPreview?: boolean;
+}
 export interface ColorPickerProps {
     value: string;
-    onChange: (value: string) => void;
+    onChange: (value: string, extra?: any) => void;
     style?: React.CSSProperties;
     sx?: object;
+    renderTabs?: (defaultTabs: TabItem[]) => TabItem[];
 }
 export interface ColorItemProps {
     color: string;
@@ -20,6 +30,7 @@ export interface ConfigColorDialogProps {
         value: string;
     }, close: () => void) => void;
     enableMuiPalette?: boolean;
+    renderTabs?: (defaultTabs: TabItem[]) => TabItem[];
 }
 interface AlternateColorIndicatorProps {
     value?: string;
@@ -40,8 +51,8 @@ interface CornerBorderProps {
 }
 export declare function CornerBorder({ border, cornerSize, borderRadius, sx }: CornerBorderProps): import("react/jsx-runtime").JSX.Element;
 export declare function ColorItem({ color, sx, ...props }: ColorItemProps): import("react/jsx-runtime").JSX.Element;
-export declare const ConfigColorDialog: ({ ref, onSave, enableMuiPalette, }: ConfigColorDialogProps & {
+export declare const ConfigColorDialog: ({ ref, onSave, enableMuiPalette, renderTabs, }: ConfigColorDialogProps & {
     ref: React.RefObject<ConfigColorDialogRef | null>;
 }) => import("react/jsx-runtime").JSX.Element;
-export declare function ColorPicker({ value, onChange, style, sx }: ColorPickerProps): import("react/jsx-runtime").JSX.Element;
+export declare function ColorPicker({ value, onChange, style, sx, renderTabs }: ColorPickerProps): import("react/jsx-runtime").JSX.Element;
 export default ColorPicker;

package/lib/types/builtin/zod.d.ts

@@ -0,0 +1,269 @@
+import * as z4 from 'zod/v4';
+export * from 'zod/v4';
+type PagesKitComponentMeta = {
+    id?: string;
+    type: string;
+    locales: {
+        [locale: string]: {
+            name?: string;
+            description?: string;
+            defaultValue?: any;
+            placeholder?: string;
+            [key: string]: any;
+        };
+    };
+    examples?: z4.$output[];
+};
+export declare const pagesKitRegistry: z4.z.core.$ZodRegistry<PagesKitComponentMeta, z4.z.core.$ZodType<unknown, unknown, z4.z.core.$ZodTypeInternals<unknown, unknown>>>;
+export declare const uploadSchema: z4.ZodObject<{
+    url: z4.ZodNullable<z4.ZodString>;
+    mediaKitUrl: z4.ZodNullable<z4.ZodString>;
+    width: z4.ZodNullable<z4.ZodNumber>;
+    height: z4.ZodNullable<z4.ZodNumber>;
+}, z4.z.core.$strip>;
+export declare const z: {
+    upload: () => z4.ZodObject<{
+        url: z4.ZodNullable<z4.ZodString>;
+        mediaKitUrl: z4.ZodNullable<z4.ZodString>;
+        width: z4.ZodNullable<z4.ZodNumber>;
+        height: z4.ZodNullable<z4.ZodNumber>;
+    }, z4.z.core.$strip>;
+    default: typeof z4.z;
+    z: typeof z4.z;
+    core: typeof z4.core;
+    globalRegistry: z4.z.core.$ZodRegistry<z4.z.core.GlobalMeta, z4.z.core.$ZodType<unknown, unknown, z4.z.core.$ZodTypeInternals<unknown, unknown>>>;
+    registry: typeof z4.core.registry;
+    config: typeof z4.core.config;
+    function: typeof z4.core.function;
+    $output: typeof z4.core.$output;
+    $input: typeof z4.core.$input;
+    $brand: typeof z4.core.$brand;
+    clone: typeof z4.core.util.clone;
+    regexes: typeof z4.core.regexes;
+    treeifyError: typeof z4.core.treeifyError;
+    prettifyError: typeof z4.core.prettifyError;
+    formatError: typeof z4.core.formatError;
+    flattenError: typeof z4.core.flattenError;
+    toJSONSchema: typeof z4.core.toJSONSchema;
+    TimePrecision: {
+        readonly Any: null;
+        readonly Minute: -1;
+        readonly Second: 0;
+        readonly Millisecond: 3;
+        readonly Microsecond: 6;
+    };
+    NEVER: never;
+    locales: typeof z4.core.locales;
+    ZodISODateTime: z4.z.core.$constructor<z4.z.ZodISODateTime, z4.z.core.$ZodISODateTimeDef>;
+    ZodISODate: z4.z.core.$constructor<z4.z.ZodISODate, z4.z.core.$ZodStringFormatDef<"date">>;
+    ZodISOTime: z4.z.core.$constructor<z4.z.ZodISOTime, z4.z.core.$ZodISOTimeDef>;
+    ZodISODuration: z4.z.core.$constructor<z4.z.ZodISODuration, z4.z.core.$ZodStringFormatDef<"duration">>;
+    iso: typeof z4.iso;
+    coerce: typeof z4.coerce;
+    string(params?: string | z4.z.core.$ZodStringParams): z4.ZodString;
+    string<T extends string>(params?: string | z4.z.core.$ZodStringParams): z4.z.core.$ZodType<T, T>;
+    email(params?: string | z4.z.core.$ZodEmailParams): z4.ZodEmail;
+    guid(params?: string | z4.z.core.$ZodGUIDParams): z4.ZodGUID;
+    uuid(params?: string | z4.z.core.$ZodUUIDParams): z4.ZodUUID;
+    uuidv4(params?: string | z4.z.core.$ZodUUIDv4Params): z4.ZodUUID;
+    uuidv6(params?: string | z4.z.core.$ZodUUIDv6Params): z4.ZodUUID;
+    uuidv7(params?: string | z4.z.core.$ZodUUIDv7Params): z4.ZodUUID;
+    url(params?: string | z4.z.core.$ZodURLParams): z4.ZodURL;
+    emoji(params?: string | z4.z.core.$ZodEmojiParams): z4.ZodEmoji;
+    nanoid(params?: string | z4.z.core.$ZodNanoIDParams): z4.ZodNanoID;
+    cuid(params?: string | z4.z.core.$ZodCUIDParams): z4.ZodCUID;
+    cuid2(params?: string | z4.z.core.$ZodCUID2Params): z4.ZodCUID2;
+    ulid(params?: string | z4.z.core.$ZodULIDParams): z4.ZodULID;
+    xid(params?: string | z4.z.core.$ZodXIDParams): z4.ZodXID;
+    ksuid(params?: string | z4.z.core.$ZodKSUIDParams): z4.ZodKSUID;
+    ipv4(params?: string | z4.z.core.$ZodIPv4Params): z4.ZodIPv4;
+    ipv6(params?: string | z4.z.core.$ZodIPv6Params): z4.ZodIPv6;
+    cidrv4(params?: string | z4.z.core.$ZodCIDRv4Params): z4.ZodCIDRv4;
+    cidrv6(params?: string | z4.z.core.$ZodCIDRv6Params): z4.ZodCIDRv6;
+    base64(params?: string | z4.z.core.$ZodBase64Params): z4.ZodBase64;
+    base64url(params?: string | z4.z.core.$ZodBase64URLParams): z4.ZodBase64URL;
+    e164(params?: string | z4.z.core.$ZodE164Params): z4.ZodE164;
+    jwt(params?: string | z4.z.core.$ZodJWTParams): z4.ZodJWT;
+    stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => z4.z.core.util.MaybeAsync<unknown>) | RegExp, _params?: string | z4.z.core.$ZodStringFormatParams): z4.ZodCustomStringFormat<Format>;
+    number(params?: string | z4.z.core.$ZodNumberParams): z4.ZodNumber;
+    int(params?: string | z4.z.core.$ZodCheckNumberFormatParams): z4.ZodInt;
+    float32(params?: string | z4.z.core.$ZodCheckNumberFormatParams): z4.ZodFloat32;
+    float64(params?: string | z4.z.core.$ZodCheckNumberFormatParams): z4.ZodFloat64;
+    int32(params?: string | z4.z.core.$ZodCheckNumberFormatParams): z4.ZodInt32;
+    uint32(params?: string | z4.z.core.$ZodCheckNumberFormatParams): z4.ZodUInt32;
+    boolean(params?: string | z4.z.core.$ZodBooleanParams): z4.ZodBoolean;
+    bigint(params?: string | z4.z.core.$ZodBigIntParams): z4.ZodBigInt;
+    int64(params?: string | z4.z.core.$ZodBigIntFormatParams): z4.ZodBigIntFormat;
+    uint64(params?: string | z4.z.core.$ZodBigIntFormatParams): z4.ZodBigIntFormat;
+    symbol(params?: string | z4.z.core.$ZodSymbolParams): z4.ZodSymbol;
+    any(): z4.ZodAny;
+    unknown(): z4.ZodUnknown;
+    never(params?: string | z4.z.core.$ZodNeverParams): z4.ZodNever;
+    date(params?: string | z4.z.core.$ZodDateParams): z4.ZodDate;
+    array<T extends z4.z.core.SomeType>(element: T, params?: string | z4.z.core.$ZodArrayParams): z4.ZodArray<T>;
+    keyof<T extends z4.ZodObject>(schema: T): z4.ZodLiteral<Exclude<keyof T["_zod"]["output"], symbol>>;
+    object<T extends z4.z.core.$ZodLooseShape = Partial<Record<never, z4.z.core.SomeType>>>(shape?: T, params?: string | z4.z.core.$ZodObjectParams): z4.ZodObject<z4.z.core.util.Writeable<T>, z4.z.core.$strip>;
+    strictObject<T extends z4.z.core.$ZodLooseShape>(shape: T, params?: string | z4.z.core.$ZodObjectParams): z4.ZodObject<T, z4.z.core.$strict>;
+    looseObject<T extends z4.z.core.$ZodLooseShape>(shape: T, params?: string | z4.z.core.$ZodObjectParams): z4.ZodObject<T, z4.z.core.$loose>;
+    union<const T extends readonly z4.z.core.SomeType[]>(options: T, params?: string | z4.z.core.$ZodUnionParams): z4.ZodUnion<T>;
+    discriminatedUnion<Types extends readonly [z4.z.core.$ZodTypeDiscriminable, ...z4.z.core.$ZodTypeDiscriminable[]]>(discriminator: string, options: Types, params?: string | z4.z.core.$ZodDiscriminatedUnionParams): z4.ZodDiscriminatedUnion<Types>;
+    intersection<T extends z4.z.core.SomeType, U extends z4.z.core.SomeType>(left: T, right: U): z4.ZodIntersection<T, U>;
+    tuple<T extends readonly [z4.z.core.SomeType, ...z4.z.core.SomeType[]]>(items: T, params?: string | z4.z.core.$ZodTupleParams): z4.ZodTuple<T, null>;
+    tuple<T extends readonly [z4.z.core.SomeType, ...z4.z.core.SomeType[]], Rest extends z4.z.core.SomeType>(items: T, rest: Rest, params?: string | z4.z.core.$ZodTupleParams): z4.ZodTuple<T, Rest>;
+    tuple(items: [], params?: string | z4.z.core.$ZodTupleParams): z4.ZodTuple<[], null>;
+    record<Key extends z4.z.core.$ZodRecordKey, Value extends z4.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | z4.z.core.$ZodRecordParams): z4.ZodRecord<Key, Value>;
+    partialRecord<Key extends z4.z.core.$ZodRecordKey, Value extends z4.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | z4.z.core.$ZodRecordParams): z4.ZodRecord<Key & z4.z.core.$partial, Value>;
+    map<Key extends z4.z.core.SomeType, Value extends z4.z.core.SomeType>(keyType: Key, valueType: Value, params?: string | z4.z.core.$ZodMapParams): z4.ZodMap<Key, Value>;
+    set<Value extends z4.z.core.SomeType>(valueType: Value, params?: string | z4.z.core.$ZodSetParams): z4.ZodSet<Value>;
+    nativeEnum<T extends z4.z.core.util.EnumLike>(entries: T, params?: string | z4.z.core.$ZodEnumParams): z4.ZodEnum<T>;
+    literal<const T extends ReadonlyArray<z4.z.core.util.Literal>>(value: T, params?: string | z4.z.core.$ZodLiteralParams): z4.ZodLiteral<T[number]>;
+    literal<const T extends z4.z.core.util.Literal>(value: T, params?: string | z4.z.core.$ZodLiteralParams): z4.ZodLiteral<T>;
+    file(params?: string | z4.z.core.$ZodFileParams): z4.ZodFile;
+    transform<I = unknown, O = I>(fn: (input: I, ctx: z4.z.core.ParsePayload) => O): z4.ZodTransform<Awaited<O>, I>;
+    optional<T extends z4.z.core.SomeType>(innerType: T): z4.ZodOptional<T>;
+    nullable<T extends z4.z.core.SomeType>(innerType: T): z4.ZodNullable<T>;
+    nullish<T extends z4.z.core.SomeType>(innerType: T): z4.ZodOptional<z4.ZodNullable<T>>;
+    _default<T extends z4.z.core.SomeType>(innerType: T, defaultValue: z4.z.core.util.NoUndefined<z4.z.core.output<T>> | (() => z4.z.core.util.NoUndefined<z4.z.core.output<T>>)): z4.ZodDefault<T>;
+    prefault<T extends z4.z.core.SomeType>(innerType: T, defaultValue: z4.z.core.input<T> | (() => z4.z.core.input<T>)): z4.ZodPrefault<T>;
+    nonoptional<T extends z4.z.core.SomeType>(innerType: T, params?: string | z4.z.core.$ZodNonOptionalParams): z4.ZodNonOptional<T>;
+    success<T extends z4.z.core.SomeType>(innerType: T): z4.ZodSuccess<T>;
+    nan(params?: string | z4.z.core.$ZodNaNParams): z4.ZodNaN;
+    pipe<const A extends z4.z.core.SomeType, B extends z4.z.core.$ZodType<unknown, z4.z.core.output<A>> = z4.z.core.$ZodType<unknown, z4.z.core.output<A>, z4.z.core.$ZodTypeInternals<unknown, z4.z.core.output<A>>>>(in_: A, out: B | z4.z.core.$ZodType<unknown, z4.z.core.output<A>>): z4.ZodPipe<A, B>;
+    readonly<T extends z4.z.core.SomeType>(innerType: T): z4.ZodReadonly<T>;
+    templateLiteral<const Parts extends z4.z.core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | z4.z.core.$ZodTemplateLiteralParams): z4.ZodTemplateLiteral<z4.z.core.$PartsToTemplateLiteral<Parts>>;
+    lazy<T extends z4.z.core.SomeType>(getter: () => T): z4.ZodLazy<T>;
+    promise<T extends z4.z.core.SomeType>(innerType: T): z4.ZodPromise<T>;
+    check<O = unknown>(fn: z4.z.core.CheckFn<O>): z4.z.core.$ZodCheck<O>;
+    custom<O>(fn?: (data: unknown) => unknown, _params?: string | z4.z.core.$ZodCustomParams | undefined): z4.ZodCustom<O, O>;
+    refine<T>(fn: (arg: NoInfer<T>) => z4.z.core.util.MaybeAsync<unknown>, _params?: string | z4.z.core.$ZodCustomParams): z4.z.core.$ZodCheck<T>;
+    superRefine<T>(fn: (arg: T, payload: z4.RefinementCtx<T>) => void | Promise<void>): z4.z.core.$ZodCheck<T>;
+    json(params?: string | z4.z.core.$ZodCustomParams): z4.ZodJSONSchema;
+    preprocess<A, U extends z4.z.core.SomeType, B = unknown>(fn: (arg: B, ctx: z4.RefinementCtx) => A, schema: U): z4.ZodPipe<z4.ZodTransform<A, B>, U>;
+    ZodType: z4.z.core.$constructor<z4.ZodType>;
+    _ZodString: z4.z.core.$constructor<z4._ZodString>;
+    ZodString: z4.z.core.$constructor<z4.ZodString>;
+    ZodStringFormat: z4.z.core.$constructor<z4.ZodStringFormat>;
+    ZodEmail: z4.z.core.$constructor<z4.ZodEmail>;
+    ZodGUID: z4.z.core.$constructor<z4.ZodGUID>;
+    ZodUUID: z4.z.core.$constructor<z4.ZodUUID>;
+    ZodURL: z4.z.core.$constructor<z4.ZodURL>;
+    ZodEmoji: z4.z.core.$constructor<z4.ZodEmoji>;
+    ZodNanoID: z4.z.core.$constructor<z4.ZodNanoID>;
+    ZodCUID: z4.z.core.$constructor<z4.ZodCUID>;
+    ZodCUID2: z4.z.core.$constructor<z4.ZodCUID2>;
+    ZodULID: z4.z.core.$constructor<z4.ZodULID>;
+    ZodXID: z4.z.core.$constructor<z4.ZodXID>;
+    ZodKSUID: z4.z.core.$constructor<z4.ZodKSUID>;
+    ZodIPv4: z4.z.core.$constructor<z4.ZodIPv4>;
+    ZodIPv6: z4.z.core.$constructor<z4.ZodIPv6>;
+    ZodCIDRv4: z4.z.core.$constructor<z4.ZodCIDRv4>;
+    ZodCIDRv6: z4.z.core.$constructor<z4.ZodCIDRv6>;
+    ZodBase64: z4.z.core.$constructor<z4.ZodBase64>;
+    ZodBase64URL: z4.z.core.$constructor<z4.ZodBase64URL>;
+    ZodE164: z4.z.core.$constructor<z4.ZodE164>;
+    ZodJWT: z4.z.core.$constructor<z4.ZodJWT>;
+    ZodCustomStringFormat: z4.z.core.$constructor<z4.ZodCustomStringFormat>;
+    ZodNumber: z4.z.core.$constructor<z4.ZodNumber>;
+    ZodNumberFormat: z4.z.core.$constructor<z4.ZodNumberFormat>;
+    ZodBoolean: z4.z.core.$constructor<z4.ZodBoolean>;
+    ZodBigInt: z4.z.core.$constructor<z4.ZodBigInt>;
+    ZodBigIntFormat: z4.z.core.$constructor<z4.ZodBigIntFormat>;
+    ZodSymbol: z4.z.core.$constructor<z4.ZodSymbol>;
+    ZodUndefined: z4.z.core.$constructor<z4.ZodUndefined>;
+    undefined: typeof z4.undefined;
+    ZodNull: z4.z.core.$constructor<z4.ZodNull>;
+    null: typeof z4.null;
+    ZodAny: z4.z.core.$constructor<z4.ZodAny>;
+    ZodUnknown: z4.z.core.$constructor<z4.ZodUnknown>;
+    ZodNever: z4.z.core.$constructor<z4.ZodNever>;
+    ZodVoid: z4.z.core.$constructor<z4.ZodVoid>;
+    void: typeof z4.void;
+    ZodDate: z4.z.core.$constructor<z4.ZodDate>;
+    ZodArray: z4.z.core.$constructor<z4.ZodArray>;
+    ZodObject: z4.z.core.$constructor<z4.ZodObject>;
+    ZodUnion: z4.z.core.$constructor<z4.ZodUnion>;
+    ZodDiscriminatedUnion: z4.z.core.$constructor<z4.ZodDiscriminatedUnion>;
+    ZodIntersection: z4.z.core.$constructor<z4.ZodIntersection>;
+    ZodTuple: z4.z.core.$constructor<z4.ZodTuple>;
+    ZodRecord: z4.z.core.$constructor<z4.ZodRecord>;
+    ZodMap: z4.z.core.$constructor<z4.ZodMap>;
+    ZodSet: z4.z.core.$constructor<z4.ZodSet>;
+    ZodEnum: z4.z.core.$constructor<z4.ZodEnum>;
+    enum: typeof z4.enum;
+    ZodLiteral: z4.z.core.$constructor<z4.ZodLiteral>;
+    ZodFile: z4.z.core.$constructor<z4.ZodFile>;
+    ZodTransform: z4.z.core.$constructor<z4.ZodTransform>;
+    ZodOptional: z4.z.core.$constructor<z4.ZodOptional>;
+    ZodNullable: z4.z.core.$constructor<z4.ZodNullable>;
+    ZodDefault: z4.z.core.$constructor<z4.ZodDefault>;
+    ZodPrefault: z4.z.core.$constructor<z4.ZodPrefault>;
+    ZodNonOptional: z4.z.core.$constructor<z4.ZodNonOptional>;
+    ZodSuccess: z4.z.core.$constructor<z4.ZodSuccess>;
+    ZodCatch: z4.z.core.$constructor<z4.ZodCatch>;
+    catch: typeof z4.catch;
+    ZodNaN: z4.z.core.$constructor<z4.ZodNaN>;
+    ZodPipe: z4.z.core.$constructor<z4.ZodPipe>;
+    ZodReadonly: z4.z.core.$constructor<z4.ZodReadonly>;
+    ZodTemplateLiteral: z4.z.core.$constructor<z4.ZodTemplateLiteral>;
+    ZodLazy: z4.z.core.$constructor<z4.ZodLazy>;
+    ZodPromise: z4.z.core.$constructor<z4.ZodPromise>;
+    ZodCustom: z4.z.core.$constructor<z4.ZodCustom>;
+    instanceof: typeof z4.instanceof;
+    stringbool: (_params?: string | z4.z.core.$ZodStringBoolParams) => z4.ZodPipe<z4.ZodPipe<z4.ZodString, z4.ZodTransform<boolean, string>>, z4.ZodBoolean>;
+    lt: typeof z4.core._lt;
+    lte: typeof z4.core._lte;
+    gt: typeof z4.core._gt;
+    gte: typeof z4.core._gte;
+    positive: typeof z4.core._positive;
+    negative: typeof z4.core._negative;
+    nonpositive: typeof z4.core._nonpositive;
+    nonnegative: typeof z4.core._nonnegative;
+    multipleOf: typeof z4.core._multipleOf;
+    maxSize: typeof z4.core._maxSize;
+    minSize: typeof z4.core._minSize;
+    size: typeof z4.core._size;
+    maxLength: typeof z4.core._maxLength;
+    minLength: typeof z4.core._minLength;
+    length: typeof z4.core._length;
+    regex: typeof z4.core._regex;
+    lowercase: typeof z4.core._lowercase;
+    uppercase: typeof z4.core._uppercase;
+    includes: typeof z4.core._includes;
+    startsWith: typeof z4.core._startsWith;
+    endsWith: typeof z4.core._endsWith;
+    property: typeof z4.core._property;
+    mime: typeof z4.core._mime;
+    overwrite: typeof z4.core._overwrite;
+    normalize: typeof z4.core._normalize;
+    trim: typeof z4.core._trim;
+    toLowerCase: typeof z4.core._toLowerCase;
+    toUpperCase: typeof z4.core._toUpperCase;
+    ZodError: z4.z.core.$constructor<z4.ZodError>;
+    ZodRealError: z4.z.core.$constructor<z4.ZodError>;
+    parse: <T extends z4.z.core.$ZodType>(schema: T, value: unknown, _ctx?: z4.z.core.ParseContext<z4.z.core.$ZodIssue>, _params?: {
+        callee?: z4.z.core.util.AnyFunc;
+        Err?: z4.z.core.$ZodErrorClass;
+    }) => z4.z.core.output<T>;
+    parseAsync: <T extends z4.z.core.$ZodType>(schema: T, value: unknown, _ctx?: z4.z.core.ParseContext<z4.z.core.$ZodIssue>, _params?: {
+        callee?: z4.z.core.util.AnyFunc;
+        Err?: z4.z.core.$ZodErrorClass;
+    }) => Promise<z4.z.core.output<T>>;
+    safeParse: <T extends z4.z.core.$ZodType>(schema: T, value: unknown, _ctx?: z4.z.core.ParseContext<z4.z.core.$ZodIssue>) => z4.ZodSafeParseResult<z4.z.core.output<T>>;
+    safeParseAsync: <T extends z4.z.core.$ZodType>(schema: T, value: unknown, _ctx?: z4.z.core.ParseContext<z4.z.core.$ZodIssue>) => Promise<z4.ZodSafeParseResult<z4.z.core.output<T>>>;
+    setErrorMap(map: z4.z.core.$ZodErrorMap): void;
+    getErrorMap(): z4.z.core.$ZodErrorMap<z4.z.core.$ZodIssue> | undefined;
+    ZodIssueCode: {
+        readonly invalid_type: "invalid_type";
+        readonly too_big: "too_big";
+        readonly too_small: "too_small";
+        readonly invalid_format: "invalid_format";
+        readonly not_multiple_of: "not_multiple_of";
+        readonly unrecognized_keys: "unrecognized_keys";
+        readonly invalid_union: "invalid_union";
+        readonly invalid_key: "invalid_key";
+        readonly invalid_element: "invalid_element";
+        readonly invalid_value: "invalid_value";
+        readonly custom: "custom";
+    };
+};
+export default z;