switchboard-cli 0.1.0-alpha.3 → 0.1.0-alpha.5

package/node_modules/@switchboard/core/node_modules/zod/src/v3/tests/number.test.ts

@@ -1,176 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-const gtFive = z.number().gt(5);
-const gteFive = z.number().gte(-5).gte(5);
-const minFive = z.number().min(0).min(5);
-const ltFive = z.number().lte(10).lt(5);
-const lteFive = z.number().lte(5);
-const maxFive = z.number().max(10).max(5);
-const intNum = z.number().int();
-const positive = z.number().positive();
-const negative = z.number().negative();
-const nonpositive = z.number().nonpositive();
-const nonnegative = z.number().nonnegative();
-const multipleOfFive = z.number().multipleOf(5);
-const multipleOfNegativeFive = z.number().multipleOf(-5);
-const finite = z.number().finite();
-const safe = z.number().safe();
-const stepPointOne = z.number().step(0.1);
-const stepPointZeroZeroZeroOne = z.number().step(0.0001);
-const stepSixPointFour = z.number().step(6.4);
-
-test("passing validations", () => {
-  z.number().parse(1);
-  z.number().parse(1.5);
-  z.number().parse(0);
-  z.number().parse(-1.5);
-  z.number().parse(-1);
-  z.number().parse(Number.POSITIVE_INFINITY);
-  z.number().parse(Number.NEGATIVE_INFINITY);
-  gtFive.parse(6);
-  gtFive.parse(Number.POSITIVE_INFINITY);
-  gteFive.parse(5);
-  gteFive.parse(Number.POSITIVE_INFINITY);
-  minFive.parse(5);
-  minFive.parse(Number.POSITIVE_INFINITY);
-  ltFive.parse(4);
-  ltFive.parse(Number.NEGATIVE_INFINITY);
-  lteFive.parse(5);
-  lteFive.parse(Number.NEGATIVE_INFINITY);
-  maxFive.parse(5);
-  maxFive.parse(Number.NEGATIVE_INFINITY);
-  intNum.parse(4);
-  positive.parse(1);
-  positive.parse(Number.POSITIVE_INFINITY);
-  negative.parse(-1);
-  negative.parse(Number.NEGATIVE_INFINITY);
-  nonpositive.parse(0);
-  nonpositive.parse(-1);
-  nonpositive.parse(Number.NEGATIVE_INFINITY);
-  nonnegative.parse(0);
-  nonnegative.parse(1);
-  nonnegative.parse(Number.POSITIVE_INFINITY);
-  multipleOfFive.parse(15);
-  multipleOfFive.parse(-15);
-  multipleOfNegativeFive.parse(-15);
-  multipleOfNegativeFive.parse(15);
-  finite.parse(123);
-  safe.parse(Number.MIN_SAFE_INTEGER);
-  safe.parse(Number.MAX_SAFE_INTEGER);
-  stepPointOne.parse(6);
-  stepPointOne.parse(6.1);
-  stepPointOne.parse(6.1);
-  stepSixPointFour.parse(12.8);
-  stepPointZeroZeroZeroOne.parse(3.01);
-});
-
-test("failing validations", () => {
-  expect(() => ltFive.parse(5)).toThrow();
-  expect(() => lteFive.parse(6)).toThrow();
-  expect(() => maxFive.parse(6)).toThrow();
-  expect(() => gtFive.parse(5)).toThrow();
-  expect(() => gteFive.parse(4)).toThrow();
-  expect(() => minFive.parse(4)).toThrow();
-  expect(() => intNum.parse(3.14)).toThrow();
-  expect(() => positive.parse(0)).toThrow();
-  expect(() => positive.parse(-1)).toThrow();
-  expect(() => negative.parse(0)).toThrow();
-  expect(() => negative.parse(1)).toThrow();
-  expect(() => nonpositive.parse(1)).toThrow();
-  expect(() => nonnegative.parse(-1)).toThrow();
-  expect(() => multipleOfFive.parse(7.5)).toThrow();
-  expect(() => multipleOfFive.parse(-7.5)).toThrow();
-  expect(() => multipleOfNegativeFive.parse(-7.5)).toThrow();
-  expect(() => multipleOfNegativeFive.parse(7.5)).toThrow();
-  expect(() => finite.parse(Number.POSITIVE_INFINITY)).toThrow();
-  expect(() => finite.parse(Number.NEGATIVE_INFINITY)).toThrow();
-  expect(() => safe.parse(Number.MIN_SAFE_INTEGER - 1)).toThrow();
-  expect(() => safe.parse(Number.MAX_SAFE_INTEGER + 1)).toThrow();
-
-  expect(() => stepPointOne.parse(6.11)).toThrow();
-  expect(() => stepPointOne.parse(6.1000000001)).toThrow();
-  expect(() => stepSixPointFour.parse(6.41)).toThrow();
-});
-
-test("parse NaN", () => {
-  expect(() => z.number().parse(Number.NaN)).toThrow();
-});
-
-test("min max getters", () => {
-  expect(z.number().minValue).toBeNull;
-  expect(ltFive.minValue).toBeNull;
-  expect(lteFive.minValue).toBeNull;
-  expect(maxFive.minValue).toBeNull;
-  expect(negative.minValue).toBeNull;
-  expect(nonpositive.minValue).toBeNull;
-  expect(intNum.minValue).toBeNull;
-  expect(multipleOfFive.minValue).toBeNull;
-  expect(finite.minValue).toBeNull;
-  expect(gtFive.minValue).toEqual(5);
-  expect(gteFive.minValue).toEqual(5);
-  expect(minFive.minValue).toEqual(5);
-  expect(minFive.min(10).minValue).toEqual(10);
-  expect(positive.minValue).toEqual(0);
-  expect(nonnegative.minValue).toEqual(0);
-  expect(safe.minValue).toEqual(Number.MIN_SAFE_INTEGER);
-
-  expect(z.number().maxValue).toBeNull;
-  expect(gtFive.maxValue).toBeNull;
-  expect(gteFive.maxValue).toBeNull;
-  expect(minFive.maxValue).toBeNull;
-  expect(positive.maxValue).toBeNull;
-  expect(nonnegative.maxValue).toBeNull;
-  expect(intNum.minValue).toBeNull;
-  expect(multipleOfFive.minValue).toBeNull;
-  expect(finite.minValue).toBeNull;
-  expect(ltFive.maxValue).toEqual(5);
-  expect(lteFive.maxValue).toEqual(5);
-  expect(maxFive.maxValue).toEqual(5);
-  expect(maxFive.max(1).maxValue).toEqual(1);
-  expect(negative.maxValue).toEqual(0);
-  expect(nonpositive.maxValue).toEqual(0);
-  expect(safe.maxValue).toEqual(Number.MAX_SAFE_INTEGER);
-});
-
-test("int getter", () => {
-  expect(z.number().isInt).toEqual(false);
-  expect(z.number().multipleOf(1.5).isInt).toEqual(false);
-  expect(gtFive.isInt).toEqual(false);
-  expect(gteFive.isInt).toEqual(false);
-  expect(minFive.isInt).toEqual(false);
-  expect(positive.isInt).toEqual(false);
-  expect(nonnegative.isInt).toEqual(false);
-  expect(finite.isInt).toEqual(false);
-  expect(ltFive.isInt).toEqual(false);
-  expect(lteFive.isInt).toEqual(false);
-  expect(maxFive.isInt).toEqual(false);
-  expect(negative.isInt).toEqual(false);
-  expect(nonpositive.isInt).toEqual(false);
-  expect(safe.isInt).toEqual(false);
-
-  expect(intNum.isInt).toEqual(true);
-  expect(multipleOfFive.isInt).toEqual(true);
-});
-
-test("finite getter", () => {
-  expect(z.number().isFinite).toEqual(false);
-  expect(gtFive.isFinite).toEqual(false);
-  expect(gteFive.isFinite).toEqual(false);
-  expect(minFive.isFinite).toEqual(false);
-  expect(positive.isFinite).toEqual(false);
-  expect(nonnegative.isFinite).toEqual(false);
-  expect(ltFive.isFinite).toEqual(false);
-  expect(lteFive.isFinite).toEqual(false);
-  expect(maxFive.isFinite).toEqual(false);
-  expect(negative.isFinite).toEqual(false);
-  expect(nonpositive.isFinite).toEqual(false);
-
-  expect(finite.isFinite).toEqual(true);
-  expect(intNum.isFinite).toEqual(true);
-  expect(multipleOfFive.isFinite).toEqual(true);
-  expect(z.number().min(5).max(10).isFinite).toEqual(true);
-  expect(safe.isFinite).toEqual(true);
-});

