@shuttl-io/core 0.2.0

package/node_modules/zod/src/v4/classic/checks.ts

@@ -0,0 +1,32 @@
+export {
+  _lt as lt,
+  _lte as lte,
+  _gt as gt,
+  _gte as gte,
+  _positive as positive,
+  _negative as negative,
+  _nonpositive as nonpositive,
+  _nonnegative as nonnegative,
+  _multipleOf as multipleOf,
+  _maxSize as maxSize,
+  _minSize as minSize,
+  _size as size,
+  _maxLength as maxLength,
+  _minLength as minLength,
+  _length as length,
+  _regex as regex,
+  _lowercase as lowercase,
+  _uppercase as uppercase,
+  _includes as includes,
+  _startsWith as startsWith,
+  _endsWith as endsWith,
+  _property as property,
+  _mime as mime,
+  _overwrite as overwrite,
+  _normalize as normalize,
+  _trim as trim,
+  _toLowerCase as toLowerCase,
+  _toUpperCase as toUpperCase,
+  _slugify as slugify,
+  type $RefinementCtx as RefinementCtx,
+} from "../core/index.js";

package/node_modules/zod/src/v4/classic/coerce.ts

@@ -0,0 +1,27 @@
+import * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+
+export interface ZodCoercedString<T = unknown> extends schemas._ZodString<core.$ZodStringInternals<T>> {}
+export function string<T = unknown>(params?: string | core.$ZodStringParams): ZodCoercedString<T> {
+  return core._coercedString(schemas.ZodString, params) as any;
+}
+
+export interface ZodCoercedNumber<T = unknown> extends schemas._ZodNumber<core.$ZodNumberInternals<T>> {}
+export function number<T = unknown>(params?: string | core.$ZodNumberParams): ZodCoercedNumber<T> {
+  return core._coercedNumber(schemas.ZodNumber, params) as ZodCoercedNumber<T>;
+}
+
+export interface ZodCoercedBoolean<T = unknown> extends schemas._ZodBoolean<core.$ZodBooleanInternals<T>> {}
+export function boolean<T = unknown>(params?: string | core.$ZodBooleanParams): ZodCoercedBoolean<T> {
+  return core._coercedBoolean(schemas.ZodBoolean, params) as ZodCoercedBoolean<T>;
+}
+
+export interface ZodCoercedBigInt<T = unknown> extends schemas._ZodBigInt<core.$ZodBigIntInternals<T>> {}
+export function bigint<T = unknown>(params?: string | core.$ZodBigIntParams): ZodCoercedBigInt<T> {
+  return core._coercedBigint(schemas.ZodBigInt, params) as ZodCoercedBigInt<T>;
+}
+
+export interface ZodCoercedDate<T = unknown> extends schemas._ZodDate<core.$ZodDateInternals<T>> {}
+export function date<T = unknown>(params?: string | core.$ZodDateParams): ZodCoercedDate<T> {
+  return core._coercedDate(schemas.ZodDate, params) as ZodCoercedDate<T>;
+}

package/node_modules/zod/src/v4/classic/compat.ts

@@ -0,0 +1,70 @@
+// Zod 3 compat layer
+
+import * as core from "../core/index.js";
+import type { ZodType } from "./schemas.js";
+
+export type {
+  /** @deprecated Use `z.output<T>` instead. */
+  output as TypeOf,
+  /** @deprecated Use `z.output<T>` instead. */
+  output as Infer,
+  /** @deprecated Use `z.core.$$ZodFirstPartyTypes` instead */
+  $ZodTypes as ZodFirstPartySchemaTypes,
+} from "../core/index.js";
+
+/** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
+export const ZodIssueCode = {
+  invalid_type: "invalid_type",
+  too_big: "too_big",
+  too_small: "too_small",
+  invalid_format: "invalid_format",
+  not_multiple_of: "not_multiple_of",
+  unrecognized_keys: "unrecognized_keys",
+  invalid_union: "invalid_union",
+  invalid_key: "invalid_key",
+  invalid_element: "invalid_element",
+  invalid_value: "invalid_value",
+  custom: "custom",
+} as const;
+
+/** @deprecated Use `z.$ZodFlattenedError` */
+export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
+
+/** @deprecated Use `z.$ZodFormattedError` */
+export type inferFormattedError<T extends core.$ZodType<any, any>, U = string> = core.$ZodFormattedError<
+  core.output<T>,
+  U
+>;
+
+/** Use `z.$brand` instead */
+export type BRAND<T extends string | number | symbol = string | number | symbol> = {
+  [core.$brand]: { [k in T]: true };
+};
+export { $brand, config } from "../core/index.js";
+
+/** @deprecated Use `z.config(params)` instead. */
+export function setErrorMap(map: core.$ZodErrorMap): void {
+  core.config({
+    customError: map,
+  });
+}
+
+/** @deprecated Use `z.config()` instead. */
+export function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined {
+  return core.config().customError;
+}
+
+export type {
+  /** @deprecated Use z.ZodType (without generics) instead. */
+  ZodType as ZodTypeAny,
+  /** @deprecated Use `z.ZodType` */
+  ZodType as ZodSchema,
+  /** @deprecated Use `z.ZodType` */
+  ZodType as Schema,
+};
+
+/** Included for Zod 3 compatibility */
+export type ZodRawShape = core.$ZodShape;
+
+/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */
+export enum ZodFirstPartyTypeKind {}

