Confusing missing property error in a circular situation #62180

interface ZodType<T> {
  optional: "true" | "false";
  output: T;
}

interface ZodString extends ZodType<string> {
  optional: "false";
}

type ZodShape = Record<string, any>;
type Prettify<T> = { [K in keyof T]: T[K] } & {};
type InferObjectType<Shape extends ZodShape> = Prettify<
  {
    [k in keyof Shape as Shape[k] extends { optional: "true" }
      ? k
      : never]?: Shape[k]["output"];
  } & {
    [k in keyof Shape as Shape[k] extends { optional: "true" }
      ? never
      : k]: Shape[k]["output"];
  }
>;
interface ZodObject<T extends ZodShape> extends ZodType<InferObjectType<T>> {
  optional: "false";
}

interface ZodOptional<T extends ZodType<any>>
  extends ZodType<T["output"] | undefined> {
  optional: "true";
}

declare function object<T extends ZodShape>(shape: T): ZodObject<T>;
declare function string(): ZodString;
declare function optional<T extends ZodType<any>>(schema: T): ZodOptional<T>;

const Category = object({
  name: string(),
  get parent() {
    // Argument of type 'ZodObject<{ name: ZodString; readonly parent: ZodOptional<ZodType<any>>; }>' is not assignable to parameter of type 'ZodType<any>'.
    //   Property 'output' is missing in type 'ZodObject<{ name: ZodString; readonly parent: ZodOptional<ZodType<any>>; }>' but required in type 'ZodType<any>'.(2345)
    return optional(Category);
  },
});

export const output = Category.output;