diff --git a/base/comment-injection-typescript-zod/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts b/head/comment-injection-typescript-zod/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts
index ec5015b..076c0ba 100644
--- a/base/comment-injection-typescript-zod/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts
+++ b/head/comment-injection-typescript-zod/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts
@@ -12,5 +12,5 @@ export type Kind = z.infer<typeof KindSchema>;
 
 export const TopLevelSchema = z.object({
     "kind": KindSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/comment-injection-typescript-zod/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts b/head/comment-injection-typescript-zod/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts
index 6599d9d..066d53e 100644
--- a/base/comment-injection-typescript-zod/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts
+++ b/head/comment-injection-typescript-zod/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts
@@ -15,5 +15,5 @@ export type Kind = z.infer<typeof KindSchema>;
 
 export const TopLevelSchema = z.object({
     "kind": KindSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/accessors.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/accessors.schema/default/TopLevel.ts
index 0e7ce28..56c57df 100644
--- a/base/schema-typescript-zod/test/inputs/schema/accessors.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/accessors.schema/default/TopLevel.ts
@@ -13,5 +13,5 @@ export const TopLevelSchema = z.object({
     "enum": EnumSchema,
     "foo": z.string(),
     "union": z.union([z.boolean(), z.number()]),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.ts
index 8cd37f4..ec11690 100644
--- a/base/schema-typescript-zod/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/all-of-additional-properties-false.schema/default/TopLevel.ts
@@ -20,5 +20,5 @@ export const TopLevelSchema = z.object({
     "frequency": FrequencySchema,
     "description": z.string().optional(),
     "type": TypeSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/any.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/any.schema/default/TopLevel.ts
index 2a971a2..08c92fc 100644
--- a/base/schema-typescript-zod/test/inputs/schema/any.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/any.schema/default/TopLevel.ts
@@ -4,5 +4,5 @@ import * as z from "zod";
 export const TopLevelSchema = z.object({
     "foo": z.any(),
     "values": z.record(z.string(), z.any()),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/bool-string.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/bool-string.schema/default/TopLevel.ts
index 88edd3b..ff9dc5c 100644
--- a/base/schema-typescript-zod/test/inputs/schema/bool-string.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/bool-string.schema/default/TopLevel.ts
@@ -14,5 +14,5 @@ export const TopLevelSchema = z.object({
     "optional": z.enum(["true", "false"]).optional(),
     "unionWithBool": z.union([z.boolean(), z.enum(["true", "false"]).transform(x => x === "true")]),
     "unionWithBoolAndEnum": z.union([z.boolean(), z.enum(["true", "false"]).transform(x => x === "true"), UnionWithBoolAndEnumEnumSchema]),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/boolean-subschema.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/boolean-subschema.schema/default/TopLevel.ts
index 15b1ddd..57f568e 100644
--- a/base/schema-typescript-zod/test/inputs/schema/boolean-subschema.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/boolean-subschema.schema/default/TopLevel.ts
@@ -6,5 +6,5 @@ export const TopLevelSchema = z.object({
     "empty": z.array(z.any()),
     "foo": z.string(),
     "impossible": z.any().optional(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/camelCase.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/camelCase.schema/default/TopLevel.ts
index 2bb9168..933de11 100644
--- a/base/schema-typescript-zod/test/inputs/schema/camelCase.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/camelCase.schema/default/TopLevel.ts
@@ -4,5 +4,5 @@ import * as z from "zod";
 export const TopLevelSchema = z.object({
     "myProperty": z.string().optional(),
     "secondProperty": z.string().optional(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/class-map-union.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/class-map-union.schema/default/TopLevel.ts
index df36b06..a919de2 100644
--- a/base/schema-typescript-zod/test/inputs/schema/class-map-union.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/class-map-union.schema/default/TopLevel.ts
@@ -1,12 +1,18 @@
 import * as z from "zod";
 
 
-export const UnionClassSchema = z.object({
+export const BarObjectSchema = z.object({
     "quux": z.number().int().optional(),
-});
-export type UnionClass = z.infer<typeof UnionClassSchema>;
+}).passthrough();
+export type BarObject = z.infer<typeof BarObjectSchema>;
+
+export const TopLevelUnionSchema = z.object({
+    "foo": z.union([z.boolean(), z.number(), BarObjectSchema]).optional(),
+    "bar": z.union([z.boolean(), BarObjectSchema, z.string()]).optional(),
+}).catchall(z.union([z.boolean(), BarObjectSchema]));
+export type TopLevelUnion = z.infer<typeof TopLevelUnionSchema>;
 
 export const TopLevelSchema = z.object({
-    "union": z.record(z.string(), z.union([z.boolean(), UnionClassSchema, z.number(), z.string()])).optional(),
-});
+    "union": TopLevelUnionSchema.optional(),
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/class-with-additional.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/class-with-additional.schema/default/TopLevel.ts
index 9bd73cb..bb13fcf 100644
--- a/base/schema-typescript-zod/test/inputs/schema/class-with-additional.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/class-with-additional.schema/default/TopLevel.ts
@@ -1,7 +1,12 @@
 import * as z from "zod";
 
 
+export const MapSchema = z.object({
+    "foo": z.number().optional(),
+}).catchall(z.boolean());
+export type Map = z.infer<typeof MapSchema>;
+
 export const TopLevelSchema = z.object({
-    "map": z.record(z.string(), z.union([z.boolean(), z.number()])).optional(),
-});
+    "map": MapSchema.optional(),
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts
index ec5015b..076c0ba 100644
--- a/base/schema-typescript-zod/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/comment-injection-enum-nested-comment.schema/default/TopLevel.ts
@@ -12,5 +12,5 @@ export type Kind = z.infer<typeof KindSchema>;
 
 export const TopLevelSchema = z.object({
     "kind": KindSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts
index 6599d9d..066d53e 100644
--- a/base/schema-typescript-zod/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/comment-injection-enum.schema/default/TopLevel.ts
@@ -15,5 +15,5 @@ export type Kind = z.infer<typeof KindSchema>;
 
 export const TopLevelSchema = z.object({
     "kind": KindSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts
index 95970e0..377158a 100644
--- a/base/schema-typescript-zod/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/comment-injection-nested-comment.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "value": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/comment-injection.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/comment-injection.schema/default/TopLevel.ts
index 70c7b02..b57dfa9 100644
--- a/base/schema-typescript-zod/test/inputs/schema/comment-injection.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/comment-injection.schema/default/TopLevel.ts
@@ -6,5 +6,5 @@ export const TopLevelSchema = z.object({
     "trailingQuote": z.string().optional(),
     "trailingTripleQuote": z.string().optional(),
     "value": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/const-non-string.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/const-non-string.schema/default/TopLevel.ts
index 92c520e..3522fb8 100644
--- a/base/schema-typescript-zod/test/inputs/schema/const-non-string.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/const-non-string.schema/default/TopLevel.ts
@@ -12,5 +12,5 @@ export const TopLevelSchema = z.object({
     "kind": KindSchema,
     "ratio": z.number(),
     "version": z.number(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/constructor.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/constructor.schema/default/TopLevel.ts
index 9093bde..2fb6632 100644
--- a/base/schema-typescript-zod/test/inputs/schema/constructor.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/constructor.schema/default/TopLevel.ts
@@ -2,10 +2,10 @@ import * as z from "zod";
 
 
 export const ConstructorSchema = z.object({
-});
+}).strict();
 export type Constructor = z.infer<typeof ConstructorSchema>;
 
 export const TopLevelSchema = z.preprocess(value => typeof value === "object" && value !== null && !Array.isArray(value) ? Object.assign(Object.create(null), value) : value, z.object({
     "constructor": z.union([ConstructorSchema, z.number()]).optional(),
-}));
+}).passthrough());
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/cut-enum.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/cut-enum.schema/default/TopLevel.ts
index 8787324..f9ec7ce 100644
--- a/base/schema-typescript-zod/test/inputs/schema/cut-enum.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/cut-enum.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "foo": z.number().int(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/date-time-or-string.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/date-time-or-string.schema/default/TopLevel.ts
index b07557c..2c9ab4b 100644
--- a/base/schema-typescript-zod/test/inputs/schema/date-time-or-string.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/date-time-or-string.schema/default/TopLevel.ts
@@ -9,5 +9,5 @@ export type BarEnum = z.infer<typeof BarEnumSchema>;
 export const TopLevelSchema = z.object({
     "bar": z.union([BarEnumSchema, z.coerce.date()]),
     "foo": z.string(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/date-time.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/date-time.schema/default/TopLevel.ts
index c3f6f08..4387c45 100644
--- a/base/schema-typescript-zod/test/inputs/schema/date-time.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/date-time.schema/default/TopLevel.ts
@@ -13,5 +13,5 @@ export const TopLevelSchema = z.object({
     "date-time": z.coerce.date(),
     "time": z.string(),
     "union-array": z.array(z.string()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/default-value.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/default-value.schema/default/TopLevel.ts
index 61b476d..68247c5 100644
--- a/base/schema-typescript-zod/test/inputs/schema/default-value.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/default-value.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "id": z.number().int(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.ts
index 0712a77..df18a1b 100644
--- a/base/schema-typescript-zod/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/description-with-double-quotes.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "foo": z.boolean().optional(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/description.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/description.schema/default/TopLevel.ts
index 52b083c..074992d 100644
--- a/base/schema-typescript-zod/test/inputs/schema/description.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/description.schema/default/TopLevel.ts
@@ -8,16 +8,16 @@ export const EnumSchema = z.enum([
 ]);
 export type Enum = z.infer<typeof EnumSchema>;
 
-export const ObjectOrStringClassSchema = z.object({
+export const ObjectOrStringObjectSchema = z.object({
     "prop": z.number(),
-});
-export type ObjectOrStringClass = z.infer<typeof ObjectOrStringClassSchema>;
+}).passthrough();
+export type ObjectOrStringObject = z.infer<typeof ObjectOrStringObjectSchema>;
 
 export const TopLevelSchema = z.object({
     "bar": z.boolean().optional(),
     "enum": EnumSchema,
     "foo": z.number().optional(),
-    "object-or-string": z.union([ObjectOrStringClassSchema, z.string()]),
+    "object-or-string": z.union([ObjectOrStringObjectSchema, z.string()]),
     "union": z.union([z.number(), z.string()]),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/direct-union.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/direct-union.schema/default/TopLevel.ts
index 6887a6e..d6e224f 100644
--- a/base/schema-typescript-zod/test/inputs/schema/direct-union.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/direct-union.schema/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const ThingSchema = z.object({
     "optional": z.union([z.null(), z.array(z.any()), z.boolean(), z.number(), z.number().int(), z.record(z.string(), z.any()), z.string()]).optional(),
     "required": z.union([z.null(), z.array(z.any()), z.boolean(), z.number(), z.number().int(), z.record(z.string(), z.any()), z.string()]),
-});
+}).strict();
 export type Thing = z.infer<typeof ThingSchema>;
 
 export const TopLevelSchema = z.object({
     "stuff": z.record(z.string(), ThingSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/enum-large.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/enum-large.schema/default/TopLevel.ts
index 11be42f..b5b0fab 100644
--- a/base/schema-typescript-zod/test/inputs/schema/enum-large.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/enum-large.schema/default/TopLevel.ts
@@ -36,5 +36,5 @@ export type Priority = z.infer<typeof PrioritySchema>;
 export const TopLevelSchema = z.object({
     "callsign": CallsignSchema,
     "priority": PrioritySchema,
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/enum-with-null.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/enum-with-null.schema/default/TopLevel.ts
index e62dad3..8888d21 100644
--- a/base/schema-typescript-zod/test/inputs/schema/enum-with-null.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/enum-with-null.schema/default/TopLevel.ts
@@ -9,5 +9,5 @@ export type Enum = z.infer<typeof EnumSchema>;
 
 export const TopLevelSchema = z.object({
     "enum": z.union([z.null(), EnumSchema]),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/enum-with-values.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/enum-with-values.schema/default/TopLevel.ts
index 1903356..b372a5e 100644
--- a/base/schema-typescript-zod/test/inputs/schema/enum-with-values.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/enum-with-values.schema/default/TopLevel.ts
@@ -14,5 +14,5 @@ export type Weekdays = z.infer<typeof WeekdaysSchema>;
 
 export const TopLevelSchema = z.object({
     "weekdays": WeekdaysSchema,
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/enum.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/enum.schema/default/TopLevel.ts
index a3ce463..c98dada 100644
--- a/base/schema-typescript-zod/test/inputs/schema/enum.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/enum.schema/default/TopLevel.ts
@@ -30,5 +30,5 @@ export const TopLevelSchema = z.object({
     "gve": GveSchema,
     "lvc": LvcSchema.optional(),
     "otherArr": z.array(OtherArrSchema).optional(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.ts
index 31ee01d..e33e57d 100644
--- a/base/schema-typescript-zod/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/go-schema-pattern-properties.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "map": z.record(z.string(), z.number().int()),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.ts
index e86d51d..cf3638d 100644
--- a/base/schema-typescript-zod/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/haskell-enum-forbidden.schema/default/TopLevel.ts
@@ -9,5 +9,5 @@ export type Health = z.infer<typeof HealthSchema>;
 
 export const TopLevelSchema = z.object({
     "health": HealthSchema,
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/id-no-address.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/id-no-address.schema/default/TopLevel.ts
index ca37781..42e2c44 100644
--- a/base/schema-typescript-zod/test/inputs/schema/id-no-address.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/id-no-address.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "item": z.number().int(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/id-root.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/id-root.schema/default/TopLevel.ts
index 46f2fc7..71bc6ec 100644
--- a/base/schema-typescript-zod/test/inputs/schema/id-root.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/id-root.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "bar": z.number().int(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.ts
index df13443..4d8b2c5 100644
--- a/base/schema-typescript-zod/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/ie-suffix-singularization.schema/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const CookieSchema = z.object({
     "name": z.string(),
     "value": z.string(),
-});
+}).passthrough();
 export type Cookie = z.infer<typeof CookieSchema>;
 
 export const TopLevelSchema = z.object({
     "cookies": z.array(CookieSchema),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/implicit-all-of.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/implicit-all-of.schema/default/TopLevel.ts
index fb54aa7..9d08577 100644
--- a/base/schema-typescript-zod/test/inputs/schema/implicit-all-of.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/implicit-all-of.schema/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "foo": z.number().int(),
     "bar": z.boolean(),
     "quux": z.string(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.ts
index 3063e84..ae27ff8 100644
--- a/base/schema-typescript-zod/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/implicit-class-array-union.schema/default/TopLevel.ts
@@ -1,12 +1,12 @@
 import * as z from "zod";
 
 
-export const FooClassSchema = z.object({
+export const FooObjectSchema = z.object({
     "bar": z.number().int(),
-});
-export type FooClass = z.infer<typeof FooClassSchema>;
+}).passthrough();
+export type FooObject = z.infer<typeof FooObjectSchema>;
 
 export const TopLevelSchema = z.object({
-    "foo": z.union([z.null(), z.array(z.number().int()), z.boolean(), FooClassSchema, z.number(), z.number().int(), z.string()]),
-});
+    "foo": z.union([z.null(), z.array(z.number().int()), z.boolean(), z.number(), z.number().int(), FooObjectSchema, z.string()]),
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/implicit-one-of.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/implicit-one-of.schema/default/TopLevel.ts
index e38977f..1c5bea0 100644
--- a/base/schema-typescript-zod/test/inputs/schema/implicit-one-of.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/implicit-one-of.schema/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "foo": z.number().int(),
     "bar": z.boolean().optional(),
     "quux": z.string().optional(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/integer-float-union.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/integer-float-union.schema/default/TopLevel.ts
index 529e890..f24bf01 100644
--- a/base/schema-typescript-zod/test/inputs/schema/integer-float-union.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/integer-float-union.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "number": z.number(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/integer-string.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/integer-string.schema/default/TopLevel.ts
index f326b01..9425d3f 100644
--- a/base/schema-typescript-zod/test/inputs/schema/integer-string.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/integer-string.schema/default/TopLevel.ts
@@ -14,5 +14,5 @@ export const TopLevelSchema = z.object({
     "optional": z.string().regex(/^-?\d+$/).optional(),
     "unionWithInt": z.union([z.number().int(), z.string().regex(/^-?\d+$/).transform(Number)]),
     "unionWithIntAndEnum": z.union([UnionWithIntAndEnumEnumSchema, z.number().int(), z.string().regex(/^-?\d+$/).transform(Number)]),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/integer-type.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/integer-type.schema/default/TopLevel.ts
index 61c0ee3..8f83f46 100644
--- a/base/schema-typescript-zod/test/inputs/schema/integer-type.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/integer-type.schema/default/TopLevel.ts
@@ -11,5 +11,5 @@ export const TopLevelSchema = z.object({
     "small_negative": z.number().int().min(-100).max(0),
     "small_positive": z.number().int().min(0).max(100),
     "unbounded": z.number().int(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/intersection-nested.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/intersection-nested.schema/default/TopLevel.ts
index dbc9c33..f1c746f 100644
--- a/base/schema-typescript-zod/test/inputs/schema/intersection-nested.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/intersection-nested.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "intersection": z.number().optional(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/intersection.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/intersection.schema/default/TopLevel.ts
index 399b29f..1d93040 100644
--- a/base/schema-typescript-zod/test/inputs/schema/intersection.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/intersection.schema/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const IntersectionSchema = z.object({
     "foo": z.number(),
     "bar": z.string().optional(),
-});
+}).passthrough();
 export type Intersection = z.infer<typeof IntersectionSchema>;
 
 export const TopLevelSchema = z.object({
     "intersection": IntersectionSchema.optional(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/keyword-enum.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/keyword-enum.schema/default/TopLevel.ts
index 0a953db..5918508 100644
--- a/base/schema-typescript-zod/test/inputs/schema/keyword-enum.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/keyword-enum.schema/default/TopLevel.ts
@@ -284,5 +284,5 @@ export type Enum = z.infer<typeof EnumSchema>;
 
 export const TopLevelSchema = z.object({
     "enum": EnumSchema.optional(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/keyword-unions.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/keyword-unions.schema/default/TopLevel.ts
index 8d21332..9091e77 100644
--- a/base/schema-typescript-zod/test/inputs/schema/keyword-unions.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/keyword-unions.schema/default/TopLevel.ts
@@ -1,1108 +1,1108 @@
 import * as z from "zod";
 
 
+export const AnySchema = z.object({
+}).strict();
+export type Any = z.infer<typeof AnySchema>;
+
+export const BoolSchema = z.object({
+}).strict();
+export type Bool = z.infer<typeof BoolSchema>;
+
+export const ClassClassSchema = z.object({
+}).strict();
+export type ClassClass = z.infer<typeof ClassClassSchema>;
+
+export const FalseSchema = z.object({
+}).strict();
+export type False = z.infer<typeof FalseSchema>;
+
+export const ImpSchema = z.object({
+}).strict();
+export type Imp = z.infer<typeof ImpSchema>;
+
+export const NoSchema = z.object({
+}).strict();
+export type No = z.infer<typeof NoSchema>;
+
+export const NsStringSchema = z.object({
+}).strict();
+export type NsString = z.infer<typeof NsStringSchema>;
+
+export const NullSchema = z.object({
+}).strict();
+export type Null = z.infer<typeof NullSchema>;
+
+export const NoneSchema = z.object({
+}).strict();
+export type None = z.infer<typeof NoneSchema>;
+
+export const ProtocolSchema = z.object({
+}).strict();
+export type Protocol = z.infer<typeof ProtocolSchema>;
+
+export const SelSchema = z.object({
+}).strict();
+export type Sel = z.infer<typeof SelSchema>;
+
+export const SelfSchema = z.object({
+}).strict();
+export type Self = z.infer<typeof SelfSchema>;
+
+export const TrueSchema = z.object({
+}).strict();
+export type True = z.infer<typeof TrueSchema>;
+
+export const TypeSchema = z.object({
+}).strict();
+export type Type = z.infer<typeof TypeSchema>;
+
+export const YesSchema = z.object({
+}).strict();
+export type Yes = z.infer<typeof YesSchema>;
+
+export const EmptySchema = z.object({
+}).strict();
+export type Empty = z.infer<typeof EmptySchema>;
+
+export const BoolClassSchema = z.object({
+}).strict();
+export type BoolClass = z.infer<typeof BoolClassSchema>;
+
+export const ComplexSchema = z.object({
+}).strict();
+export type Complex = z.infer<typeof ComplexSchema>;
+
+export const ImaginerySchema = z.object({
+}).strict();
+export type Imaginery = z.infer<typeof ImaginerySchema>;
+
 export const AbstractSchema = z.object({
-});
+}).strict();
 export type Abstract = z.infer<typeof AbstractSchema>;
 
 export const AlignasSchema = z.object({
-});
+}).strict();
 export type Alignas = z.infer<typeof AlignasSchema>;
 
 export const AlignofSchema = z.object({
-});
+}).strict();
 export type Alignof = z.infer<typeof AlignofSchema>;
 
 export const AndSchema = z.object({
-});
+}).strict();
 export type And = z.infer<typeof AndSchema>;
 
 export const AndEqSchema = z.object({
-});
+}).strict();
 export type AndEq = z.infer<typeof AndEqSchema>;
 
-export const AnySchema = z.object({
-});
-export type Any = z.infer<typeof AnySchema>;
+export const AnyClassSchema = z.object({
+}).strict();
+export type AnyClass = z.infer<typeof AnyClassSchema>;
 
 export const ArrayClassSchema = z.object({
-});
+}).strict();
 export type ArrayClass = z.infer<typeof ArrayClassSchema>;
 
 export const AsSchema = z.object({
-});
+}).strict();
 export type As = z.infer<typeof AsSchema>;
 
 export const AsmSchema = z.object({
-});
+}).strict();
 export type Asm = z.infer<typeof AsmSchema>;
 
 export const AssertSchema = z.object({
-});
+}).strict();
 export type Assert = z.infer<typeof AssertSchema>;
 
 export const AssociatedtypeSchema = z.object({
-});
+}).strict();
 export type Associatedtype = z.infer<typeof AssociatedtypeSchema>;
 
 export const AssociativitySchema = z.object({
-});
+}).strict();
 export type Associativity = z.infer<typeof AssociativitySchema>;
 
 export const AsyncSchema = z.object({
-});
+}).strict();
 export type Async = z.infer<typeof AsyncSchema>;
 
 export const AtomicSchema = z.object({
-});
+}).strict();
 export type Atomic = z.infer<typeof AtomicSchema>;
 
 export const AtomicCancelSchema = z.object({
-});
+}).strict();
 export type AtomicCancel = z.infer<typeof AtomicCancelSchema>;
 
 export const AtomicCommitSchema = z.object({
-});
+}).strict();
 export type AtomicCommit = z.infer<typeof AtomicCommitSchema>;
 
 export const AtomicNoexceptSchema = z.object({
-});
+}).strict();
 export type AtomicNoexcept = z.infer<typeof AtomicNoexceptSchema>;
 
 export const AutoSchema = z.object({
-});
+}).strict();
 export type Auto = z.infer<typeof AutoSchema>;
 
 export const AwaitSchema = z.object({
-});
+}).strict();
 export type Await = z.infer<typeof AwaitSchema>;
 
 export const BaseSchema = z.object({
-});
+}).strict();
 export type Base = z.infer<typeof BaseSchema>;
 
 export const BitandSchema = z.object({
-});
+}).strict();
 export type Bitand = z.infer<typeof BitandSchema>;
 
 export const BitorSchema = z.object({
-});
+}).strict();
 export type Bitor = z.infer<typeof BitorSchema>;
 
-export const BoolSchema = z.object({
-});
-export type Bool = z.infer<typeof BoolSchema>;
+export const UnionBoolBoolSchema = z.object({
+}).strict();
+export type UnionBoolBool = z.infer<typeof UnionBoolBoolSchema>;
 
 export const BooleanSchema = z.object({
-});
+}).strict();
 export type Boolean = z.infer<typeof BooleanSchema>;
 
 export const BreakSchema = z.object({
-});
+}).strict();
 export type Break = z.infer<typeof BreakSchema>;
 
 export const BycopySchema = z.object({
-});
+}).strict();
 export type Bycopy = z.infer<typeof BycopySchema>;
 
 export const ByrefSchema = z.object({
-});
+}).strict();
 export type Byref = z.infer<typeof ByrefSchema>;
 
 export const ByteSchema = z.object({
-});
+}).strict();
 export type Byte = z.infer<typeof ByteSchema>;
 
 export const CaseSchema = z.object({
-});
+}).strict();
 export type Case = z.infer<typeof CaseSchema>;
 
 export const CatchSchema = z.object({
-});
+}).strict();
 export type Catch = z.infer<typeof CatchSchema>;
 
 export const ChanSchema = z.object({
-});
+}).strict();
 export type Chan = z.infer<typeof ChanSchema>;
 
 export const CharSchema = z.object({
-});
+}).strict();
 export type Char = z.infer<typeof CharSchema>;
 
 export const Char16TSchema = z.object({
-});
+}).strict();
 export type Char16T = z.infer<typeof Char16TSchema>;
 
 export const Char32TSchema = z.object({
-});
+}).strict();
 export type Char32T = z.infer<typeof Char32TSchema>;
 
 export const CheckedSchema = z.object({
-});
+}).strict();
 export type Checked = z.infer<typeof CheckedSchema>;
 
-export const ClassClassSchema = z.object({
-});
-export type ClassClass = z.infer<typeof ClassClassSchema>;
+export const UnionClassClassSchema = z.object({
+}).strict();
+export type UnionClassClass = z.infer<typeof UnionClassClassSchema>;
 
 export const CoAwaitSchema = z.object({
-});
+}).strict();
 export type CoAwait = z.infer<typeof CoAwaitSchema>;
 
 export const CoReturnSchema = z.object({
-});
+}).strict();
 export type CoReturn = z.infer<typeof CoReturnSchema>;
 
 export const CoYieldSchema = z.object({
-});
+}).strict();
 export type CoYield = z.infer<typeof CoYieldSchema>;
 
 export const ComplSchema = z.object({
-});
+}).strict();
 export type Compl = z.infer<typeof ComplSchema>;
 
-export const ComplexSchema = z.object({
-});
-export type Complex = z.infer<typeof ComplexSchema>;
-
 export const ConceptSchema = z.object({
-});
+}).strict();
 export type Concept = z.infer<typeof ConceptSchema>;
 
 export const ConsoleSchema = z.object({
-});
+}).strict();
 export type Console = z.infer<typeof ConsoleSchema>;
 
 export const ConstSchema = z.object({
-});
+}).strict();
 export type Const = z.infer<typeof ConstSchema>;
 
 export const ConstCastSchema = z.object({
-});
+}).strict();
 export type ConstCast = z.infer<typeof ConstCastSchema>;
 
 export const ConstexprSchema = z.object({
-});
+}).strict();
 export type Constexpr = z.infer<typeof ConstexprSchema>;
 
 export const ConstructorSchema = z.object({
-});
+}).strict();
 export type Constructor = z.infer<typeof ConstructorSchema>;
 
 export const ContinueSchema = z.object({
-});
+}).strict();
 export type Continue = z.infer<typeof ContinueSchema>;
 
 export const ConvenienceSchema = z.object({
-});
+}).strict();
 export type Convenience = z.infer<typeof ConvenienceSchema>;
 
 export const ConvertSchema = z.object({
-});
+}).strict();
 export type Convert = z.infer<typeof ConvertSchema>;
 
 export const ConverterSchema = z.object({
-});
+}).strict();
 export type Converter = z.infer<typeof ConverterSchema>;
 
 export const DateClassSchema = z.object({
-});
+}).strict();
 export type DateClass = z.infer<typeof DateClassSchema>;
 
 export const DateParseHandlingSchema = z.object({
-});
+}).strict();
 export type DateParseHandling = z.infer<typeof DateParseHandlingSchema>;
 
 export const DebuggerSchema = z.object({
-});
+}).strict();
 export type Debugger = z.infer<typeof DebuggerSchema>;
 
 export const DecimalSchema = z.object({
-});
+}).strict();
 export type Decimal = z.infer<typeof DecimalSchema>;
 
 export const DeclareSchema = z.object({
-});
+}).strict();
 export type Declare = z.infer<typeof DeclareSchema>;
 
 export const DecltypeSchema = z.object({
-});
+}).strict();
 export type Decltype = z.infer<typeof DecltypeSchema>;
 
 export const DecodeStringSchema = z.object({
-});
+}).strict();
 export type DecodeString = z.infer<typeof DecodeStringSchema>;
 
 export const DefSchema = z.object({
-});
+}).strict();
 export type Def = z.infer<typeof DefSchema>;
 
 export const DefaultSchema = z.object({
-});
+}).strict();
 export type Default = z.infer<typeof DefaultSchema>;
 
 export const DeferSchema = z.object({
-});
+}).strict();
 export type Defer = z.infer<typeof DeferSchema>;
 
 export const DeinitSchema = z.object({
-});
+}).strict();
 export type Deinit = z.infer<typeof DeinitSchema>;
 
 export const DelSchema = z.object({
-});
+}).strict();
 export type Del = z.infer<typeof DelSchema>;
 
 export const DelegateSchema = z.object({
-});
+}).strict();
 export type Delegate = z.infer<typeof DelegateSchema>;
 
 export const DeleteSchema = z.object({
-});
+}).strict();
 export type Delete = z.infer<typeof DeleteSchema>;
 
 export const DictSchema = z.object({
-});
+}).strict();
 export type Dict = z.infer<typeof DictSchema>;
 
 export const DictionarySchema = z.object({
-});
+}).strict();
 export type Dictionary = z.infer<typeof DictionarySchema>;
 
 export const DidSetSchema = z.object({
-});
+}).strict();
 export type DidSet = z.infer<typeof DidSetSchema>;
 
 export const DoSchema = z.object({
-});
+}).strict();
 export type Do = z.infer<typeof DoSchema>;
 
 export const DoubleSchema = z.object({
-});
+}).strict();
 export type Double = z.infer<typeof DoubleSchema>;
 
 export const DynamicSchema = z.object({
-});
+}).strict();
 export type Dynamic = z.infer<typeof DynamicSchema>;
 
 export const DynamicCastSchema = z.object({
-});
+}).strict();
 export type DynamicCast = z.infer<typeof DynamicCastSchema>;
 
 export const ElifSchema = z.object({
-});
+}).strict();
 export type Elif = z.infer<typeof ElifSchema>;
 
 export const ElseSchema = z.object({
-});
+}).strict();
 export type Else = z.infer<typeof ElseSchema>;
 
-export const EmptySchema = z.object({
-});
-export type Empty = z.infer<typeof EmptySchema>;
-
 export const EncodeQuickTypeSchema = z.object({
-});
+}).strict();
 export type EncodeQuickType = z.infer<typeof EncodeQuickTypeSchema>;
 
 export const EnumSchema = z.object({
-});
+}).strict();
 export type Enum = z.infer<typeof EnumSchema>;
 
 export const EventSchema = z.object({
-});
+}).strict();
 export type Event = z.infer<typeof EventSchema>;
 
 export const ExceptSchema = z.object({
-});
+}).strict();
 export type Except = z.infer<typeof ExceptSchema>;
 
 export const ExceptionSchema = z.object({
-});
+}).strict();
 export type Exception = z.infer<typeof ExceptionSchema>;
 
 export const ExplicitSchema = z.object({
-});
+}).strict();
 export type Explicit = z.infer<typeof ExplicitSchema>;
 
 export const ExportSchema = z.object({
-});
+}).strict();
 export type Export = z.infer<typeof ExportSchema>;
 
 export const ExposingSchema = z.object({
-});
+}).strict();
 export type Exposing = z.infer<typeof ExposingSchema>;
 
 export const ExtendsSchema = z.object({
-});
+}).strict();
 export type Extends = z.infer<typeof ExtendsSchema>;
 
 export const ExtensionSchema = z.object({
-});
+}).strict();
 export type Extension = z.infer<typeof ExtensionSchema>;
 
 export const ExternSchema = z.object({
-});
+}).strict();
 export type Extern = z.infer<typeof ExternSchema>;
 
 export const FallthroughSchema = z.object({
-});
+}).strict();
 export type Fallthrough = z.infer<typeof FallthroughSchema>;
 
-export const FalseSchema = z.object({
-});
-export type False = z.infer<typeof FalseSchema>;
+export const FalseClassSchema = z.object({
+}).strict();
+export type FalseClass = z.infer<typeof FalseClassSchema>;
 
 export const FileprivateSchema = z.object({
-});
+}).strict();
 export type Fileprivate = z.infer<typeof FileprivateSchema>;
 
 export const FinalSchema = z.object({
-});
+}).strict();
 export type Final = z.infer<typeof FinalSchema>;
 
 export const FinallySchema = z.object({
-});
+}).strict();
 export type Finally = z.infer<typeof FinallySchema>;
 
 export const FixedSchema = z.object({
-});
+}).strict();
 export type Fixed = z.infer<typeof FixedSchema>;
 
 export const FloatSchema = z.object({
-});
+}).strict();
 export type Float = z.infer<typeof FloatSchema>;
 
 export const ForSchema = z.object({
-});
+}).strict();
 export type For = z.infer<typeof ForSchema>;
 
 export const ForeachSchema = z.object({
-});
+}).strict();
 export type Foreach = z.infer<typeof ForeachSchema>;
 
 export const FriendSchema = z.object({
-});
+}).strict();
 export type Friend = z.infer<typeof FriendSchema>;
 
 export const FromSchema = z.object({
-});
+}).strict();
 export type From = z.infer<typeof FromSchema>;
 
 export const FromJsonSchema = z.object({
-});
+}).strict();
 export type FromJson = z.infer<typeof FromJsonSchema>;
 
 export const FuncSchema = z.object({
-});
+}).strict();
 export type Func = z.infer<typeof FuncSchema>;
 
 export const FunctionSchema = z.object({
-});
+}).strict();
 export type Function = z.infer<typeof FunctionSchema>;
 
 export const GetSchema = z.object({
-});
+}).strict();
 export type Get = z.infer<typeof GetSchema>;
 
 export const GlobalSchema = z.object({
-});
+}).strict();
 export type Global = z.infer<typeof GlobalSchema>;
 
 export const GoSchema = z.object({
-});
+}).strict();
 export type Go = z.infer<typeof GoSchema>;
 
 export const GotoSchema = z.object({
-});
+}).strict();
 export type Goto = z.infer<typeof GotoSchema>;
 
 export const GuardSchema = z.object({
-});
+}).strict();
 export type Guard = z.infer<typeof GuardSchema>;
 
 export const HasOwnPropertySchema = z.object({
-});
+}).strict();
 export type HasOwnProperty = z.infer<typeof HasOwnPropertySchema>;
 
 export const IdSchema = z.object({
-});
+}).strict();
 export type Id = z.infer<typeof IdSchema>;
 
 export const IfSchema = z.object({
-});
+}).strict();
 export type If = z.infer<typeof IfSchema>;
 
-export const ImaginerySchema = z.object({
-});
-export type Imaginery = z.infer<typeof ImaginerySchema>;
-
-export const ImpSchema = z.object({
-});
-export type Imp = z.infer<typeof ImpSchema>;
-
 export const ImplementsSchema = z.object({
-});
+}).strict();
 export type Implements = z.infer<typeof ImplementsSchema>;
 
 export const ImplicitSchema = z.object({
-});
+}).strict();
 export type Implicit = z.infer<typeof ImplicitSchema>;
 
 export const ImportSchema = z.object({
-});
+}).strict();
 export type Import = z.infer<typeof ImportSchema>;
 
 export const InSchema = z.object({
-});
+}).strict();
 export type In = z.infer<typeof InSchema>;
 
 export const IndirectSchema = z.object({
-});
+}).strict();
 export type Indirect = z.infer<typeof IndirectSchema>;
 
 export const InfixSchema = z.object({
-});
+}).strict();
 export type Infix = z.infer<typeof InfixSchema>;
 
 export const InitSchema = z.object({
-});
+}).strict();
 export type Init = z.infer<typeof InitSchema>;
 
 export const InlineSchema = z.object({
-});
+}).strict();
 export type Inline = z.infer<typeof InlineSchema>;
 
 export const InoutSchema = z.object({
-});
+}).strict();
 export type Inout = z.infer<typeof InoutSchema>;
 
 export const InstanceofSchema = z.object({
-});
+}).strict();
 export type Instanceof = z.infer<typeof InstanceofSchema>;
 
 export const IntSchema = z.object({
-});
+}).strict();
 export type Int = z.infer<typeof IntSchema>;
 
 export const InterfaceSchema = z.object({
-});
+}).strict();
 export type Interface = z.infer<typeof InterfaceSchema>;
 
 export const InternalSchema = z.object({
-});
+}).strict();
 export type Internal = z.infer<typeof InternalSchema>;
 
 export const IsSchema = z.object({
-});
+}).strict();
 export type Is = z.infer<typeof IsSchema>;
 
 export const IterableSchema = z.object({
-});
+}).strict();
 export type Iterable = z.infer<typeof IterableSchema>;
 
 export const JdecSchema = z.object({
-});
+}).strict();
 export type Jdec = z.infer<typeof JdecSchema>;
 
 export const JencSchema = z.object({
-});
+}).strict();
 export type Jenc = z.infer<typeof JencSchema>;
 
 export const JpipeSchema = z.object({
-});
+}).strict();
 export type Jpipe = z.infer<typeof JpipeSchema>;
 
 export const JsonSchema = z.object({
-});
+}).strict();
 export type Json = z.infer<typeof JsonSchema>;
 
 export const JsonConverterSchema = z.object({
-});
+}).strict();
 export type JsonConverter = z.infer<typeof JsonConverterSchema>;
 
 export const JsonSerializerSchema = z.object({
-});
+}).strict();
 export type JsonSerializer = z.infer<typeof JsonSerializerSchema>;
 
 export const JsonTokenSchema = z.object({
-});
+}).strict();
 export type JsonToken = z.infer<typeof JsonTokenSchema>;
 
 export const JsonWriterSchema = z.object({
-});
+}).strict();
 export type JsonWriter = z.infer<typeof JsonWriterSchema>;
 
 export const LambdaSchema = z.object({
-});
+}).strict();
 export type Lambda = z.infer<typeof LambdaSchema>;
 
 export const LazySchema = z.object({
-});
+}).strict();
 export type Lazy = z.infer<typeof LazySchema>;
 
 export const LeftSchema = z.object({
-});
+}).strict();
 export type Left = z.infer<typeof LeftSchema>;
 
 export const LetSchema = z.object({
-});
+}).strict();
 export type Let = z.infer<typeof LetSchema>;
 
 export const ListSchema = z.object({
-});
+}).strict();
 export type List = z.infer<typeof ListSchema>;
 
 export const LockSchema = z.object({
-});
+}).strict();
 export type Lock = z.infer<typeof LockSchema>;
 
 export const LongSchema = z.object({
-});
+}).strict();
 export type Long = z.infer<typeof LongSchema>;
 
 export const MapSchema = z.object({
-});
+}).strict();
 export type Map = z.infer<typeof MapSchema>;
 
 export const MetadataPropertyHandlingSchema = z.object({
-});
+}).strict();
 export type MetadataPropertyHandling = z.infer<typeof MetadataPropertyHandlingSchema>;
 
 export const ModuleSchema = z.object({
-});
+}).strict();
 export type Module = z.infer<typeof ModuleSchema>;
 
 export const MutableSchema = z.object({
-});
+}).strict();
 export type Mutable = z.infer<typeof MutableSchema>;
 
 export const MutatingSchema = z.object({
-});
+}).strict();
 export type Mutating = z.infer<typeof MutatingSchema>;
 
 export const NamespaceSchema = z.object({
-});
+}).strict();
 export type Namespace = z.infer<typeof NamespaceSchema>;
 
 export const NativeSchema = z.object({
-});
+}).strict();
 export type Native = z.infer<typeof NativeSchema>;
 
 export const NewSchema = z.object({
-});
+}).strict();
 export type New = z.infer<typeof NewSchema>;
 
 export const NewtonsoftSchema = z.object({
-});
+}).strict();
 export type Newtonsoft = z.infer<typeof NewtonsoftSchema>;
 
 export const NilSchema = z.object({
-});
+}).strict();
 export type Nil = z.infer<typeof NilSchema>;
 
-export const NoSchema = z.object({
-});
-export type No = z.infer<typeof NoSchema>;
-
 export const NoexceptSchema = z.object({
-});
+}).strict();
 export type Noexcept = z.infer<typeof NoexceptSchema>;
 
 export const NonatomicSchema = z.object({
-});
+}).strict();
 export type Nonatomic = z.infer<typeof NonatomicSchema>;
 
-export const NoneSchema = z.object({
-});
-export type None = z.infer<typeof NoneSchema>;
+export const NoneClassSchema = z.object({
+}).strict();
+export type NoneClass = z.infer<typeof NoneClassSchema>;
 
 export const NonlocalSchema = z.object({
-});
+}).strict();
 export type Nonlocal = z.infer<typeof NonlocalSchema>;
 
 export const NonmutatingSchema = z.object({
-});
+}).strict();
 export type Nonmutating = z.infer<typeof NonmutatingSchema>;
 
 export const NotSchema = z.object({
-});
+}).strict();
 export type Not = z.infer<typeof NotSchema>;
 
 export const NotEqSchema = z.object({
-});
+}).strict();
 export type NotEq = z.infer<typeof NotEqSchema>;
 
-export const NsStringSchema = z.object({
-});
-export type NsString = z.infer<typeof NsStringSchema>;
-
-export const NullSchema = z.object({
-});
-export type Null = z.infer<typeof NullSchema>;
+export const NullClassSchema = z.object({
+}).strict();
+export type NullClass = z.infer<typeof NullClassSchema>;
 
 export const NullptrSchema = z.object({
-});
+}).strict();
 export type Nullptr = z.infer<typeof NullptrSchema>;
 
 export const NumberSchema = z.object({
-});
+}).strict();
 export type Number = z.infer<typeof NumberSchema>;
 
 export const ObjectClassSchema = z.object({
-});
+}).strict();
 export type ObjectClass = z.infer<typeof ObjectClassSchema>;
 
 export const OfSchema = z.object({
-});
+}).strict();
 export type Of = z.infer<typeof OfSchema>;
 
 export const OnewaySchema = z.object({
-});
+}).strict();
 export type Oneway = z.infer<typeof OnewaySchema>;
 
 export const OpenSchema = z.object({
-});
+}).strict();
 export type Open = z.infer<typeof OpenSchema>;
 
 export const OperatorSchema = z.object({
-});
+}).strict();
 export type Operator = z.infer<typeof OperatorSchema>;
 
 export const OptionalSchema = z.object({
-});
+}).strict();
 export type Optional = z.infer<typeof OptionalSchema>;
 
 export const OrSchema = z.object({
-});
+}).strict();
 export type Or = z.infer<typeof OrSchema>;
 
 export const OrEqSchema = z.object({
-});
+}).strict();
 export type OrEq = z.infer<typeof OrEqSchema>;
 
 export const OutSchema = z.object({
-});
+}).strict();
 export type Out = z.infer<typeof OutSchema>;
 
 export const OverrideSchema = z.object({
-});
+}).strict();
 export type Override = z.infer<typeof OverrideSchema>;
 
 export const PackageSchema = z.object({
-});
+}).strict();
 export type Package = z.infer<typeof PackageSchema>;
 
 export const ParamsSchema = z.object({
-});
+}).strict();
 export type Params = z.infer<typeof ParamsSchema>;
 
 export const PassSchema = z.object({
-});
+}).strict();
 export type Pass = z.infer<typeof PassSchema>;
 
 export const PortSchema = z.object({
-});
+}).strict();
 export type Port = z.infer<typeof PortSchema>;
 
 export const PostfixSchema = z.object({
-});
+}).strict();
 export type Postfix = z.infer<typeof PostfixSchema>;
 
 export const PrecedenceSchema = z.object({
-});
+}).strict();
 export type Precedence = z.infer<typeof PrecedenceSchema>;
 
 export const PrefixSchema = z.object({
-});
+}).strict();
 export type Prefix = z.infer<typeof PrefixSchema>;
 
 export const PrintSchema = z.object({
-});
+}).strict();
 export type Print = z.infer<typeof PrintSchema>;
 
 export const PrintfSchema = z.object({
-});
+}).strict();
 export type Printf = z.infer<typeof PrintfSchema>;
 
 export const PrivateSchema = z.object({
-});
+}).strict();
 export type Private = z.infer<typeof PrivateSchema>;
 
 export const ProtectedSchema = z.object({
-});
+}).strict();
 export type Protected = z.infer<typeof ProtectedSchema>;
 
-export const ProtocolSchema = z.object({
-});
-export type Protocol = z.infer<typeof ProtocolSchema>;
+export const ProtocolClassSchema = z.object({
+}).strict();
+export type ProtocolClass = z.infer<typeof ProtocolClassSchema>;
 
 export const PublicSchema = z.object({
-});
+}).strict();
 export type Public = z.infer<typeof PublicSchema>;
 
-export const UnionBoolBoolSchema = z.object({
-});
-export type UnionBoolBool = z.infer<typeof UnionBoolBoolSchema>;
-
 export const QuicktypeSchema = z.object({
-});
+}).strict();
 export type Quicktype = z.infer<typeof QuicktypeSchema>;
 
 export const RaiseSchema = z.object({
-});
+}).strict();
 export type Raise = z.infer<typeof RaiseSchema>;
 
 export const RangeSchema = z.object({
-});
+}).strict();
 export type Range = z.infer<typeof RangeSchema>;
 
 export const ReadonlySchema = z.object({
-});
+}).strict();
 export type Readonly = z.infer<typeof ReadonlySchema>;
 
 export const RefSchema = z.object({
-});
+}).strict();
 export type Ref = z.infer<typeof RefSchema>;
 
 export const RegisterSchema = z.object({
-});
+}).strict();
 export type Register = z.infer<typeof RegisterSchema>;
 
 export const ReinterpretCastSchema = z.object({
-});
+}).strict();
 export type ReinterpretCast = z.infer<typeof ReinterpretCastSchema>;
 
 export const RepeatSchema = z.object({
-});
+}).strict();
 export type Repeat = z.infer<typeof RepeatSchema>;
 
 export const RequireSchema = z.object({
-});
+}).strict();
 export type Require = z.infer<typeof RequireSchema>;
 
 export const RequiredSchema = z.object({
-});
+}).strict();
 export type Required = z.infer<typeof RequiredSchema>;
 
 export const RequiresSchema = z.object({
-});
+}).strict();
 export type Requires = z.infer<typeof RequiresSchema>;
 
 export const RestrictSchema = z.object({
-});
+}).strict();
 export type Restrict = z.infer<typeof RestrictSchema>;
 
 export const RetainSchema = z.object({
-});
+}).strict();
 export type Retain = z.infer<typeof RetainSchema>;
 
 export const RethrowsSchema = z.object({
-});
+}).strict();
 export type Rethrows = z.infer<typeof RethrowsSchema>;
 
 export const ReturnSchema = z.object({
-});
+}).strict();
 export type Return = z.infer<typeof ReturnSchema>;
 
 export const RightSchema = z.object({
-});
+}).strict();
 export type Right = z.infer<typeof RightSchema>;
 
 export const SbyteSchema = z.object({
-});
+}).strict();
 export type Sbyte = z.infer<typeof SbyteSchema>;
 
 export const SealedSchema = z.object({
-});
+}).strict();
 export type Sealed = z.infer<typeof SealedSchema>;
 
-export const SelSchema = z.object({
-});
-export type Sel = z.infer<typeof SelSchema>;
-
 export const SelectSchema = z.object({
-});
+}).strict();
 export type Select = z.infer<typeof SelectSchema>;
 
-export const SelfSchema = z.object({
-});
-export type Self = z.infer<typeof SelfSchema>;
+export const SelfClassSchema = z.object({
+}).strict();
+export type SelfClass = z.infer<typeof SelfClassSchema>;
 
 export const SerializeSchema = z.object({
-});
+}).strict();
 export type Serialize = z.infer<typeof SerializeSchema>;
 
 export const SetSchema = z.object({
-});
+}).strict();
 export type Set = z.infer<typeof SetSchema>;
 
 export const ShortSchema = z.object({
-});
+}).strict();
 export type Short = z.infer<typeof ShortSchema>;
 
 export const SignedSchema = z.object({
-});
+}).strict();
 export type Signed = z.infer<typeof SignedSchema>;
 
 export const SizeofSchema = z.object({
-});
+}).strict();
 export type Sizeof = z.infer<typeof SizeofSchema>;
 
 export const StackallocSchema = z.object({
-});
+}).strict();
 export type Stackalloc = z.infer<typeof StackallocSchema>;
 
 export const StaticSchema = z.object({
-});
+}).strict();
 export type Static = z.infer<typeof StaticSchema>;
 
 export const StaticAssertSchema = z.object({
-});
+}).strict();
 export type StaticAssert = z.infer<typeof StaticAssertSchema>;
 
 export const StaticCastSchema = z.object({
-});
+}).strict();
 export type StaticCast = z.infer<typeof StaticCastSchema>;
 
 export const StrictfpSchema = z.object({
-});
+}).strict();
 export type Strictfp = z.infer<typeof StrictfpSchema>;
 
 export const StringClassSchema = z.object({
-});
+}).strict();
 export type StringClass = z.infer<typeof StringClassSchema>;
 
 export const StructSchema = z.object({
-});
+}).strict();
 export type Struct = z.infer<typeof StructSchema>;
 
 export const SubscriptSchema = z.object({
-});
+}).strict();
 export type Subscript = z.infer<typeof SubscriptSchema>;
 
 export const SuperSchema = z.object({
-});
+}).strict();
 export type Super = z.infer<typeof SuperSchema>;
 
 export const SwitchSchema = z.object({
-});
+}).strict();
 export type Switch = z.infer<typeof SwitchSchema>;
 
 export const SymbolSchema = z.object({
-});
+}).strict();
 export type Symbol = z.infer<typeof SymbolSchema>;
 
 export const SynchronizedSchema = z.object({
-});
+}).strict();
 export type Synchronized = z.infer<typeof SynchronizedSchema>;
 
 export const SystemSchema = z.object({
-});
+}).strict();
 export type System = z.infer<typeof SystemSchema>;
 
 export const TemplateSchema = z.object({
-});
+}).strict();
 export type Template = z.infer<typeof TemplateSchema>;
 
 export const ThenSchema = z.object({
-});
+}).strict();
 export type Then = z.infer<typeof ThenSchema>;
 
 export const ThisSchema = z.object({
-});
+}).strict();
 export type This = z.infer<typeof ThisSchema>;
 
 export const ThreadLocalSchema = z.object({
-});
+}).strict();
 export type ThreadLocal = z.infer<typeof ThreadLocalSchema>;
 
 export const ThrowSchema = z.object({
-});
+}).strict();
 export type Throw = z.infer<typeof ThrowSchema>;
 
 export const ThrowsSchema = z.object({
-});
+}).strict();
 export type Throws = z.infer<typeof ThrowsSchema>;
 
 export const ToJsonSchema = z.object({
-});
+}).strict();
 export type ToJson = z.infer<typeof ToJsonSchema>;
 
 export const TopLevelClassSchema = z.object({
-});
+}).strict();
 export type TopLevelClass = z.infer<typeof TopLevelClassSchema>;
 
-export const AnyClassSchema = z.object({
-});
-export type AnyClass = z.infer<typeof AnyClassSchema>;
-
-export const BoolClassSchema = z.object({
-});
-export type BoolClass = z.infer<typeof BoolClassSchema>;
-
-export const UnionClassClassSchema = z.object({
-});
-export type UnionClassClass = z.infer<typeof UnionClassClassSchema>;
-
-export const FalseClassSchema = z.object({
-});
-export type FalseClass = z.infer<typeof FalseClassSchema>;
-
-export const NoneClassSchema = z.object({
-});
-export type NoneClass = z.infer<typeof NoneClassSchema>;
-
-export const NullClassSchema = z.object({
-});
-export type NullClass = z.infer<typeof NullClassSchema>;
-
-export const ProtocolClassSchema = z.object({
-});
-export type ProtocolClass = z.infer<typeof ProtocolClassSchema>;
-
-export const SelfClassSchema = z.object({
-});
-export type SelfClass = z.infer<typeof SelfClassSchema>;
-
-export const TrueClassSchema = z.object({
-});
-export type TrueClass = z.infer<typeof TrueClassSchema>;
-
-export const TypeClassSchema = z.object({
-});
-export type TypeClass = z.infer<typeof TypeClassSchema>;
-
 export const TransientSchema = z.object({
-});
+}).strict();
 export type Transient = z.infer<typeof TransientSchema>;
 
-export const TrueSchema = z.object({
-});
-export type True = z.infer<typeof TrueSchema>;
+export const TrueClassSchema = z.object({
+}).strict();
+export type TrueClass = z.infer<typeof TrueClassSchema>;
 
 export const TrySchema = z.object({
-});
+}).strict();
 export type Try = z.infer<typeof TrySchema>;
 
-export const TypeSchema = z.object({
-});
-export type Type = z.infer<typeof TypeSchema>;
+export const TypeClassSchema = z.object({
+}).strict();
+export type TypeClass = z.infer<typeof TypeClassSchema>;
 
 export const TypealiasSchema = z.object({
-});
+}).strict();
 export type Typealias = z.infer<typeof TypealiasSchema>;
 
 export const TypedefSchema = z.object({
-});
+}).strict();
 export type Typedef = z.infer<typeof TypedefSchema>;
 
 export const TypeidSchema = z.object({
-});
+}).strict();
 export type Typeid = z.infer<typeof TypeidSchema>;
 
 export const TypenameSchema = z.object({
-});
+}).strict();
 export type Typename = z.infer<typeof TypenameSchema>;
 
 export const TypeofSchema = z.object({
-});
+}).strict();
 export type Typeof = z.infer<typeof TypeofSchema>;
 
 export const UintSchema = z.object({
-});
+}).strict();
 export type Uint = z.infer<typeof UintSchema>;
 
 export const UlongSchema = z.object({
-});
+}).strict();
 export type Ulong = z.infer<typeof UlongSchema>;
 
 export const UncheckedSchema = z.object({
-});
+}).strict();
 export type Unchecked = z.infer<typeof UncheckedSchema>;
 
 export const UndefinedSchema = z.object({
-});
+}).strict();
 export type Undefined = z.infer<typeof UndefinedSchema>;
 
 export const UnionSchema = z.object({
-});
+}).strict();
 export type Union = z.infer<typeof UnionSchema>;
 
 export const UnownedSchema = z.object({
-});
+}).strict();
 export type Unowned = z.infer<typeof UnownedSchema>;
 
 export const UnsafeSchema = z.object({
-});
+}).strict();
 export type Unsafe = z.infer<typeof UnsafeSchema>;
 
 export const UnsignedSchema = z.object({
-});
+}).strict();
 export type Unsigned = z.infer<typeof UnsignedSchema>;
 
 export const UshortSchema = z.object({
-});
+}).strict();
 export type Ushort = z.infer<typeof UshortSchema>;
 
 export const UsingSchema = z.object({
-});
+}).strict();
 export type Using = z.infer<typeof UsingSchema>;
 
 export const VarSchema = z.object({
-});
+}).strict();
 export type Var = z.infer<typeof VarSchema>;
 
 export const VirtualSchema = z.object({
-});
+}).strict();
 export type Virtual = z.infer<typeof VirtualSchema>;
 
 export const VoidSchema = z.object({
-});
+}).strict();
 export type Void = z.infer<typeof VoidSchema>;
 
 export const VolatileSchema = z.object({
-});
+}).strict();
 export type Volatile = z.infer<typeof VolatileSchema>;
 
 export const WcharTSchema = z.object({
-});
+}).strict();
 export type WcharT = z.infer<typeof WcharTSchema>;
 
 export const WeakSchema = z.object({
-});
+}).strict();
 export type Weak = z.infer<typeof WeakSchema>;
 
 export const WhereSchema = z.object({
-});
+}).strict();
 export type Where = z.infer<typeof WhereSchema>;
 
 export const WhileSchema = z.object({
-});
+}).strict();
 export type While = z.infer<typeof WhileSchema>;
 
 export const WillSetSchema = z.object({
-});
+}).strict();
 export type WillSet = z.infer<typeof WillSetSchema>;
 
 export const WithSchema = z.object({
-});
+}).strict();
 export type With = z.infer<typeof WithSchema>;
 
 export const XorSchema = z.object({
-});
+}).strict();
 export type Xor = z.infer<typeof XorSchema>;
 
 export const XorEqSchema = z.object({
-});
+}).strict();
 export type XorEq = z.infer<typeof XorEqSchema>;
 
-export const YesSchema = z.object({
-});
-export type Yes = z.infer<typeof YesSchema>;
-
 export const YieldSchema = z.object({
-});
+}).strict();
 export type Yield = z.infer<typeof YieldSchema>;
 
 export const TopLevelSchema = z.preprocess(value => typeof value === "object" && value !== null && !Array.isArray(value) ? Object.assign(Object.create(null), value) : value, z.object({
@@ -1383,5 +1383,5 @@ export const TopLevelSchema = z.preprocess(value => typeof value === "object" &&
     "xor_eq": z.union([XorEqSchema, z.number()]).optional(),
     "YES": z.union([YesSchema, z.number()]).optional(),
     "yield": z.union([YieldSchema, z.number()]).optional(),
-}));
+}).passthrough());
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/light.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/light.schema/default/TopLevel.ts
index d23650b..506f66e 100644
--- a/base/schema-typescript-zod/test/inputs/schema/light.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/light.schema/default/TopLevel.ts
@@ -5,10 +5,10 @@ export const LightParamsSchema = z.object({
     "app_id": z.string(),
     "outlet_id": z.string(),
     "rgba": z.string(),
-});
+}).strict();
 export type LightParams = z.infer<typeof LightParamsSchema>;
 
 export const TopLevelSchema = z.object({
     "LightParams": LightParamsSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/list.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/list.schema/default/TopLevel.ts
index c7d88df..9824c79 100644
--- a/base/schema-typescript-zod/test/inputs/schema/list.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/list.schema/default/TopLevel.ts
@@ -7,5 +7,5 @@ export type TopLevel = {
 export const TopLevelSchema: z.ZodType<TopLevel> = z.lazy(() =>
     z.object({
         "next": TopLevelSchema.optional(),
-    })
+    }).passthrough()
 );
diff --git a/base/schema-typescript-zod/test/inputs/schema/min-max-items.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/min-max-items.schema/default/TopLevel.ts
index cb6d1d1..1de68c2 100644
--- a/base/schema-typescript-zod/test/inputs/schema/min-max-items.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/min-max-items.schema/default/TopLevel.ts
@@ -7,5 +7,5 @@ export const TopLevelSchema = z.object({
     "minOnly": z.array(z.string()).min(2),
     "plain": z.array(z.string()),
     "unionItems": z.array(z.union([z.number().int(), z.string()])).min(2),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/minmax-integer.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/minmax-integer.schema/default/TopLevel.ts
index bef8ead..5caac6e 100644
--- a/base/schema-typescript-zod/test/inputs/schema/minmax-integer.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/minmax-integer.schema/default/TopLevel.ts
@@ -10,5 +10,5 @@ export const TopLevelSchema = z.object({
     "minMaxIntersection": z.number().int().min(3).max(5),
     "minMaxUnion": z.number().int(),
     "union": z.number().int().min(3).max(6),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/minmax.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/minmax.schema/default/TopLevel.ts
index 983775c..5287875 100644
--- a/base/schema-typescript-zod/test/inputs/schema/minmax.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/minmax.schema/default/TopLevel.ts
@@ -10,5 +10,5 @@ export const TopLevelSchema = z.object({
     "minMaxIntersection": z.number().min(3).max(5),
     "minMaxUnion": z.number(),
     "union": z.number().min(3).max(6),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts
index 0a16cef..2f11d68 100644
--- a/base/schema-typescript-zod/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/minmaxlength.schema/default/TopLevel.ts
@@ -10,5 +10,5 @@ export const TopLevelSchema = z.object({
     "minmaxlength": z.string().min(3).max(5),
     "minMaxUnion": z.string(),
     "union": z.string().min(3).max(6),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/multi-type-enum.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/multi-type-enum.schema/default/TopLevel.ts
index 058cfb6..217afb6 100644
--- a/base/schema-typescript-zod/test/inputs/schema/multi-type-enum.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/multi-type-enum.schema/default/TopLevel.ts
@@ -10,5 +10,5 @@ export type FooEnum = z.infer<typeof FooEnumSchema>;
 
 export const TopLevelSchema = z.object({
     "foo": z.union([z.boolean(), z.number(), FooEnumSchema]),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/mutually-recursive.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/mutually-recursive.schema/default/TopLevel.ts
index ed771de..e02ff33 100644
--- a/base/schema-typescript-zod/test/inputs/schema/mutually-recursive.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/mutually-recursive.schema/default/TopLevel.ts
@@ -7,7 +7,7 @@ export type Bar = {
 export const BarSchema: z.ZodType<Bar> = z.lazy(() =>
     z.object({
         "foo": z.union([z.array(TopLevelSchema), TopLevelSchema]),
-    })
+    }).passthrough()
 );
 
 export type TopLevel = {
@@ -16,5 +16,5 @@ export type TopLevel = {
 export const TopLevelSchema: z.ZodType<TopLevel> = z.lazy(() =>
     z.object({
         "bar": BarSchema.optional(),
-    })
+    }).passthrough()
 );
diff --git a/base/schema-typescript-zod/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.ts
index 30e46b7..0c0e2ba 100644
--- a/base/schema-typescript-zod/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/nested-intersection-union.schema/default/TopLevel.ts
@@ -6,10 +6,10 @@ export const ItemSchema = z.object({
     "id": z.string().optional(),
     "output": z.string().optional(),
     "summary": z.string().optional(),
-});
+}).passthrough();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const TopLevelSchema = z.object({
     "input": z.array(ItemSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/non-standard-ref.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/non-standard-ref.schema/default/TopLevel.ts
index e8901bb..0c042f8 100644
--- a/base/schema-typescript-zod/test/inputs/schema/non-standard-ref.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/non-standard-ref.schema/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "bar": z.number().int(),
     "foo": z.number().int(),
     "quux": z.boolean(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.ts
index 75ba873..e8ec150 100644
--- a/base/schema-typescript-zod/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/nullable-optional-one-of.schema/default/TopLevel.ts
@@ -10,5 +10,5 @@ export type Kind = z.infer<typeof KindSchema>;
 export const TopLevelSchema = z.object({
     "b": z.union([z.null(), z.string()]).optional(),
     "kind": KindSchema,
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/object-type-required.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/object-type-required.schema/default/TopLevel.ts
index 4a816c5..55b554f 100644
--- a/base/schema-typescript-zod/test/inputs/schema/object-type-required.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/object-type-required.schema/default/TopLevel.ts
@@ -4,5 +4,5 @@ import * as z from "zod";
 export const TopLevelSchema = z.object({
     "foo": z.string(),
     "bar": z.string().optional(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/optional-any.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/optional-any.schema/default/TopLevel.ts
index 816f79c..e0effe4 100644
--- a/base/schema-typescript-zod/test/inputs/schema/optional-any.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/optional-any.schema/default/TopLevel.ts
@@ -4,5 +4,5 @@ import * as z from "zod";
 export const TopLevelSchema = z.object({
     "bar": z.boolean(),
     "foo": z.any().optional(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts
index 1372ddb..e7e58bf 100644
--- a/base/schema-typescript-zod/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/optional-const-ref.schema/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const CoordinateSchema = z.object({
     "latitude": z.number(),
     "longitude": z.number(),
-});
+}).strict();
 export type Coordinate = z.infer<typeof CoordinateSchema>;
 
 export const TopLevelSchema = z.object({
@@ -15,5 +15,5 @@ export const TopLevelSchema = z.object({
     "requiredCount": z.number().int().min(1).max(100),
     "requiredLabel": z.string().min(2).max(16),
     "weight": z.number().min(0.5).max(99.5).optional(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts
index 3c40ff0..6aa9dfe 100644
--- a/base/schema-typescript-zod/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/optional-constraints.schema/default/TopLevel.ts
@@ -7,5 +7,5 @@ export const TopLevelSchema = z.object({
     "optPattern": z.string().regex(new RegExp("^[a-z]+$")).optional(),
     "optString": z.string().min(3).max(10).optional(),
     "reqZeroMin": z.number().int().min(0).max(100),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/optional-date-time.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/optional-date-time.schema/default/TopLevel.ts
index f4338b3..a9c7465 100644
--- a/base/schema-typescript-zod/test/inputs/schema/optional-date-time.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/optional-date-time.schema/default/TopLevel.ts
@@ -8,5 +8,5 @@ export const TopLevelSchema = z.object({
     "required-date": z.string(),
     "required-date-time": z.coerce.date(),
     "required-time": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/optional-enum.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/optional-enum.schema/default/TopLevel.ts
index 3ce9360..0586f62 100644
--- a/base/schema-typescript-zod/test/inputs/schema/optional-enum.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/optional-enum.schema/default/TopLevel.ts
@@ -10,5 +10,5 @@ export type Shortcut = z.infer<typeof ShortcutSchema>;
 export const TopLevelSchema = z.object({
     "name": z.string(),
     "shortcut": ShortcutSchema.optional(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/pattern.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/pattern.schema/default/TopLevel.ts
index 4fe2b21..8b2c1e2 100644
--- a/base/schema-typescript-zod/test/inputs/schema/pattern.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/pattern.schema/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "pattern1": z.string().regex(new RegExp("a[.]*")),
     "pattern2": z.string().regex(new RegExp("b[.]*")),
     "union": z.string().regex(new RegExp("(b[.]*)|(c[.]*)")),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/postman-collection.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/postman-collection.schema/default/TopLevel.ts
index 98d0eb5..6097926 100644
--- a/base/schema-typescript-zod/test/inputs/schema/postman-collection.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/postman-collection.schema/default/TopLevel.ts
@@ -11,10 +11,10 @@ export const TopLevelSchema: z.ZodType<TopLevel> = z.lazy(() =>
         "item": z.array(TopLevelSchema).optional(),
         "name": z.string().optional(),
         "response": z.array(ResponseSchema).optional(),
-    })
+    }).passthrough()
 );
 
 export const ResponseSchema = z.object({
     "body": z.string().optional(),
-});
+}).passthrough();
 export type Response = z.infer<typeof ResponseSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/prefix-items.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/prefix-items.schema/default/TopLevel.ts
index de99345..954c4c0 100644
--- a/base/schema-typescript-zod/test/inputs/schema/prefix-items.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/prefix-items.schema/default/TopLevel.ts
@@ -4,5 +4,5 @@ import * as z from "zod";
 export const TopLevelSchema = z.object({
     "open": z.array(z.union([z.boolean(), z.number().int()])),
     "tuple": z.array(z.union([z.boolean(), z.number().int()])),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.ts
index 62a038c..03e1653 100644
--- a/base/schema-typescript-zod/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/recursive-union-flattening.schema/default/TopLevel.ts
@@ -1,19 +1,19 @@
 import * as z from "zod";
 
 
-export type XClass = {
-    "x"?: Array<Array<any> | boolean | XClass | number | null | string> | boolean | number | Record<string, any> | null | string;
+export type XObject = {
+    "x"?: Array<Array<any> | boolean | number | null | XObject | string> | boolean | number | Record<string, any> | null | string;
 };
-export const XClassSchema: z.ZodType<XClass> = z.lazy(() =>
+export const XObjectSchema: z.ZodType<XObject> = z.lazy(() =>
     z.object({
-        "x": z.union([z.null(), z.array(z.union([z.null(), z.array(z.any()), z.boolean(), XClassSchema, z.number(), z.string()])), z.boolean(), z.number(), z.record(z.string(), z.any()), z.string()]).optional(),
-    })
+        "x": z.union([z.null(), z.array(z.union([z.null(), z.array(z.any()), z.boolean(), z.number(), XObjectSchema, z.string()])), z.boolean(), z.number(), z.record(z.string(), z.any()), z.string()]).optional(),
+    }).passthrough()
 );
 
-export const TopLevelClassSchema = z.object({
-    "x": z.union([z.null(), z.array(z.union([z.null(), z.array(z.any()), z.boolean(), XClassSchema, z.number(), z.string()])), z.boolean(), z.number(), z.record(z.string(), z.any()), z.string()]).optional(),
-});
-export type TopLevelClass = z.infer<typeof TopLevelClassSchema>;
+export const TopLevelObjectSchema = z.object({
+    "x": z.union([z.null(), z.array(z.union([z.null(), z.array(z.any()), z.boolean(), z.number(), XObjectSchema, z.string()])), z.boolean(), z.number(), z.record(z.string(), z.any()), z.string()]).optional(),
+}).passthrough();
+export type TopLevelObject = z.infer<typeof TopLevelObjectSchema>;
 
-export const TopLevelSchema = z.union([z.null(), z.array(z.union([z.null(), z.array(z.any()), z.boolean(), TopLevelClassSchema, z.number(), z.string()])), z.boolean(), z.number(), z.number().int(), z.record(z.string(), z.any()), z.string()]);
+export const TopLevelSchema = z.union([z.null(), z.array(z.union([z.null(), z.array(z.any()), z.boolean(), z.number(), TopLevelObjectSchema, z.string()])), z.boolean(), z.number(), z.number().int(), z.record(z.string(), z.any()), z.string()]);
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/ref-id-files.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/ref-id-files.schema/default/TopLevel.ts
index 8787324..f9ec7ce 100644
--- a/base/schema-typescript-zod/test/inputs/schema/ref-id-files.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/ref-id-files.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "foo": z.number().int(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/ref-remote.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/ref-remote.schema/default/TopLevel.ts
index c7d88df..9824c79 100644
--- a/base/schema-typescript-zod/test/inputs/schema/ref-remote.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/ref-remote.schema/default/TopLevel.ts
@@ -7,5 +7,5 @@ export type TopLevel = {
 export const TopLevelSchema: z.ZodType<TopLevel> = z.lazy(() =>
     z.object({
         "next": TopLevelSchema.optional(),
-    })
+    }).passthrough()
 );
diff --git a/base/schema-typescript-zod/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts
index 040a94a..b96ed5c 100644
--- a/base/schema-typescript-zod/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/renaming-bug.schema/default/TopLevel.ts
@@ -5,9 +5,9 @@ export const AxisSchema = z.enum([
     "X",
     "Y",
     "Z",
-    "XY",
     "YZ",
     "ZX",
+    "XY",
 ]);
 export type Axis = z.infer<typeof AxisSchema>;
 
@@ -27,53 +27,53 @@ export type Name = z.infer<typeof NameSchema>;
 
 export const ColorSchema = z.object({
     "rgb": z.number().optional(),
-});
+}).passthrough();
 export type Color = z.infer<typeof ColorSchema>;
 
 export const CircularShapeSchema = z.object({
     "shapeName": z.string().optional(),
-});
+}).passthrough();
 export type CircularShape = z.infer<typeof CircularShapeSchema>;
 
 export const PartSchema = z.object({
     "depth": z.string().optional(),
     "length": z.string().optional(),
     "width": z.string().optional(),
-});
+}).passthrough();
 export type Part = z.infer<typeof PartSchema>;
 
 export const HistorySchema = z.object({
     "class": z.string().optional(),
-});
+}).passthrough();
 export type History = z.infer<typeof HistorySchema>;
 
 export const LimitSchema = z.object({
     "maximum": z.number().optional(),
     "minimum": z.number().optional(),
-});
+}).passthrough();
 export type Limit = z.infer<typeof LimitSchema>;
 
 export const VehicleTypeSchema = z.object({
     "name": NameSchema.optional(),
     "width": AxisSchema.optional(),
     "length": AxisSchema.optional(),
-});
+}).passthrough();
 export type VehicleType = z.infer<typeof VehicleTypeSchema>;
 
 export const RectShapeSchema = z.object({
     "parts": z.array(PartSchema).optional(),
-});
+}).passthrough();
 export type RectShape = z.infer<typeof RectShapeSchema>;
 
 export const SpeedSchema = z.object({
     "velocity": LimitSchema.optional(),
-});
+}).passthrough();
 export type Speed = z.infer<typeof SpeedSchema>;
 
 export const GeometrySchema = z.object({
     "rectShape": RectShapeSchema.optional(),
     "circularShape": z.array(CircularShapeSchema).optional(),
-});
+}).passthrough();
 export type Geometry = z.infer<typeof GeometrySchema>;
 
 export const VehicleSchema = z.object({
@@ -83,32 +83,32 @@ export const VehicleSchema = z.object({
     "subModule": z.boolean().optional(),
     "type": VehicleTypeSchema.optional(),
     "year": z.string().optional(),
-});
+}).passthrough();
 export type Vehicle = z.infer<typeof VehicleSchema>;
 
 export const ShapeSchema = z.object({
     "geometry": GeometrySchema.optional(),
     "history": HistorySchema.optional(),
-});
+}).passthrough();
 export type Shape = z.infer<typeof ShapeSchema>;
 
 export const BerrySchema = z.object({
     "color": ColorSchema.optional(),
     "name": z.string().min(1).optional(),
     "shapes": z.array(ShapeSchema).optional(),
-});
+}).passthrough();
 export type Berry = z.infer<typeof BerrySchema>;
 
 export const FruitSchema = z.object({
     "apple": z.boolean().optional(),
     "berries": z.array(BerrySchema).optional(),
     "orange": z.boolean().optional(),
-});
+}).passthrough();
 export type Fruit = z.infer<typeof FruitSchema>;
 
 export const TopLevelSchema = z.object({
     "version": z.string().regex(new RegExp("^\\d{1,5}.{1}\\d{1,5}.{1}\\d{1,5}$")).optional(),
     "fruits": z.array(FruitSchema).optional(),
     "vehicles": z.array(VehicleSchema).optional(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/required-draft3.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/required-draft3.schema/default/TopLevel.ts
index e3e054b..1fce77b 100644
--- a/base/schema-typescript-zod/test/inputs/schema/required-draft3.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/required-draft3.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "longitude": z.number(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/required-non-properties.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/required-non-properties.schema/default/TopLevel.ts
index 68354ef..67816f4 100644
--- a/base/schema-typescript-zod/test/inputs/schema/required-non-properties.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/required-non-properties.schema/default/TopLevel.ts
@@ -4,5 +4,5 @@ import * as z from "zod";
 export const TopLevelSchema = z.object({
     "foo": z.number().int(),
     "bar": z.any(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/required.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/required.schema/default/TopLevel.ts
index e3e054b..1fce77b 100644
--- a/base/schema-typescript-zod/test/inputs/schema/required.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/required.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "longitude": z.number(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.ts
index 9036c1e..9b67032 100644
--- a/base/schema-typescript-zod/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/rust-cycle-breaker-union.schema/default/TopLevel.ts
@@ -2,18 +2,18 @@ import * as z from "zod";
 
 
 export type Node = {
-    "next"?: Node | null | string;
+    "next"?: null | Node | string;
     "value": string;
 };
 export const NodeSchema: z.ZodType<Node> = z.lazy(() =>
     z.object({
         "next": z.union([z.null(), NodeSchema, z.string()]).optional(),
         "value": z.string(),
-    })
+    }).passthrough()
 );
 
 export const TopLevelSchema = z.object({
     "next": z.union([z.null(), NodeSchema, z.string()]).optional(),
     "value": z.string(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts
index d87842a..92e790f 100644
--- a/base/schema-typescript-zod/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/schema-constraints.schema/default/TopLevel.ts
@@ -4,5 +4,5 @@ import * as z from "zod";
 export const TopLevelSchema = z.object({
     "minMaxLength": z.string().min(5).max(5),
     "percent": z.number().min(0).max(1),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/simple-ref.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/simple-ref.schema/default/TopLevel.ts
index c7d88df..9824c79 100644
--- a/base/schema-typescript-zod/test/inputs/schema/simple-ref.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/simple-ref.schema/default/TopLevel.ts
@@ -7,5 +7,5 @@ export type TopLevel = {
 export const TopLevelSchema: z.ZodType<TopLevel> = z.lazy(() =>
     z.object({
         "next": TopLevelSchema.optional(),
-    })
+    }).passthrough()
 );
diff --git a/base/schema-typescript-zod/test/inputs/schema/strict-optional.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/strict-optional.schema/default/TopLevel.ts
index bd01268..35dca5e 100644
--- a/base/schema-typescript-zod/test/inputs/schema/strict-optional.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/strict-optional.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "foo": z.union([z.null(), z.number()]),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/top-level-array.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/top-level-array.schema/default/TopLevel.ts
index fddcbb8..3bf6e3d 100644
--- a/base/schema-typescript-zod/test/inputs/schema/top-level-array.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/top-level-array.schema/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const TextClassificationOutputElementSchema = z.object({
     "label": z.string(),
     "score": z.number(),
-});
+}).passthrough();
 export type TextClassificationOutputElement = z.infer<typeof TextClassificationOutputElementSchema>;
 
 export const TopLevelSchema = z.array(TextClassificationOutputElementSchema);
diff --git a/base/schema-typescript-zod/test/inputs/schema/tuple.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/tuple.schema/default/TopLevel.ts
index 77b2256..4b8aa27 100644
--- a/base/schema-typescript-zod/test/inputs/schema/tuple.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/tuple.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "tuple": z.array(z.union([z.boolean(), z.number().int()])),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.ts
index 061a636..97d8599 100644
--- a/base/schema-typescript-zod/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/unevaluated-properties.schema/default/TopLevel.ts
@@ -2,23 +2,23 @@ import * as z from "zod";
 
 
 export const ClosedClassSchema = z.object({
-});
+}).strict();
 export type ClosedClass = z.infer<typeof ClosedClassSchema>;
 
 export const ItemSchema = z.object({
     "key": z.string(),
     "value": z.string(),
-});
+}).passthrough();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ConfigSchema = z.object({
     "closed": z.union([z.null(), z.array(z.any()), z.boolean(), ClosedClassSchema, z.number(), z.number().int(), z.string()]).optional(),
     "name": z.string().optional(),
     "settings": z.record(z.string(), z.array(ItemSchema)).optional(),
-});
+}).passthrough();
 export type Config = z.infer<typeof ConfigSchema>;
 
 export const TopLevelSchema = z.object({
     "config": ConfigSchema.optional(),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/union-int-double.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/union-int-double.schema/default/TopLevel.ts
index 11cffd8..7efeb22 100644
--- a/base/schema-typescript-zod/test/inputs/schema/union-int-double.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/union-int-double.schema/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "value": z.union([z.number(), z.string()]),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/union-list.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/union-list.schema/default/TopLevel.ts
index f8a9519..aba6877 100644
--- a/base/schema-typescript-zod/test/inputs/schema/union-list.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/union-list.schema/default/TopLevel.ts
@@ -7,10 +7,10 @@ export type UnionListClass = {
 export const UnionListClassSchema: z.ZodType<UnionListClass> = z.lazy(() =>
     z.object({
         "next": z.union([UnionListClassSchema, z.number()]),
-    })
+    }).strict()
 );
 
 export const TopLevelSchema = z.object({
     "list": z.union([UnionListClassSchema, z.number()]),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/union.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/union.schema/default/TopLevel.ts
index ded6565..37768fe 100644
--- a/base/schema-typescript-zod/test/inputs/schema/union.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/union.schema/default/TopLevel.ts
@@ -5,7 +5,7 @@ export const TopLevelElementSchema = z.object({
     "one": z.number().int().optional(),
     "two": z.boolean(),
     "three": z.number().optional(),
-});
+}).passthrough();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/schema-typescript-zod/test/inputs/schema/uuid.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/uuid.schema/default/TopLevel.ts
index 0f56be9..322722d 100644
--- a/base/schema-typescript-zod/test/inputs/schema/uuid.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/uuid.schema/default/TopLevel.ts
@@ -13,5 +13,5 @@ export const TopLevelSchema = z.object({
     "one": z.string().uuid(),
     "optional": z.string().uuid().optional(),
     "unionWithEnum": z.union([UnionWithEnumEnumSchema, z.string().uuid()]),
-});
+}).passthrough();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/schema-typescript-zod/test/inputs/schema/vega-lite.schema/default/TopLevel.ts b/head/schema-typescript-zod/test/inputs/schema/vega-lite.schema/default/TopLevel.ts
index a7bc5c6..8df1b3f 100644
--- a/base/schema-typescript-zod/test/inputs/schema/vega-lite.schema/default/TopLevel.ts
+++ b/head/schema-typescript-zod/test/inputs/schema/vega-lite.schema/default/TopLevel.ts
@@ -597,7 +597,7 @@ export const SelectionSchema: z.ZodType<Selection> = z.lazy(() =>
         "not": z.union([SelectionSchema, z.string()]).optional(),
         "and": z.array(z.union([SelectionSchema, z.string()])).optional(),
         "or": z.array(z.union([SelectionSchema, z.string()])).optional(),
-    })
+    }).strict()
 );
 
 export type Predicate = {
@@ -622,7 +622,7 @@ export const PredicateSchema: z.ZodType<Predicate> = z.lazy(() =>
         "range": z.array(z.union([z.null(), DateTimeSchema, z.number()])).min(2).max(2).optional(),
         "oneOf": z.array(z.union([z.boolean(), DateTimeSchema, z.number(), z.string()])).optional(),
         "selection": z.union([SelectionSchema, z.string()]).optional(),
-    })
+    }).strict()
 );
 
 export type Spec = {
@@ -665,7 +665,7 @@ export const SpecSchema: z.ZodType<Spec> = z.lazy(() =>
         "repeat": RepeatSchema.optional(),
         "vconcat": z.array(SpecSchema).optional(),
         "hconcat": z.array(SpecSchema).optional(),
-    })
+    }).strict()
 );
 
 export type LayerSpec = {
@@ -698,14 +698,14 @@ export const LayerSpecSchema: z.ZodType<LayerSpec> = z.lazy(() =>
         "mark": z.union([MarkDefSchema, MarkSchema]).optional(),
         "projection": ProjectionSchema.optional(),
         "selection": z.record(z.string(), SelectionDefSchema).optional(),
-    })
+    }).strict()
 );
 
 export const AutoSizeParamsSchema = z.object({
     "contains": ContainsSchema.optional(),
     "resize": z.boolean().optional(),
     "type": AutosizeTypeSchema.optional(),
-});
+}).strict();
 export type AutoSizeParams = z.infer<typeof AutoSizeParamsSchema>;
 
 export const MarkConfigSchema = z.object({
@@ -739,7 +739,7 @@ export const MarkConfigSchema = z.object({
     "tension": z.number().min(0).max(1).optional(),
     "text": z.string().optional(),
     "theta": z.number().optional(),
-});
+}).strict();
 export type MarkConfig = z.infer<typeof MarkConfigSchema>;
 
 export const AxisConfigSchema = z.object({
@@ -782,7 +782,7 @@ export const AxisConfigSchema = z.object({
     "titlePadding": z.number().optional(),
     "titleX": z.number().optional(),
     "titleY": z.number().optional(),
-});
+}).strict();
 export type AxisConfig = z.infer<typeof AxisConfigSchema>;
 
 export const VgAxisConfigSchema = z.object({
@@ -824,7 +824,7 @@ export const VgAxisConfigSchema = z.object({
     "titlePadding": z.number().optional(),
     "titleX": z.number().optional(),
     "titleY": z.number().optional(),
-});
+}).strict();
 export type VgAxisConfig = z.infer<typeof VgAxisConfigSchema>;
 
 export const BarConfigSchema = z.object({
@@ -861,7 +861,7 @@ export const BarConfigSchema = z.object({
     "tension": z.number().min(0).max(1).optional(),
     "text": z.string().optional(),
     "theta": z.number().optional(),
-});
+}).strict();
 export type BarConfig = z.infer<typeof BarConfigSchema>;
 
 export const LegendConfigSchema = z.object({
@@ -901,7 +901,7 @@ export const LegendConfigSchema = z.object({
     "titleFontWeight": z.union([z.number(), z.string()]).optional(),
     "titleLimit": z.number().optional(),
     "titlePadding": z.number().optional(),
-});
+}).strict();
 export type LegendConfig = z.infer<typeof LegendConfigSchema>;
 
 export const PaddingClassSchema = z.object({
@@ -909,35 +909,28 @@ export const PaddingClassSchema = z.object({
     "left": z.number().optional(),
     "right": z.number().optional(),
     "top": z.number().optional(),
-});
+}).strict();
 export type PaddingClass = z.infer<typeof PaddingClassSchema>;
 
-export const ProjectionConfigSchema = z.object({
-    "center": z.array(z.number()).optional(),
-    "clipAngle": z.number().optional(),
-    "clipExtent": z.array(z.array(z.number())).optional(),
-    "coefficient": z.number().optional(),
-    "distance": z.number().optional(),
-    "fraction": z.number().optional(),
-    "lobes": z.number().optional(),
-    "parallel": z.number().optional(),
-    "precision": z.record(z.string(), z.union([z.number(), z.string()])).optional(),
-    "radius": z.number().optional(),
-    "ratio": z.number().optional(),
-    "rotate": z.array(z.number()).optional(),
-    "spacing": z.number().optional(),
-    "tilt": z.number().optional(),
-    "type": VgProjectionTypeSchema.optional(),
-});
-export type ProjectionConfig = z.infer<typeof ProjectionConfigSchema>;
+export const PurplePrecisionSchema = z.object({
+    "length": z.number(),
+}).catchall(z.string());
+export type PurplePrecision = z.infer<typeof PurplePrecisionSchema>;
 
-export const VgSchemeSchema = z.object({
+export const CategoryVgSchemeSchema = z.object({
+    "count": z.number().optional(),
+    "extent": z.array(z.number()).optional(),
+    "scheme": z.string(),
+}).strict();
+export type CategoryVgScheme = z.infer<typeof CategoryVgSchemeSchema>;
+
+export const RangeConfigValueVgSchemeSchema = z.object({
     "count": z.number().optional(),
     "extent": z.array(z.number()).optional(),
     "scheme": z.string().optional(),
     "step": z.number().optional(),
-});
-export type VgScheme = z.infer<typeof VgSchemeSchema>;
+}).strict();
+export type RangeConfigValueVgScheme = z.infer<typeof RangeConfigValueVgSchemeSchema>;
 
 export const ScaleConfigSchema = z.object({
     "bandPaddingInner": z.number().min(0).max(1).optional(),
@@ -959,7 +952,7 @@ export const ScaleConfigSchema = z.object({
     "round": z.boolean().optional(),
     "textXRangeStep": z.number().min(0).optional(),
     "useUnaggregatedDomain": z.boolean().optional(),
-});
+}).strict();
 export type ScaleConfig = z.infer<typeof ScaleConfigSchema>;
 
 export const BrushConfigSchema = z.object({
@@ -970,7 +963,7 @@ export const BrushConfigSchema = z.object({
     "strokeDashOffset": z.number().optional(),
     "strokeOpacity": z.number().optional(),
     "strokeWidth": z.number().optional(),
-});
+}).strict();
 export type BrushConfig = z.infer<typeof BrushConfigSchema>;
 
 export const MultiSelectionConfigSchema = z.object({
@@ -981,7 +974,7 @@ export const MultiSelectionConfigSchema = z.object({
     "on": z.any().optional(),
     "resolve": SelectionResolutionSchema.optional(),
     "toggle": z.union([z.boolean(), z.string()]).optional(),
-});
+}).strict();
 export type MultiSelectionConfig = z.infer<typeof MultiSelectionConfigSchema>;
 
 export const VgBindingSchema = z.object({
@@ -991,7 +984,7 @@ export const VgBindingSchema = z.object({
     "max": z.number().optional(),
     "min": z.number().optional(),
     "step": z.number().optional(),
-});
+}).strict();
 export type VgBinding = z.infer<typeof VgBindingSchema>;
 
 export const VgMarkConfigSchema = z.object({
@@ -1023,7 +1016,7 @@ export const VgMarkConfigSchema = z.object({
     "tension": z.number().min(0).max(1).optional(),
     "text": z.string().optional(),
     "theta": z.number().optional(),
-});
+}).strict();
 export type VgMarkConfig = z.infer<typeof VgMarkConfigSchema>;
 
 export const TextConfigSchema = z.object({
@@ -1058,7 +1051,7 @@ export const TextConfigSchema = z.object({
     "tension": z.number().min(0).max(1).optional(),
     "text": z.string().optional(),
     "theta": z.number().optional(),
-});
+}).strict();
 export type TextConfig = z.infer<typeof TextConfigSchema>;
 
 export const TickConfigSchema = z.object({
@@ -1094,7 +1087,7 @@ export const TickConfigSchema = z.object({
     "text": z.string().optional(),
     "theta": z.number().optional(),
     "thickness": z.number().min(0).optional(),
-});
+}).strict();
 export type TickConfig = z.infer<typeof TickConfigSchema>;
 
 export const VgTitleConfigSchema = z.object({
@@ -1108,7 +1101,7 @@ export const VgTitleConfigSchema = z.object({
     "limit": z.number().min(0).optional(),
     "offset": z.number().optional(),
     "orient": TitleOrientSchema.optional(),
-});
+}).strict();
 export type VgTitleConfig = z.infer<typeof VgTitleConfigSchema>;
 
 export const ViewConfigSchema = z.object({
@@ -1122,7 +1115,7 @@ export const ViewConfigSchema = z.object({
     "strokeOpacity": z.number().optional(),
     "strokeWidth": z.number().optional(),
     "width": z.number().optional(),
-});
+}).strict();
 export type ViewConfig = z.infer<typeof ViewConfigSchema>;
 
 export const DataFormatSchema = z.object({
@@ -1131,7 +1124,7 @@ export const DataFormatSchema = z.object({
     "property": z.string().optional(),
     "feature": z.string().optional(),
     "mesh": z.string().optional(),
-});
+}).strict();
 export type DataFormat = z.infer<typeof DataFormatSchema>;
 
 export const BinParamsSchema = z.object({
@@ -1143,14 +1136,14 @@ export const BinParamsSchema = z.object({
     "nice": z.boolean().optional(),
     "step": z.number().optional(),
     "steps": z.array(z.number()).min(1).optional(),
-});
+}).strict();
 export type BinParams = z.infer<typeof BinParamsSchema>;
 
 export const ConditionalValueDefSchema = z.object({
     "test": z.union([PredicateSchema, z.string()]).optional(),
     "value": z.union([z.boolean(), z.number(), z.string()]),
     "selection": z.union([SelectionSchema, z.string()]).optional(),
-});
+}).strict();
 export type ConditionalValueDef = z.infer<typeof ConditionalValueDefSchema>;
 
 export const DateTimeSchema = z.object({
@@ -1164,12 +1157,12 @@ export const DateTimeSchema = z.object({
     "seconds": z.number().min(0).max(59).optional(),
     "utc": z.boolean().optional(),
     "year": z.number().optional(),
-});
+}).strict();
 export type DateTime = z.infer<typeof DateTimeSchema>;
 
 export const RepeatRefSchema = z.object({
     "repeat": RepeatEnumSchema,
-});
+}).strict();
 export type RepeatRef = z.infer<typeof RepeatRefSchema>;
 
 export const LegendSchema = z.object({
@@ -1183,46 +1176,46 @@ export const LegendSchema = z.object({
     "type": LegendTypeSchema.optional(),
     "values": z.array(z.union([DateTimeSchema, z.number(), z.string()])).optional(),
     "zindex": z.number().min(0).optional(),
-});
+}).strict();
 export type Legend = z.infer<typeof LegendSchema>;
 
 export const DomainClassSchema = z.object({
     "field": z.string().optional(),
     "selection": z.string(),
     "encoding": z.string().optional(),
-});
+}).strict();
 export type DomainClass = z.infer<typeof DomainClassSchema>;
 
 export const InterpolateParamsSchema = z.object({
     "gamma": z.number().optional(),
     "type": InterpolateParamsTypeSchema,
-});
+}).strict();
 export type InterpolateParams = z.infer<typeof InterpolateParamsSchema>;
 
 export const NiceClassSchema = z.object({
     "interval": z.string(),
     "step": z.number(),
-});
+}).strict();
 export type NiceClass = z.infer<typeof NiceClassSchema>;
 
 export const SchemeParamsSchema = z.object({
     "extent": z.array(z.number()).optional(),
     "name": z.string(),
-});
+}).strict();
 export type SchemeParams = z.infer<typeof SchemeParamsSchema>;
 
 export const SortFieldSchema = z.object({
     "field": z.union([RepeatRefSchema, z.string()]).optional(),
     "op": AggregateOpSchema,
     "order": z.union([z.null(), SortEnumSchema]).optional(),
-});
+}).strict();
 export type SortField = z.infer<typeof SortFieldSchema>;
 
 export const HeaderSchema = z.object({
     "format": z.string().optional(),
     "labelAngle": z.number().min(-360).max(360).optional(),
     "title": z.union([z.null(), z.string()]).optional(),
-});
+}).strict();
 export type Header = z.infer<typeof HeaderSchema>;
 
 export const FieldDefSchema = z.object({
@@ -1231,7 +1224,7 @@ export const FieldDefSchema = z.object({
     "field": z.union([RepeatRefSchema, z.string()]).optional(),
     "timeUnit": TimeUnitSchema.optional(),
     "type": TypeSchema,
-});
+}).strict();
 export type FieldDef = z.infer<typeof FieldDefSchema>;
 
 export const ConditionalPredicateFieldDefClassSchema = z.object({
@@ -1243,7 +1236,7 @@ export const ConditionalPredicateFieldDefClassSchema = z.object({
     "field": z.union([RepeatRefSchema, z.string()]).optional(),
     "timeUnit": TimeUnitSchema.optional(),
     "type": TypeSchema.optional(),
-});
+}).strict();
 export type ConditionalPredicateFieldDefClass = z.infer<typeof ConditionalPredicateFieldDefClassSchema>;
 
 export const OrderFieldDefSchema = z.object({
@@ -1253,7 +1246,7 @@ export const OrderFieldDefSchema = z.object({
     "sort": z.union([z.null(), SortEnumSchema]).optional(),
     "timeUnit": TimeUnitSchema.optional(),
     "type": TypeSchema,
-});
+}).strict();
 export type OrderFieldDef = z.infer<typeof OrderFieldDefSchema>;
 
 export const ConditionalPredicateTextFieldDefClassSchema = z.object({
@@ -1266,7 +1259,7 @@ export const ConditionalPredicateTextFieldDefClassSchema = z.object({
     "format": z.string().optional(),
     "timeUnit": TimeUnitSchema.optional(),
     "type": TypeSchema.optional(),
-});
+}).strict();
 export type ConditionalPredicateTextFieldDefClass = z.infer<typeof ConditionalPredicateTextFieldDefClassSchema>;
 
 export const AxisSchema = z.object({
@@ -1292,7 +1285,7 @@ export const AxisSchema = z.object({
     "titlePadding": z.number().optional(),
     "values": z.array(z.union([DateTimeSchema, z.number()])).optional(),
     "zindex": z.number().min(0).optional(),
-});
+}).strict();
 export type Axis = z.infer<typeof AxisSchema>;
 
 export const X2ClassSchema = z.object({
@@ -1302,7 +1295,7 @@ export const X2ClassSchema = z.object({
     "timeUnit": TimeUnitSchema.optional(),
     "type": TypeSchema.optional(),
     "value": z.union([z.boolean(), z.number(), z.string()]).optional(),
-});
+}).strict();
 export type X2Class = z.infer<typeof X2ClassSchema>;
 
 export const MarkDefSchema = z.object({
@@ -1339,32 +1332,18 @@ export const MarkDefSchema = z.object({
     "text": z.string().optional(),
     "theta": z.number().optional(),
     "type": MarkSchema,
-});
+}).strict();
 export type MarkDef = z.infer<typeof MarkDefSchema>;
 
-export const ProjectionSchema = z.object({
-    "center": z.array(z.number()).optional(),
-    "clipAngle": z.number().optional(),
-    "clipExtent": z.array(z.array(z.number())).optional(),
-    "coefficient": z.number().optional(),
-    "distance": z.number().optional(),
-    "fraction": z.number().optional(),
-    "lobes": z.number().optional(),
-    "parallel": z.number().optional(),
-    "precision": z.record(z.string(), z.union([z.number(), z.string()])).optional(),
-    "radius": z.number().optional(),
-    "ratio": z.number().optional(),
-    "rotate": z.array(z.number()).optional(),
-    "spacing": z.number().optional(),
-    "tilt": z.number().optional(),
-    "type": VgProjectionTypeSchema.optional(),
-});
-export type Projection = z.infer<typeof ProjectionSchema>;
+export const FluffyPrecisionSchema = z.object({
+    "length": z.number(),
+}).catchall(z.string());
+export type FluffyPrecision = z.infer<typeof FluffyPrecisionSchema>;
 
 export const AxisResolveMapSchema = z.object({
     "x": ResolveModeSchema.optional(),
     "y": ResolveModeSchema.optional(),
-});
+}).strict();
 export type AxisResolveMap = z.infer<typeof AxisResolveMapSchema>;
 
 export const LegendResolveMapSchema = z.object({
@@ -1372,7 +1351,7 @@ export const LegendResolveMapSchema = z.object({
     "opacity": ResolveModeSchema.optional(),
     "shape": ResolveModeSchema.optional(),
     "size": ResolveModeSchema.optional(),
-});
+}).strict();
 export type LegendResolveMap = z.infer<typeof LegendResolveMapSchema>;
 
 export const ScaleResolveMapSchema = z.object({
@@ -1382,7 +1361,7 @@ export const ScaleResolveMapSchema = z.object({
     "size": ResolveModeSchema.optional(),
     "x": ResolveModeSchema.optional(),
     "y": ResolveModeSchema.optional(),
-});
+}).strict();
 export type ScaleResolveMap = z.infer<typeof ScaleResolveMapSchema>;
 
 export const SelectionDefSchema = z.object({
@@ -1398,7 +1377,7 @@ export const SelectionDefSchema = z.object({
     "mark": BrushConfigSchema.optional(),
     "translate": z.union([z.boolean(), z.string()]).optional(),
     "zoom": z.union([z.boolean(), z.string()]).optional(),
-});
+}).strict();
 export type SelectionDef = z.infer<typeof SelectionDefSchema>;
 
 export const TitleParamsSchema = z.object({
@@ -1407,22 +1386,51 @@ export const TitleParamsSchema = z.object({
     "orient": TitleOrientSchema.optional(),
     "style": z.union([z.array(z.string()), z.string()]).optional(),
     "text": z.string(),
-});
+}).strict();
 export type TitleParams = z.infer<typeof TitleParamsSchema>;
 
 export const AggregatedFieldDefSchema = z.object({
     "as": z.string(),
     "field": z.string(),
     "op": AggregateOpSchema,
-});
+}).strict();
 export type AggregatedFieldDef = z.infer<typeof AggregatedFieldDefSchema>;
 
 export const RepeatSchema = z.object({
     "column": z.array(z.string()).optional(),
     "row": z.array(z.string()).optional(),
-});
+}).strict();
 export type Repeat = z.infer<typeof RepeatSchema>;
 
+export const ProjectionConfigSchema = z.object({
+    "center": z.array(z.number()).optional(),
+    "clipAngle": z.number().optional(),
+    "clipExtent": z.array(z.array(z.number())).optional(),
+    "coefficient": z.number().optional(),
+    "distance": z.number().optional(),
+    "fraction": z.number().optional(),
+    "lobes": z.number().optional(),
+    "parallel": z.number().optional(),
+    "precision": PurplePrecisionSchema.optional(),
+    "radius": z.number().optional(),
+    "ratio": z.number().optional(),
+    "rotate": z.array(z.number()).optional(),
+    "spacing": z.number().optional(),
+    "tilt": z.number().optional(),
+    "type": VgProjectionTypeSchema.optional(),
+}).strict();
+export type ProjectionConfig = z.infer<typeof ProjectionConfigSchema>;
+
+export const RangeConfigSchema = z.object({
+    "category": z.union([z.array(z.string()), CategoryVgSchemeSchema]).optional(),
+    "diverging": z.union([z.array(z.string()), CategoryVgSchemeSchema]).optional(),
+    "heatmap": z.union([z.array(z.string()), CategoryVgSchemeSchema]).optional(),
+    "ordinal": z.union([z.array(z.string()), CategoryVgSchemeSchema]).optional(),
+    "ramp": z.union([z.array(z.string()), CategoryVgSchemeSchema]).optional(),
+    "symbol": z.array(z.string()).optional(),
+}).catchall(z.union([z.array(z.union([z.number(), z.string()])), RangeConfigValueVgSchemeSchema]));
+export type RangeConfig = z.infer<typeof RangeConfigSchema>;
+
 export const IntervalSelectionConfigSchema = z.object({
     "bind": BindEnumSchema.optional(),
     "empty": EmptySchema.optional(),
@@ -1433,7 +1441,7 @@ export const IntervalSelectionConfigSchema = z.object({
     "resolve": SelectionResolutionSchema.optional(),
     "translate": z.union([z.boolean(), z.string()]).optional(),
     "zoom": z.union([z.boolean(), z.string()]).optional(),
-});
+}).strict();
 export type IntervalSelectionConfig = z.infer<typeof IntervalSelectionConfigSchema>;
 
 export const SingleSelectionConfigSchema = z.object({
@@ -1444,7 +1452,7 @@ export const SingleSelectionConfigSchema = z.object({
     "nearest": z.boolean().optional(),
     "on": z.any().optional(),
     "resolve": SelectionResolutionSchema.optional(),
-});
+}).strict();
 export type SingleSelectionConfig = z.infer<typeof SingleSelectionConfigSchema>;
 
 export const DataSchema = z.object({
@@ -1452,7 +1460,7 @@ export const DataSchema = z.object({
     "url": z.string().optional(),
     "values": z.union([z.array(z.union([z.boolean(), z.number(), z.record(z.string(), z.any()), z.string()])), z.record(z.string(), z.any()), z.string()]).optional(),
     "name": z.string().optional(),
-});
+}).strict();
 export type Data = z.infer<typeof DataSchema>;
 
 export const ScaleSchema = z.object({
@@ -1471,7 +1479,7 @@ export const ScaleSchema = z.object({
     "scheme": z.union([SchemeParamsSchema, z.string()]).optional(),
     "type": ScaleTypeSchema.optional(),
     "zero": z.boolean().optional(),
-});
+}).strict();
 export type Scale = z.infer<typeof ScaleSchema>;
 
 export const FacetFieldDefSchema = z.object({
@@ -1482,7 +1490,7 @@ export const FacetFieldDefSchema = z.object({
     "sort": z.union([z.null(), SortEnumSchema]).optional(),
     "timeUnit": TimeUnitSchema.optional(),
     "type": TypeSchema,
-});
+}).strict();
 export type FacetFieldDef = z.infer<typeof FacetFieldDefSchema>;
 
 export const DefWithConditionSchema = z.object({
@@ -1493,7 +1501,7 @@ export const DefWithConditionSchema = z.object({
     "timeUnit": TimeUnitSchema.optional(),
     "type": TypeSchema.optional(),
     "value": z.union([z.boolean(), z.number(), z.string()]).optional(),
-});
+}).strict();
 export type DefWithCondition = z.infer<typeof DefWithConditionSchema>;
 
 export const TextDefWithConditionSchema = z.object({
@@ -1505,7 +1513,7 @@ export const TextDefWithConditionSchema = z.object({
     "timeUnit": TimeUnitSchema.optional(),
     "type": TypeSchema.optional(),
     "value": z.union([z.boolean(), z.number(), z.string()]).optional(),
-});
+}).strict();
 export type TextDefWithCondition = z.infer<typeof TextDefWithConditionSchema>;
 
 export const XClassSchema = z.object({
@@ -1519,34 +1527,53 @@ export const XClassSchema = z.object({
     "timeUnit": TimeUnitSchema.optional(),
     "type": TypeSchema.optional(),
     "value": z.union([z.boolean(), z.number(), z.string()]).optional(),
-});
+}).strict();
 export type XClass = z.infer<typeof XClassSchema>;
 
 export const FacetMappingSchema = z.object({
     "column": FacetFieldDefSchema.optional(),
     "row": FacetFieldDefSchema.optional(),
-});
+}).strict();
 export type FacetMapping = z.infer<typeof FacetMappingSchema>;
 
+export const ProjectionSchema = z.object({
+    "center": z.array(z.number()).optional(),
+    "clipAngle": z.number().optional(),
+    "clipExtent": z.array(z.array(z.number())).optional(),
+    "coefficient": z.number().optional(),
+    "distance": z.number().optional(),
+    "fraction": z.number().optional(),
+    "lobes": z.number().optional(),
+    "parallel": z.number().optional(),
+    "precision": FluffyPrecisionSchema.optional(),
+    "radius": z.number().optional(),
+    "ratio": z.number().optional(),
+    "rotate": z.array(z.number()).optional(),
+    "spacing": z.number().optional(),
+    "tilt": z.number().optional(),
+    "type": VgProjectionTypeSchema.optional(),
+}).strict();
+export type Projection = z.infer<typeof ProjectionSchema>;
+
 export const ResolveSchema = z.object({
     "axis": AxisResolveMapSchema.optional(),
     "legend": LegendResolveMapSchema.optional(),
     "scale": ScaleResolveMapSchema.optional(),
-});
+}).strict();
 export type Resolve = z.infer<typeof ResolveSchema>;
 
 export const LookupDataSchema = z.object({
     "data": DataSchema,
     "fields": z.array(z.string()).optional(),
     "key": z.string(),
-});
+}).strict();
 export type LookupData = z.infer<typeof LookupDataSchema>;
 
 export const SelectionConfigSchema = z.object({
     "interval": IntervalSelectionConfigSchema.optional(),
     "multi": MultiSelectionConfigSchema.optional(),
     "single": SingleSelectionConfigSchema.optional(),
-});
+}).strict();
 export type SelectionConfig = z.infer<typeof SelectionConfigSchema>;
 
 export const ConditionalPredicateMarkPropFieldDefClassSchema = z.object({
@@ -1561,7 +1588,7 @@ export const ConditionalPredicateMarkPropFieldDefClassSchema = z.object({
     "sort": z.union([z.null(), SortFieldSchema, SortEnumSchema]).optional(),
     "timeUnit": TimeUnitSchema.optional(),
     "type": TypeSchema.optional(),
-});
+}).strict();
 export type ConditionalPredicateMarkPropFieldDefClass = z.infer<typeof ConditionalPredicateMarkPropFieldDefClassSchema>;
 
 export const TransformSchema = z.object({
@@ -1576,7 +1603,7 @@ export const TransformSchema = z.object({
     "timeUnit": TimeUnitSchema.optional(),
     "aggregate": z.array(AggregatedFieldDefSchema).optional(),
     "groupby": z.array(z.string()).optional(),
-});
+}).strict();
 export type Transform = z.infer<typeof TransformSchema>;
 
 export const ConfigSchema = z.object({
@@ -1604,7 +1631,7 @@ export const ConfigSchema = z.object({
     "padding": z.union([PaddingClassSchema, z.number()]).optional(),
     "point": MarkConfigSchema.optional(),
     "projection": ProjectionConfigSchema.optional(),
-    "range": z.record(z.string(), z.union([z.array(z.union([z.number(), z.string()])), VgSchemeSchema])).optional(),
+    "range": RangeConfigSchema.optional(),
     "rect": MarkConfigSchema.optional(),
     "rule": MarkConfigSchema.optional(),
     "scale": ScaleConfigSchema.optional(),
@@ -1617,7 +1644,7 @@ export const ConfigSchema = z.object({
     "timeFormat": z.string().optional(),
     "title": VgTitleConfigSchema.optional(),
     "view": ViewConfigSchema.optional(),
-});
+}).strict();
 export type Config = z.infer<typeof ConfigSchema>;
 
 export const MarkPropDefWithConditionSchema = z.object({
@@ -1631,7 +1658,7 @@ export const MarkPropDefWithConditionSchema = z.object({
     "timeUnit": TimeUnitSchema.optional(),
     "type": TypeSchema.optional(),
     "value": z.union([z.boolean(), z.number(), z.string()]).optional(),
-});
+}).strict();
 export type MarkPropDefWithCondition = z.infer<typeof MarkPropDefWithConditionSchema>;
 
 export const EncodingSchema = z.object({
@@ -1648,7 +1675,7 @@ export const EncodingSchema = z.object({
     "x2": X2ClassSchema.optional(),
     "y": XClassSchema.optional(),
     "y2": X2ClassSchema.optional(),
-});
+}).strict();
 export type Encoding = z.infer<typeof EncodingSchema>;
 
 export const EncodingWithFacetSchema = z.object({
@@ -1667,7 +1694,7 @@ export const EncodingWithFacetSchema = z.object({
     "x2": X2ClassSchema.optional(),
     "y": XClassSchema.optional(),
     "y2": X2ClassSchema.optional(),
-});
+}).strict();
 export type EncodingWithFacet = z.infer<typeof EncodingWithFacetSchema>;
 
 export const TopLevelSchema = z.object({
@@ -1694,5 +1721,5 @@ export const TopLevelSchema = z.object({
     "repeat": RepeatSchema.optional(),
     "vconcat": z.array(SpecSchema).optional(),
     "hconcat": z.array(SpecSchema).optional(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/00c36.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/00c36.json/default/TopLevel.ts
index 74b2d3a..3496108 100644
--- a/base/typescript-zod/test/inputs/json/misc/00c36.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/00c36.json/default/TopLevel.ts
@@ -17,7 +17,7 @@ export type Value = z.infer<typeof ValueSchema>;
 export const CountrySchema = z.object({
     "id": IdSchema,
     "value": ValueSchema,
-});
+}).strict();
 export type Country = z.infer<typeof CountrySchema>;
 
 export const FluffyTopLevelSchema = z.object({
@@ -25,7 +25,7 @@ export const FluffyTopLevelSchema = z.object({
     "pages": z.number().int(),
     "per_page": z.string().regex(/^-?\d+$/),
     "total": z.number().int(),
-});
+}).strict();
 export type FluffyTopLevel = z.infer<typeof FluffyTopLevelSchema>;
 
 export const PurpleTopLevelSchema = z.object({
@@ -34,7 +34,7 @@ export const PurpleTopLevelSchema = z.object({
     "decimal": z.string().regex(/^-?\d+$/),
     "indicator": CountrySchema,
     "value": z.string(),
-});
+}).strict();
 export type PurpleTopLevel = z.infer<typeof PurpleTopLevelSchema>;
 
 export const TopLevelSchema = z.array(z.union([z.array(PurpleTopLevelSchema), FluffyTopLevelSchema]));
diff --git a/base/typescript-zod/test/inputs/json/misc/00ec5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/00ec5.json/default/TopLevel.ts
index 7634f29..2f33962 100644
--- a/base/typescript-zod/test/inputs/json/misc/00ec5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/00ec5.json/default/TopLevel.ts
@@ -9,14 +9,14 @@ export type Type = z.infer<typeof TypeSchema>;
 export const PropertySchema = z.object({
     "description": z.string(),
     "type": TypeSchema,
-});
+}).strict();
 export type Property = z.infer<typeof PropertySchema>;
 
 export const InfoSchema = z.object({
     "description": z.string(),
     "title": z.string(),
     "version": z.string(),
-});
+}).strict();
 export type Info = z.infer<typeof InfoSchema>;
 
 export const ParameterSchema = z.object({
@@ -26,33 +26,33 @@ export const ParameterSchema = z.object({
     "name": z.string(),
     "required": z.boolean(),
     "type": TypeSchema,
-});
+}).strict();
 export type Parameter = z.infer<typeof ParameterSchema>;
 
 export const SchemaSchema = z.object({
     "$ref": z.string(),
-});
+}).strict();
 export type Schema = z.infer<typeof SchemaSchema>;
 
 export const ProviderSchema = z.object({
     "properties": z.record(z.string(), PropertySchema),
-});
+}).strict();
 export type Provider = z.infer<typeof ProviderSchema>;
 
 export const The200Schema = z.object({
     "description": z.string(),
     "schema": SchemaSchema,
-});
+}).strict();
 export type The200 = z.infer<typeof The200Schema>;
 
 export const DefinitionsSchema = z.object({
     "Provider": ProviderSchema,
-});
+}).strict();
 export type Definitions = z.infer<typeof DefinitionsSchema>;
 
 export const ResponsesSchema = z.object({
     "200": The200Schema,
-});
+}).strict();
 export type Responses = z.infer<typeof ResponsesSchema>;
 
 export const GetSchema = z.object({
@@ -61,17 +61,17 @@ export const GetSchema = z.object({
     "responses": ResponsesSchema,
     "summary": z.string(),
     "tags": z.array(z.string()),
-});
+}).strict();
 export type Get = z.infer<typeof GetSchema>;
 
 export const BusinessServiceProvidersSearchSchema = z.object({
     "get": GetSchema,
-});
+}).strict();
 export type BusinessServiceProvidersSearch = z.infer<typeof BusinessServiceProvidersSearchSchema>;
 
 export const PathsSchema = z.object({
     "/business_service_providers/search": BusinessServiceProvidersSearchSchema,
-});
+}).strict();
 export type Paths = z.infer<typeof PathsSchema>;
 
 export const TopLevelSchema = z.object({
@@ -83,5 +83,5 @@ export const TopLevelSchema = z.object({
     "produces": z.array(z.string()),
     "schemes": z.array(z.string()),
     "swagger": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/010b1.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/010b1.json/default/TopLevel.ts
index b8a003b..f51fac7 100644
--- a/base/typescript-zod/test/inputs/json/misc/010b1.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/010b1.json/default/TopLevel.ts
@@ -13,7 +13,7 @@ export const TopLevelElementSchema = z.object({
     "males": z.number().int(),
     "total": z.number().int(),
     "year": z.number().int(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/016af.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/016af.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/016af.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/016af.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/033b1.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/033b1.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/033b1.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/033b1.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/050b0.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/050b0.json/default/TopLevel.ts
index 3c4cc2b..dd1b140 100644
--- a/base/typescript-zod/test/inputs/json/misc/050b0.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/050b0.json/default/TopLevel.ts
@@ -44,26 +44,26 @@ export type Title = z.infer<typeof TitleSchema>;
 export const IdentifierSchema = z.object({
     "identifier": z.string(),
     "scheme": SchemeSchema,
-});
+}).strict();
 export type Identifier = z.infer<typeof IdentifierSchema>;
 
 export const LinkSchema = z.object({
     "note": NoteSchema,
     "url": z.string(),
-});
+}).strict();
 export type Link = z.infer<typeof LinkSchema>;
 
 export const OtherNameSchema = z.object({
     "name": z.string(),
     "note": z.union([z.null(), z.string()]),
-});
+}).strict();
 export type OtherName = z.infer<typeof OtherNameSchema>;
 
 export const TextSchema = z.object({
     "media_type": MediaTypeSchema,
     "title": TitleSchema,
     "url": z.string(),
-});
+}).strict();
 export type Text = z.infer<typeof TextSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -75,7 +75,7 @@ export const TopLevelElementSchema = z.object({
     "other_names": z.array(OtherNameSchema),
     "superseded_by": z.union([z.null(), z.string()]),
     "text": z.array(TextSchema),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/06bee.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/06bee.json/default/TopLevel.ts
index 5bbfe67..2c38eae 100644
--- a/base/typescript-zod/test/inputs/json/misc/06bee.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/06bee.json/default/TopLevel.ts
@@ -37,20 +37,20 @@ export type Title = z.infer<typeof TitleSchema>;
 export const IdentifierSchema = z.object({
     "identifier": z.string(),
     "scheme": SchemeSchema,
-});
+}).strict();
 export type Identifier = z.infer<typeof IdentifierSchema>;
 
 export const LinkSchema = z.object({
     "note": NoteSchema,
     "url": z.string(),
-});
+}).strict();
 export type Link = z.infer<typeof LinkSchema>;
 
 export const TextSchema = z.object({
     "media_type": MediaTypeSchema,
     "title": TitleSchema,
     "url": z.string(),
-});
+}).strict();
 export type Text = z.infer<typeof TextSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -62,7 +62,7 @@ export const TopLevelElementSchema = z.object({
     "other_names": z.array(z.any()),
     "superseded_by": z.null(),
     "text": z.array(TextSchema),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/07540.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/07540.json/default/TopLevel.ts
index 78722a8..fd3f159 100644
--- a/base/typescript-zod/test/inputs/json/misc/07540.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/07540.json/default/TopLevel.ts
@@ -2,10 +2,10 @@ import * as z from "zod";
 
 
 export const CookiesSchema = z.object({
-});
+}).strict();
 export type Cookies = z.infer<typeof CookiesSchema>;
 
 export const TopLevelSchema = z.object({
     "cookies": CookiesSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/0779f.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/0779f.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/0779f.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/0779f.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/07c75.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/07c75.json/default/TopLevel.ts
index 6514bef..a1cdeac 100644
--- a/base/typescript-zod/test/inputs/json/misc/07c75.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/07c75.json/default/TopLevel.ts
@@ -4,20 +4,20 @@ import * as z from "zod";
 export const IdentifierSchema = z.object({
     "identifier": z.string(),
     "scheme": z.string(),
-});
+}).strict();
 export type Identifier = z.infer<typeof IdentifierSchema>;
 
 export const LinkSchema = z.object({
     "note": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Link = z.infer<typeof LinkSchema>;
 
 export const TextSchema = z.object({
     "media_type": z.string(),
     "title": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Text = z.infer<typeof TextSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -29,7 +29,7 @@ export const TopLevelElementSchema = z.object({
     "other_names": z.array(z.any()),
     "superseded_by": z.null(),
     "text": z.array(TextSchema),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/09f54.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/09f54.json/default/TopLevel.ts
index b71dac0..cfc3dbb 100644
--- a/base/typescript-zod/test/inputs/json/misc/09f54.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/09f54.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const DatumSchema = z.object({
     "anomaly": z.string(),
     "value": z.string(),
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const DescriptionSchema = z.object({
@@ -12,11 +12,11 @@ export const DescriptionSchema = z.object({
     "missing": z.number().int(),
     "title": z.string(),
     "units": z.string(),
-});
+}).strict();
 export type Description = z.infer<typeof DescriptionSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.record(z.string(), DatumSchema),
     "description": DescriptionSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/0a358.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/0a358.json/default/TopLevel.ts
index 4fb2e4f..8751a55 100644
--- a/base/typescript-zod/test/inputs/json/misc/0a358.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/0a358.json/default/TopLevel.ts
@@ -2,7 +2,7 @@ import * as z from "zod";
 
 
 export const FacetsSchema = z.object({
-});
+}).strict();
 export type Facets = z.infer<typeof FacetsSchema>;
 
 export const ResultSchema = z.object({
@@ -12,7 +12,7 @@ export const ResultSchema = z.object({
     "name": z.string(),
     "updated_at": z.coerce.date(),
     "uri": z.string(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
@@ -23,5 +23,5 @@ export const TopLevelSchema = z.object({
     "offset": z.number().int(),
     "previous": z.boolean(),
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/0a91a.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/0a91a.json/default/TopLevel.ts
index 9acc770..33df661 100644
--- a/base/typescript-zod/test/inputs/json/misc/0a91a.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/0a91a.json/default/TopLevel.ts
@@ -17,13 +17,13 @@ export const ActorSchema = z.object({
     "id": z.number().int(),
     "login": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Actor = z.infer<typeof ActorSchema>;
 
 export const AuthorSchema = z.object({
     "email": z.string(),
     "name": z.string(),
-});
+}).strict();
 export type Author = z.infer<typeof AuthorSchema>;
 
 export const MergedBySchema = z.object({
@@ -44,19 +44,19 @@ export const MergedBySchema = z.object({
     "subscriptions_url": z.string(),
     "type": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type MergedBy = z.infer<typeof MergedBySchema>;
 
 export const CommentsSchema = z.object({
     "href": z.string(),
-});
+}).strict();
 export type Comments = z.infer<typeof CommentsSchema>;
 
 export const TopLevelRepoSchema = z.object({
     "id": z.number().int(),
     "name": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type TopLevelRepo = z.infer<typeof TopLevelRepoSchema>;
 
 export const CommitSchema = z.object({
@@ -65,7 +65,7 @@ export const CommitSchema = z.object({
     "message": z.string(),
     "sha": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Commit = z.infer<typeof CommitSchema>;
 
 export const BaseRepoSchema = z.object({
@@ -138,7 +138,7 @@ export const BaseRepoSchema = z.object({
     "url": z.string(),
     "watchers": z.number().int(),
     "watchers_count": z.number().int(),
-});
+}).strict();
 export type BaseRepo = z.infer<typeof BaseRepoSchema>;
 
 export const LinksSchema = z.object({
@@ -150,7 +150,7 @@ export const LinksSchema = z.object({
     "review_comments": CommentsSchema,
     "self": CommentsSchema,
     "statuses": CommentsSchema,
-});
+}).strict();
 export type Links = z.infer<typeof LinksSchema>;
 
 export const BaseSchema = z.object({
@@ -159,7 +159,7 @@ export const BaseSchema = z.object({
     "repo": BaseRepoSchema,
     "sha": z.string(),
     "user": MergedBySchema,
-});
+}).strict();
 export type Base = z.infer<typeof BaseSchema>;
 
 export const PullRequestSchema = z.object({
@@ -204,7 +204,7 @@ export const PullRequestSchema = z.object({
     "updated_at": z.coerce.date(),
     "url": z.string(),
     "user": MergedBySchema,
-});
+}).strict();
 export type PullRequest = z.infer<typeof PullRequestSchema>;
 
 export const PayloadSchema = z.object({
@@ -222,7 +222,7 @@ export const PayloadSchema = z.object({
     "ref": z.string().optional(),
     "ref_type": z.string().optional(),
     "size": z.number().int().optional(),
-});
+}).strict();
 export type Payload = z.infer<typeof PayloadSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -234,7 +234,7 @@ export const TopLevelElementSchema = z.object({
     "public": z.boolean(),
     "repo": TopLevelRepoSchema,
     "type": TypeSchema,
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/0b91a.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/0b91a.json/default/TopLevel.ts
index 7ec1861..63cfa5a 100644
--- a/base/typescript-zod/test/inputs/json/misc/0b91a.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/0b91a.json/default/TopLevel.ts
@@ -4,27 +4,27 @@ import * as z from "zod";
 export const ResponseInfoSchema = z.object({
     "developerMessage": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type ResponseInfo = z.infer<typeof ResponseInfoSchema>;
 
 export const ResultsetSchema = z.object({
     "count": z.number().int(),
     "page": z.number().int(),
     "pagesize": z.number().int(),
-});
+}).strict();
 export type Resultset = z.infer<typeof ResultsetSchema>;
 
 export const ComponentSchema = z.object({
     "name": z.string(),
     "uuid": z.string().uuid(),
-});
+}).strict();
 export type Component = z.infer<typeof ComponentSchema>;
 
 export const MetadataSchema = z.object({
     "executionTime": z.number(),
     "responseInfo": ResponseInfoSchema,
     "resultset": ResultsetSchema,
-});
+}).strict();
 export type Metadata = z.infer<typeof MetadataSchema>;
 
 export const ResultSchema = z.object({
@@ -42,11 +42,11 @@ export const ResultSchema = z.object({
     "url": z.string(),
     "uuid": z.string().uuid(),
     "vuuid": z.string().uuid(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
     "metadata": MetadataSchema,
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/0cffa.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/0cffa.json/default/TopLevel.ts
index 02bca10..2745c93 100644
--- a/base/typescript-zod/test/inputs/json/misc/0cffa.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/0cffa.json/default/TopLevel.ts
@@ -27,7 +27,7 @@ export const The480_WStillSchema = z.object({
     "size": z.string().regex(/^-?\d+$/).optional(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type The480_WStill = z.infer<typeof The480_WStillSchema>;
 
 export const DownsizedSmallSchema = z.object({
@@ -35,7 +35,7 @@ export const DownsizedSmallSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type DownsizedSmall = z.infer<typeof DownsizedSmallSchema>;
 
 export const FixedHeightSchema = z.object({
@@ -49,13 +49,13 @@ export const FixedHeightSchema = z.object({
     "webp": z.string(),
     "webp_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type FixedHeight = z.infer<typeof FixedHeightSchema>;
 
 export const LoopingSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Looping = z.infer<typeof LoopingSchema>;
 
 export const UserSchema = z.object({
@@ -65,21 +65,21 @@ export const UserSchema = z.object({
     "profile_url": z.string(),
     "twitter": z.string(),
     "username": UsernameSchema,
-});
+}).strict();
 export type User = z.infer<typeof UserSchema>;
 
 export const MetaSchema = z.object({
     "msg": z.string(),
     "response_id": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const PaginationSchema = z.object({
     "count": z.number().int(),
     "offset": z.number().int(),
     "total_count": z.number().int(),
-});
+}).strict();
 export type Pagination = z.infer<typeof PaginationSchema>;
 
 export const ImagesSchema = z.object({
@@ -106,7 +106,7 @@ export const ImagesSchema = z.object({
     "preview_gif": The480_WStillSchema,
     "preview_webp": The480_WStillSchema,
     "480w_still": The480_WStillSchema.optional(),
-});
+}).strict();
 export type Images = z.infer<typeof ImagesSchema>;
 
 export const DatumSchema = z.object({
@@ -128,12 +128,12 @@ export const DatumSchema = z.object({
     "url": z.string(),
     "user": UserSchema.optional(),
     "username": UsernameSchema,
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(DatumSchema),
     "meta": MetaSchema,
     "pagination": PaginationSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/0e0c2.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/0e0c2.json/default/TopLevel.ts
index adb9482..203cbdd 100644
--- a/base/typescript-zod/test/inputs/json/misc/0e0c2.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/0e0c2.json/default/TopLevel.ts
@@ -26,7 +26,7 @@ export const CollectionSchema = z.object({
     "movies": z.array(z.number().int()),
     "name": z.string(),
     "slug": z.string(),
-});
+}).strict();
 export type Collection = z.infer<typeof CollectionSchema>;
 
 export const DetailSchema = z.object({
@@ -37,14 +37,14 @@ export const DetailSchema = z.object({
     "storyline": z.string(),
     "tagline": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Detail = z.infer<typeof DetailSchema>;
 
 export const FavMovieSchema = z.object({
     "follow": z.boolean(),
     "star": z.boolean(),
     "watched": z.boolean(),
-});
+}).strict();
 export type FavMovie = z.infer<typeof FavMovieSchema>;
 
 export const ImageSchema = z.object({
@@ -53,7 +53,7 @@ export const ImageSchema = z.object({
     "thumbnail": z.string(),
     "type": TypeSchema,
     "url": z.string(),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const VideoSchema = z.object({
@@ -61,14 +61,14 @@ export const VideoSchema = z.object({
     "language": ResultLanguageSchema,
     "source": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Video = z.infer<typeof VideoSchema>;
 
 export const VoteScoreSchema = z.object({
     "avg": z.number().int(),
     "score": z.number().int(),
     "total": z.number().int(),
-});
+}).strict();
 export type VoteScore = z.infer<typeof VoteScoreSchema>;
 
 export const ResultSchema = z.object({
@@ -87,7 +87,7 @@ export const ResultSchema = z.object({
     "videos": z.array(VideoSchema),
     "vote_score": VoteScoreSchema,
     "watches": z.number().int(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
@@ -95,5 +95,5 @@ export const TopLevelSchema = z.object({
     "next": z.string(),
     "previous": z.null(),
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/0fecf.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/0fecf.json/default/TopLevel.ts
index 980dbcb..031a805 100644
--- a/base/typescript-zod/test/inputs/json/misc/0fecf.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/0fecf.json/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "countries": z.array(z.string()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/10be4.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/10be4.json/default/TopLevel.ts
index 0254ea4..913fd15 100644
--- a/base/typescript-zod/test/inputs/json/misc/10be4.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/10be4.json/default/TopLevel.ts
@@ -55,26 +55,26 @@ export type Title = z.infer<typeof TitleSchema>;
 export const IdentifierSchema = z.object({
     "identifier": z.string(),
     "scheme": SchemeSchema,
-});
+}).strict();
 export type Identifier = z.infer<typeof IdentifierSchema>;
 
 export const LinkSchema = z.object({
     "note": NoteSchema,
     "url": z.string(),
-});
+}).strict();
 export type Link = z.infer<typeof LinkSchema>;
 
 export const OtherNameSchema = z.object({
     "name": z.string(),
     "note": z.union([z.null(), z.string()]),
-});
+}).strict();
 export type OtherName = z.infer<typeof OtherNameSchema>;
 
 export const TextSchema = z.object({
     "media_type": MediaTypeSchema,
     "title": TitleSchema,
     "url": z.string(),
-});
+}).strict();
 export type Text = z.infer<typeof TextSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -86,7 +86,7 @@ export const TopLevelElementSchema = z.object({
     "other_names": z.array(OtherNameSchema),
     "superseded_by": z.union([z.null(), z.string()]),
     "text": z.array(TextSchema),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/112b5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/112b5.json/default/TopLevel.ts
index d04617d..7cc1354 100644
--- a/base/typescript-zod/test/inputs/json/misc/112b5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/112b5.json/default/TopLevel.ts
@@ -2,7 +2,7 @@ import * as z from "zod";
 
 
 export const ArgsSchema = z.object({
-});
+}).strict();
 export type Args = z.infer<typeof ArgsSchema>;
 
 export const HeadersSchema = z.object({
@@ -10,7 +10,7 @@ export const HeadersSchema = z.object({
     "Connection": z.string(),
     "Host": z.string(),
     "User-Agent": z.string(),
-});
+}).strict();
 export type Headers = z.infer<typeof HeadersSchema>;
 
 export const TopLevelSchema = z.object({
@@ -18,5 +18,5 @@ export const TopLevelSchema = z.object({
     "headers": HeadersSchema,
     "origin": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/127a1.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/127a1.json/default/TopLevel.ts
index bf649e3..20b6283 100644
--- a/base/typescript-zod/test/inputs/json/misc/127a1.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/127a1.json/default/TopLevel.ts
@@ -26,7 +26,7 @@ export const The480_WStillSchema = z.object({
     "size": z.string().regex(/^-?\d+$/).optional(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type The480_WStill = z.infer<typeof The480_WStillSchema>;
 
 export const DownsizedSmallSchema = z.object({
@@ -34,7 +34,7 @@ export const DownsizedSmallSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type DownsizedSmall = z.infer<typeof DownsizedSmallSchema>;
 
 export const FixedHeightSchema = z.object({
@@ -48,13 +48,13 @@ export const FixedHeightSchema = z.object({
     "webp": z.string(),
     "webp_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type FixedHeight = z.infer<typeof FixedHeightSchema>;
 
 export const LoopingSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Looping = z.infer<typeof LoopingSchema>;
 
 export const UserSchema = z.object({
@@ -64,21 +64,21 @@ export const UserSchema = z.object({
     "profile_url": z.string(),
     "twitter": z.string().optional(),
     "username": UsernameSchema,
-});
+}).strict();
 export type User = z.infer<typeof UserSchema>;
 
 export const MetaSchema = z.object({
     "msg": z.string(),
     "response_id": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const PaginationSchema = z.object({
     "count": z.number().int(),
     "offset": z.number().int(),
     "total_count": z.number().int(),
-});
+}).strict();
 export type Pagination = z.infer<typeof PaginationSchema>;
 
 export const ImagesSchema = z.object({
@@ -105,7 +105,7 @@ export const ImagesSchema = z.object({
     "preview_gif": The480_WStillSchema,
     "preview_webp": The480_WStillSchema,
     "480w_still": The480_WStillSchema.optional(),
-});
+}).strict();
 export type Images = z.infer<typeof ImagesSchema>;
 
 export const DatumSchema = z.object({
@@ -127,12 +127,12 @@ export const DatumSchema = z.object({
     "url": z.string(),
     "user": UserSchema.optional(),
     "username": UsernameSchema,
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(DatumSchema),
     "meta": MetaSchema,
     "pagination": PaginationSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/13d8d.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/13d8d.json/default/TopLevel.ts
index ae5adec..2c90d14 100644
--- a/base/typescript-zod/test/inputs/json/misc/13d8d.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/13d8d.json/default/TopLevel.ts
@@ -4,20 +4,20 @@ import * as z from "zod";
 export const StreetSchema = z.object({
     "id": z.number().int(),
     "name": z.string(),
-});
+}).strict();
 export type Street = z.infer<typeof StreetSchema>;
 
 export const OutcomeStatusSchema = z.object({
     "category": z.string(),
     "date": z.string(),
-});
+}).strict();
 export type OutcomeStatus = z.infer<typeof OutcomeStatusSchema>;
 
 export const LocationSchema = z.object({
     "latitude": z.string(),
     "longitude": z.string(),
     "street": StreetSchema,
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -30,7 +30,7 @@ export const TopLevelElementSchema = z.object({
     "month": z.string(),
     "outcome_status": OutcomeStatusSchema,
     "persistent_id": z.string(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/14d38.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/14d38.json/default/TopLevel.ts
index 9b66a6d..2380760 100644
--- a/base/typescript-zod/test/inputs/json/misc/14d38.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/14d38.json/default/TopLevel.ts
@@ -6,10 +6,10 @@ export const HeadersSchema = z.object({
     "Connection": z.string(),
     "Host": z.string(),
     "User-Agent": z.string(),
-});
+}).strict();
 export type Headers = z.infer<typeof HeadersSchema>;
 
 export const TopLevelSchema = z.object({
     "headers": HeadersSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/167d6.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/167d6.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/167d6.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/167d6.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/16bc5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/16bc5.json/default/TopLevel.ts
index 82adaab..e046c65 100644
--- a/base/typescript-zod/test/inputs/json/misc/16bc5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/16bc5.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -12,7 +12,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -21,7 +21,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -29,7 +29,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -39,19 +39,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -59,14 +59,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -79,7 +79,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -96,12 +96,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -109,10 +109,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/176f1.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/176f1.json/default/TopLevel.ts
index 825d96e..5946d4d 100644
--- a/base/typescript-zod/test/inputs/json/misc/176f1.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/176f1.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const FootnoteSchema = z.object({
     "code": z.string().optional(),
     "text": z.string().optional(),
-});
+}).strict();
 export type Footnote = z.infer<typeof FootnoteSchema>;
 
 export const DatumSchema = z.object({
@@ -13,18 +13,18 @@ export const DatumSchema = z.object({
     "periodName": z.string(),
     "value": z.string(),
     "year": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const SeriesSchema = z.object({
     "data": z.array(DatumSchema),
     "seriesID": z.string(),
-});
+}).strict();
 export type Series = z.infer<typeof SeriesSchema>;
 
 export const ResultsSchema = z.object({
     "series": z.array(SeriesSchema),
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const TopLevelSchema = z.object({
@@ -32,5 +32,5 @@ export const TopLevelSchema = z.object({
     "responseTime": z.number().int(),
     "Results": ResultsSchema,
     "status": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/1a7f5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/1a7f5.json/default/TopLevel.ts
index b8a003b..f51fac7 100644
--- a/base/typescript-zod/test/inputs/json/misc/1a7f5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/1a7f5.json/default/TopLevel.ts
@@ -13,7 +13,7 @@ export const TopLevelElementSchema = z.object({
     "males": z.number().int(),
     "total": z.number().int(),
     "year": z.number().int(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/1b28c.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/1b28c.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/1b28c.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/1b28c.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/1b409.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/1b409.json/default/TopLevel.ts
index 39e2bf8..3c8f907 100644
--- a/base/typescript-zod/test/inputs/json/misc/1b409.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/1b409.json/default/TopLevel.ts
@@ -56,7 +56,7 @@ export const MetaSchema = z.object({
     "limit": z.number().int(),
     "offset": z.number().int(),
     "total_count": z.number().int(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const ExtraSchema = z.object({
@@ -65,7 +65,7 @@ export const ExtraSchema = z.object({
     "fax": z.union([z.null(), z.string()]).optional(),
     "office": z.string(),
     "rss_url": z.string().optional(),
-});
+}).strict();
 export type Extra = z.infer<typeof ExtraSchema>;
 
 export const PersonSchema = z.object({
@@ -87,7 +87,7 @@ export const PersonSchema = z.object({
     "sortname": z.string(),
     "twitterid": z.union([z.null(), z.string()]),
     "youtubeid": z.union([z.null(), z.string()]),
-});
+}).strict();
 export type Person = z.infer<typeof PersonSchema>;
 
 export const ObjectElementSchema = z.object({
@@ -112,11 +112,11 @@ export const ObjectElementSchema = z.object({
     "title": TitleSchema,
     "title_long": RoleTypeLabelSchema,
     "website": z.string(),
-});
+}).strict();
 export type ObjectElement = z.infer<typeof ObjectElementSchema>;
 
 export const TopLevelSchema = z.object({
     "meta": MetaSchema,
     "objects": z.array(ObjectElementSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/2465e.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/2465e.json/default/TopLevel.ts
index d58c1f7..869051c 100644
--- a/base/typescript-zod/test/inputs/json/misc/2465e.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/2465e.json/default/TopLevel.ts
@@ -4,14 +4,14 @@ import * as z from "zod";
 export const AnnotationsSchema = z.object({
     "description": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Annotations = z.infer<typeof AnnotationsSchema>;
 
 export const InfoSchema = z.object({
     "description": z.string(),
     "title": z.string(),
     "version": z.string(),
-});
+}).strict();
 export type Info = z.infer<typeof InfoSchema>;
 
 export const ParameterSchema = z.object({
@@ -21,12 +21,12 @@ export const ParameterSchema = z.object({
     "name": z.string(),
     "required": z.boolean(),
     "type": z.string(),
-});
+}).strict();
 export type Parameter = z.infer<typeof ParameterSchema>;
 
 export const SchemaSchema = z.object({
     "$ref": z.string(),
-});
+}).strict();
 export type Schema = z.infer<typeof SchemaSchema>;
 
 export const PropertiesSchema = z.object({
@@ -36,28 +36,28 @@ export const PropertiesSchema = z.object({
     "label": AnnotationsSchema,
     "sub_class_of": AnnotationsSchema,
     "type": AnnotationsSchema,
-});
+}).strict();
 export type Properties = z.infer<typeof PropertiesSchema>;
 
 export const The200Schema = z.object({
     "description": z.string(),
     "schema": SchemaSchema,
-});
+}).strict();
 export type The200 = z.infer<typeof The200Schema>;
 
 export const TaxonomySchema = z.object({
     "properties": PropertiesSchema,
-});
+}).strict();
 export type Taxonomy = z.infer<typeof TaxonomySchema>;
 
 export const ResponsesSchema = z.object({
     "200": The200Schema,
-});
+}).strict();
 export type Responses = z.infer<typeof ResponsesSchema>;
 
 export const DefinitionsSchema = z.object({
     "Taxonomy": TaxonomySchema,
-});
+}).strict();
 export type Definitions = z.infer<typeof DefinitionsSchema>;
 
 export const GetSchema = z.object({
@@ -66,17 +66,17 @@ export const GetSchema = z.object({
     "responses": ResponsesSchema,
     "summary": z.string(),
     "tags": z.array(z.string()),
-});
+}).strict();
 export type Get = z.infer<typeof GetSchema>;
 
 export const ItaTaxonomiesSearchSchema = z.object({
     "get": GetSchema,
-});
+}).strict();
 export type ItaTaxonomiesSearch = z.infer<typeof ItaTaxonomiesSearchSchema>;
 
 export const PathsSchema = z.object({
     "/ita_taxonomies/search": ItaTaxonomiesSearchSchema,
-});
+}).strict();
 export type Paths = z.infer<typeof PathsSchema>;
 
 export const TopLevelSchema = z.object({
@@ -88,5 +88,5 @@ export const TopLevelSchema = z.object({
     "produces": z.array(z.string()),
     "schemes": z.array(z.string()),
     "swagger": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/24f52.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/24f52.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/24f52.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/24f52.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/262f0.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/262f0.json/default/TopLevel.ts
index 9fe0479..0065993 100644
--- a/base/typescript-zod/test/inputs/json/misc/262f0.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/262f0.json/default/TopLevel.ts
@@ -11,7 +11,7 @@ export type Text = z.infer<typeof TextSchema>;
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -19,7 +19,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -28,7 +28,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -36,7 +36,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": TextSchema,
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -46,19 +46,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": TextSchema,
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -66,14 +66,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -86,7 +86,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -103,12 +103,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -116,10 +116,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/26b49.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/26b49.json/default/TopLevel.ts
index 982e53f..33a95cf 100644
--- a/base/typescript-zod/test/inputs/json/misc/26b49.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/26b49.json/default/TopLevel.ts
@@ -20,7 +20,7 @@ export const The480_WStillSchema = z.object({
     "size": z.string().regex(/^-?\d+$/).optional(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type The480_WStill = z.infer<typeof The480_WStillSchema>;
 
 export const DownsizedSmallSchema = z.object({
@@ -28,7 +28,7 @@ export const DownsizedSmallSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type DownsizedSmall = z.infer<typeof DownsizedSmallSchema>;
 
 export const FixedHeightSchema = z.object({
@@ -42,13 +42,13 @@ export const FixedHeightSchema = z.object({
     "webp": z.string(),
     "webp_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type FixedHeight = z.infer<typeof FixedHeightSchema>;
 
 export const LoopingSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Looping = z.infer<typeof LoopingSchema>;
 
 export const UserSchema = z.object({
@@ -58,21 +58,21 @@ export const UserSchema = z.object({
     "profile_url": z.string(),
     "twitter": z.string().optional(),
     "username": z.string(),
-});
+}).strict();
 export type User = z.infer<typeof UserSchema>;
 
 export const MetaSchema = z.object({
     "msg": z.string(),
     "response_id": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const PaginationSchema = z.object({
     "count": z.number().int(),
     "offset": z.number().int(),
     "total_count": z.number().int(),
-});
+}).strict();
 export type Pagination = z.infer<typeof PaginationSchema>;
 
 export const ImagesSchema = z.object({
@@ -100,7 +100,7 @@ export const ImagesSchema = z.object({
     "preview_gif": The480_WStillSchema,
     "preview_webp": The480_WStillSchema,
     "480w_still": The480_WStillSchema.optional(),
-});
+}).strict();
 export type Images = z.infer<typeof ImagesSchema>;
 
 export const DatumSchema = z.object({
@@ -122,12 +122,12 @@ export const DatumSchema = z.object({
     "url": z.string(),
     "user": UserSchema.optional(),
     "username": z.string(),
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(DatumSchema),
     "meta": MetaSchema,
     "pagination": PaginationSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/26c9c.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/26c9c.json/default/TopLevel.ts
index 75f3375..5abde0d 100644
--- a/base/typescript-zod/test/inputs/json/misc/26c9c.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/26c9c.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const TopSchema = z.object({
     "count": z.number().int(),
     "item": z.string(),
-});
+}).strict();
 export type Top = z.infer<typeof TopSchema>;
 
 export const FormatSchema = z.object({
@@ -12,14 +12,14 @@ export const FormatSchema = z.object({
     "noCommas": z.enum(["true", "false"]).optional(),
     "precisionStyle": z.string().optional(),
     "view": z.string().optional(),
-});
+}).strict();
 export type Format = z.infer<typeof FormatSchema>;
 
 export const GrantSchema = z.object({
     "flags": z.array(z.string()),
     "inherited": z.boolean(),
     "type": z.string(),
-});
+}).strict();
 export type Grant = z.infer<typeof GrantSchema>;
 
 export const AttachmentSchema = z.object({
@@ -27,25 +27,25 @@ export const AttachmentSchema = z.object({
     "blobId": z.string(),
     "filename": z.string(),
     "name": z.string(),
-});
+}).strict();
 export type Attachment = z.infer<typeof AttachmentSchema>;
 
 export const AdditionalResourcesSchema = z.object({
     "See Also ": z.string(),
     "See Also": z.string(),
-});
+}).strict();
 export type AdditionalResources = z.infer<typeof AdditionalResourcesSchema>;
 
 export const CommonCoreSchema = z.object({
     "Contact Email": z.string(),
     "Contact Name": z.string(),
     "Publisher": z.string(),
-});
+}).strict();
 export type CommonCore = z.infer<typeof CommonCoreSchema>;
 
 export const DatasetInformationSchema = z.object({
     "Agency": z.string(),
-});
+}).strict();
 export type DatasetInformation = z.infer<typeof DatasetInformationSchema>;
 
 export const DatasetSummarySchema = z.object({
@@ -58,23 +58,23 @@ export const DatasetSummarySchema = z.object({
     "Posting Frequency": z.string(),
     "Time Period": z.string(),
     "Units": z.string(),
-});
+}).strict();
 export type DatasetSummary = z.infer<typeof DatasetSummarySchema>;
 
 export const NotesSchema = z.object({
     "Notes": z.string(),
-});
+}).strict();
 export type Notes = z.infer<typeof NotesSchema>;
 
 export const OrderSchema = z.object({
     "ascending": z.boolean(),
     "columnFieldName": z.string(),
-});
+}).strict();
 export type Order = z.infer<typeof OrderSchema>;
 
 export const VisibleSchema = z.object({
     "table": z.boolean(),
-});
+}).strict();
 export type Visible = z.infer<typeof VisibleSchema>;
 
 export const OwnerSchema = z.object({
@@ -86,13 +86,13 @@ export const OwnerSchema = z.object({
     "rights": z.array(z.string()),
     "roleName": z.string(),
     "screenName": z.string(),
-});
+}).strict();
 export type Owner = z.infer<typeof OwnerSchema>;
 
 export const ExpressionSchema = z.object({
     "columnId": z.number().int(),
     "type": z.string(),
-});
+}).strict();
 export type Expression = z.infer<typeof ExpressionSchema>;
 
 export const CachedContentsSchema = z.object({
@@ -103,7 +103,7 @@ export const CachedContentsSchema = z.object({
     "smallest": z.string(),
     "sum": z.string().regex(/^-?\d+$/).optional(),
     "top": z.array(TopSchema),
-});
+}).strict();
 export type CachedContents = z.infer<typeof CachedContentsSchema>;
 
 export const CustomFieldsSchema = z.object({
@@ -112,23 +112,23 @@ export const CustomFieldsSchema = z.object({
     "Dataset Information": DatasetInformationSchema,
     "Dataset Summary": DatasetSummarySchema,
     "Notes": NotesSchema,
-});
+}).strict();
 export type CustomFields = z.infer<typeof CustomFieldsSchema>;
 
 export const JsonQuerySchema = z.object({
     "order": z.array(OrderSchema),
-});
+}).strict();
 export type JsonQuery = z.infer<typeof JsonQuerySchema>;
 
 export const RenderTypeConfigSchema = z.object({
     "visible": VisibleSchema,
-});
+}).strict();
 export type RenderTypeConfig = z.infer<typeof RenderTypeConfigSchema>;
 
 export const OrderBySchema = z.object({
     "ascending": z.boolean(),
     "expression": ExpressionSchema,
-});
+}).strict();
 export type OrderBy = z.infer<typeof OrderBySchema>;
 
 export const ColumnSchema = z.object({
@@ -143,7 +143,7 @@ export const ColumnSchema = z.object({
     "renderTypeName": z.string(),
     "tableColumnId": z.number().int().optional(),
     "width": z.number().int().optional(),
-});
+}).strict();
 export type Column = z.infer<typeof ColumnSchema>;
 
 export const MetadataSchema = z.object({
@@ -153,12 +153,12 @@ export const MetadataSchema = z.object({
     "jsonQuery": JsonQuerySchema,
     "rdfSubject": z.string().regex(/^-?\d+$/),
     "renderTypeConfig": RenderTypeConfigSchema,
-});
+}).strict();
 export type Metadata = z.infer<typeof MetadataSchema>;
 
 export const QuerySchema = z.object({
     "orderBys": z.array(OrderBySchema),
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const ViewSchema = z.object({
@@ -200,16 +200,16 @@ export const ViewSchema = z.object({
     "viewCount": z.number().int(),
     "viewLastModified": z.number().int(),
     "viewType": z.string(),
-});
+}).strict();
 export type View = z.infer<typeof ViewSchema>;
 
 export const MetaSchema = z.object({
     "view": ViewSchema,
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(z.array(z.union([z.null(), z.number().int(), z.string()]))),
     "meta": MetaSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/27332.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/27332.json/default/TopLevel.ts
index b0e40ec..23f1b9d 100644
--- a/base/typescript-zod/test/inputs/json/misc/27332.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/27332.json/default/TopLevel.ts
@@ -59,7 +59,7 @@ export const OembedSchema = z.object({
     "type": z.string(),
     "version": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Oembed = z.infer<typeof OembedSchema>;
 
 export const MediaEmbedSchema = z.object({
@@ -67,24 +67,24 @@ export const MediaEmbedSchema = z.object({
     "height": z.number().int().optional(),
     "scrolling": z.boolean().optional(),
     "width": z.number().int().optional(),
-});
+}).strict();
 export type MediaEmbed = z.infer<typeof MediaEmbedSchema>;
 
 export const SourceSchema = z.object({
     "height": z.number().int(),
     "url": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Source = z.infer<typeof SourceSchema>;
 
 export const VariantsSchema = z.object({
-});
+}).strict();
 export type Variants = z.infer<typeof VariantsSchema>;
 
 export const MediaSchema = z.object({
     "oembed": OembedSchema,
     "type": DomainSchema,
-});
+}).strict();
 export type Media = z.infer<typeof MediaSchema>;
 
 export const ImageSchema = z.object({
@@ -92,13 +92,13 @@ export const ImageSchema = z.object({
     "resolutions": z.array(SourceSchema),
     "source": SourceSchema,
     "variants": VariantsSchema,
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const PreviewSchema = z.object({
     "enabled": z.boolean(),
     "images": z.array(ImageSchema),
-});
+}).strict();
 export type Preview = z.infer<typeof PreviewSchema>;
 
 export const ChildDataSchema = z.object({
@@ -166,13 +166,13 @@ export const ChildDataSchema = z.object({
     "user_reports": z.array(z.any()),
     "view_count": z.null(),
     "visited": z.boolean(),
-});
+}).strict();
 export type ChildData = z.infer<typeof ChildDataSchema>;
 
 export const ChildSchema = z.object({
     "data": ChildDataSchema,
     "kind": KindSchema,
-});
+}).strict();
 export type Child = z.infer<typeof ChildSchema>;
 
 export const TopLevelDataSchema = z.object({
@@ -180,11 +180,11 @@ export const TopLevelDataSchema = z.object({
     "before": z.null(),
     "children": z.array(ChildSchema),
     "modhash": z.string(),
-});
+}).strict();
 export type TopLevelData = z.infer<typeof TopLevelDataSchema>;
 
 export const TopLevelSchema = z.object({
     "data": TopLevelDataSchema,
     "kind": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/29f47.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/29f47.json/default/TopLevel.ts
index 343504d..8fd08f4 100644
--- a/base/typescript-zod/test/inputs/json/misc/29f47.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/29f47.json/default/TopLevel.ts
@@ -51,26 +51,26 @@ export const KindSchema = z.enum([
 export type Kind = z.infer<typeof KindSchema>;
 
 export const MediaEmbedSchema = z.object({
-});
+}).strict();
 export type MediaEmbed = z.infer<typeof MediaEmbedSchema>;
 
 export const SourceSchema = z.object({
     "height": z.number().int(),
     "url": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Source = z.infer<typeof SourceSchema>;
 
 export const GifSchema = z.object({
     "resolutions": z.array(SourceSchema),
     "source": SourceSchema,
-});
+}).strict();
 export type Gif = z.infer<typeof GifSchema>;
 
 export const VariantsSchema = z.object({
     "gif": GifSchema.optional(),
     "mp4": GifSchema.optional(),
-});
+}).strict();
 export type Variants = z.infer<typeof VariantsSchema>;
 
 export const ImageSchema = z.object({
@@ -78,13 +78,13 @@ export const ImageSchema = z.object({
     "resolutions": z.array(SourceSchema),
     "source": SourceSchema,
     "variants": VariantsSchema,
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const PreviewSchema = z.object({
     "enabled": z.boolean(),
     "images": z.array(ImageSchema),
-});
+}).strict();
 export type Preview = z.infer<typeof PreviewSchema>;
 
 export const ChildDataSchema = z.object({
@@ -152,13 +152,13 @@ export const ChildDataSchema = z.object({
     "user_reports": z.array(z.any()),
     "view_count": z.null(),
     "visited": z.boolean(),
-});
+}).strict();
 export type ChildData = z.infer<typeof ChildDataSchema>;
 
 export const ChildSchema = z.object({
     "data": ChildDataSchema,
     "kind": KindSchema,
-});
+}).strict();
 export type Child = z.infer<typeof ChildSchema>;
 
 export const TopLevelDataSchema = z.object({
@@ -166,11 +166,11 @@ export const TopLevelDataSchema = z.object({
     "before": z.null(),
     "children": z.array(ChildSchema),
     "modhash": z.string(),
-});
+}).strict();
 export type TopLevelData = z.infer<typeof TopLevelDataSchema>;
 
 export const TopLevelSchema = z.object({
     "data": TopLevelDataSchema,
     "kind": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/2d4e2.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/2d4e2.json/default/TopLevel.ts
index 0deef1f..fbaad8d 100644
--- a/base/typescript-zod/test/inputs/json/misc/2d4e2.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/2d4e2.json/default/TopLevel.ts
@@ -82,7 +82,7 @@ export const MetaSchema = z.object({
     "limit": z.number().int(),
     "offset": z.number().int(),
     "total_count": z.number().int(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const ExtraSchema = z.object({
@@ -91,7 +91,7 @@ export const ExtraSchema = z.object({
     "fax": z.string().optional(),
     "office": z.string(),
     "rss_url": z.string().optional(),
-});
+}).strict();
 export type Extra = z.infer<typeof ExtraSchema>;
 
 export const PersonSchema = z.object({
@@ -113,7 +113,7 @@ export const PersonSchema = z.object({
     "sortname": z.string(),
     "twitterid": z.union([z.null(), z.string()]),
     "youtubeid": z.union([z.null(), z.string()]),
-});
+}).strict();
 export type Person = z.infer<typeof PersonSchema>;
 
 export const ObjectElementSchema = z.object({
@@ -140,11 +140,11 @@ export const ObjectElementSchema = z.object({
     "title": TitleSchema,
     "title_long": RoleTypeLabelSchema,
     "website": z.string(),
-});
+}).strict();
 export type ObjectElement = z.infer<typeof ObjectElementSchema>;
 
 export const TopLevelSchema = z.object({
     "meta": MetaSchema,
     "objects": z.array(ObjectElementSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/2df80.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/2df80.json/default/TopLevel.ts
index d2b62be..4005256 100644
--- a/base/typescript-zod/test/inputs/json/misc/2df80.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/2df80.json/default/TopLevel.ts
@@ -57,7 +57,7 @@ export type Value = z.infer<typeof ValueSchema>;
 export const AdminregionSchema = z.object({
     "id": IdSchema,
     "value": ValueSchema,
-});
+}).strict();
 export type Adminregion = z.infer<typeof AdminregionSchema>;
 
 export const FluffyTopLevelSchema = z.object({
@@ -65,7 +65,7 @@ export const FluffyTopLevelSchema = z.object({
     "pages": z.number().int(),
     "per_page": z.string().regex(/^-?\d+$/),
     "total": z.number().int(),
-});
+}).strict();
 export type FluffyTopLevel = z.infer<typeof FluffyTopLevelSchema>;
 
 export const PurpleTopLevelSchema = z.object({
@@ -79,7 +79,7 @@ export const PurpleTopLevelSchema = z.object({
     "longitude": z.string(),
     "name": z.string(),
     "region": AdminregionSchema,
-});
+}).strict();
 export type PurpleTopLevel = z.infer<typeof PurpleTopLevelSchema>;
 
 export const TopLevelSchema = z.array(z.union([z.array(PurpleTopLevelSchema), FluffyTopLevelSchema]));
diff --git a/base/typescript-zod/test/inputs/json/misc/31189.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/31189.json/default/TopLevel.ts
index a7a72ec..3858f4c 100644
--- a/base/typescript-zod/test/inputs/json/misc/31189.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/31189.json/default/TopLevel.ts
@@ -8,13 +8,13 @@ export const RatesSchema = z.object({
     "reduced2": z.number().optional(),
     "standard": z.number(),
     "super_reduced": z.number().optional(),
-});
+}).strict();
 export type Rates = z.infer<typeof RatesSchema>;
 
 export const PeriodSchema = z.object({
     "effective_from": z.string(),
     "rates": RatesSchema,
-});
+}).strict();
 export type Period = z.infer<typeof PeriodSchema>;
 
 export const RateSchema = z.object({
@@ -22,12 +22,12 @@ export const RateSchema = z.object({
     "country_code": z.string(),
     "name": z.string(),
     "periods": z.array(PeriodSchema),
-});
+}).strict();
 export type Rate = z.infer<typeof RateSchema>;
 
 export const TopLevelSchema = z.object({
     "details": z.string(),
     "rates": z.array(RateSchema),
     "version": z.null(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/32431.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/32431.json/default/TopLevel.ts
index e0f114b..03f041b 100644
--- a/base/typescript-zod/test/inputs/json/misc/32431.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/32431.json/default/TopLevel.ts
@@ -36,7 +36,7 @@ export type FeatureType = z.infer<typeof FeatureTypeSchema>;
 export const GeometrySchema = z.object({
     "coordinates": z.array(z.number()),
     "type": GeometryTypeSchema,
-});
+}).strict();
 export type Geometry = z.infer<typeof GeometrySchema>;
 
 export const PropertiesSchema = z.object({
@@ -66,7 +66,7 @@ export const PropertiesSchema = z.object({
     "tz": z.number().int(),
     "updated": z.number().int(),
     "url": z.string(),
-});
+}).strict();
 export type Properties = z.infer<typeof PropertiesSchema>;
 
 export const MetadataSchema = z.object({
@@ -76,7 +76,7 @@ export const MetadataSchema = z.object({
     "status": z.number().int(),
     "title": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Metadata = z.infer<typeof MetadataSchema>;
 
 export const FeatureSchema = z.object({
@@ -84,7 +84,7 @@ export const FeatureSchema = z.object({
     "id": z.string(),
     "properties": PropertiesSchema,
     "type": FeatureTypeSchema,
-});
+}).strict();
 export type Feature = z.infer<typeof FeatureSchema>;
 
 export const TopLevelSchema = z.object({
@@ -92,5 +92,5 @@ export const TopLevelSchema = z.object({
     "features": z.array(FeatureSchema),
     "metadata": MetadataSchema,
     "type": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/32d5c.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/32d5c.json/default/TopLevel.ts
index 53aa92a..c6129db 100644
--- a/base/typescript-zod/test/inputs/json/misc/32d5c.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/32d5c.json/default/TopLevel.ts
@@ -10,7 +10,7 @@ export const TopLevelElementSchema = z.object({
     "PersonID": z.number().int(),
     "PhotoURL": z.string(),
     "PreferredName": z.string(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/337ed.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/337ed.json/default/TopLevel.ts
index cb60a3e..afa4215 100644
--- a/base/typescript-zod/test/inputs/json/misc/337ed.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/337ed.json/default/TopLevel.ts
@@ -23,7 +23,7 @@ export const ResultTypeSchema = z.enum([
 export type ResultType = z.infer<typeof ResultTypeSchema>;
 
 export const FacetsSchema = z.object({
-});
+}).strict();
 export type Facets = z.infer<typeof FacetsSchema>;
 
 export const CustomIncomeSchema = z.object({
@@ -35,7 +35,7 @@ export const CustomIncomeSchema = z.object({
     "type": CustomIncomeTypeSchema,
     "updated_at": z.coerce.date(),
     "uri": z.string(),
-});
+}).strict();
 export type CustomIncome = z.infer<typeof CustomIncomeSchema>;
 
 export const ResultSchema = z.object({
@@ -71,7 +71,7 @@ export const ResultSchema = z.object({
     "type": ResultTypeSchema,
     "updated_at": z.coerce.date(),
     "uri": z.string(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
@@ -82,5 +82,5 @@ export const TopLevelSchema = z.object({
     "offset": z.number().int(),
     "previous": z.boolean(),
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/33d2e.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/33d2e.json/default/TopLevel.ts
index bc6817f..6b5be18 100644
--- a/base/typescript-zod/test/inputs/json/misc/33d2e.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/33d2e.json/default/TopLevel.ts
@@ -23,7 +23,7 @@ export const AffiliationClassSchema = z.object({
     "city": z.string().optional(),
     "country": z.string().optional(),
     "name": z.string().optional(),
-});
+}).strict();
 export type AffiliationClass = z.infer<typeof AffiliationClassSchema>;
 
 export const PrizeSchema = z.object({
@@ -33,7 +33,7 @@ export const PrizeSchema = z.object({
     "overallMotivation": z.string().optional(),
     "share": z.string().regex(/^-?\d+$/).optional(),
     "year": z.string().regex(/^-?\d+$/).optional(),
-});
+}).strict();
 export type Prize = z.infer<typeof PrizeSchema>;
 
 export const LaureateSchema = z.object({
@@ -50,10 +50,10 @@ export const LaureateSchema = z.object({
     "id": z.string().regex(/^-?\d+$/),
     "prizes": z.array(PrizeSchema),
     "surname": z.string().optional(),
-});
+}).strict();
 export type Laureate = z.infer<typeof LaureateSchema>;
 
 export const TopLevelSchema = z.object({
     "laureates": z.array(LaureateSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/34702.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/34702.json/default/TopLevel.ts
index bbb2b7d..8a47833 100644
--- a/base/typescript-zod/test/inputs/json/misc/34702.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/34702.json/default/TopLevel.ts
@@ -65,13 +65,13 @@ export type FeatureType = z.infer<typeof FeatureTypeSchema>;
 
 export const CrsPropertiesSchema = z.object({
     "name": z.string(),
-});
+}).strict();
 export type CrsProperties = z.infer<typeof CrsPropertiesSchema>;
 
 export const GeometrySchema = z.object({
     "coordinates": z.array(z.number()),
     "type": GeometryTypeSchema,
-});
+}).strict();
 export type Geometry = z.infer<typeof GeometrySchema>;
 
 export const FeaturePropertiesSchema = z.object({
@@ -90,13 +90,13 @@ export const FeaturePropertiesSchema = z.object({
     "street": z.string(),
     "suburb": z.string(),
     "type": z.union([z.null(), PropertiesTypeSchema]),
-});
+}).strict();
 export type FeatureProperties = z.infer<typeof FeaturePropertiesSchema>;
 
 export const CrsSchema = z.object({
     "properties": CrsPropertiesSchema,
     "type": z.string(),
-});
+}).strict();
 export type Crs = z.infer<typeof CrsSchema>;
 
 export const FeatureSchema = z.object({
@@ -105,7 +105,7 @@ export const FeatureSchema = z.object({
     "id": z.string(),
     "properties": FeaturePropertiesSchema,
     "type": FeatureTypeSchema,
-});
+}).strict();
 export type Feature = z.infer<typeof FeatureSchema>;
 
 export const TopLevelSchema = z.object({
@@ -113,5 +113,5 @@ export const TopLevelSchema = z.object({
     "features": z.array(FeatureSchema),
     "totalFeatures": z.number().int(),
     "type": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/3536b.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/3536b.json/default/TopLevel.ts
index bc38f94..09842de 100644
--- a/base/typescript-zod/test/inputs/json/misc/3536b.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/3536b.json/default/TopLevel.ts
@@ -19,20 +19,20 @@ export type Keyword = z.infer<typeof KeywordSchema>;
 export const IdentifierSchema = z.object({
     "identifier": z.string(),
     "scheme": SchemeSchema,
-});
+}).strict();
 export type Identifier = z.infer<typeof IdentifierSchema>;
 
 export const LinkSchema = z.object({
     "note": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Link = z.infer<typeof LinkSchema>;
 
 export const TextSchema = z.object({
     "media_type": z.string(),
     "title": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Text = z.infer<typeof TextSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -44,7 +44,7 @@ export const TopLevelElementSchema = z.object({
     "other_names": z.array(z.any()),
     "superseded_by": z.string(),
     "text": z.array(TextSchema),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/3659d.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/3659d.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/3659d.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/3659d.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/36d5d.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/36d5d.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/36d5d.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/36d5d.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/3a6b3.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/3a6b3.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/3a6b3.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/3a6b3.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/3e9a3.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/3e9a3.json/default/TopLevel.ts
index 825d96e..5946d4d 100644
--- a/base/typescript-zod/test/inputs/json/misc/3e9a3.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/3e9a3.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const FootnoteSchema = z.object({
     "code": z.string().optional(),
     "text": z.string().optional(),
-});
+}).strict();
 export type Footnote = z.infer<typeof FootnoteSchema>;
 
 export const DatumSchema = z.object({
@@ -13,18 +13,18 @@ export const DatumSchema = z.object({
     "periodName": z.string(),
     "value": z.string(),
     "year": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const SeriesSchema = z.object({
     "data": z.array(DatumSchema),
     "seriesID": z.string(),
-});
+}).strict();
 export type Series = z.infer<typeof SeriesSchema>;
 
 export const ResultsSchema = z.object({
     "series": z.array(SeriesSchema),
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const TopLevelSchema = z.object({
@@ -32,5 +32,5 @@ export const TopLevelSchema = z.object({
     "responseTime": z.number().int(),
     "Results": ResultsSchema,
     "status": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/3f1ce.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/3f1ce.json/default/TopLevel.ts
index 7af027f..ed64551 100644
--- a/base/typescript-zod/test/inputs/json/misc/3f1ce.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/3f1ce.json/default/TopLevel.ts
@@ -9,7 +9,7 @@ export type Text = z.infer<typeof TextSchema>;
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -17,7 +17,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -26,7 +26,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -34,7 +34,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -44,19 +44,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": TextSchema,
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -64,14 +64,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -84,7 +84,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -101,12 +101,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -114,10 +114,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/421d4.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/421d4.json/default/TopLevel.ts
index 51269ab..9aad1ed 100644
--- a/base/typescript-zod/test/inputs/json/misc/421d4.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/421d4.json/default/TopLevel.ts
@@ -4,35 +4,35 @@ import * as z from "zod";
 export const TopSchema = z.object({
     "count": z.number().int(),
     "item": z.string(),
-});
+}).strict();
 export type Top = z.infer<typeof TopSchema>;
 
 export const QuerySchema = z.object({
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const GrantSchema = z.object({
     "flags": z.array(z.string()),
     "inherited": z.boolean(),
     "type": z.string(),
-});
+}).strict();
 export type Grant = z.infer<typeof GrantSchema>;
 
 export const LicenseSchema = z.object({
     "name": z.string(),
-});
+}).strict();
 export type License = z.infer<typeof LicenseSchema>;
 
 export const VisibleSchema = z.object({
     "table": z.boolean(),
-});
+}).strict();
 export type Visible = z.infer<typeof VisibleSchema>;
 
 export const OwnerSchema = z.object({
     "displayName": z.string(),
     "id": z.string(),
     "screenName": z.string(),
-});
+}).strict();
 export type Owner = z.infer<typeof OwnerSchema>;
 
 export const CachedContentsSchema = z.object({
@@ -43,12 +43,12 @@ export const CachedContentsSchema = z.object({
     "smallest": z.string().optional(),
     "sum": z.string().regex(/^-?\d+$/).optional(),
     "top": z.array(TopSchema).optional(),
-});
+}).strict();
 export type CachedContents = z.infer<typeof CachedContentsSchema>;
 
 export const RenderTypeConfigSchema = z.object({
     "visible": VisibleSchema,
-});
+}).strict();
 export type RenderTypeConfig = z.infer<typeof RenderTypeConfigSchema>;
 
 export const ColumnSchema = z.object({
@@ -63,7 +63,7 @@ export const ColumnSchema = z.object({
     "renderTypeName": z.string(),
     "tableColumnId": z.number().int().optional(),
     "width": z.number().int().optional(),
-});
+}).strict();
 export type Column = z.infer<typeof ColumnSchema>;
 
 export const MetadataSchema = z.object({
@@ -72,7 +72,7 @@ export const MetadataSchema = z.object({
     "rdfSubject": z.string().regex(/^-?\d+$/),
     "renderTypeConfig": RenderTypeConfigSchema,
     "rowIdentifier": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Metadata = z.infer<typeof MetadataSchema>;
 
 export const ViewSchema = z.object({
@@ -116,16 +116,16 @@ export const ViewSchema = z.object({
     "viewCount": z.number().int(),
     "viewLastModified": z.number().int(),
     "viewType": z.string(),
-});
+}).strict();
 export type View = z.infer<typeof ViewSchema>;
 
 export const MetaSchema = z.object({
     "view": ViewSchema,
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(z.array(z.union([z.null(), z.number().int(), z.string()]))),
     "meta": MetaSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/437e7.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/437e7.json/default/TopLevel.ts
index 74844f3..7c00fea 100644
--- a/base/typescript-zod/test/inputs/json/misc/437e7.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/437e7.json/default/TopLevel.ts
@@ -20,7 +20,7 @@ export const DownsizedSchema = z.object({
     "size": z.string().regex(/^-?\d+$/).optional(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Downsized = z.infer<typeof DownsizedSchema>;
 
 export const DownsizedSmallSchema = z.object({
@@ -28,7 +28,7 @@ export const DownsizedSmallSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type DownsizedSmall = z.infer<typeof DownsizedSmallSchema>;
 
 export const FixedHeightSchema = z.object({
@@ -41,13 +41,13 @@ export const FixedHeightSchema = z.object({
     "webp": z.string(),
     "webp_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type FixedHeight = z.infer<typeof FixedHeightSchema>;
 
 export const LoopingSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Looping = z.infer<typeof LoopingSchema>;
 
 export const UserSchema = z.object({
@@ -57,21 +57,21 @@ export const UserSchema = z.object({
     "profile_url": z.string(),
     "twitter": z.string(),
     "username": z.string(),
-});
+}).strict();
 export type User = z.infer<typeof UserSchema>;
 
 export const MetaSchema = z.object({
     "msg": z.string(),
     "response_id": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const PaginationSchema = z.object({
     "count": z.number().int(),
     "offset": z.number().int(),
     "total_count": z.number().int(),
-});
+}).strict();
 export type Pagination = z.infer<typeof PaginationSchema>;
 
 export const ImagesSchema = z.object({
@@ -97,7 +97,7 @@ export const ImagesSchema = z.object({
     "preview": DownsizedSmallSchema,
     "preview_gif": DownsizedSchema,
     "preview_webp": DownsizedSchema,
-});
+}).strict();
 export type Images = z.infer<typeof ImagesSchema>;
 
 export const DatumSchema = z.object({
@@ -119,12 +119,12 @@ export const DatumSchema = z.object({
     "url": z.string(),
     "user": UserSchema.optional(),
     "username": z.string(),
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(DatumSchema),
     "meta": MetaSchema,
     "pagination": PaginationSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/43970.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/43970.json/default/TopLevel.ts
index 0f7e6c8..783c189 100644
--- a/base/typescript-zod/test/inputs/json/misc/43970.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/43970.json/default/TopLevel.ts
@@ -5,7 +5,7 @@ export const TopLevelElementSchema = z.object({
     "ID": z.number().int(),
     "Name": z.string(),
     "Notes": z.string(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/43eaf.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/43eaf.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/43eaf.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/43eaf.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/458db.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/458db.json/default/TopLevel.ts
index ba77f2d..8456bce 100644
--- a/base/typescript-zod/test/inputs/json/misc/458db.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/458db.json/default/TopLevel.ts
@@ -9,27 +9,27 @@ export type Name = z.infer<typeof NameSchema>;
 export const ResponseInfoSchema = z.object({
     "developerMessage": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type ResponseInfo = z.infer<typeof ResponseInfoSchema>;
 
 export const ResultsetSchema = z.object({
     "count": z.number().int(),
     "page": z.number().int(),
     "pagesize": z.number().int(),
-});
+}).strict();
 export type Resultset = z.infer<typeof ResultsetSchema>;
 
 export const ComponentSchema = z.object({
     "name": NameSchema,
     "uuid": z.string().uuid(),
-});
+}).strict();
 export type Component = z.infer<typeof ComponentSchema>;
 
 export const MetadataSchema = z.object({
     "executionTime": z.number(),
     "responseInfo": ResponseInfoSchema,
     "resultset": ResultsetSchema,
-});
+}).strict();
 export type Metadata = z.infer<typeof MetadataSchema>;
 
 export const ResultSchema = z.object({
@@ -46,11 +46,11 @@ export const ResultSchema = z.object({
     "url": z.string(),
     "uuid": z.string().uuid(),
     "vuuid": z.string().uuid(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
     "metadata": MetadataSchema,
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/4961a.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/4961a.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/4961a.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/4961a.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/4a0d7.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/4a0d7.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/4a0d7.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/4a0d7.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/4a455.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/4a455.json/default/TopLevel.ts
index 9dde2fe..2b3e03d 100644
--- a/base/typescript-zod/test/inputs/json/misc/4a455.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/4a455.json/default/TopLevel.ts
@@ -20,13 +20,13 @@ export type FeatureType = z.infer<typeof FeatureTypeSchema>;
 
 export const CrsPropertiesSchema = z.object({
     "name": z.string(),
-});
+}).strict();
 export type CrsProperties = z.infer<typeof CrsPropertiesSchema>;
 
 export const GeometrySchema = z.object({
     "coordinates": z.array(z.array(z.number())),
     "type": GeometryTypeSchema,
-});
+}).strict();
 export type Geometry = z.infer<typeof GeometrySchema>;
 
 export const FeaturePropertiesSchema = z.object({
@@ -36,13 +36,13 @@ export const FeaturePropertiesSchema = z.object({
     "siteurl": z.string(),
     "streetaddress": z.string(),
     "twitteraccount": z.string(),
-});
+}).strict();
 export type FeatureProperties = z.infer<typeof FeaturePropertiesSchema>;
 
 export const CrsSchema = z.object({
     "properties": CrsPropertiesSchema,
     "type": z.string(),
-});
+}).strict();
 export type Crs = z.infer<typeof CrsSchema>;
 
 export const FeatureSchema = z.object({
@@ -51,7 +51,7 @@ export const FeatureSchema = z.object({
     "id": z.string(),
     "properties": FeaturePropertiesSchema,
     "type": FeatureTypeSchema,
-});
+}).strict();
 export type Feature = z.infer<typeof FeatureSchema>;
 
 export const TopLevelSchema = z.object({
@@ -59,5 +59,5 @@ export const TopLevelSchema = z.object({
     "features": z.array(FeatureSchema),
     "totalFeatures": z.number().int(),
     "type": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/4c547.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/4c547.json/default/TopLevel.ts
index 82adaab..e046c65 100644
--- a/base/typescript-zod/test/inputs/json/misc/4c547.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/4c547.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -12,7 +12,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -21,7 +21,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -29,7 +29,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -39,19 +39,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -59,14 +59,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -79,7 +79,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -96,12 +96,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -109,10 +109,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/4d6fb.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/4d6fb.json/default/TopLevel.ts
index 5c5ce2a..cfeb05e 100644
--- a/base/typescript-zod/test/inputs/json/misc/4d6fb.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/4d6fb.json/default/TopLevel.ts
@@ -51,7 +51,7 @@ export const OembedSchema = z.object({
     "type": z.string(),
     "version": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Oembed = z.infer<typeof OembedSchema>;
 
 export const MediaEmbedSchema = z.object({
@@ -59,24 +59,24 @@ export const MediaEmbedSchema = z.object({
     "height": z.number().int().optional(),
     "scrolling": z.boolean().optional(),
     "width": z.number().int().optional(),
-});
+}).strict();
 export type MediaEmbed = z.infer<typeof MediaEmbedSchema>;
 
 export const SourceSchema = z.object({
     "height": z.number().int(),
     "url": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Source = z.infer<typeof SourceSchema>;
 
 export const VariantsSchema = z.object({
-});
+}).strict();
 export type Variants = z.infer<typeof VariantsSchema>;
 
 export const MediaSchema = z.object({
     "oembed": OembedSchema,
     "type": z.string(),
-});
+}).strict();
 export type Media = z.infer<typeof MediaSchema>;
 
 export const ImageSchema = z.object({
@@ -84,13 +84,13 @@ export const ImageSchema = z.object({
     "resolutions": z.array(SourceSchema),
     "source": SourceSchema,
     "variants": VariantsSchema,
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const PreviewSchema = z.object({
     "enabled": z.boolean(),
     "images": z.array(ImageSchema),
-});
+}).strict();
 export type Preview = z.infer<typeof PreviewSchema>;
 
 export const ChildDataSchema = z.object({
@@ -158,13 +158,13 @@ export const ChildDataSchema = z.object({
     "user_reports": z.array(z.any()),
     "view_count": z.null(),
     "visited": z.boolean(),
-});
+}).strict();
 export type ChildData = z.infer<typeof ChildDataSchema>;
 
 export const ChildSchema = z.object({
     "data": ChildDataSchema,
     "kind": KindSchema,
-});
+}).strict();
 export type Child = z.infer<typeof ChildSchema>;
 
 export const TopLevelDataSchema = z.object({
@@ -172,11 +172,11 @@ export const TopLevelDataSchema = z.object({
     "before": z.null(),
     "children": z.array(ChildSchema),
     "modhash": z.string(),
-});
+}).strict();
 export type TopLevelData = z.infer<typeof TopLevelDataSchema>;
 
 export const TopLevelSchema = z.object({
     "data": TopLevelDataSchema,
     "kind": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/4e336.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/4e336.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/4e336.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/4e336.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/54147.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/54147.json/default/TopLevel.ts
index a68979e..77d0dc7 100644
--- a/base/typescript-zod/test/inputs/json/misc/54147.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/54147.json/default/TopLevel.ts
@@ -2,7 +2,7 @@ import * as z from "zod";
 
 
 export const ArgsSchema = z.object({
-});
+}).strict();
 export type Args = z.infer<typeof ArgsSchema>;
 
 export const HeadersSchema = z.object({
@@ -10,7 +10,7 @@ export const HeadersSchema = z.object({
     "Connection": z.string(),
     "Host": z.string(),
     "User-Agent": z.string(),
-});
+}).strict();
 export type Headers = z.infer<typeof HeadersSchema>;
 
 export const TopLevelSchema = z.object({
@@ -21,5 +21,5 @@ export const TopLevelSchema = z.object({
     "headers": HeadersSchema,
     "origin": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/54d32.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/54d32.json/default/TopLevel.ts
index 2a61df0..82d9c8e 100644
--- a/base/typescript-zod/test/inputs/json/misc/54d32.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/54d32.json/default/TopLevel.ts
@@ -8,7 +8,7 @@ export const StatusSchema = z.enum([
 export type Status = z.infer<typeof StatusSchema>;
 
 export const FacetsSchema = z.object({
-});
+}).strict();
 export type Facets = z.infer<typeof FacetsSchema>;
 
 export const ResultSchema = z.object({
@@ -18,7 +18,7 @@ export const ResultSchema = z.object({
     "representative_id": z.string(),
     "status": StatusSchema,
     "updated_at": z.coerce.date(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
@@ -29,5 +29,5 @@ export const TopLevelSchema = z.object({
     "offset": z.number().int(),
     "previous": z.boolean(),
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/570ec.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/570ec.json/default/TopLevel.ts
index 93a5713..5dc7003 100644
--- a/base/typescript-zod/test/inputs/json/misc/570ec.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/570ec.json/default/TopLevel.ts
@@ -11,26 +11,26 @@ export type Scheme = z.infer<typeof SchemeSchema>;
 export const IdentifierSchema = z.object({
     "identifier": z.string(),
     "scheme": SchemeSchema,
-});
+}).strict();
 export type Identifier = z.infer<typeof IdentifierSchema>;
 
 export const LinkSchema = z.object({
     "note": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Link = z.infer<typeof LinkSchema>;
 
 export const OtherNameSchema = z.object({
     "name": z.string(),
     "note": z.union([z.null(), z.string()]),
-});
+}).strict();
 export type OtherName = z.infer<typeof OtherNameSchema>;
 
 export const TextSchema = z.object({
     "media_type": z.string(),
     "title": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Text = z.infer<typeof TextSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -42,7 +42,7 @@ export const TopLevelElementSchema = z.object({
     "other_names": z.array(OtherNameSchema),
     "superseded_by": z.null(),
     "text": z.array(TextSchema),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/5dd0d.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/5dd0d.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/5dd0d.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/5dd0d.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/5eae5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/5eae5.json/default/TopLevel.ts
index 1bd8506..3f1f282 100644
--- a/base/typescript-zod/test/inputs/json/misc/5eae5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/5eae5.json/default/TopLevel.ts
@@ -6,7 +6,7 @@ export const TopLevelElementSchema = z.object({
     "ID": z.number().int(),
     "Sponsor": z.string(),
     "Title": z.string(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/5eb20.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/5eb20.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/5eb20.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/5eb20.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/5f3a1.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/5f3a1.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/5f3a1.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/5f3a1.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/5f7fe.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/5f7fe.json/default/TopLevel.ts
index 7d36f19..634e2bf 100644
--- a/base/typescript-zod/test/inputs/json/misc/5f7fe.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/5f7fe.json/default/TopLevel.ts
@@ -11,20 +11,20 @@ export type TypeName = z.infer<typeof TypeNameSchema>;
 export const TopSchema = z.object({
     "count": z.number().int(),
     "item": z.string(),
-});
+}).strict();
 export type Top = z.infer<typeof TopSchema>;
 
 export const FormatSchema = z.object({
     "align": z.string().optional(),
     "view": z.string().optional(),
-});
+}).strict();
 export type Format = z.infer<typeof FormatSchema>;
 
 export const GrantSchema = z.object({
     "flags": z.array(z.string()),
     "inherited": z.boolean(),
     "type": z.string(),
-});
+}).strict();
 export type Grant = z.infer<typeof GrantSchema>;
 
 export const AttachmentSchema = z.object({
@@ -32,25 +32,25 @@ export const AttachmentSchema = z.object({
     "blobId": z.string(),
     "filename": z.string(),
     "name": z.string(),
-});
+}).strict();
 export type Attachment = z.infer<typeof AttachmentSchema>;
 
 export const AdditionalResourcesSchema = z.object({
     "See Also ": z.string(),
     "See Also": z.string(),
-});
+}).strict();
 export type AdditionalResources = z.infer<typeof AdditionalResourcesSchema>;
 
 export const CommonCoreSchema = z.object({
     "Contact Email": z.string(),
     "Contact Name": z.string(),
     "Publisher": z.string(),
-});
+}).strict();
 export type CommonCore = z.infer<typeof CommonCoreSchema>;
 
 export const DatasetInformationSchema = z.object({
     "Agency": z.string(),
-});
+}).strict();
 export type DatasetInformation = z.infer<typeof DatasetInformationSchema>;
 
 export const DatasetSummarySchema = z.object({
@@ -63,23 +63,23 @@ export const DatasetSummarySchema = z.object({
     "Posting Frequency": z.string(),
     "Time Period": z.string(),
     "Units": z.string(),
-});
+}).strict();
 export type DatasetSummary = z.infer<typeof DatasetSummarySchema>;
 
 export const NotesSchema = z.object({
     "Notes": z.string(),
-});
+}).strict();
 export type Notes = z.infer<typeof NotesSchema>;
 
 export const OrderSchema = z.object({
     "ascending": z.boolean(),
     "columnFieldName": z.string(),
-});
+}).strict();
 export type Order = z.infer<typeof OrderSchema>;
 
 export const VisibleSchema = z.object({
     "table": z.boolean(),
-});
+}).strict();
 export type Visible = z.infer<typeof VisibleSchema>;
 
 export const OwnerSchema = z.object({
@@ -91,13 +91,13 @@ export const OwnerSchema = z.object({
     "rights": z.array(z.string()),
     "roleName": z.string(),
     "screenName": z.string(),
-});
+}).strict();
 export type Owner = z.infer<typeof OwnerSchema>;
 
 export const ExpressionSchema = z.object({
     "columnId": z.number().int(),
     "type": z.string(),
-});
+}).strict();
 export type Expression = z.infer<typeof ExpressionSchema>;
 
 export const CachedContentsSchema = z.object({
@@ -106,7 +106,7 @@ export const CachedContentsSchema = z.object({
     "null": z.number().int(),
     "smallest": z.string(),
     "top": z.array(TopSchema),
-});
+}).strict();
 export type CachedContents = z.infer<typeof CachedContentsSchema>;
 
 export const CustomFieldsSchema = z.object({
@@ -115,23 +115,23 @@ export const CustomFieldsSchema = z.object({
     "Dataset Information": DatasetInformationSchema,
     "Dataset Summary": DatasetSummarySchema,
     "Notes": NotesSchema,
-});
+}).strict();
 export type CustomFields = z.infer<typeof CustomFieldsSchema>;
 
 export const JsonQuerySchema = z.object({
     "order": z.array(OrderSchema),
-});
+}).strict();
 export type JsonQuery = z.infer<typeof JsonQuerySchema>;
 
 export const RenderTypeConfigSchema = z.object({
     "visible": VisibleSchema,
-});
+}).strict();
 export type RenderTypeConfig = z.infer<typeof RenderTypeConfigSchema>;
 
 export const OrderBySchema = z.object({
     "ascending": z.boolean(),
     "expression": ExpressionSchema,
-});
+}).strict();
 export type OrderBy = z.infer<typeof OrderBySchema>;
 
 export const ColumnSchema = z.object({
@@ -146,7 +146,7 @@ export const ColumnSchema = z.object({
     "renderTypeName": TypeNameSchema,
     "tableColumnId": z.number().int().optional(),
     "width": z.number().int().optional(),
-});
+}).strict();
 export type Column = z.infer<typeof ColumnSchema>;
 
 export const MetadataSchema = z.object({
@@ -156,12 +156,12 @@ export const MetadataSchema = z.object({
     "jsonQuery": JsonQuerySchema,
     "rdfSubject": z.string().regex(/^-?\d+$/),
     "renderTypeConfig": RenderTypeConfigSchema,
-});
+}).strict();
 export type Metadata = z.infer<typeof MetadataSchema>;
 
 export const QuerySchema = z.object({
     "orderBys": z.array(OrderBySchema),
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const ViewSchema = z.object({
@@ -203,16 +203,16 @@ export const ViewSchema = z.object({
     "viewCount": z.number().int(),
     "viewLastModified": z.number().int(),
     "viewType": z.string(),
-});
+}).strict();
 export type View = z.infer<typeof ViewSchema>;
 
 export const MetaSchema = z.object({
     "view": ViewSchema,
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(z.array(z.union([z.null(), z.number().int(), z.string()]))),
     "meta": MetaSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/617e8.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/617e8.json/default/TopLevel.ts
index bf535c5..e7f9933 100644
--- a/base/typescript-zod/test/inputs/json/misc/617e8.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/617e8.json/default/TopLevel.ts
@@ -11,20 +11,20 @@ export type TypeName = z.infer<typeof TypeNameSchema>;
 export const TopSchema = z.object({
     "count": z.number().int(),
     "item": z.string(),
-});
+}).strict();
 export type Top = z.infer<typeof TopSchema>;
 
 export const FormatSchema = z.object({
     "align": z.string().optional(),
     "view": z.string().optional(),
-});
+}).strict();
 export type Format = z.infer<typeof FormatSchema>;
 
 export const GrantSchema = z.object({
     "flags": z.array(z.string()),
     "inherited": z.boolean(),
     "type": z.string(),
-});
+}).strict();
 export type Grant = z.infer<typeof GrantSchema>;
 
 export const AttachmentSchema = z.object({
@@ -32,24 +32,24 @@ export const AttachmentSchema = z.object({
     "blobId": z.string(),
     "filename": z.string(),
     "name": z.string(),
-});
+}).strict();
 export type Attachment = z.infer<typeof AttachmentSchema>;
 
 export const AdditionalResourcesSchema = z.object({
     "See Also": z.string(),
-});
+}).strict();
 export type AdditionalResources = z.infer<typeof AdditionalResourcesSchema>;
 
 export const CommonCoreSchema = z.object({
     "Contact Email": z.string(),
     "Contact Name": z.string(),
     "Publisher": z.string(),
-});
+}).strict();
 export type CommonCore = z.infer<typeof CommonCoreSchema>;
 
 export const DatasetInformationSchema = z.object({
     "Agency": z.string(),
-});
+}).strict();
 export type DatasetInformation = z.infer<typeof DatasetInformationSchema>;
 
 export const DatasetSummarySchema = z.object({
@@ -61,23 +61,23 @@ export const DatasetSummarySchema = z.object({
     "Organization": z.string(),
     "Posting Frequency": z.string(),
     "Time Period": z.string(),
-});
+}).strict();
 export type DatasetSummary = z.infer<typeof DatasetSummarySchema>;
 
 export const NotesSchema = z.object({
     "Notes": z.string(),
-});
+}).strict();
 export type Notes = z.infer<typeof NotesSchema>;
 
 export const OrderSchema = z.object({
     "ascending": z.boolean(),
     "columnFieldName": z.string(),
-});
+}).strict();
 export type Order = z.infer<typeof OrderSchema>;
 
 export const VisibleSchema = z.object({
     "table": z.boolean(),
-});
+}).strict();
 export type Visible = z.infer<typeof VisibleSchema>;
 
 export const OwnerSchema = z.object({
@@ -89,13 +89,13 @@ export const OwnerSchema = z.object({
     "rights": z.array(z.string()),
     "roleName": z.string(),
     "screenName": z.string(),
-});
+}).strict();
 export type Owner = z.infer<typeof OwnerSchema>;
 
 export const ExpressionSchema = z.object({
     "columnId": z.number().int(),
     "type": z.string(),
-});
+}).strict();
 export type Expression = z.infer<typeof ExpressionSchema>;
 
 export const CachedContentsSchema = z.object({
@@ -104,7 +104,7 @@ export const CachedContentsSchema = z.object({
     "null": z.number().int(),
     "smallest": z.string(),
     "top": z.array(TopSchema),
-});
+}).strict();
 export type CachedContents = z.infer<typeof CachedContentsSchema>;
 
 export const CustomFieldsSchema = z.object({
@@ -113,23 +113,23 @@ export const CustomFieldsSchema = z.object({
     "Dataset Information": DatasetInformationSchema,
     "Dataset Summary": DatasetSummarySchema,
     "Notes": NotesSchema,
-});
+}).strict();
 export type CustomFields = z.infer<typeof CustomFieldsSchema>;
 
 export const JsonQuerySchema = z.object({
     "order": z.array(OrderSchema),
-});
+}).strict();
 export type JsonQuery = z.infer<typeof JsonQuerySchema>;
 
 export const RenderTypeConfigSchema = z.object({
     "visible": VisibleSchema,
-});
+}).strict();
 export type RenderTypeConfig = z.infer<typeof RenderTypeConfigSchema>;
 
 export const OrderBySchema = z.object({
     "ascending": z.boolean(),
     "expression": ExpressionSchema,
-});
+}).strict();
 export type OrderBy = z.infer<typeof OrderBySchema>;
 
 export const ColumnSchema = z.object({
@@ -145,7 +145,7 @@ export const ColumnSchema = z.object({
     "renderTypeName": TypeNameSchema,
     "tableColumnId": z.number().int().optional(),
     "width": z.number().int().optional(),
-});
+}).strict();
 export type Column = z.infer<typeof ColumnSchema>;
 
 export const MetadataSchema = z.object({
@@ -155,12 +155,12 @@ export const MetadataSchema = z.object({
     "jsonQuery": JsonQuerySchema,
     "rdfSubject": z.string().regex(/^-?\d+$/),
     "renderTypeConfig": RenderTypeConfigSchema,
-});
+}).strict();
 export type Metadata = z.infer<typeof MetadataSchema>;
 
 export const QuerySchema = z.object({
     "orderBys": z.array(OrderBySchema),
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const ViewSchema = z.object({
@@ -202,16 +202,16 @@ export const ViewSchema = z.object({
     "viewCount": z.number().int(),
     "viewLastModified": z.number().int(),
     "viewType": z.string(),
-});
+}).strict();
 export type View = z.infer<typeof ViewSchema>;
 
 export const MetaSchema = z.object({
     "view": ViewSchema,
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(z.array(z.union([z.null(), z.number().int(), z.string()]))),
     "meta": MetaSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/61b66.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/61b66.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/61b66.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/61b66.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/6260a.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/6260a.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/6260a.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/6260a.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/65dec.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/65dec.json/default/TopLevel.ts
index 630e3b8..fd5b5e2 100644
--- a/base/typescript-zod/test/inputs/json/misc/65dec.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/65dec.json/default/TopLevel.ts
@@ -57,13 +57,13 @@ export type Type = z.infer<typeof TypeSchema>;
 export const LegalityElementSchema = z.object({
     "format": z.string(),
     "legality": LegalityEnumSchema,
-});
+}).strict();
 export type LegalityElement = z.infer<typeof LegalityElementSchema>;
 
 export const RulingSchema = z.object({
     "date": z.string(),
     "text": z.string(),
-});
+}).strict();
 export type Ruling = z.infer<typeof RulingSchema>;
 
 export const CardSchema = z.object({
@@ -95,7 +95,7 @@ export const CardSchema = z.object({
     "types": z.array(TypeSchema),
     "variations": z.array(z.number().int()).optional(),
     "watermark": WatermarkSchema.optional(),
-});
+}).strict();
 export type Card = z.infer<typeof CardSchema>;
 
 export const TopLevelSchema = z.object({
@@ -110,5 +110,5 @@ export const TopLevelSchema = z.object({
     "name": z.string(),
     "releaseDate": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/66121.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/66121.json/default/TopLevel.ts
index b459abe..83055c5 100644
--- a/base/typescript-zod/test/inputs/json/misc/66121.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/66121.json/default/TopLevel.ts
@@ -37,20 +37,20 @@ export type Title = z.infer<typeof TitleSchema>;
 export const IdentifierSchema = z.object({
     "identifier": z.string(),
     "scheme": SchemeSchema,
-});
+}).strict();
 export type Identifier = z.infer<typeof IdentifierSchema>;
 
 export const LinkSchema = z.object({
     "note": NoteSchema,
     "url": z.string(),
-});
+}).strict();
 export type Link = z.infer<typeof LinkSchema>;
 
 export const TextSchema = z.object({
     "media_type": MediaTypeSchema,
     "title": TitleSchema,
     "url": z.string(),
-});
+}).strict();
 export type Text = z.infer<typeof TextSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -62,7 +62,7 @@ export const TopLevelElementSchema = z.object({
     "other_names": z.array(z.any()),
     "superseded_by": z.union([z.null(), z.string()]),
     "text": z.array(TextSchema),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/6617c.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/6617c.json/default/TopLevel.ts
index e3fe56a..8af5f1f 100644
--- a/base/typescript-zod/test/inputs/json/misc/6617c.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/6617c.json/default/TopLevel.ts
@@ -4,12 +4,12 @@ import * as z from "zod";
 export const IssPositionSchema = z.object({
     "latitude": z.string(),
     "longitude": z.string(),
-});
+}).strict();
 export type IssPosition = z.infer<typeof IssPositionSchema>;
 
 export const TopLevelSchema = z.object({
     "iss_position": IssPositionSchema,
     "message": z.string(),
     "timestamp": z.number().int(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/67c03.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/67c03.json/default/TopLevel.ts
index e945e2c..adbf3b9 100644
--- a/base/typescript-zod/test/inputs/json/misc/67c03.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/67c03.json/default/TopLevel.ts
@@ -4,12 +4,12 @@ import * as z from "zod";
 export const PersonSchema = z.object({
     "craft": z.string(),
     "name": z.string(),
-});
+}).strict();
 export type Person = z.infer<typeof PersonSchema>;
 
 export const TopLevelSchema = z.object({
     "message": z.string(),
     "number": z.number().int(),
     "people": z.array(PersonSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/68c30.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/68c30.json/default/TopLevel.ts
index 42d724e..cf8296b 100644
--- a/base/typescript-zod/test/inputs/json/misc/68c30.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/68c30.json/default/TopLevel.ts
@@ -9,14 +9,14 @@ export const OutSchema = z.object({
     "tx_index": z.number().int(),
     "type": z.number().int(),
     "value": z.number().int(),
-});
+}).strict();
 export type Out = z.infer<typeof OutSchema>;
 
 export const InputSchema = z.object({
     "prev_out": OutSchema,
     "script": z.string(),
     "sequence": z.number().int(),
-});
+}).strict();
 export type Input = z.infer<typeof InputSchema>;
 
 export const TxSchema = z.object({
@@ -32,10 +32,10 @@ export const TxSchema = z.object({
     "ver": z.number().int(),
     "vin_sz": z.number().int(),
     "vout_sz": z.number().int(),
-});
+}).strict();
 export type Tx = z.infer<typeof TxSchema>;
 
 export const TopLevelSchema = z.object({
     "txs": z.array(TxSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/6c155.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/6c155.json/default/TopLevel.ts
index 3870189..9022434 100644
--- a/base/typescript-zod/test/inputs/json/misc/6c155.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/6c155.json/default/TopLevel.ts
@@ -4,20 +4,20 @@ import * as z from "zod";
 export const ResponseInfoSchema = z.object({
     "developerMessage": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type ResponseInfo = z.infer<typeof ResponseInfoSchema>;
 
 export const ResultsetSchema = z.object({
     "count": z.number().int(),
     "page": z.number().int(),
     "pagesize": z.number().int(),
-});
+}).strict();
 export type Resultset = z.infer<typeof ResultsetSchema>;
 
 export const ComponentSchema = z.object({
     "name": z.string(),
     "uuid": z.string().uuid(),
-});
+}).strict();
 export type Component = z.infer<typeof ComponentSchema>;
 
 export const LocationSchema = z.object({
@@ -31,14 +31,14 @@ export const LocationSchema = z.object({
     "postal_code": z.string(),
     "sub_premise": z.null(),
     "thoroughfare": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const MetadataSchema = z.object({
     "executionTime": z.number(),
     "responseInfo": ResponseInfoSchema,
     "resultset": ResultsetSchema,
-});
+}).strict();
 export type Metadata = z.infer<typeof MetadataSchema>;
 
 export const ResultSchema = z.object({
@@ -56,11 +56,11 @@ export const ResultSchema = z.object({
     "url": z.string(),
     "uuid": z.string().uuid(),
     "vuuid": z.string().uuid(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
     "metadata": MetadataSchema,
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/6de06.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/6de06.json/default/TopLevel.ts
index faac6d2..098a4c3 100644
--- a/base/typescript-zod/test/inputs/json/misc/6de06.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/6de06.json/default/TopLevel.ts
@@ -33,7 +33,7 @@ export const OembedSchema = z.object({
     "type": z.string(),
     "version": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Oembed = z.infer<typeof OembedSchema>;
 
 export const MediaEmbedSchema = z.object({
@@ -41,26 +41,26 @@ export const MediaEmbedSchema = z.object({
     "height": z.number().int().optional(),
     "scrolling": z.boolean().optional(),
     "width": z.number().int().optional(),
-});
+}).strict();
 export type MediaEmbed = z.infer<typeof MediaEmbedSchema>;
 
 export const SourceSchema = z.object({
     "height": z.number().int(),
     "url": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Source = z.infer<typeof SourceSchema>;
 
 export const GifSchema = z.object({
     "resolutions": z.array(SourceSchema),
     "source": SourceSchema,
-});
+}).strict();
 export type Gif = z.infer<typeof GifSchema>;
 
 export const MediaSchema = z.object({
     "oembed": OembedSchema,
     "type": z.string(),
-});
+}).strict();
 export type Media = z.infer<typeof MediaSchema>;
 
 export const VariantsSchema = z.object({
@@ -68,7 +68,7 @@ export const VariantsSchema = z.object({
     "mp4": GifSchema.optional(),
     "nsfw": GifSchema.optional(),
     "obfuscated": GifSchema.optional(),
-});
+}).strict();
 export type Variants = z.infer<typeof VariantsSchema>;
 
 export const ImageSchema = z.object({
@@ -76,13 +76,13 @@ export const ImageSchema = z.object({
     "resolutions": z.array(SourceSchema),
     "source": SourceSchema,
     "variants": VariantsSchema,
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const PreviewSchema = z.object({
     "enabled": z.boolean(),
     "images": z.array(ImageSchema),
-});
+}).strict();
 export type Preview = z.infer<typeof PreviewSchema>;
 
 export const ChildDataSchema = z.object({
@@ -150,13 +150,13 @@ export const ChildDataSchema = z.object({
     "user_reports": z.array(z.any()),
     "view_count": z.null(),
     "visited": z.boolean(),
-});
+}).strict();
 export type ChildData = z.infer<typeof ChildDataSchema>;
 
 export const ChildSchema = z.object({
     "data": ChildDataSchema,
     "kind": KindSchema,
-});
+}).strict();
 export type Child = z.infer<typeof ChildSchema>;
 
 export const TopLevelDataSchema = z.object({
@@ -164,11 +164,11 @@ export const TopLevelDataSchema = z.object({
     "before": z.null(),
     "children": z.array(ChildSchema),
     "modhash": z.string(),
-});
+}).strict();
 export type TopLevelData = z.infer<typeof TopLevelDataSchema>;
 
 export const TopLevelSchema = z.object({
     "data": TopLevelDataSchema,
     "kind": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/6dec6.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/6dec6.json/default/TopLevel.ts
index 2b92a18..dfc479d 100644
--- a/base/typescript-zod/test/inputs/json/misc/6dec6.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/6dec6.json/default/TopLevel.ts
@@ -11,7 +11,7 @@ export type Text = z.infer<typeof TextSchema>;
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -19,7 +19,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -28,7 +28,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -36,7 +36,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -46,19 +46,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": TextSchema,
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -66,14 +66,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -86,7 +86,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -103,12 +103,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -116,10 +116,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/6eb00.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/6eb00.json/default/TopLevel.ts
index fec89ef..d157aa4 100644
--- a/base/typescript-zod/test/inputs/json/misc/6eb00.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/6eb00.json/default/TopLevel.ts
@@ -5,7 +5,7 @@ export const TopLevelElementSchema = z.object({
     "DirectorateID": z.number().int(),
     "Id": z.number().int(),
     "Name": z.string(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/70c77.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/70c77.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/70c77.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/70c77.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/734ad.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/734ad.json/default/TopLevel.ts
index ba39d4b..ff0f11a 100644
--- a/base/typescript-zod/test/inputs/json/misc/734ad.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/734ad.json/default/TopLevel.ts
@@ -8,7 +8,7 @@ export const StatusSchema = z.enum([
 export type Status = z.infer<typeof StatusSchema>;
 
 export const FacetsSchema = z.object({
-});
+}).strict();
 export type Facets = z.infer<typeof FacetsSchema>;
 
 export const ResultSchema = z.object({
@@ -70,7 +70,7 @@ export const ResultSchema = z.object({
     "updated_at": z.coerce.date(),
     "uri": z.string(),
     "web_site_url": z.union([z.null(), z.string()]),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
@@ -81,5 +81,5 @@ export const TopLevelSchema = z.object({
     "offset": z.number().int(),
     "previous": z.boolean(),
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/75912.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/75912.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/75912.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/75912.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/7681c.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/7681c.json/default/TopLevel.ts
index c6ca384..82b00b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/7681c.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/7681c.json/default/TopLevel.ts
@@ -28,7 +28,7 @@ export const The480_WStillSchema = z.object({
     "size": z.string().regex(/^-?\d+$/).optional(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type The480_WStill = z.infer<typeof The480_WStillSchema>;
 
 export const DownsizedSmallSchema = z.object({
@@ -36,7 +36,7 @@ export const DownsizedSmallSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type DownsizedSmall = z.infer<typeof DownsizedSmallSchema>;
 
 export const FixedHeightSchema = z.object({
@@ -50,13 +50,13 @@ export const FixedHeightSchema = z.object({
     "webp": z.string(),
     "webp_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type FixedHeight = z.infer<typeof FixedHeightSchema>;
 
 export const LoopingSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Looping = z.infer<typeof LoopingSchema>;
 
 export const UserSchema = z.object({
@@ -66,21 +66,21 @@ export const UserSchema = z.object({
     "profile_url": z.string(),
     "twitter": z.string().optional(),
     "username": z.string(),
-});
+}).strict();
 export type User = z.infer<typeof UserSchema>;
 
 export const MetaSchema = z.object({
     "msg": z.string(),
     "response_id": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const PaginationSchema = z.object({
     "count": z.number().int(),
     "offset": z.number().int(),
     "total_count": z.number().int(),
-});
+}).strict();
 export type Pagination = z.infer<typeof PaginationSchema>;
 
 export const ImagesSchema = z.object({
@@ -107,7 +107,7 @@ export const ImagesSchema = z.object({
     "preview_gif": The480_WStillSchema,
     "preview_webp": The480_WStillSchema,
     "480w_still": The480_WStillSchema.optional(),
-});
+}).strict();
 export type Images = z.infer<typeof ImagesSchema>;
 
 export const DatumSchema = z.object({
@@ -129,12 +129,12 @@ export const DatumSchema = z.object({
     "url": z.string(),
     "user": UserSchema.optional(),
     "username": UsernameSchema,
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(DatumSchema),
     "meta": MetaSchema,
     "pagination": PaginationSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/76ae1.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/76ae1.json/default/TopLevel.ts
index 1e1c383..0689284 100644
--- a/base/typescript-zod/test/inputs/json/misc/76ae1.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/76ae1.json/default/TopLevel.ts
@@ -21,7 +21,7 @@ export type SchemaType = z.infer<typeof SchemaTypeSchema>;
 export const PropertySchema = z.object({
     "description": z.string(),
     "type": FormatEnumSchema,
-});
+}).strict();
 export type Property = z.infer<typeof PropertySchema>;
 
 export const DeMinimisPropertiesSchema = z.object({
@@ -32,7 +32,7 @@ export const DeMinimisPropertiesSchema = z.object({
     "notes": PropertySchema,
     "vat_amount": PropertySchema,
     "vat_currency": PropertySchema,
-});
+}).strict();
 export type DeMinimisProperties = z.infer<typeof DeMinimisPropertiesSchema>;
 
 export const FaqPropertiesSchema = z.object({
@@ -47,7 +47,7 @@ export const FaqPropertiesSchema = z.object({
     "trade_regions": PropertySchema,
     "url": PropertySchema,
     "world_regions": PropertySchema,
-});
+}).strict();
 export type FaqProperties = z.infer<typeof FaqPropertiesSchema>;
 
 export const ReportPropertiesSchema = z.object({
@@ -60,7 +60,7 @@ export const ReportPropertiesSchema = z.object({
     "report_type": PropertySchema,
     "title": PropertySchema,
     "url": PropertySchema,
-});
+}).strict();
 export type ReportProperties = z.infer<typeof ReportPropertiesSchema>;
 
 export const TaxonomyPropertiesSchema = z.object({
@@ -70,14 +70,14 @@ export const TaxonomyPropertiesSchema = z.object({
     "label": PropertySchema,
     "sub_class_of": PropertySchema,
     "type": PropertySchema,
-});
+}).strict();
 export type TaxonomyProperties = z.infer<typeof TaxonomyPropertiesSchema>;
 
 export const InfoSchema = z.object({
     "description": z.string(),
     "title": z.string(),
     "version": z.string(),
-});
+}).strict();
 export type Info = z.infer<typeof InfoSchema>;
 
 export const ParameterSchema = z.object({
@@ -87,55 +87,55 @@ export const ParameterSchema = z.object({
     "name": z.string(),
     "required": z.boolean(),
     "type": FormatEnumSchema,
-});
+}).strict();
 export type Parameter = z.infer<typeof ParameterSchema>;
 
 export const ItemsClassSchema = z.object({
     "$ref": z.string(),
-});
+}).strict();
 export type ItemsClass = z.infer<typeof ItemsClassSchema>;
 
 export const PurpleSchemaSchema = z.object({
     "items": ItemsClassSchema,
     "type": SchemaTypeSchema,
-});
+}).strict();
 export type PurpleSchema = z.infer<typeof PurpleSchemaSchema>;
 
 export const ArticleSchema = z.object({
     "properties": z.record(z.string(), PropertySchema),
-});
+}).strict();
 export type Article = z.infer<typeof ArticleSchema>;
 
 export const DeMinimisSchema = z.object({
     "properties": DeMinimisPropertiesSchema,
-});
+}).strict();
 export type DeMinimis = z.infer<typeof DeMinimisSchema>;
 
 export const FaqSchema = z.object({
     "properties": FaqPropertiesSchema,
-});
+}).strict();
 export type Faq = z.infer<typeof FaqSchema>;
 
 export const ReportSchema = z.object({
     "properties": ReportPropertiesSchema,
-});
+}).strict();
 export type Report = z.infer<typeof ReportSchema>;
 
 export const TaxonomySchema = z.object({
     "properties": TaxonomyPropertiesSchema,
-});
+}).strict();
 export type Taxonomy = z.infer<typeof TaxonomySchema>;
 
 export const Purple200Schema = z.object({
     "description": z.string(),
     "schema": ItemsClassSchema,
-});
+}).strict();
 export type Purple200 = z.infer<typeof Purple200Schema>;
 
 export const Fluffy200Schema = z.object({
     "description": z.string(),
     "schema": PurpleSchemaSchema,
-});
+}).strict();
 export type Fluffy200 = z.infer<typeof Fluffy200Schema>;
 
 export const DefinitionsSchema = z.object({
@@ -152,17 +152,17 @@ export const DefinitionsSchema = z.object({
     "Rate": ArticleSchema,
     "Report": ReportSchema,
     "Taxonomy": TaxonomySchema,
-});
+}).strict();
 export type Definitions = z.infer<typeof DefinitionsSchema>;
 
 export const PurpleResponsesSchema = z.object({
     "200": Purple200Schema,
-});
+}).strict();
 export type PurpleResponses = z.infer<typeof PurpleResponsesSchema>;
 
 export const FluffyResponsesSchema = z.object({
     "200": Fluffy200Schema,
-});
+}).strict();
 export type FluffyResponses = z.infer<typeof FluffyResponsesSchema>;
 
 export const BusinessServiceProvidersSearchGetSchema = z.object({
@@ -171,7 +171,7 @@ export const BusinessServiceProvidersSearchGetSchema = z.object({
     "responses": PurpleResponsesSchema,
     "summary": z.string(),
     "tags": z.array(z.string()),
-});
+}).strict();
 export type BusinessServiceProvidersSearchGet = z.infer<typeof BusinessServiceProvidersSearchGetSchema>;
 
 export const ConsolidatedScreeningListSearchGetSchema = z.object({
@@ -180,17 +180,17 @@ export const ConsolidatedScreeningListSearchGetSchema = z.object({
     "responses": FluffyResponsesSchema,
     "summary": z.string(),
     "tags": z.array(z.string()),
-});
+}).strict();
 export type ConsolidatedScreeningListSearchGet = z.infer<typeof ConsolidatedScreeningListSearchGetSchema>;
 
 export const BusinessServiceProvidersSearchClassSchema = z.object({
     "get": BusinessServiceProvidersSearchGetSchema,
-});
+}).strict();
 export type BusinessServiceProvidersSearchClass = z.infer<typeof BusinessServiceProvidersSearchClassSchema>;
 
 export const ConsolidatedScreeningListSearchClassSchema = z.object({
     "get": ConsolidatedScreeningListSearchGetSchema,
-});
+}).strict();
 export type ConsolidatedScreeningListSearchClass = z.infer<typeof ConsolidatedScreeningListSearchClassSchema>;
 
 export const PathsSchema = z.object({
@@ -207,7 +207,7 @@ export const PathsSchema = z.object({
     "/trade_articles/search": ConsolidatedScreeningListSearchClassSchema,
     "/trade_events/search": ConsolidatedScreeningListSearchClassSchema,
     "/trade_leads/search": ConsolidatedScreeningListSearchClassSchema,
-});
+}).strict();
 export type Paths = z.infer<typeof PathsSchema>;
 
 export const TopLevelSchema = z.object({
@@ -219,5 +219,5 @@ export const TopLevelSchema = z.object({
     "produces": z.array(z.string()),
     "schemes": z.array(z.string()),
     "swagger": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/77392.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/77392.json/default/TopLevel.ts
index 21a4c60..d843d06 100644
--- a/base/typescript-zod/test/inputs/json/misc/77392.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/77392.json/default/TopLevel.ts
@@ -33,7 +33,7 @@ export const TopLevelElementSchema = z.object({
     "pha": PhaSchema,
     "q_au_1": z.string(),
     "q_au_2": z.string().optional(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/7d397.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/7d397.json/default/TopLevel.ts
index 6872550..fd919a2 100644
--- a/base/typescript-zod/test/inputs/json/misc/7d397.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/7d397.json/default/TopLevel.ts
@@ -15,14 +15,14 @@ export type In = z.infer<typeof InSchema>;
 export const PropertySchema = z.object({
     "description": z.string(),
     "type": TypeSchema,
-});
+}).strict();
 export type Property = z.infer<typeof PropertySchema>;
 
 export const InfoSchema = z.object({
     "description": z.string(),
     "title": z.string(),
     "version": z.string(),
-});
+}).strict();
 export type Info = z.infer<typeof InfoSchema>;
 
 export const ParameterSchema = z.object({
@@ -32,39 +32,39 @@ export const ParameterSchema = z.object({
     "name": z.string(),
     "required": z.boolean(),
     "type": TypeSchema,
-});
+}).strict();
 export type Parameter = z.infer<typeof ParameterSchema>;
 
 export const ItemsSchema = z.object({
     "$ref": z.string(),
-});
+}).strict();
 export type Items = z.infer<typeof ItemsSchema>;
 
 export const ListSchema = z.object({
     "properties": z.record(z.string(), PropertySchema),
-});
+}).strict();
 export type List = z.infer<typeof ListSchema>;
 
 export const SchemaSchema = z.object({
     "items": ItemsSchema,
     "type": z.string(),
-});
+}).strict();
 export type Schema = z.infer<typeof SchemaSchema>;
 
 export const DefinitionsSchema = z.object({
     "List": ListSchema,
-});
+}).strict();
 export type Definitions = z.infer<typeof DefinitionsSchema>;
 
 export const The200Schema = z.object({
     "description": z.string(),
     "schema": SchemaSchema,
-});
+}).strict();
 export type The200 = z.infer<typeof The200Schema>;
 
 export const ResponsesSchema = z.object({
     "200": The200Schema,
-});
+}).strict();
 export type Responses = z.infer<typeof ResponsesSchema>;
 
 export const GetSchema = z.object({
@@ -73,17 +73,17 @@ export const GetSchema = z.object({
     "responses": ResponsesSchema,
     "summary": z.string(),
     "tags": z.array(z.string()),
-});
+}).strict();
 export type Get = z.infer<typeof GetSchema>;
 
 export const ConsolidatedScreeningListSearchSchema = z.object({
     "get": GetSchema,
-});
+}).strict();
 export type ConsolidatedScreeningListSearch = z.infer<typeof ConsolidatedScreeningListSearchSchema>;
 
 export const PathsSchema = z.object({
     "/consolidated_screening_list/search": ConsolidatedScreeningListSearchSchema,
-});
+}).strict();
 export type Paths = z.infer<typeof PathsSchema>;
 
 export const TopLevelSchema = z.object({
@@ -95,5 +95,5 @@ export const TopLevelSchema = z.object({
     "produces": z.array(z.string()),
     "schemes": z.array(z.string()),
     "swagger": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/7d722.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/7d722.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/7d722.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/7d722.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/7df41.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/7df41.json/default/TopLevel.ts
index ebd7655..fd02906 100644
--- a/base/typescript-zod/test/inputs/json/misc/7df41.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/7df41.json/default/TopLevel.ts
@@ -5,7 +5,7 @@ export const PcSchema = z.object({
     "count": z.number().int(),
     "label": z.string(),
     "peak24": z.number().int(),
-});
+}).strict();
 export type Pc = z.infer<typeof PcSchema>;
 
 export const TopLevelSchema = z.object({
@@ -14,5 +14,5 @@ export const TopLevelSchema = z.object({
     "ps4": PcSchema,
     "xbox": PcSchema,
     "xone": PcSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/7dfa6.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/7dfa6.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/7dfa6.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/7dfa6.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/7eb30.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/7eb30.json/default/TopLevel.ts
index 3f1facc..b6e0977 100644
--- a/base/typescript-zod/test/inputs/json/misc/7eb30.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/7eb30.json/default/TopLevel.ts
@@ -37,7 +37,7 @@ export const GroupSchema = z.object({
     "english": EnglishSchema,
     "thai": ThaiSchema,
     "website": z.string(),
-});
+}).strict();
 export type Group = z.infer<typeof GroupSchema>;
 
 export const ResultSchema = z.object({
@@ -55,7 +55,7 @@ export const ResultSchema = z.object({
     "today_screens": z.number().int(),
     "url": z.string(),
     "website": z.string(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
@@ -63,5 +63,5 @@ export const TopLevelSchema = z.object({
     "next": z.string(),
     "previous": z.null(),
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/7f568.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/7f568.json/default/TopLevel.ts
index 9fab307..9f67329 100644
--- a/base/typescript-zod/test/inputs/json/misc/7f568.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/7f568.json/default/TopLevel.ts
@@ -18,7 +18,7 @@ export const FileSchema = z.object({
     "raw_url": z.string(),
     "size": z.number().int(),
     "type": TypeSchema,
-});
+}).strict();
 export type File = z.infer<typeof FileSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -38,7 +38,7 @@ export const TopLevelElementSchema = z.object({
     "updated_at": z.coerce.date(),
     "url": z.string(),
     "user": z.null(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/7fbfb.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/7fbfb.json/default/TopLevel.ts
index ecc13a3..13bc318 100644
--- a/base/typescript-zod/test/inputs/json/misc/7fbfb.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/7fbfb.json/default/TopLevel.ts
@@ -17,7 +17,7 @@ export type Value = z.infer<typeof ValueSchema>;
 export const CountrySchema = z.object({
     "id": IdSchema,
     "value": ValueSchema,
-});
+}).strict();
 export type Country = z.infer<typeof CountrySchema>;
 
 export const FluffyTopLevelSchema = z.object({
@@ -25,7 +25,7 @@ export const FluffyTopLevelSchema = z.object({
     "pages": z.number().int(),
     "per_page": z.string().regex(/^-?\d+$/),
     "total": z.number().int(),
-});
+}).strict();
 export type FluffyTopLevel = z.infer<typeof FluffyTopLevelSchema>;
 
 export const PurpleTopLevelSchema = z.object({
@@ -34,7 +34,7 @@ export const PurpleTopLevelSchema = z.object({
     "decimal": z.string().regex(/^-?\d+$/),
     "indicator": CountrySchema,
     "value": z.string(),
-});
+}).strict();
 export type PurpleTopLevel = z.infer<typeof PurpleTopLevelSchema>;
 
 export const TopLevelSchema = z.array(z.union([z.array(PurpleTopLevelSchema), FluffyTopLevelSchema]));
diff --git a/base/typescript-zod/test/inputs/json/misc/80aff.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/80aff.json/default/TopLevel.ts
index ee6ff28..b9f585e 100644
--- a/base/typescript-zod/test/inputs/json/misc/80aff.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/80aff.json/default/TopLevel.ts
@@ -2,7 +2,7 @@ import * as z from "zod";
 
 
 export const FacetsSchema = z.object({
-});
+}).strict();
 export type Facets = z.infer<typeof FacetsSchema>;
 
 export const ResultSchema = z.object({
@@ -13,7 +13,7 @@ export const ResultSchema = z.object({
     "parent": z.union([z.null(), z.number().int()]),
     "updated_at": z.coerce.date(),
     "uri": z.string(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
@@ -24,5 +24,5 @@ export const TopLevelSchema = z.object({
     "offset": z.number().int(),
     "previous": z.boolean(),
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/82509.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/82509.json/default/TopLevel.ts
index 8d5e574..f071bb0 100644
--- a/base/typescript-zod/test/inputs/json/misc/82509.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/82509.json/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "origin": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/8592b.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/8592b.json/default/TopLevel.ts
index 596b205..76f2328 100644
--- a/base/typescript-zod/test/inputs/json/misc/8592b.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/8592b.json/default/TopLevel.ts
@@ -44,14 +44,14 @@ export const KindSchema = z.enum([
 export type Kind = z.infer<typeof KindSchema>;
 
 export const MediaEmbedSchema = z.object({
-});
+}).strict();
 export type MediaEmbed = z.infer<typeof MediaEmbedSchema>;
 
 export const SourceSchema = z.object({
     "height": z.number().int(),
     "url": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Source = z.infer<typeof SourceSchema>;
 
 export const ImageSchema = z.object({
@@ -59,13 +59,13 @@ export const ImageSchema = z.object({
     "resolutions": z.array(SourceSchema),
     "source": SourceSchema,
     "variants": MediaEmbedSchema,
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const PreviewSchema = z.object({
     "enabled": z.boolean(),
     "images": z.array(ImageSchema),
-});
+}).strict();
 export type Preview = z.infer<typeof PreviewSchema>;
 
 export const ChildDataSchema = z.object({
@@ -133,13 +133,13 @@ export const ChildDataSchema = z.object({
     "user_reports": z.array(z.any()),
     "view_count": z.null(),
     "visited": z.boolean(),
-});
+}).strict();
 export type ChildData = z.infer<typeof ChildDataSchema>;
 
 export const ChildSchema = z.object({
     "data": ChildDataSchema,
     "kind": KindSchema,
-});
+}).strict();
 export type Child = z.infer<typeof ChildSchema>;
 
 export const TopLevelDataSchema = z.object({
@@ -147,11 +147,11 @@ export const TopLevelDataSchema = z.object({
     "before": z.null(),
     "children": z.array(ChildSchema),
     "modhash": z.string(),
-});
+}).strict();
 export type TopLevelData = z.infer<typeof TopLevelDataSchema>;
 
 export const TopLevelSchema = z.object({
     "data": TopLevelDataSchema,
     "kind": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/88130.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/88130.json/default/TopLevel.ts
index 82adaab..e046c65 100644
--- a/base/typescript-zod/test/inputs/json/misc/88130.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/88130.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -12,7 +12,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -21,7 +21,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -29,7 +29,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -39,19 +39,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -59,14 +59,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -79,7 +79,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -96,12 +96,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -109,10 +109,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/8a62c.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/8a62c.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/8a62c.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/8a62c.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/908db.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/908db.json/default/TopLevel.ts
index 18db732..1e7ae30 100644
--- a/base/typescript-zod/test/inputs/json/misc/908db.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/908db.json/default/TopLevel.ts
@@ -4,15 +4,15 @@ import * as z from "zod";
 export const StateStateSchema = z.object({
     "state_id": z.string(),
     "state_name": z.string(),
-});
+}).strict();
 export type StateState = z.infer<typeof StateStateSchema>;
 
 export const StateElementSchema = z.object({
     "state": StateStateSchema,
-});
+}).strict();
 export type StateElement = z.infer<typeof StateElementSchema>;
 
 export const TopLevelSchema = z.object({
     "states": z.array(StateElementSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/9617f.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/9617f.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/9617f.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/9617f.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/96f7c.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/96f7c.json/default/TopLevel.ts
index 1ac15d1..37072d1 100644
--- a/base/typescript-zod/test/inputs/json/misc/96f7c.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/96f7c.json/default/TopLevel.ts
@@ -8,5 +8,5 @@ export const TopLevelSchema = z.object({
     "importer": z.array(z.string()),
     "pages": z.array(z.string()),
     "verifiable_password_authentication": z.boolean(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/9847b.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/9847b.json/default/TopLevel.ts
index 0766c70..9c3d6c0 100644
--- a/base/typescript-zod/test/inputs/json/misc/9847b.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/9847b.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const TopLevelElementSchema = z.object({
     "id": z.string(),
     "name": z.string(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/9929c.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/9929c.json/default/TopLevel.ts
index 82adaab..e046c65 100644
--- a/base/typescript-zod/test/inputs/json/misc/9929c.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/9929c.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -12,7 +12,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -21,7 +21,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -29,7 +29,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -39,19 +39,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -59,14 +59,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -79,7 +79,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -96,12 +96,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -109,10 +109,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/996bd.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/996bd.json/default/TopLevel.ts
index ae2985b..310cd1a 100644
--- a/base/typescript-zod/test/inputs/json/misc/996bd.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/996bd.json/default/TopLevel.ts
@@ -34,20 +34,20 @@ export type Title = z.infer<typeof TitleSchema>;
 export const IdentifierSchema = z.object({
     "identifier": z.string(),
     "scheme": SchemeSchema,
-});
+}).strict();
 export type Identifier = z.infer<typeof IdentifierSchema>;
 
 export const LinkSchema = z.object({
     "note": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Link = z.infer<typeof LinkSchema>;
 
 export const TextSchema = z.object({
     "media_type": MediaTypeSchema,
     "title": TitleSchema,
     "url": z.string(),
-});
+}).strict();
 export type Text = z.infer<typeof TextSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -59,7 +59,7 @@ export const TopLevelElementSchema = z.object({
     "other_names": z.array(z.any()),
     "superseded_by": z.union([z.null(), z.string()]),
     "text": z.array(TextSchema),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/9a503.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/9a503.json/default/TopLevel.ts
index 7816b02..79dd138 100644
--- a/base/typescript-zod/test/inputs/json/misc/9a503.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/9a503.json/default/TopLevel.ts
@@ -11,20 +11,20 @@ export type Keyword = z.infer<typeof KeywordSchema>;
 export const IdentifierSchema = z.object({
     "identifier": z.string(),
     "scheme": z.string(),
-});
+}).strict();
 export type Identifier = z.infer<typeof IdentifierSchema>;
 
 export const LinkSchema = z.object({
     "note": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Link = z.infer<typeof LinkSchema>;
 
 export const TextSchema = z.object({
     "media_type": z.string(),
     "title": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Text = z.infer<typeof TextSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -36,7 +36,7 @@ export const TopLevelElementSchema = z.object({
     "other_names": z.array(z.any()),
     "superseded_by": z.null(),
     "text": z.array(TextSchema),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/9ac3b.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/9ac3b.json/default/TopLevel.ts
index 75b5c3a..2201366 100644
--- a/base/typescript-zod/test/inputs/json/misc/9ac3b.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/9ac3b.json/default/TopLevel.ts
@@ -15,7 +15,7 @@ export const TitleSchema = z.enum([
 export type Title = z.infer<typeof TitleSchema>;
 
 export const FacetsSchema = z.object({
-});
+}).strict();
 export type Facets = z.infer<typeof FacetsSchema>;
 
 export const ResultSchema = z.object({
@@ -30,7 +30,7 @@ export const ResultSchema = z.object({
     "title": z.union([z.null(), TitleSchema]),
     "updated_at": z.coerce.date(),
     "uri": z.string(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
@@ -41,5 +41,5 @@ export const TopLevelSchema = z.object({
     "offset": z.number().int(),
     "previous": z.boolean(),
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/9eed5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/9eed5.json/default/TopLevel.ts
index a56332f..f8bf16b 100644
--- a/base/typescript-zod/test/inputs/json/misc/9eed5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/9eed5.json/default/TopLevel.ts
@@ -10,20 +10,20 @@ export type Keyword = z.infer<typeof KeywordSchema>;
 export const IdentifierSchema = z.object({
     "identifier": z.string(),
     "scheme": z.string(),
-});
+}).strict();
 export type Identifier = z.infer<typeof IdentifierSchema>;
 
 export const LinkSchema = z.object({
     "note": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Link = z.infer<typeof LinkSchema>;
 
 export const TextSchema = z.object({
     "media_type": z.string(),
     "title": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Text = z.infer<typeof TextSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -35,7 +35,7 @@ export const TopLevelElementSchema = z.object({
     "other_names": z.array(z.any()),
     "superseded_by": z.null(),
     "text": z.array(TextSchema),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/a0496.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/a0496.json/default/TopLevel.ts
index 492033a..7c2ed3f 100644
--- a/base/typescript-zod/test/inputs/json/misc/a0496.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/a0496.json/default/TopLevel.ts
@@ -2,7 +2,7 @@ import * as z from "zod";
 
 
 export const ErrorsSchema = z.object({
-});
+}).strict();
 export type Errors = z.infer<typeof ErrorsSchema>;
 
 export const TopLevelSchema = z.object({
@@ -23,5 +23,5 @@ export const TopLevelSchema = z.object({
     "type": z.string(),
     "updated_at": z.coerce.date(),
     "urlize_name": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/a1eca.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/a1eca.json/default/TopLevel.ts
index 82adaab..e046c65 100644
--- a/base/typescript-zod/test/inputs/json/misc/a1eca.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/a1eca.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -12,7 +12,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -21,7 +21,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -29,7 +29,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -39,19 +39,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -59,14 +59,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -79,7 +79,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -96,12 +96,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -109,10 +109,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/a3d8c.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/a3d8c.json/default/TopLevel.ts
index 33e6fe6..b347539 100644
--- a/base/typescript-zod/test/inputs/json/misc/a3d8c.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/a3d8c.json/default/TopLevel.ts
@@ -11,35 +11,35 @@ export type TypeName = z.infer<typeof TypeNameSchema>;
 export const TopSchema = z.object({
     "count": z.number().int(),
     "item": z.string(),
-});
+}).strict();
 export type Top = z.infer<typeof TopSchema>;
 
 export const QuerySchema = z.object({
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const GrantSchema = z.object({
     "flags": z.array(z.string()),
     "inherited": z.boolean(),
     "type": z.string(),
-});
+}).strict();
 export type Grant = z.infer<typeof GrantSchema>;
 
 export const LicenseSchema = z.object({
     "name": z.string(),
-});
+}).strict();
 export type License = z.infer<typeof LicenseSchema>;
 
 export const VisibleSchema = z.object({
     "table": z.boolean(),
-});
+}).strict();
 export type Visible = z.infer<typeof VisibleSchema>;
 
 export const OwnerSchema = z.object({
     "displayName": z.string(),
     "id": z.string(),
     "screenName": z.string(),
-});
+}).strict();
 export type Owner = z.infer<typeof OwnerSchema>;
 
 export const CachedContentsSchema = z.object({
@@ -50,12 +50,12 @@ export const CachedContentsSchema = z.object({
     "smallest": z.string(),
     "sum": z.string().regex(/^-?\d+$/).optional(),
     "top": z.array(TopSchema),
-});
+}).strict();
 export type CachedContents = z.infer<typeof CachedContentsSchema>;
 
 export const RenderTypeConfigSchema = z.object({
     "visible": VisibleSchema,
-});
+}).strict();
 export type RenderTypeConfig = z.infer<typeof RenderTypeConfigSchema>;
 
 export const ColumnSchema = z.object({
@@ -70,7 +70,7 @@ export const ColumnSchema = z.object({
     "renderTypeName": TypeNameSchema,
     "tableColumnId": z.number().int().optional(),
     "width": z.number().int().optional(),
-});
+}).strict();
 export type Column = z.infer<typeof ColumnSchema>;
 
 export const MetadataSchema = z.object({
@@ -79,7 +79,7 @@ export const MetadataSchema = z.object({
     "rdfSubject": z.string().regex(/^-?\d+$/),
     "renderTypeConfig": RenderTypeConfigSchema,
     "rowIdentifier": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Metadata = z.infer<typeof MetadataSchema>;
 
 export const ViewSchema = z.object({
@@ -120,16 +120,16 @@ export const ViewSchema = z.object({
     "viewCount": z.number().int(),
     "viewLastModified": z.number().int(),
     "viewType": z.string(),
-});
+}).strict();
 export type View = z.infer<typeof ViewSchema>;
 
 export const MetaSchema = z.object({
     "view": ViewSchema,
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(z.array(z.union([z.null(), z.number().int(), z.string()]))),
     "meta": MetaSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/a45b0.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/a45b0.json/default/TopLevel.ts
index b8a003b..f51fac7 100644
--- a/base/typescript-zod/test/inputs/json/misc/a45b0.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/a45b0.json/default/TopLevel.ts
@@ -13,7 +13,7 @@ export const TopLevelElementSchema = z.object({
     "males": z.number().int(),
     "total": z.number().int(),
     "year": z.number().int(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/a71df.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/a71df.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/a71df.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/a71df.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/a9691.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/a9691.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/a9691.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/a9691.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/ab0d1.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/ab0d1.json/default/TopLevel.ts
index b8a003b..f51fac7 100644
--- a/base/typescript-zod/test/inputs/json/misc/ab0d1.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/ab0d1.json/default/TopLevel.ts
@@ -13,7 +13,7 @@ export const TopLevelElementSchema = z.object({
     "males": z.number().int(),
     "total": z.number().int(),
     "year": z.number().int(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/abb4b.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/abb4b.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/abb4b.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/abb4b.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/ac944.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/ac944.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/ac944.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/ac944.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/ad8be.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/ad8be.json/default/TopLevel.ts
index 0254ea4..913fd15 100644
--- a/base/typescript-zod/test/inputs/json/misc/ad8be.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/ad8be.json/default/TopLevel.ts
@@ -55,26 +55,26 @@ export type Title = z.infer<typeof TitleSchema>;
 export const IdentifierSchema = z.object({
     "identifier": z.string(),
     "scheme": SchemeSchema,
-});
+}).strict();
 export type Identifier = z.infer<typeof IdentifierSchema>;
 
 export const LinkSchema = z.object({
     "note": NoteSchema,
     "url": z.string(),
-});
+}).strict();
 export type Link = z.infer<typeof LinkSchema>;
 
 export const OtherNameSchema = z.object({
     "name": z.string(),
     "note": z.union([z.null(), z.string()]),
-});
+}).strict();
 export type OtherName = z.infer<typeof OtherNameSchema>;
 
 export const TextSchema = z.object({
     "media_type": MediaTypeSchema,
     "title": TitleSchema,
     "url": z.string(),
-});
+}).strict();
 export type Text = z.infer<typeof TextSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -86,7 +86,7 @@ export const TopLevelElementSchema = z.object({
     "other_names": z.array(OtherNameSchema),
     "superseded_by": z.union([z.null(), z.string()]),
     "text": z.array(TextSchema),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/ae7f0.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/ae7f0.json/default/TopLevel.ts
index 7b14a27..352435b 100644
--- a/base/typescript-zod/test/inputs/json/misc/ae7f0.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/ae7f0.json/default/TopLevel.ts
@@ -37,7 +37,7 @@ export const KindSchema = z.enum([
 export type Kind = z.infer<typeof KindSchema>;
 
 export const MediaEmbedSchema = z.object({
-});
+}).strict();
 export type MediaEmbed = z.infer<typeof MediaEmbedSchema>;
 
 export const ChildDataSchema = z.object({
@@ -101,13 +101,13 @@ export const ChildDataSchema = z.object({
     "user_reports": z.array(z.any()),
     "view_count": z.null(),
     "visited": z.boolean(),
-});
+}).strict();
 export type ChildData = z.infer<typeof ChildDataSchema>;
 
 export const ChildSchema = z.object({
     "data": ChildDataSchema,
     "kind": KindSchema,
-});
+}).strict();
 export type Child = z.infer<typeof ChildSchema>;
 
 export const TopLevelDataSchema = z.object({
@@ -115,11 +115,11 @@ export const TopLevelDataSchema = z.object({
     "before": z.null(),
     "children": z.array(ChildSchema),
     "modhash": z.string(),
-});
+}).strict();
 export type TopLevelData = z.infer<typeof TopLevelDataSchema>;
 
 export const TopLevelSchema = z.object({
     "data": TopLevelDataSchema,
     "kind": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/ae9ca.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/ae9ca.json/default/TopLevel.ts
index 1e60e21..21cdccc 100644
--- a/base/typescript-zod/test/inputs/json/misc/ae9ca.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/ae9ca.json/default/TopLevel.ts
@@ -38,7 +38,7 @@ export type FeatureType = z.infer<typeof FeatureTypeSchema>;
 export const GeometrySchema = z.object({
     "coordinates": z.array(z.number()),
     "type": GeometryTypeSchema,
-});
+}).strict();
 export type Geometry = z.infer<typeof GeometrySchema>;
 
 export const PropertiesSchema = z.object({
@@ -52,19 +52,19 @@ export const PropertiesSchema = z.object({
     "Number": z.string().regex(/^-?\d+$/),
     "Site Name": z.string(),
     "Ward": WardSchema,
-});
+}).strict();
 export type Properties = z.infer<typeof PropertiesSchema>;
 
 export const FeatureSchema = z.object({
     "geometry": GeometrySchema,
     "properties": PropertiesSchema,
     "type": FeatureTypeSchema,
-});
+}).strict();
 export type Feature = z.infer<typeof FeatureSchema>;
 
 export const TopLevelSchema = z.object({
     "features": z.array(FeatureSchema),
     "name": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/af2d1.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/af2d1.json/default/TopLevel.ts
index 2f6ac0d..de428a1 100644
--- a/base/typescript-zod/test/inputs/json/misc/af2d1.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/af2d1.json/default/TopLevel.ts
@@ -74,13 +74,13 @@ export type FeatureType = z.infer<typeof FeatureTypeSchema>;
 
 export const CrsPropertiesSchema = z.object({
     "name": z.string(),
-});
+}).strict();
 export type CrsProperties = z.infer<typeof CrsPropertiesSchema>;
 
 export const GeometrySchema = z.object({
     "coordinates": z.array(z.array(z.array(z.array(z.number())))),
     "type": GeometryTypeSchema,
-});
+}).strict();
 export type Geometry = z.infer<typeof GeometrySchema>;
 
 export const FeaturePropertiesSchema = z.object({
@@ -122,13 +122,13 @@ export const FeaturePropertiesSchema = z.object({
     "update_dat": z.string(),
     "updatedate": z.null(),
     "updateuser": z.null(),
-});
+}).strict();
 export type FeatureProperties = z.infer<typeof FeaturePropertiesSchema>;
 
 export const CrsSchema = z.object({
     "properties": CrsPropertiesSchema,
     "type": z.string(),
-});
+}).strict();
 export type Crs = z.infer<typeof CrsSchema>;
 
 export const FeatureSchema = z.object({
@@ -137,7 +137,7 @@ export const FeatureSchema = z.object({
     "id": z.string(),
     "properties": FeaturePropertiesSchema,
     "type": FeatureTypeSchema,
-});
+}).strict();
 export type Feature = z.infer<typeof FeatureSchema>;
 
 export const TopLevelSchema = z.object({
@@ -145,5 +145,5 @@ export const TopLevelSchema = z.object({
     "features": z.array(FeatureSchema),
     "totalFeatures": z.number().int(),
     "type": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/b4865.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/b4865.json/default/TopLevel.ts
index f968c76..a8d6da7 100644
--- a/base/typescript-zod/test/inputs/json/misc/b4865.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/b4865.json/default/TopLevel.ts
@@ -22,7 +22,7 @@ export type Nametype = z.infer<typeof NametypeSchema>;
 export const GeolocationSchema = z.object({
     "coordinates": z.array(z.number()),
     "type": TypeSchema,
-});
+}).strict();
 export type Geolocation = z.infer<typeof GeolocationSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -38,7 +38,7 @@ export const TopLevelElementSchema = z.object({
     "reclat": z.string().optional(),
     "reclong": z.string().optional(),
     "year": z.coerce.date().optional(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/b6f2c.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/b6f2c.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/b6f2c.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/b6f2c.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/b6fe5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/b6fe5.json/default/TopLevel.ts
index 3109a7d..be892ed 100644
--- a/base/typescript-zod/test/inputs/json/misc/b6fe5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/b6fe5.json/default/TopLevel.ts
@@ -6,5 +6,5 @@ export const TopLevelSchema = z.object({
     "movie": z.string(),
     "movie-image": z.string(),
     "theater": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/b9f64.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/b9f64.json/default/TopLevel.ts
index fcde3b6..bb47ba9 100644
--- a/base/typescript-zod/test/inputs/json/misc/b9f64.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/b9f64.json/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "user-agent": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/bb1ec.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/bb1ec.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/bb1ec.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/bb1ec.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/be234.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/be234.json/default/TopLevel.ts
index 56debe5..049552c 100644
--- a/base/typescript-zod/test/inputs/json/misc/be234.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/be234.json/default/TopLevel.ts
@@ -61,7 +61,7 @@ export const OembedSchema = z.object({
     "type": z.string(),
     "version": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Oembed = z.infer<typeof OembedSchema>;
 
 export const MediaEmbedSchema = z.object({
@@ -69,32 +69,32 @@ export const MediaEmbedSchema = z.object({
     "height": z.number().int().optional(),
     "scrolling": z.boolean().optional(),
     "width": z.number().int().optional(),
-});
+}).strict();
 export type MediaEmbed = z.infer<typeof MediaEmbedSchema>;
 
 export const SourceSchema = z.object({
     "height": z.number().int(),
     "url": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Source = z.infer<typeof SourceSchema>;
 
 export const GifSchema = z.object({
     "resolutions": z.array(SourceSchema),
     "source": SourceSchema,
-});
+}).strict();
 export type Gif = z.infer<typeof GifSchema>;
 
 export const MediaSchema = z.object({
     "oembed": OembedSchema,
     "type": DomainSchema,
-});
+}).strict();
 export type Media = z.infer<typeof MediaSchema>;
 
 export const VariantsSchema = z.object({
     "gif": GifSchema.optional(),
     "mp4": GifSchema.optional(),
-});
+}).strict();
 export type Variants = z.infer<typeof VariantsSchema>;
 
 export const ImageSchema = z.object({
@@ -102,13 +102,13 @@ export const ImageSchema = z.object({
     "resolutions": z.array(SourceSchema),
     "source": SourceSchema,
     "variants": VariantsSchema,
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const PreviewSchema = z.object({
     "enabled": z.boolean(),
     "images": z.array(ImageSchema),
-});
+}).strict();
 export type Preview = z.infer<typeof PreviewSchema>;
 
 export const ChildDataSchema = z.object({
@@ -176,13 +176,13 @@ export const ChildDataSchema = z.object({
     "user_reports": z.array(z.any()),
     "view_count": z.null(),
     "visited": z.boolean(),
-});
+}).strict();
 export type ChildData = z.infer<typeof ChildDataSchema>;
 
 export const ChildSchema = z.object({
     "data": ChildDataSchema,
     "kind": KindSchema,
-});
+}).strict();
 export type Child = z.infer<typeof ChildSchema>;
 
 export const TopLevelDataSchema = z.object({
@@ -190,11 +190,11 @@ export const TopLevelDataSchema = z.object({
     "before": z.null(),
     "children": z.array(ChildSchema),
     "modhash": z.string(),
-});
+}).strict();
 export type TopLevelData = z.infer<typeof TopLevelDataSchema>;
 
 export const TopLevelSchema = z.object({
     "data": TopLevelDataSchema,
     "kind": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/c0356.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/c0356.json/default/TopLevel.ts
index fb32163..a4bdb00 100644
--- a/base/typescript-zod/test/inputs/json/misc/c0356.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/c0356.json/default/TopLevel.ts
@@ -4,18 +4,18 @@ import * as z from "zod";
 export const DatumSchema = z.object({
     "anomaly": z.string(),
     "value": z.string(),
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const DescriptionSchema = z.object({
     "base_period": z.string(),
     "missing": z.number().int(),
     "title": z.string(),
-});
+}).strict();
 export type Description = z.infer<typeof DescriptionSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.record(z.string(), DatumSchema),
     "description": DescriptionSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/c0a3a.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/c0a3a.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/c0a3a.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/c0a3a.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/c3303.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/c3303.json/default/TopLevel.ts
index 68cc95e..c9f1097 100644
--- a/base/typescript-zod/test/inputs/json/misc/c3303.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/c3303.json/default/TopLevel.ts
@@ -26,7 +26,7 @@ export const The480_WStillSchema = z.object({
     "size": z.string().regex(/^-?\d+$/).optional(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type The480_WStill = z.infer<typeof The480_WStillSchema>;
 
 export const DownsizedSmallSchema = z.object({
@@ -34,7 +34,7 @@ export const DownsizedSmallSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type DownsizedSmall = z.infer<typeof DownsizedSmallSchema>;
 
 export const FixedHeightSchema = z.object({
@@ -48,13 +48,13 @@ export const FixedHeightSchema = z.object({
     "webp": z.string(),
     "webp_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type FixedHeight = z.infer<typeof FixedHeightSchema>;
 
 export const LoopingSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Looping = z.infer<typeof LoopingSchema>;
 
 export const UserSchema = z.object({
@@ -63,21 +63,21 @@ export const UserSchema = z.object({
     "display_name": z.string(),
     "profile_url": z.string(),
     "username": UsernameSchema,
-});
+}).strict();
 export type User = z.infer<typeof UserSchema>;
 
 export const MetaSchema = z.object({
     "msg": z.string(),
     "response_id": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const PaginationSchema = z.object({
     "count": z.number().int(),
     "offset": z.number().int(),
     "total_count": z.number().int(),
-});
+}).strict();
 export type Pagination = z.infer<typeof PaginationSchema>;
 
 export const ImagesSchema = z.object({
@@ -104,7 +104,7 @@ export const ImagesSchema = z.object({
     "preview_gif": The480_WStillSchema,
     "preview_webp": The480_WStillSchema,
     "480w_still": The480_WStillSchema.optional(),
-});
+}).strict();
 export type Images = z.infer<typeof ImagesSchema>;
 
 export const DatumSchema = z.object({
@@ -126,12 +126,12 @@ export const DatumSchema = z.object({
     "url": z.string(),
     "user": UserSchema.optional(),
     "username": UsernameSchema,
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(DatumSchema),
     "meta": MetaSchema,
     "pagination": PaginationSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/c6cfd.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/c6cfd.json/default/TopLevel.ts
index 3f6a884..b086035 100644
--- a/base/typescript-zod/test/inputs/json/misc/c6cfd.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/c6cfd.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const CountrySchema = z.object({
     "code": z.string(),
     "name": z.string(),
-});
+}).strict();
 export type Country = z.infer<typeof CountrySchema>;
 
 export const TopLevelSchema = z.object({
     "countries": z.array(CountrySchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/c8c7e.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/c8c7e.json/default/TopLevel.ts
index 0dfe609..c11aa05 100644
--- a/base/typescript-zod/test/inputs/json/misc/c8c7e.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/c8c7e.json/default/TopLevel.ts
@@ -17,7 +17,7 @@ export type Value = z.infer<typeof ValueSchema>;
 export const CountrySchema = z.object({
     "id": IdSchema,
     "value": ValueSchema,
-});
+}).strict();
 export type Country = z.infer<typeof CountrySchema>;
 
 export const FluffyTopLevelSchema = z.object({
@@ -25,7 +25,7 @@ export const FluffyTopLevelSchema = z.object({
     "pages": z.number().int(),
     "per_page": z.string().regex(/^-?\d+$/),
     "total": z.number().int(),
-});
+}).strict();
 export type FluffyTopLevel = z.infer<typeof FluffyTopLevelSchema>;
 
 export const PurpleTopLevelSchema = z.object({
@@ -34,7 +34,7 @@ export const PurpleTopLevelSchema = z.object({
     "decimal": z.string().regex(/^-?\d+$/),
     "indicator": CountrySchema,
     "value": z.string(),
-});
+}).strict();
 export type PurpleTopLevel = z.infer<typeof PurpleTopLevelSchema>;
 
 export const TopLevelSchema = z.array(z.union([z.array(PurpleTopLevelSchema), FluffyTopLevelSchema]));
diff --git a/base/typescript-zod/test/inputs/json/misc/cb0cc.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/cb0cc.json/default/TopLevel.ts
index ebd127b..b48e4c2 100644
--- a/base/typescript-zod/test/inputs/json/misc/cb0cc.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/cb0cc.json/default/TopLevel.ts
@@ -17,7 +17,7 @@ export const LaureateSchema = z.object({
     "motivation": z.string().optional(),
     "share": z.string().regex(/^-?\d+$/),
     "surname": z.string(),
-});
+}).strict();
 export type Laureate = z.infer<typeof LaureateSchema>;
 
 export const PrizeSchema = z.object({
@@ -25,10 +25,10 @@ export const PrizeSchema = z.object({
     "laureates": z.array(LaureateSchema),
     "overallMotivation": z.string().optional(),
     "year": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Prize = z.infer<typeof PrizeSchema>;
 
 export const TopLevelSchema = z.object({
     "prizes": z.array(PrizeSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/cb81e.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/cb81e.json/default/TopLevel.ts
index 1cebe60..a87c06f 100644
--- a/base/typescript-zod/test/inputs/json/misc/cb81e.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/cb81e.json/default/TopLevel.ts
@@ -6,11 +6,11 @@ export const DescriptionSchema = z.object({
     "missing": z.string(),
     "title": z.string(),
     "units": z.string(),
-});
+}).strict();
 export type Description = z.infer<typeof DescriptionSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.record(z.string(), z.string()),
     "description": DescriptionSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/ccd18.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/ccd18.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/ccd18.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/ccd18.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/cd238.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/cd238.json/default/TopLevel.ts
index 5048e7e..76831b7 100644
--- a/base/typescript-zod/test/inputs/json/misc/cd238.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/cd238.json/default/TopLevel.ts
@@ -11,14 +11,14 @@ export const StatusSchema = z.object({
     "reason": z.string(),
     "trend": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Status = z.infer<typeof StatusSchema>;
 
 export const MetaSchema = z.object({
     "credit": z.string(),
     "updated": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const WeatherSchema = z.object({
@@ -27,7 +27,7 @@ export const WeatherSchema = z.object({
     "visibility": z.number(),
     "weather": z.string(),
     "wind": z.string(),
-});
+}).strict();
 export type Weather = z.infer<typeof WeatherSchema>;
 
 export const TopLevelSchema = z.object({
@@ -39,5 +39,5 @@ export const TopLevelSchema = z.object({
     "state": z.string(),
     "status": StatusSchema,
     "weather": WeatherSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/cd463.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/cd463.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/cd463.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/cd463.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/cda6c.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/cda6c.json/default/TopLevel.ts
index 37c2116..28015fa 100644
--- a/base/typescript-zod/test/inputs/json/misc/cda6c.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/cda6c.json/default/TopLevel.ts
@@ -17,7 +17,7 @@ export type Value = z.infer<typeof ValueSchema>;
 export const CountrySchema = z.object({
     "id": IdSchema,
     "value": ValueSchema,
-});
+}).strict();
 export type Country = z.infer<typeof CountrySchema>;
 
 export const FluffyTopLevelSchema = z.object({
@@ -25,7 +25,7 @@ export const FluffyTopLevelSchema = z.object({
     "pages": z.number().int(),
     "per_page": z.string().regex(/^-?\d+$/),
     "total": z.number().int(),
-});
+}).strict();
 export type FluffyTopLevel = z.infer<typeof FluffyTopLevelSchema>;
 
 export const PurpleTopLevelSchema = z.object({
@@ -34,7 +34,7 @@ export const PurpleTopLevelSchema = z.object({
     "decimal": z.string().regex(/^-?\d+$/),
     "indicator": CountrySchema,
     "value": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type PurpleTopLevel = z.infer<typeof PurpleTopLevelSchema>;
 
 export const TopLevelSchema = z.array(z.union([z.array(PurpleTopLevelSchema), FluffyTopLevelSchema]));
diff --git a/base/typescript-zod/test/inputs/json/misc/cf0d8.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/cf0d8.json/default/TopLevel.ts
index 82adaab..e046c65 100644
--- a/base/typescript-zod/test/inputs/json/misc/cf0d8.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/cf0d8.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -12,7 +12,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -21,7 +21,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -29,7 +29,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -39,19 +39,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -59,14 +59,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -79,7 +79,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -96,12 +96,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -109,10 +109,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/cfbce.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/cfbce.json/default/TopLevel.ts
index f170e37..c32fdb2 100644
--- a/base/typescript-zod/test/inputs/json/misc/cfbce.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/cfbce.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "base": z.string(),
     "date": z.string(),
     "rates": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/d0908.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/d0908.json/default/TopLevel.ts
index 3c5684f..5c2148a 100644
--- a/base/typescript-zod/test/inputs/json/misc/d0908.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/d0908.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const TotalPopulationSchema = z.object({
     "date": z.string(),
     "population": z.number().int(),
-});
+}).strict();
 export type TotalPopulation = z.infer<typeof TotalPopulationSchema>;
 
 export const TopLevelSchema = z.object({
     "total_population": z.array(TotalPopulationSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/d23d5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/d23d5.json/default/TopLevel.ts
index 6039b5f..2a50510 100644
--- a/base/typescript-zod/test/inputs/json/misc/d23d5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/d23d5.json/default/TopLevel.ts
@@ -2,7 +2,7 @@ import * as z from "zod";
 
 
 export const FacetsSchema = z.object({
-});
+}).strict();
 export type Facets = z.infer<typeof FacetsSchema>;
 
 export const ResultSchema = z.object({
@@ -12,7 +12,7 @@ export const ResultSchema = z.object({
     "name": z.string(),
     "updated_at": z.coerce.date(),
     "uri": z.string(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
@@ -23,5 +23,5 @@ export const TopLevelSchema = z.object({
     "offset": z.number().int(),
     "previous": z.boolean(),
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/dbfb3.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/dbfb3.json/default/TopLevel.ts
index c6a4438..f68a1f4 100644
--- a/base/typescript-zod/test/inputs/json/misc/dbfb3.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/dbfb3.json/default/TopLevel.ts
@@ -10,7 +10,7 @@ export type Text = z.infer<typeof TextSchema>;
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -18,7 +18,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -27,7 +27,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -35,7 +35,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": TextSchema,
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -45,19 +45,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": TextSchema,
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -65,14 +65,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -85,7 +85,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -102,12 +102,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -115,10 +115,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/dc44f.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/dc44f.json/default/TopLevel.ts
index adcb59e..38336a1 100644
--- a/base/typescript-zod/test/inputs/json/misc/dc44f.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/dc44f.json/default/TopLevel.ts
@@ -106,13 +106,13 @@ export type Type = z.infer<typeof TypeSchema>;
 export const LegalityElementSchema = z.object({
     "format": FormatSchema,
     "legality": LegalityEnumSchema,
-});
+}).strict();
 export type LegalityElement = z.infer<typeof LegalityElementSchema>;
 
 export const RulingSchema = z.object({
     "date": z.string(),
     "text": z.string(),
-});
+}).strict();
 export type Ruling = z.infer<typeof RulingSchema>;
 
 export const CardSchema = z.object({
@@ -143,7 +143,7 @@ export const CardSchema = z.object({
     "type": z.string(),
     "types": z.array(TypeSchema),
     "variations": z.array(z.number().int()).optional(),
-});
+}).strict();
 export type Card = z.infer<typeof CardSchema>;
 
 export const TopLevelSchema = z.object({
@@ -158,5 +158,5 @@ export const TopLevelSchema = z.object({
     "name": z.string(),
     "releaseDate": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/dd1ce.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/dd1ce.json/default/TopLevel.ts
index adcb59e..38336a1 100644
--- a/base/typescript-zod/test/inputs/json/misc/dd1ce.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/dd1ce.json/default/TopLevel.ts
@@ -106,13 +106,13 @@ export type Type = z.infer<typeof TypeSchema>;
 export const LegalityElementSchema = z.object({
     "format": FormatSchema,
     "legality": LegalityEnumSchema,
-});
+}).strict();
 export type LegalityElement = z.infer<typeof LegalityElementSchema>;
 
 export const RulingSchema = z.object({
     "date": z.string(),
     "text": z.string(),
-});
+}).strict();
 export type Ruling = z.infer<typeof RulingSchema>;
 
 export const CardSchema = z.object({
@@ -143,7 +143,7 @@ export const CardSchema = z.object({
     "type": z.string(),
     "types": z.array(TypeSchema),
     "variations": z.array(z.number().int()).optional(),
-});
+}).strict();
 export type Card = z.infer<typeof CardSchema>;
 
 export const TopLevelSchema = z.object({
@@ -158,5 +158,5 @@ export const TopLevelSchema = z.object({
     "name": z.string(),
     "releaseDate": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/dec3a.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/dec3a.json/default/TopLevel.ts
index 9bf8c01..c9eb366 100644
--- a/base/typescript-zod/test/inputs/json/misc/dec3a.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/dec3a.json/default/TopLevel.ts
@@ -4,20 +4,20 @@ import * as z from "zod";
 export const ResponseInfoSchema = z.object({
     "developerMessage": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type ResponseInfo = z.infer<typeof ResponseInfoSchema>;
 
 export const ResultsetSchema = z.object({
     "count": z.number().int(),
     "page": z.number().int(),
     "pagesize": z.number().int(),
-});
+}).strict();
 export type Resultset = z.infer<typeof ResultsetSchema>;
 
 export const HiringOrgSchema = z.object({
     "name": z.string(),
     "uuid": z.string().uuid(),
-});
+}).strict();
 export type HiringOrg = z.infer<typeof HiringOrgSchema>;
 
 export const LocationSchema = z.object({
@@ -31,14 +31,14 @@ export const LocationSchema = z.object({
     "postal_code": z.string().regex(/^-?\d+$/),
     "sub_premise": z.null(),
     "thoroughfare": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const MetadataSchema = z.object({
     "executionTime": z.number(),
     "responseInfo": ResponseInfoSchema,
     "resultset": ResultsetSchema,
-});
+}).strict();
 export type Metadata = z.infer<typeof MetadataSchema>;
 
 export const ResultSchema = z.object({
@@ -64,11 +64,11 @@ export const ResultSchema = z.object({
     "url": z.string(),
     "uuid": z.string().uuid(),
     "vuuid": z.string().uuid(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
     "metadata": MetadataSchema,
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/df957.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/df957.json/default/TopLevel.ts
index 82adaab..e046c65 100644
--- a/base/typescript-zod/test/inputs/json/misc/df957.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/df957.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -12,7 +12,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -21,7 +21,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -29,7 +29,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -39,19 +39,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -59,14 +59,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -79,7 +79,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -96,12 +96,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -109,10 +109,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/e0ac7.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/e0ac7.json/default/TopLevel.ts
index 5cc167a..4156e34 100644
--- a/base/typescript-zod/test/inputs/json/misc/e0ac7.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/e0ac7.json/default/TopLevel.ts
@@ -19,7 +19,7 @@ export const DownsizedSchema = z.object({
     "size": z.string().regex(/^-?\d+$/).optional(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Downsized = z.infer<typeof DownsizedSchema>;
 
 export const DownsizedSmallSchema = z.object({
@@ -27,7 +27,7 @@ export const DownsizedSmallSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type DownsizedSmall = z.infer<typeof DownsizedSmallSchema>;
 
 export const FixedHeightSchema = z.object({
@@ -41,13 +41,13 @@ export const FixedHeightSchema = z.object({
     "webp": z.string(),
     "webp_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type FixedHeight = z.infer<typeof FixedHeightSchema>;
 
 export const LoopingSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Looping = z.infer<typeof LoopingSchema>;
 
 export const UserSchema = z.object({
@@ -57,21 +57,21 @@ export const UserSchema = z.object({
     "profile_url": z.string(),
     "twitter": z.string(),
     "username": z.string(),
-});
+}).strict();
 export type User = z.infer<typeof UserSchema>;
 
 export const MetaSchema = z.object({
     "msg": z.string(),
     "response_id": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const PaginationSchema = z.object({
     "count": z.number().int(),
     "offset": z.number().int(),
     "total_count": z.number().int(),
-});
+}).strict();
 export type Pagination = z.infer<typeof PaginationSchema>;
 
 export const ImagesSchema = z.object({
@@ -98,7 +98,7 @@ export const ImagesSchema = z.object({
     "preview": DownsizedSmallSchema,
     "preview_gif": DownsizedSchema,
     "preview_webp": DownsizedSchema,
-});
+}).strict();
 export type Images = z.infer<typeof ImagesSchema>;
 
 export const DatumSchema = z.object({
@@ -120,12 +120,12 @@ export const DatumSchema = z.object({
     "url": z.string(),
     "user": UserSchema.optional(),
     "username": z.string(),
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(DatumSchema),
     "meta": MetaSchema,
     "pagination": PaginationSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/e2915.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/e2915.json/default/TopLevel.ts
index 1cc8fda..331a0fa 100644
--- a/base/typescript-zod/test/inputs/json/misc/e2915.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/e2915.json/default/TopLevel.ts
@@ -9,7 +9,7 @@ export type Text = z.infer<typeof TextSchema>;
 export const AstronomySchema = z.object({
     "sunrise": z.string(),
     "sunset": z.string(),
-});
+}).strict();
 export type Astronomy = z.infer<typeof AstronomySchema>;
 
 export const AtmosphereSchema = z.object({
@@ -17,7 +17,7 @@ export const AtmosphereSchema = z.object({
     "pressure": z.string(),
     "rising": z.string().regex(/^-?\d+$/),
     "visibility": z.string(),
-});
+}).strict();
 export type Atmosphere = z.infer<typeof AtmosphereSchema>;
 
 export const ImageSchema = z.object({
@@ -26,7 +26,7 @@ export const ImageSchema = z.object({
     "title": z.string(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ConditionSchema = z.object({
@@ -34,7 +34,7 @@ export const ConditionSchema = z.object({
     "date": z.string(),
     "temp": z.string().regex(/^-?\d+$/),
     "text": z.string(),
-});
+}).strict();
 export type Condition = z.infer<typeof ConditionSchema>;
 
 export const ForecastSchema = z.object({
@@ -44,19 +44,19 @@ export const ForecastSchema = z.object({
     "high": z.string().regex(/^-?\d+$/),
     "low": z.string().regex(/^-?\d+$/),
     "text": TextSchema,
-});
+}).strict();
 export type Forecast = z.infer<typeof ForecastSchema>;
 
 export const GuidSchema = z.object({
     "isPermaLink": z.enum(["true", "false"]),
-});
+}).strict();
 export type Guid = z.infer<typeof GuidSchema>;
 
 export const LocationSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "region": z.string(),
-});
+}).strict();
 export type Location = z.infer<typeof LocationSchema>;
 
 export const UnitsSchema = z.object({
@@ -64,14 +64,14 @@ export const UnitsSchema = z.object({
     "pressure": z.string(),
     "speed": z.string(),
     "temperature": z.string(),
-});
+}).strict();
 export type Units = z.infer<typeof UnitsSchema>;
 
 export const WindSchema = z.object({
     "chill": z.string().regex(/^-?\d+$/),
     "direction": z.string().regex(/^-?\d+$/),
     "speed": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Wind = z.infer<typeof WindSchema>;
 
 export const ItemSchema = z.object({
@@ -84,7 +84,7 @@ export const ItemSchema = z.object({
     "long": z.string(),
     "pubDate": z.string(),
     "title": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const ChannelSchema = z.object({
@@ -101,12 +101,12 @@ export const ChannelSchema = z.object({
     "ttl": z.string().regex(/^-?\d+$/),
     "units": UnitsSchema,
     "wind": WindSchema,
-});
+}).strict();
 export type Channel = z.infer<typeof ChannelSchema>;
 
 export const ResultsSchema = z.object({
     "channel": ChannelSchema,
-});
+}).strict();
 export type Results = z.infer<typeof ResultsSchema>;
 
 export const QuerySchema = z.object({
@@ -114,10 +114,10 @@ export const QuerySchema = z.object({
     "created": z.coerce.date(),
     "lang": z.string(),
     "results": ResultsSchema,
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const TopLevelSchema = z.object({
     "query": QuerySchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/e2a58.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/e2a58.json/default/TopLevel.ts
index 08031a4..c48c0eb 100644
--- a/base/typescript-zod/test/inputs/json/misc/e2a58.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/e2a58.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const TopLevelElementSchema = z.object({
     "date": z.string(),
     "stop-and-search": z.array(z.string()),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/e324e.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/e324e.json/default/TopLevel.ts
index 2e9f6ad..731683c 100644
--- a/base/typescript-zod/test/inputs/json/misc/e324e.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/e324e.json/default/TopLevel.ts
@@ -9,14 +9,14 @@ export type Type = z.infer<typeof TypeSchema>;
 export const PropertySchema = z.object({
     "description": z.string(),
     "type": TypeSchema,
-});
+}).strict();
 export type Property = z.infer<typeof PropertySchema>;
 
 export const InfoSchema = z.object({
     "description": z.string(),
     "title": z.string(),
     "version": z.string(),
-});
+}).strict();
 export type Info = z.infer<typeof InfoSchema>;
 
 export const ParameterSchema = z.object({
@@ -26,39 +26,39 @@ export const ParameterSchema = z.object({
     "name": z.string(),
     "required": z.boolean(),
     "type": TypeSchema,
-});
+}).strict();
 export type Parameter = z.infer<typeof ParameterSchema>;
 
 export const ItemsSchema = z.object({
     "$ref": z.string(),
-});
+}).strict();
 export type Items = z.infer<typeof ItemsSchema>;
 
 export const RateSchema = z.object({
     "properties": z.record(z.string(), PropertySchema),
-});
+}).strict();
 export type Rate = z.infer<typeof RateSchema>;
 
 export const SchemaSchema = z.object({
     "items": ItemsSchema,
     "type": z.string(),
-});
+}).strict();
 export type Schema = z.infer<typeof SchemaSchema>;
 
 export const DefinitionsSchema = z.object({
     "Rate": RateSchema,
-});
+}).strict();
 export type Definitions = z.infer<typeof DefinitionsSchema>;
 
 export const The200Schema = z.object({
     "description": z.string(),
     "schema": SchemaSchema,
-});
+}).strict();
 export type The200 = z.infer<typeof The200Schema>;
 
 export const ResponsesSchema = z.object({
     "200": The200Schema,
-});
+}).strict();
 export type Responses = z.infer<typeof ResponsesSchema>;
 
 export const GetSchema = z.object({
@@ -67,17 +67,17 @@ export const GetSchema = z.object({
     "responses": ResponsesSchema,
     "summary": z.string(),
     "tags": z.array(z.string()),
-});
+}).strict();
 export type Get = z.infer<typeof GetSchema>;
 
 export const TariffRatesSearchSchema = z.object({
     "get": GetSchema,
-});
+}).strict();
 export type TariffRatesSearch = z.infer<typeof TariffRatesSearchSchema>;
 
 export const PathsSchema = z.object({
     "/tariff_rates/search": TariffRatesSearchSchema,
-});
+}).strict();
 export type Paths = z.infer<typeof PathsSchema>;
 
 export const TopLevelSchema = z.object({
@@ -89,5 +89,5 @@ export const TopLevelSchema = z.object({
     "produces": z.array(z.string()),
     "schemes": z.array(z.string()),
     "swagger": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/e53b5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/e53b5.json/default/TopLevel.ts
index 85e9bb0..bf92272 100644
--- a/base/typescript-zod/test/inputs/json/misc/e53b5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/e53b5.json/default/TopLevel.ts
@@ -17,7 +17,7 @@ export type Value = z.infer<typeof ValueSchema>;
 export const CountrySchema = z.object({
     "id": IdSchema,
     "value": ValueSchema,
-});
+}).strict();
 export type Country = z.infer<typeof CountrySchema>;
 
 export const FluffyTopLevelSchema = z.object({
@@ -25,7 +25,7 @@ export const FluffyTopLevelSchema = z.object({
     "pages": z.number().int(),
     "per_page": z.string().regex(/^-?\d+$/),
     "total": z.number().int(),
-});
+}).strict();
 export type FluffyTopLevel = z.infer<typeof FluffyTopLevelSchema>;
 
 export const PurpleTopLevelSchema = z.object({
@@ -34,7 +34,7 @@ export const PurpleTopLevelSchema = z.object({
     "decimal": z.string().regex(/^-?\d+$/),
     "indicator": CountrySchema,
     "value": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type PurpleTopLevel = z.infer<typeof PurpleTopLevelSchema>;
 
 export const TopLevelSchema = z.array(z.union([z.array(PurpleTopLevelSchema), FluffyTopLevelSchema]));
diff --git a/base/typescript-zod/test/inputs/json/misc/e64a0.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/e64a0.json/default/TopLevel.ts
index d04617d..7cc1354 100644
--- a/base/typescript-zod/test/inputs/json/misc/e64a0.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/e64a0.json/default/TopLevel.ts
@@ -2,7 +2,7 @@ import * as z from "zod";
 
 
 export const ArgsSchema = z.object({
-});
+}).strict();
 export type Args = z.infer<typeof ArgsSchema>;
 
 export const HeadersSchema = z.object({
@@ -10,7 +10,7 @@ export const HeadersSchema = z.object({
     "Connection": z.string(),
     "Host": z.string(),
     "User-Agent": z.string(),
-});
+}).strict();
 export type Headers = z.infer<typeof HeadersSchema>;
 
 export const TopLevelSchema = z.object({
@@ -18,5 +18,5 @@ export const TopLevelSchema = z.object({
     "headers": HeadersSchema,
     "origin": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/e8a0b.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/e8a0b.json/default/TopLevel.ts
index b8a003b..f51fac7 100644
--- a/base/typescript-zod/test/inputs/json/misc/e8a0b.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/e8a0b.json/default/TopLevel.ts
@@ -13,7 +13,7 @@ export const TopLevelElementSchema = z.object({
     "males": z.number().int(),
     "total": z.number().int(),
     "year": z.number().int(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/e8b04.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/e8b04.json/default/TopLevel.ts
index 67d7c51..efc8f2c 100644
--- a/base/typescript-zod/test/inputs/json/misc/e8b04.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/e8b04.json/default/TopLevel.ts
@@ -133,61 +133,61 @@ export const GrantSchema = z.object({
     "flags": z.array(GrantFlagSchema),
     "inherited": z.boolean(),
     "type": GrantTypeSchema,
-});
+}).strict();
 export type Grant = z.infer<typeof GrantSchema>;
 
 export const TestSchema = z.object({
     "CFPB1": z.string(),
-});
+}).strict();
 export type Test = z.infer<typeof TestSchema>;
 
 export const GroupSchema = z.object({
     "columnFieldName": z.string(),
-});
+}).strict();
 export type Group = z.infer<typeof GroupSchema>;
 
 export const OrderSchema = z.object({
     "ascending": z.boolean(),
     "columnFieldName": OrderColumnFieldNameSchema,
-});
+}).strict();
 export type Order = z.infer<typeof OrderSchema>;
 
 export const SelectSchema = z.object({
     "aggregate": z.string().optional(),
     "columnFieldName": z.string(),
-});
+}).strict();
 export type Select = z.infer<typeof SelectSchema>;
 
 export const TableColumnIdSchema = z.object({
     "2819740": z.number().int(),
-});
+}).strict();
 export type TableColumnId = z.infer<typeof TableColumnIdSchema>;
 
 export const PurpleVisibleSchema = z.object({
     "fatrow": z.boolean().optional(),
     "table": z.boolean().optional(),
-});
+}).strict();
 export type PurpleVisible = z.infer<typeof PurpleVisibleSchema>;
 
 export const FieldSchema = z.object({
     "tableColumnId": z.number().int(),
     "type": FieldTypeSchema,
-});
+}).strict();
 export type Field = z.infer<typeof FieldSchema>;
 
 export const StylesSchema = z.object({
     "width": WidthSchema,
-});
+}).strict();
 export type Styles = z.infer<typeof StylesSchema>;
 
 export const AccessPointsSchema = z.object({
     "new_view": z.string(),
-});
+}).strict();
 export type AccessPoints = z.infer<typeof AccessPointsSchema>;
 
 export const FluffyVisibleSchema = z.object({
     "href": z.boolean(),
-});
+}).strict();
 export type FluffyVisible = z.infer<typeof FluffyVisibleSchema>;
 
 export const OwnerSchema = z.object({
@@ -201,12 +201,12 @@ export const OwnerSchema = z.object({
     "rights": z.array(z.string()).optional(),
     "roleName": RoleNameSchema.optional(),
     "screenName": z.string(),
-});
+}).strict();
 export type Owner = z.infer<typeof OwnerSchema>;
 
 export const RatingsSchema = z.object({
     "rating": z.number().int(),
-});
+}).strict();
 export type Ratings = z.infer<typeof RatingsSchema>;
 
 export const TableAuthorSchema = z.object({
@@ -215,12 +215,12 @@ export const TableAuthorSchema = z.object({
     "rights": z.array(z.string()).optional(),
     "roleName": RoleNameSchema.optional(),
     "screenName": z.string(),
-});
+}).strict();
 export type TableAuthor = z.infer<typeof TableAuthorSchema>;
 
 export const CustomFieldsSchema = z.object({
     "TEST": TestSchema,
-});
+}).strict();
 export type CustomFields = z.infer<typeof CustomFieldsSchema>;
 
 export const ChildMetadataSchema = z.object({
@@ -230,22 +230,22 @@ export const ChildMetadataSchema = z.object({
     "operator": MetadataOperatorSchema.optional(),
     "tableColumnId": TableColumnIdSchema.optional(),
     "unifiedVersion": z.number().int().optional(),
-});
+}).strict();
 export type ChildMetadata = z.infer<typeof ChildMetadataSchema>;
 
 export const MetadataRenderTypeConfigSchema = z.object({
     "visible": PurpleVisibleSchema,
-});
+}).strict();
 export type MetadataRenderTypeConfig = z.infer<typeof MetadataRenderTypeConfigSchema>;
 
 export const RowSchema = z.object({
     "fields": z.array(FieldSchema),
-});
+}).strict();
 export type Row = z.infer<typeof RowSchema>;
 
 export const V1ArchivedPropertiesRenderTypeConfigSchema = z.object({
     "visible": FluffyVisibleSchema,
-});
+}).strict();
 export type V1ArchivedPropertiesRenderTypeConfig = z.infer<typeof V1ArchivedPropertiesRenderTypeConfigSchema>;
 
 export const ChildSchema = z.object({
@@ -253,20 +253,20 @@ export const ChildSchema = z.object({
     "metadata": ChildMetadataSchema.optional(),
     "operator": ChildOperatorSchema,
     "value": z.string().optional(),
-});
+}).strict();
 export type Child = z.infer<typeof ChildSchema>;
 
 export const ColumnSchema = z.object({
     "rows": z.array(RowSchema),
     "styles": StylesSchema,
-});
+}).strict();
 export type Column = z.infer<typeof ColumnSchema>;
 
 export const V1ArchivedPropertiesSchema = z.object({
     "accessPoints": AccessPointsSchema,
     "blist_id": z.string().regex(/^-?\d+$/),
     "renderTypeConfig": V1ArchivedPropertiesRenderTypeConfigSchema,
-});
+}).strict();
 export type V1ArchivedProperties = z.infer<typeof V1ArchivedPropertiesSchema>;
 
 export const WhereSchema = z.object({
@@ -275,12 +275,12 @@ export const WhereSchema = z.object({
     "metadata": ChildMetadataSchema.optional(),
     "operator": WhereOperatorSchema,
     "value": z.string().optional(),
-});
+}).strict();
 export type Where = z.infer<typeof WhereSchema>;
 
 export const FatRowSchema = z.object({
     "columns": z.array(ColumnSchema),
-});
+}).strict();
 export type FatRow = z.infer<typeof FatRowSchema>;
 
 export const JsonQuerySchema = z.object({
@@ -288,12 +288,12 @@ export const JsonQuerySchema = z.object({
     "order": z.array(OrderSchema).optional(),
     "select": z.array(SelectSchema).optional(),
     "where": WhereSchema.optional(),
-});
+}).strict();
 export type JsonQuery = z.infer<typeof JsonQuerySchema>;
 
 export const RichRendererConfigsSchema = z.object({
     "fatRow": FatRowSchema,
-});
+}).strict();
 export type RichRendererConfigs = z.infer<typeof RichRendererConfigsSchema>;
 
 export const TopLevelMetadataSchema = z.object({
@@ -307,7 +307,7 @@ export const TopLevelMetadataSchema = z.object({
     "rowIdentifier": z.string().optional(),
     "rowLabel": z.string().optional(),
     "v1_archived_properties": V1ArchivedPropertiesSchema.optional(),
-});
+}).strict();
 export type TopLevelMetadata = z.infer<typeof TopLevelMetadataSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -351,7 +351,7 @@ export const TopLevelElementSchema = z.object({
     "viewCount": z.number().int(),
     "viewLastModified": z.number().int(),
     "viewType": ViewTypeSchema,
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/f22f5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/f22f5.json/default/TopLevel.ts
index f3a648d..acb7acb 100644
--- a/base/typescript-zod/test/inputs/json/misc/f22f5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/f22f5.json/default/TopLevel.ts
@@ -31,7 +31,7 @@ export const KindSchema = z.enum([
 export type Kind = z.infer<typeof KindSchema>;
 
 export const MediaEmbedSchema = z.object({
-});
+}).strict();
 export type MediaEmbed = z.infer<typeof MediaEmbedSchema>;
 
 export const ChildDataSchema = z.object({
@@ -95,13 +95,13 @@ export const ChildDataSchema = z.object({
     "user_reports": z.array(z.any()),
     "view_count": z.null(),
     "visited": z.boolean(),
-});
+}).strict();
 export type ChildData = z.infer<typeof ChildDataSchema>;
 
 export const ChildSchema = z.object({
     "data": ChildDataSchema,
     "kind": KindSchema,
-});
+}).strict();
 export type Child = z.infer<typeof ChildSchema>;
 
 export const TopLevelDataSchema = z.object({
@@ -109,11 +109,11 @@ export const TopLevelDataSchema = z.object({
     "before": z.null(),
     "children": z.array(ChildSchema),
     "modhash": z.string(),
-});
+}).strict();
 export type TopLevelData = z.infer<typeof TopLevelDataSchema>;
 
 export const TopLevelSchema = z.object({
     "data": TopLevelDataSchema,
     "kind": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/f3139.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/f3139.json/default/TopLevel.ts
index 0766c70..9c3d6c0 100644
--- a/base/typescript-zod/test/inputs/json/misc/f3139.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/f3139.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const TopLevelElementSchema = z.object({
     "id": z.string(),
     "name": z.string(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/f3edf.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/f3edf.json/default/TopLevel.ts
index b8a003b..f51fac7 100644
--- a/base/typescript-zod/test/inputs/json/misc/f3edf.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/f3edf.json/default/TopLevel.ts
@@ -13,7 +13,7 @@ export const TopLevelElementSchema = z.object({
     "males": z.number().int(),
     "total": z.number().int(),
     "year": z.number().int(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/f466a.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/f466a.json/default/TopLevel.ts
index b8a003b..f51fac7 100644
--- a/base/typescript-zod/test/inputs/json/misc/f466a.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/f466a.json/default/TopLevel.ts
@@ -13,7 +13,7 @@ export const TopLevelElementSchema = z.object({
     "males": z.number().int(),
     "total": z.number().int(),
     "year": z.number().int(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/misc/f6a65.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/f6a65.json/default/TopLevel.ts
index f81c485..2daa964 100644
--- a/base/typescript-zod/test/inputs/json/misc/f6a65.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/f6a65.json/default/TopLevel.ts
@@ -29,7 +29,7 @@ export const The480_WStillSchema = z.object({
     "size": z.string().regex(/^-?\d+$/).optional(),
     "url": z.string(),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type The480_WStill = z.infer<typeof The480_WStillSchema>;
 
 export const DownsizedSmallSchema = z.object({
@@ -37,7 +37,7 @@ export const DownsizedSmallSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type DownsizedSmall = z.infer<typeof DownsizedSmallSchema>;
 
 export const FixedHeightSchema = z.object({
@@ -51,13 +51,13 @@ export const FixedHeightSchema = z.object({
     "webp": z.string(),
     "webp_size": z.string().regex(/^-?\d+$/),
     "width": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type FixedHeight = z.infer<typeof FixedHeightSchema>;
 
 export const LoopingSchema = z.object({
     "mp4": z.string(),
     "mp4_size": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Looping = z.infer<typeof LoopingSchema>;
 
 export const UserSchema = z.object({
@@ -67,21 +67,21 @@ export const UserSchema = z.object({
     "profile_url": z.string(),
     "twitter": z.string(),
     "username": UsernameSchema,
-});
+}).strict();
 export type User = z.infer<typeof UserSchema>;
 
 export const MetaSchema = z.object({
     "msg": z.string(),
     "response_id": z.string(),
     "status": z.number().int(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const PaginationSchema = z.object({
     "count": z.number().int(),
     "offset": z.number().int(),
     "total_count": z.number().int(),
-});
+}).strict();
 export type Pagination = z.infer<typeof PaginationSchema>;
 
 export const ImagesSchema = z.object({
@@ -108,7 +108,7 @@ export const ImagesSchema = z.object({
     "preview_gif": The480_WStillSchema,
     "preview_webp": The480_WStillSchema,
     "480w_still": The480_WStillSchema.optional(),
-});
+}).strict();
 export type Images = z.infer<typeof ImagesSchema>;
 
 export const DatumSchema = z.object({
@@ -130,12 +130,12 @@ export const DatumSchema = z.object({
     "url": z.string(),
     "user": UserSchema.optional(),
     "username": UsernameSchema,
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(DatumSchema),
     "meta": MetaSchema,
     "pagination": PaginationSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/f74d5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/f74d5.json/default/TopLevel.ts
index 355ecf3..f64841d 100644
--- a/base/typescript-zod/test/inputs/json/misc/f74d5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/f74d5.json/default/TopLevel.ts
@@ -11,35 +11,35 @@ export type TypeName = z.infer<typeof TypeNameSchema>;
 export const TopSchema = z.object({
     "count": z.number().int(),
     "item": z.string(),
-});
+}).strict();
 export type Top = z.infer<typeof TopSchema>;
 
 export const QuerySchema = z.object({
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const GrantSchema = z.object({
     "flags": z.array(z.string()),
     "inherited": z.boolean(),
     "type": z.string(),
-});
+}).strict();
 export type Grant = z.infer<typeof GrantSchema>;
 
 export const LicenseSchema = z.object({
     "name": z.string(),
-});
+}).strict();
 export type License = z.infer<typeof LicenseSchema>;
 
 export const VisibleSchema = z.object({
     "table": z.boolean(),
-});
+}).strict();
 export type Visible = z.infer<typeof VisibleSchema>;
 
 export const OwnerSchema = z.object({
     "displayName": z.string(),
     "id": z.string(),
     "screenName": z.string(),
-});
+}).strict();
 export type Owner = z.infer<typeof OwnerSchema>;
 
 export const CachedContentsSchema = z.object({
@@ -50,12 +50,12 @@ export const CachedContentsSchema = z.object({
     "smallest": z.string(),
     "sum": z.string().regex(/^-?\d+$/).optional(),
     "top": z.array(TopSchema),
-});
+}).strict();
 export type CachedContents = z.infer<typeof CachedContentsSchema>;
 
 export const RenderTypeConfigSchema = z.object({
     "visible": VisibleSchema,
-});
+}).strict();
 export type RenderTypeConfig = z.infer<typeof RenderTypeConfigSchema>;
 
 export const ColumnSchema = z.object({
@@ -70,7 +70,7 @@ export const ColumnSchema = z.object({
     "renderTypeName": TypeNameSchema,
     "tableColumnId": z.number().int().optional(),
     "width": z.number().int().optional(),
-});
+}).strict();
 export type Column = z.infer<typeof ColumnSchema>;
 
 export const MetadataSchema = z.object({
@@ -79,7 +79,7 @@ export const MetadataSchema = z.object({
     "rdfSubject": z.string().regex(/^-?\d+$/),
     "renderTypeConfig": RenderTypeConfigSchema,
     "rowIdentifier": z.string().regex(/^-?\d+$/),
-});
+}).strict();
 export type Metadata = z.infer<typeof MetadataSchema>;
 
 export const ViewSchema = z.object({
@@ -120,16 +120,16 @@ export const ViewSchema = z.object({
     "viewCount": z.number().int(),
     "viewLastModified": z.number().int(),
     "viewType": z.string(),
-});
+}).strict();
 export type View = z.infer<typeof ViewSchema>;
 
 export const MetaSchema = z.object({
     "view": ViewSchema,
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(z.array(z.union([z.number().int(), z.string()]))),
     "meta": MetaSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/f82d9.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/f82d9.json/default/TopLevel.ts
index f94c99d..f74a38b 100644
--- a/base/typescript-zod/test/inputs/json/misc/f82d9.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/f82d9.json/default/TopLevel.ts
@@ -9,14 +9,14 @@ export type Type = z.infer<typeof TypeSchema>;
 export const ClickUrlSchema = z.object({
     "description": z.string(),
     "type": TypeSchema,
-});
+}).strict();
 export type ClickUrl = z.infer<typeof ClickUrlSchema>;
 
 export const InfoSchema = z.object({
     "description": z.string(),
     "title": z.string(),
     "version": z.string(),
-});
+}).strict();
 export type Info = z.infer<typeof InfoSchema>;
 
 export const ParameterSchema = z.object({
@@ -26,12 +26,12 @@ export const ParameterSchema = z.object({
     "name": z.string(),
     "required": z.boolean(),
     "type": TypeSchema,
-});
+}).strict();
 export type Parameter = z.infer<typeof ParameterSchema>;
 
 export const ItemsSchema = z.object({
     "$ref": z.string(),
-});
+}).strict();
 export type Items = z.infer<typeof ItemsSchema>;
 
 export const PropertiesSchema = z.object({
@@ -45,34 +45,34 @@ export const PropertiesSchema = z.object({
     "source_industry": ClickUrlSchema,
     "title": ClickUrlSchema,
     "url": ClickUrlSchema,
-});
+}).strict();
 export type Properties = z.infer<typeof PropertiesSchema>;
 
 export const SchemaSchema = z.object({
     "items": ItemsSchema,
     "type": z.string(),
-});
+}).strict();
 export type Schema = z.infer<typeof SchemaSchema>;
 
 export const ReportSchema = z.object({
     "properties": PropertiesSchema,
-});
+}).strict();
 export type Report = z.infer<typeof ReportSchema>;
 
 export const The200Schema = z.object({
     "description": z.string(),
     "schema": SchemaSchema,
-});
+}).strict();
 export type The200 = z.infer<typeof The200Schema>;
 
 export const DefinitionsSchema = z.object({
     "Report": ReportSchema,
-});
+}).strict();
 export type Definitions = z.infer<typeof DefinitionsSchema>;
 
 export const ResponsesSchema = z.object({
     "200": The200Schema,
-});
+}).strict();
 export type Responses = z.infer<typeof ResponsesSchema>;
 
 export const GetSchema = z.object({
@@ -81,17 +81,17 @@ export const GetSchema = z.object({
     "responses": ResponsesSchema,
     "summary": z.string(),
     "tags": z.array(z.string()),
-});
+}).strict();
 export type Get = z.infer<typeof GetSchema>;
 
 export const MarketResearchLibrarySearchSchema = z.object({
     "get": GetSchema,
-});
+}).strict();
 export type MarketResearchLibrarySearch = z.infer<typeof MarketResearchLibrarySearchSchema>;
 
 export const PathsSchema = z.object({
     "/market_research_library/search": MarketResearchLibrarySearchSchema,
-});
+}).strict();
 export type Paths = z.infer<typeof PathsSchema>;
 
 export const TopLevelSchema = z.object({
@@ -103,5 +103,5 @@ export const TopLevelSchema = z.object({
     "produces": z.array(z.string()),
     "schemes": z.array(z.string()),
     "swagger": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/f974d.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/f974d.json/default/TopLevel.ts
index d2c18e8..5537874 100644
--- a/base/typescript-zod/test/inputs/json/misc/f974d.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/f974d.json/default/TopLevel.ts
@@ -7,5 +7,5 @@ export const TopLevelSchema = z.object({
     "height": z.number().int(),
     "time": z.number().int(),
     "txIndexes": z.array(z.number().int()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/faff5.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/faff5.json/default/TopLevel.ts
index 447f181..da5ac63 100644
--- a/base/typescript-zod/test/inputs/json/misc/faff5.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/faff5.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const ResponseSchema = z.object({
     "player_count": z.number().int(),
     "result": z.number().int(),
-});
+}).strict();
 export type Response = z.infer<typeof ResponseSchema>;
 
 export const TopLevelSchema = z.object({
     "response": ResponseSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/fcca3.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/fcca3.json/default/TopLevel.ts
index b5aaa7a..b3812c4 100644
--- a/base/typescript-zod/test/inputs/json/misc/fcca3.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/fcca3.json/default/TopLevel.ts
@@ -11,21 +11,21 @@ export type TypeName = z.infer<typeof TypeNameSchema>;
 export const TopSchema = z.object({
     "count": z.number().int(),
     "item": z.string(),
-});
+}).strict();
 export type Top = z.infer<typeof TopSchema>;
 
 export const FormatSchema = z.object({
     "align": z.string().optional(),
     "noCommas": z.enum(["true", "false"]).optional(),
     "precisionStyle": z.string().optional(),
-});
+}).strict();
 export type Format = z.infer<typeof FormatSchema>;
 
 export const GrantSchema = z.object({
     "flags": z.array(z.string()),
     "inherited": z.boolean(),
     "type": z.string(),
-});
+}).strict();
 export type Grant = z.infer<typeof GrantSchema>;
 
 export const AttachmentSchema = z.object({
@@ -33,19 +33,19 @@ export const AttachmentSchema = z.object({
     "blobId": z.string(),
     "filename": z.string(),
     "name": z.string(),
-});
+}).strict();
 export type Attachment = z.infer<typeof AttachmentSchema>;
 
 export const CommonCoreSchema = z.object({
     "Contact Email": z.string(),
     "Contact Name": z.string(),
     "Publisher": z.string(),
-});
+}).strict();
 export type CommonCore = z.infer<typeof CommonCoreSchema>;
 
 export const DatasetInformationSchema = z.object({
     "Agency": z.string(),
-});
+}).strict();
 export type DatasetInformation = z.infer<typeof DatasetInformationSchema>;
 
 export const DatasetSummarySchema = z.object({
@@ -55,35 +55,35 @@ export const DatasetSummarySchema = z.object({
     "Organization": z.string(),
     "Posting Frequency": z.string(),
     "Time Period": z.string(),
-});
+}).strict();
 export type DatasetSummary = z.infer<typeof DatasetSummarySchema>;
 
 export const DisclaimersSchema = z.object({
     "Disclaimer": z.string(),
     "Limitations": z.string(),
-});
+}).strict();
 export type Disclaimers = z.infer<typeof DisclaimersSchema>;
 
 export const TableColumnIdSchema = z.object({
     "703610": z.number().int(),
-});
+}).strict();
 export type TableColumnId = z.infer<typeof TableColumnIdSchema>;
 
 export const FilterConditionMetadataSchema = z.object({
     "advanced": z.boolean(),
     "unifiedVersion": z.number().int(),
-});
+}).strict();
 export type FilterConditionMetadata = z.infer<typeof FilterConditionMetadataSchema>;
 
 export const OrderSchema = z.object({
     "ascending": z.boolean(),
     "columnFieldName": z.string(),
-});
+}).strict();
 export type Order = z.infer<typeof OrderSchema>;
 
 export const VisibleSchema = z.object({
     "table": z.boolean(),
-});
+}).strict();
 export type Visible = z.infer<typeof VisibleSchema>;
 
 export const OwnerSchema = z.object({
@@ -95,13 +95,13 @@ export const OwnerSchema = z.object({
     "rights": z.array(z.string()),
     "roleName": z.string(),
     "screenName": z.string(),
-});
+}).strict();
 export type Owner = z.infer<typeof OwnerSchema>;
 
 export const ExpressionSchema = z.object({
     "columnId": z.number().int(),
     "type": z.string(),
-});
+}).strict();
 export type Expression = z.infer<typeof ExpressionSchema>;
 
 export const CachedContentsSchema = z.object({
@@ -112,7 +112,7 @@ export const CachedContentsSchema = z.object({
     "smallest": z.string(),
     "sum": z.string().regex(/^-?\d+$/).optional(),
     "top": z.array(TopSchema),
-});
+}).strict();
 export type CachedContents = z.infer<typeof CachedContentsSchema>;
 
 export const CustomFieldsSchema = z.object({
@@ -120,30 +120,30 @@ export const CustomFieldsSchema = z.object({
     "Dataset Information": DatasetInformationSchema,
     "Dataset Summary": DatasetSummarySchema,
     "Disclaimers": DisclaimersSchema,
-});
+}).strict();
 export type CustomFields = z.infer<typeof CustomFieldsSchema>;
 
 export const ChildMetadataSchema = z.object({
     "customValues": z.array(z.array(z.string())),
     "operator": z.string(),
     "tableColumnId": TableColumnIdSchema,
-});
+}).strict();
 export type ChildMetadata = z.infer<typeof ChildMetadataSchema>;
 
 export const JsonQuerySchema = z.object({
     "order": z.array(OrderSchema),
-});
+}).strict();
 export type JsonQuery = z.infer<typeof JsonQuerySchema>;
 
 export const RenderTypeConfigSchema = z.object({
     "visible": VisibleSchema,
-});
+}).strict();
 export type RenderTypeConfig = z.infer<typeof RenderTypeConfigSchema>;
 
 export const OrderBySchema = z.object({
     "ascending": z.boolean(),
     "expression": ExpressionSchema,
-});
+}).strict();
 export type OrderBy = z.infer<typeof OrderBySchema>;
 
 export const ColumnSchema = z.object({
@@ -159,19 +159,19 @@ export const ColumnSchema = z.object({
     "renderTypeName": TypeNameSchema,
     "tableColumnId": z.number().int().optional(),
     "width": z.number().int().optional(),
-});
+}).strict();
 export type Column = z.infer<typeof ColumnSchema>;
 
 export const ChildSchema = z.object({
     "metadata": ChildMetadataSchema,
     "type": z.string(),
     "value": z.string(),
-});
+}).strict();
 export type Child = z.infer<typeof ChildSchema>;
 
 export const QuerySchema = z.object({
     "orderBys": z.array(OrderBySchema),
-});
+}).strict();
 export type Query = z.infer<typeof QuerySchema>;
 
 export const FilterConditionSchema = z.object({
@@ -179,7 +179,7 @@ export const FilterConditionSchema = z.object({
     "metadata": FilterConditionMetadataSchema,
     "type": z.string(),
     "value": z.string(),
-});
+}).strict();
 export type FilterCondition = z.infer<typeof FilterConditionSchema>;
 
 export const ViewMetadataSchema = z.object({
@@ -191,7 +191,7 @@ export const ViewMetadataSchema = z.object({
     "rdfSubject": z.string().regex(/^-?\d+$/),
     "renderTypeConfig": RenderTypeConfigSchema,
     "rowLabel": z.string(),
-});
+}).strict();
 export type ViewMetadata = z.infer<typeof ViewMetadataSchema>;
 
 export const ViewSchema = z.object({
@@ -232,16 +232,16 @@ export const ViewSchema = z.object({
     "viewCount": z.number().int(),
     "viewLastModified": z.number().int(),
     "viewType": z.string(),
-});
+}).strict();
 export type View = z.infer<typeof ViewSchema>;
 
 export const MetaSchema = z.object({
     "view": ViewSchema,
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.array(z.array(z.union([z.null(), z.number().int(), z.string()]))),
     "meta": MetaSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/misc/fd329.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/misc/fd329.json/default/TopLevel.ts
index b71dac0..cfc3dbb 100644
--- a/base/typescript-zod/test/inputs/json/misc/fd329.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/misc/fd329.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const DatumSchema = z.object({
     "anomaly": z.string(),
     "value": z.string(),
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const DescriptionSchema = z.object({
@@ -12,11 +12,11 @@ export const DescriptionSchema = z.object({
     "missing": z.number().int(),
     "title": z.string(),
     "units": z.string(),
-});
+}).strict();
 export type Description = z.infer<typeof DescriptionSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.record(z.string(), DatumSchema),
     "description": DescriptionSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/blns-object.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/blns-object.json/default/TopLevel.ts
index f981b59..b5808e6 100644
--- a/base/typescript-zod/test/inputs/json/priority/blns-object.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/blns-object.json/default/TopLevel.ts
@@ -232,7 +232,7 @@ export const ASchema = z.object({
     "和製漢語": z.string(),
     "田中さんにあげて下さい": z.string(),
     "｀ｨ(´∀｀∩": z.string(),
-});
+}).strict();
 export type A = z.infer<typeof ASchema>;
 
 export const BSchema = z.object({
@@ -395,7 +395,7 @@ export const BSchema = z.object({
     "찦차를 타고 온 펲시맨과 쑛다리 똠방각하": z.string(),
     "ﷺ": z.string(),
     "__ﾛ(,_,*)": z.string(),
-});
+}).strict();
 export type B = z.infer<typeof BSchema>;
 
 export const CSchema = z.object({
@@ -594,12 +594,12 @@ export const CSchema = z.object({
     "울란바토르": z.string(),
     "Ｔｈｅ ｑｕｉｃｋ ｂｒｏｗｎ ｆｏｘ ｊｕｍｐｓ ｏｖｅｒ ｔｈｅ ｌａｚｙ ｄｏｇ": z.string(),
     "(ﾉಥ益ಥ）ﾉ\ufeff ┻━┻": z.string(),
-});
+}).strict();
 export type C = z.infer<typeof CSchema>;
 
 export const TopLevelSchema = z.object({
     "a": ASchema,
     "b": BSchema,
     "c": CSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/bug2037.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/bug2037.json/default/TopLevel.ts
index 7be23fe..dc68b37 100644
--- a/base/typescript-zod/test/inputs/json/priority/bug2037.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/bug2037.json/default/TopLevel.ts
@@ -2,20 +2,20 @@ import * as z from "zod";
 
 
 export const RewardSchema = z.object({
-});
+}).strict();
 export type Reward = z.infer<typeof RewardSchema>;
 
 export const ObjectiveSchema = z.object({
     "rewards": z.record(z.string(), RewardSchema),
-});
+}).strict();
 export type Objective = z.infer<typeof ObjectiveSchema>;
 
 export const MissionSpecSchema = z.object({
     "objectives": z.record(z.string(), ObjectiveSchema),
-});
+}).strict();
 export type MissionSpec = z.infer<typeof MissionSpecSchema>;
 
 export const TopLevelSchema = z.object({
     "mission_specs": z.record(z.string(), MissionSpecSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/bug2521.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/bug2521.json/default/TopLevel.ts
index 62fe393..82686bd 100644
--- a/base/typescript-zod/test/inputs/json/priority/bug2521.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/bug2521.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const OptionSchema = z.object({
     "foo": z.string().optional(),
     "name": z.string(),
-});
+}).strict();
 export type Option = z.infer<typeof OptionSchema>;
 
 export const TopLevelSchema = z.object({
     "options": z.array(OptionSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/bug2590.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/bug2590.json/default/TopLevel.ts
index e74da63..3dec7b4 100644
--- a/base/typescript-zod/test/inputs/json/priority/bug2590.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/bug2590.json/default/TopLevel.ts
@@ -5,10 +5,10 @@ export const InvoiceSchema = z.object({
     "createdAt": z.union([z.null(), z.coerce.date()]),
     "dueDate": z.union([z.null(), z.string()]),
     "name": z.string(),
-});
+}).strict();
 export type Invoice = z.infer<typeof InvoiceSchema>;
 
 export const TopLevelSchema = z.object({
     "invoices": z.array(InvoiceSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/bug2663.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/bug2663.json/default/TopLevel.ts
index c5a467a..5ac641c 100644
--- a/base/typescript-zod/test/inputs/json/priority/bug2663.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/bug2663.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "birthday": z.string(),
     "lastSeen": z.coerce.date(),
     "name": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/bug2793.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/bug2793.json/default/TopLevel.ts
index 1f07b34..24e8ecc 100644
--- a/base/typescript-zod/test/inputs/json/priority/bug2793.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/bug2793.json/default/TopLevel.ts
@@ -2,17 +2,17 @@ import * as z from "zod";
 
 
 export const HintsSchema = z.object({
-});
+}).strict();
 export type Hints = z.infer<typeof HintsSchema>;
 
 export const LabelsSchema = z.object({
     "AccountNumber": z.string(),
     "Title": z.string(),
-});
+}).strict();
 export type Labels = z.infer<typeof LabelsSchema>;
 
 export const TopLevelSchema = z.object({
     "Hints": HintsSchema,
     "Labels": LabelsSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/bug427.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/bug427.json/default/TopLevel.ts
index d1de85f..98994fe 100644
--- a/base/typescript-zod/test/inputs/json/priority/bug427.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/bug427.json/default/TopLevel.ts
@@ -103,7 +103,7 @@ export const GetSignatureTypeSchema: z.ZodType<GetSignatureType> = z.lazy(() =>
         "elementType": ElementTypeSchema.optional(),
         "name": NameSchema.optional(),
         "type": TypeEnumSchema,
-    })
+    }).strict()
 );
 
 export type IndexSignatureElement = {
@@ -124,7 +124,7 @@ export const IndexSignatureElementSchema: z.ZodType<IndexSignatureElement> = z.l
         "name": z.string(),
         "parameters": z.array(GetSignatureSchema).optional(),
         "type": PurpleTypeSchema,
-    })
+    }).strict()
 );
 
 export type PurpleType = {
@@ -137,7 +137,7 @@ export const PurpleTypeSchema: z.ZodType<PurpleType> = z.lazy(() =>
         "declaration": GetSignatureSchema.optional(),
         "name": NameSchema.optional(),
         "type": TypeEnumSchema,
-    })
+    }).strict()
 );
 
 export type GetSignatureChild = {
@@ -160,7 +160,7 @@ export const GetSignatureChildSchema: z.ZodType<GetSignatureChild> = z.lazy(() =
         "name": z.string(),
         "sources": z.array(SourceSchema),
         "type": PurpleTypeSchema,
-    })
+    }).strict()
 );
 
 export type GetSignature = {
@@ -195,7 +195,7 @@ export const GetSignatureSchema: z.ZodType<GetSignature> = z.lazy(() =>
         "sources": z.array(SourceSchema).optional(),
         "type": GetSignatureTypeSchema.optional(),
         "typeParameter": z.array(GetSignatureSchema).optional(),
-    })
+    }).strict()
 );
 
 export type ExtendedBy = {
@@ -212,70 +212,70 @@ export const ExtendedBySchema: z.ZodType<ExtendedBy> = z.lazy(() =>
         "name": z.string(),
         "type": TypeEnumSchema,
         "typeArguments": z.array(ExtendedBySchema).optional(),
-    })
+    }).strict()
 );
 
 export const PurpleCommentSchema = z.object({
     "shortText": z.string(),
-});
+}).strict();
 export type PurpleComment = z.infer<typeof PurpleCommentSchema>;
 
 export const PurpleFlagsSchema = z.object({
     "isExported": z.boolean().optional(),
-});
+}).strict();
 export type PurpleFlags = z.infer<typeof PurpleFlagsSchema>;
 
 export const GetSignatureFlagsSchema = z.object({
-});
+}).strict();
 export type GetSignatureFlags = z.infer<typeof GetSignatureFlagsSchema>;
 
 export const ElementTypeSchema = z.object({
     "name": NameSchema,
     "type": TypeEnumSchema,
-});
+}).strict();
 export type ElementType = z.infer<typeof ElementTypeSchema>;
 
 export const FluffyCommentSchema = z.object({
     "text": z.string(),
-});
+}).strict();
 export type FluffyComment = z.infer<typeof FluffyCommentSchema>;
 
 export const FluffyFlagsSchema = z.object({
     "isOptional": z.boolean().optional(),
-});
+}).strict();
 export type FluffyFlags = z.infer<typeof FluffyFlagsSchema>;
 
 export const SourceSchema = z.object({
     "character": z.number().int(),
     "fileName": FileNameSchema,
     "line": z.number().int(),
-});
+}).strict();
 export type Source = z.infer<typeof SourceSchema>;
 
 export const GetSignatureCommentSchema = z.object({
     "returns": z.string().optional(),
     "shortText": z.string().optional(),
     "text": z.string().optional(),
-});
+}).strict();
 export type GetSignatureComment = z.infer<typeof GetSignatureCommentSchema>;
 
 export const GroupSchema = z.object({
     "children": z.array(z.number().int()),
     "kind": z.number().int(),
     "title": z.string(),
-});
+}).strict();
 export type Group = z.infer<typeof GroupSchema>;
 
 export const TentacledCommentSchema = z.object({
     "shortText": z.string().optional(),
     "text": z.string().optional(),
-});
+}).strict();
 export type TentacledComment = z.infer<typeof TentacledCommentSchema>;
 
 export const TentacledFlagsSchema = z.object({
     "isOptional": z.boolean().optional(),
     "isRest": z.boolean().optional(),
-});
+}).strict();
 export type TentacledFlags = z.infer<typeof TentacledFlagsSchema>;
 
 export const FluffyTypeSchema = z.object({
@@ -283,7 +283,7 @@ export const FluffyTypeSchema = z.object({
     "name": NameSchema.optional(),
     "type": TypeEnumSchema,
     "typeArguments": z.array(ElementTypeSchema).optional(),
-});
+}).strict();
 export type FluffyType = z.infer<typeof FluffyTypeSchema>;
 
 export const PurpleDeclarationSchema = z.object({
@@ -294,7 +294,7 @@ export const PurpleDeclarationSchema = z.object({
     "kind": z.number().int(),
     "kindString": z.string(),
     "name": z.string(),
-});
+}).strict();
 export type PurpleDeclaration = z.infer<typeof PurpleDeclarationSchema>;
 
 export const TypeElementSchema = z.object({
@@ -303,13 +303,13 @@ export const TypeElementSchema = z.object({
     "name": NameSchema.optional(),
     "type": TypeEnumSchema,
     "typeArguments": z.array(ElementTypeSchema).optional(),
-});
+}).strict();
 export type TypeElement = z.infer<typeof TypeElementSchema>;
 
 export const TagSchema = z.object({
     "tag": z.string(),
     "text": z.string(),
-});
+}).strict();
 export type Tag = z.infer<typeof TagSchema>;
 
 export const StickyFlagsSchema = z.object({
@@ -320,13 +320,13 @@ export const StickyFlagsSchema = z.object({
     "isProtected": z.boolean().optional(),
     "isPublic": z.boolean().optional(),
     "isStatic": z.boolean().optional(),
-});
+}).strict();
 export type StickyFlags = z.infer<typeof StickyFlagsSchema>;
 
 export const IndigoFlagsSchema = z.object({
     "isPrivate": z.boolean().optional(),
     "isProtected": z.boolean().optional(),
-});
+}).strict();
 export type IndigoFlags = z.infer<typeof IndigoFlagsSchema>;
 
 export const StickyTypeSchema = z.object({
@@ -338,7 +338,7 @@ export const StickyTypeSchema = z.object({
     "name": z.string().optional(),
     "type": TypeEnumSchema,
     "typeArguments": z.array(ElementTypeSchema).optional(),
-});
+}).strict();
 export type StickyType = z.infer<typeof StickyTypeSchema>;
 
 export const IndecentTypeSchema = z.object({
@@ -346,19 +346,19 @@ export const IndecentTypeSchema = z.object({
     "elements": z.array(ElementTypeSchema).optional(),
     "name": NameSchema.optional(),
     "type": TypeEnumSchema,
-});
+}).strict();
 export type IndecentType = z.infer<typeof IndecentTypeSchema>;
 
 export const HilariousTypeSchema = z.object({
     "declaration": GetSignatureSchema,
     "type": TypeEnumSchema,
-});
+}).strict();
 export type HilariousType = z.infer<typeof HilariousTypeSchema>;
 
 export const IndigoCommentSchema = z.object({
     "returns": z.string(),
     "shortText": z.string(),
-});
+}).strict();
 export type IndigoComment = z.infer<typeof IndigoCommentSchema>;
 
 export const FluffyParameterSchema = z.object({
@@ -370,14 +370,14 @@ export const FluffyParameterSchema = z.object({
     "name": z.string(),
     "sources": z.array(SourceSchema).optional(),
     "type": ElementTypeSchema,
-});
+}).strict();
 export type FluffyParameter = z.infer<typeof FluffyParameterSchema>;
 
 export const PurpleTypeArgumentSchema = z.object({
     "operator": z.string(),
     "target": ElementTypeSchema,
     "type": z.string(),
-});
+}).strict();
 export type PurpleTypeArgument = z.infer<typeof PurpleTypeArgumentSchema>;
 
 export const IndecentFlagsSchema = z.object({
@@ -388,7 +388,7 @@ export const IndecentFlagsSchema = z.object({
     "isLet": z.boolean().optional(),
     "isPrivate": z.boolean().optional(),
     "isProtected": z.boolean().optional(),
-});
+}).strict();
 export type IndecentFlags = z.infer<typeof IndecentFlagsSchema>;
 
 export const IndigoChildSchema = z.object({
@@ -401,7 +401,7 @@ export const IndigoChildSchema = z.object({
     "name": z.string(),
     "sources": z.array(SourceSchema),
     "type": IndecentTypeSchema,
-});
+}).strict();
 export type IndigoChild = z.infer<typeof IndigoChildSchema>;
 
 export const CunningTypeSchema = z.object({
@@ -410,7 +410,7 @@ export const CunningTypeSchema = z.object({
     "name": NameSchema.optional(),
     "type": TypeEnumSchema,
     "typeArguments": z.array(ElementTypeSchema).optional(),
-});
+}).strict();
 export type CunningType = z.infer<typeof CunningTypeSchema>;
 
 export const IndigoDeclarationSchema = z.object({
@@ -423,13 +423,13 @@ export const IndigoDeclarationSchema = z.object({
     "name": z.string(),
     "signatures": z.array(GetSignatureSchema).optional(),
     "sources": z.array(SourceSchema),
-});
+}).strict();
 export type IndigoDeclaration = z.infer<typeof IndigoDeclarationSchema>;
 
 export const FluffyTypeArgumentSchema = z.object({
     "type": TypeEnumSchema,
     "types": z.array(ElementTypeSchema),
-});
+}).strict();
 export type FluffyTypeArgument = z.infer<typeof FluffyTypeArgumentSchema>;
 
 export const MischievousTypeSchema = z.object({
@@ -438,13 +438,13 @@ export const MischievousTypeSchema = z.object({
     "operator": z.string().optional(),
     "target": ElementTypeSchema.optional(),
     "type": z.string(),
-});
+}).strict();
 export type MischievousType = z.infer<typeof MischievousTypeSchema>;
 
 export const IndecentCommentSchema = z.object({
     "shortText": z.string(),
     "tags": z.array(TagSchema).optional(),
-});
+}).strict();
 export type IndecentComment = z.infer<typeof IndecentCommentSchema>;
 
 export const GetSignatureParameterSchema = z.object({
@@ -455,14 +455,14 @@ export const GetSignatureParameterSchema = z.object({
     "kindString": ParameterKindStringSchema,
     "name": z.string(),
     "type": FluffyTypeSchema,
-});
+}).strict();
 export type GetSignatureParameter = z.infer<typeof GetSignatureParameterSchema>;
 
 export const TentacledTypeSchema = z.object({
     "declaration": PurpleDeclarationSchema.optional(),
     "name": NameSchema.optional(),
     "type": TypeEnumSchema,
-});
+}).strict();
 export type TentacledType = z.infer<typeof TentacledTypeSchema>;
 
 export const StickyCommentSchema = z.object({
@@ -470,7 +470,7 @@ export const StickyCommentSchema = z.object({
     "shortText": z.string().optional(),
     "tags": z.array(TagSchema).optional(),
     "text": z.string().optional(),
-});
+}).strict();
 export type StickyComment = z.infer<typeof StickyCommentSchema>;
 
 export const PurpleParameterSchema = z.object({
@@ -481,7 +481,7 @@ export const PurpleParameterSchema = z.object({
     "kindString": ParameterKindStringSchema,
     "name": z.string(),
     "type": StickyTypeSchema,
-});
+}).strict();
 export type PurpleParameter = z.infer<typeof PurpleParameterSchema>;
 
 export const StickyChildSchema = z.object({
@@ -493,7 +493,7 @@ export const StickyChildSchema = z.object({
     "name": z.string(),
     "sources": z.array(SourceSchema),
     "type": IndecentTypeSchema,
-});
+}).strict();
 export type StickyChild = z.infer<typeof StickyChildSchema>;
 
 export const IndexSignatureSchema = z.object({
@@ -504,7 +504,7 @@ export const IndexSignatureSchema = z.object({
     "name": z.string(),
     "parameters": z.array(GetSignatureSchema),
     "type": HilariousTypeSchema,
-});
+}).strict();
 export type IndexSignature = z.infer<typeof IndexSignatureSchema>;
 
 export const TentacledSignatureSchema = z.object({
@@ -516,7 +516,7 @@ export const TentacledSignatureSchema = z.object({
     "name": z.string(),
     "parameters": z.array(FluffyParameterSchema).optional(),
     "type": ExtendedBySchema,
-});
+}).strict();
 export type TentacledSignature = z.infer<typeof TentacledSignatureSchema>;
 
 export const TentacledDeclarationSchema = z.object({
@@ -530,14 +530,14 @@ export const TentacledDeclarationSchema = z.object({
     "name": z.string(),
     "signatures": z.array(GetSignatureSchema).optional(),
     "sources": z.array(SourceSchema),
-});
+}).strict();
 export type TentacledDeclaration = z.infer<typeof TentacledDeclarationSchema>;
 
 export const FriskyTypeSchema = z.object({
     "declaration": IndigoDeclarationSchema.optional(),
     "name": NameSchema.optional(),
     "type": TypeEnumSchema,
-});
+}).strict();
 export type FriskyType = z.infer<typeof FriskyTypeSchema>;
 
 export const TypeParameterSchema = z.object({
@@ -548,7 +548,7 @@ export const TypeParameterSchema = z.object({
     "kindString": z.string(),
     "name": z.string(),
     "type": MischievousTypeSchema.optional(),
-});
+}).strict();
 export type TypeParameter = z.infer<typeof TypeParameterSchema>;
 
 export const PurpleSignatureSchema = z.object({
@@ -560,7 +560,7 @@ export const PurpleSignatureSchema = z.object({
     "name": z.string(),
     "parameters": z.array(GetSignatureSchema),
     "type": TentacledTypeSchema,
-});
+}).strict();
 export type PurpleSignature = z.infer<typeof PurpleSignatureSchema>;
 
 export const FluffySignatureSchema = z.object({
@@ -576,7 +576,7 @@ export const FluffySignatureSchema = z.object({
     "parameters": z.array(PurpleParameterSchema).optional(),
     "type": ExtendedBySchema,
     "typeParameter": z.array(GetSignatureSchema).optional(),
-});
+}).strict();
 export type FluffySignature = z.infer<typeof FluffySignatureSchema>;
 
 export const FluffyDeclarationSchema = z.object({
@@ -590,7 +590,7 @@ export const FluffyDeclarationSchema = z.object({
     "name": z.string(),
     "signatures": z.array(TentacledSignatureSchema).optional(),
     "sources": z.array(SourceSchema),
-});
+}).strict();
 export type FluffyDeclaration = z.infer<typeof FluffyDeclarationSchema>;
 
 export const AmbitiousTypeSchema = z.object({
@@ -600,7 +600,7 @@ export const AmbitiousTypeSchema = z.object({
     "name": z.string().optional(),
     "type": TypeEnumSchema,
     "typeArguments": z.array(ElementTypeSchema).optional(),
-});
+}).strict();
 export type AmbitiousType = z.infer<typeof AmbitiousTypeSchema>;
 
 export const IndecentChildSchema = z.object({
@@ -611,7 +611,7 @@ export const IndecentChildSchema = z.object({
     "name": z.string(),
     "sources": z.array(SourceSchema),
     "type": FriskyTypeSchema,
-});
+}).strict();
 export type IndecentChild = z.infer<typeof IndecentChildSchema>;
 
 export const TentacledChildSchema = z.object({
@@ -625,7 +625,7 @@ export const TentacledChildSchema = z.object({
     "signatures": z.array(PurpleSignatureSchema).optional(),
     "sources": z.array(SourceSchema),
     "type": TypeElementSchema.optional(),
-});
+}).strict();
 export type TentacledChild = z.infer<typeof TentacledChildSchema>;
 
 export const IndigoTypeSchema = z.object({
@@ -638,7 +638,7 @@ export const IndigoTypeSchema = z.object({
     "type": TypeEnumSchema,
     "typeArguments": z.array(PurpleTypeArgumentSchema).optional(),
     "types": z.array(TypeElementSchema).optional(),
-});
+}).strict();
 export type IndigoType = z.infer<typeof IndigoTypeSchema>;
 
 export const TentacledParameterSchema = z.object({
@@ -651,7 +651,7 @@ export const TentacledParameterSchema = z.object({
     "name": z.string(),
     "originalName": z.string().optional(),
     "type": AmbitiousTypeSchema,
-});
+}).strict();
 export type TentacledParameter = z.infer<typeof TentacledParameterSchema>;
 
 export const StickyDeclarationSchema = z.object({
@@ -664,7 +664,7 @@ export const StickyDeclarationSchema = z.object({
     "name": z.string(),
     "signatures": z.array(GetSignatureSchema),
     "sources": z.array(SourceSchema),
-});
+}).strict();
 export type StickyDeclaration = z.infer<typeof StickyDeclarationSchema>;
 
 export const FluffyChildSchema = z.object({
@@ -685,7 +685,7 @@ export const FluffyChildSchema = z.object({
     "signatures": z.array(FluffySignatureSchema).optional(),
     "sources": z.array(SourceSchema),
     "type": IndigoTypeSchema.optional(),
-});
+}).strict();
 export type FluffyChild = z.infer<typeof FluffyChildSchema>;
 
 export const StickySignatureSchema = z.object({
@@ -698,7 +698,7 @@ export const StickySignatureSchema = z.object({
     "parameters": z.array(TentacledParameterSchema).optional(),
     "type": CunningTypeSchema,
     "typeParameter": z.array(GetSignatureSchema).optional(),
-});
+}).strict();
 export type StickySignature = z.infer<typeof StickySignatureSchema>;
 
 export const MagentaTypeSchema = z.object({
@@ -711,7 +711,7 @@ export const MagentaTypeSchema = z.object({
     "typeArguments": z.array(FluffyTypeArgumentSchema).optional(),
     "types": z.array(ExtendedBySchema).optional(),
     "value": z.string().optional(),
-});
+}).strict();
 export type MagentaType = z.infer<typeof MagentaTypeSchema>;
 
 export const PurpleChildSchema = z.object({
@@ -732,7 +732,7 @@ export const PurpleChildSchema = z.object({
     "sources": z.array(SourceSchema),
     "type": MagentaTypeSchema.optional(),
     "typeParameter": z.array(TypeParameterSchema).optional(),
-});
+}).strict();
 export type PurpleChild = z.infer<typeof PurpleChildSchema>;
 
 export const TopLevelChildSchema = z.object({
@@ -746,7 +746,7 @@ export const TopLevelChildSchema = z.object({
     "name": z.string(),
     "originalName": z.string(),
     "sources": z.array(SourceSchema),
-});
+}).strict();
 export type TopLevelChild = z.infer<typeof TopLevelChildSchema>;
 
 export const TopLevelSchema = z.object({
@@ -756,5 +756,5 @@ export const TopLevelSchema = z.object({
     "id": z.number().int(),
     "kind": z.number().int(),
     "name": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/bug790.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/bug790.json/default/TopLevel.ts
index c5f76b2..b9bc177 100644
--- a/base/typescript-zod/test/inputs/json/priority/bug790.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/bug790.json/default/TopLevel.ts
@@ -21,5 +21,5 @@ export const TopLevelSchema: z.ZodType<TopLevel> = z.lazy(() =>
         "parent_id": z.number().int(),
         "position": z.number().int(),
         "product_count": z.number().int(),
-    })
+    }).strict()
 );
diff --git a/base/typescript-zod/test/inputs/json/priority/bug855-short.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/bug855-short.json/default/TopLevel.ts
index 6e57a34..fcf97e0 100644
--- a/base/typescript-zod/test/inputs/json/priority/bug855-short.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/bug855-short.json/default/TopLevel.ts
@@ -7,7 +7,7 @@ export const TopLevelValueSchema = z.object({
     "code": z.string(),
     "emoticon_set": z.number().int(),
     "id": z.number().int(),
-});
+}).strict();
 export type TopLevelValue = z.infer<typeof TopLevelValueSchema>;
 
 export const TopLevelSchema = z.record(z.string(), TopLevelValueSchema);
diff --git a/base/typescript-zod/test/inputs/json/priority/bug863.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/bug863.json/default/TopLevel.ts
index b22a547..a64b2a5 100644
--- a/base/typescript-zod/test/inputs/json/priority/bug863.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/bug863.json/default/TopLevel.ts
@@ -64,7 +64,7 @@ export const PurpleTopLevelSchema = z.object({
     "RANK": z.number().int(),
     "RANK_TITLE": RankTitleSchema,
     "SEX": SexSchema,
-});
+}).strict();
 export type PurpleTopLevel = z.infer<typeof PurpleTopLevelSchema>;
 
 export const FluffyTopLevelSchema = z.object({
@@ -103,7 +103,7 @@ export const FluffyTopLevelSchema = z.object({
     "SOLIDERCOUNT": z.number().int(),
     "SOLITUSCOUNT": z.number().int(),
     "TRADERCOUNT": z.number().int(),
-});
+}).strict();
 export type FluffyTopLevel = z.infer<typeof FluffyTopLevelSchema>;
 
 export const TopLevelSchema = z.array(z.union([z.array(PurpleTopLevelSchema), FluffyTopLevelSchema, z.string()]));
diff --git a/base/typescript-zod/test/inputs/json/priority/coin-pairs.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/coin-pairs.json/default/TopLevel.ts
index 1f3197a..d540a0a 100644
--- a/base/typescript-zod/test/inputs/json/priority/coin-pairs.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/coin-pairs.json/default/TopLevel.ts
@@ -10,11 +10,11 @@ export const PairSchema = z.object({
     "min_amount": z.number(),
     "min_price": z.number(),
     "min_total": z.number(),
-});
+}).strict();
 export type Pair = z.infer<typeof PairSchema>;
 
 export const TopLevelSchema = z.object({
     "pairs": z.record(z.string(), PairSchema),
     "server_time": z.number().int(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/combinations1.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/combinations1.json/default/TopLevel.ts
index a261f3c..06caa69 100644
--- a/base/typescript-zod/test/inputs/json/priority/combinations1.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/combinations1.json/default/TopLevel.ts
@@ -22,7 +22,7 @@ export const CerographClassSchema = z.object({
     "Tolowa": z.null(),
     "tradeful": z.null(),
     "unriveting": z.null(),
-});
+}).strict();
 export type CerographClass = z.infer<typeof CerographClassSchema>;
 
 export const ChemotherapeuticClassSchema = z.object({
@@ -51,7 +51,7 @@ export const ChemotherapeuticClassSchema = z.object({
     "stagmometer": z.null().optional(),
     "tetherball": z.null().optional(),
     "unshy": z.null().optional(),
-});
+}).strict();
 export type ChemotherapeuticClass = z.infer<typeof ChemotherapeuticClassSchema>;
 
 export const CimeliaClassSchema = z.object({
@@ -60,7 +60,7 @@ export const CimeliaClassSchema = z.object({
     "disdiapason": z.string(),
     "homocerc": z.boolean(),
     "nonbookish": z.null(),
-});
+}).strict();
 export type CimeliaClass = z.infer<typeof CimeliaClassSchema>;
 
 export const CoadjustClassSchema = z.object({
@@ -89,7 +89,7 @@ export const CoadjustClassSchema = z.object({
     "symbiot": z.null().optional(),
     "tablefellow": z.null().optional(),
     "unchargeable": z.null().optional(),
-});
+}).strict();
 export type CoadjustClass = z.infer<typeof CoadjustClassSchema>;
 
 export const CredulityClassSchema = z.object({
@@ -113,7 +113,7 @@ export const CredulityClassSchema = z.object({
     "seriality": z.null(),
     "vamphorn": z.null(),
     "wharp": z.null(),
-});
+}).strict();
 export type CredulityClass = z.infer<typeof CredulityClassSchema>;
 
 export const DeruralizeClassSchema = z.object({
@@ -137,7 +137,7 @@ export const DeruralizeClassSchema = z.object({
     "unnicked": z.null(),
     "unstavable": z.null(),
     "windfirm": z.null(),
-});
+}).strict();
 export type DeruralizeClass = z.infer<typeof DeruralizeClassSchema>;
 
 export const DiaereseClassSchema = z.object({
@@ -161,7 +161,7 @@ export const DiaereseClassSchema = z.object({
     "silker": z.null(),
     "subdentated": z.null(),
     "subobscure": z.null(),
-});
+}).strict();
 export type DiaereseClass = z.infer<typeof DiaereseClassSchema>;
 
 export const EncrustSchema = z.object({
@@ -185,7 +185,7 @@ export const EncrustSchema = z.object({
     "ungyved": z.null(),
     "whirlabout": z.null(),
     "woodenware": z.null(),
-});
+}).strict();
 export type Encrust = z.infer<typeof EncrustSchema>;
 
 export const FagginglyClassSchema = z.object({
@@ -209,7 +209,7 @@ export const FagginglyClassSchema = z.object({
     "soleas": z.null(),
     "unfastenable": z.null(),
     "unmillinered": z.null(),
-});
+}).strict();
 export type FagginglyClass = z.infer<typeof FagginglyClassSchema>;
 
 export const FenkClassSchema = z.object({
@@ -233,7 +233,7 @@ export const FenkClassSchema = z.object({
     "Tritoness": z.null(),
     "undergrade": z.null(),
     "undermountain": z.null(),
-});
+}).strict();
 export type FenkClass = z.infer<typeof FenkClassSchema>;
 
 export const FlagmakingClassSchema = z.object({
@@ -257,7 +257,7 @@ export const FlagmakingClassSchema = z.object({
     "unloveliness": z.null(),
     "unquarantined": z.null(),
     "unrenounceable": z.null(),
-});
+}).strict();
 export type FlagmakingClass = z.infer<typeof FlagmakingClassSchema>;
 
 export const HemocoeleClassSchema = z.object({
@@ -286,7 +286,7 @@ export const HemocoeleClassSchema = z.object({
     "untutelar": z.null().optional(),
     "vagrant": z.null().optional(),
     "Walt": z.null().optional(),
-});
+}).strict();
 export type HemocoeleClass = z.infer<typeof HemocoeleClassSchema>;
 
 export const InteracinarSchema = z.object({
@@ -295,7 +295,7 @@ export const InteracinarSchema = z.object({
     "triseriatim": z.string(),
     "tubbing": z.number().int(),
     "untrimmed": z.null(),
-});
+}).strict();
 export type Interacinar = z.infer<typeof InteracinarSchema>;
 
 export const TopLevelSchema = z.object({
@@ -342,5 +342,5 @@ export const TopLevelSchema = z.object({
     "interacinar": InteracinarSchema,
     "intercorrelation": z.array(z.union([z.null(), z.array(z.number().int())])),
     "jacutinga": z.array(z.union([z.array(z.number().int()), z.record(z.string(), z.union([z.null(), z.number().int()]))])),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/combinations2.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/combinations2.json/default/TopLevel.ts
index c94cf89..3221c74 100644
--- a/base/typescript-zod/test/inputs/json/priority/combinations2.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/combinations2.json/default/TopLevel.ts
@@ -22,7 +22,7 @@ export const AlleviateClassSchema = z.object({
     "unparking": z.null(),
     "unvarnishedness": z.null(),
     "wherewithal": z.null(),
-});
+}).strict();
 export type AlleviateClass = z.infer<typeof AlleviateClassSchema>;
 
 export const RebeccaSchema = z.object({
@@ -31,7 +31,7 @@ export const RebeccaSchema = z.object({
     "disdiapason": z.string(),
     "homocerc": z.boolean(),
     "nonbookish": z.null(),
-});
+}).strict();
 export type Rebecca = z.infer<typeof RebeccaSchema>;
 
 export const AmphithyronSchema = z.object({
@@ -60,7 +60,7 @@ export const AmphithyronSchema = z.object({
     "stagnum": z.number().int().optional(),
     "Those": z.number().int().optional(),
     "undecimal": z.number().int().optional(),
-});
+}).strict();
 export type Amphithyron = z.infer<typeof AmphithyronSchema>;
 
 export const AnkeeClassSchema = z.object({
@@ -84,7 +84,7 @@ export const AnkeeClassSchema = z.object({
     "tracheophone": z.null(),
     "tuglike": z.null(),
     "unscratchingly": z.null(),
-});
+}).strict();
 export type AnkeeClass = z.infer<typeof AnkeeClassSchema>;
 
 export const AnsarieClassSchema = z.object({
@@ -108,7 +108,7 @@ export const AnsarieClassSchema = z.object({
     "water": z.null(),
     "zestfully": z.null(),
     "zincic": z.null(),
-});
+}).strict();
 export type AnsarieClass = z.infer<typeof AnsarieClassSchema>;
 
 export const ChytridiaceaeClassSchema = z.object({
@@ -132,7 +132,7 @@ export const ChytridiaceaeClassSchema = z.object({
     "uckia": z.null(),
     "unmettle": z.null(),
     "vorticellid": z.null(),
-});
+}).strict();
 export type ChytridiaceaeClass = z.infer<typeof ChytridiaceaeClassSchema>;
 
 export const DiscordiaClassSchema = z.object({
@@ -161,7 +161,7 @@ export const DiscordiaClassSchema = z.object({
     "swow": z.number().int().optional(),
     "wastrel": z.number().int().optional(),
     "wingle": z.number().int().optional(),
-});
+}).strict();
 export type DiscordiaClass = z.infer<typeof DiscordiaClassSchema>;
 
 export const GryphosaurusClassSchema = z.object({
@@ -185,7 +185,7 @@ export const GryphosaurusClassSchema = z.object({
     "Tahami": z.null(),
     "undaubed": z.null(),
     "underntime": z.null(),
-});
+}).strict();
 export type GryphosaurusClass = z.infer<typeof GryphosaurusClassSchema>;
 
 export const LaviniaClassSchema = z.object({
@@ -214,7 +214,7 @@ export const LaviniaClassSchema = z.object({
     "tranquillize": z.number().int().optional(),
     "unquestionable": z.number().int().optional(),
     "uproute": z.number().int().optional(),
-});
+}).strict();
 export type LaviniaClass = z.infer<typeof LaviniaClassSchema>;
 
 export const OskarClassSchema = z.object({
@@ -238,7 +238,7 @@ export const OskarClassSchema = z.object({
     "teachment": z.null(),
     "unmutinous": z.null(),
     "unstoppable": z.null(),
-});
+}).strict();
 export type OskarClass = z.infer<typeof OskarClassSchema>;
 
 export const TopLevelSchema = z.object({
@@ -287,5 +287,5 @@ export const TopLevelSchema = z.object({
     "Shakespearolater": z.array(z.union([z.array(z.number().int()), z.number(), z.string()])),
     "Svan": z.array(z.number()),
     "Wayao": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/combinations3.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/combinations3.json/default/TopLevel.ts
index f997a6c..e38a0f5 100644
--- a/base/typescript-zod/test/inputs/json/priority/combinations3.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/combinations3.json/default/TopLevel.ts
@@ -22,7 +22,7 @@ export const JurorClassSchema = z.object({
     "uncontemporary": z.null(),
     "uncouched": z.null(),
     "uninhabitedness": z.null(),
-});
+}).strict();
 export type JurorClass = z.infer<typeof JurorClassSchema>;
 
 export const LadronismClassSchema = z.object({
@@ -46,7 +46,7 @@ export const LadronismClassSchema = z.object({
     "uplook": z.null(),
     "vermiformis": z.null(),
     "whafabout": z.null(),
-});
+}).strict();
 export type LadronismClass = z.infer<typeof LadronismClassSchema>;
 
 export const LandlubberlyClassSchema = z.object({
@@ -70,7 +70,7 @@ export const LandlubberlyClassSchema = z.object({
     "saddling": z.null(),
     "subcurrent": z.null(),
     "unrecriminative": z.null(),
-});
+}).strict();
 export type LandlubberlyClass = z.infer<typeof LandlubberlyClassSchema>;
 
 export const LupusClassSchema = z.object({
@@ -99,7 +99,7 @@ export const LupusClassSchema = z.object({
     "unsignificantly": z.number().int().optional(),
     "unsnap": z.number().int().optional(),
     "vendible": z.number().int().optional(),
-});
+}).strict();
 export type LupusClass = z.infer<typeof LupusClassSchema>;
 
 export const MaslinSchema = z.object({
@@ -148,7 +148,7 @@ export const MaslinSchema = z.object({
     "unassuaged": z.number().int().optional(),
     "ungross": z.null().optional(),
     "unjudiciously": z.null().optional(),
-});
+}).strict();
 export type Maslin = z.infer<typeof MaslinSchema>;
 
 export const MonaziteClassSchema = z.object({
@@ -157,7 +157,7 @@ export const MonaziteClassSchema = z.object({
     "disdiapason": z.string(),
     "homocerc": z.boolean(),
     "nonbookish": z.null(),
-});
+}).strict();
 export type MonaziteClass = z.infer<typeof MonaziteClassSchema>;
 
 export const MonotheisticallyClassSchema = z.object({
@@ -186,7 +186,7 @@ export const MonotheisticallyClassSchema = z.object({
     "superedification": z.null().optional(),
     "trust": z.null().optional(),
     "whitestone": z.null().optional(),
-});
+}).strict();
 export type MonotheisticallyClass = z.infer<typeof MonotheisticallyClassSchema>;
 
 export const NoncontributingSchema = z.object({
@@ -195,7 +195,7 @@ export const NoncontributingSchema = z.object({
     "sauternes": z.number().int(),
     "sparsely": z.boolean(),
     "unrequested": z.null(),
-});
+}).strict();
 export type Noncontributing = z.infer<typeof NoncontributingSchema>;
 
 export const OccupationalistClassSchema = z.object({
@@ -219,7 +219,7 @@ export const OccupationalistClassSchema = z.object({
     "tingitid": z.null(),
     "trailless": z.null(),
     "unpocketed": z.null(),
-});
+}).strict();
 export type OccupationalistClass = z.infer<typeof OccupationalistClassSchema>;
 
 export const OutrivalClassSchema = z.object({
@@ -243,7 +243,7 @@ export const OutrivalClassSchema = z.object({
     "rebellious": z.null(),
     "recodify": z.null(),
     "unpaced": z.null(),
-});
+}).strict();
 export type OutrivalClass = z.infer<typeof OutrivalClassSchema>;
 
 export const PiaculumClassSchema = z.object({
@@ -272,7 +272,7 @@ export const PiaculumClassSchema = z.object({
     "thorax": z.number().int().optional(),
     "yachting": z.number().int().optional(),
     "Zipper": z.number().int().optional(),
-});
+}).strict();
 export type PiaculumClass = z.infer<typeof PiaculumClassSchema>;
 
 export const PneumoceleSchema = z.object({
@@ -301,7 +301,7 @@ export const PneumoceleSchema = z.object({
     "taillight": z.null().optional(),
     "unjealous": z.null().optional(),
     "visitorial": z.null().optional(),
-});
+}).strict();
 export type Pneumocele = z.infer<typeof PneumoceleSchema>;
 
 export const PotwhiskyClassSchema = z.object({
@@ -325,7 +325,7 @@ export const PotwhiskyClassSchema = z.object({
     "thrashel": z.null(),
     "tyremesis": z.null(),
     "Yoruba": z.null(),
-});
+}).strict();
 export type PotwhiskyClass = z.infer<typeof PotwhiskyClassSchema>;
 
 export const PrefreshmanClassSchema = z.object({
@@ -349,7 +349,7 @@ export const PrefreshmanClassSchema = z.object({
     "scutatiform": z.null(),
     "theodolite": z.null(),
     "underward": z.null(),
-});
+}).strict();
 export type PrefreshmanClass = z.infer<typeof PrefreshmanClassSchema>;
 
 export const TopLevelSchema = z.object({
@@ -395,5 +395,5 @@ export const TopLevelSchema = z.object({
     "prevoidance": z.array(z.union([z.array(z.number().int()), MonaziteClassSchema, z.number().int()])),
     "probant": z.array(z.record(z.string(), z.union([z.null(), z.number().int()]))),
     "protext": z.array(z.union([z.array(z.number().int()), z.boolean(), MonaziteClassSchema])),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/combinations4.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/combinations4.json/default/TopLevel.ts
index 6631e70..28723ac 100644
--- a/base/typescript-zod/test/inputs/json/priority/combinations4.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/combinations4.json/default/TopLevel.ts
@@ -22,7 +22,7 @@ export const PulpitismClassSchema = z.object({
     "syllabe": z.null(),
     "toughhead": z.null(),
     "underburn": z.null(),
-});
+}).strict();
 export type PulpitismClass = z.infer<typeof PulpitismClassSchema>;
 
 export const PyodermiaClassSchema = z.object({
@@ -46,7 +46,7 @@ export const PyodermiaClassSchema = z.object({
     "unclothedly": z.null(),
     "unimplied": z.null(),
     "unsyncopated": z.null(),
-});
+}).strict();
 export type PyodermiaClass = z.infer<typeof PyodermiaClassSchema>;
 
 export const QuebrachineClassSchema = z.object({
@@ -55,7 +55,7 @@ export const QuebrachineClassSchema = z.object({
     "disdiapason": z.string(),
     "homocerc": z.boolean(),
     "nonbookish": z.null(),
-});
+}).strict();
 export type QuebrachineClass = z.infer<typeof QuebrachineClassSchema>;
 
 export const ReimagineSchema = z.object({
@@ -84,7 +84,7 @@ export const ReimagineSchema = z.object({
     "subdie": z.null().optional(),
     "tibiometatarsal": z.null().optional(),
     "waltzlike": z.null().optional(),
-});
+}).strict();
 export type Reimagine = z.infer<typeof ReimagineSchema>;
 
 export const RessautSchema = z.object({
@@ -108,7 +108,7 @@ export const RessautSchema = z.object({
     "Theopaschitism": z.string(),
     "undurableness": z.string(),
     "unmingleable": z.string(),
-});
+}).strict();
 export type Ressaut = z.infer<typeof RessautSchema>;
 
 export const RewriteClassSchema = z.object({
@@ -132,7 +132,7 @@ export const RewriteClassSchema = z.object({
     "vertical": z.null(),
     "Whiggification": z.null(),
     "yardman": z.null(),
-});
+}).strict();
 export type RewriteClass = z.infer<typeof RewriteClassSchema>;
 
 export const SantirClassSchema = z.object({
@@ -156,7 +156,7 @@ export const SantirClassSchema = z.object({
     "timelily": z.null(),
     "unprofaned": z.null(),
     "vorticular": z.null(),
-});
+}).strict();
 export type SantirClass = z.infer<typeof SantirClassSchema>;
 
 export const SaxtenClassSchema = z.object({
@@ -185,7 +185,7 @@ export const SaxtenClassSchema = z.object({
     "trunchman": z.null().optional(),
     "urger": z.null().optional(),
     "withdrawnness": z.null().optional(),
-});
+}).strict();
 export type SaxtenClass = z.infer<typeof SaxtenClassSchema>;
 
 export const ScattySchema = z.object({
@@ -209,7 +209,7 @@ export const ScattySchema = z.object({
     "Tabasco": z.null(),
     "teleianthous": z.null(),
     "uncombated": z.null(),
-});
+}).strict();
 export type Scatty = z.infer<typeof ScattySchema>;
 
 export const SisteringClassSchema = z.object({
@@ -233,7 +233,7 @@ export const SisteringClassSchema = z.object({
     "unmixable": z.null(),
     "untruckling": z.null(),
     "vineal": z.null(),
-});
+}).strict();
 export type SisteringClass = z.infer<typeof SisteringClassSchema>;
 
 export const StaghuntingSchema = z.object({
@@ -262,7 +262,7 @@ export const StaghuntingSchema = z.object({
     "trifid": z.number().int().optional(),
     "undefeatedly": z.number().int().optional(),
     "ungirlish": z.number().int().optional(),
-});
+}).strict();
 export type Staghunting = z.infer<typeof StaghuntingSchema>;
 
 export const StrenuosityClassSchema = z.object({
@@ -291,7 +291,7 @@ export const StrenuosityClassSchema = z.object({
     "undueness": z.number().int().optional(),
     "worthily": z.number().int().optional(),
     "Yankeeist": z.number().int().optional(),
-});
+}).strict();
 export type StrenuosityClass = z.infer<typeof StrenuosityClassSchema>;
 
 export const TruantcyClassSchema = z.object({
@@ -320,7 +320,7 @@ export const TruantcyClassSchema = z.object({
     "skelder": z.null().optional(),
     "windwaywardly": z.null().optional(),
     "Yuman": z.null().optional(),
-});
+}).strict();
 export type TruantcyClass = z.infer<typeof TruantcyClassSchema>;
 
 export const UnimpeachablyClassSchema = z.object({
@@ -349,7 +349,7 @@ export const UnimpeachablyClassSchema = z.object({
     "tussocker": z.number().int().optional(),
     "ultraproud": z.number().int().optional(),
     "unsuggestedness": z.number().int().optional(),
-});
+}).strict();
 export type UnimpeachablyClass = z.infer<typeof UnimpeachablyClassSchema>;
 
 export const UnstressedClassSchema = z.object({
@@ -373,7 +373,7 @@ export const UnstressedClassSchema = z.object({
     "undecreed": z.null(),
     "venerable": z.null(),
     "vowellessness": z.null(),
-});
+}).strict();
 export type UnstressedClass = z.infer<typeof UnstressedClassSchema>;
 
 export const WrothyClassSchema = z.object({
@@ -397,7 +397,7 @@ export const WrothyClassSchema = z.object({
     "transhumance": z.null(),
     "triandrian": z.null(),
     "unbooked": z.null(),
-});
+}).strict();
 export type WrothyClass = z.infer<typeof WrothyClassSchema>;
 
 export const TopLevelSchema = z.object({
@@ -453,5 +453,5 @@ export const TopLevelSchema = z.object({
     "warriorship": z.record(z.string(), z.boolean()),
     "whitepot": z.array(z.union([QuebrachineClassSchema, z.number()])),
     "wrothy": z.array(z.union([z.array(z.null()), WrothyClassSchema])),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/combined-enum.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/combined-enum.json/default/TopLevel.ts
index 0dfb593..eec246a 100644
--- a/base/typescript-zod/test/inputs/json/priority/combined-enum.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/combined-enum.json/default/TopLevel.ts
@@ -10,11 +10,11 @@ export type X = z.infer<typeof XSchema>;
 
 export const BarSchema = z.object({
     "x": XSchema,
-});
+}).strict();
 export type Bar = z.infer<typeof BarSchema>;
 
 export const TopLevelSchema = z.object({
     "bar": z.array(BarSchema),
     "foo": z.array(BarSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/direct-recursive.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/direct-recursive.json/default/TopLevel.ts
index b52907b..ffb7a6b 100644
--- a/base/typescript-zod/test/inputs/json/priority/direct-recursive.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/direct-recursive.json/default/TopLevel.ts
@@ -15,5 +15,5 @@ export const TopLevelSchema: z.ZodType<TopLevel> = z.lazy(() =>
         "foo": z.number().int(),
         "moo": z.number(),
         "quux": z.string(),
-    })
+    }).strict()
 );
diff --git a/base/typescript-zod/test/inputs/json/priority/empty-enum.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/empty-enum.json/default/TopLevel.ts
index 9927b1f..a8e7ae0 100644
--- a/base/typescript-zod/test/inputs/json/priority/empty-enum.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/empty-enum.json/default/TopLevel.ts
@@ -3,10 +3,10 @@ import * as z from "zod";
 
 export const FooSchema = z.object({
     "bar": z.string().optional(),
-});
+}).strict();
 export type Foo = z.infer<typeof FooSchema>;
 
 export const TopLevelSchema = z.object({
     "foo": z.array(FooSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/identifiers.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/identifiers.json/default/TopLevel.ts
index 5a20e77..31baca7 100644
--- a/base/typescript-zod/test/inputs/json/priority/identifiers.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/identifiers.json/default/TopLevel.ts
@@ -3,34 +3,34 @@ import * as z from "zod";
 
 export const TopLevelBlaSchema = z.object({
     "bar": z.number().int(),
-});
+}).strict();
 export type TopLevelBla = z.infer<typeof TopLevelBlaSchema>;
 
 export const EmptySchema = z.object({
     "x": z.number().int(),
-});
+}).strict();
 export type Empty = z.infer<typeof EmptySchema>;
 
 export const FooBlaSchema = z.object({
-});
+}).strict();
 export type FooBla = z.infer<typeof FooBlaSchema>;
 
 export const ThisIsAToughOneSchema = z.object({
     "\n\n\n": z.number().int(),
     "\"": z.number().int(),
-});
+}).strict();
 export type ThisIsAToughOne = z.infer<typeof ThisIsAToughOneSchema>;
 
 export const EmptyClassSchema = z.object({
     "y": z.number().int(),
-});
+}).strict();
 export type EmptyClass = z.infer<typeof EmptyClassSchema>;
 
 export const FooSchema = z.object({
     "bla": FooBlaSchema,
     "_": z.number().int(),
     "__": z.number().int(),
-});
+}).strict();
 export type Foo = z.infer<typeof FooSchema>;
 
 export const TopLevelSchema = z.object({
@@ -40,5 +40,5 @@ export const TopLevelSchema = z.object({
     "ThisIsA\ud83d\ude1cTough\"\n\nOne": ThisIsAToughOneSchema,
     "!": z.number().int(),
     "Empty": EmptyClassSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.ts
index cdfaff4..b237296 100644
--- a/base/typescript-zod/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/issue2680-object-array.json/default/TopLevel.ts
@@ -3,7 +3,7 @@ import * as z from "zod";
 
 export const TopLevelElementSchema = z.object({
     "key": z.string(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/priority/keywords.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/keywords.json/default/TopLevel.ts
index 2950ede..e6794c1 100644
--- a/base/typescript-zod/test/inputs/json/priority/keywords.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/keywords.json/default/TopLevel.ts
@@ -3,1397 +3,1397 @@ import * as z from "zod";
 
 export const AbstractSchema = z.object({
     "abstract": z.number().int(),
-});
+}).strict();
 export type Abstract = z.infer<typeof AbstractSchema>;
 
 export const AlignasSchema = z.object({
     "alignas": z.number().int(),
-});
+}).strict();
 export type Alignas = z.infer<typeof AlignasSchema>;
 
 export const AlignofSchema = z.object({
     "alignof": z.number().int(),
-});
+}).strict();
 export type Alignof = z.infer<typeof AlignofSchema>;
 
 export const AndSchema = z.object({
     "and": z.number().int(),
-});
+}).strict();
 export type And = z.infer<typeof AndSchema>;
 
 export const AndEqSchema = z.object({
     "and_eq": z.number().int(),
-});
+}).strict();
 export type AndEq = z.infer<typeof AndEqSchema>;
 
 export const AnySchema = z.object({
     "Any": z.number().int(),
-});
+}).strict();
 export type Any = z.infer<typeof AnySchema>;
 
 export const ArrayClassSchema = z.object({
     "array": z.number().int(),
-});
+}).strict();
 export type ArrayClass = z.infer<typeof ArrayClassSchema>;
 
 export const AsSchema = z.object({
     "as": z.number().int(),
-});
+}).strict();
 export type As = z.infer<typeof AsSchema>;
 
 export const AsmSchema = z.object({
     "asm": z.number().int(),
-});
+}).strict();
 export type Asm = z.infer<typeof AsmSchema>;
 
 export const AssertSchema = z.object({
     "assert": z.number().int(),
-});
+}).strict();
 export type Assert = z.infer<typeof AssertSchema>;
 
 export const AssociatedtypeSchema = z.object({
     "associatedtype": z.number().int(),
-});
+}).strict();
 export type Associatedtype = z.infer<typeof AssociatedtypeSchema>;
 
 export const AssociativitySchema = z.object({
     "associativity": z.number().int(),
-});
+}).strict();
 export type Associativity = z.infer<typeof AssociativitySchema>;
 
 export const AsyncSchema = z.object({
     "async": z.number().int(),
-});
+}).strict();
 export type Async = z.infer<typeof AsyncSchema>;
 
 export const AtomicSchema = z.object({
     "atomic": z.number().int(),
-});
+}).strict();
 export type Atomic = z.infer<typeof AtomicSchema>;
 
 export const AtomicCancelSchema = z.object({
     "atomic_cancel": z.number().int(),
-});
+}).strict();
 export type AtomicCancel = z.infer<typeof AtomicCancelSchema>;
 
 export const AtomicCommitSchema = z.object({
     "atomic_commit": z.number().int(),
-});
+}).strict();
 export type AtomicCommit = z.infer<typeof AtomicCommitSchema>;
 
 export const AtomicNoexceptSchema = z.object({
     "atomic_noexcept": z.number().int(),
-});
+}).strict();
 export type AtomicNoexcept = z.infer<typeof AtomicNoexceptSchema>;
 
 export const AutoSchema = z.object({
     "auto": z.number().int(),
-});
+}).strict();
 export type Auto = z.infer<typeof AutoSchema>;
 
 export const AwaitSchema = z.object({
     "await": z.number().int(),
-});
+}).strict();
 export type Await = z.infer<typeof AwaitSchema>;
 
 export const BaseSchema = z.object({
     "base": z.number().int(),
-});
+}).strict();
 export type Base = z.infer<typeof BaseSchema>;
 
 export const BitandSchema = z.object({
     "bitand": z.number().int(),
-});
+}).strict();
 export type Bitand = z.infer<typeof BitandSchema>;
 
 export const BitorSchema = z.object({
     "bitor": z.number().int(),
-});
+}).strict();
 export type Bitor = z.infer<typeof BitorSchema>;
 
 export const BoolSchema = z.object({
     "BOOL": z.number().int(),
-});
+}).strict();
 export type Bool = z.infer<typeof BoolSchema>;
 
 export const BooleanSchema = z.object({
     "boolean": z.number().int(),
-});
+}).strict();
 export type Boolean = z.infer<typeof BooleanSchema>;
 
 export const BreakSchema = z.object({
     "break": z.number().int(),
-});
+}).strict();
 export type Break = z.infer<typeof BreakSchema>;
 
 export const BycopySchema = z.object({
     "bycopy": z.number().int(),
-});
+}).strict();
 export type Bycopy = z.infer<typeof BycopySchema>;
 
 export const ByrefSchema = z.object({
     "byref": z.number().int(),
-});
+}).strict();
 export type Byref = z.infer<typeof ByrefSchema>;
 
 export const ByteSchema = z.object({
     "byte": z.number().int(),
-});
+}).strict();
 export type Byte = z.infer<typeof ByteSchema>;
 
 export const CaseSchema = z.object({
     "case": z.number().int(),
-});
+}).strict();
 export type Case = z.infer<typeof CaseSchema>;
 
 export const CatchSchema = z.object({
     "catch": z.number().int(),
-});
+}).strict();
 export type Catch = z.infer<typeof CatchSchema>;
 
 export const ChanSchema = z.object({
     "chan": z.number().int(),
-});
+}).strict();
 export type Chan = z.infer<typeof ChanSchema>;
 
 export const CharSchema = z.object({
     "char": z.number().int(),
-});
+}).strict();
 export type Char = z.infer<typeof CharSchema>;
 
 export const Char16TSchema = z.object({
     "char16_t": z.number().int(),
-});
+}).strict();
 export type Char16T = z.infer<typeof Char16TSchema>;
 
 export const Char32TSchema = z.object({
     "char32_t": z.number().int(),
-});
+}).strict();
 export type Char32T = z.infer<typeof Char32TSchema>;
 
 export const CheckedSchema = z.object({
     "checked": z.number().int(),
-});
+}).strict();
 export type Checked = z.infer<typeof CheckedSchema>;
 
 export const ClassClassSchema = z.object({
     "Class": z.number().int(),
-});
+}).strict();
 export type ClassClass = z.infer<typeof ClassClassSchema>;
 
 export const CloneSchema = z.object({
     "clone": z.number().int(),
-});
+}).strict();
 export type Clone = z.infer<typeof CloneSchema>;
 
 export const CoAwaitSchema = z.object({
     "co_await": z.number().int(),
-});
+}).strict();
 export type CoAwait = z.infer<typeof CoAwaitSchema>;
 
 export const CoReturnSchema = z.object({
     "co_return": z.number().int(),
-});
+}).strict();
 export type CoReturn = z.infer<typeof CoReturnSchema>;
 
 export const CoYieldSchema = z.object({
     "co_yield": z.number().int(),
-});
+}).strict();
 export type CoYield = z.infer<typeof CoYieldSchema>;
 
 export const ComplSchema = z.object({
     "compl": z.number().int(),
-});
+}).strict();
 export type Compl = z.infer<typeof ComplSchema>;
 
 export const ComplexSchema = z.object({
     "_Complex": z.number().int(),
-});
+}).strict();
 export type Complex = z.infer<typeof ComplexSchema>;
 
 export const ConceptSchema = z.object({
     "concept": z.number().int(),
-});
+}).strict();
 export type Concept = z.infer<typeof ConceptSchema>;
 
 export const ConsoleSchema = z.object({
     "console": z.number().int(),
-});
+}).strict();
 export type Console = z.infer<typeof ConsoleSchema>;
 
 export const ConstSchema = z.object({
     "const": z.number().int(),
-});
+}).strict();
 export type Const = z.infer<typeof ConstSchema>;
 
 export const ConstCastSchema = z.object({
     "const_cast": z.number().int(),
-});
+}).strict();
 export type ConstCast = z.infer<typeof ConstCastSchema>;
 
 export const ConstexprSchema = z.object({
     "constexpr": z.number().int(),
-});
+}).strict();
 export type Constexpr = z.infer<typeof ConstexprSchema>;
 
 export const ConstructorSchema = z.object({
     "constructor": z.number().int(),
-});
+}).strict();
 export type Constructor = z.infer<typeof ConstructorSchema>;
 
 export const ContinueSchema = z.object({
     "continue": z.number().int(),
-});
+}).strict();
 export type Continue = z.infer<typeof ContinueSchema>;
 
 export const ConvenienceSchema = z.object({
     "convenience": z.number().int(),
-});
+}).strict();
 export type Convenience = z.infer<typeof ConvenienceSchema>;
 
 export const ConvertSchema = z.object({
     "convert": z.number().int(),
-});
+}).strict();
 export type Convert = z.infer<typeof ConvertSchema>;
 
 export const ConverterSchema = z.object({
     "converter": z.number().int(),
-});
+}).strict();
 export type Converter = z.infer<typeof ConverterSchema>;
 
 export const DateClassSchema = z.object({
     "date": z.number().int(),
-});
+}).strict();
 export type DateClass = z.infer<typeof DateClassSchema>;
 
 export const DateParseHandlingSchema = z.object({
     "date_parse_handling": z.number().int(),
-});
+}).strict();
 export type DateParseHandling = z.infer<typeof DateParseHandlingSchema>;
 
 export const DebuggerSchema = z.object({
     "debugger": z.number().int(),
-});
+}).strict();
 export type Debugger = z.infer<typeof DebuggerSchema>;
 
 export const DecimalSchema = z.object({
     "decimal": z.number().int(),
-});
+}).strict();
 export type Decimal = z.infer<typeof DecimalSchema>;
 
 export const DeclareSchema = z.object({
     "declare": z.number().int(),
-});
+}).strict();
 export type Declare = z.infer<typeof DeclareSchema>;
 
 export const DecltypeSchema = z.object({
     "decltype": z.number().int(),
-});
+}).strict();
 export type Decltype = z.infer<typeof DecltypeSchema>;
 
 export const DecodeStringSchema = z.object({
     "decode_string": z.number().int(),
-});
+}).strict();
 export type DecodeString = z.infer<typeof DecodeStringSchema>;
 
 export const EmptySchema = z.object({
     "_": z.number().int(),
-});
+}).strict();
 export type Empty = z.infer<typeof EmptySchema>;
 
 export const ImaginerySchema = z.object({
     "_Imaginery": z.number().int(),
-});
+}).strict();
 export type Imaginery = z.infer<typeof ImaginerySchema>;
 
 export const AnyClassSchema = z.object({
     "any": z.number().int(),
-});
+}).strict();
 export type AnyClass = z.infer<typeof AnyClassSchema>;
 
 export const BoolClassSchema = z.object({
     "_Bool": z.number().int(),
-});
+}).strict();
 export type BoolClass = z.infer<typeof BoolClassSchema>;
 
 export const Obj1ClassSchema = z.object({
     "class": z.number().int(),
-});
+}).strict();
 export type Obj1Class = z.infer<typeof Obj1ClassSchema>;
 
 export const Obj1BoolSchema = z.object({
     "bool": z.number().int(),
-});
+}).strict();
 export type Obj1Bool = z.infer<typeof Obj1BoolSchema>;
 
 export const DefSchema = z.object({
     "def": z.number().int(),
-});
+}).strict();
 export type Def = z.infer<typeof DefSchema>;
 
 export const DefaultSchema = z.object({
     "default": z.number().int(),
-});
+}).strict();
 export type Default = z.infer<typeof DefaultSchema>;
 
 export const DeferSchema = z.object({
     "defer": z.number().int(),
-});
+}).strict();
 export type Defer = z.infer<typeof DeferSchema>;
 
 export const DeinitSchema = z.object({
     "deinit": z.number().int(),
-});
+}).strict();
 export type Deinit = z.infer<typeof DeinitSchema>;
 
 export const DelSchema = z.object({
     "del": z.number().int(),
-});
+}).strict();
 export type Del = z.infer<typeof DelSchema>;
 
 export const DelegateSchema = z.object({
     "delegate": z.number().int(),
-});
+}).strict();
 export type Delegate = z.infer<typeof DelegateSchema>;
 
 export const DeleteSchema = z.object({
     "delete": z.number().int(),
-});
+}).strict();
 export type Delete = z.infer<typeof DeleteSchema>;
 
 export const DictSchema = z.object({
     "dict": z.number().int(),
-});
+}).strict();
 export type Dict = z.infer<typeof DictSchema>;
 
 export const DictionarySchema = z.object({
     "dictionary": z.number().int(),
-});
+}).strict();
 export type Dictionary = z.infer<typeof DictionarySchema>;
 
 export const DidSetSchema = z.object({
     "didSet": z.number().int(),
-});
+}).strict();
 export type DidSet = z.infer<typeof DidSetSchema>;
 
 export const DoSchema = z.object({
     "do": z.number().int(),
-});
+}).strict();
 export type Do = z.infer<typeof DoSchema>;
 
 export const DoubleSchema = z.object({
     "double": z.number().int(),
-});
+}).strict();
 export type Double = z.infer<typeof DoubleSchema>;
 
 export const DynamicSchema = z.object({
     "dynamic": z.number().int(),
-});
+}).strict();
 export type Dynamic = z.infer<typeof DynamicSchema>;
 
 export const DynamicCastSchema = z.object({
     "dynamic_cast": z.number().int(),
-});
+}).strict();
 export type DynamicCast = z.infer<typeof DynamicCastSchema>;
 
 export const ElifSchema = z.object({
     "elif": z.number().int(),
-});
+}).strict();
 export type Elif = z.infer<typeof ElifSchema>;
 
 export const ElseSchema = z.object({
     "else": z.number().int(),
-});
+}).strict();
 export type Else = z.infer<typeof ElseSchema>;
 
 export const EncodeQuickTypeSchema = z.object({
     "encode_quick_type": z.number().int(),
-});
+}).strict();
 export type EncodeQuickType = z.infer<typeof EncodeQuickTypeSchema>;
 
 export const EnumSchema = z.object({
     "enum": z.number().int(),
-});
+}).strict();
 export type Enum = z.infer<typeof EnumSchema>;
 
 export const EqualityContractSchema = z.object({
     "equalityContract": z.number().int(),
-});
+}).strict();
 export type EqualityContract = z.infer<typeof EqualityContractSchema>;
 
 export const EventSchema = z.object({
     "event": z.number().int(),
-});
+}).strict();
 export type Event = z.infer<typeof EventSchema>;
 
 export const ExceptSchema = z.object({
     "except": z.number().int(),
-});
+}).strict();
 export type Except = z.infer<typeof ExceptSchema>;
 
 export const ExceptionSchema = z.object({
     "exception": z.number().int(),
-});
+}).strict();
 export type Exception = z.infer<typeof ExceptionSchema>;
 
 export const ExplicitSchema = z.object({
     "explicit": z.number().int(),
-});
+}).strict();
 export type Explicit = z.infer<typeof ExplicitSchema>;
 
 export const ExportSchema = z.object({
     "export": z.number().int(),
-});
+}).strict();
 export type Export = z.infer<typeof ExportSchema>;
 
 export const ExposingSchema = z.object({
     "exposing": z.number().int(),
-});
+}).strict();
 export type Exposing = z.infer<typeof ExposingSchema>;
 
 export const ExtendsSchema = z.object({
     "extends": z.number().int(),
-});
+}).strict();
 export type Extends = z.infer<typeof ExtendsSchema>;
 
 export const ExtensionSchema = z.object({
     "extension": z.number().int(),
-});
+}).strict();
 export type Extension = z.infer<typeof ExtensionSchema>;
 
 export const ExternSchema = z.object({
     "extern": z.number().int(),
-});
+}).strict();
 export type Extern = z.infer<typeof ExternSchema>;
 
 export const FallthroughSchema = z.object({
     "fallthrough": z.number().int(),
-});
+}).strict();
 export type Fallthrough = z.infer<typeof FallthroughSchema>;
 
 export const FalseSchema = z.object({
     "False": z.number().int(),
-});
+}).strict();
 export type False = z.infer<typeof FalseSchema>;
 
 export const FileprivateSchema = z.object({
     "fileprivate": z.number().int(),
-});
+}).strict();
 export type Fileprivate = z.infer<typeof FileprivateSchema>;
 
 export const FinalSchema = z.object({
     "final": z.number().int(),
-});
+}).strict();
 export type Final = z.infer<typeof FinalSchema>;
 
 export const FinallySchema = z.object({
     "finally": z.number().int(),
-});
+}).strict();
 export type Finally = z.infer<typeof FinallySchema>;
 
 export const FixedSchema = z.object({
     "fixed": z.number().int(),
-});
+}).strict();
 export type Fixed = z.infer<typeof FixedSchema>;
 
 export const FloatSchema = z.object({
     "float": z.number().int(),
-});
+}).strict();
 export type Float = z.infer<typeof FloatSchema>;
 
 export const ForSchema = z.object({
     "for": z.number().int(),
-});
+}).strict();
 export type For = z.infer<typeof ForSchema>;
 
 export const ForeachSchema = z.object({
     "foreach": z.number().int(),
-});
+}).strict();
 export type Foreach = z.infer<typeof ForeachSchema>;
 
 export const FriendSchema = z.object({
     "friend": z.number().int(),
-});
+}).strict();
 export type Friend = z.infer<typeof FriendSchema>;
 
 export const FromSchema = z.object({
     "from": z.number().int(),
-});
+}).strict();
 export type From = z.infer<typeof FromSchema>;
 
 export const FromJsonSchema = z.object({
     "from_json": z.number().int(),
-});
+}).strict();
 export type FromJson = z.infer<typeof FromJsonSchema>;
 
 export const FuncSchema = z.object({
     "func": z.number().int(),
-});
+}).strict();
 export type Func = z.infer<typeof FuncSchema>;
 
 export const FunctionSchema = z.object({
     "function": z.number().int(),
-});
+}).strict();
 export type Function = z.infer<typeof FunctionSchema>;
 
 export const GetSchema = z.object({
     "get": z.number().int(),
-});
+}).strict();
 export type Get = z.infer<typeof GetSchema>;
 
 export const GlobalSchema = z.object({
     "global": z.number().int(),
-});
+}).strict();
 export type Global = z.infer<typeof GlobalSchema>;
 
 export const GoSchema = z.object({
     "go": z.number().int(),
-});
+}).strict();
 export type Go = z.infer<typeof GoSchema>;
 
 export const GotoSchema = z.object({
     "goto": z.number().int(),
-});
+}).strict();
 export type Goto = z.infer<typeof GotoSchema>;
 
 export const GuardSchema = z.object({
     "guard": z.number().int(),
-});
+}).strict();
 export type Guard = z.infer<typeof GuardSchema>;
 
 export const HasOwnPropertySchema = z.object({
     "hasOwnProperty": z.number().int(),
-});
+}).strict();
 export type HasOwnProperty = z.infer<typeof HasOwnPropertySchema>;
 
 export const IdSchema = z.object({
     "id": z.number().int(),
-});
+}).strict();
 export type Id = z.infer<typeof IdSchema>;
 
 export const IfSchema = z.object({
     "if": z.number().int(),
-});
+}).strict();
 export type If = z.infer<typeof IfSchema>;
 
 export const ImpSchema = z.object({
     "IMP": z.number().int(),
-});
+}).strict();
 export type Imp = z.infer<typeof ImpSchema>;
 
 export const ImplementsSchema = z.object({
     "implements": z.number().int(),
-});
+}).strict();
 export type Implements = z.infer<typeof ImplementsSchema>;
 
 export const ImplicitSchema = z.object({
     "implicit": z.number().int(),
-});
+}).strict();
 export type Implicit = z.infer<typeof ImplicitSchema>;
 
 export const ImportSchema = z.object({
     "import": z.number().int(),
-});
+}).strict();
 export type Import = z.infer<typeof ImportSchema>;
 
 export const InSchema = z.object({
     "in": z.number().int(),
-});
+}).strict();
 export type In = z.infer<typeof InSchema>;
 
 export const IndirectSchema = z.object({
     "indirect": z.number().int(),
-});
+}).strict();
 export type Indirect = z.infer<typeof IndirectSchema>;
 
 export const InfixSchema = z.object({
     "infix": z.number().int(),
-});
+}).strict();
 export type Infix = z.infer<typeof InfixSchema>;
 
 export const InitSchema = z.object({
     "init": z.number().int(),
-});
+}).strict();
 export type Init = z.infer<typeof InitSchema>;
 
 export const InlineSchema = z.object({
     "inline": z.number().int(),
-});
+}).strict();
 export type Inline = z.infer<typeof InlineSchema>;
 
 export const InoutSchema = z.object({
     "inout": z.number().int(),
-});
+}).strict();
 export type Inout = z.infer<typeof InoutSchema>;
 
 export const InstanceofSchema = z.object({
     "instanceof": z.number().int(),
-});
+}).strict();
 export type Instanceof = z.infer<typeof InstanceofSchema>;
 
 export const IntSchema = z.object({
     "int": z.number().int(),
-});
+}).strict();
 export type Int = z.infer<typeof IntSchema>;
 
 export const InterfaceSchema = z.object({
     "interface": z.number().int(),
-});
+}).strict();
 export type Interface = z.infer<typeof InterfaceSchema>;
 
 export const InternalSchema = z.object({
     "internal": z.number().int(),
-});
+}).strict();
 export type Internal = z.infer<typeof InternalSchema>;
 
 export const FalseClassSchema = z.object({
     "false": z.number().int(),
-});
+}).strict();
 export type FalseClass = z.infer<typeof FalseClassSchema>;
 
 export const IsSchema = z.object({
     "is": z.number().int(),
-});
+}).strict();
 export type Is = z.infer<typeof IsSchema>;
 
 export const IterableSchema = z.object({
     "iterable": z.number().int(),
-});
+}).strict();
 export type Iterable = z.infer<typeof IterableSchema>;
 
 export const JdecSchema = z.object({
     "jdec": z.number().int(),
-});
+}).strict();
 export type Jdec = z.infer<typeof JdecSchema>;
 
 export const JencSchema = z.object({
     "jenc": z.number().int(),
-});
+}).strict();
 export type Jenc = z.infer<typeof JencSchema>;
 
 export const JpipeSchema = z.object({
     "jpipe": z.number().int(),
-});
+}).strict();
 export type Jpipe = z.infer<typeof JpipeSchema>;
 
 export const JsonSchema = z.object({
     "json": z.number().int(),
-});
+}).strict();
 export type Json = z.infer<typeof JsonSchema>;
 
 export const JsonConverterSchema = z.object({
     "json_converter": z.number().int(),
-});
+}).strict();
 export type JsonConverter = z.infer<typeof JsonConverterSchema>;
 
 export const JsonSerializerSchema = z.object({
     "json_serializer": z.number().int(),
-});
+}).strict();
 export type JsonSerializer = z.infer<typeof JsonSerializerSchema>;
 
 export const JsonTokenSchema = z.object({
     "json_token": z.number().int(),
-});
+}).strict();
 export type JsonToken = z.infer<typeof JsonTokenSchema>;
 
 export const JsonWriterSchema = z.object({
     "json_writer": z.number().int(),
-});
+}).strict();
 export type JsonWriter = z.infer<typeof JsonWriterSchema>;
 
 export const LambdaSchema = z.object({
     "lambda": z.number().int(),
-});
+}).strict();
 export type Lambda = z.infer<typeof LambdaSchema>;
 
 export const LazySchema = z.object({
     "lazy": z.number().int(),
-});
+}).strict();
 export type Lazy = z.infer<typeof LazySchema>;
 
 export const LeftSchema = z.object({
     "left": z.number().int(),
-});
+}).strict();
 export type Left = z.infer<typeof LeftSchema>;
 
 export const LetSchema = z.object({
     "let": z.number().int(),
-});
+}).strict();
 export type Let = z.infer<typeof LetSchema>;
 
 export const ListSchema = z.object({
     "list": z.number().int(),
-});
+}).strict();
 export type List = z.infer<typeof ListSchema>;
 
 export const LockSchema = z.object({
     "lock": z.number().int(),
-});
+}).strict();
 export type Lock = z.infer<typeof LockSchema>;
 
 export const LongSchema = z.object({
     "long": z.number().int(),
-});
+}).strict();
 export type Long = z.infer<typeof LongSchema>;
 
 export const MapSchema = z.object({
     "map": z.number().int(),
-});
+}).strict();
 export type Map = z.infer<typeof MapSchema>;
 
 export const MetadataPropertyHandlingSchema = z.object({
     "metadata_property_handling": z.number().int(),
-});
+}).strict();
 export type MetadataPropertyHandling = z.infer<typeof MetadataPropertyHandlingSchema>;
 
 export const ModuleSchema = z.object({
     "module": z.number().int(),
-});
+}).strict();
 export type Module = z.infer<typeof ModuleSchema>;
 
 export const MutableSchema = z.object({
     "mutable": z.number().int(),
-});
+}).strict();
 export type Mutable = z.infer<typeof MutableSchema>;
 
 export const MutatingSchema = z.object({
     "mutating": z.number().int(),
-});
+}).strict();
 export type Mutating = z.infer<typeof MutatingSchema>;
 
 export const NamespaceSchema = z.object({
     "namespace": z.number().int(),
-});
+}).strict();
 export type Namespace = z.infer<typeof NamespaceSchema>;
 
 export const NativeSchema = z.object({
     "native": z.number().int(),
-});
+}).strict();
 export type Native = z.infer<typeof NativeSchema>;
 
 export const NewSchema = z.object({
     "new": z.number().int(),
-});
+}).strict();
 export type New = z.infer<typeof NewSchema>;
 
 export const NewtonsoftSchema = z.object({
     "newtonsoft": z.number().int(),
-});
+}).strict();
 export type Newtonsoft = z.infer<typeof NewtonsoftSchema>;
 
 export const NilSchema = z.object({
     "nil": z.number().int(),
-});
+}).strict();
 export type Nil = z.infer<typeof NilSchema>;
 
 export const NoSchema = z.object({
     "NO": z.number().int(),
-});
+}).strict();
 export type No = z.infer<typeof NoSchema>;
 
 export const NoexceptSchema = z.object({
     "noexcept": z.number().int(),
-});
+}).strict();
 export type Noexcept = z.infer<typeof NoexceptSchema>;
 
 export const NonatomicSchema = z.object({
     "nonatomic": z.number().int(),
-});
+}).strict();
 export type Nonatomic = z.infer<typeof NonatomicSchema>;
 
 export const NoneSchema = z.object({
     "None": z.number().int(),
-});
+}).strict();
 export type None = z.infer<typeof NoneSchema>;
 
 export const NonlocalSchema = z.object({
     "nonlocal": z.number().int(),
-});
+}).strict();
 export type Nonlocal = z.infer<typeof NonlocalSchema>;
 
 export const NonmutatingSchema = z.object({
     "nonmutating": z.number().int(),
-});
+}).strict();
 export type Nonmutating = z.infer<typeof NonmutatingSchema>;
 
 export const NotSchema = z.object({
     "not": z.number().int(),
-});
+}).strict();
 export type Not = z.infer<typeof NotSchema>;
 
 export const NotEqSchema = z.object({
     "not_eq": z.number().int(),
-});
+}).strict();
 export type NotEq = z.infer<typeof NotEqSchema>;
 
 export const NsStringSchema = z.object({
     "NSString": z.number().int(),
-});
+}).strict();
 export type NsString = z.infer<typeof NsStringSchema>;
 
 export const NullSchema = z.object({
     "NULL": z.number().int(),
-});
+}).strict();
 export type Null = z.infer<typeof NullSchema>;
 
 export const NullptrSchema = z.object({
     "nullptr": z.number().int(),
-});
+}).strict();
 export type Nullptr = z.infer<typeof NullptrSchema>;
 
 export const NumberSchema = z.object({
     "number": z.number().int(),
-});
+}).strict();
 export type Number = z.infer<typeof NumberSchema>;
 
 export const NoneClassSchema = z.object({
     "none": z.number().int(),
-});
+}).strict();
 export type NoneClass = z.infer<typeof NoneClassSchema>;
 
 export const NullClassSchema = z.object({
     "null": z.number().int(),
-});
+}).strict();
 export type NullClass = z.infer<typeof NullClassSchema>;
 
 export const ProtocolClassSchema = z.object({
     "protocol": z.number().int(),
-});
+}).strict();
 export type ProtocolClass = z.infer<typeof ProtocolClassSchema>;
 
 export const ObjectClassSchema = z.object({
     "object": z.number().int(),
-});
+}).strict();
 export type ObjectClass = z.infer<typeof ObjectClassSchema>;
 
 export const OfSchema = z.object({
     "of": z.number().int(),
-});
+}).strict();
 export type Of = z.infer<typeof OfSchema>;
 
 export const OnewaySchema = z.object({
     "oneway": z.number().int(),
-});
+}).strict();
 export type Oneway = z.infer<typeof OnewaySchema>;
 
 export const OpenSchema = z.object({
     "open": z.number().int(),
-});
+}).strict();
 export type Open = z.infer<typeof OpenSchema>;
 
 export const OperatorSchema = z.object({
     "operator": z.number().int(),
-});
+}).strict();
 export type Operator = z.infer<typeof OperatorSchema>;
 
 export const OptionalSchema = z.object({
     "optional": z.number().int(),
-});
+}).strict();
 export type Optional = z.infer<typeof OptionalSchema>;
 
 export const OrSchema = z.object({
     "or": z.number().int(),
-});
+}).strict();
 export type Or = z.infer<typeof OrSchema>;
 
 export const OrEqSchema = z.object({
     "or_eq": z.number().int(),
-});
+}).strict();
 export type OrEq = z.infer<typeof OrEqSchema>;
 
 export const OutSchema = z.object({
     "out": z.number().int(),
-});
+}).strict();
 export type Out = z.infer<typeof OutSchema>;
 
 export const OverrideSchema = z.object({
     "override": z.number().int(),
-});
+}).strict();
 export type Override = z.infer<typeof OverrideSchema>;
 
 export const PackageSchema = z.object({
     "package": z.number().int(),
-});
+}).strict();
 export type Package = z.infer<typeof PackageSchema>;
 
 export const ParamsSchema = z.object({
     "params": z.number().int(),
-});
+}).strict();
 export type Params = z.infer<typeof ParamsSchema>;
 
 export const PassSchema = z.object({
     "pass": z.number().int(),
-});
+}).strict();
 export type Pass = z.infer<typeof PassSchema>;
 
 export const PortSchema = z.object({
     "port": z.number().int(),
-});
+}).strict();
 export type Port = z.infer<typeof PortSchema>;
 
 export const PostfixSchema = z.object({
     "postfix": z.number().int(),
-});
+}).strict();
 export type Postfix = z.infer<typeof PostfixSchema>;
 
 export const PrecedenceSchema = z.object({
     "precedence": z.number().int(),
-});
+}).strict();
 export type Precedence = z.infer<typeof PrecedenceSchema>;
 
 export const PrefixSchema = z.object({
     "prefix": z.number().int(),
-});
+}).strict();
 export type Prefix = z.infer<typeof PrefixSchema>;
 
 export const PrintSchema = z.object({
     "print": z.number().int(),
-});
+}).strict();
 export type Print = z.infer<typeof PrintSchema>;
 
 export const PrintMembersSchema = z.object({
     "printMembers": z.number().int(),
-});
+}).strict();
 export type PrintMembers = z.infer<typeof PrintMembersSchema>;
 
 export const PrintfSchema = z.object({
     "printf": z.number().int(),
-});
+}).strict();
 export type Printf = z.infer<typeof PrintfSchema>;
 
 export const PrivateSchema = z.object({
     "private": z.number().int(),
-});
+}).strict();
 export type Private = z.infer<typeof PrivateSchema>;
 
 export const ProtectedSchema = z.object({
     "protected": z.number().int(),
-});
+}).strict();
 export type Protected = z.infer<typeof ProtectedSchema>;
 
 export const ProtocolSchema = z.object({
     "Protocol": z.number().int(),
-});
+}).strict();
 export type Protocol = z.infer<typeof ProtocolSchema>;
 
 export const SelfClassSchema = z.object({
     "self": z.number().int(),
-});
+}).strict();
 export type SelfClass = z.infer<typeof SelfClassSchema>;
 
 export const TrueClassSchema = z.object({
     "true": z.number().int(),
-});
+}).strict();
 export type TrueClass = z.infer<typeof TrueClassSchema>;
 
 export const TypeClassSchema = z.object({
     "type": z.number().int(),
-});
+}).strict();
 export type TypeClass = z.infer<typeof TypeClassSchema>;
 
 export const PublicSchema = z.object({
     "public": z.number().int(),
-});
+}).strict();
 export type Public = z.infer<typeof PublicSchema>;
 
 export const QuicktypeSchema = z.object({
     "quicktype": z.number().int(),
-});
+}).strict();
 export type Quicktype = z.infer<typeof QuicktypeSchema>;
 
 export const RaiseSchema = z.object({
     "raise": z.number().int(),
-});
+}).strict();
 export type Raise = z.infer<typeof RaiseSchema>;
 
 export const RangeSchema = z.object({
     "range": z.number().int(),
-});
+}).strict();
 export type Range = z.infer<typeof RangeSchema>;
 
 export const ReadonlySchema = z.object({
     "readonly": z.number().int(),
-});
+}).strict();
 export type Readonly = z.infer<typeof ReadonlySchema>;
 
 export const RefSchema = z.object({
     "ref": z.number().int(),
-});
+}).strict();
 export type Ref = z.infer<typeof RefSchema>;
 
 export const RegisterSchema = z.object({
     "register": z.number().int(),
-});
+}).strict();
 export type Register = z.infer<typeof RegisterSchema>;
 
 export const ReinterpretCastSchema = z.object({
     "reinterpret_cast": z.number().int(),
-});
+}).strict();
 export type ReinterpretCast = z.infer<typeof ReinterpretCastSchema>;
 
 export const RepeatSchema = z.object({
     "repeat": z.number().int(),
-});
+}).strict();
 export type Repeat = z.infer<typeof RepeatSchema>;
 
 export const RequireSchema = z.object({
     "require": z.number().int(),
-});
+}).strict();
 export type Require = z.infer<typeof RequireSchema>;
 
 export const RequiredSchema = z.object({
     "required": z.number().int(),
-});
+}).strict();
 export type Required = z.infer<typeof RequiredSchema>;
 
 export const RequiresSchema = z.object({
     "requires": z.number().int(),
-});
+}).strict();
 export type Requires = z.infer<typeof RequiresSchema>;
 
 export const RestrictSchema = z.object({
     "restrict": z.number().int(),
-});
+}).strict();
 export type Restrict = z.infer<typeof RestrictSchema>;
 
 export const RetainSchema = z.object({
     "retain": z.number().int(),
-});
+}).strict();
 export type Retain = z.infer<typeof RetainSchema>;
 
 export const RethrowsSchema = z.object({
     "rethrows": z.number().int(),
-});
+}).strict();
 export type Rethrows = z.infer<typeof RethrowsSchema>;
 
 export const ReturnSchema = z.object({
     "return": z.number().int(),
-});
+}).strict();
 export type Return = z.infer<typeof ReturnSchema>;
 
 export const RightSchema = z.object({
     "right": z.number().int(),
-});
+}).strict();
 export type Right = z.infer<typeof RightSchema>;
 
 export const SbyteSchema = z.object({
     "sbyte": z.number().int(),
-});
+}).strict();
 export type Sbyte = z.infer<typeof SbyteSchema>;
 
 export const SealedSchema = z.object({
     "sealed": z.number().int(),
-});
+}).strict();
 export type Sealed = z.infer<typeof SealedSchema>;
 
 export const SelSchema = z.object({
     "SEL": z.number().int(),
-});
+}).strict();
 export type Sel = z.infer<typeof SelSchema>;
 
 export const SelectSchema = z.object({
     "select": z.number().int(),
-});
+}).strict();
 export type Select = z.infer<typeof SelectSchema>;
 
 export const SelfSchema = z.object({
     "Self": z.number().int(),
-});
+}).strict();
 export type Self = z.infer<typeof SelfSchema>;
 
 export const SerializeSchema = z.object({
     "serialize": z.number().int(),
-});
+}).strict();
 export type Serialize = z.infer<typeof SerializeSchema>;
 
 export const SetSchema = z.object({
     "set": z.number().int(),
-});
+}).strict();
 export type Set = z.infer<typeof SetSchema>;
 
 export const ShortSchema = z.object({
     "short": z.number().int(),
-});
+}).strict();
 export type Short = z.infer<typeof ShortSchema>;
 
 export const SignedSchema = z.object({
     "signed": z.number().int(),
-});
+}).strict();
 export type Signed = z.infer<typeof SignedSchema>;
 
 export const SizeofSchema = z.object({
     "sizeof": z.number().int(),
-});
+}).strict();
 export type Sizeof = z.infer<typeof SizeofSchema>;
 
 export const StackallocSchema = z.object({
     "stackalloc": z.number().int(),
-});
+}).strict();
 export type Stackalloc = z.infer<typeof StackallocSchema>;
 
 export const StaticSchema = z.object({
     "static": z.number().int(),
-});
+}).strict();
 export type Static = z.infer<typeof StaticSchema>;
 
 export const StaticAssertSchema = z.object({
     "static_assert": z.number().int(),
-});
+}).strict();
 export type StaticAssert = z.infer<typeof StaticAssertSchema>;
 
 export const StaticCastSchema = z.object({
     "static_cast": z.number().int(),
-});
+}).strict();
 export type StaticCast = z.infer<typeof StaticCastSchema>;
 
 export const StrictfpSchema = z.object({
     "strictfp": z.number().int(),
-});
+}).strict();
 export type Strictfp = z.infer<typeof StrictfpSchema>;
 
 export const StringClassSchema = z.object({
     "string": z.number().int(),
-});
+}).strict();
 export type StringClass = z.infer<typeof StringClassSchema>;
 
 export const StructSchema = z.object({
     "struct": z.number().int(),
-});
+}).strict();
 export type Struct = z.infer<typeof StructSchema>;
 
 export const SubscriptSchema = z.object({
     "subscript": z.number().int(),
-});
+}).strict();
 export type Subscript = z.infer<typeof SubscriptSchema>;
 
 export const SuperSchema = z.object({
     "super": z.number().int(),
-});
+}).strict();
 export type Super = z.infer<typeof SuperSchema>;
 
 export const SwitchSchema = z.object({
     "switch": z.number().int(),
-});
+}).strict();
 export type Switch = z.infer<typeof SwitchSchema>;
 
 export const SymbolSchema = z.object({
     "symbol": z.number().int(),
-});
+}).strict();
 export type Symbol = z.infer<typeof SymbolSchema>;
 
 export const SynchronizedSchema = z.object({
     "synchronized": z.number().int(),
-});
+}).strict();
 export type Synchronized = z.infer<typeof SynchronizedSchema>;
 
 export const SystemSchema = z.object({
     "system": z.number().int(),
-});
+}).strict();
 export type System = z.infer<typeof SystemSchema>;
 
 export const TemplateSchema = z.object({
     "template": z.number().int(),
-});
+}).strict();
 export type Template = z.infer<typeof TemplateSchema>;
 
 export const ThenSchema = z.object({
     "then": z.number().int(),
-});
+}).strict();
 export type Then = z.infer<typeof ThenSchema>;
 
 export const ThisSchema = z.object({
     "this": z.number().int(),
-});
+}).strict();
 export type This = z.infer<typeof ThisSchema>;
 
 export const ThreadLocalSchema = z.object({
     "thread_local": z.number().int(),
-});
+}).strict();
 export type ThreadLocal = z.infer<typeof ThreadLocalSchema>;
 
 export const ThrowSchema = z.object({
     "throw": z.number().int(),
-});
+}).strict();
 export type Throw = z.infer<typeof ThrowSchema>;
 
 export const ThrowsSchema = z.object({
     "throws": z.number().int(),
-});
+}).strict();
 export type Throws = z.infer<typeof ThrowsSchema>;
 
 export const ToJsonSchema = z.object({
     "to_json": z.number().int(),
-});
+}).strict();
 export type ToJson = z.infer<typeof ToJsonSchema>;
 
 export const TopLevelClassSchema = z.object({
     "top_level": z.number().int(),
-});
+}).strict();
 export type TopLevelClass = z.infer<typeof TopLevelClassSchema>;
 
 export const TransientSchema = z.object({
     "transient": z.number().int(),
-});
+}).strict();
 export type Transient = z.infer<typeof TransientSchema>;
 
 export const TrueSchema = z.object({
     "True": z.number().int(),
-});
+}).strict();
 export type True = z.infer<typeof TrueSchema>;
 
 export const TrySchema = z.object({
     "try": z.number().int(),
-});
+}).strict();
 export type Try = z.infer<typeof TrySchema>;
 
 export const TypeSchema = z.object({
     "Type": z.number().int(),
-});
+}).strict();
 export type Type = z.infer<typeof TypeSchema>;
 
 export const TypealiasSchema = z.object({
     "typealias": z.number().int(),
-});
+}).strict();
 export type Typealias = z.infer<typeof TypealiasSchema>;
 
 export const TypedefSchema = z.object({
     "typedef": z.number().int(),
-});
+}).strict();
 export type Typedef = z.infer<typeof TypedefSchema>;
 
 export const TypeidSchema = z.object({
     "typeid": z.number().int(),
-});
+}).strict();
 export type Typeid = z.infer<typeof TypeidSchema>;
 
 export const TypenameSchema = z.object({
     "typename": z.number().int(),
-});
+}).strict();
 export type Typename = z.infer<typeof TypenameSchema>;
 
 export const TypeofSchema = z.object({
     "typeof": z.number().int(),
-});
+}).strict();
 export type Typeof = z.infer<typeof TypeofSchema>;
 
 export const UintSchema = z.object({
     "uint": z.number().int(),
-});
+}).strict();
 export type Uint = z.infer<typeof UintSchema>;
 
 export const UlongSchema = z.object({
     "ulong": z.number().int(),
-});
+}).strict();
 export type Ulong = z.infer<typeof UlongSchema>;
 
 export const UncheckedSchema = z.object({
     "unchecked": z.number().int(),
-});
+}).strict();
 export type Unchecked = z.infer<typeof UncheckedSchema>;
 
 export const UndefinedSchema = z.object({
     "undefined": z.number().int(),
-});
+}).strict();
 export type Undefined = z.infer<typeof UndefinedSchema>;
 
 export const UnionSchema = z.object({
     "union": z.number().int(),
-});
+}).strict();
 export type Union = z.infer<typeof UnionSchema>;
 
 export const UnownedSchema = z.object({
     "unowned": z.number().int(),
-});
+}).strict();
 export type Unowned = z.infer<typeof UnownedSchema>;
 
 export const UnsafeSchema = z.object({
     "unsafe": z.number().int(),
-});
+}).strict();
 export type Unsafe = z.infer<typeof UnsafeSchema>;
 
 export const UnsignedSchema = z.object({
     "unsigned": z.number().int(),
-});
+}).strict();
 export type Unsigned = z.infer<typeof UnsignedSchema>;
 
 export const UshortSchema = z.object({
     "ushort": z.number().int(),
-});
+}).strict();
 export type Ushort = z.infer<typeof UshortSchema>;
 
 export const UsingSchema = z.object({
     "using": z.number().int(),
-});
+}).strict();
 export type Using = z.infer<typeof UsingSchema>;
 
 export const VarSchema = z.object({
     "var": z.number().int(),
-});
+}).strict();
 export type Var = z.infer<typeof VarSchema>;
 
 export const VirtualSchema = z.object({
     "virtual": z.number().int(),
-});
+}).strict();
 export type Virtual = z.infer<typeof VirtualSchema>;
 
 export const VoidSchema = z.object({
     "void": z.number().int(),
-});
+}).strict();
 export type Void = z.infer<typeof VoidSchema>;
 
 export const VolatileSchema = z.object({
     "volatile": z.number().int(),
-});
+}).strict();
 export type Volatile = z.infer<typeof VolatileSchema>;
 
 export const WcharTSchema = z.object({
     "wchar_t": z.number().int(),
-});
+}).strict();
 export type WcharT = z.infer<typeof WcharTSchema>;
 
 export const WeakSchema = z.object({
     "weak": z.number().int(),
-});
+}).strict();
 export type Weak = z.infer<typeof WeakSchema>;
 
 export const WhereSchema = z.object({
     "where": z.number().int(),
-});
+}).strict();
 export type Where = z.infer<typeof WhereSchema>;
 
 export const WhileSchema = z.object({
     "while": z.number().int(),
-});
+}).strict();
 export type While = z.infer<typeof WhileSchema>;
 
 export const WillSetSchema = z.object({
     "willSet": z.number().int(),
-});
+}).strict();
 export type WillSet = z.infer<typeof WillSetSchema>;
 
 export const WithSchema = z.object({
     "with": z.number().int(),
-});
+}).strict();
 export type With = z.infer<typeof WithSchema>;
 
 export const XorSchema = z.object({
     "xor": z.number().int(),
-});
+}).strict();
 export type Xor = z.infer<typeof XorSchema>;
 
 export const XorEqSchema = z.object({
     "xor_eq": z.number().int(),
-});
+}).strict();
 export type XorEq = z.infer<typeof XorEqSchema>;
 
 export const YesSchema = z.object({
     "YES": z.number().int(),
-});
+}).strict();
 export type Yes = z.infer<typeof YesSchema>;
 
 export const YieldSchema = z.object({
     "yield": z.number().int(),
-});
+}).strict();
 export type Yield = z.infer<typeof YieldSchema>;
 
 export const Obj1Schema = z.object({
@@ -1463,7 +1463,7 @@ export const Obj1Schema = z.object({
     "_Bool": BoolClassSchema,
     "class": Obj1ClassSchema,
     "bool": Obj1BoolSchema,
-});
+}).strict();
 export type Obj1 = z.infer<typeof Obj1Schema>;
 
 export const Obj2Schema = z.object({
@@ -1533,7 +1533,7 @@ export const Obj2Schema = z.object({
     "interface": InterfaceSchema,
     "internal": InternalSchema,
     "false": FalseClassSchema,
-});
+}).strict();
 export type Obj2 = z.infer<typeof Obj2Schema>;
 
 export const Obj3Schema = z.object({
@@ -1603,7 +1603,7 @@ export const Obj3Schema = z.object({
     "private": PrivateSchema,
     "protected": ProtectedSchema,
     "Protocol": ProtocolSchema,
-});
+}).strict();
 export type Obj3 = z.infer<typeof Obj3Schema>;
 
 export const Obj4Schema = z.object({
@@ -1672,7 +1672,7 @@ export const Obj4Schema = z.object({
     "ulong": UlongSchema,
     "unchecked": UncheckedSchema,
     "undefined": UndefinedSchema,
-});
+}).strict();
 export type Obj4 = z.infer<typeof Obj4Schema>;
 
 export const Obj5Schema = z.object({
@@ -1697,7 +1697,7 @@ export const Obj5Schema = z.object({
     "xor_eq": XorEqSchema,
     "YES": YesSchema,
     "yield": YieldSchema,
-});
+}).strict();
 export type Obj5 = z.infer<typeof Obj5Schema>;
 
 export const TopLevelSchema = z.object({
@@ -1707,5 +1707,5 @@ export const TopLevelSchema = z.object({
     "obj3": Obj3Schema,
     "obj4": Obj4Schema,
     "obj5": Obj5Schema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.ts
index cc807f1..6cfe60d 100644
--- a/base/typescript-zod/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/kotlin-enum-class-case-collision.json/default/TopLevel.ts
@@ -9,7 +9,7 @@ export type Category = z.infer<typeof CategorySchema>;
 
 export const TopLevelElementSchema = z.object({
     "category": CategorySchema,
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/priority/list.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/list.json/default/TopLevel.ts
index cf83c66..fa7a8bc 100644
--- a/base/typescript-zod/test/inputs/json/priority/list.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/list.json/default/TopLevel.ts
@@ -9,5 +9,5 @@ export const TopLevelSchema: z.ZodType<TopLevel> = z.lazy(() =>
     z.object({
         "data": z.number().int(),
         "next": z.union([z.null(), TopLevelSchema]),
-    })
+    }).strict()
 );
diff --git a/base/typescript-zod/test/inputs/json/priority/name-style.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/name-style.json/default/TopLevel.ts
index 5e7cc6a..cc48e07 100644
--- a/base/typescript-zod/test/inputs/json/priority/name-style.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/name-style.json/default/TopLevel.ts
@@ -9,5 +9,5 @@ export const TopLevelSchema = z.object({
     "should_know_that_id_is_an_initialism": z.string(),
     "   spaces are separators  too  ": z.boolean(),
     "ZSR_HH_DEMO3_DELMATNR": z.boolean(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/nbl-stats.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/nbl-stats.json/default/TopLevel.ts
index ff90a9b..9a4dc12 100644
--- a/base/typescript-zod/test/inputs/json/priority/nbl-stats.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/nbl-stats.json/default/TopLevel.ts
@@ -95,7 +95,7 @@ export const TeamSchema = z.object({
     "teamCodeInternational": z.string(),
     "teamName": z.string(),
     "teamNameInternational": z.string(),
-});
+}).strict();
 export type Team = z.infer<typeof TeamSchema>;
 
 export const PbpSchema = z.object({
@@ -123,14 +123,14 @@ export const PbpSchema = z.object({
     "subType": z.string(),
     "success": z.number().int(),
     "tno": z.number().int(),
-});
+}).strict();
 export type Pbp = z.infer<typeof PbpSchema>;
 
 export const TimeSchema = z.object({
     "gt": z.string(),
     "per": z.number().int(),
     "perType": PerTypeSchema,
-});
+}).strict();
 export type Time = z.infer<typeof TimeSchema>;
 
 export const CompSchema = z.object({
@@ -138,7 +138,7 @@ export const CompSchema = z.object({
     "sMinutesAverage": z.string(),
     "sPointsAverage": z.number(),
     "sReboundsTotalAverage": z.number(),
-});
+}).strict();
 export type Comp = z.infer<typeof CompSchema>;
 
 export const ShotSchema = z.object({
@@ -154,7 +154,7 @@ export const ShotSchema = z.object({
     "tno": z.number().int(),
     "x": z.number().int(),
     "y": z.number().int(),
-});
+}).strict();
 export type Shot = z.infer<typeof ShotSchema>;
 
 export const OthermatchSchema = z.object({
@@ -169,7 +169,7 @@ export const OthermatchSchema = z.object({
     "team2": TeamSchema,
     "team2Name": z.string(),
     "team2Score": z.number().int(),
-});
+}).strict();
 export type Othermatch = z.infer<typeof OthermatchSchema>;
 
 export const ScorerSchema = z.object({
@@ -193,12 +193,12 @@ export const ScorerSchema = z.object({
     "times": z.array(TimeSchema).optional(),
     "tno": z.number().int(),
     "tot": z.number().int().optional(),
-});
+}).strict();
 export type Scorer = z.infer<typeof ScorerSchema>;
 
 export const SBlocksSchema = z.object({
     "1": ScorerSchema,
-});
+}).strict();
 export type SBlocks = z.infer<typeof SBlocksSchema>;
 
 export const PlSchema = z.object({
@@ -252,7 +252,7 @@ export const PlSchema = z.object({
     "sTwoPointersPercentage": z.number().int(),
     "shirtNumber": z.string().regex(/^-?\d+$/),
     "starter": z.number().int(),
-});
+}).strict();
 export type Pl = z.infer<typeof PlSchema>;
 
 export const TotalldsSchema = z.object({
@@ -261,7 +261,7 @@ export const TotalldsSchema = z.object({
     "sPoints": z.record(z.string(), ScorerSchema),
     "sReboundsTotal": z.record(z.string(), ScorerSchema),
     "sSteals": z.record(z.string(), ScorerSchema),
-});
+}).strict();
 export type Totallds = z.infer<typeof TotalldsSchema>;
 
 export const LdsSchema = z.object({
@@ -270,7 +270,7 @@ export const LdsSchema = z.object({
     "sPoints": z.record(z.string(), ScorerSchema),
     "sReboundsTotal": z.record(z.string(), ScorerSchema),
     "sSteals": z.record(z.string(), ScorerSchema),
-});
+}).strict();
 export type Lds = z.infer<typeof LdsSchema>;
 
 export const TmSchema = z.object({
@@ -339,7 +339,7 @@ export const TmSchema = z.object({
     "tot_sTwoPointersAttempted": z.number().int(),
     "tot_sTwoPointersMade": z.number().int(),
     "tot_sTwoPointersPercentage": z.number().int(),
-});
+}).strict();
 export type Tm = z.infer<typeof TmSchema>;
 
 export const TopLevelSchema = z.object({
@@ -363,5 +363,5 @@ export const TopLevelSchema = z.object({
     "tm": z.record(z.string(), TmSchema),
     "totalTimeAdded": z.number().int(),
     "totallds": TotalldsSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/nested-objects.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/nested-objects.json/default/TopLevel.ts
index 14b7962..7ca82eb 100644
--- a/base/typescript-zod/test/inputs/json/priority/nested-objects.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/nested-objects.json/default/TopLevel.ts
@@ -4,5 +4,5 @@ import * as z from "zod";
 export const TopLevelSchema = z.object({
     "a": z.record(z.string(), z.number().int()),
     "b": z.record(z.string(), z.number().int()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.ts
index cf825b5..336f224 100644
--- a/base/typescript-zod/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/nst-test-suite.json/default/TopLevel.ts
@@ -2,60 +2,60 @@ import * as z from "zod";
 
 
 export const JsonSchema = z.object({
-});
+}).strict();
 export type Json = z.infer<typeof JsonSchema>;
 
 export const YObjectBasicJsonSchema = z.object({
     "asd": z.string(),
-});
+}).strict();
 export type YObjectBasicJson = z.infer<typeof YObjectBasicJsonSchema>;
 
 export const YObjectEmptyKeyJsonSchema = z.object({
     "": z.number().int(),
-});
+}).strict();
 export type YObjectEmptyKeyJson = z.infer<typeof YObjectEmptyKeyJsonSchema>;
 
 export const YObjectEscapedNullInKeyJsonSchema = z.object({
     "foo\u0000bar": z.number().int(),
-});
+}).strict();
 export type YObjectEscapedNullInKeyJson = z.infer<typeof YObjectEscapedNullInKeyJsonSchema>;
 
 export const YObjectExtremeNumbersJsonSchema = z.object({
     "max": z.number(),
     "min": z.number(),
-});
+}).strict();
 export type YObjectExtremeNumbersJson = z.infer<typeof YObjectExtremeNumbersJsonSchema>;
 
 export const YObjectJsonSchema = z.object({
     "asd": z.string(),
     "dfg": z.string(),
-});
+}).strict();
 export type YObjectJson = z.infer<typeof YObjectJsonSchema>;
 
 export const XSchema = z.object({
     "id": z.string(),
-});
+}).strict();
 export type X = z.infer<typeof XSchema>;
 
 export const YObjectSimpleJsonSchema = z.object({
     "a": z.array(z.any()),
-});
+}).strict();
 export type YObjectSimpleJson = z.infer<typeof YObjectSimpleJsonSchema>;
 
 export const YObjectStringUnicodeJsonSchema = z.object({
     "title": z.string(),
-});
+}).strict();
 export type YObjectStringUnicodeJson = z.infer<typeof YObjectStringUnicodeJsonSchema>;
 
 export const YObjectWithNewlinesJsonSchema = z.object({
     "a": z.string(),
-});
+}).strict();
 export type YObjectWithNewlinesJson = z.infer<typeof YObjectWithNewlinesJsonSchema>;
 
 export const YObjectLongStringsJsonSchema = z.object({
     "id": z.string(),
     "x": z.array(XSchema),
-});
+}).strict();
 export type YObjectLongStringsJson = z.infer<typeof YObjectLongStringsJsonSchema>;
 
 export const TopLevelSchema = z.object({
@@ -152,5 +152,5 @@ export const TopLevelSchema = z.object({
     "y_structure_trailing_newline.json": z.array(z.string()),
     "y_structure_true_in_array.json": z.array(z.boolean()),
     "y_structure_whitespace_array.json": z.array(z.any()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/number-map.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/number-map.json/default/TopLevel.ts
index 95fc3e0..27080e4 100644
--- a/base/typescript-zod/test/inputs/json/priority/number-map.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/number-map.json/default/TopLevel.ts
@@ -3,5 +3,5 @@ import * as z from "zod";
 
 export const TopLevelSchema = z.object({
     "foo": z.record(z.string(), z.number()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/omit-empty.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/omit-empty.json/default/TopLevel.ts
index cfad005..f2f493d 100644
--- a/base/typescript-zod/test/inputs/json/priority/omit-empty.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/omit-empty.json/default/TopLevel.ts
@@ -4,10 +4,10 @@ import * as z from "zod";
 export const ResultSchema = z.object({
     "age": z.number().int(),
     "name": z.null().optional(),
-});
+}).strict();
 export type Result = z.infer<typeof ResultSchema>;
 
 export const TopLevelSchema = z.object({
     "results": z.array(ResultSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/optional-union.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/optional-union.json/default/TopLevel.ts
index 5bc3a6d..32a4e08 100644
--- a/base/typescript-zod/test/inputs/json/priority/optional-union.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/optional-union.json/default/TopLevel.ts
@@ -3,7 +3,7 @@ import * as z from "zod";
 
 export const TopLevelElementSchema = z.object({
     "a": z.union([z.number().int(), z.string()]).optional(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.ts
index 2da0fa1..be5e870 100644
--- a/base/typescript-zod/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/php-mixed-union.json/default/TopLevel.ts
@@ -3,10 +3,10 @@ import * as z from "zod";
 
 export const MixedClassSchema = z.object({
     "nested": z.string(),
-});
+}).strict();
 export type MixedClass = z.infer<typeof MixedClassSchema>;
 
 export const TopLevelSchema = z.object({
     "mixed": z.array(z.union([z.null(), z.boolean(), MixedClassSchema, z.number().int(), z.string()])),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/php-validation.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/php-validation.json/default/TopLevel.ts
index a4f55d9..eb4fa90 100644
--- a/base/typescript-zod/test/inputs/json/priority/php-validation.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/php-validation.json/default/TopLevel.ts
@@ -7,5 +7,5 @@ export const TopLevelSchema = z.object({
     "integers": z.array(z.number().int()),
     "number": z.number(),
     "string": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/recursive.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/recursive.json/default/TopLevel.ts
index 54a99dd..eafb8a4 100644
--- a/base/typescript-zod/test/inputs/json/priority/recursive.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/recursive.json/default/TopLevel.ts
@@ -7,7 +7,7 @@ export type Format = {
 export const FormatSchema: z.ZodType<Format> = z.lazy(() =>
     z.object({
         "formats": FormatsClassSchema,
-    })
+    }).strict()
 );
 
 export type FormatsClass = {
@@ -22,40 +22,40 @@ export const FormatsClassSchema: z.ZodType<FormatsClass> = z.lazy(() =>
         "height": z.number().int(),
         "url": z.string(),
         "width": z.number().int(),
-    })
+    }).strict()
 );
 
 export const LinkLinkSchema = z.object({
     "type": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type LinkLink = z.infer<typeof LinkLinkSchema>;
 
 export const CategoryThumbnailSchema = z.object({
     "url": z.string(),
-});
+}).strict();
 export type CategoryThumbnail = z.infer<typeof CategoryThumbnailSchema>;
 
 export const EonandyearSchema = z.object({
     "lowestsetbit": z.number().int(),
-});
+}).strict();
 export type Eonandyear = z.infer<typeof EonandyearSchema>;
 
 export const XmlschematypeSchema = z.object({
     "localpart": z.string(),
     "namespaceuri": z.string(),
     "prefix": z.string(),
-});
+}).strict();
 export type Xmlschematype = z.infer<typeof XmlschematypeSchema>;
 
 export const CurrencySchema = z.object({
     "abbreviation": z.string(),
-});
+}).strict();
 export type Currency = z.infer<typeof CurrencySchema>;
 
 export const LinkElementSchema = z.object({
     "link": LinkLinkSchema,
-});
+}).strict();
 export type LinkElement = z.infer<typeof LinkElementSchema>;
 
 export const DateClassSchema = z.object({
@@ -70,19 +70,19 @@ export const DateClassSchema = z.object({
     "valid": z.boolean(),
     "xmlschematype": XmlschematypeSchema,
     "year": z.number().int(),
-});
+}).strict();
 export type DateClass = z.infer<typeof DateClassSchema>;
 
 export const UseraverageratingSchema = z.object({
     "links": z.array(LinkElementSchema),
     "numcomments": z.number().int(),
     "rating": z.string(),
-});
+}).strict();
 export type Useraveragerating = z.infer<typeof UseraverageratingSchema>;
 
 export const SpecificationSchema = z.object({
     "links": z.array(LinkElementSchema),
-});
+}).strict();
 export type Specification = z.infer<typeof SpecificationSchema>;
 
 export const CategorySchema = z.object({
@@ -94,7 +94,7 @@ export const CategorySchema = z.object({
     "name": z.string(),
     "parentcategoryid": z.number().int(),
     "thumbnail": CategoryThumbnailSchema,
-});
+}).strict();
 export type Category = z.infer<typeof CategorySchema>;
 
 export const DetailsSchema = z.object({
@@ -105,12 +105,12 @@ export const DetailsSchema = z.object({
     "elapsedtime": z.number().int(),
     "message": z.string(),
     "status": z.string(),
-});
+}).strict();
 export type Details = z.infer<typeof DetailsSchema>;
 
 export const RatingSchema = z.object({
     "useraveragerating": UseraverageratingSchema,
-});
+}).strict();
 export type Rating = z.infer<typeof RatingSchema>;
 
 export const ProductProductSchema = z.object({
@@ -130,12 +130,12 @@ export const ProductProductSchema = z.object({
     "specification": SpecificationSchema,
     "thumbnail": FormatsClassSchema,
     "totalsellers": z.number().int(),
-});
+}).strict();
 export type ProductProduct = z.infer<typeof ProductProductSchema>;
 
 export const ProductElementSchema = z.object({
     "product": ProductProductSchema,
-});
+}).strict();
 export type ProductElement = z.infer<typeof ProductElementSchema>;
 
 export const TopLevelSchema = z.object({
@@ -149,5 +149,5 @@ export const TopLevelSchema = z.object({
     "totalpages": z.number().int(),
     "totalresultsavailable": z.number().int(),
     "totalresultsreturned": z.number().int(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.ts
index 788b738..2103d99 100644
--- a/base/typescript-zod/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/simple-identifiers.json/default/TopLevel.ts
@@ -11,5 +11,5 @@ export const TopLevelSchema = z.object({
     "undefined": z.string(),
     "x": z.string(),
     "x y": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.ts
index e03687a..115c3d4 100644
--- a/base/typescript-zod/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/union-constructor-clash.json/default/TopLevel.ts
@@ -3,11 +3,11 @@ import * as z from "zod";
 
 export const BoolInUnionSchema = z.object({
     "a": z.boolean(),
-});
+}).strict();
 export type BoolInUnion = z.infer<typeof BoolInUnionSchema>;
 
 export const TopLevelSchema = z.object({
     "BoolInUnion": BoolInUnionSchema,
     "union": z.array(z.union([z.boolean(), z.number().int()])),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/unions.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/unions.json/default/TopLevel.ts
index 4962bb4..9e5d20a 100644
--- a/base/typescript-zod/test/inputs/json/priority/unions.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/unions.json/default/TopLevel.ts
@@ -3,12 +3,12 @@ import * as z from "zod";
 
 export const ZClassSchema = z.object({
     "a": z.boolean(),
-});
+}).strict();
 export type ZClass = z.infer<typeof ZClassSchema>;
 
 export const TopLevelSchema = z.object({
     "x": z.array(z.union([z.null(), z.number().int(), z.string()])),
     "y": z.array(z.union([z.null(), z.number().int()])),
     "z": z.array(z.union([z.array(z.number().int()), ZClassSchema, z.number().int()])),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/url.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/url.json/default/TopLevel.ts
index 718db05..8037270 100644
--- a/base/typescript-zod/test/inputs/json/priority/url.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/url.json/default/TopLevel.ts
@@ -4,5 +4,5 @@ import * as z from "zod";
 export const TopLevelSchema = z.object({
     "fromURL": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/priority/uuids.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/priority/uuids.json/default/TopLevel.ts
index 5406708..f04c903 100644
--- a/base/typescript-zod/test/inputs/json/priority/uuids.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/priority/uuids.json/default/TopLevel.ts
@@ -8,5 +8,5 @@ export const TopLevelSchema = z.object({
     "stringValue": z.string(),
     "uuidValue": z.string().uuid(),
     "uuidValues": z.array(z.string().uuid()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.ts
index d2c18e8..5537874 100644
--- a/base/typescript-zod/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/samples/bitcoin-block.json/default/TopLevel.ts
@@ -7,5 +7,5 @@ export const TopLevelSchema = z.object({
     "height": z.number().int(),
     "time": z.number().int(),
     "txIndexes": z.array(z.number().int()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/samples/getting-started.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/samples/getting-started.json/default/TopLevel.ts
index 7233c1f..cde9d68 100644
--- a/base/typescript-zod/test/inputs/json/samples/getting-started.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/samples/getting-started.json/default/TopLevel.ts
@@ -4,5 +4,5 @@ import * as z from "zod";
 export const TopLevelSchema = z.object({
     "greeting": z.string(),
     "instructions": z.array(z.string()),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/samples/github-events.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/samples/github-events.json/default/TopLevel.ts
index 4960b77..436bb26 100644
--- a/base/typescript-zod/test/inputs/json/samples/github-events.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/samples/github-events.json/default/TopLevel.ts
@@ -14,7 +14,7 @@ export const ActorSchema = z.object({
     "id": z.number().int(),
     "login": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Actor = z.infer<typeof ActorSchema>;
 
 export const UserSchema = z.object({
@@ -35,13 +35,13 @@ export const UserSchema = z.object({
     "subscriptions_url": z.string(),
     "type": TypeSchema,
     "url": z.string(),
-});
+}).strict();
 export type User = z.infer<typeof UserSchema>;
 
 export const AuthorSchema = z.object({
     "email": z.string(),
     "name": z.string(),
-});
+}).strict();
 export type Author = z.infer<typeof AuthorSchema>;
 
 export const LabelSchema = z.object({
@@ -50,7 +50,7 @@ export const LabelSchema = z.object({
     "id": z.number().int(),
     "name": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Label = z.infer<typeof LabelSchema>;
 
 export const MilestoneSchema = z.object({
@@ -69,7 +69,7 @@ export const MilestoneSchema = z.object({
     "title": z.string(),
     "updated_at": z.coerce.date(),
     "url": z.string(),
-});
+}).strict();
 export type Milestone = z.infer<typeof MilestoneSchema>;
 
 export const IssuePullRequestSchema = z.object({
@@ -77,7 +77,7 @@ export const IssuePullRequestSchema = z.object({
     "html_url": z.string(),
     "patch_url": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type IssuePullRequest = z.infer<typeof IssuePullRequestSchema>;
 
 export const BaseRepoSchema = z.object({
@@ -150,19 +150,19 @@ export const BaseRepoSchema = z.object({
     "url": z.string(),
     "watchers": z.number().int(),
     "watchers_count": z.number().int(),
-});
+}).strict();
 export type BaseRepo = z.infer<typeof BaseRepoSchema>;
 
 export const CommentsSchema = z.object({
     "href": z.string(),
-});
+}).strict();
 export type Comments = z.infer<typeof CommentsSchema>;
 
 export const TopLevelRepoSchema = z.object({
     "id": z.number().int(),
     "name": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type TopLevelRepo = z.infer<typeof TopLevelRepoSchema>;
 
 export const CommentSchema = z.object({
@@ -174,7 +174,7 @@ export const CommentSchema = z.object({
     "updated_at": z.coerce.date(),
     "url": z.string(),
     "user": UserSchema,
-});
+}).strict();
 export type Comment = z.infer<typeof CommentSchema>;
 
 export const CommitSchema = z.object({
@@ -183,7 +183,7 @@ export const CommitSchema = z.object({
     "message": z.string(),
     "sha": z.string(),
     "url": z.string(),
-});
+}).strict();
 export type Commit = z.infer<typeof CommitSchema>;
 
 export const IssueSchema = z.object({
@@ -209,7 +209,7 @@ export const IssueSchema = z.object({
     "updated_at": z.coerce.date(),
     "url": z.string(),
     "user": UserSchema,
-});
+}).strict();
 export type Issue = z.infer<typeof IssueSchema>;
 
 export const BaseSchema = z.object({
@@ -218,7 +218,7 @@ export const BaseSchema = z.object({
     "repo": BaseRepoSchema,
     "sha": z.string(),
     "user": UserSchema,
-});
+}).strict();
 export type Base = z.infer<typeof BaseSchema>;
 
 export const LinksSchema = z.object({
@@ -230,7 +230,7 @@ export const LinksSchema = z.object({
     "review_comments": CommentsSchema,
     "self": CommentsSchema,
     "statuses": CommentsSchema,
-});
+}).strict();
 export type Links = z.infer<typeof LinksSchema>;
 
 export const PayloadPullRequestSchema = z.object({
@@ -275,7 +275,7 @@ export const PayloadPullRequestSchema = z.object({
     "updated_at": z.coerce.date(),
     "url": z.string(),
     "user": UserSchema,
-});
+}).strict();
 export type PayloadPullRequest = z.infer<typeof PayloadPullRequestSchema>;
 
 export const PayloadSchema = z.object({
@@ -295,7 +295,7 @@ export const PayloadSchema = z.object({
     "ref": z.string().optional(),
     "ref_type": z.string().optional(),
     "size": z.number().int().optional(),
-});
+}).strict();
 export type Payload = z.infer<typeof PayloadSchema>;
 
 export const TopLevelElementSchema = z.object({
@@ -307,7 +307,7 @@ export const TopLevelElementSchema = z.object({
     "public": z.boolean(),
     "repo": TopLevelRepoSchema,
     "type": z.string(),
-});
+}).strict();
 export type TopLevelElement = z.infer<typeof TopLevelElementSchema>;
 
 export const TopLevelSchema = z.array(TopLevelElementSchema);
diff --git a/base/typescript-zod/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.ts
index dba7bbe..6cc8b2d 100644
--- a/base/typescript-zod/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/samples/kitchen-sink.json/default/TopLevel.ts
@@ -3,20 +3,20 @@ import * as z from "zod";
 
 export const DifferentThingClassSchema = z.object({
     "name": z.string(),
-});
+}).strict();
 export type DifferentThingClass = z.infer<typeof DifferentThingClassSchema>;
 
 export const PersonElementSchema = z.object({
     "intOrString": z.union([z.number().int(), z.string().regex(/^-?\d+$/).transform(Number)]),
     "name": z.string(),
     "optionalValue": z.boolean().optional(),
-});
+}).strict();
 export type PersonElement = z.infer<typeof PersonElementSchema>;
 
 export const PurplePersonSchema = z.object({
     "intOrString": z.number().int(),
     "name": z.string(),
-});
+}).strict();
 export type PurplePerson = z.infer<typeof PurplePersonSchema>;
 
 export const TopLevelSchema = z.object({
@@ -34,5 +34,5 @@ export const TopLevelSchema = z.object({
     "stringValue": z.string(),
     "tuples": z.array(z.array(z.union([z.number().int(), z.string()]))),
     "uuidValue": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/samples/null-safe.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/samples/null-safe.json/default/TopLevel.ts
index 12756cc..3beaf81 100644
--- a/base/typescript-zod/test/inputs/json/samples/null-safe.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/samples/null-safe.json/default/TopLevel.ts
@@ -5,7 +5,7 @@ export const AddressSchema = z.object({
     "city": z.string(),
     "country": z.string(),
     "street": z.string(),
-});
+}).strict();
 export type Address = z.infer<typeof AddressSchema>;
 
 export const ItemSchema = z.object({
@@ -13,10 +13,10 @@ export const ItemSchema = z.object({
     "created_at": z.coerce.date().optional(),
     "name": z.string(),
     "sex": z.union([z.null(), z.number().int()]),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const TopLevelSchema = z.object({
     "item": z.array(ItemSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/samples/pokedex.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/samples/pokedex.json/default/TopLevel.ts
index 2c10b3d..1c30f2f 100644
--- a/base/typescript-zod/test/inputs/json/samples/pokedex.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/samples/pokedex.json/default/TopLevel.ts
@@ -36,7 +36,7 @@ export type Type = z.infer<typeof TypeSchema>;
 export const EvolutionSchema = z.object({
     "name": z.string(),
     "num": z.string(),
-});
+}).strict();
 export type Evolution = z.infer<typeof EvolutionSchema>;
 
 export const PokemonSchema = z.object({
@@ -57,10 +57,10 @@ export const PokemonSchema = z.object({
     "type": z.array(TypeSchema),
     "weaknesses": z.array(TypeSchema),
     "weight": z.string(),
-});
+}).strict();
 export type Pokemon = z.infer<typeof PokemonSchema>;
 
 export const TopLevelSchema = z.object({
     "pokemon": z.array(PokemonSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/samples/reddit.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/samples/reddit.json/default/TopLevel.ts
index 6ab6785..ab08b28 100644
--- a/base/typescript-zod/test/inputs/json/samples/reddit.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/samples/reddit.json/default/TopLevel.ts
@@ -53,26 +53,26 @@ export const KindSchema = z.enum([
 export type Kind = z.infer<typeof KindSchema>;
 
 export const MediaEmbedSchema = z.object({
-});
+}).strict();
 export type MediaEmbed = z.infer<typeof MediaEmbedSchema>;
 
 export const SourceSchema = z.object({
     "height": z.number().int(),
     "url": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Source = z.infer<typeof SourceSchema>;
 
 export const GifSchema = z.object({
     "resolutions": z.array(SourceSchema),
     "source": SourceSchema,
-});
+}).strict();
 export type Gif = z.infer<typeof GifSchema>;
 
 export const VariantsSchema = z.object({
     "gif": GifSchema.optional(),
     "mp4": GifSchema.optional(),
-});
+}).strict();
 export type Variants = z.infer<typeof VariantsSchema>;
 
 export const ImageSchema = z.object({
@@ -80,13 +80,13 @@ export const ImageSchema = z.object({
     "resolutions": z.array(SourceSchema),
     "source": SourceSchema,
     "variants": VariantsSchema,
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const PreviewSchema = z.object({
     "enabled": z.boolean(),
     "images": z.array(ImageSchema),
-});
+}).strict();
 export type Preview = z.infer<typeof PreviewSchema>;
 
 export const ChildDataSchema = z.object({
@@ -156,13 +156,13 @@ export const ChildDataSchema = z.object({
     "view_count": z.null(),
     "visited": z.boolean(),
     "whitelist_status": WhitelistStatusSchema,
-});
+}).strict();
 export type ChildData = z.infer<typeof ChildDataSchema>;
 
 export const ChildSchema = z.object({
     "data": ChildDataSchema,
     "kind": KindSchema,
-});
+}).strict();
 export type Child = z.infer<typeof ChildSchema>;
 
 export const TopLevelDataSchema = z.object({
@@ -170,11 +170,11 @@ export const TopLevelDataSchema = z.object({
     "before": z.null(),
     "children": z.array(ChildSchema),
     "modhash": z.string(),
-});
+}).strict();
 export type TopLevelData = z.infer<typeof TopLevelDataSchema>;
 
 export const TopLevelSchema = z.object({
     "data": TopLevelDataSchema,
     "kind": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/samples/simple-object.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/samples/simple-object.json/default/TopLevel.ts
index 2750ff7..d777822 100644
--- a/base/typescript-zod/test/inputs/json/samples/simple-object.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/samples/simple-object.json/default/TopLevel.ts
@@ -5,5 +5,5 @@ export const TopLevelSchema = z.object({
     "date": z.number().int(),
     "title": z.string(),
     "validity": z.boolean(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/samples/spotify-album.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/samples/spotify-album.json/default/TopLevel.ts
index cdbdd89..1d2b9e7 100644
--- a/base/typescript-zod/test/inputs/json/samples/spotify-album.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/samples/spotify-album.json/default/TopLevel.ts
@@ -3,25 +3,25 @@ import * as z from "zod";
 
 export const ExternalUrlsSchema = z.object({
     "spotify": z.string(),
-});
+}).strict();
 export type ExternalUrls = z.infer<typeof ExternalUrlsSchema>;
 
 export const CopyrightSchema = z.object({
     "text": z.string(),
     "type": z.string(),
-});
+}).strict();
 export type Copyright = z.infer<typeof CopyrightSchema>;
 
 export const ExternalIdsSchema = z.object({
     "upc": z.string(),
-});
+}).strict();
 export type ExternalIds = z.infer<typeof ExternalIdsSchema>;
 
 export const ImageSchema = z.object({
     "height": z.number().int(),
     "url": z.string(),
     "width": z.number().int(),
-});
+}).strict();
 export type Image = z.infer<typeof ImageSchema>;
 
 export const ArtistSchema = z.object({
@@ -31,7 +31,7 @@ export const ArtistSchema = z.object({
     "name": z.string(),
     "type": z.string(),
     "uri": z.string(),
-});
+}).strict();
 export type Artist = z.infer<typeof ArtistSchema>;
 
 export const ItemSchema = z.object({
@@ -48,7 +48,7 @@ export const ItemSchema = z.object({
     "track_number": z.number().int(),
     "type": z.string(),
     "uri": z.string(),
-});
+}).strict();
 export type Item = z.infer<typeof ItemSchema>;
 
 export const TracksSchema = z.object({
@@ -59,7 +59,7 @@ export const TracksSchema = z.object({
     "offset": z.number().int(),
     "previous": z.null(),
     "total": z.number().int(),
-});
+}).strict();
 export type Tracks = z.infer<typeof TracksSchema>;
 
 export const TopLevelSchema = z.object({
@@ -80,5 +80,5 @@ export const TopLevelSchema = z.object({
     "tracks": TracksSchema,
     "type": z.string(),
     "uri": z.string(),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.ts
index b71dac0..cfc3dbb 100644
--- a/base/typescript-zod/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/samples/us-avg-temperatures.json/default/TopLevel.ts
@@ -4,7 +4,7 @@ import * as z from "zod";
 export const DatumSchema = z.object({
     "anomaly": z.string(),
     "value": z.string(),
-});
+}).strict();
 export type Datum = z.infer<typeof DatumSchema>;
 
 export const DescriptionSchema = z.object({
@@ -12,11 +12,11 @@ export const DescriptionSchema = z.object({
     "missing": z.number().int(),
     "title": z.string(),
     "units": z.string(),
-});
+}).strict();
 export type Description = z.infer<typeof DescriptionSchema>;
 
 export const TopLevelSchema = z.object({
     "data": z.record(z.string(), DatumSchema),
     "description": DescriptionSchema,
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;
diff --git a/base/typescript-zod/test/inputs/json/samples/us-senators.json/default/TopLevel.ts b/head/typescript-zod/test/inputs/json/samples/us-senators.json/default/TopLevel.ts
index d0aa369..709948b 100644
--- a/base/typescript-zod/test/inputs/json/samples/us-senators.json/default/TopLevel.ts
+++ b/head/typescript-zod/test/inputs/json/samples/us-senators.json/default/TopLevel.ts
@@ -82,7 +82,7 @@ export const MetaSchema = z.object({
     "limit": z.number().int(),
     "offset": z.number().int(),
     "total_count": z.number().int(),
-});
+}).strict();
 export type Meta = z.infer<typeof MetaSchema>;
 
 export const ExtraSchema = z.object({
@@ -91,7 +91,7 @@ export const ExtraSchema = z.object({
     "fax": z.string().optional(),
     "office": z.string(),
     "rss_url": z.string().optional(),
-});
+}).strict();
 export type Extra = z.infer<typeof ExtraSchema>;
 
 export const PersonSchema = z.object({
@@ -112,7 +112,7 @@ export const PersonSchema = z.object({
     "sortname": z.string(),
     "twitterid": z.union([z.null(), z.string()]),
     "youtubeid": z.union([z.null(), z.string()]),
-});
+}).strict();
 export type Person = z.infer<typeof PersonSchema>;
 
 export const ObjectElementSchema = z.object({
@@ -138,11 +138,11 @@ export const ObjectElementSchema = z.object({
     "title": TitleSchema,
     "title_long": RoleTypeLabelSchema,
     "website": z.string(),
-});
+}).strict();
 export type ObjectElement = z.infer<typeof ObjectElementSchema>;
 
 export const TopLevelSchema = z.object({
     "meta": MetaSchema,
     "objects": z.array(ObjectElementSchema),
-});
+}).strict();
 export type TopLevel = z.infer<typeof TopLevelSchema>;