package/node_modules/zod/src/v4/classic/errors.ts

@@ -0,0 +1,82 @@
+import * as core from "../core/index.js";
+import { $ZodError } from "../core/index.js";
+import * as util from "../core/util.js";
+
+/** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */
+export type ZodIssue = core.$ZodIssue;
+
+/** An Error-like class used to store Zod validation issues.  */
+export interface ZodError<T = unknown> extends $ZodError<T> {
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  format(): core.$ZodFormattedError<T>;
+  format<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFormattedError<T, U>;
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  flatten(): core.$ZodFlattenedError<T>;
+  flatten<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFlattenedError<T, U>;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssue(issue: core.$ZodIssue): void;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssues(issues: core.$ZodIssue[]): void;
+
+  /** @deprecated Check `err.issues.length === 0` instead. */
+  isEmpty: boolean;
+}
+
+const initializer = (inst: ZodError, issues: core.$ZodIssue[]) => {
+  $ZodError.init(inst, issues);
+  inst.name = "ZodError";
+  Object.defineProperties(inst, {
+    format: {
+      value: (mapper: any) => core.formatError(inst, mapper),
+      // enumerable: false,
+    },
+    flatten: {
+      value: (mapper: any) => core.flattenError(inst, mapper),
+      // enumerable: false,
+    },
+    addIssue: {
+      value: (issue: any) => {
+        inst.issues.push(issue);
+        inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);
+      },
+      // enumerable: false,
+    },
+    addIssues: {
+      value: (issues: any) => {
+        inst.issues.push(...issues);
+        inst.message = JSON.stringify(inst.issues, util.jsonStringifyReplacer, 2);
+      },
+      // enumerable: false,
+    },
+    isEmpty: {
+      get() {
+        return inst.issues.length === 0;
+      },
+      // enumerable: false,
+    },
+  });
+  // Object.defineProperty(inst, "isEmpty", {
+  //   get() {
+  //     return inst.issues.length === 0;
+  //   },
+  // });
+};
+export const ZodError: core.$constructor<ZodError> = core.$constructor("ZodError", initializer);
+export const ZodRealError: core.$constructor<ZodError> = core.$constructor("ZodError", initializer, {
+  Parent: Error,
+});
+
+export type {
+  /** @deprecated Use `z.core.$ZodFlattenedError` instead. */
+  $ZodFlattenedError as ZodFlattenedError,
+  /** @deprecated Use `z.core.$ZodFormattedError` instead. */
+  $ZodFormattedError as ZodFormattedError,
+  /** @deprecated Use `z.core.$ZodErrorMap` instead. */
+  $ZodErrorMap as ZodErrorMap,
+} from "../core/index.js";
+
+/** @deprecated Use `z.core.$ZodRawIssue` instead. */
+export type IssueData = core.$ZodRawIssue;
+
+// /** @deprecated Use `z.core.$ZodErrorMapCtx` instead. */
+// export type ErrorMapCtx = core.$ZodErrorMapCtx;

package/node_modules/zod/src/v4/classic/external.ts

@@ -0,0 +1,51 @@
+export * as core from "../core/index.js";
+export * from "./schemas.js";
+export * from "./checks.js";
+export * from "./errors.js";
+export * from "./parse.js";
+export * from "./compat.js";
+
+// zod-specified
+import { config } from "../core/index.js";
+import en from "../locales/en.js";
+config(en());
+
+export type { infer, output, input } from "../core/index.js";
+export {
+  globalRegistry,
+  type GlobalMeta,
+  registry,
+  config,
+  $output,
+  $input,
+  $brand,
+  clone,
+  regexes,
+  treeifyError,
+  prettifyError,
+  formatError,
+  flattenError,
+  TimePrecision,
+  util,
+  NEVER,
+} from "../core/index.js";
+export { toJSONSchema } from "../core/json-schema-processors.js";
+export { fromJSONSchema } from "./from-json-schema.js";
+
+export * as locales from "../locales/index.js";
+
+// iso
+// must be exported from top-level
+// https://github.com/colinhacks/zod/issues/4491
+export { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from "./iso.js";
+export * as iso from "./iso.js";
+
+// coerce
+export type {
+  ZodCoercedString,
+  ZodCoercedNumber,
+  ZodCoercedBigInt,
+  ZodCoercedBoolean,
+  ZodCoercedDate,
+} from "./coerce.js";
+export * as coerce from "./coerce.js";