@openclaw/firecrawl-plugin 2026.9.4 → 2026.9.6

package/node_modules/zod/v4/mini/schemas.d.cts

@@ -1,4 +1,5 @@
 import * as core from "../core/index.cjs";
+import type { $ZodBigIntFormats } from "../core/index.cjs";
 import * as util from "../core/util.cjs";
 type SomeType = core.SomeType;
 export interface ZodMiniType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
@@ -15,7 +16,7 @@ export interface ZodMiniType<out Output = unknown, out Input = unknown, out Inte
     safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): util.SafeParseResult<core.output<this>>;
     parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<util.SafeParseResult<core.output<this>>>;
-    apply<T>(fn: (schema: this) => T): T;
+    apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
 }
 interface _ZodMiniType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodMiniType<any, any, Internals> {
 }
@@ -127,6 +128,14 @@ export interface ZodMiniE164 extends _ZodMiniString<core.$ZodE164Internals> {
 }
 export declare const ZodMiniE164: core.$constructor<ZodMiniE164>;
 export declare function e164(params?: string | core.$ZodE164Params): ZodMiniE164;
+export interface ZodMiniCreditCard extends _ZodMiniString<core.$ZodCreditCardInternals> {
+}
+export declare const ZodMiniCreditCard: core.$constructor<ZodMiniCreditCard>;
+export declare function creditCard(params?: string | core.$ZodCreditCardParams): ZodMiniCreditCard;
+export interface ZodMiniIBAN extends _ZodMiniString<core.$ZodIBANInternals> {
+}
+export declare const ZodMiniIBAN: core.$constructor<ZodMiniIBAN>;
+export declare function iban(params?: string | core.$ZodIBANParams): ZodMiniIBAN;
 export interface ZodMiniJWT extends _ZodMiniString<core.$ZodJWTInternals> {
 }
 export declare const ZodMiniJWT: core.$constructor<ZodMiniJWT>;
