zod-codegen 1.2.1 → 1.3.0

package/.claude/settings.local.json

@@ -0,0 +1,43 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm install:*)",
+      "Bash(npm uninstall:*)",
+      "Bash(npm run type-check:*)",
+      "Bash(npm run build:*)",
+      "Bash(./dist/src/cli.js --help)",
+      "Bash(./dist/src/cli.js --version)",
+      "Bash(npm run dev:*)",
+      "Bash(node:*)",
+      "Bash(npm run lint)",
+      "Bash(npx husky init:*)",
+      "Bash(chmod:*)",
+      "Bash(npm run validate:*)",
+      "Bash(npm run format:*)",
+      "Bash(npm run test:*)",
+      "Bash(npm test)",
+      "Bash(npm audit:*)",
+      "Bash(npx depcheck:*)",
+      "Bash(npm outdated)",
+      "Bash(npm update:*)",
+      "WebSearch",
+      "Bash(find:*)",
+      "Bash(npx zod-codegen:*)",
+      "Bash(DEBUG=1 node ./dist/src/cli.js --input ./samples/openapi.json --output ./test-generated)",
+      "Bash(rm:*)",
+      "Bash(npm outdated:*)",
+      "Bash(npm view:*)",
+      "Bash(git tag:*)",
+      "Bash(npm run release:*)",
+      "Bash(git log:*)",
+      "Bash(npx commitlint:*)",
+      "Bash(git rev-list:*)",
+      "Bash(./fix-commit-messages.sh:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(FILTER_BRANCH_SQUELCH_WARNING=1 ./fix-commit-messages.sh)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 
@@ -64,7 +64,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
 
       - name: Setup Node.js
         uses: actions/setup-node@v5
@@ -85,7 +85,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
 
       - name: Setup Node.js
         uses: actions/setup-node@v5
@@ -121,7 +121,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
 

package/.github/workflows/release.yml

@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
           token: ${{ secrets.GITHUB_TOKEN }}