package/node_modules/@switchboard/core/node_modules/zod/src/v3/tests/object-augmentation.test.ts

@@ -1,29 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-test("object augmentation", () => {
-  const Animal = z
-    .object({
-      species: z.string(),
-    })
-    .augment({
-      population: z.number(),
-    });
-  // overwrites `species`
-  const ModifiedAnimal = Animal.augment({
-    species: z.array(z.string()),
-  });
-  ModifiedAnimal.parse({
-    species: ["asd"],
-    population: 1324,
-  });
-
-  const bad = () =>
-    ModifiedAnimal.parse({
-      species: "asdf",
-      population: 1324,
-    } as any);
-  expect(bad).toThrow();
-});

package/node_modules/@switchboard/core/node_modules/zod/src/v3/tests/object-in-es5-env.test.ts

@@ -1,29 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-const RealSet = Set;
-const RealMap = Map;
-const RealDate = Date;
-
-test("doesn’t throw when Date is undefined", () => {
-  delete (globalThis as any).Date;
-  const result = z.object({}).safeParse({});
-  expect(result.success).toEqual(true);
-  globalThis.Date = RealDate;
-});
-
-test("doesn’t throw when Set is undefined", () => {
-  delete (globalThis as any).Set;
-  const result = z.object({}).safeParse({});
-  expect(result.success).toEqual(true);
-  globalThis.Set = RealSet;
-});
-
-test("doesn’t throw when Map is undefined", () => {
-  delete (globalThis as any).Map;
-  const result = z.object({}).safeParse({});
-  expect(result.success).toEqual(true);
-  globalThis.Map = RealMap;
-});

