golar 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "golar",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "engines": {
     "node": ">=22.12.0"
@@ -30,15 +30,15 @@
   },
   "dependencies": {
     "detect-libc": "^2.1.2",
-    "@golar/util": "0.1.4"
+    "@golar/util": "0.1.5"
   },
   "optionalDependencies": {
-    "@golar/darwin-arm64": "0.1.4",
-    "@golar/linux-arm64": "0.1.4",
-    "@golar/darwin-x64": "0.1.4",
-    "@golar/linux-arm64-musl": "0.1.4",
-    "@golar/linux-x64-musl": "0.1.4",
-    "@golar/win32-x64": "0.1.4",
-    "@golar/linux-x64": "0.1.4"
+    "@golar/darwin-x64": "0.1.5",
+    "@golar/linux-arm64": "0.1.5",
+    "@golar/darwin-arm64": "0.1.5",
+    "@golar/linux-x64": "0.1.5",
+    "@golar/linux-arm64-musl": "0.1.5",
+    "@golar/linux-x64-musl": "0.1.5",
+    "@golar/win32-x64": "0.1.5"
   }
 }

package/dist/node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.d.ts

@@ -1,22 +0,0 @@
-import { $ZodError, $ZodErrorMap, $ZodFlattenedError, $ZodFormattedError, $ZodIssue } from "../core/errors.js";
-import { $constructor } from "../core/core.js";
-
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.d.cts
-/** An Error-like class used to store Zod validation issues.  */
-interface ZodError<T = unknown> extends $ZodError<T> {
-  /** @deprecated Use the `z.treeifyError(err)` function instead. */
-  format(): $ZodFormattedError<T>;
-  format<U>(mapper: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
-  /** @deprecated Use the `z.treeifyError(err)` function instead. */
-  flatten(): $ZodFlattenedError<T>;
-  flatten<U>(mapper: (issue: $ZodIssue) => U): $ZodFlattenedError<T, U>;
-  /** @deprecated Push directly to `.issues` instead. */
-  addIssue(issue: $ZodIssue): void;
-  /** @deprecated Push directly to `.issues` instead. */
-  addIssues(issues: $ZodIssue[]): void;
-  /** @deprecated Check `err.issues.length === 0` instead. */
-  isEmpty: boolean;
-}
-declare const ZodError: $constructor<ZodError>;
-//#endregion
-export { ZodError };

package/dist/node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.js

@@ -1,29 +0,0 @@
-import { $constructor } from "../core/core.js";
-import { jsonStringifyReplacer } from "../core/util.js";
-import { $ZodError, flattenError, formatError } from "../core/errors.js";
-
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.js
-const initializer = (inst, issues) => {
-	$ZodError.init(inst, issues);
-	inst.name = "ZodError";
-	Object.defineProperties(inst, {
-		format: { value: (mapper) => formatError(inst, mapper) },
-		flatten: { value: (mapper) => flattenError(inst, mapper) },
-		addIssue: { value: (issue) => {
-			inst.issues.push(issue);
-			inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
-		} },
-		addIssues: { value: (issues) => {
-			inst.issues.push(...issues);
-			inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
-		} },
-		isEmpty: { get() {
-			return inst.issues.length === 0;
-		} }
-	});
-};
-const ZodError = $constructor("ZodError", initializer);
-const ZodRealError = $constructor("ZodError", initializer, { Parent: Error });
-
-//#endregion
-export { ZodRealError };

package/dist/node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/iso.js

@@ -1,37 +0,0 @@
-import { $constructor } from "../core/core.js";
-import { $ZodISODate, $ZodISODateTime, $ZodISODuration, $ZodISOTime } from "../core/schemas.js";
-import { _isoDate, _isoDateTime, _isoDuration, _isoTime } from "../core/api.js";
-import { ZodStringFormat } from "./schemas.js";
-
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/iso.js
-const ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
-	$ZodISODateTime.init(inst, def);
-	ZodStringFormat.init(inst, def);
-});
-function datetime(params) {
-	return _isoDateTime(ZodISODateTime, params);
-}
-const ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
-	$ZodISODate.init(inst, def);
-	ZodStringFormat.init(inst, def);
-});
-function date(params) {
-	return _isoDate(ZodISODate, params);
-}
-const ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
-	$ZodISOTime.init(inst, def);
-	ZodStringFormat.init(inst, def);
-});
-function time(params) {
-	return _isoTime(ZodISOTime, params);
-}
-const ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
-	$ZodISODuration.init(inst, def);
-	ZodStringFormat.init(inst, def);
-});
-function duration(params) {
-	return _isoDuration(ZodISODuration, params);
-}
-
-//#endregion
-export { date, datetime, duration, time };