package/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 1.3.0 (2025-11-24)
+
+- Merge pull request #36 from julienandreu/dependabot/npm_and_yarn/dev-dependencies-16beb30ed0 ([3d85de4](https://github.com/julienandreu/zod-codegen/commit/3d85de4)), closes [#36](https://github.com/julienandreu/zod-codegen/issues/36)
+- Merge pull request #37 from julienandreu/dependabot/npm_and_yarn/production-dependencies-e947a059e9 ([25bfc2e](https://github.com/julienandreu/zod-codegen/commit/25bfc2e)), closes [#37](https://github.com/julienandreu/zod-codegen/issues/37)
+- Merge pull request #38 from julienandreu/dependabot/github_actions/actions/checkout-6 ([6377f8b](https://github.com/julienandreu/zod-codegen/commit/6377f8b)), closes [#38](https://github.com/julienandreu/zod-codegen/issues/38)
+- Merge pull request #39 from julienandreu/migrate-zod-string-api-v4 ([472d53f](https://github.com/julienandreu/zod-codegen/commit/472d53f)), closes [#39](https://github.com/julienandreu/zod-codegen/issues/39)
+- feat: migrate deprecated Zod string schema API to v4 ([b4461b4](https://github.com/julienandreu/zod-codegen/commit/b4461b4))
+- ci(deps): bump actions/checkout from 5 to 6 ([45d007c](https://github.com/julienandreu/zod-codegen/commit/45d007c))
+- chore(deps-dev): bump the dev-dependencies group with 3 updates ([644ecdc](https://github.com/julienandreu/zod-codegen/commit/644ecdc))
+- chore(deps): bump zod in the production-dependencies group ([69b5694](https://github.com/julienandreu/zod-codegen/commit/69b5694))
+
+## <small>1.2.2 (2025-11-19)</small>
+
+- Merge pull request #35 from julienandreu/fix/generate-typescript-type-aliases ([b8d9250](https://github.com/julienandreu/zod-codegen/commit/b8d9250)), closes [#35](https://github.com/julienandreu/zod-codegen/issues/35)
+- fix: generate TypeScript type aliases alongside Zod schemas ([7032a69](https://github.com/julienandreu/zod-codegen/commit/7032a69))
+
 ## <small>1.2.1 (2025-11-19)</small>
 
 - Merge pull request #33 from julienandreu/fix/add-z-infer-to-response-types ([a14d81c](https://github.com/julienandreu/zod-codegen/commit/a14d81c)), closes [#33](https://github.com/julienandreu/zod-codegen/issues/33)

package/dist/src/services/code-generator.service.js

@@ -40,6 +40,7 @@ export class TypeScriptCodeGeneratorService {
     buildAST(openapi) {
         const imports = this.importBuilder.buildImports();
         const schemas = this.buildSchemas(openapi);
+        const schemaTypeAliases = this.buildSchemaTypeAliases(schemas);
         const serverConfig = this.buildServerConfiguration(openapi);
         const clientClass = this.buildClientClass(openapi, schemas);
         return [
@@ -47,6 +48,7 @@ export class TypeScriptCodeGeneratorService {
             ...imports,
             this.createComment('Components schemas'),
             ...Object.values(schemas),
+            ...schemaTypeAliases,
             ...serverConfig,
             this.createComment('Client class'),
             clientClass,
@@ -68,6 +70,12 @@ export class TypeScriptCodeGeneratorService {
             };
         }, {});
     }
+    buildSchemaTypeAliases(schemas) {
+        return Object.keys(schemas).map((name) => {
+            const sanitizedName = this.typeBuilder.sanitizeIdentifier(name);
+            return ts.factory.createTypeAliasDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(sanitizedName), undefined, ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')), [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedName), undefined)]));
+        });
+    }
     buildClientClass(openapi, schemas) {
         const clientName = this.generateClientName(openapi.info.title);
         const methods = this.buildClientMethods(openapi, schemas);
@@ -516,36 +524,34 @@ export class TypeScriptCodeGeneratorService {
         }
         const responseSchema = response.content['application/json'].schema;
         const typeName = this.getSchemaTypeName(responseSchema, schemas);
-        const inferredType = this.wrapTypeWithZInfer(typeName, schemas);
-        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [inferredType]);
-    }
-    wrapTypeWithZInfer(typeName, schemas) {
-        // Primitive types and Record types don't need z.infer
-        const primitiveTypes = ['string', 'number', 'boolean', 'unknown'];
-        if (primitiveTypes.includes(typeName) || typeName.startsWith('Record<')) {
-            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
-        }
         // Handle array types like "Pet[]"
         if (typeName.endsWith('[]')) {
             const itemTypeName = typeName.slice(0, -2);
             const sanitizedItemTypeName = this.typeBuilder.sanitizeIdentifier(itemTypeName);
-            // Check if the item type is a custom schema
+            // Check if the item type is a custom schema (we have a type alias for it)
             if (schemas[sanitizedItemTypeName]) {
-                // Return z.infer<typeof ItemType>[]
-                const zInferType = ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')), [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedItemTypeName), undefined)]);
-                return ts.factory.createArrayTypeNode(zInferType);
+                // Use the type alias directly (it already uses z.infer)
+                return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+                    ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedItemTypeName), undefined)),
+                ]);
             }
-            // If it's a primitive array, return as-is
-            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
+            // If it's a primitive array, use the type name as-is
+            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
+            ]);
         }
-        // Handle custom schema types
         const sanitizedTypeName = this.typeBuilder.sanitizeIdentifier(typeName);
+        // Check if it's a custom schema type (we have a type alias for it)
         if (schemas[sanitizedTypeName]) {
-            // Return z.infer<typeof TypeName>
-            return ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')), [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedTypeName), undefined)]);
+            // Use the type name directly (we have a type alias that already uses z.infer)
+            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedTypeName), undefined),
+            ]);
         }
-        // Fallback: return as-is if we can't determine
-        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
+        // For primitive types and Record types, use the type name directly
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
+        ]);
     }
     buildServerConfiguration(openapi) {
         const servers = openapi.servers;
@@ -975,20 +981,20 @@ export class TypeScriptCodeGeneratorService {
                 if (prop['format']) {
                     switch (prop['format']) {
                         case 'email':
-                            stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('email')), undefined, []);
+                            stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('email')), undefined, []);
                             break;
                         case 'uri':
                         case 'url':
-                            stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('url')), undefined, []);
+                            stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('url')), undefined, []);
                             break;
                         case 'uuid':
-                            stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('uuid')), undefined, []);
+                            stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('uuid')), undefined, []);
                             break;
                         case 'date-time':
-                            stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('datetime')), undefined, []);
+                            stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('iso')), ts.factory.createIdentifier('datetime')), undefined, [this.buildDefaultValue({ local: true })]);
                             break;
                         case 'date':
-                            stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('date')), undefined, []);
+                            stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('iso')), ts.factory.createIdentifier('date')), undefined, []);
                             break;
                         case 'time':
                             stringSchema = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('time')), undefined, []);

package/package.json

@@ -19,7 +19,7 @@
     "typescript": "^5.9.3",
     "url-pattern": "^1.0.3",
     "yargs": "^18.0.0",