package/node_modules/@switchboard/core/node_modules/zod/src/v3/tests/object.test.ts

@@ -1,434 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-const Test = z.object({
-  f1: z.number(),
-  f2: z.string().optional(),
-  f3: z.string().nullable(),
-  f4: z.array(z.object({ t: z.union([z.string(), z.boolean()]) })),
-});
-
-test("object type inference", () => {
-  type TestType = {
-    f1: number;
-    f2?: string | undefined;
-    f3: string | null;
-    f4: { t: string | boolean }[];
-  };
-
-  util.assertEqual<z.TypeOf<typeof Test>, TestType>(true);
-});
-
-test("unknown throw", () => {
-  const asdf: unknown = 35;
-  expect(() => Test.parse(asdf)).toThrow();
-});
-
-test("shape() should return schema of particular key", () => {
-  const f1Schema = Test.shape.f1;
-  const f2Schema = Test.shape.f2;
-  const f3Schema = Test.shape.f3;
-  const f4Schema = Test.shape.f4;
-
-  expect(f1Schema).toBeInstanceOf(z.ZodNumber);
-  expect(f2Schema).toBeInstanceOf(z.ZodOptional);
-  expect(f3Schema).toBeInstanceOf(z.ZodNullable);
-  expect(f4Schema).toBeInstanceOf(z.ZodArray);
-});
-
-test("correct parsing", () => {
-  Test.parse({
-    f1: 12,
-    f2: "string",
-    f3: "string",
-    f4: [
-      {
-        t: "string",
-      },
-    ],
-  });
-
-  Test.parse({
-    f1: 12,
-    f3: null,
-    f4: [
-      {
-        t: false,
-      },
-    ],
-  });
-});
-
-test("incorrect #1", () => {
-  expect(() => Test.parse({} as any)).toThrow();
-});
-
-test("nonstrict by default", () => {
-  z.object({ points: z.number() }).parse({
-    points: 2314,
-    unknown: "asdf",
-  });
-});
-
-const data = {
-  points: 2314,
-  unknown: "asdf",
-};
-
-test("strip by default", () => {
-  const val = z.object({ points: z.number() }).parse(data);
-  expect(val).toEqual({ points: 2314 });
-});
-
-test("unknownkeys override", () => {
-  const val = z.object({ points: z.number() }).strict().passthrough().strip().nonstrict().parse(data);
-
-  expect(val).toEqual(data);
-});
-
-test("passthrough unknown", () => {
-  const val = z.object({ points: z.number() }).passthrough().parse(data);
-
-  expect(val).toEqual(data);
-});
-
-test("strip unknown", () => {
-  const val = z.object({ points: z.number() }).strip().parse(data);
-
-  expect(val).toEqual({ points: 2314 });
-});
-
-test("strict", () => {
-  const val = z.object({ points: z.number() }).strict().safeParse(data);
-
-  expect(val.success).toEqual(false);
-});
-
-test("catchall inference", () => {
-  const o1 = z
-    .object({
-      first: z.string(),
-    })
-    .catchall(z.number());
-
-  const d1 = o1.parse({ first: "asdf", num: 1243 });
-  util.assertEqual<number, (typeof d1)["asdf"]>(true);
-  util.assertEqual<string, (typeof d1)["first"]>(true);
-});
-
-test("catchall overrides strict", () => {
-  const o1 = z.object({ first: z.string().optional() }).strict().catchall(z.number());
-
-  // should run fine
-  // setting a catchall overrides the unknownKeys behavior
-  o1.parse({
-    asdf: 1234,
-  });
-
-  // should only run catchall validation
-  // against unknown keys
-  o1.parse({
-    first: "asdf",
-    asdf: 1234,
-  });
-});
-
-test("catchall overrides strict", () => {
-  const o1 = z
-    .object({
-      first: z.string(),
-    })
-    .strict()
-    .catchall(z.number());
-
-  // should run fine
-  // setting a catchall overrides the unknownKeys behavior
-  o1.parse({
-    first: "asdf",
-    asdf: 1234,
-  });
-});
-
-test("test that optional keys are unset", async () => {
-  const SNamedEntity = z.object({
-    id: z.string(),
-    set: z.string().optional(),
-    unset: z.string().optional(),
-  });
-  const result = await SNamedEntity.parse({
-    id: "asdf",
-    set: undefined,
-  });
-  // eslint-disable-next-line ban/ban
-  expect(Object.keys(result)).toEqual(["id", "set"]);
-});
-
-test("test catchall parsing", async () => {
-  const result = z.object({ name: z.string() }).catchall(z.number()).parse({ name: "Foo", validExtraKey: 61 });
-
-  expect(result).toEqual({ name: "Foo", validExtraKey: 61 });
-
-  const result2 = z
-    .object({ name: z.string() })
-    .catchall(z.number())
-    .safeParse({ name: "Foo", validExtraKey: 61, invalid: "asdf" });
-
-  expect(result2.success).toEqual(false);
-});
-
-test("test nonexistent keys", async () => {
-  const Schema = z.union([z.object({ a: z.string() }), z.object({ b: z.number() })]);
-  const obj = { a: "A" };
-  const result = await Schema.spa(obj); // Works with 1.11.10, breaks with 2.0.0-beta.21
-  expect(result.success).toBe(true);
-});
-
-test("test async union", async () => {
-  const Schema2 = z.union([
-    z.object({
-      ty: z.string(),
-    }),
-    z.object({
-      ty: z.number(),
-    }),
-  ]);
-
-  const obj = { ty: "A" };
-  const result = await Schema2.spa(obj); // Works with 1.11.10, breaks with 2.0.0-beta.21
-  expect(result.success).toEqual(true);
-});
-
-test("test inferred merged type", async () => {
-  const asdf = z.object({ a: z.string() }).merge(z.object({ a: z.number() }));
-  type asdf = z.infer<typeof asdf>;
-  util.assertEqual<asdf, { a: number }>(true);
-});
-
-test("inferred merged object type with optional properties", async () => {
-  const Merged = z
-    .object({ a: z.string(), b: z.string().optional() })
-    .merge(z.object({ a: z.string().optional(), b: z.string() }));
-  type Merged = z.infer<typeof Merged>;
-  util.assertEqual<Merged, { a?: string; b: string }>(true);
-  // todo
-  // util.assertEqual<Merged, { a?: string; b: string }>(true);
-});
-
-test("inferred unioned object type with optional properties", async () => {
-  const Unioned = z.union([
-    z.object({ a: z.string(), b: z.string().optional() }),
-    z.object({ a: z.string().optional(), b: z.string() }),
-  ]);
-  type Unioned = z.infer<typeof Unioned>;
-  util.assertEqual<Unioned, { a: string; b?: string } | { a?: string; b: string }>(true);
-});
-
-test("inferred enum type", async () => {
-  const Enum = z.object({ a: z.string(), b: z.string().optional() }).keyof();
-
-  expect(Enum.Values).toEqual({
-    a: "a",
-    b: "b",
-  });
-  expect(Enum.enum).toEqual({
-    a: "a",
-    b: "b",
-  });
-  expect(Enum._def.values).toEqual(["a", "b"]);
-  type Enum = z.infer<typeof Enum>;
-  util.assertEqual<Enum, "a" | "b">(true);
-});
-
-test("inferred partial object type with optional properties", async () => {
-  const Partial = z.object({ a: z.string(), b: z.string().optional() }).partial();
-  type Partial = z.infer<typeof Partial>;
-  util.assertEqual<Partial, { a?: string; b?: string }>(true);
-});
-
-test("inferred picked object type with optional properties", async () => {
-  const Picked = z.object({ a: z.string(), b: z.string().optional() }).pick({ b: true });
-  type Picked = z.infer<typeof Picked>;
-  util.assertEqual<Picked, { b?: string }>(true);
-});
-
-test("inferred type for unknown/any keys", () => {
-  const myType = z.object({
-    anyOptional: z.any().optional(),
-    anyRequired: z.any(),
-    unknownOptional: z.unknown().optional(),
-    unknownRequired: z.unknown(),
-  });
-  type myType = z.infer<typeof myType>;
-  util.assertEqual<
-    myType,
-    {
-      anyOptional?: any;
-      anyRequired?: any;
-      unknownOptional?: unknown;
-      unknownRequired?: unknown;
-    }
-  >(true);
-});
-
-test("setKey", () => {
-  const base = z.object({ name: z.string() });
-  const withNewKey = base.setKey("age", z.number());
-
-  type withNewKey = z.infer<typeof withNewKey>;
-  util.assertEqual<withNewKey, { name: string; age: number }>(true);
-  withNewKey.parse({ name: "asdf", age: 1234 });
-});
-
-test("strictcreate", async () => {
-  const strictObj = z.strictObject({
-    name: z.string(),
-  });
-
-  const syncResult = strictObj.safeParse({ name: "asdf", unexpected: 13 });
-  expect(syncResult.success).toEqual(false);
-
-  const asyncResult = await strictObj.spa({ name: "asdf", unexpected: 13 });
-  expect(asyncResult.success).toEqual(false);
-});
-
-test("object with refine", async () => {
-  const schema = z
-    .object({
-      a: z.string().default("foo"),
-      b: z.number(),
-    })
-    .refine(() => true);
-  expect(schema.parse({ b: 5 })).toEqual({ b: 5, a: "foo" });
-  const result = await schema.parseAsync({ b: 5 });
-  expect(result).toEqual({ b: 5, a: "foo" });
-});
-
-test("intersection of object with date", async () => {
-  const schema = z.object({
-    a: z.date(),
-  });
-  expect(schema.and(schema).parse({ a: new Date(1637353595983) })).toEqual({
-    a: new Date(1637353595983),
-  });
-  const result = await schema.parseAsync({ a: new Date(1637353595983) });
-  expect(result).toEqual({ a: new Date(1637353595983) });
-});
-
-test("intersection of object with refine with date", async () => {
-  const schema = z
-    .object({
-      a: z.date(),
-    })
-    .refine(() => true);
-  expect(schema.and(schema).parse({ a: new Date(1637353595983) })).toEqual({
-    a: new Date(1637353595983),
-  });
-  const result = await schema.parseAsync({ a: new Date(1637353595983) });
-  expect(result).toEqual({ a: new Date(1637353595983) });
-});
-
-test("constructor key", () => {
-  const person = z
-    .object({
-      name: z.string(),
-    })
-    .strict();
-
-  expect(() =>
-    person.parse({
-      name: "bob dylan",
-      constructor: 61,
-    })
-  ).toThrow();
-});
-
-test("constructor key", () => {
-  const Example = z.object({
-    prop: z.string(),
-    opt: z.number().optional(),
-    arr: z.string().array(),
-  });
-
-  type Example = z.infer<typeof Example>;
-  util.assertEqual<keyof Example, "prop" | "opt" | "arr">(true);
-});
-
-test("unknownkeys merging", () => {
-  // This one is "strict"
-  const schemaA = z
-    .object({
-      a: z.string(),
-    })
-    .strict();
-
-  // This one is "strip"
-  const schemaB = z
-    .object({
-      b: z.string(),
-    })
-    .catchall(z.string());
-
-  const mergedSchema = schemaA.merge(schemaB);
-  type mergedSchema = typeof mergedSchema;
-  util.assertEqual<mergedSchema["_def"]["unknownKeys"], "strip">(true);
-  expect(mergedSchema._def.unknownKeys).toEqual("strip");
-
-  util.assertEqual<mergedSchema["_def"]["catchall"], z.ZodString>(true);
-  expect(mergedSchema._def.catchall instanceof z.ZodString).toEqual(true);
-});
-
-const personToExtend = z.object({
-  firstName: z.string(),
-  lastName: z.string(),
-});
-
-test("extend() should return schema with new key", () => {
-  const PersonWithNickname = personToExtend.extend({ nickName: z.string() });
-  type PersonWithNickname = z.infer<typeof PersonWithNickname>;
-
-  const expected = { firstName: "f", nickName: "n", lastName: "l" };
-  const actual = PersonWithNickname.parse(expected);
-
-  expect(actual).toEqual(expected);
-  util.assertEqual<keyof PersonWithNickname, "firstName" | "lastName" | "nickName">(true);
-  util.assertEqual<PersonWithNickname, { firstName: string; lastName: string; nickName: string }>(true);
-});
-
-test("extend() should have power to override existing key", () => {
-  const PersonWithNumberAsLastName = personToExtend.extend({
-    lastName: z.number(),
-  });
-  type PersonWithNumberAsLastName = z.infer<typeof PersonWithNumberAsLastName>;
-
-  const expected = { firstName: "f", lastName: 42 };
-  const actual = PersonWithNumberAsLastName.parse(expected);
-
-  expect(actual).toEqual(expected);
-  util.assertEqual<PersonWithNumberAsLastName, { firstName: string; lastName: number }>(true);
-});
-
-test("passthrough index signature", () => {
-  const a = z.object({ a: z.string() });
-  type a = z.infer<typeof a>;
-  util.assertEqual<{ a: string }, a>(true);
-  const b = a.passthrough();
-  type b = z.infer<typeof b>;
-  util.assertEqual<{ a: string } & { [k: string]: unknown }, b>(true);
-});
-
-test("xor", () => {
-  type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
-  type XOR<T, U> = T extends object ? (U extends object ? (Without<T, U> & U) | (Without<U, T> & T) : U) : T;
-
-  type A = { name: string; a: number };
-  type B = { name: string; b: number };
-  type C = XOR<A, B>;
-  type Outer = { data: C };
-
-  const _Outer: z.ZodType<Outer> = z.object({
-    data: z.union([z.object({ name: z.string(), a: z.number() }), z.object({ name: z.string(), b: z.number() })]),
-  });
-});