package/dist/node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/parse.d.ts

@@ -1,16 +0,0 @@
-import { ZodError } from "./errors.js";
-
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/parse.d.cts
-type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
-type ZodSafeParseSuccess<T> = {
-  success: true;
-  data: T;
-  error?: never;
-};
-type ZodSafeParseError<T> = {
-  success: false;
-  data?: never;
-  error: ZodError<T>;
-};
-//#endregion
-export { ZodSafeParseResult };

package/dist/node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/parse.js

@@ -1,19 +0,0 @@
-import { _decode, _decodeAsync, _encode, _encodeAsync, _parse, _parseAsync, _safeDecode, _safeDecodeAsync, _safeEncode, _safeEncodeAsync, _safeParse, _safeParseAsync } from "../core/parse.js";
-import { ZodRealError } from "./errors.js";
-
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/parse.js
-const parse = /* @__PURE__ */ _parse(ZodRealError);
-const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
-const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
-const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
-const encode = /* @__PURE__ */ _encode(ZodRealError);
-const decode = /* @__PURE__ */ _decode(ZodRealError);
-const encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
-const decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
-const safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
-const safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
-const safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
-const safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
-
-//#endregion
-export { decode, decodeAsync, encode, encodeAsync, parse, parseAsync, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync };

package/dist/node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.d.ts