-    "zod": "^4.1.12"
+    "zod": "^4.1.13"
   },
   "description": "A powerful TypeScript code generator that creates Zod schemas and type-safe clients from OpenAPI specifications",
   "keywords": [
@@ -45,16 +45,16 @@
     "@types/jsonpath": "^0.2.4",
     "@types/node": "^24.10.1",
     "@types/yargs": "^17.0.35",
-    "@vitest/coverage-v8": "^4.0.9",
+    "@vitest/coverage-v8": "^4.0.13",
     "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
     "husky": "^9.1.7",
-    "lint-staged": "^16.2.6",
+    "lint-staged": "^16.2.7",
     "semantic-release": "^25.0.2",
     "ts-node": "^10.9.2",
     "typescript-eslint": "^8.46.4",
     "undici": "^7.16.0",
-    "vitest": "^4.0.8",
+    "vitest": "^4.0.13",
     "yarn-audit-fix": "^10.1.1"
   },
   "optionalDependencies": {
@@ -110,5 +110,5 @@
     "release": "semantic-release",
     "release:dry": "semantic-release --dry-run"
   },
-  "version": "1.2.1"
+  "version": "1.3.0"
 }

package/scripts/republish-versions.sh

@@ -0,0 +1,94 @@
+#!/bin/bash
+
+# Script to republish missing versions to npm
+# Usage: ./scripts/republish-versions.sh [version1] [version2]
+# Example: ./scripts/republish-versions.sh 1.3.0 1.4.0
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Function to publish a version
+publish_version() {
+    local version=$1
+    local tag="v${version}"
+    
+    echo -e "${YELLOW}📦 Publishing version ${version}...${NC}"
+    
+    # Check if tag exists
+    if ! git rev-parse "$tag" >/dev/null 2>&1; then
+        echo -e "${RED}❌ Tag ${tag} does not exist${NC}"
+        return 1
+    fi
+    
+    # Check if version is already published
+    if npm view "zod-codegen@${version}" version >/dev/null 2>&1; then
+        echo -e "${YELLOW}⚠️  Version ${version} already exists on npm. Skipping...${NC}"
+        return 0
+    fi
+    
+    # Save current branch/commit
+    local current_branch=$(git rev-parse --abbrev-ref HEAD)
+    local current_commit=$(git rev-parse HEAD)
+    
+    echo -e "${GREEN}✓ Checking out tag ${tag}${NC}"
+    git checkout "$tag" --quiet
+    
+    # Verify package.json version matches
+    local package_version=$(node -p "require('./package.json').version")
+    if [ "$package_version" != "$version" ]; then
+        echo -e "${RED}❌ Package.json version (${package_version}) doesn't match tag version (${version})${NC}"
+        git checkout "$current_branch" --quiet 2>/dev/null || git checkout "$current_commit" --quiet
+        return 1
+    fi
+    
+    # Install dependencies
+    echo -e "${GREEN}✓ Installing dependencies...${NC}"
+    yarn install --frozen-lockfile
+    
+    # Build project
+    echo -e "${GREEN}✓ Building project...${NC}"
+    yarn build
+    
+    # Run prepublishOnly checks (build, test, lint, type-check)
+    echo -e "${GREEN}✓ Running prepublish checks...${NC}"
+    yarn test
+    yarn lint:check
+    yarn type-check
+    
+    # Publish to npm
+    echo -e "${GREEN}✓ Publishing to npm...${NC}"
+    npm publish --access public
+    
+    echo -e "${GREEN}✅ Successfully published version ${version}${NC}"
+    
+    # Return to original branch/commit
+    echo -e "${GREEN}✓ Returning to ${current_branch}...${NC}"
+    git checkout "$current_branch" --quiet 2>/dev/null || git checkout "$current_commit" --quiet
+    
+    echo ""
+}
+
+# Check if npm is authenticated
+if ! npm whoami >/dev/null 2>&1; then
+    echo -e "${RED}❌ Not authenticated to npm. Please run 'npm login' first.${NC}"
+    exit 1
+fi
+
+echo -e "${GREEN}✓ Authenticated as $(npm whoami)${NC}"
+echo ""
+
+# Get versions from arguments or use defaults
+VERSIONS=("${@:-1.3.0 1.4.0}")
+
+# Publish each version
+for version in "${VERSIONS[@]}"; do
+    publish_version "$version"
+done
+
+echo -e "${GREEN}🎉 All versions published successfully!${NC}"
+

package/src/services/code-generator.service.ts

@@ -53,6 +53,7 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
   private buildAST(openapi: OpenApiSpecType): ts.Statement[] {
     const imports = this.importBuilder.buildImports();
     const schemas = this.buildSchemas(openapi);
+    const schemaTypeAliases = this.buildSchemaTypeAliases(schemas);
     const serverConfig = this.buildServerConfiguration(openapi);
     const clientClass = this.buildClientClass(openapi, schemas);
 
@@ -61,6 +62,7 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
       ...imports,
       this.createComment('Components schemas'),
       ...Object.values(schemas),
+      ...schemaTypeAliases,
       ...serverConfig,
       this.createComment('Client class'),
       clientClass,
@@ -97,6 +99,21 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
     }, {});
   }
 
