hunk.code_window:   get shape() {
       return this._def.shape();
     }
     strict(): ZodObject<T, "strict", Catchall> {
       return new ZodObject({
         ...this._def,
         unknownKeys: "strict",
  
hunk.labels: keep keep keep keep replace keep keep keep
hunk.after_edit:   strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall> {
  
hunk.file_path: deno/lib/types.ts
hunk.type: replace
file: // @ts-ignore TS6133
  import { expect, test } from "@jest/globals";
  
  import { util } from "../helpers/util";
  import * as z from "../index";
  
  const stringToNumber = z.string().transform((arg) => parseFloat(arg));
  // const numberToString = z
  //   .transformer(z.number())
  //   .transform((n) => String(n));
  const asyncNumberToString = z.number().transform(async (n) => String(n));
  
  test("basic transformations", () => {
    const r1 = z
      .string()
      .transform((data) => data.length)
      .parse("asdf");
    expect(r1).toEqual(4);
  });
  
  test("coercion", () => {
    const numToString = z.number().transform((n) => String(n));
    const data = z
      .object({
        id: numToString,
      })
      .parse({ id: 5 });
  
    expect(data).toEqual({ id: "5" });
  });
  
  test("async coercion", async () => {
    const numToString = z.number().transform(async (n) => String(n));
    const data = await z
      .object({
        id: numToString,
      })
      .parseAsync({ id: 5 });
  
    expect(data).toEqual({ id: "5" });
  });
  
  test("sync coercion async error", async () => {
    expect(() =>
      z
        .object({
          id: asyncNumberToString,
        })
        .parse({ id: 5 })
    ).toThrow();
    // expect(data).toEqual({ id: '5' });
  });
  
  test("default", () => {
    const data = z.string().default("asdf").parse(undefined); // => "asdf"
    expect(data).toEqual("asdf");
  });
  
  test("dynamic default", () => {
    const data = z
      .string()
      .default(() => "string")
      .parse(undefined); // => "asdf"
    expect(data).toEqual("string");
  });
  
  test("default when property is null or undefined", () => {
    const data = z
      .object({
        foo: z.boolean().nullable().default(true),
        bar: z.boolean().default(true),
      })
      .parse({ foo: null });
  
    expect(data).toEqual({ foo: null, bar: true });
  });
  
  test("default with falsy values", () => {
    const schema = z.object({
      emptyStr: z.string().default("def"),
      zero: z.number().default(5),
      falseBoolean: z.boolean().default(true),
    });
    const input = { emptyStr: "", zero: 0, falseBoolean: true };
    const output = schema.parse(input);
    // defaults are not supposed to be used
    expect(output).toEqual(input);
  });
  
  test("object typing", () => {
    const t1 = z.object({
      stringToNumber,
    });
  
    type t1 = z.input<typeof t1>;
    type t2 = z.output<typeof t1>;
  
    const f1: util.AssertEqual<t1, { stringToNumber: string }> = true;
    const f2: util.AssertEqual<t2, { stringToNumber: number }> = true;
    f1;
    f2;
  });
  
  test("transform method overloads", () => {
    const t1 = z.string().transform((val) => val.toUpperCase());
    expect(t1.parse("asdf")).toEqual("ASDF");
  
    const t2 = z.string().transform((val) => val.length);
    expect(t2.parse("asdf")).toEqual(4);
  });
  
  test("multiple transformers", () => {
    const doubler = stringToNumber.transform((val) => {
      return val * 2;
    });
    expect(doubler.parse("5")).toEqual(10);
  });
  
  test("preprocess", () => {
    const schema = z.preprocess((data) => [data], z.string().array());
  
    const value = schema.parse("asdf");
    expect(value).toEqual(["asdf"]);
  });
  
  test("async preprocess", async () => {
    const schema = z.preprocess(async (data) => [data], z.string().array());
  
    const value = await schema.parseAsync("asdf");
    expect(value).toEqual(["asdf"]);
  });
  