```diff
--- test_files/437-original.txt	2025-03-07 19:07:00
+++ test_files/437-modified.txt	2025-03-07 19:07:00
@@ -1,59 +1,71 @@
-import { jsonSchemaToTsType, jsonSchemaToModel, getEnvVariable, nodeExternalRequire } from './shared';
-import z from 'zod';
+import z from "zod";
+import {
+  getEnvVariable,
+  jsonSchemaToModel,
+  jsonSchemaToTsType,
+  nodeExternalRequire,
+} from "./shared";
 
-describe('shared utilities', () => {
-  describe('jsonSchemaToTsType', () => {
-    it('should convert json schema types to TypeScript types', () => {
-      expect(jsonSchemaToTsType({ type: 'string' })).toBe(String);
-      expect(jsonSchemaToTsType({ type: 'integer' })).toBe(Number);
-      expect(jsonSchemaToTsType({ type: 'number' })).toBe(Number);
-      expect(jsonSchemaToTsType({ type: 'boolean' })).toBe(Boolean);
-      expect(jsonSchemaToTsType({ type: 'null' })).toBe(null);
-      expect(() => jsonSchemaToTsType({ type: 'unknown' })).toThrow('Unsupported JSON schema type: unknown');
+describe("shared utilities", () => {
+  describe("jsonSchemaToTsType", () => {
+    it("should convert json schema types to TypeScript types", () => {
+      expect(jsonSchemaToTsType({ type: "string" })).toBe(String);
+      expect(jsonSchemaToTsType({ type: "integer" })).toBe(Number);
+      expect(jsonSchemaToTsType({ type: "number" })).toBe(Number);
+      expect(jsonSchemaToTsType({ type: "boolean" })).toBe(Boolean);
+      expect(jsonSchemaToTsType({ type: "null" })).toBe(null);
+      expect(() => jsonSchemaToTsType({ type: "unknown" })).toThrow(
+        "Unsupported JSON schema type: unknown"
+      );
     });
   });
 
-  describe('jsonSchemaToModel', () => {
-    it('should convert json schema to zod model', () => {
+  describe("jsonSchemaToModel", () => {
+    it("should convert json schema to zod model", () => {
       const schema = {
-        type: 'object',
+        type: "object",
         properties: {
-          name: { type: 'string' },
-          age: { type: 'integer' },
+          name: { type: "string" },
+          age: { type: "integer" },
         },
-        required: ['name']
+        required: ["name"],
       };
       const model = jsonSchemaToModel(schema);
       expect(model).toBeInstanceOf(z.ZodObject);
-      expect(() => model.parse({ name: 'John', age: 'not a number' })).toThrow();
-      expect(model.parse({ name: 'John', age: 30 })).toEqual({ name: 'John', age: 30 });
+      expect(() =>
+        model.parse({ name: "John", age: "not a number" })
+      ).toThrow();
+      expect(model.parse({ name: "John", age: 30 })).toEqual({
+        name: "John",
+        age: 30,
+      });
     });
   });
 
-  describe('getEnvVariable', () => {
-    it('should return the environment variable if set', () => {
-      process.env.TEST_VAR = 'test';
-      expect(getEnvVariable('TEST_VAR')).toBe('test');
+  describe("getEnvVariable", () => {
+    it("should return the environment variable if set", () => {
+      process.env.TEST_VAR = "test";
+      expect(getEnvVariable("TEST_VAR")).toBe("test");
     });
 
-    it('should return undefined if the environment variable is not set', () => {
+    it("should return undefined if the environment variable is not set", () => {
       delete process.env.TEST_VAR;
-      expect(getEnvVariable('TEST_VAR')).toBeUndefined();
+      expect(getEnvVariable("TEST_VAR")).toBeUndefined();
     });
 
-    it('should return the default value if the environment variable is not set and default is provided', () => {
-      expect(getEnvVariable('TEST_VAR', 'default')).toBe('default');
+    it("should return the default value if the environment variable is not set and default is provided", () => {
+      expect(getEnvVariable("TEST_VAR", "default")).toBe("default");
     });
   });
 
-  describe('nodeExternalRequire', () => {
-    it('should require a module', () => {
-      const module = nodeExternalRequire('path');
+  describe("nodeExternalRequire", () => {
+    it("should require a module", () => {
+      const module = nodeExternalRequire("path");
       expect(module).toBeDefined();
     });
 
-    it('should return null if the module cannot be required', () => {
-      const module = nodeExternalRequire('nonexistent-module');
+    it("should return null if the module cannot be required", () => {
+      const module = nodeExternalRequire("nonexistent-module");
       expect(module).toBeNull();
     });
   });
```