+  private buildSchemaTypeAliases(schemas: Record<string, ts.VariableStatement>): ts.TypeAliasDeclaration[] {
+    return Object.keys(schemas).map((name) => {
+      const sanitizedName = this.typeBuilder.sanitizeIdentifier(name);
+      return ts.factory.createTypeAliasDeclaration(
+        [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+        ts.factory.createIdentifier(sanitizedName),
+        undefined,
+        ts.factory.createTypeReferenceNode(
+          ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')),
+          [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedName), undefined)],
+        ),
+      );
+    });
+  }
+
   private buildClientClass(
     openapi: OpenApiSpecType,
     schemas: Record<string, ts.VariableStatement>,
@@ -1264,48 +1281,41 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
 
     const responseSchema = response.content['application/json'].schema;
     const typeName = this.getSchemaTypeName(responseSchema, schemas);
-    const inferredType = this.wrapTypeWithZInfer(typeName, schemas);
-
-    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [inferredType]);
-  }
-
-  private wrapTypeWithZInfer(typeName: string, schemas: Record<string, ts.VariableStatement>): ts.TypeNode {
-    // Primitive types and Record types don't need z.infer
-    const primitiveTypes = ['string', 'number', 'boolean', 'unknown'];
-    if (primitiveTypes.includes(typeName) || typeName.startsWith('Record<')) {
-      return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
-    }
 
     // Handle array types like "Pet[]"
     if (typeName.endsWith('[]')) {
       const itemTypeName = typeName.slice(0, -2);
       const sanitizedItemTypeName = this.typeBuilder.sanitizeIdentifier(itemTypeName);
 
-      // Check if the item type is a custom schema
+      // Check if the item type is a custom schema (we have a type alias for it)
       if (schemas[sanitizedItemTypeName]) {
-        // Return z.infer<typeof ItemType>[]
-        const zInferType = ts.factory.createTypeReferenceNode(
-          ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')),
-          [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedItemTypeName), undefined)],
-        );
-        return ts.factory.createArrayTypeNode(zInferType);
+        // Use the type alias directly (it already uses z.infer)
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+          ts.factory.createArrayTypeNode(
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedItemTypeName), undefined),
+          ),
+        ]);
       }
-      // If it's a primitive array, return as-is
-      return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
+      // If it's a primitive array, use the type name as-is
+      return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
+      ]);
     }
 
-    // Handle custom schema types
     const sanitizedTypeName = this.typeBuilder.sanitizeIdentifier(typeName);
+
+    // Check if it's a custom schema type (we have a type alias for it)
     if (schemas[sanitizedTypeName]) {
-      // Return z.infer<typeof TypeName>
-      return ts.factory.createTypeReferenceNode(
-        ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')),
-        [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedTypeName), undefined)],
-      );
+      // Use the type name directly (we have a type alias that already uses z.infer)
+      return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedTypeName), undefined),
+      ]);
     }
 
-    // Fallback: return as-is if we can't determine
-    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
+    // For primitive types and Record types, use the type name directly
+    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+      ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
+    ]);
   }
 
   private buildServerConfiguration(openapi: OpenApiSpecType): ts.Statement[] {
@@ -2276,7 +2286,10 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
           switch (prop['format']) {
             case 'email':
               stringSchema = ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('email')),
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier('z'),
+                  ts.factory.createIdentifier('email'),
+                ),
                 undefined,
                 [],
               );
@@ -2284,28 +2297,46 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
             case 'uri':
             case 'url':
               stringSchema = ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('url')),
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier('z'),
+                  ts.factory.createIdentifier('url'),
+                ),
                 undefined,
                 [],
               );
               break;
             case 'uuid':
               stringSchema = ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('uuid')),
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier('z'),
+                  ts.factory.createIdentifier('uuid'),
+                ),
                 undefined,
                 [],
               );
               break;
             case 'date-time':
               stringSchema = ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('datetime')),
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createIdentifier('z'),
+                    ts.factory.createIdentifier('iso'),
+                  ),
+                  ts.factory.createIdentifier('datetime'),
+                ),
                 undefined,
-                [],
+                [this.buildDefaultValue({local: true})],
               );
               break;
             case 'date':
               stringSchema = ts.factory.createCallExpression(
-                ts.factory.createPropertyAccessExpression(stringSchema, ts.factory.createIdentifier('date')),
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createIdentifier('z'),
+                    ts.factory.createIdentifier('iso'),
+                  ),
+                  ts.factory.createIdentifier('date'),
+                ),
                 undefined,
                 [],
               );