@sanity/codegen 4.19.1-next.8 → 4.20.0-next.40

package/lib/index.js

@@ -1,42 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: !0 });
-var fs = require("node:fs/promises"), json5 = require("json5"), z = require("zod"), groqJs = require("groq-js"), createDebug = require("debug"), glob = require("globby"), fs$1 = require("node:fs"), path = require("node:path"), node_module = require("node:module"), core = require("@babel/core"), t = require("@babel/types"), traverse = require("@babel/traverse"), tsconfigPaths = require("tsconfig-paths"), register = require("@babel/register"), generator = require("@babel/generator");
-function _interopDefaultCompat(e) {
-  return e && typeof e == "object" && "default" in e ? e : { default: e };
-}
-function _interopNamespaceCompat(e) {
-  if (e && typeof e == "object" && "default" in e) return e;
-  var n = /* @__PURE__ */ Object.create(null);
-  return e && Object.keys(e).forEach(function(k) {
-    if (k !== "default") {
-      var d = Object.getOwnPropertyDescriptor(e, k);
-      Object.defineProperty(n, k, d.get ? d : {
-        enumerable: !0,
-        get: function() {
-          return e[k];
-        }
-      });
-    }
-  }), n.default = e, Object.freeze(n);
-}
-var fs__default$1 = /* @__PURE__ */ _interopDefaultCompat(fs), json5__default = /* @__PURE__ */ _interopDefaultCompat(json5), z__namespace = /* @__PURE__ */ _interopNamespaceCompat(z), createDebug__default = /* @__PURE__ */ _interopDefaultCompat(createDebug), glob__default = /* @__PURE__ */ _interopDefaultCompat(glob), fs__default = /* @__PURE__ */ _interopDefaultCompat(fs$1), path__default = /* @__PURE__ */ _interopDefaultCompat(path), t__namespace = /* @__PURE__ */ _interopNamespaceCompat(t), traverse__default = /* @__PURE__ */ _interopDefaultCompat(traverse), register__default = /* @__PURE__ */ _interopDefaultCompat(register);
-const configDefinition = z__namespace.object({
-  path: z__namespace.string().or(z__namespace.array(z__namespace.string())).default([
+import fs$1, { readFile } from "node:fs/promises";
+import json5 from "json5";
+import * as z from "zod";
+import { parse } from "groq-js";
+import createDebug from "debug";
+import glob from "globby";
+import fs, { existsSync } from "node:fs";
+import path, { dirname, join, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { parse as parse$1, traverse as traverse$1 } from "@babel/core";
+import * as t from "@babel/types";
+import traverse, { Scope } from "@babel/traverse";
+import { loadConfig, createMatchPath } from "tsconfig-paths";
+import register from "@babel/register";
+import { CodeGenerator } from "@babel/generator";
+const configDefinition = z.object({
+  path: z.string().or(z.array(z.string())).default([
     "./src/**/*.{ts,tsx,js,jsx,mjs,cjs,astro}",
     "./app/**/*.{ts,tsx,js,jsx,mjs,cjs}",
     "./sanity/**/*.{ts,tsx,js,jsx,mjs,cjs}"
   ]),
-  schema: z__namespace.string().default("./schema.json"),
-  generates: z__namespace.string().default("./sanity.types.ts"),
-  formatGeneratedCode: z__namespace.boolean().default(!0),
-  overloadClientMethods: z__namespace.boolean().default(!0)
+  schema: z.string().default("./schema.json"),
+  generates: z.string().default("./sanity.types.ts"),
+  formatGeneratedCode: z.boolean().default(!0),
+  overloadClientMethods: z.boolean().default(!0)
 });
 async function readConfig(path2) {
   try {
-    const content = await fs.readFile(path2, "utf-8"), json = json5__default.default.parse(content);
+    const content = await readFile(path2, "utf-8"), json = json5.parse(content);
     return configDefinition.parseAsync(json);
   } catch (error) {
-    if (error instanceof z__namespace.ZodError)
+    if (error instanceof z.ZodError)
       throw new Error(
         `Error in config file
  ${error.errors.map((err) => err.message).join(`
@@ -49,14 +43,14 @@ async function readConfig(path2) {
   }
 }
 async function readSchema(path2) {
-  const content = await fs.readFile(path2, "utf-8");
+  const content = await readFile(path2, "utf-8");
   return JSON.parse(content);
 }
 function safeParseQuery(query) {
   const params = {};
   for (const param of extractSliceParams(query))
     params[param] = 0;
-  return groqJs.parse(query, { params });
+  return parse(query, { params });
 }
 function* extractSliceParams(query) {
   const sliceRegex = /\[(\$(\w+)|\d)\.\.\.?(\$(\w+)|\d)\]/g, matches = query.matchAll(sliceRegex);
@@ -68,22 +62,23 @@ function* extractSliceParams(query) {
       end !== null && (yield end);
     }
 }
-function findBabelConfig(path$1) {
-  const configPath = path.join(path$1, "babel.config.json");
-  if (fs$1.existsSync(configPath))
+const __dirname$1 = dirname(new URL(import.meta.url).pathname);
+function findBabelConfig(path2) {
+  const configPath = join(path2, "babel.config.json");
+  if (existsSync(configPath))
     return configPath;
-  const parent = path.resolve(path.join(path$1, ".."));
-  if (parent && parent !== path$1)
+  const parent = resolve(join(path2, ".."));
+  if (parent && parent !== path2)
     return findBabelConfig(parent);
   throw new Error("Could not find `babel.config.json` in @sanity/codegen");
 }
 function getBabelConfig(path2) {
-  return { extends: findBabelConfig(__dirname) };
+  return { extends: findBabelConfig(__dirname$1) };
 }
 function parseSourceFile(_source, _filename, babelOptions) {
   let source = _source, filename = _filename;
   filename.endsWith(".astro") ? (filename += ".ts", source = parseAstro(source)) : filename.endsWith(".vue") && (filename += ".ts", source = parseVue(source));
-  const result = core.parse(source, {
+  const result = parse$1(source, {
     ...babelOptions,
     filename
   });
@@ -112,7 +107,7 @@ function matchAllPolyfill(str, regex) {
     matches.push(match);
   return matches;
 }
-const debug$2 = createDebug__default.default("sanity:codegen:findQueries:debug"), TAGGED_TEMPLATE_ALLOW_LIST = ["groq"], FUNCTION_WRAPPER_ALLOW_LIST = ["defineQuery"];
+const debug$2 = createDebug("sanity:codegen:findQueries:debug"), TAGGED_TEMPLATE_ALLOW_LIST = ["groq"], FUNCTION_WRAPPER_ALLOW_LIST = ["defineQuery"];
 function resolveExpression({
   node,
   file,
@@ -125,7 +120,7 @@ function resolveExpression({
 }) {
   if (debug$2(
     `Resolving node ${node.type} in ${filename}:${node.loc?.start.line}:${node.loc?.start.column}`
-  ), t__namespace.isTaggedTemplateExpression(node) && t__namespace.isIdentifier(node.tag) && TAGGED_TEMPLATE_ALLOW_LIST.includes(node.tag.name))
+  ), t.isTaggedTemplateExpression(node) && t.isIdentifier(node.tag) && TAGGED_TEMPLATE_ALLOW_LIST.includes(node.tag.name))
     return resolveExpression({
       node: node.quasi,
       scope,
@@ -136,7 +131,7 @@ function resolveExpression({
       babelConfig,
       fnArguments
     });
-  if (t__namespace.isTemplateLiteral(node)) {
+  if (t.isTemplateLiteral(node)) {
     const resolvedExpressions = node.expressions.map(
       (expression) => resolveExpression({
         node: expression,
@@ -151,12 +146,12 @@ function resolveExpression({
     );
     return node.quasis.map((quasi, idx) => (quasi.value.cooked || "") + (resolvedExpressions[idx] || "")).join("");
   }
-  if (t__namespace.isLiteral(node)) {
+  if (t.isLiteral(node)) {
     if (node.type === "NullLiteral" || node.type === "RegExpLiteral")
       throw new Error(`Unsupported literal type: ${node.type}`);
     return node.value.toString();
   }
-  if (t__namespace.isIdentifier(node))
+  if (t.isIdentifier(node))
     return resolveIdentifier({
       node,
       scope,
@@ -167,8 +162,8 @@ function resolveExpression({
       babelConfig,
       params
     });
-  if (t__namespace.isVariableDeclarator(node)) {
-    const init = node.init ?? (t__namespace.isAssignmentPattern(node.id) && node.id.right);
+  if (t.isVariableDeclarator(node)) {
+    const init = node.init ?? (t.isAssignmentPattern(node.id) && node.id.right);
     if (!init)
       throw new Error("Unsupported variable declarator");
     return resolveExpression({
@@ -181,7 +176,7 @@ function resolveExpression({
       resolver
     });
   }
-  if (t__namespace.isCallExpression(node) && t__namespace.isIdentifier(node.callee) && FUNCTION_WRAPPER_ALLOW_LIST.includes(node.callee.name))
+  if (t.isCallExpression(node) && t.isIdentifier(node.callee) && FUNCTION_WRAPPER_ALLOW_LIST.includes(node.callee.name))
     return resolveExpression({
       node: node.arguments[0],
       scope,
@@ -191,7 +186,7 @@ function resolveExpression({
       babelConfig,
       params
     });
-  if (t__namespace.isCallExpression(node))
+  if (t.isCallExpression(node))
     return resolveCallExpression({
       node,
       scope,
@@ -201,8 +196,8 @@ function resolveExpression({
       babelConfig,
       params
     });
-  if (t__namespace.isArrowFunctionExpression(node) || t__namespace.isFunctionDeclaration(node) || t__namespace.isFunctionExpression(node)) {
-    const newScope = new traverse.Scope(scope.path, scope);
+  if (t.isArrowFunctionExpression(node) || t.isFunctionDeclaration(node) || t.isFunctionExpression(node)) {
+    const newScope = new Scope(scope.path, scope);
     return params.forEach((param, i) => {
       newScope.push({
         id: param,
@@ -219,7 +214,7 @@ function resolveExpression({
       resolver
     });
   }
-  if (t__namespace.isNewExpression(node))
+  if (t.isNewExpression(node))
     return resolveExpression({
       node: node.callee,
       scope,
@@ -228,9 +223,9 @@ function resolveExpression({
       babelConfig,
       resolver
     });
-  if (t__namespace.isImportDefaultSpecifier(node) || t__namespace.isImportSpecifier(node))
+  if (t.isImportDefaultSpecifier(node) || t.isImportSpecifier(node))
     return resolveImportSpecifier({ node, file, filename, fnArguments, resolver, babelConfig });
-  if (t__namespace.isAssignmentPattern(node))
+  if (t.isAssignmentPattern(node))
     return resolveExpression({
       node: node.right,
       scope,
@@ -256,10 +251,10 @@ function resolveIdentifier({
   params
 }) {
   const paramIndex = params.findIndex(
-    (param) => t__namespace.isIdentifier(param) && node.name === param.name || t__namespace.isAssignmentPattern(param) && t__namespace.isIdentifier(param.left) && node.name === param.left.name
+    (param) => t.isIdentifier(param) && node.name === param.name || t.isAssignmentPattern(param) && t.isIdentifier(param.left) && node.name === param.left.name
   );
   let argument = fnArguments[paramIndex];
-  if (!argument && paramIndex >= 0 && t__namespace.isAssignmentPattern(params[paramIndex]) && (argument = params[paramIndex].right), argument && t__namespace.isLiteral(argument))
+  if (!argument && paramIndex >= 0 && t.isAssignmentPattern(params[paramIndex]) && (argument = params[paramIndex].right), argument && t.isLiteral(argument))
     return resolveExpression({
       node: argument,
       scope,
@@ -272,7 +267,7 @@ function resolveIdentifier({
     });
   const binding = scope.getBinding(node.name);
   if (binding) {
-    if (t__namespace.isIdentifier(binding.path.node) && binding.path.node.name === node.name)
+    if (t.isIdentifier(binding.path.node) && binding.path.node.name === node.name)
       throw new Error(
         `Could not resolve same identifier "${node.name}" in "${filename}:${node.loc?.start.line}:${node.loc?.start.column}"`
       );
@@ -321,11 +316,11 @@ function resolveImportSpecifier({
   babelConfig
 }) {
   let importDeclaration;
-  if (traverse__default.default(file, {
+  if (traverse(file, {
     ImportDeclaration(n) {
-      if (t__namespace.isImportDeclaration(n.node))
+      if (t.isImportDeclaration(n.node))
         for (const specifier of n.node.specifiers) {
-          if (t__namespace.isImportDefaultSpecifier(specifier) && specifier.local.loc?.identifierName === node.local.name) {
+          if (t.isImportDefaultSpecifier(specifier) && specifier.local.loc?.identifierName === node.local.name) {
             importDeclaration = n.node;
             break;
           }
@@ -334,9 +329,9 @@ function resolveImportSpecifier({
     }
   }), !importDeclaration)
     throw new Error(`Could not find import declaration for ${node.local.name}`);
-  const importName = node.local.name, importFileName = importDeclaration.source.value, importPath = importFileName.startsWith("./") || importFileName.startsWith("../") ? path__default.default.resolve(path__default.default.dirname(filename), importFileName) : importFileName, resolvedFile = resolver(importPath), source = fs__default.default.readFileSync(resolvedFile), tree = parseSourceFile(source.toString(), resolvedFile, babelConfig);
+  const importName = node.local.name, importFileName = importDeclaration.source.value, importPath = importFileName.startsWith("./") || importFileName.startsWith("../") ? path.resolve(path.dirname(filename), importFileName) : importFileName, resolvedFile = resolver(importPath), source = fs.readFileSync(resolvedFile), tree = parseSourceFile(source.toString(), resolvedFile, babelConfig);
   let newScope;
-  if (traverse__default.default(tree, {
+  if (traverse(tree, {
     Program(p) {
       newScope = p.scope;
     }
@@ -354,7 +349,7 @@ function resolveImportSpecifier({
       resolver
     });
   let namedExport, newImportName;
-  if (traverse__default.default(tree, {
+  if (traverse(tree, {
     ExportDeclaration(p) {
       if (p.node.type === "ExportNamedDeclaration")
         for (const specifier of p.node.specifiers)
@@ -370,7 +365,7 @@ function resolveImportSpecifier({
       babelConfig
     });
   let result;
-  if (traverse__default.default(tree, {
+  if (traverse(tree, {
     ExportDeclaration(p) {
       if (p.node.type === "ExportAllDeclaration")
         try {
@@ -399,9 +394,9 @@ function resolveExportSpecifier({
 }) {
   if (!node.source)
     throw new Error(`Could not find source for export "${importName}" in ${filename}`);
-  const importFileName = node.source.value, importPath = path__default.default.resolve(path__default.default.dirname(filename), importFileName), resolvedFile = resolver(importPath), source = fs__default.default.readFileSync(resolvedFile), tree = parseSourceFile(source.toString(), resolvedFile, babelConfig);
+  const importFileName = node.source.value, importPath = path.resolve(path.dirname(filename), importFileName), resolvedFile = resolver(importPath), source = fs.readFileSync(resolvedFile), tree = parseSourceFile(source.toString(), resolvedFile, babelConfig);
   let newScope;
-  if (traverse__default.default(tree, {
+  if (traverse(tree, {
     Program(p) {
       newScope = p.scope;
     }
@@ -422,15 +417,15 @@ function resolveExportSpecifier({
     cause: `noBinding:${importName}`
   });
 }
-const require$1 = node_module.createRequire(__filename), groqTagName = "groq", defineQueryFunctionName = "defineQuery", groqModuleName = "groq", nextSanityModuleName = "next-sanity", ignoreValue = "@sanity-typegen-ignore";
-function findQueriesInSource(source, filename, babelConfig = getBabelConfig(), resolver = require$1.resolve) {
+const __filename$1 = fileURLToPath(import.meta.url), require$2 = createRequire(__filename$1), groqTagName = "groq", defineQueryFunctionName = "defineQuery", groqModuleName = "groq", nextSanityModuleName = "next-sanity", ignoreValue = "@sanity-typegen-ignore";
+function findQueriesInSource(source, filename, babelConfig = getBabelConfig(), resolver = require$2.resolve) {
   const queries = [], file = parseSourceFile(source, filename, babelConfig);
-  return core.traverse(file, {
+  return traverse$1(file, {
     // Look for variable declarations, e.g. `const myQuery = groq`... and extract the query.
     // The variable name is used as the name of the query result type
     VariableDeclarator(path2) {
-      const { node, scope } = path2, init = node.init, isGroqTemplateTag = t__namespace.isTaggedTemplateExpression(init) && t__namespace.isIdentifier(init.tag) && init.tag.name === groqTagName, isDefineQueryCall = t__namespace.isCallExpression(init) && (isImportFrom(groqModuleName, defineQueryFunctionName, scope, init.callee) || isImportFrom(nextSanityModuleName, defineQueryFunctionName, scope, init.callee));
-      if (t__namespace.isIdentifier(node.id) && (isGroqTemplateTag || isDefineQueryCall)) {
+      const { node, scope } = path2, init = node.init, isGroqTemplateTag = t.isTaggedTemplateExpression(init) && t.isIdentifier(init.tag) && init.tag.name === groqTagName, isDefineQueryCall = t.isCallExpression(init) && (isImportFrom(groqModuleName, defineQueryFunctionName, scope, init.callee) || isImportFrom(nextSanityModuleName, defineQueryFunctionName, scope, init.callee));
+      if (t.isIdentifier(node.id) && (isGroqTemplateTag || isDefineQueryCall)) {
         if (declarationLeadingCommentContains(path2, ignoreValue))
           return;
         const queryName = `${node.id.name}`, queryResult = resolveExpression({
@@ -462,47 +457,47 @@ function declarationLeadingCommentContains(path2, comment) {
   )) : !1;
 }
 function isImportFrom(moduleName, importName, scope, node) {
-  if (t__namespace.isIdentifier(node)) {
+  if (t.isIdentifier(node)) {
     const binding = scope.getBinding(node.name);
     if (!binding)
       return !1;
     const { path: path2 } = binding;
-    if (t__namespace.isImportSpecifier(path2.node))
-      return path2.node.importKind === "value" && path2.parentPath && t__namespace.isImportDeclaration(path2.parentPath.node) && path2.parentPath.node.source.value === moduleName && t__namespace.isIdentifier(path2.node.imported) && path2.node.imported.name === importName;
-    if (t__namespace.isVariableDeclarator(path2.node)) {
+    if (t.isImportSpecifier(path2.node))
+      return path2.node.importKind === "value" && path2.parentPath && t.isImportDeclaration(path2.parentPath.node) && path2.parentPath.node.source.value === moduleName && t.isIdentifier(path2.node.imported) && path2.node.imported.name === importName;
+    if (t.isVariableDeclarator(path2.node)) {
       const { init } = path2.node;
-      return t__namespace.isCallExpression(init) && t__namespace.isIdentifier(init.callee) && init.callee.name === "require" && t__namespace.isStringLiteral(init.arguments[0]) && init.arguments[0].value === moduleName;
+      return t.isCallExpression(init) && t.isIdentifier(init.callee) && init.callee.name === "require" && t.isStringLiteral(init.arguments[0]) && init.arguments[0].value === moduleName;
     }
   }
-  if (t__namespace.isMemberExpression(node)) {
+  if (t.isMemberExpression(node)) {
     const { object, property } = node;
-    if (!t__namespace.isIdentifier(object))
+    if (!t.isIdentifier(object))
       return !1;
     const binding = scope.getBinding(object.name);
     if (!binding)
       return !1;
     const { path: path2 } = binding;
-    return t__namespace.isIdentifier(object) && t__namespace.isIdentifier(property) && property.name === importName && t__namespace.isImportNamespaceSpecifier(path2.node) && path2.parentPath && t__namespace.isImportDeclaration(path2.parentPath.node) && path2.parentPath.node.source.value === moduleName;
+    return t.isIdentifier(object) && t.isIdentifier(property) && property.name === importName && t.isImportNamespaceSpecifier(path2.node) && path2.parentPath && t.isImportDeclaration(path2.parentPath.node) && path2.parentPath.node.source.value === moduleName;
   }
   return !1;
 }
-const debug$1 = createDebug__default.default("sanity:codegen:moduleResolver");
+const require$1 = createRequire(import.meta.url), debug$1 = createDebug("sanity:codegen:moduleResolver");
 function getResolver(cwd) {
-  const tsConfig = tsconfigPaths.loadConfig(cwd);
+  const tsConfig = loadConfig(cwd);
   if (tsConfig.resultType === "failed")
-    return debug$1("Could not load tsconfig, using default resolver: %s", tsConfig.message), require.resolve;
-  const matchPath = tsconfigPaths.createMatchPath(
+    return debug$1("Could not load tsconfig, using default resolver: %s", tsConfig.message), require$1.resolve;
+  const matchPath = createMatchPath(
     tsConfig.absoluteBaseUrl,
     tsConfig.paths,
     tsConfig.mainFields,
     tsConfig.addMatchAll
-  ), resolve = function(request, options) {
+  ), resolve2 = function(request, options) {
     const found = matchPath(request);
-    return found !== void 0 ? require.resolve(found, options) : require.resolve(request, options);
+    return found !== void 0 ? require$1.resolve(found, options) : require$1.resolve(request, options);
   };
-  return resolve.paths = (request) => require.resolve.paths(request), resolve;
+  return resolve2.paths = (request) => require$1.resolve.paths(request), resolve2;
 }
-const debug = createDebug__default.default("sanity:codegen:findQueries:debug");
+const debug = createDebug("sanity:codegen:findQueries:debug");
 async function* findQueriesInPath({
   path: path2,
   babelOptions = getBabelConfig(),
@@ -510,7 +505,7 @@ async function* findQueriesInPath({
 }) {
   const queryNames = /* @__PURE__ */ new Set();
   debug(`Globing ${path2}`);
-  const files = glob__default.default.sync(path2, {
+  const files = glob.sync(path2, {
     absolute: !1,
     ignore: ["**/node_modules/**"],
     // we never want to look in node_modules
@@ -520,7 +515,7 @@ async function* findQueriesInPath({
     if (typeof filename == "string") {
       debug(`Found file "${filename}"`);
       try {
-        const source = await fs__default$1.default.readFile(filename, "utf8"), queries = findQueriesInSource(source, filename, babelOptions, resolver);
+        const source = await fs$1.readFile(filename, "utf8"), queries = findQueriesInSource(source, filename, babelOptions, resolver);
         for (const query of queries) {
           if (queryNames.has(query.name))
             throw new Error(
@@ -536,7 +531,7 @@ async function* findQueriesInPath({
 }
 function registerBabel(babelOptions) {
   const options = babelOptions || getBabelConfig();
-  register__default.default({ ...options, extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"] });
+  register({ ...options, extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"] });
 }
 const REFERENCE_SYMBOL_NAME = "internalGroqTypeReferenceTo", ALL_SCHEMA_TYPES = "AllSanitySchemaTypes";
 class TypeGenerator {
@@ -565,19 +560,19 @@ class TypeGenerator {
       if (!schemaName)
         throw new Error(`Schema name not found for schema ${schema.name}`);
       schemaNames.add(schemaName);
-      const typeAlias = t__namespace.tsTypeAliasDeclaration(t__namespace.identifier(schemaName), null, typeLiteral);
-      typeDeclarations.push(t__namespace.exportNamedDeclaration(typeAlias));
+      const typeAlias = t.tsTypeAliasDeclaration(t.identifier(schemaName), null, typeLiteral);
+      typeDeclarations.push(t.exportNamedDeclaration(typeAlias));
     }), typeDeclarations.push(
-      t__namespace.exportNamedDeclaration(
-        t__namespace.tsTypeAliasDeclaration(
-          t__namespace.identifier(this.getTypeName(ALL_SCHEMA_TYPES)),
+      t.exportNamedDeclaration(
+        t.tsTypeAliasDeclaration(
+          t.identifier(this.getTypeName(ALL_SCHEMA_TYPES)),
           null,
-          t__namespace.tsUnionType(
-            [...schemaNames].map((typeName) => t__namespace.tsTypeReference(t__namespace.identifier(typeName)))
+          t.tsUnionType(
+            [...schemaNames].map((typeName) => t.tsTypeReference(t.identifier(typeName)))
           )
         )
       )
-    ), typeDeclarations.map((decl) => new generator.CodeGenerator(decl).generate().code).join(`
+    ), typeDeclarations.map((decl) => new CodeGenerator(decl).generate().code).join(`
 
 `);
   }
@@ -590,14 +585,14 @@ class TypeGenerator {
    * @beta
    */
   generateTypeNodeTypes(identifierName, typeNode) {
-    const type = this.getTypeNodeType(typeNode), typeName = this.getTypeName(identifierName, typeNode), typeAlias = t__namespace.tsTypeAliasDeclaration(t__namespace.identifier(typeName), null, type);
-    return new generator.CodeGenerator(t__namespace.exportNamedDeclaration(typeAlias)).generate().code.trim();
+    const type = this.getTypeNodeType(typeNode), typeName = this.getTypeName(identifierName, typeNode), typeAlias = t.tsTypeAliasDeclaration(t.identifier(typeName), null, type);
+    return new CodeGenerator(t.exportNamedDeclaration(typeAlias)).generate().code.trim();
   }
   static generateKnownTypes() {
-    const typeOperator = t__namespace.tsTypeOperator(t__namespace.tsSymbolKeyword(), "unique"), identifier = t__namespace.identifier(REFERENCE_SYMBOL_NAME);
-    identifier.typeAnnotation = t__namespace.tsTypeAnnotation(typeOperator);
-    const decleration = t__namespace.variableDeclaration("const", [t__namespace.variableDeclarator(identifier)]);
-    return decleration.declare = !0, new generator.CodeGenerator(t__namespace.exportNamedDeclaration(decleration)).generate().code.trim();
+    const typeOperator = t.tsTypeOperator(t.tsSymbolKeyword(), "unique"), identifier = t.identifier(REFERENCE_SYMBOL_NAME);
+    identifier.typeAnnotation = t.tsTypeAnnotation(typeOperator);
+    const decleration = t.variableDeclaration("const", [t.variableDeclarator(identifier)]);
+    return decleration.declare = !0, new CodeGenerator(t.exportNamedDeclaration(decleration)).generate().code.trim();
   }
   /**
    * Takes a list of queries from the codebase and generates a type declaration
@@ -617,23 +612,23 @@ class TypeGenerator {
       const name = this.typeNodeNameMap.get(query.typeNode);
       name && (typesByQuerystring[query.query] ??= [], typesByQuerystring[query.query].push(name));
     }
-    const queryReturnInterface = t__namespace.tsInterfaceDeclaration(
-      t__namespace.identifier("SanityQueries"),
+    const queryReturnInterface = t.tsInterfaceDeclaration(
+      t.identifier("SanityQueries"),
       null,
       [],
-      t__namespace.tsInterfaceBody(
-        Object.entries(typesByQuerystring).map(([query, types]) => t__namespace.tsPropertySignature(
-          t__namespace.stringLiteral(query),
-          t__namespace.tsTypeAnnotation(
-            t__namespace.tsUnionType(types.map((type) => t__namespace.tsTypeReference(t__namespace.identifier(type))))
+      t.tsInterfaceBody(
+        Object.entries(typesByQuerystring).map(([query, types]) => t.tsPropertySignature(
+          t.stringLiteral(query),
+          t.tsTypeAnnotation(
+            t.tsUnionType(types.map((type) => t.tsTypeReference(t.identifier(type))))
           )
         ))
       )
-    ), declareModule = t__namespace.declareModule(
-      t__namespace.stringLiteral("@sanity/client"),
-      t__namespace.blockStatement([queryReturnInterface])
-    ), clientImport = t__namespace.importDeclaration([], t__namespace.stringLiteral("@sanity/client"));
-    return new generator.CodeGenerator(t__namespace.program([clientImport, declareModule])).generate().code.trim();
+    ), declareModule = t.declareModule(
+      t.stringLiteral("@sanity/client"),
+      t.blockStatement([queryReturnInterface])
+    ), clientImport = t.importDeclaration([], t.stringLiteral("@sanity/client"));
+    return new CodeGenerator(t.program([clientImport, declareModule])).generate().code.trim();
   }
   /**
    * Since we are sanitizing identifiers we migt end up with collisions. Ie there might be a type mux.video and muxVideo, both these
@@ -650,13 +645,13 @@ class TypeGenerator {
   getTypeNodeType(typeNode) {
     switch (typeNode.type) {
       case "string":
-        return typeNode.value !== void 0 ? t__namespace.tsLiteralType(t__namespace.stringLiteral(typeNode.value)) : t__namespace.tsStringKeyword();
+        return typeNode.value !== void 0 ? t.tsLiteralType(t.stringLiteral(typeNode.value)) : t.tsStringKeyword();
       case "number":
-        return typeNode.value !== void 0 ? t__namespace.tsLiteralType(t__namespace.numericLiteral(typeNode.value)) : t__namespace.tsNumberKeyword();
+        return typeNode.value !== void 0 ? t.tsLiteralType(t.numericLiteral(typeNode.value)) : t.tsNumberKeyword();
       case "boolean":
-        return typeNode.value !== void 0 ? t__namespace.tsLiteralType(t__namespace.booleanLiteral(typeNode.value)) : t__namespace.tsBooleanKeyword();
+        return typeNode.value !== void 0 ? t.tsLiteralType(t.booleanLiteral(typeNode.value)) : t.tsBooleanKeyword();
       case "unknown":
-        return t__namespace.tsUnknownKeyword();
+        return t.tsUnknownKeyword();
       case "document":
         return this.generateDocumentType(typeNode);
       case "type":
@@ -670,7 +665,7 @@ class TypeGenerator {
       case "inline":
         return this.generateInlineTsType(typeNode);
       case "null":
-        return t__namespace.tsNullKeyword();
+        return t.tsNullKeyword();
       default:
         throw new Error(`Type "${typeNode.type}" not found in schema`);
     }
@@ -678,16 +673,16 @@ class TypeGenerator {
   // Helper function used to generate TS types for array type nodes.
   generateArrayTsType(typeNode) {
     const typeNodes = this.getTypeNodeType(typeNode.of);
-    return t__namespace.tsTypeReference(
-      t__namespace.identifier("Array"),
-      t__namespace.tsTypeParameterInstantiation([typeNodes])
+    return t.tsTypeReference(
+      t.identifier("Array"),
+      t.tsTypeParameterInstantiation([typeNodes])
     );
   }
   // Helper function used to generate TS types for object properties.
   generateObjectProperty(key, attribute) {
-    const type = this.getTypeNodeType(attribute.value), propertySignature = t__namespace.tsPropertySignature(
-      t__namespace.identifier(sanitizeIdentifier(key)),
-      t__namespace.tsTypeAnnotation(type)
+    const type = this.getTypeNodeType(attribute.value), propertySignature = t.tsPropertySignature(
+      t.identifier(sanitizeIdentifier(key)),
+      t.tsTypeAnnotation(type)
     );
     return propertySignature.optional = attribute.optional, propertySignature;
   }
@@ -701,7 +696,7 @@ class TypeGenerator {
     if (rest !== void 0)
       switch (rest.type) {
         case "unknown":
-          return t__namespace.tsUnknownKeyword();
+          return t.tsUnknownKeyword();
         case "object": {
           Object.entries(rest.attributes).forEach(([key, attribute]) => {
             props.push(this.generateObjectProperty(key, attribute));
@@ -710,27 +705,27 @@ class TypeGenerator {
         }
         case "inline": {
           const resolved = this.generateInlineTsType(rest);
-          return t__namespace.isTSUnknownKeyword(resolved) ? resolved : t__namespace.tsIntersectionType([t__namespace.tsTypeLiteral(props), resolved]);
+          return t.isTSUnknownKeyword(resolved) ? resolved : t.tsIntersectionType([t.tsTypeLiteral(props), resolved]);
         }
         default:
           throw new Error(`Type "${rest.type}" not found in schema`);
       }
     if (typeNode.dereferencesTo !== void 0) {
-      const derefType = t__namespace.tsPropertySignature(
-        t__namespace.identifier(REFERENCE_SYMBOL_NAME),
-        t__namespace.tsTypeAnnotation(t__namespace.tsLiteralType(t__namespace.stringLiteral(typeNode.dereferencesTo)))
+      const derefType = t.tsPropertySignature(
+        t.identifier(REFERENCE_SYMBOL_NAME),
+        t.tsTypeAnnotation(t.tsLiteralType(t.stringLiteral(typeNode.dereferencesTo)))
       );
       derefType.computed = !0, derefType.optional = !0, props.push(derefType);
     }
-    return t__namespace.tsTypeLiteral(props);
+    return t.tsTypeLiteral(props);
   }
   generateInlineTsType(typeNode) {
     const referencedTypeNode = this.schema.find((schema) => schema.name === typeNode.name);
     if (referencedTypeNode === void 0) {
       const generatedName2 = this.typeNameMap.get(typeNode.name);
       if (generatedName2)
-        return t__namespace.tsTypeReference(t__namespace.identifier(generatedName2));
-      const missing = t__namespace.tsUnknownKeyword();
+        return t.tsTypeReference(t.identifier(generatedName2));
+      const missing = t.tsUnknownKeyword();
       return missing.trailingComments = [
         {
           type: "CommentLine",
@@ -739,23 +734,23 @@ class TypeGenerator {
       ], missing;
     }
     const generatedName = this.typeNameMap.get(referencedTypeNode.name);
-    return generatedName ? t__namespace.tsTypeReference(t__namespace.identifier(generatedName)) : t__namespace.tsUnknownKeyword();
+    return generatedName ? t.tsTypeReference(t.identifier(generatedName)) : t.tsUnknownKeyword();
   }
   // Helper function used to generate TS types for union type nodes.
   generateUnionTsType(typeNode) {
     if (typeNode.of.length === 0)
-      return t__namespace.tsNeverKeyword();
+      return t.tsNeverKeyword();
     if (typeNode.of.length === 1)
       return this.getTypeNodeType(typeNode.of[0]);
     const typeNodes = typeNode.of.map((node) => this.getTypeNodeType(node));
-    return t__namespace.tsUnionType(typeNodes);
+    return t.tsUnionType(typeNodes);
   }
   // Helper function used to generate TS types for document type nodes.
   generateDocumentType(document) {
     const props = Object.entries(document.attributes).map(
       ([key, node]) => this.generateObjectProperty(key, node)
     );
-    return t__namespace.tsTypeLiteral(props);
+    return t.tsTypeLiteral(props);
   }
 }
 function uppercaseFirstLetter(input) {
@@ -764,13 +759,15 @@ function uppercaseFirstLetter(input) {
 function sanitizeIdentifier(input) {
   return `${input.replace(/^\d/, "_").replace(/[^$\w]+(.)/g, (_, char) => char.toUpperCase())}`;
 }
-exports.TypeGenerator = TypeGenerator;
-exports.configDefinition = configDefinition;
-exports.findQueriesInPath = findQueriesInPath;
-exports.findQueriesInSource = findQueriesInSource;
-exports.getResolver = getResolver;
-exports.readConfig = readConfig;
-exports.readSchema = readSchema;
-exports.registerBabel = registerBabel;
-exports.safeParseQuery = safeParseQuery;
+export {
+  TypeGenerator,
+  configDefinition,
+  findQueriesInPath,
+  findQueriesInSource,
+  getResolver,
+  readConfig,
+  readSchema,
+  registerBabel,
+  safeParseQuery
+};
 //# sourceMappingURL=index.js.map