@@ -1,208 +0,0 @@
-import { StandardSchemaWithJSONProps } from "../core/standard-schema.js";
-import { $ZodRegistry, $replace, GlobalMeta } from "../core/registries.js";
-import { ToJSONSchemaParams, ZodStandardJSONSchemaPayload } from "../core/to-json-schema.js";
-import { EnumLike, Extend, Flatten, Mask, NoUndefined, ToEnum } from "../core/util.js";
-import { $ZodArray, $ZodArrayInternals, $ZodBooleanInternals, $ZodCatch, $ZodCatchCtx, $ZodCatchInternals, $ZodDefault, $ZodDefaultInternals, $ZodEnum, $ZodEnumInternals, $ZodExactOptional, $ZodExactOptionalInternals, $ZodIntersection, $ZodIntersectionInternals, $ZodLooseShape, $ZodNonOptional, $ZodNonOptionalInternals, $ZodNullable, $ZodNullableInternals, $ZodObject, $ZodObjectConfig, $ZodObjectInternals, $ZodOptional, $ZodOptionalInternals, $ZodPipe, $ZodPipeInternals, $ZodPrefault, $ZodPrefaultInternals, $ZodReadonly, $ZodReadonlyInternals, $ZodShape, $ZodTransform, $ZodTransformInternals, $ZodType, $ZodTypeInternals, $ZodUnion, $ZodUnionInternals, $catchall, $loose, $strict, $strip, CheckFn, ParseContext, SomeType } from "../core/schemas.js";
-import { $ZodCheck } from "../core/checks.js";
-import { $ZodIssue } from "../core/errors.js";
-import { $ZodBranded, $constructor, input, output } from "../core/core.js";
-import { $RefinementCtx, $ZodCheckLengthEqualsParams, $ZodCheckMaxLengthParams, $ZodCheckMinLengthParams, $ZodCustomParams, $ZodEnumParams, $ZodNonOptionalParams } from "../core/api.js";
-import { ZodSafeParseResult } from "./parse.js";
-
-//#region ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.d.cts
-type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
-interface ZodType<out Output = unknown, out Input = unknown, out Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> extends $ZodType<Output, Input, Internals> {
-  def: Internals["def"];
-  type: Internals["def"]["type"];
-  /** @deprecated Use `.def` instead. */
-  _def: Internals["def"];
-  /** @deprecated Use `z.output<typeof schema>` instead. */
-  _output: Internals["output"];
-  /** @deprecated Use `z.input<typeof schema>` instead. */
-  _input: Internals["input"];
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  /** Converts this schema to a JSON Schema representation. */
-  toJSONSchema(params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<this>;
-  check(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
-  with(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
-  clone(def?: Internals["def"], params?: {
-    parent: boolean;
-  }): this;
-  register<R extends $ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [$replace<R["_meta"], this>?] : [$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
-  brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T): PropertyKey extends T ? this : $ZodBranded<this, T, Dir>;
-  parse(data: unknown, params?: ParseContext<$ZodIssue>): output<this>;
-  safeParse(data: unknown, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
-  parseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
-  safeParseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
-  spa: (data: unknown, params?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output<this>>>;
-  encode(data: output<this>, params?: ParseContext<$ZodIssue>): input<this>;
-  decode(data: input<this>, params?: ParseContext<$ZodIssue>): output<this>;
-  encodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<input<this>>;
-  decodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
-  safeEncode(data: output<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<input<this>>;
-  safeDecode(data: input<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
-  safeEncodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<input<this>>>;
-  safeDecodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
-  refine<Ch extends (arg: output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | $ZodCustomParams): Ch extends ((arg: any) => arg is infer R) ? this & ZodType<R, input<this>> : this;
-  superRefine(refinement: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => void | Promise<void>): this;
-  overwrite(fn: (x: output<this>) => output<this>): this;
-  optional(): ZodOptional<this>;
-  exactOptional(): ZodExactOptional<this>;
-  nonoptional(params?: string | $ZodNonOptionalParams): ZodNonOptional<this>;
-  nullable(): ZodNullable<this>;
-  nullish(): ZodOptional<ZodNullable<this>>;
-  default(def: NoUndefined<output<this>>): ZodDefault<this>;
-  default(def: () => NoUndefined<output<this>>): ZodDefault<this>;
-  prefault(def: () => input<this>): ZodPrefault<this>;
-  prefault(def: input<this>): ZodPrefault<this>;
-  array(): ZodArray<this>;
-  or<T extends SomeType>(option: T): ZodUnion<[this, T]>;
-  and<T extends SomeType>(incoming: T): ZodIntersection<this, T>;
-  transform<NewOut>(transform: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output<this>>>;
-  catch(def: output<this>): ZodCatch<this>;
-  catch(def: (ctx: $ZodCatchCtx) => output<this>): ZodCatch<this>;
-  pipe<T extends $ZodType<any, output<this>>>(target: T | $ZodType<any, output<this>>): ZodPipe<this, T>;
-  readonly(): ZodReadonly<this>;
-  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
-  describe(description: string): this;
-  description?: string;
-  /** Returns the metadata associated with this instance in `z.globalRegistry` */
-  meta(): $replace<GlobalMeta, this> | undefined;
-  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
-  meta(data: $replace<GlobalMeta, this>): this;
-  /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
-   *
-   * ```ts
-   * const schema = z.string().optional();
-   * const isOptional = schema.safeParse(undefined).success; // true
-   * ```
-   */
-  isOptional(): boolean;
-  /**
-   * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
-   *
-   * ```ts
-   * const schema = z.string().nullable();
-   * const isNullable = schema.safeParse(null).success; // true
-   * ```
-   */
-  isNullable(): boolean;
-  apply<T>(fn: (schema: this) => T): T;
-}
-interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType<any, any, Internals> {}
-declare const ZodType: $constructor<ZodType>;
-interface _ZodBoolean<T extends $ZodBooleanInternals = $ZodBooleanInternals> extends _ZodType<T> {}
-interface ZodBoolean extends _ZodBoolean<$ZodBooleanInternals<boolean>> {}
-declare const ZodBoolean: $constructor<ZodBoolean>;
-interface ZodArray<T extends SomeType = $ZodType> extends _ZodType<$ZodArrayInternals<T>>, $ZodArray<T> {
-  element: T;
-  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
-  nonempty(params?: string | $ZodCheckMinLengthParams): this;
-  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
-  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
-  unwrap(): T;
-  "~standard": ZodStandardSchemaWithJSON<this>;
-}
-declare const ZodArray: $constructor<ZodArray>;
-type SafeExtendShape<Base extends $ZodShape, Ext extends $ZodLooseShape> = { [K in keyof Ext]: K extends keyof Base ? output<Ext[K]> extends output<Base[K]> ? input<Ext[K]> extends input<Base[K]> ? Ext[K] : never : never : Ext[K] };
-interface ZodObject< /** @ts-ignore Cast variance */out Shape extends $ZodShape = $ZodLooseShape, out Config extends $ZodObjectConfig = $strip> extends _ZodType<$ZodObjectInternals<Shape, Config>>, $ZodObject<Shape, Config> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  shape: Shape;
-  keyof(): ZodEnum<ToEnum<keyof Shape & string>>;
-  /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
-  catchall<T extends SomeType>(schema: T): ZodObject<Shape, $catchall<T>>;
-  /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
-  passthrough(): ZodObject<Shape, $loose>;
-  /** Consider `z.looseObject(A.shape)` instead */
-  loose(): ZodObject<Shape, $loose>;
-  /** Consider `z.strictObject(A.shape)` instead */
-  strict(): ZodObject<Shape, $strict>;
-  /** This is the default behavior. This method call is likely unnecessary. */
-  strip(): ZodObject<Shape, $strip>;
-  extend<U extends $ZodLooseShape>(shape: U): ZodObject<Extend<Shape, U>, Config>;
-  safeExtend<U extends $ZodLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, SomeType>>): ZodObject<Extend<Shape, U>, Config>;
-  /**
-   * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
-   */
-  merge<U extends ZodObject>(other: U): ZodObject<Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
-  pick<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
-  omit<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
-  partial(): ZodObject<{ [k in keyof Shape]: ZodOptional<Shape[k]> }, Config>;
-  partial<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{ [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k] }, Config>;
-  required(): ZodObject<{ [k in keyof Shape]: ZodNonOptional<Shape[k]> }, Config>;
-  required<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{ [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k] }, Config>;
-}
-declare const ZodObject: $constructor<ZodObject>;
-interface ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodUnionInternals<T>>, $ZodUnion<T> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  options: T;
-}
-declare const ZodUnion: $constructor<ZodUnion>;
-interface ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-}
-declare const ZodIntersection: $constructor<ZodIntersection>;
-interface ZodEnum< /** @ts-ignore Cast variance */out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodEnum<T> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  enum: T;
-  options: Array<T[keyof T]>;
-  extract<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Pick<T, U[number]>>>;
-  exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Omit<T, U[number]>>>;
-}
-declare const ZodEnum: $constructor<ZodEnum>;
-interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-}
-declare const ZodTransform: $constructor<ZodTransform>;
-interface ZodOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  unwrap(): T;
-}
-declare const ZodOptional: $constructor<ZodOptional>;
-interface ZodExactOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodExactOptionalInternals<T>>, $ZodExactOptional<T> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  unwrap(): T;
-}
-declare const ZodExactOptional: $constructor<ZodExactOptional>;
-interface ZodNullable<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  unwrap(): T;
-}
-declare const ZodNullable: $constructor<ZodNullable>;
-interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  unwrap(): T;
-  /** @deprecated Use `.unwrap()` instead. */
-  removeDefault(): T;
-}
-declare const ZodDefault: $constructor<ZodDefault>;
-interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  unwrap(): T;
-}
-declare const ZodPrefault: $constructor<ZodPrefault>;
-interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  unwrap(): T;
-}
-declare const ZodNonOptional: $constructor<ZodNonOptional>;
-interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  unwrap(): T;
-  /** @deprecated Use `.unwrap()` instead. */
-  removeCatch(): T;
-}
-declare const ZodCatch: $constructor<ZodCatch>;
-interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  in: A;
-  out: B;
-}
-declare const ZodPipe: $constructor<ZodPipe>;
-interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
-  "~standard": ZodStandardSchemaWithJSON<this>;
-  unwrap(): T;
-}
-declare const ZodReadonly: $constructor<ZodReadonly>;
-//#endregion
-export { ZodBoolean, ZodDefault, ZodObject };