package/node_modules/@switchboard/core/node_modules/zod/src/v3/tests/optional.test.ts

@@ -1,42 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-
-function checkErrors(a: z.ZodTypeAny, bad: any) {
-  let expected: any;
-  try {
-    a.parse(bad);
-  } catch (error) {
-    expected = (error as z.ZodError).formErrors;
-  }
-  try {
-    a.optional().parse(bad);
-  } catch (error) {
-    expect((error as z.ZodError).formErrors).toEqual(expected);
-  }
-}
-
-test("Should have error messages appropriate for the underlying type", () => {
-  checkErrors(z.string().min(2), 1);
-  z.string().min(2).optional().parse(undefined);
-  checkErrors(z.number().gte(2), 1);
-  z.number().gte(2).optional().parse(undefined);
-  checkErrors(z.boolean(), "");
-  z.boolean().optional().parse(undefined);
-  checkErrors(z.undefined(), null);
-  z.undefined().optional().parse(undefined);
-  checkErrors(z.null(), {});
-  z.null().optional().parse(undefined);
-  checkErrors(z.object({}), 1);
-  z.object({}).optional().parse(undefined);
-  checkErrors(z.tuple([]), 1);
-  z.tuple([]).optional().parse(undefined);
-  checkErrors(z.unknown(), 1);
-  z.unknown().optional().parse(undefined);
-});
-
-test("unwrap", () => {
-  const unwrapped = z.string().optional().unwrap();
-  expect(unwrapped).toBeInstanceOf(z.ZodString);
-});