houdini 0.19.4 → 1.0.0-next.0

package/build/cmd-cjs/index.js

@@ -11507,7 +11507,7 @@ var require_graphql = __commonJS({
     Object.defineProperty(exports, "__esModule", {
       value: true
     });
-    exports.graphql = graphql30;
+    exports.graphql = graphql29;
     exports.graphqlSync = graphqlSync;
     var _isPromise = _interopRequireDefault(require_isPromise());
     var _parser = require_parser();
@@ -11517,7 +11517,7 @@ var require_graphql = __commonJS({
     function _interopRequireDefault(obj) {
       return obj && obj.__esModule ? obj : { default: obj };
     }
-    function graphql30(argsOrSchema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) {
+    function graphql29(argsOrSchema, source, rootValue, contextValue, variableValues, operationName, fieldResolver, typeResolver) {
       var _arguments = arguments;
       return new Promise(function(resolve2) {
         return resolve2(
@@ -16462,9 +16462,9 @@ var require_graphql2 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/minimatch@5.1.1/node_modules/minimatch/lib/path.js
+// ../../node_modules/.pnpm/minimatch@5.1.2/node_modules/minimatch/lib/path.js
 var require_path = __commonJS({
-  "../../node_modules/.pnpm/minimatch@5.1.1/node_modules/minimatch/lib/path.js"(exports, module2) {
+  "../../node_modules/.pnpm/minimatch@5.1.2/node_modules/minimatch/lib/path.js"(exports, module2) {
     var isWindows = typeof process === "object" && process && process.platform === "win32";
     module2.exports = isWindows ? { sep: "\\" } : { sep: "/" };
   }
@@ -16681,9 +16681,9 @@ var require_brace_expansion = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/minimatch@5.1.1/node_modules/minimatch/minimatch.js
+// ../../node_modules/.pnpm/minimatch@5.1.2/node_modules/minimatch/minimatch.js
 var require_minimatch = __commonJS({
-  "../../node_modules/.pnpm/minimatch@5.1.1/node_modules/minimatch/minimatch.js"(exports, module2) {
+  "../../node_modules/.pnpm/minimatch@5.1.2/node_modules/minimatch/minimatch.js"(exports, module2) {
     var minimatch2 = module2.exports = (p, pattern, options = {}) => {
       assertValidPattern(pattern);
       if (!options.nocomment && pattern.charAt(0) === "#") {
@@ -16769,7 +16769,9 @@ var require_minimatch = __commonJS({
       return list;
     };
     var globUnescape = (s2) => s2.replace(/\\(.)/g, "$1");
+    var charUnescape = (s2) => s2.replace(/\\([^-\]])/g, "$1");
     var regExpEscape = (s2) => s2.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    var braExpEscape = (s2) => s2.replace(/[[\]\\]/g, "\\$&");
     var Minimatch = class {
       constructor(pattern, options) {
         assertValidPattern(pattern);
@@ -16961,6 +16963,10 @@ var require_minimatch = __commonJS({
               return false;
             }
             case "\\":
+              if (inClass && pattern.charAt(i2 + 1) === "-") {
+                re += c;
+                continue;
+              }
               clearStateChar();
               escaping = true;
               continue;
@@ -17043,17 +17049,13 @@ var require_minimatch = __commonJS({
               }
               cs = pattern.substring(classStart + 1, i2);
               try {
-                RegExp("[" + cs + "]");
+                RegExp("[" + braExpEscape(charUnescape(cs)) + "]");
+                re += c;
               } catch (er) {
-                sp = this.parse(cs, SUBPARSE);
-                re = re.substring(0, reClassStart) + "\\[" + sp[0] + "\\]";
-                hasMagic = hasMagic || sp[1];
-                inClass = false;
-                continue;
+                re = re.substring(0, reClassStart) + "(?:$.)";
               }
               hasMagic = true;
               inClass = false;
-              re += c;
               continue;
             default:
               clearStateChar();
@@ -29229,9 +29231,9 @@ var init_multipart_parser = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/@babel+parser@7.20.5/node_modules/@babel/parser/lib/index.js
+// ../../node_modules/.pnpm/@babel+parser@7.20.7/node_modules/@babel/parser/lib/index.js
 var require_lib3 = __commonJS({
-  "../../node_modules/.pnpm/@babel+parser@7.20.5/node_modules/@babel/parser/lib/index.js"(exports) {
+  "../../node_modules/.pnpm/@babel+parser@7.20.7/node_modules/@babel/parser/lib/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     function _objectWithoutPropertiesLoose(source, excluded) {
@@ -29347,9 +29349,9 @@ var require_lib3 = __commonJS({
       AwaitExpressionFormalParameter: "'await' is not allowed in async function parameters.",
       AwaitNotInAsyncContext: "'await' is only allowed within async functions and at the top levels of modules.",
       AwaitNotInAsyncFunction: "'await' is only allowed within async functions.",
-      BadGetterArity: "A 'get' accesor must not have any formal parameters.",
-      BadSetterArity: "A 'set' accesor must have exactly one formal parameter.",
-      BadSetterRestParameter: "A 'set' accesor function argument must not be a rest parameter.",
+      BadGetterArity: "A 'get' accessor must not have any formal parameters.",
+      BadSetterArity: "A 'set' accessor must have exactly one formal parameter.",
+      BadSetterRestParameter: "A 'set' accessor function argument must not be a rest parameter.",
       ConstructorClassField: "Classes may not have a field named 'constructor'.",
       ConstructorClassPrivateField: "Classes may not have a private field named '#constructor'.",
       ConstructorIsAccessor: "Class constructor may not be an accessor.",
@@ -32783,7 +32785,7 @@ var require_lib3 = __commonJS({
         }
         this.parser.raise(toParseError, origin);
       }
-      recordArrowParemeterBindingError(error, {
+      recordArrowParameterBindingError(error, {
         at: node
       }) {
         const {
@@ -36542,6 +36544,7 @@ var require_lib3 = __commonJS({
       }) => `Property '${propertyName}' cannot have an initializer because it is marked abstract.`,
       AccesorCannotDeclareThisParameter: "'get' and 'set' accessors cannot declare 'this' parameters.",
       AccesorCannotHaveTypeParameters: "An accessor cannot have type parameters.",
+      AccessorCannotBeOptional: "An 'accessor' property cannot be declared optional.",
       ClassMethodHasDeclare: "Class methods cannot have the 'declare' modifier.",
       ClassMethodHasReadonly: "Class methods cannot have the 'readonly' modifier.",
       ConstInitiailizerMustBeStringOrNumericLiteralOrLiteralEnumReference: "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.",
@@ -38504,8 +38507,12 @@ var require_lib3 = __commonJS({
           node.typeParameters = typeParameters;
       }
       parseClassPropertyAnnotation(node) {
-        if (!node.optional && this.eat(35)) {
-          node.definite = true;
+        if (!node.optional) {
+          if (this.eat(35)) {
+            node.definite = true;
+          } else if (this.eat(17)) {
+            node.optional = true;
+          }
         }
         const type = this.tsTryParseTypeAnnotation();
         if (type)
@@ -38544,6 +38551,15 @@ var require_lib3 = __commonJS({
         this.parseClassPropertyAnnotation(node);
         return super.parseClassPrivateProperty(node);
       }
+      parseClassAccessorProperty(node) {
+        this.parseClassPropertyAnnotation(node);
+        if (node.optional) {
+          this.raise(TSErrors.AccessorCannotBeOptional, {
+            at: node
+          });
+        }
+        return super.parseClassAccessorProperty(node);
+      }
       pushClassMethod(classBody, method, isGenerator, isAsync, isConstructor, allowsDirectSuper) {
         const typeParameters = this.tsTryParseTypeParameters();
         if (typeParameters && isConstructor) {
@@ -38754,7 +38770,7 @@ var require_lib3 = __commonJS({
           case "TSNonNullExpression":
           case "TSTypeAssertion":
             if (isLHS) {
-              this.expressionScope.recordArrowParemeterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
+              this.expressionScope.recordArrowParameterBindingError(TSErrors.UnexpectedTypeCastInParameter, {
                 at: node
               });
             } else {
@@ -39461,7 +39477,7 @@ var require_lib3 = __commonJS({
           parenthesized = unwrapParenthesizedExpression(node);
           if (isLHS) {
             if (parenthesized.type === "Identifier") {
-              this.expressionScope.recordArrowParemeterBindingError(Errors.InvalidParenthesizedAssignment, {
+              this.expressionScope.recordArrowParameterBindingError(Errors.InvalidParenthesizedAssignment, {
                 at: node
               });
             } else if (parenthesized.type !== "MemberExpression") {
@@ -72247,6 +72263,60 @@ function formatErrors(e2, afterError) {
     afterError?.(e2);
   }
 }
+function unwrapType(config2, type, wrappers = []) {
+  if (type.kind === "NonNullType") {
+    return unwrapType(config2, type.type, [TypeWrapper.NonNull, ...wrappers]);
+  }
+  if (type instanceof graphql3.GraphQLNonNull) {
+    return unwrapType(config2, type.ofType, [TypeWrapper.NonNull, ...wrappers]);
+  }
+  if (wrappers[0] !== TypeWrapper.NonNull) {
+    wrappers.unshift(TypeWrapper.Nullable);
+  }
+  if (type.kind === "ListType") {
+    return unwrapType(config2, type.type, [TypeWrapper.List, ...wrappers]);
+  }
+  if (type instanceof graphql3.GraphQLList) {
+    return unwrapType(config2, type.ofType, [TypeWrapper.List, ...wrappers]);
+  }
+  const namedType = config2.schema.getType(type.name.value || type.name);
+  if (!namedType) {
+    throw new Error("Could not unwrap type: " + JSON.stringify(type));
+  }
+  return { type: namedType, wrappers };
+}
+function wrapType({
+  type,
+  wrappers
+}) {
+  const head = wrappers[0];
+  const tail = wrappers.slice(1);
+  let kind = graphql3.Kind.NAMED_TYPE;
+  if (head === TypeWrapper.List) {
+    kind = graphql3.Kind.LIST_TYPE;
+  } else if (head === TypeWrapper.NonNull) {
+    kind = graphql3.Kind.NON_NULL_TYPE;
+  }
+  if (kind === "NamedType") {
+    return {
+      kind,
+      name: {
+        kind: graphql3.Kind.NAME,
+        value: type.name
+      }
+    };
+  }
+  return {
+    kind,
+    type: wrapType({ type, wrappers: tail })
+  };
+}
+var TypeWrapper = /* @__PURE__ */ ((TypeWrapper2) => {
+  TypeWrapper2["Nullable"] = "Nullable";
+  TypeWrapper2["List"] = "List";
+  TypeWrapper2["NonNull"] = "NonNull";
+  return TypeWrapper2;
+})(TypeWrapper || {});
 
 // src/lib/parse.ts
 var import_parser = __toESM(require_lib3(), 1);
@@ -72495,10 +72565,10 @@ async function find_graphql(config2, parsedScript, walker) {
 }
 
 // src/codegen/index.ts
-var graphql29 = __toESM(require_graphql2(), 1);
+var graphql28 = __toESM(require_graphql2(), 1);
 
 // src/codegen/generators/artifacts/index.ts
-var graphql14 = __toESM(require_graphql2(), 1);
+var graphql13 = __toESM(require_graphql2(), 1);
 var recast5 = __toESM(require_main2(), 1);
 
 // src/codegen/utils/commonjs.ts
@@ -72674,63 +72744,6 @@ var FieldCollection = class {
   }
 };
 
-// src/codegen/utils/graphql.ts
-var graphql5 = __toESM(require_graphql2(), 1);
-function unwrapType(config2, type, wrappers = []) {
-  if (type.kind === "NonNullType") {
-    return unwrapType(config2, type.type, [TypeWrapper.NonNull, ...wrappers]);
-  }
-  if (type instanceof graphql5.GraphQLNonNull) {
-    return unwrapType(config2, type.ofType, [TypeWrapper.NonNull, ...wrappers]);
-  }
-  if (wrappers[0] !== TypeWrapper.NonNull) {
-    wrappers.unshift(TypeWrapper.Nullable);
-  }
-  if (type.kind === "ListType") {
-    return unwrapType(config2, type.type, [TypeWrapper.List, ...wrappers]);
-  }
-  if (type instanceof graphql5.GraphQLList) {
-    return unwrapType(config2, type.ofType, [TypeWrapper.List, ...wrappers]);
-  }
-  const namedType = config2.schema.getType(type.name.value || type.name);
-  if (!namedType) {
-    throw new Error("Could not unwrap type: " + JSON.stringify(type));
-  }
-  return { type: namedType, wrappers };
-}
-function wrapType({
-  type,
-  wrappers
-}) {
-  const head = wrappers[0];
-  const tail = wrappers.slice(1);
-  let kind = graphql5.Kind.NAMED_TYPE;
-  if (head === TypeWrapper.List) {
-    kind = graphql5.Kind.LIST_TYPE;
-  } else if (head === TypeWrapper.NonNull) {
-    kind = graphql5.Kind.NON_NULL_TYPE;
-  }
-  if (kind === "NamedType") {
-    return {
-      kind,
-      name: {
-        kind: graphql5.Kind.NAME,
-        value: type.name
-      }
-    };
-  }
-  return {
-    kind,
-    type: wrapType({ type, wrappers: tail })
-  };
-}
-var TypeWrapper = /* @__PURE__ */ ((TypeWrapper2) => {
-  TypeWrapper2["Nullable"] = "Nullable";
-  TypeWrapper2["List"] = "List";
-  TypeWrapper2["NonNull"] = "NonNull";
-  return TypeWrapper2;
-})(TypeWrapper || {});
-
 // src/codegen/utils/moduleExport.ts
 var recast2 = __toESM(require_main2(), 1);
 var AST2 = recast2.types.builders;
@@ -72817,7 +72830,7 @@ ${exportDefaultFrom(`./${doc.name}`, doc.name)}`,
 }
 
 // src/codegen/generators/artifacts/inputs.ts
-var graphql6 = __toESM(require_graphql2(), 1);
+var graphql5 = __toESM(require_graphql2(), 1);
 var recast3 = __toESM(require_main2(), 1);
 var AST3 = recast3.types.builders;
 function inputObject(config2, inputs) {
@@ -72842,10 +72855,10 @@ function walkInputs(config2, visitedTypes, inputObj, rootType) {
   if (visitedTypes.has(type.name)) {
     return;
   }
-  if (graphql6.isEnumType(type) || graphql6.isScalarType(type)) {
+  if (graphql5.isEnumType(type) || graphql5.isScalarType(type)) {
     return;
   }
-  if (graphql6.isUnionType(type)) {
+  if (graphql5.isUnionType(type)) {
     return;
   }
   visitedTypes.add(type.name);
@@ -72863,10 +72876,10 @@ function walkInputs(config2, visitedTypes, inputObj, rootType) {
 }
 
 // src/codegen/generators/artifacts/operations.ts
-var graphql8 = __toESM(require_graphql2(), 1);
+var graphql7 = __toESM(require_graphql2(), 1);
 
 // src/codegen/generators/artifacts/utils.ts
-var graphql7 = __toESM(require_graphql2(), 1);
+var graphql6 = __toESM(require_graphql2(), 1);
 var recast4 = __toESM(require_main2(), 1);
 var AST4 = recast4.types.builders;
 function serializeValue(value) {
@@ -72918,19 +72931,19 @@ function deepMerge(filepath, ...targets) {
 function convertValue(config2, val) {
   let value;
   let kind;
-  if (val.kind === graphql7.Kind.INT) {
+  if (val.kind === graphql6.Kind.INT) {
     value = parseInt(val.value, 10);
     kind = "Int";
-  } else if (val.kind === graphql7.Kind.FLOAT) {
+  } else if (val.kind === graphql6.Kind.FLOAT) {
     value = parseFloat(val.value);
     kind = "Float";
-  } else if (val.kind === graphql7.Kind.BOOLEAN) {
+  } else if (val.kind === graphql6.Kind.BOOLEAN) {
     value = val.value;
     kind = "Boolean";
-  } else if (val.kind === graphql7.Kind.VARIABLE) {
+  } else if (val.kind === graphql6.Kind.VARIABLE) {
     value = val.name.value;
     kind = "Variable";
-  } else if (val.kind === graphql7.Kind.STRING) {
+  } else if (val.kind === graphql6.Kind.STRING) {
     value = val.value;
     kind = "String";
   }
@@ -72943,7 +72956,7 @@ function operationsByPath(config2, filepath, definition, filterTypes) {
     return {};
   }
   const pathOperations = {};
-  graphql8.visit(definition, {
+  graphql7.visit(definition, {
     FragmentSpread(node, _, __, ___, ancestors) {
       if (!config2.isListFragment(node.name.value)) {
         return;
@@ -73102,7 +73115,7 @@ function ancestorKey(ancestors) {
 }
 
 // src/codegen/generators/artifacts/selection.ts
-var graphql13 = __toESM(require_graphql2(), 1);
+var graphql12 = __toESM(require_graphql2(), 1);
 
 // ../../node_modules/.pnpm/@kitql+helper@0.5.0/node_modules/@kitql/helper/index.mjs
 var config = {
@@ -73142,16 +73155,16 @@ function logYellow(str) {
 }
 
 // src/codegen/transforms/list.ts
-var graphql11 = __toESM(require_graphql2(), 1);
+var graphql10 = __toESM(require_graphql2(), 1);
 
 // src/codegen/utils/objectIdentificationSelection.ts
-var graphql9 = __toESM(require_graphql2(), 1);
+var graphql8 = __toESM(require_graphql2(), 1);
 var objectIdentificationSelection = (config2, type) => {
   return config2.keyFieldsForType(type.name).map((key) => {
     return {
-      kind: graphql9.Kind.FIELD,
+      kind: graphql8.Kind.FIELD,
       name: {
-        kind: graphql9.Kind.NAME,
+        kind: graphql8.Kind.NAME,
         value: key
       }
     };
@@ -73159,7 +73172,7 @@ var objectIdentificationSelection = (config2, type) => {
 };
 
 // src/codegen/transforms/paginate.ts
-var graphql10 = __toESM(require_graphql2(), 1);
+var graphql9 = __toESM(require_graphql2(), 1);
 async function paginate(config2, documents) {
   const newDocs = [];
   for (const doc of documents) {
@@ -73192,7 +73205,7 @@ async function paginate(config2, documents) {
     };
     let cursorType = "String";
     let paginationPath = [];
-    doc.document = graphql10.visit(doc.document, {
+    doc.document = graphql9.visit(doc.document, {
       Field(node, _, __, ___, ancestors) {
         const paginateDirective = node.directives?.find(
           (directive) => directive.name.value === config2.paginateDirective
@@ -73219,7 +73232,7 @@ async function paginate(config2, documents) {
         flags.offset.enabled = offsetPagination;
         flags.limit.enabled = offsetPagination;
         paginationPath = ancestors.filter(
-          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql10.Kind.FIELD
+          (ancestor) => !Array.isArray(ancestor) && ancestor.kind === graphql9.Kind.FIELD
         ).concat(node).map((field) => field.alias?.value || field.name.value);
         return {
           ...node,
@@ -73240,7 +73253,7 @@ async function paginate(config2, documents) {
         refetchUpdate = "prepend" /* prepend */;
       }
       let fragment = "";
-      doc.document = graphql10.visit(doc.document, {
+      doc.document = graphql9.visit(doc.document, {
         OperationDefinition(node) {
           if (node.operation !== "query") {
             throw new HoudiniError({
@@ -73294,9 +73307,9 @@ async function paginate(config2, documents) {
               directives: [
                 ...node.directives || [],
                 {
-                  kind: graphql10.Kind.DIRECTIVE,
+                  kind: graphql9.Kind.DIRECTIVE,
                   name: {
-                    kind: graphql10.Kind.NAME,
+                    kind: graphql9.Kind.NAME,
                     value: config2.argumentsDirective
                   }
                 }
@@ -73359,16 +73372,16 @@ async function paginate(config2, documents) {
       const paginationArgs = Object.entries(flags).filter(([_, { enabled }]) => enabled).map(([key, value]) => ({ name: key, ...value }));
       const fragmentSpreadSelection = [
         {
-          kind: graphql10.Kind.FRAGMENT_SPREAD,
+          kind: graphql9.Kind.FRAGMENT_SPREAD,
           name: {
-            kind: graphql10.Kind.NAME,
+            kind: graphql9.Kind.NAME,
             value: fragmentName
           },
           directives: [
             {
-              kind: graphql10.Kind.DIRECTIVE,
+              kind: graphql9.Kind.DIRECTIVE,
               name: {
-                kind: graphql10.Kind.NAME,
+                kind: graphql9.Kind.NAME,
                 value: config2.withDirective
               },
               ["arguments"]: paginationArgs.map(
@@ -73396,29 +73409,29 @@ async function paginate(config2, documents) {
       });
       const typeConfig = config2.typeConfig?.[fragment];
       const queryDoc = {
-        kind: graphql10.Kind.DOCUMENT,
+        kind: graphql9.Kind.DOCUMENT,
         definitions: [
           {
-            kind: graphql10.Kind.OPERATION_DEFINITION,
+            kind: graphql9.Kind.OPERATION_DEFINITION,
             name: {
-              kind: graphql10.Kind.NAME,
+              kind: graphql9.Kind.NAME,
               value: refetchQueryName
             },
             operation: "query",
             variableDefinitions: paginationArgs.map(
               (arg) => ({
-                kind: graphql10.Kind.VARIABLE_DEFINITION,
+                kind: graphql9.Kind.VARIABLE_DEFINITION,
                 type: {
-                  kind: graphql10.Kind.NAMED_TYPE,
+                  kind: graphql9.Kind.NAMED_TYPE,
                   name: {
-                    kind: graphql10.Kind.NAME,
+                    kind: graphql9.Kind.NAME,
                     value: arg.type
                   }
                 },
                 variable: {
-                  kind: graphql10.Kind.VARIABLE,
+                  kind: graphql9.Kind.VARIABLE,
                   name: {
-                    kind: graphql10.Kind.NAME,
+                    kind: graphql9.Kind.NAME,
                     value: arg.name
                   }
                 },
@@ -73430,12 +73443,12 @@ async function paginate(config2, documents) {
             ).concat(
               !nodeQuery ? [] : keys.map(
                 (key) => ({
-                  kind: graphql10.Kind.VARIABLE_DEFINITION,
+                  kind: graphql9.Kind.VARIABLE_DEFINITION,
                   type: key.type,
                   variable: {
-                    kind: graphql10.Kind.VARIABLE,
+                    kind: graphql9.Kind.VARIABLE,
                     name: {
-                      kind: graphql10.Kind.NAME,
+                      kind: graphql9.Kind.NAME,
                       value: key.name
                     }
                   }
@@ -73443,42 +73456,42 @@ async function paginate(config2, documents) {
               )
             ),
             selectionSet: {
-              kind: graphql10.Kind.SELECTION_SET,
+              kind: graphql9.Kind.SELECTION_SET,
               selections: !nodeQuery ? fragmentSpreadSelection : [
                 {
-                  kind: graphql10.Kind.FIELD,
+                  kind: graphql9.Kind.FIELD,
                   name: {
-                    kind: graphql10.Kind.NAME,
+                    kind: graphql9.Kind.NAME,
                     value: typeConfig?.resolve?.queryField || "node"
                   },
                   ["arguments"]: keys.map((key) => ({
-                    kind: graphql10.Kind.ARGUMENT,
+                    kind: graphql9.Kind.ARGUMENT,
                     name: {
-                      kind: graphql10.Kind.NAME,
+                      kind: graphql9.Kind.NAME,
                       value: key.name
                     },
                     value: {
-                      kind: graphql10.Kind.VARIABLE,
+                      kind: graphql9.Kind.VARIABLE,
                       name: {
-                        kind: graphql10.Kind.NAME,
+                        kind: graphql9.Kind.NAME,
                         value: key.name
                       }
                     }
                   })),
                   selectionSet: {
-                    kind: graphql10.Kind.SELECTION_SET,
+                    kind: graphql9.Kind.SELECTION_SET,
                     selections: [
                       {
-                        kind: graphql10.Kind.FIELD,
+                        kind: graphql9.Kind.FIELD,
                         name: {
-                          kind: graphql10.Kind.NAME,
+                          kind: graphql9.Kind.NAME,
                           value: "__typename"
                         }
                       },
                       ...(typeConfig?.keys || ["id"]).map((key) => ({
-                        kind: graphql10.Kind.FIELD,
+                        kind: graphql9.Kind.FIELD,
                         name: {
-                          kind: graphql10.Kind.NAME,
+                          kind: graphql9.Kind.NAME,
                           value: key
                         }
                       })),
@@ -73540,15 +73553,15 @@ function replaceArgumentsWithVariables(args, flags) {
 }
 function variableAsArgument(name2, variable) {
   return {
-    kind: graphql10.Kind.ARGUMENT,
+    kind: graphql9.Kind.ARGUMENT,
     name: {
-      kind: graphql10.Kind.NAME,
+      kind: graphql9.Kind.NAME,
       value: name2
     },
     value: {
-      kind: graphql10.Kind.VARIABLE,
+      kind: graphql9.Kind.VARIABLE,
       name: {
-        kind: graphql10.Kind.NAME,
+        kind: graphql9.Kind.NAME,
         value: variable ?? name2
       }
     }
@@ -73556,18 +73569,18 @@ function variableAsArgument(name2, variable) {
 }
 function staticVariableDefinition(name2, type, defaultValue, variableName) {
   return {
-    kind: graphql10.Kind.VARIABLE_DEFINITION,
+    kind: graphql9.Kind.VARIABLE_DEFINITION,
     type: {
-      kind: graphql10.Kind.NAMED_TYPE,
+      kind: graphql9.Kind.NAMED_TYPE,
       name: {
-        kind: graphql10.Kind.NAME,
+        kind: graphql9.Kind.NAME,
         value: type
       }
     },
     variable: {
-      kind: graphql10.Kind.VARIABLE,
+      kind: graphql9.Kind.VARIABLE,
       name: {
-        kind: graphql10.Kind.NAME,
+        kind: graphql9.Kind.NAME,
         value: variableName ?? name2
       }
     },
@@ -73579,9 +73592,9 @@ function staticVariableDefinition(name2, type, defaultValue, variableName) {
 }
 function argumentNode(name2, value) {
   return {
-    kind: graphql10.Kind.ARGUMENT,
+    kind: graphql9.Kind.ARGUMENT,
     name: {
-      kind: graphql10.Kind.NAME,
+      kind: graphql9.Kind.NAME,
       value: name2
     },
     value: objectNode(value)
@@ -73589,16 +73602,16 @@ function argumentNode(name2, value) {
 }
 function objectNode([type, defaultValue]) {
   const node = {
-    kind: graphql10.Kind.OBJECT,
+    kind: graphql9.Kind.OBJECT,
     fields: [
       {
-        kind: graphql10.Kind.OBJECT_FIELD,
+        kind: graphql9.Kind.OBJECT_FIELD,
         name: {
-          kind: graphql10.Kind.NAME,
+          kind: graphql9.Kind.NAME,
           value: "type"
         },
         value: {
-          kind: graphql10.Kind.STRING,
+          kind: graphql9.Kind.STRING,
           value: type
         }
       }
@@ -73606,8 +73619,8 @@ function objectNode([type, defaultValue]) {
   };
   if (defaultValue) {
     node.fields.push({
-      kind: graphql10.Kind.OBJECT_FIELD,
-      name: { kind: graphql10.Kind.NAME, value: "default" },
+      kind: graphql9.Kind.OBJECT_FIELD,
+      name: { kind: graphql9.Kind.NAME, value: "default" },
       value: {
         kind: typeof defaultValue === "number" ? "IntValue" : "StringValue",
         value: defaultValue.toString()
@@ -73618,34 +73631,34 @@ function objectNode([type, defaultValue]) {
 }
 var pageInfoSelection = [
   {
-    kind: graphql10.Kind.FIELD,
+    kind: graphql9.Kind.FIELD,
     name: {
-      kind: graphql10.Kind.NAME,
+      kind: graphql9.Kind.NAME,
       value: "edges"
     },
     selectionSet: {
-      kind: graphql10.Kind.SELECTION_SET,
+      kind: graphql9.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql10.Kind.FIELD,
+          kind: graphql9.Kind.FIELD,
           name: {
-            kind: graphql10.Kind.NAME,
+            kind: graphql9.Kind.NAME,
             value: "cursor"
           }
         },
         {
-          kind: graphql10.Kind.FIELD,
+          kind: graphql9.Kind.FIELD,
           name: {
-            kind: graphql10.Kind.NAME,
+            kind: graphql9.Kind.NAME,
             value: "node"
           },
           selectionSet: {
-            kind: graphql10.Kind.SELECTION_SET,
+            kind: graphql9.Kind.SELECTION_SET,
             selections: [
               {
-                kind: graphql10.Kind.FIELD,
+                kind: graphql9.Kind.FIELD,
                 name: {
-                  kind: graphql10.Kind.NAME,
+                  kind: graphql9.Kind.NAME,
                   value: "__typename"
                 }
               }
@@ -73656,39 +73669,39 @@ var pageInfoSelection = [
     }
   },
   {
-    kind: graphql10.Kind.FIELD,
+    kind: graphql9.Kind.FIELD,
     name: {
-      kind: graphql10.Kind.NAME,
+      kind: graphql9.Kind.NAME,
       value: "pageInfo"
     },
     selectionSet: {
-      kind: graphql10.Kind.SELECTION_SET,
+      kind: graphql9.Kind.SELECTION_SET,
       selections: [
         {
-          kind: graphql10.Kind.FIELD,
+          kind: graphql9.Kind.FIELD,
           name: {
-            kind: graphql10.Kind.NAME,
+            kind: graphql9.Kind.NAME,
             value: "hasPreviousPage"
           }
         },
         {
-          kind: graphql10.Kind.FIELD,
+          kind: graphql9.Kind.FIELD,
           name: {
-            kind: graphql10.Kind.NAME,
+            kind: graphql9.Kind.NAME,
             value: "hasNextPage"
           }
         },
         {
-          kind: graphql10.Kind.FIELD,
+          kind: graphql9.Kind.FIELD,
           name: {
-            kind: graphql10.Kind.NAME,
+            kind: graphql9.Kind.NAME,
             value: "startCursor"
           }
         },
         {
-          kind: graphql10.Kind.FIELD,
+          kind: graphql9.Kind.FIELD,
           name: {
-            kind: graphql10.Kind.NAME,
+            kind: graphql9.Kind.NAME,
             value: "endCursor"
           }
         }
@@ -73702,15 +73715,15 @@ async function addListFragments(config2, documents) {
   const lists = {};
   const errors = [];
   for (const doc of documents) {
-    doc.document = graphql11.visit(doc.document, {
+    doc.document = graphql10.visit(doc.document, {
       Directive(node, key, parent, path2, ancestors) {
         if ([config2.listDirective, config2.paginateDirective].includes(node.name.value)) {
           const nameArg = node.arguments?.find((arg) => arg.name.value === "name");
           let error = {
-            ...new graphql11.GraphQLError(
+            ...new graphql10.GraphQLError(
               "",
               node,
-              new graphql11.Source(""),
+              new graphql10.Source(""),
               node.loc ? [node.loc.start, node.loc.end] : null,
               path2
             ),
@@ -73762,7 +73775,7 @@ async function addListFragments(config2, documents) {
                 {
                   kind: "Argument",
                   name: {
-                    kind: graphql11.Kind.NAME,
+                    kind: graphql10.Kind.NAME,
                     value: "connection"
                   },
                   value: {
@@ -73812,7 +73825,7 @@ async function addListFragments(config2, documents) {
   const validDeletes = [
     ...new Set(
       Object.values(lists).map(({ type }) => {
-        if (!(type instanceof graphql11.GraphQLObjectType)) {
+        if (!(type instanceof graphql10.GraphQLObjectType)) {
           return "";
         }
         if (config2.keyFieldsForType(type.name).length !== 1) {
@@ -73826,7 +73839,7 @@ async function addListFragments(config2, documents) {
     return;
   }
   const generatedDoc = {
-    kind: graphql11.Kind.DOCUMENT,
+    kind: graphql10.Kind.DOCUMENT,
     definitions: Object.entries(lists).flatMap(
       ([name2, { selection: selection2, type }]) => {
         const schemaType = config2.schema.getType(type.name);
@@ -73834,7 +73847,7 @@ async function addListFragments(config2, documents) {
           throw new HoudiniError({ message: "Lists must have a selection" });
         }
         const fragmentSelection = {
-          kind: graphql11.Kind.SELECTION_SET,
+          kind: graphql10.Kind.SELECTION_SET,
           selections: [...selection2.selections]
         };
         if (schemaType && fragmentSelection && !fragmentSelection?.selections.find(
@@ -73849,14 +73862,14 @@ async function addListFragments(config2, documents) {
           {
             name: {
               value: config2.listInsertFragment(name2),
-              kind: graphql11.Kind.NAME
+              kind: graphql10.Kind.NAME
             },
-            kind: graphql11.Kind.FRAGMENT_DEFINITION,
+            kind: graphql10.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql11.Kind.NAMED_TYPE,
+              kind: graphql10.Kind.NAMED_TYPE,
               name: {
-                kind: graphql11.Kind.NAME,
+                kind: graphql10.Kind.NAME,
                 value: type.name
               }
             }
@@ -73864,32 +73877,32 @@ async function addListFragments(config2, documents) {
           {
             name: {
               value: config2.listToggleFragment(name2),
-              kind: graphql11.Kind.NAME
+              kind: graphql10.Kind.NAME
             },
-            kind: graphql11.Kind.FRAGMENT_DEFINITION,
+            kind: graphql10.Kind.FRAGMENT_DEFINITION,
             selectionSet: fragmentSelection,
             typeCondition: {
-              kind: graphql11.Kind.NAMED_TYPE,
+              kind: graphql10.Kind.NAMED_TYPE,
               name: {
-                kind: graphql11.Kind.NAME,
+                kind: graphql10.Kind.NAME,
                 value: type.name
               }
             }
           },
           {
-            kind: graphql11.Kind.FRAGMENT_DEFINITION,
+            kind: graphql10.Kind.FRAGMENT_DEFINITION,
             name: {
               value: config2.listRemoveFragment(name2),
-              kind: graphql11.Kind.NAME
+              kind: graphql10.Kind.NAME
             },
             selectionSet: {
-              kind: graphql11.Kind.SELECTION_SET,
+              kind: graphql10.Kind.SELECTION_SET,
               selections: [...objectIdentificationSelection(config2, type)]
             },
             typeCondition: {
-              kind: graphql11.Kind.NAMED_TYPE,
+              kind: graphql10.Kind.NAMED_TYPE,
               name: {
-                kind: graphql11.Kind.NAME,
+                kind: graphql10.Kind.NAME,
                 value: type.name
               }
             }
@@ -73898,14 +73911,14 @@ async function addListFragments(config2, documents) {
       }
     ).concat(
       ...validDeletes.map((typeName) => ({
-        kind: graphql11.Kind.DIRECTIVE_DEFINITION,
+        kind: graphql10.Kind.DIRECTIVE_DEFINITION,
         name: {
-          kind: graphql11.Kind.NAME,
+          kind: graphql10.Kind.NAME,
           value: config2.listDeleteDirective(typeName)
         },
         locations: [
           {
-            kind: graphql11.Kind.NAME,
+            kind: graphql10.Kind.NAME,
             value: "FIELD"
           }
         ],
@@ -73913,8 +73926,8 @@ async function addListFragments(config2, documents) {
       }))
     )
   };
-  config2.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql11.print).join("\n\n");
-  config2.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql11.print).join("\n\n");
+  config2.newSchema += "\n" + generatedDoc.definitions.filter((c) => c.kind !== "FragmentDefinition").map(graphql10.print).join("\n\n");
+  config2.newDocuments += "\n" + generatedDoc.definitions.filter((c) => c.kind === "FragmentDefinition").map(graphql10.print).join("\n\n");
   documents.push({
     name: "generated::lists",
     kind: "HoudiniFragment" /* Fragment */,
@@ -73999,11 +74012,11 @@ var nodeNotDefinedMessage = (config2) => `Looks like you are trying to use the $
 For more information, visit this link: ${siteURL}/guides/pagination`;
 
 // src/codegen/generators/artifacts/fieldKey.ts
-var graphql12 = __toESM(require_graphql2(), 1);
+var graphql11 = __toESM(require_graphql2(), 1);
 function fieldKey(config2, field) {
   const attributeName = field.alias?.value || field.name.value;
-  const printed = graphql12.print(field);
-  const secondParse = graphql12.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
+  const printed = graphql11.print(field);
+  const secondParse = graphql11.parse(`{${printed}}`).definitions[0].selectionSet.selections[0];
   const paginated = !!field.directives?.find(
     (directive) => directive.name.value === config2.paginateDirective
   );
@@ -74098,8 +74111,8 @@ function selection({
         const typeConditionName = field.typeCondition.name.value;
         const typeCondition = config2.schema.getType(typeConditionName);
         const possibleTypes = [];
-        if (!graphql13.isAbstractType(typeCondition)) {
-        } else if (graphql13.isAbstractType(parentType)) {
+        if (!graphql12.isAbstractType(typeCondition)) {
+        } else if (graphql12.isAbstractType(parentType)) {
           const possibleParentTypes = config2.schema.getPossibleTypes(parentType).map((type) => type.name);
           for (const possible of config2.schema.getPossibleTypes(typeCondition)) {
             if (possibleParentTypes.includes(possible.name)) {
@@ -74147,7 +74160,7 @@ function selection({
       } else {
         let typeRef = type.getFields()[field.name.value].type;
         fieldType = getRootType(typeRef);
-        nullable = !graphql13.isNonNullType(typeRef);
+        nullable = !graphql12.isNonNullType(typeRef);
       }
       const typeName = fieldType.toString();
       const pathSoFar = path2.concat(attributeName);
@@ -74212,7 +74225,7 @@ function selection({
           {}
         );
       }
-      if (graphql13.isInterfaceType(fieldType) || graphql13.isUnionType(fieldType)) {
+      if (graphql12.isInterfaceType(fieldType) || graphql12.isUnionType(fieldType)) {
         fieldObj.abstract = true;
       }
       object.fields = {
@@ -74269,7 +74282,7 @@ function artifactGenerator(stats) {
   return async function(config2, docs) {
     const filterTypes = {};
     for (const doc of docs) {
-      graphql14.visit(doc.document, {
+      graphql13.visit(doc.document, {
         Directive(node, _, __, ___, ancestors) {
           if (node.name.value !== config2.listDirective) {
             return;
@@ -74328,7 +74341,7 @@ function artifactGenerator(stats) {
             return;
           }
           const usedVariableNames = /* @__PURE__ */ new Set();
-          let documentWithoutInternalDirectives = graphql14.visit(document, {
+          let documentWithoutInternalDirectives = graphql13.visit(document, {
             Directive(node) {
               if (config2.isInternalDirective(node)) {
                 return null;
@@ -74341,7 +74354,7 @@ function artifactGenerator(stats) {
               }
             }
           });
-          let documentWithoutExtraVariables = graphql14.visit(
+          let documentWithoutExtraVariables = graphql13.visit(
             documentWithoutInternalDirectives,
             {
               VariableDefinition(variableDefinitionNode) {
@@ -74352,13 +74365,13 @@ function artifactGenerator(stats) {
               }
             }
           );
-          let rawString = graphql14.print(documentWithoutExtraVariables);
+          let rawString = graphql13.print(documentWithoutExtraVariables);
           let docKind = doc.kind;
           const operations = document.definitions.filter(
-            ({ kind }) => kind === graphql14.Kind.OPERATION_DEFINITION
+            ({ kind }) => kind === graphql13.Kind.OPERATION_DEFINITION
           );
           const fragments = document.definitions.filter(
-            ({ kind }) => kind === graphql14.Kind.FRAGMENT_DEFINITION
+            ({ kind }) => kind === graphql13.Kind.FRAGMENT_DEFINITION
           );
           let rootType = "";
           let selectionSet;
@@ -74600,15 +74613,15 @@ async function generatePluginRuntime(config2, plugin) {
 var recast12 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/addReferencedInputTypes.ts
-var graphql17 = __toESM(require_graphql2(), 1);
+var graphql16 = __toESM(require_graphql2(), 1);
 var recast9 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/typeReference.ts
-var graphql16 = __toESM(require_graphql2(), 1);
+var graphql15 = __toESM(require_graphql2(), 1);
 var recast8 = __toESM(require_main2(), 1);
 
 // src/codegen/generators/typescript/types.ts
-var graphql15 = __toESM(require_graphql2(), 1);
+var graphql14 = __toESM(require_graphql2(), 1);
 var recast7 = __toESM(require_main2(), 1);
 var AST7 = recast7.types.builders;
 function readonlyProperty(prop, enable = true) {
@@ -74642,7 +74655,7 @@ function scalarPropertyValue(config2, missingScalars, target) {
       return AST7.tsStringKeyword();
     }
     default: {
-      if (graphql15.isNonNullType(target) && "ofType" in target) {
+      if (graphql14.isNonNullType(target) && "ofType" in target) {
         return scalarPropertyValue(
           config2,
           missingScalars,
@@ -74663,7 +74676,7 @@ var AST8 = recast8.types.builders;
 function tsTypeReference(config2, missingScalars, definition) {
   const { type, wrappers } = unwrapType(config2, definition.type);
   let result;
-  if (graphql16.isScalarType(type)) {
+  if (graphql15.isScalarType(type)) {
     result = scalarPropertyValue(config2, missingScalars, type);
   } else {
     result = AST8.tsTypeReference(AST8.identifier(type.name));
@@ -74684,17 +74697,17 @@ function tsTypeReference(config2, missingScalars, definition) {
 var AST9 = recast9.types.builders;
 function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingScalars, rootType) {
   const { type } = unwrapType(config2, rootType);
-  if (graphql17.isScalarType(type)) {
+  if (graphql16.isScalarType(type)) {
     return;
   }
   if (visitedTypes.has(type.name)) {
     return;
   }
-  if (graphql17.isUnionType(type)) {
+  if (graphql16.isUnionType(type)) {
     throw new HoudiniError({ filepath, message: "Input Unions are not supported yet. Sorry!" });
   }
   visitedTypes.add(type.name);
-  if (graphql17.isEnumType(type)) {
+  if (graphql16.isEnumType(type)) {
     ensureImports({
       config: config2,
       body,
@@ -74711,7 +74724,7 @@ function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingS
       AST9.tsPropertySignature(
         AST9.identifier(field.name),
         AST9.tsTypeAnnotation(tsTypeReference(config2, missingScalars, field)),
-        graphql17.isNullableType(field.type)
+        graphql16.isNullableType(field.type)
       )
     );
   }
@@ -74719,7 +74732,7 @@ function addReferencedInputTypes(config2, filepath, body, visitedTypes, missingS
 }
 
 // src/codegen/generators/typescript/imperativeCache.ts
-var graphql18 = __toESM(require_graphql2(), 1);
+var graphql17 = __toESM(require_graphql2(), 1);
 var recast10 = __toESM(require_main2(), 1);
 var AST10 = recast10.types.builders;
 async function imperativeCacheTypef(config2, docs) {
@@ -74755,7 +74768,7 @@ function typeDefinitions(config2, body) {
   const operationTypes = [config2.schema.getMutationType(), config2.schema.getSubscriptionType()].filter(Boolean).map((type) => type?.name);
   const visitedTypes = /* @__PURE__ */ new Set();
   const types16 = Object.values(config2.schema.getTypeMap()).filter(
-    (type) => !graphql18.isAbstractType(type) && !graphql18.isScalarType(type) && !graphql18.isEnumType(type) && !graphql18.isInputObjectType(type) && !type.name.startsWith("__") && !operationTypes.includes(type.name)
+    (type) => !graphql17.isAbstractType(type) && !graphql17.isScalarType(type) && !graphql17.isEnumType(type) && !graphql17.isInputObjectType(type) && !type.name.startsWith("__") && !operationTypes.includes(type.name)
   );
   return AST10.tsTypeLiteral(
     types16.map((type) => {
@@ -74765,7 +74778,7 @@ function typeDefinitions(config2, body) {
       }
       let idFields = AST10.tsNeverKeyword();
       const keys = keyFieldsForType(config2.configFile, type.name);
-      if (graphql18.isObjectType(type) && keys.length > 0 && keys.every((key) => type.getFields()[key])) {
+      if (graphql17.isObjectType(type) && keys.length > 0 && keys.every((key) => type.getFields()[key])) {
         idFields = AST10.tsTypeLiteral(
           keys.map((key) => {
             const fieldType = type.getFields()[key];
@@ -74782,21 +74795,21 @@ function typeDefinitions(config2, body) {
         idFields = AST10.tsTypeLiteral([]);
       }
       let fields = AST10.tsTypeLiteral([]);
-      if (graphql18.isObjectType(type)) {
+      if (graphql17.isObjectType(type)) {
         fields = AST10.tsTypeLiteral(
           Object.entries(type.getFields()).map(
             ([key, fieldType]) => {
               const unwrapped = unwrapType(config2, fieldType.type);
               let typeOptions = AST10.tsUnionType([]);
-              if (graphql18.isScalarType(unwrapped.type)) {
+              if (graphql17.isScalarType(unwrapped.type)) {
                 typeOptions.types.push(
                   scalarPropertyValue(config2, /* @__PURE__ */ new Set(), unwrapped.type)
                 );
-              } else if (graphql18.isEnumType(unwrapped.type)) {
+              } else if (graphql17.isEnumType(unwrapped.type)) {
                 typeOptions.types.push(
                   AST10.tsTypeReference(AST10.identifier(unwrapped.type.name))
                 );
-              } else if (!graphql18.isAbstractType(unwrapped.type)) {
+              } else if (!graphql17.isAbstractType(unwrapped.type)) {
                 typeOptions.types.push(record(unwrapped.type.name));
               } else {
                 typeOptions.types.push(
@@ -74882,7 +74895,7 @@ function listDefinitions(config2, docs) {
   const lists = [];
   const visitedLists = /* @__PURE__ */ new Set();
   for (const doc of docs) {
-    graphql18.visit(doc.document, {
+    graphql17.visit(doc.document, {
       Directive(node, key, parent, path2, ancestors) {
         if (![config2.listDirective, config2.paginateDirective].includes(node.name.value)) {
           return;
@@ -74902,7 +74915,7 @@ function listDefinitions(config2, docs) {
         const targetFieldDefinition = parentType.getFields()[targetField.name.value];
         const { type: listType } = unwrapType(config2, targetFieldDefinition.type);
         const possibleTypes = [];
-        if (graphql18.isAbstractType(listType)) {
+        if (graphql17.isAbstractType(listType)) {
           possibleTypes.push(
             ...config2.schema.getPossibleTypes(listType).map((possible) => possible.name)
           );
@@ -74966,7 +74979,7 @@ function record(name2) {
 }
 
 // src/codegen/generators/typescript/inlineType.ts
-var graphql19 = __toESM(require_graphql2(), 1);
+var graphql18 = __toESM(require_graphql2(), 1);
 var recast11 = __toESM(require_main2(), 1);
 var AST11 = recast11.types.builders;
 var fragmentKey = "$fragments";
@@ -74985,9 +74998,9 @@ function inlineType({
 }) {
   const { type, wrappers } = unwrapType(config2, rootType);
   let result;
-  if (graphql19.isScalarType(type)) {
+  if (graphql18.isScalarType(type)) {
     result = scalarPropertyValue(config2, missingScalars, type);
-  } else if (graphql19.isEnumType(type)) {
+  } else if (graphql18.isEnumType(type)) {
     if (!visitedTypes.has(type.name)) {
       ensureImports({
         config: config2,
@@ -75005,11 +75018,11 @@ function inlineType({
     for (const selection2 of selections) {
       if (selection2.kind === "InlineFragment" && selection2.typeCondition) {
         const fragmentType = config2.schema.getType(selection2.typeCondition.name.value);
-        if (!graphql19.isInterfaceType(type) && !graphql19.isUnionType(type)) {
+        if (!graphql18.isInterfaceType(type) && !graphql18.isUnionType(type)) {
           selectedFields.push(...selection2.selectionSet.selections);
           continue;
         }
-        if (!graphql19.isInterfaceType(fragmentType) && !graphql19.isUnionType(fragmentType)) {
+        if (!graphql18.isInterfaceType(fragmentType) && !graphql18.isUnionType(fragmentType)) {
           if (!inlineFragments[fragmentType.name]) {
             inlineFragments[fragmentType.name] = [];
           }
@@ -75129,7 +75142,7 @@ function inlineType({
           }
         }
       }
-      if (objectType.type === "TSTypeLiteral" && !graphql19.isInterfaceType(fragmentRootType) && !graphql19.isUnionType(fragmentRootType)) {
+      if (objectType.type === "TSTypeLiteral" && !graphql18.isInterfaceType(fragmentRootType) && !graphql18.isUnionType(fragmentRootType)) {
         const existingTypenameIndex = objectType.members.findIndex(
           (member) => member.type === "TSPropertySignature" && member.key.type === "Identifier" && member.key.name === "__typename"
         );
@@ -75196,7 +75209,7 @@ function selectionTypeInfo(schema, filepath, rootType, selection2) {
       },
       type: schema.getType("String")
     };
-  } else if (graphql19.isNonNullType(rootType) && "getFields" in rootType.ofType) {
+  } else if (graphql18.isNonNullType(rootType) && "getFields" in rootType.ofType) {
     fields = rootType.ofType.getFields();
   } else {
     fields = rootType.getFields();
@@ -75208,7 +75221,7 @@ function selectionTypeInfo(schema, filepath, rootType, selection2) {
       message: `Could not find type information for field ${rootType.toString()}.${selectionName} ${field}`
     });
   }
-  const fieldType = graphql19.getNamedType(field.type);
+  const fieldType = graphql18.getNamedType(field.type);
   if (!fieldType) {
     throw new HoudiniError({
       filepath,
@@ -75529,7 +75542,7 @@ async function generateFragmentTypeDefs(config2, filepath, body, selections, def
 }
 
 // src/codegen/generators/persistedQueries/index.ts
-var graphql20 = __toESM(require_graphql2(), 1);
+var graphql19 = __toESM(require_graphql2(), 1);
 async function persistOutputGenerator(config2, docs) {
   if (typeof config2.persistedQueryPath !== "string" || config2.persistedQueryPath.length === 0)
     return;
@@ -75541,8 +75554,8 @@ async function persistOutputGenerator(config2, docs) {
     if (!generateArtifact) {
       return acc;
     }
-    let rawString = graphql20.print(
-      graphql20.visit(document, {
+    let rawString = graphql19.print(
+      graphql19.visit(document, {
         Directive(node) {
           if (config2.isInternalDirective(node)) {
             return null;
@@ -75551,7 +75564,7 @@ async function persistOutputGenerator(config2, docs) {
       })
     );
     const operations = document.definitions.filter(
-      ({ kind }) => kind === graphql20.Kind.OPERATION_DEFINITION
+      ({ kind }) => kind === graphql19.Kind.OPERATION_DEFINITION
     );
     if (operations.length > 0 && operations[0].kind === "OperationDefinition") {
       acc[hashDocument(rawString)] = rawString;
@@ -75564,11 +75577,11 @@ async function persistOutputGenerator(config2, docs) {
 }
 
 // src/codegen/generators/definitions/enums.ts
-var graphql21 = __toESM(require_graphql2(), 1);
+var graphql20 = __toESM(require_graphql2(), 1);
 var recast13 = __toESM(require_main2(), 1);
 var AST13 = recast13.types.builders;
 async function definitionsGenerator(config2) {
-  const enums = graphql21.parse(graphql21.printSchema(config2.schema)).definitions.filter(
+  const enums = graphql20.parse(graphql20.printSchema(config2.schema)).definitions.filter(
     (definition) => definition.kind === "EnumTypeDefinition"
   ).filter((def) => !config2.isInternalEnum(def));
   const runtimeDefinitions = recast13.print(
@@ -75741,7 +75754,7 @@ function flattenFragments(filepath, operation, fragments) {
 }
 
 // src/codegen/transforms/schema.ts
-var graphql23 = __toESM(require_graphql2(), 1);
+var graphql22 = __toESM(require_graphql2(), 1);
 async function graphqlExtensions(config2, documents) {
   const internalSchema = `
 enum CachePolicy {
@@ -75819,19 +75832,19 @@ directive @${config2.maskEnableDirective} on FRAGMENT_SPREAD
 """
 directive @${config2.maskDisableDirective} on FRAGMENT_SPREAD
 `;
-  let currentSchema = graphql23.printSchema(config2.schema);
+  let currentSchema = graphql22.printSchema(config2.schema);
   if (!currentSchema.includes(`directive @${config2.listDirective}`)) {
     currentSchema += internalSchema;
   }
   config2.newSchema += internalSchema;
-  config2.schema = graphql23.buildSchema(currentSchema);
+  config2.schema = graphql22.buildSchema(currentSchema);
 }
 
 // src/codegen/transforms/typename.ts
-var graphql24 = __toESM(require_graphql2(), 1);
+var graphql23 = __toESM(require_graphql2(), 1);
 async function addTypename(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql24.visit(doc.document, {
+    doc.document = graphql23.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -75843,7 +75856,7 @@ async function addTypename(config2, documents) {
         );
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
-        if (graphql24.isInterfaceType(fieldType) || graphql24.isUnionType(fieldType)) {
+        if (graphql23.isInterfaceType(fieldType) || graphql23.isUnionType(fieldType)) {
           return {
             ...node,
             selectionSet: {
@@ -75851,9 +75864,9 @@ async function addTypename(config2, documents) {
               selections: [
                 ...node.selectionSet.selections,
                 {
-                  kind: graphql24.Kind.FIELD,
+                  kind: graphql23.Kind.FIELD,
                   name: {
-                    kind: graphql24.Kind.NAME,
+                    kind: graphql23.Kind.NAME,
                     value: "__typename"
                   }
                 }
@@ -75867,10 +75880,10 @@ async function addTypename(config2, documents) {
 }
 
 // src/codegen/transforms/addID.ts
-var graphql25 = __toESM(require_graphql2(), 1);
+var graphql24 = __toESM(require_graphql2(), 1);
 async function addID(config2, documents) {
   for (const doc of documents) {
-    doc.document = graphql25.visit(doc.document, {
+    doc.document = graphql24.visit(doc.document, {
       Field(node, key, parent, path2, ancestors) {
         if (!node.selectionSet) {
           return;
@@ -75883,7 +75896,7 @@ async function addID(config2, documents) {
         const field = type.getFields()[node.name.value];
         const fieldType = unwrapType(config2, field.type).type;
         if (node.selectionSet?.selections.length > 0) {
-          if (!graphql25.isObjectType(fieldType) && !graphql25.isInterfaceType(fieldType)) {
+          if (!graphql24.isObjectType(fieldType) && !graphql24.isInterfaceType(fieldType)) {
             return;
           }
           const keyFields = config2.keyFieldsForType(fieldType.name);
@@ -75898,9 +75911,9 @@ async function addID(config2, documents) {
               continue;
             }
             selections.push({
-              kind: graphql25.Kind.FIELD,
+              kind: graphql24.Kind.FIELD,
               name: {
-                kind: graphql25.Kind.NAME,
+                kind: graphql24.Kind.NAME,
                 value: keyField
               }
             });
@@ -75919,8 +75932,8 @@ async function addID(config2, documents) {
 }
 
 // src/codegen/transforms/fragmentVariables.ts
-var graphql26 = __toESM(require_graphql2(), 1);
-var GraphqlKinds2 = graphql26.Kind;
+var graphql25 = __toESM(require_graphql2(), 1);
+var GraphqlKinds2 = graphql25.Kind;
 async function fragmentVariables(config2, documents) {
   const fragments = collectFragments(config2, documents);
   const generatedFragments = {};
@@ -75943,7 +75956,7 @@ async function fragmentVariables(config2, documents) {
     });
   }
   const doc = {
-    kind: graphql26.Kind.DOCUMENT,
+    kind: graphql25.Kind.DOCUMENT,
     definitions: Object.values(generatedFragments)
   };
   documents.push({
@@ -75979,7 +75992,7 @@ function inlineFragmentArgs({
     filepath,
     document
   ).reduce((acc, arg) => ({ ...acc, [arg.name]: arg }), {});
-  const result = graphql26.visit(document, {
+  const result = graphql25.visit(document, {
     FragmentSpread(node) {
       const { definition } = fragmentDefinitions[node.name.value];
       let { args, hash } = collectWithArguments(config2, filepath, node, scope);
@@ -76067,7 +76080,7 @@ function inlineFragmentArgs({
   });
   if (newName) {
     result.name = {
-      kind: graphql26.Kind.NAME,
+      kind: graphql25.Kind.NAME,
       value: newName
     };
   }
@@ -76179,7 +76192,7 @@ function operationScope(operation) {
 }
 
 // src/codegen/validators/typeCheck.ts
-var graphql27 = __toESM(require_graphql2(), 1);
+var graphql26 = __toESM(require_graphql2(), 1);
 async function typeCheck(config2, docs) {
   const errors = [];
   const freeLists = [];
@@ -76187,11 +76200,11 @@ async function typeCheck(config2, docs) {
   const listTypes = [];
   const fragments = {};
   for (const { document: parsed, filename } of docs) {
-    graphql27.visit(parsed, {
-      [graphql27.Kind.FRAGMENT_DEFINITION](definition) {
+    graphql26.visit(parsed, {
+      [graphql26.Kind.FRAGMENT_DEFINITION](definition) {
         fragments[definition.name.value] = definition;
       },
-      [graphql27.Kind.DIRECTIVE](directive, _, parent, __, ancestors) {
+      [graphql26.Kind.DIRECTIVE](directive, _, parent, __, ancestors) {
         if (![config2.listDirective, config2.paginateDirective].includes(directive.name.value)) {
           return;
         }
@@ -76237,14 +76250,14 @@ async function typeCheck(config2, docs) {
             );
             return;
           }
-          if (graphql27.isListType(rootType) || graphql27.isNonNullType(rootType) && graphql27.isListType(rootType.ofType)) {
+          if (graphql26.isListType(rootType) || graphql26.isNonNullType(rootType) && graphql26.isListType(rootType.ofType)) {
             needsParent = true;
             break;
           }
-          if (graphql27.isNonNullType(rootType) && "ofType" in rootType) {
+          if (graphql26.isNonNullType(rootType) && "ofType" in rootType) {
             rootType = rootType.ofType;
           }
-          if (graphql27.isScalarType(rootType)) {
+          if (graphql26.isScalarType(rootType)) {
             break;
           }
           rootType = rootType?.getFields()[parent2.name.value]?.type;
@@ -76320,9 +76333,9 @@ async function typeCheck(config2, docs) {
           );
         }
         let targetTypes = [type];
-        if (graphql27.isUnionType(type)) {
+        if (graphql26.isUnionType(type)) {
           targetTypes = config2.schema.getPossibleTypes(type);
-        } else if (graphql27.isInterfaceType(type)) {
+        } else if (graphql26.isInterfaceType(type)) {
           try {
             for (const key of config2.keyFieldsForType(type.name)) {
               if (!type.getFields()[key]) {
@@ -76360,13 +76373,13 @@ async function typeCheck(config2, docs) {
   if (errors.length > 0) {
     throw errors;
   }
-  const rules = (filepath) => [...graphql27.specifiedRules].filter(
+  const rules = (filepath) => [...graphql26.specifiedRules].filter(
     (rule) => ![
-      graphql27.NoUnusedFragmentsRule,
-      graphql27.KnownFragmentNamesRule,
-      graphql27.ExecutableDefinitionsRule,
-      graphql27.KnownDirectivesRule,
-      graphql27.KnownArgumentNamesRule
+      graphql26.NoUnusedFragmentsRule,
+      graphql26.KnownFragmentNamesRule,
+      graphql26.ExecutableDefinitionsRule,
+      graphql26.KnownDirectivesRule,
+      graphql26.KnownArgumentNamesRule
     ].includes(rule)
   ).concat(
     validateLists({
@@ -76385,7 +76398,7 @@ async function typeCheck(config2, docs) {
     noUnusedFragmentArguments(config2)
   );
   for (const { filename, document: parsed } of docs) {
-    for (const error of graphql27.validate(config2.schema, parsed, rules(filename))) {
+    for (const error of graphql26.validate(config2.schema, parsed, rules(filename))) {
       errors.push(
         new HoudiniError({
           filepath: filename,
@@ -76411,7 +76424,7 @@ var validateLists = ({
       if (!config2.isListFragment(node.name.value)) {
         if (!fragments[node.name.value]) {
           ctx.reportError(
-            new graphql27.GraphQLError(
+            new graphql26.GraphQLError(
               "Encountered unknown fragment: " + node.name.value
             )
           );
@@ -76421,7 +76434,7 @@ var validateLists = ({
       const listName = config2.listNameFromFragment(node.name.value);
       if (!lists.includes(listName)) {
         ctx.reportError(
-          new graphql27.GraphQLError(
+          new graphql26.GraphQLError(
             "Encountered fragment referencing unknown list: " + listName
           )
         );
@@ -76446,7 +76459,7 @@ var validateLists = ({
         );
         if (parentArg) {
           ctx.reportError(
-            new graphql27.GraphQLError(
+            new graphql26.GraphQLError(
               `@${config2.deprecatedlistDirectiveParentIDArg} should be defined only in it's own directive now`
             )
           );
@@ -76462,7 +76475,7 @@ var validateLists = ({
         return;
       }
       ctx.reportError(
-        new graphql27.GraphQLError(
+        new graphql26.GraphQLError(
           `For this list fragment, you need to add or @${config2.listParentDirective} or @${config2.listAllListsDirective} directive to specify the behavior`
         )
       );
@@ -76472,7 +76485,7 @@ var validateLists = ({
       const directiveName = node.name.value;
       if (directiveName === "connection") {
         ctx.reportError(
-          new graphql27.GraphQLError(
+          new graphql26.GraphQLError(
             "@connection was renamed to @list. Please change your components. If you were using `cache.connection` in your components, you will need to update that to `cache.list` too."
           )
         );
@@ -76481,7 +76494,7 @@ var validateLists = ({
       if (!config2.isInternalDirective(node)) {
         if (!config2.schema.getDirective(directiveName)) {
           ctx.reportError(
-            new graphql27.GraphQLError(
+            new graphql26.GraphQLError(
               "Encountered unknown directive: " + directiveName
             )
           );
@@ -76490,7 +76503,7 @@ var validateLists = ({
       }
       if (config2.isListOperationDirective(directiveName) && !listTypes.includes(config2.listNameFromDirective(directiveName))) {
         ctx.reportError(
-          new graphql27.GraphQLError(
+          new graphql26.GraphQLError(
             "Encountered directive referencing unknown list: " + directiveName
           )
         );
@@ -76501,7 +76514,7 @@ var validateLists = ({
 };
 function knownArguments(config2) {
   return function(ctx) {
-    const nativeValidator = graphql27.KnownArgumentNamesRule(ctx);
+    const nativeValidator = graphql26.KnownArgumentNamesRule(ctx);
     return {
       ...nativeValidator,
       Directive(directiveNode) {
@@ -76534,7 +76547,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         for (const arg of node.arguments || []) {
           if (arg.value.kind !== "ObjectValue") {
             ctx.reportError(
-              new graphql27.GraphQLError("values in @arguments must be an object")
+              new graphql26.GraphQLError("values in @arguments must be an object")
             );
             return;
           }
@@ -76544,13 +76557,13 @@ function validateFragmentArguments(config2, filepath, fragments) {
           );
           if (!typeArg) {
             ctx.reportError(
-              new graphql27.GraphQLError("missing type field for @arguments directive")
+              new graphql26.GraphQLError("missing type field for @arguments directive")
             );
             return;
           }
-          if (typeArg.value.kind !== graphql27.Kind.STRING) {
+          if (typeArg.value.kind !== graphql26.Kind.STRING) {
             ctx.reportError(
-              new graphql27.GraphQLError("type field to @arguments must be a string")
+              new graphql26.GraphQLError("type field to @arguments must be a string")
             );
             return;
           }
@@ -76563,7 +76576,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           );
           if (typeArg.value.value !== defaultValueType) {
             ctx.reportError(
-              new graphql27.GraphQLError(
+              new graphql26.GraphQLError(
                 `Invalid default value provided for ${arg.name.value}. Expected ${typeArg.value.value}, found ${defaultValueType}`
               )
             );
@@ -76581,7 +76594,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
           try {
             args = fragmentArguments(config2, filepath, fragments[fragmentName]);
           } catch (e2) {
-            ctx.reportError(new graphql27.GraphQLError(e2.message));
+            ctx.reportError(new graphql26.GraphQLError(e2.message));
             return;
           }
           fragmentArguments2[fragmentName] = args;
@@ -76604,7 +76617,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         );
         if (missing.length > 0) {
           ctx.reportError(
-            new graphql27.GraphQLError(
+            new graphql26.GraphQLError(
               "The following arguments are missing from this fragment: " + JSON.stringify(missing)
             )
           );
@@ -76615,7 +76628,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
         );
         if (unknown.length > 0) {
           ctx.reportError(
-            new graphql27.GraphQLError(
+            new graphql26.GraphQLError(
               "Encountered unknown arguments: " + JSON.stringify(unknown)
             )
           );
@@ -76627,7 +76640,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
             ]
           );
           for (const [applied, target] of zipped) {
-            if (applied.value.kind === graphql27.Kind.VARIABLE || applied.value.kind === graphql27.Kind.LIST || applied.value.kind === graphql27.Kind.OBJECT) {
+            if (applied.value.kind === graphql26.Kind.VARIABLE || applied.value.kind === graphql26.Kind.LIST || applied.value.kind === graphql26.Kind.OBJECT) {
               continue;
             }
             const appliedType = applied.value.kind.substring(
@@ -76636,7 +76649,7 @@ function validateFragmentArguments(config2, filepath, fragments) {
             );
             if (appliedType !== target) {
               ctx.reportError(
-                new graphql27.GraphQLError(
+                new graphql26.GraphQLError(
                   `Invalid argument type. Expected ${target}, found ${appliedType}`
                 )
               );
@@ -76657,7 +76670,7 @@ function paginateArgs(config2, filepath) {
         }
         if (alreadyPaginated) {
           ctx.reportError(
-            new graphql27.GraphQLError(
+            new graphql26.GraphQLError(
               `@${config2.paginateDirective} can only appear in a document once.`
             )
           );
@@ -76672,7 +76685,7 @@ function paginateArgs(config2, filepath) {
         const hasRequiredArgs = definitionArgs.find((arg) => arg.required);
         if (hasRequiredArgs) {
           ctx.reportError(
-            new graphql27.GraphQLError(
+            new graphql26.GraphQLError(
               "@paginate cannot appear on a document with required args"
             )
           );
@@ -76704,14 +76717,14 @@ function paginateArgs(config2, filepath) {
           const backwards = appliedArgs.has("last");
           if (!forward && !backwards) {
             ctx.reportError(
-              new graphql27.GraphQLError(
+              new graphql26.GraphQLError(
                 "A field with cursor-based pagination must have a first or last argument"
               )
             );
           }
           if (forward && backwards) {
             ctx.reportError(
-              new graphql27.GraphQLError(
+              new graphql26.GraphQLError(
                 `A field with cursor pagination cannot go forwards an backwards simultaneously`
               )
             );
@@ -76725,7 +76738,7 @@ function paginateArgs(config2, filepath) {
           );
           if (!appliedLimitArg) {
             ctx.reportError(
-              new graphql27.GraphQLError(
+              new graphql26.GraphQLError(
                 "A field with offset-based pagination must have a limit argument"
               )
             );
@@ -76741,20 +76754,20 @@ function noUnusedFragmentArguments(config2) {
     const args = /* @__PURE__ */ new Set();
     return {
       enter(node) {
-        if (node.kind === graphql27.Kind.FRAGMENT_DEFINITION) {
+        if (node.kind === graphql26.Kind.FRAGMENT_DEFINITION) {
           const definitionArguments = node.directives?.filter((directive) => directive.name.value === config2.argumentsDirective).flatMap((directive) => directive.arguments);
           for (const arg of definitionArguments?.map((arg2) => arg2?.name.value) || []) {
             args.add(arg);
           }
-        } else if (node.kind === graphql27.Kind.VARIABLE) {
+        } else if (node.kind === graphql26.Kind.VARIABLE) {
           args.delete(node.name.value);
         }
       },
       leave(node) {
-        if (node.kind === graphql27.Kind.FRAGMENT_DEFINITION) {
+        if (node.kind === graphql26.Kind.FRAGMENT_DEFINITION) {
           if (args.size > 0) {
             ctx.reportError(
-              new graphql27.GraphQLError(
+              new graphql26.GraphQLError(
                 "Encountered unused fragment arguments: " + [...args].join(",")
               )
             );
@@ -76790,7 +76803,7 @@ function nodeDirectives(config2, directives) {
         if (definition.kind === "OperationDefinition") {
           if (definition.operation !== "query") {
             ctx.reportError(
-              new graphql27.GraphQLError(
+              new graphql26.GraphQLError(
                 `@${node.name.value} must fall on a fragment or query document`
               )
             );
@@ -76802,7 +76815,7 @@ function nodeDirectives(config2, directives) {
         }
         if (!possibleNodes.includes(definitionType)) {
           ctx.reportError(
-            new graphql27.GraphQLError(paginateOnNonNodeMessage(config2, node.name.value))
+            new graphql26.GraphQLError(paginateOnNonNodeMessage(config2, node.name.value))
           );
         }
       }
@@ -76821,7 +76834,7 @@ function checkMutationOperation(config2) {
         );
         if (append && prepend) {
           ctx.reportError(
-            new graphql27.GraphQLError(
+            new graphql26.GraphQLError(
               `You can't apply both @${config2.listPrependDirective} and @${config2.listAppendDirective} at the same time`
             )
           );
@@ -76835,7 +76848,7 @@ function checkMutationOperation(config2) {
         );
         if (parentId && allLists) {
           ctx.reportError(
-            new graphql27.GraphQLError(
+            new graphql26.GraphQLError(
               `You can't apply both @${config2.listParentDirective} and @${config2.listAllListsDirective} at the same time`
             )
           );
@@ -76857,7 +76870,7 @@ function checkMaskDirective(config2) {
         );
         if (maskEnableDirective && maskDisableDirective) {
           ctx.reportError(
-            new graphql27.GraphQLError(
+            new graphql26.GraphQLError(
               `You can't apply both @${config2.maskEnableDirective} and @${config2.maskDisableDirective} at the same time`
             )
           );
@@ -76873,7 +76886,7 @@ function getAndVerifyNodeInterface(config2) {
   if (!nodeInterface) {
     return null;
   }
-  if (!graphql27.isInterfaceType(nodeInterface)) {
+  if (!graphql26.isInterfaceType(nodeInterface)) {
     displayInvalidNodeFieldMessage(config2.logLevel);
     return null;
   }
@@ -76971,11 +76984,11 @@ async function uniqueDocumentNames(config2, docs) {
 }
 
 // src/codegen/validators/noIDAlias.ts
-var graphql28 = __toESM(require_graphql2(), 1);
+var graphql27 = __toESM(require_graphql2(), 1);
 async function noIDAlias(config2, docs) {
   const errors = [];
   for (const { filename, document } of docs) {
-    graphql28.visit(document, {
+    graphql27.visit(document, {
       Field(node, _, __, ___, ancestors) {
         const fieldType = parentTypeFromAncestors(config2.schema, filename, ancestors).name;
         if (config2.keyFieldsForType(fieldType).includes(node.alias?.value || "")) {
@@ -77173,12 +77186,12 @@ async function processJSFile(config2, contents) {
   return documents;
 }
 async function processGraphQLDocument(config2, filepath, document) {
-  const parsedDoc = graphql29.parse(document);
+  const parsedDoc = graphql28.parse(document);
   const operations = parsedDoc.definitions.filter(
-    ({ kind: kind2 }) => kind2 === graphql29.Kind.OPERATION_DEFINITION
+    ({ kind: kind2 }) => kind2 === graphql28.Kind.OPERATION_DEFINITION
   );
   const fragments = parsedDoc.definitions.filter(
-    ({ kind: kind2 }) => kind2 === graphql29.Kind.FRAGMENT_DEFINITION
+    ({ kind: kind2 }) => kind2 === graphql28.Kind.FRAGMENT_DEFINITION
   );
   if (operations.length > 1) {
     throw new HoudiniError({
@@ -77733,8 +77746,8 @@ async function updatePackageJSON(targetPath) {
   }
   packageJSON.devDependencies = {
     ...packageJSON.devDependencies,
-    houdini: "^0.19.4",
-    "houdini-svelte": "^0.19.4",
+    houdini: "^1.0.0-next.0",
+    "houdini-svelte": "^1.0.0-next.0",
     graphql: "^15.8.0"
   };
   await fs_exports.writeFile(packagePath, JSON.stringify(packageJSON, null, 4));