@@ -138,6 +147,7 @@ export declare const ZodMiniCustomStringFormat: core.$constructor<ZodMiniCustomS
 export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<Format>;
 export declare function hostname(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"hostname">;
 export declare function hex(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"hex">;
+export declare function currencyCode(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"currency_code">;
 export declare function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = "hex">(alg: Alg, params?: {
     enc?: Enc;
 } & core.$ZodStringFormatParams): ZodMiniCustomStringFormat<`${Alg}_${Enc}`>;
@@ -148,14 +158,24 @@ export interface ZodMiniNumber<Input = unknown> extends _ZodMiniNumber<core.$Zod
 }
 export declare const ZodMiniNumber: core.$constructor<ZodMiniNumber>;
 export declare function number(params?: string | core.$ZodNumberParams): ZodMiniNumber<number>;
-export interface ZodMiniNumberFormat extends _ZodMiniNumber<core.$ZodNumberFormatInternals>, core.$ZodNumberFormat {
+export interface ZodMiniNumberFormat<Format extends core.$ZodNumberFormats = core.$ZodNumberFormats> extends _ZodMiniNumber<core.$ZodNumberFormatInternals<Format>>, core.$ZodNumberFormat<Format> {
 }
 export declare const ZodMiniNumberFormat: core.$constructor<ZodMiniNumberFormat>;
-export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
+export interface ZodMiniInt extends ZodMiniNumberFormat<"safeint"> {
+}
+export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniInt;
+export interface ZodMiniFloat32 extends ZodMiniNumberFormat<"float32"> {
+}
+export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniFloat32;
+export interface ZodMiniFloat64 extends ZodMiniNumberFormat<"float64"> {
+}
+export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniFloat64;
+export interface ZodMiniInt32 extends ZodMiniNumberFormat<"int32"> {
+}
+export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniInt32;
+export interface ZodMiniUInt32 extends ZodMiniNumberFormat<"uint32"> {
+}
+export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniUInt32;
 export interface ZodMiniBoolean<T = unknown> extends _ZodMiniType<core.$ZodBooleanInternals<T>> {
 }
 export declare const ZodMiniBoolean: core.$constructor<ZodMiniBoolean>;
@@ -164,11 +184,15 @@ export interface ZodMiniBigInt<T = unknown> extends _ZodMiniType<core.$ZodBigInt
 }
 export declare const ZodMiniBigInt: core.$constructor<ZodMiniBigInt>;
 export declare function bigint(params?: string | core.$ZodBigIntParams): ZodMiniBigInt<bigint>;
-export interface ZodMiniBigIntFormat extends _ZodMiniType<core.$ZodBigIntFormatInternals> {
+export interface ZodMiniBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends _ZodMiniType<core.$ZodBigIntFormatInternals<Format>> {
 }
 export declare const ZodMiniBigIntFormat: core.$constructor<ZodMiniBigIntFormat>;
-export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
-export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
+export interface ZodMiniInt64 extends ZodMiniBigIntFormat<"int64"> {
+}
+export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniInt64;
+export interface ZodMiniUInt64 extends ZodMiniBigIntFormat<"uint64"> {
+}
+export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniUInt64;
 export interface ZodMiniSymbol extends _ZodMiniType<core.$ZodSymbolInternals> {
 }
 export declare const ZodMiniSymbol: core.$constructor<ZodMiniSymbol>;
@@ -223,8 +247,10 @@ export type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLo
     [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];
 };
 export declare function safeExtend<T extends ZodMiniObject, U extends core.$ZodLooseShape>(schema: T, shape: SafeExtendShape<T["shape"], U>): ZodMiniObject<util.Extend<T["shape"], util.Writeable<U>>, T["_zod"]["config"]>;
-/** @deprecated Identical to `z.extend(A, B)` */
-export declare function merge<T extends ZodMiniObject, U extends ZodMiniObject>(a: T, b: U): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, T["_zod"]["config"]>;
+/**
+ * @deprecated Use [`z.extend(A, B.shape)`](https://zod.dev/api?id=extend) instead.
+ */
+export declare function merge<T extends ZodMiniObject, U extends ZodMiniObject>(a: T, b: U): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, U["_zod"]["config"]>;
 export declare function pick<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<util.Flatten<Pick<T["shape"], keyof T["shape"] & keyof M>>, T["_zod"]["config"]>;
 export declare function omit<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<util.Flatten<Omit<T["shape"], keyof M>>, T["_zod"]["config"]>;
 export declare function partial<T extends ZodMiniObject>(schema: T): ZodMiniObject<{
@@ -233,6 +259,15 @@ export declare function partial<T extends ZodMiniObject>(schema: T): ZodMiniObje
 export declare function partial<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<{
     -readonly [k in keyof T["shape"]]: k extends keyof M ? ZodMiniOptional<T["shape"][k]> : T["shape"][k];
 }, T["_zod"]["config"]>;
+export declare function partial<T extends util.TupleItems, Rest extends SomeType | null>(schema: ZodMiniTuple<T, Rest>): ZodMiniTuple<{
+    -readonly [k in keyof T]: ZodMiniOptional<T[k]>;
+}, Rest>;
+export declare function exactPartial<T extends ZodMiniObject>(schema: T): ZodMiniObject<{
+    -readonly [k in keyof T["shape"]]: ZodMiniExactOptional<T["shape"][k]>;
+}, T["_zod"]["config"]>;
+export declare function exactPartial<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<{
+    -readonly [k in keyof T["shape"]]: k extends keyof M ? ZodMiniExactOptional<T["shape"][k]> : T["shape"][k];
+}, T["_zod"]["config"]>;
 export type RequiredInterfaceShape<Shape extends core.$ZodLooseShape, Keys extends PropertyKey = keyof Shape> = util.Identity<{
     [k in keyof Shape as k extends Keys ? k : never]: ZodMiniNonOptional<Shape[k]>;
 } & {
@@ -260,7 +295,7 @@ export interface ZodMiniDiscriminatedUnion<Options extends readonly SomeType[] =
     _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
 }
 export declare const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUnion>;
-export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
+export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
 export interface ZodMiniIntersection<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodIntersectionInternals<A, B>> {
 }
 export declare const ZodMiniIntersection: core.$constructor<ZodMiniIntersection>;
@@ -333,7 +368,7 @@ export declare function _default<T extends SomeType>(innerType: T, defaultValue:
 export interface ZodMiniPrefault<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPrefaultInternals<T>> {
 }
 export declare const ZodMiniPrefault: core.$constructor<ZodMiniPrefault>;
-export declare function prefault<T extends SomeType>(innerType: T, defaultValue: util.NoUndefined<core.input<T>> | (() => util.NoUndefined<core.input<T>>)): ZodMiniPrefault<T>;
+export declare function prefault<T extends SomeType>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): ZodMiniPrefault<T>;
 export interface ZodMiniNonOptional<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodNonOptionalInternals<T>> {
 }
 export declare const ZodMiniNonOptional: core.$constructor<ZodMiniNonOptional>;

package/node_modules/zod/v4/mini/schemas.d.ts

@@ -1,4 +1,5 @@
 import * as core from "../core/index.js";
+import type { $ZodBigIntFormats } from "../core/index.js";
 import * as util from "../core/util.js";
 type SomeType = core.SomeType;
 export interface ZodMiniType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
@@ -15,7 +16,7 @@ export interface ZodMiniType<out Output = unknown, out Input = unknown, out Inte
     safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): util.SafeParseResult<core.output<this>>;
     parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<util.SafeParseResult<core.output<this>>>;
-    apply<T>(fn: (schema: this) => T): T;
+    apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
 }
 interface _ZodMiniType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodMiniType<any, any, Internals> {
 }
@@ -127,6 +128,14 @@ export interface ZodMiniE164 extends _ZodMiniString<core.$ZodE164Internals> {
 }
 export declare const ZodMiniE164: core.$constructor<ZodMiniE164>;
 export declare function e164(params?: string | core.$ZodE164Params): ZodMiniE164;
+export interface ZodMiniCreditCard extends _ZodMiniString<core.$ZodCreditCardInternals> {
+}
+export declare const ZodMiniCreditCard: core.$constructor<ZodMiniCreditCard>;
+export declare function creditCard(params?: string | core.$ZodCreditCardParams): ZodMiniCreditCard;
+export interface ZodMiniIBAN extends _ZodMiniString<core.$ZodIBANInternals> {
+}
+export declare const ZodMiniIBAN: core.$constructor<ZodMiniIBAN>;
+export declare function iban(params?: string | core.$ZodIBANParams): ZodMiniIBAN;
 export interface ZodMiniJWT extends _ZodMiniString<core.$ZodJWTInternals> {
 }
 export declare const ZodMiniJWT: core.$constructor<ZodMiniJWT>;
@@ -138,6 +147,7 @@ export declare const ZodMiniCustomStringFormat: core.$constructor<ZodMiniCustomS
 export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<Format>;
 export declare function hostname(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"hostname">;
 export declare function hex(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"hex">;
+export declare function currencyCode(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<"currency_code">;
 export declare function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = "hex">(alg: Alg, params?: {
     enc?: Enc;
 } & core.$ZodStringFormatParams): ZodMiniCustomStringFormat<`${Alg}_${Enc}`>;
@@ -148,14 +158,24 @@ export interface ZodMiniNumber<Input = unknown> extends _ZodMiniNumber<core.$Zod
 }
 export declare const ZodMiniNumber: core.$constructor<ZodMiniNumber>;
 export declare function number(params?: string | core.$ZodNumberParams): ZodMiniNumber<number>;
-export interface ZodMiniNumberFormat extends _ZodMiniNumber<core.$ZodNumberFormatInternals>, core.$ZodNumberFormat {
+export interface ZodMiniNumberFormat<Format extends core.$ZodNumberFormats = core.$ZodNumberFormats> extends _ZodMiniNumber<core.$ZodNumberFormatInternals<Format>>, core.$ZodNumberFormat<Format> {
 }
 export declare const ZodMiniNumberFormat: core.$constructor<ZodMiniNumberFormat>;
-export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
+export interface ZodMiniInt extends ZodMiniNumberFormat<"safeint"> {
+}
+export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniInt;
+export interface ZodMiniFloat32 extends ZodMiniNumberFormat<"float32"> {
+}
+export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniFloat32;
+export interface ZodMiniFloat64 extends ZodMiniNumberFormat<"float64"> {
+}
+export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniFloat64;
+export interface ZodMiniInt32 extends ZodMiniNumberFormat<"int32"> {
+}
+export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniInt32;
+export interface ZodMiniUInt32 extends ZodMiniNumberFormat<"uint32"> {
+}
+export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniUInt32;
 export interface ZodMiniBoolean<T = unknown> extends _ZodMiniType<core.$ZodBooleanInternals<T>> {
 }
 export declare const ZodMiniBoolean: core.$constructor<ZodMiniBoolean>;
@@ -164,11 +184,15 @@ export interface ZodMiniBigInt<T = unknown> extends _ZodMiniType<core.$ZodBigInt
 }
 export declare const ZodMiniBigInt: core.$constructor<ZodMiniBigInt>;
 export declare function bigint(params?: string | core.$ZodBigIntParams): ZodMiniBigInt<bigint>;
-export interface ZodMiniBigIntFormat extends _ZodMiniType<core.$ZodBigIntFormatInternals> {
+export interface ZodMiniBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends _ZodMiniType<core.$ZodBigIntFormatInternals<Format>> {
 }
 export declare const ZodMiniBigIntFormat: core.$constructor<ZodMiniBigIntFormat>;
-export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
-export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
+export interface ZodMiniInt64 extends ZodMiniBigIntFormat<"int64"> {
+}
+export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniInt64;
+export interface ZodMiniUInt64 extends ZodMiniBigIntFormat<"uint64"> {
+}
+export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniUInt64;
 export interface ZodMiniSymbol extends _ZodMiniType<core.$ZodSymbolInternals> {
 }
 export declare const ZodMiniSymbol: core.$constructor<ZodMiniSymbol>;
@@ -223,8 +247,10 @@ export type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLo
     [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];
 };
 export declare function safeExtend<T extends ZodMiniObject, U extends core.$ZodLooseShape>(schema: T, shape: SafeExtendShape<T["shape"], U>): ZodMiniObject<util.Extend<T["shape"], util.Writeable<U>>, T["_zod"]["config"]>;
-/** @deprecated Identical to `z.extend(A, B)` */
-export declare function merge<T extends ZodMiniObject, U extends ZodMiniObject>(a: T, b: U): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, T["_zod"]["config"]>;
+/**
+ * @deprecated Use [`z.extend(A, B.shape)`](https://zod.dev/api?id=extend) instead.
+ */
+export declare function merge<T extends ZodMiniObject, U extends ZodMiniObject>(a: T, b: U): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, U["_zod"]["config"]>;
 export declare function pick<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<util.Flatten<Pick<T["shape"], keyof T["shape"] & keyof M>>, T["_zod"]["config"]>;
 export declare function omit<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<util.Flatten<Omit<T["shape"], keyof M>>, T["_zod"]["config"]>;
 export declare function partial<T extends ZodMiniObject>(schema: T): ZodMiniObject<{
@@ -233,6 +259,15 @@ export declare function partial<T extends ZodMiniObject>(schema: T): ZodMiniObje
 export declare function partial<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<{
     -readonly [k in keyof T["shape"]]: k extends keyof M ? ZodMiniOptional<T["shape"][k]> : T["shape"][k];
 }, T["_zod"]["config"]>;
+export declare function partial<T extends util.TupleItems, Rest extends SomeType | null>(schema: ZodMiniTuple<T, Rest>): ZodMiniTuple<{
+    -readonly [k in keyof T]: ZodMiniOptional<T[k]>;
+}, Rest>;
+export declare function exactPartial<T extends ZodMiniObject>(schema: T): ZodMiniObject<{
+    -readonly [k in keyof T["shape"]]: ZodMiniExactOptional<T["shape"][k]>;
+}, T["_zod"]["config"]>;
+export declare function exactPartial<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<{
+    -readonly [k in keyof T["shape"]]: k extends keyof M ? ZodMiniExactOptional<T["shape"][k]> : T["shape"][k];
+}, T["_zod"]["config"]>;
 export type RequiredInterfaceShape<Shape extends core.$ZodLooseShape, Keys extends PropertyKey = keyof Shape> = util.Identity<{
     [k in keyof Shape as k extends Keys ? k : never]: ZodMiniNonOptional<Shape[k]>;
 } & {
@@ -260,7 +295,7 @@ export interface ZodMiniDiscriminatedUnion<Options extends readonly SomeType[] =
     _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
 }
 export declare const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUnion>;
-export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
+export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
 export interface ZodMiniIntersection<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodIntersectionInternals<A, B>> {
 }
 export declare const ZodMiniIntersection: core.$constructor<ZodMiniIntersection>;
@@ -333,7 +368,7 @@ export declare function _default<T extends SomeType>(innerType: T, defaultValue:
 export interface ZodMiniPrefault<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPrefaultInternals<T>> {
 }
 export declare const ZodMiniPrefault: core.$constructor<ZodMiniPrefault>;
-export declare function prefault<T extends SomeType>(innerType: T, defaultValue: util.NoUndefined<core.input<T>> | (() => util.NoUndefined<core.input<T>>)): ZodMiniPrefault<T>;
+export declare function prefault<T extends SomeType>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): ZodMiniPrefault<T>;
 export interface ZodMiniNonOptional<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodNonOptionalInternals<T>> {
 }
 export declare const ZodMiniNonOptional: core.$constructor<ZodMiniNonOptional>;

package/node_modules/zod/v4/mini/schemas.js

@@ -1,4 +1,5 @@
 import * as core from "../core/index.js";
+import * as regexes from "../core/regexes.js";
 import * as util from "../core/util.js";
 import * as parse from "./parse.js";
 export const ZodMiniType = /*@__PURE__*/ core.$constructor("ZodMiniType", (inst, def) => {
@@ -7,31 +8,49 @@ export const ZodMiniType = /*@__PURE__*/ core.$constructor("ZodMiniType", (inst,
     core.$ZodType.init(inst, def);
     inst.def = def;
     inst.type = def.type;
-    inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });
-    inst.safeParse = (data, params) => parse.safeParse(inst, data, params);
-    inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });
-    inst.safeParseAsync = async (data, params) => parse.safeParseAsync(inst, data, params);
-    inst.check = (...checks) => {
-        return inst.clone({
+}, {
+    // `with` is an alias for `check`: the same function object, not a wrapper.
+    get with() {
+        return this.check;
+    },
+    set with(value) {
+        util.own(this, "with", value);
+    },
+    parse(data, params) {
+        return parse.parse(this, data, params, { callee: this.parse });
+    },
+    parseAsync(data, params) {
+        return parse.parseAsync(this, data, params, { callee: this.parseAsync });
+    },
+    safeParse(data, params) {
+        return parse.safeParse(this, data, params);
+    },
+    safeParseAsync(data, params) {
+        return parse.safeParseAsync(this, data, params);
+    },
+    check(...checks) {
+        const def = this.def;
+        return this.clone({
             ...def,
             checks: [
                 ...(def.checks ?? []),
-                ...checks.map((ch) => typeof ch === "function"
-                    ? {
-                        _zod: { check: ch, def: { check: "custom" }, onattach: [] },
-                    }
-                    : ch),
+                ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
             ],
         }, { parent: true });
-    };
-    inst.with = inst.check;
-    inst.clone = (_def, params) => core.clone(inst, _def, params);
-    inst.brand = () => inst;
-    inst.register = ((reg, meta) => {
-        reg.add(inst, meta);
-        return inst;
-    });
-    inst.apply = (fn) => fn(inst);
+    },
+    clone(_def, params) {
+        return core.clone(this, _def, params);
+    },
+    brand() {
+        return this;
+    },
+    register(reg, meta) {
+        reg.add(this, meta);
+        return this;
+    },
+    apply(fn, ...args) {
+        return args.length === 0 ? fn(this) : fn(this, ...args);
+    },
 });
 export const ZodMiniString = /*@__PURE__*/ core.$constructor("ZodMiniString", (inst, def) => {
     core.$ZodString.init(inst, def);
@@ -94,8 +113,8 @@ export function url(params) {
 // @__NO_SIDE_EFFECTS__
 export function httpUrl(params) {
     return core._url(ZodMiniURL, {
-        protocol: core.regexes.httpProtocol,
-        hostname: core.regexes.domain,
+        protocol: regexes.httpProtocol,
+        hostname: regexes.domain,
         ...util.normalizeParams(params),
     });
 }
@@ -231,6 +250,22 @@ export const ZodMiniE164 = /*@__PURE__*/ core.$constructor("ZodMiniE164", (inst,
 export function e164(params) {
     return core._e164(ZodMiniE164, params);
 }
+export const ZodMiniCreditCard = /*@__PURE__*/ core.$constructor("ZodMiniCreditCard", (inst, def) => {
+    core.$ZodCreditCard.init(inst, def);
+    ZodMiniStringFormat.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+export function creditCard(params) {
+    return core._creditCard(ZodMiniCreditCard, params);
+}
+export const ZodMiniIBAN = /*@__PURE__*/ core.$constructor("ZodMiniIBAN", (inst, def) => {
+    core.$ZodIBAN.init(inst, def);
+    ZodMiniStringFormat.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+export function iban(params) {
+    return core._iban(ZodMiniIBAN, params);
+}
 export const ZodMiniJWT = /*@__PURE__*/ core.$constructor("ZodMiniJWT", (inst, def) => {
     core.$ZodJWT.init(inst, def);
     ZodMiniStringFormat.init(inst, def);
@@ -249,11 +284,15 @@ export function stringFormat(format, fnOrRegex, _params = {}) {
 }
 // @__NO_SIDE_EFFECTS__
 export function hostname(_params) {
-    return core._stringFormat(ZodMiniCustomStringFormat, "hostname", core.regexes.hostname, _params);
+    return core._stringFormat(ZodMiniCustomStringFormat, "hostname", regexes.hostname, _params);
 }
 // @__NO_SIDE_EFFECTS__
 export function hex(_params) {
-    return core._stringFormat(ZodMiniCustomStringFormat, "hex", core.regexes.hex, _params);
+    return core._stringFormat(ZodMiniCustomStringFormat, "hex", regexes.hex, _params);
+}
+// @__NO_SIDE_EFFECTS__
+export function currencyCode(_params) {
+    return core._stringFormat(ZodMiniCustomStringFormat, "currency_code", regexes.currencyCode, _params);
 }
 // @__NO_SIDE_EFFECTS__
 export function hash(alg, params) {
@@ -277,28 +316,18 @@ export const ZodMiniNumberFormat = /*@__PURE__*/ core.$constructor("ZodMiniNumbe
     core.$ZodNumberFormat.init(inst, def);
     ZodMiniNumber.init(inst, def);
 });
-// int
-// @__NO_SIDE_EFFECTS__
 export function int(params) {
     return core._int(ZodMiniNumberFormat, params);
 }
-// float32
-// @__NO_SIDE_EFFECTS__
 export function float32(params) {
     return core._float32(ZodMiniNumberFormat, params);
 }
-// float64
-// @__NO_SIDE_EFFECTS__
 export function float64(params) {
     return core._float64(ZodMiniNumberFormat, params);
 }
-// int32
-// @__NO_SIDE_EFFECTS__
 export function int32(params) {
     return core._int32(ZodMiniNumberFormat, params);
 }
-// uint32
-// @__NO_SIDE_EFFECTS__
 export function uint32(params) {
     return core._uint32(ZodMiniNumberFormat, params);
 }
@@ -322,13 +351,9 @@ export const ZodMiniBigIntFormat = /*@__PURE__*/ core.$constructor("ZodMiniBigIn
     core.$ZodBigIntFormat.init(inst, def);
     ZodMiniBigInt.init(inst, def);
 });
-// int64
-// @__NO_SIDE_EFFECTS__
 export function int64(params) {
     return core._int64(ZodMiniBigIntFormat, params);
 }
-// uint64
-// @__NO_SIDE_EFFECTS__
 export function uint64(params) {
     return core._uint64(ZodMiniBigIntFormat, params);
 }
@@ -420,7 +445,7 @@ export function keyof(schema) {
 export const ZodMiniObject = /*@__PURE__*/ core.$constructor("ZodMiniObject", (inst, def) => {
     core.$ZodObject.init(inst, def);
     ZodMiniType.init(inst, def);
-    util.defineLazy(inst, "shape", () => def.shape);
+    util.installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
 });
 // @__NO_SIDE_EFFECTS__
 export function object(shape, params) {
@@ -460,9 +485,12 @@ export function extend(schema, shape) {
 export function safeExtend(schema, shape) {
     return util.safeExtend(schema, shape);
 }
+/**
+ * @deprecated Use [`z.extend(A, B.shape)`](https://zod.dev/api?id=extend) instead.
+ */
 // @__NO_SIDE_EFFECTS__
-export function merge(schema, shape) {
-    return util.extend(schema, shape);
+export function merge(a, b) {
+    return util.merge(a, b);
 }
 // @__NO_SIDE_EFFECTS__
 export function pick(schema, mask) {
@@ -475,7 +503,20 @@ export function omit(schema, mask) {
 }
 // @__NO_SIDE_EFFECTS__
 export function partial(schema, mask) {
-    return util.partial(ZodMiniOptional, schema, mask);
+    const def = schema._zod.def;
+    if (def.type !== "tuple")
+        return util.partial(ZodMiniOptional, schema, mask);
+    // a refinement was authored against the full arity; partialing would run it on a shorter array
+    if (def.checks?.length)
+        throw new Error(".partial() cannot be used on tuple schemas containing refinements");
+    return util.clone(schema, {
+        ...def,
+        items: def.items.map((item) => new ZodMiniOptional({ type: "optional", innerType: item })),
+    });
+}
+// @__NO_SIDE_EFFECTS__
+export function exactPartial(schema, mask) {
+    return util.partial(ZodMiniExactOptional, schema, mask, "exactPartial");
 }
 // @__NO_SIDE_EFFECTS__
 export function required(schema, mask) {
@@ -483,7 +524,8 @@ export function required(schema, mask) {
 }
 // @__NO_SIDE_EFFECTS__
 export function catchall(inst, catchall) {
-    return inst.clone({ ...inst._zod.def, catchall: catchall });
+    // `mergeDefs` rather than a spread: spreading reads `shape`, and resolving it can mint a whole fresh subtree
+    return inst.clone(util.mergeDefs(inst._zod.def, { catchall: catchall }));
 }
 export const ZodMiniUnion = /*@__PURE__*/ core.$constructor("ZodMiniUnion", (inst, def) => {
     core.$ZodUnion.init(inst, def);
@@ -520,7 +562,7 @@ export const ZodMiniDiscriminatedUnion = /*@__PURE__*/ core.$constructor("ZodMin
 export function discriminatedUnion(discriminator, options, params) {
     return new ZodMiniDiscriminatedUnion({
         type: "union",
-        options,
+        options: options,
         discriminator,
         ...util.normalizeParams(params),
     });
@@ -577,13 +619,12 @@ export function record(keyType, valueType, params) {
 }
 // @__NO_SIDE_EFFECTS__
 export function partialRecord(keyType, valueType, params) {
-    const k = core.clone(keyType);
-    k._zod.values = undefined;
     return new ZodMiniRecord({
         type: "record",
-        keyType: k,
+        keyType,
         valueType: valueType,
         ...util.normalizeParams(params),
+        partial: true,
     });
 }
 export function looseRecord(keyType, valueType, params) {
@@ -623,7 +664,8 @@ export function set(valueType, params) {
 export const ZodMiniEnum = /*@__PURE__*/ core.$constructor("ZodMiniEnum", (inst, def) => {
     core.$ZodEnum.init(inst, def);
     ZodMiniType.init(inst, def);
-    inst.options = Object.values(def.entries);
+    // reuse the parsed value set so a numeric TS enum's reverse-mapping keys stay out
+    inst.options = [...inst._zod.values];
 });
 // @__NO_SIDE_EFFECTS__
 function _enum(values, params) {
@@ -779,7 +821,7 @@ function _catch(innerType, catchValue) {
     return new ZodMiniCatch({
         type: "catch",
         innerType: innerType,
-        catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue),
+        catchValue: (typeof catchValue === "function" ? catchValue : core.util.constantCatch(catchValue)),
     });
 }
 export { _catch as catch };
@@ -891,8 +933,7 @@ export function check(fn, params) {
     ch._zod.check = fn;
     return ch;
 }
-// ZodCustom
-// custom schema
+// ZodCustom custom schema
 // @__NO_SIDE_EFFECTS__
 export function custom(fn, _params) {
     return core._custom(ZodMiniCustom, fn ?? (() => true), _params);

package/node_modules/zod/v4-mini/index.cjs

@@ -30,3 +30,22 @@ exports.z = void 0;
 const z = __importStar(require("../v4/mini/external.cjs"));
 exports.z = z;
 __exportStar(require("../v4/mini/external.cjs"), exports);
+
+// seal-cjs-exports
+(function () {
+  var keys = Object.getOwnPropertyNames(exports);
+  for (var i = 0; i < keys.length; i++) {
+    var desc = Object.getOwnPropertyDescriptor(exports, keys[i]);
+    if (!desc || !desc.get || !desc.configurable) continue;
+    var value;
+    try {
+      value = desc.get();
+    } catch (e) {
+      continue;
+    }
+    // a circular require may not have settled this one yet, so leave it live
+    if (value === undefined) continue;
+    Object.defineProperty(exports, keys[i], { value: value, writable: false, enumerable: desc.enumerable, configurable: false });
+  }
+  Object.freeze(exports);
+})();

package/openclaw.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "firecrawl",
-  "categories": ["web", "tools"],
+  "categories": ["web"],
   "activation": {
     "onStartup": false
   },
@@ -39,6 +39,20 @@
     "webSearchProviders": ["firecrawl", "firecrawl-free"],
     "tools": ["firecrawl_search", "firecrawl_scrape"]
   },
+  "configGroups": [
+    {
+      "id": "web-search",
+      "title": "Web search",
+      "order": 10,
+      "properties": ["webSearch"]
+    },
+    {
+      "id": "web-fetch",
+      "title": "Web fetch",
+      "order": 20,
+      "properties": ["webFetch"]
+    }
+  ],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/firecrawl-plugin",
-  "version": "2026.9.4",
+  "version": "2026.9.6",
   "description": "OpenClaw Firecrawl plugin.",
   "repository": {
     "type": "git",
@@ -8,8 +8,8 @@
   },
   "type": "module",
   "dependencies": {
-    "typebox": "1.3.18",
-    "zod": "4.4.3"
+    "typebox": "1.3.30",
+    "zod": "4.6.5"
   },
   "openclaw": {
     "extensions": [
@@ -22,10 +22,10 @@
       "minHostVersion": ">=2026.6.8"
     },
     "compat": {
-      "pluginApi": ">=2026.9.4"
+      "pluginApi": ">=2026.9.6"
     },
     "build": {
-      "openclawVersion": "2026.9.4",
+      "openclawVersion": "2026.9.6",
       "bundledDist": false
     },
     "release": {
@@ -39,10 +39,12 @@
   "files": [
     "dist/**",
     "openclaw.plugin.json",
-    "README.md"
+    "README.md",
+    "assets/icon.png",
+    "assets/activity.svg"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.9.4"
+    "openclaw": ">=2026.9.6"
   },
   "peerDependenciesMeta": {
     "openclaw": {