pi-cursor-sdk 0.1.2 → 0.1.3

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

@@ -0,0 +1,30 @@
+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,
+} 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,66 @@
+// 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,
+};
+
+export type ZodRawShape = core.$ZodShape;

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

@@ -0,0 +1,75 @@
+import * as core from "../core/index.js";
+import { $ZodError } from "../core/index.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),
+      // enumerable: false,
+    },
+    addIssues: {
+      value: (issues: any) => inst.issues.push(...issues),
+      // 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,50 @@
+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,
+  function,
+  $output,
+  $input,
+  $brand,
+  clone,
+  regexes,
+  treeifyError,
+  prettifyError,
+  formatError,
+  flattenError,
+  toJSONSchema,
+  TimePrecision,
+  NEVER,
+} from "../core/index.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";

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

@@ -0,0 +1,5 @@
+import * as z from "./external.js";
+
+export { z };
+export * from "./external.js";
+export default z;

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

@@ -0,0 +1,90 @@
+import * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////                          //////////
+//////////      ZodISODateTime      //////////
+//////////                          //////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+
+export interface ZodISODateTime extends schemas.ZodStringFormat {
+  _zod: core.$ZodISODateTimeInternals;
+}
+export const ZodISODateTime: core.$constructor<ZodISODateTime> = /*@__PURE__*/ core.$constructor(
+  "ZodISODateTime",
+  (inst, def) => {
+    core.$ZodISODateTime.init(inst, def);
+    schemas.ZodStringFormat.init(inst, def);
+  }
+);
+
+export function datetime(params?: string | core.$ZodISODateTimeParams): ZodISODateTime {
+  return core._isoDateTime(ZodISODateTime, params);
+}
+
+//////////////////////////////////////////
+//////////////////////////////////////////
+//////////                      //////////
+//////////      ZodISODate      //////////
+//////////                      //////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+
+export interface ZodISODate extends schemas.ZodStringFormat {
+  _zod: core.$ZodISODateInternals;
+}
+export const ZodISODate: core.$constructor<ZodISODate> = /*@__PURE__*/ core.$constructor("ZodISODate", (inst, def) => {
+  core.$ZodISODate.init(inst, def);
+  schemas.ZodStringFormat.init(inst, def);
+});
+
+export function date(params?: string | core.$ZodISODateParams): ZodISODate {
+  return core._isoDate(ZodISODate, params);
+}
+
+// ZodISOTime
+
+//////////////////////////////////////////
+//////////////////////////////////////////
+//////////                      //////////
+//////////      ZodISOTime      //////////
+//////////                      //////////
+//////////////////////////////////////////
+//////////////////////////////////////////
+
+export interface ZodISOTime extends schemas.ZodStringFormat {
+  _zod: core.$ZodISOTimeInternals;
+}
+export const ZodISOTime: core.$constructor<ZodISOTime> = /*@__PURE__*/ core.$constructor("ZodISOTime", (inst, def) => {
+  core.$ZodISOTime.init(inst, def);
+  schemas.ZodStringFormat.init(inst, def);
+});
+
+export function time(params?: string | core.$ZodISOTimeParams): ZodISOTime {
+  return core._isoTime(ZodISOTime, params);
+}
+
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////                          //////////
+//////////      ZodISODuration      //////////
+//////////                          //////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+
+export interface ZodISODuration extends schemas.ZodStringFormat {
+  _zod: core.$ZodISODurationInternals;
+}
+export const ZodISODuration: core.$constructor<ZodISODuration> = /*@__PURE__*/ core.$constructor(
+  "ZodISODuration",
+  (inst, def) => {
+    core.$ZodISODuration.init(inst, def);
+    schemas.ZodStringFormat.init(inst, def);
+  }
+);
+
+export function duration(params?: string | core.$ZodISODurationParams): ZodISODuration {
+  return core._isoDuration(ZodISODuration, params);
+}

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

@@ -0,0 +1,33 @@
+import * as core from "../core/index.js";
+import { type ZodError, ZodRealError } from "./errors.js";
+
+export type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
+export type ZodSafeParseSuccess<T> = { success: true; data: T; error?: never };
+export type ZodSafeParseError<T> = { success: false; data?: never; error: ZodError<T> };
+
+export const parse: <T extends core.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: core.ParseContext<core.$ZodIssue>,
+  _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
+) => core.output<T> = /* @__PURE__ */ core._parse(ZodRealError) as any;
+
+export const parseAsync: <T extends core.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: core.ParseContext<core.$ZodIssue>,
+  _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
+) => Promise<core.output<T>> = /* @__PURE__ */ core._parseAsync(ZodRealError) as any;
+
+export const safeParse: <T extends core.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: core.ParseContext<core.$ZodIssue>
+  // _params?: { callee?: core.util.AnyFunc; Err?: core.$ZodErrorClass }
+) => ZodSafeParseResult<core.output<T>> = /* @__PURE__ */ core._safeParse(ZodRealError) as any;
+
+export const safeParseAsync: <T extends core.$ZodType>(
+  schema: T,
+  value: unknown,
+  _ctx?: core.ParseContext<core.$ZodIssue>
+) => Promise<ZodSafeParseResult<core.output<T>>> = /* @__PURE__ */ core._safeParseAsync(ZodRealError) as any;