@zimic/http 0.1.0-canary.7 → 0.1.1-canary.0

package/dist/{chunk-343XY3VF.js → chunk-KDDZRZK6.js}

@@ -15,15 +15,17 @@ var chalk__default = /*#__PURE__*/_interopDefault(chalk);
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// src/utils/data.ts
+// ../zimic-utils/dist/chunk-PAWJFY3S.mjs
+var __defProp2 = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
+
+// ../zimic-utils/dist/chunk-3O5CS47X.mjs
 function isDefined(value) {
-  return value !== undefined && value !== null;
+  return value !== void 0 && value !== null;
 }
 __name(isDefined, "isDefined");
-function isNonEmpty(value) {
-  return isDefined(value) && value !== "";
-}
-__name(isNonEmpty, "isNonEmpty");
+__name2(isDefined, "isDefined");
+var isDefined_default = isDefined;
 function isNeverType(type) {
   return type.kind === ts3__default.default.SyntaxKind.NeverKeyword;
 }
@@ -45,13 +47,13 @@ function createNullType() {
 }
 __name(createNullType, "createNullType");
 function createImportSpecifier(importName) {
-  return ts3__default.default.factory.createImportSpecifier(false, undefined, ts3__default.default.factory.createIdentifier(importName));
+  return ts3__default.default.factory.createImportSpecifier(false, void 0, ts3__default.default.factory.createIdentifier(importName));
 }
 __name(createImportSpecifier, "createImportSpecifier");
 function createImportDeclaration(importSpecifiers, moduleName, options) {
   return ts3__default.default.factory.createImportDeclaration(
-    undefined,
-    ts3__default.default.factory.createImportClause(options.typeOnly, undefined, ts3__default.default.factory.createNamedImports(importSpecifiers)),
+    void 0,
+    ts3__default.default.factory.createImportClause(options.typeOnly, void 0, ts3__default.default.factory.createNamedImports(importSpecifiers)),
     ts3__default.default.factory.createStringLiteral(moduleName)
   );
 }
@@ -59,7 +61,7 @@ __name(createImportDeclaration, "createImportDeclaration");
 var HTTP_METHODS = Object.freeze(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 function logWithPrefix(message, options) {
   const { method } = options;
-  console[method](chalk__default.default.cyan("[zimic]"), message);
+  console[method](chalk__default.default.cyan("[@zimic/http]"), message);
 }
 __name(logWithPrefix, "logWithPrefix");
 function createOperationsIdentifierText(serviceName) {
@@ -71,11 +73,11 @@ function createOperationsIdentifier(serviceName) {
 }
 __name(createOperationsIdentifier, "createOperationsIdentifier");
 function isOperationsDeclaration(node) {
-  return node !== undefined && ts3__default.default.isInterfaceDeclaration(node) && node.name.text === "operations";
+  return node !== void 0 && ts3__default.default.isInterfaceDeclaration(node) && node.name.text === "operations";
 }
 __name(isOperationsDeclaration, "isOperationsDeclaration");
 function isOperation(node) {
-  return ts3__default.default.isPropertySignature(node) && (ts3__default.default.isIdentifier(node.name) || ts3__default.default.isStringLiteral(node.name)) && node.type !== undefined && ts3__default.default.isTypeLiteralNode(node.type);
+  return ts3__default.default.isPropertySignature(node) && (ts3__default.default.isIdentifier(node.name) || ts3__default.default.isStringLiteral(node.name)) && node.type !== void 0 && ts3__default.default.isTypeLiteralNode(node.type);
 }
 __name(isOperation, "isOperation");
 function wrapOperationType(type, context) {
@@ -89,7 +91,7 @@ function wrapOperationType(type, context) {
 __name(wrapOperationType, "wrapOperationType");
 function normalizeOperation(operation, context) {
   if (!isOperation(operation)) {
-    return undefined;
+    return void 0;
   }
   const newType = normalizeTypeLiteralMethodType(operation.type, context);
   return ts3__default.default.factory.updatePropertySignature(
@@ -103,7 +105,7 @@ function normalizeOperation(operation, context) {
 __name(normalizeOperation, "normalizeOperation");
 function normalizeOperations(operations, context) {
   const newIdentifier = createOperationsIdentifier(context.serviceName);
-  const newMembers = operations.members.map((operation) => normalizeOperation(operation, context)).filter(isDefined);
+  const newMembers = operations.members.map((operation) => normalizeOperation(operation, context)).filter(isDefined_default);
   return ts3__default.default.factory.updateInterfaceDeclaration(
     operations,
     operations.modifiers,
@@ -116,7 +118,7 @@ function normalizeOperations(operations, context) {
 __name(normalizeOperations, "normalizeOperations");
 function removeOperationIfUnreferenced(operation, context) {
   if (!isOperation(operation)) {
-    return undefined;
+    return void 0;
   }
   const operationName = operation.name.text;
   const isReferenced = context.referencedTypes.operations.has(operationName);
@@ -124,14 +126,14 @@ function removeOperationIfUnreferenced(operation, context) {
     context.referencedTypes.operations.delete(operationName);
     return operation;
   }
-  return undefined;
+  return void 0;
 }
 __name(removeOperationIfUnreferenced, "removeOperationIfUnreferenced");
 function removeUnreferencedOperations(operations, context) {
-  const newMembers = operations.members.map((operation) => removeOperationIfUnreferenced(operation, context)).filter(isDefined);
+  const newMembers = operations.members.map((operation) => removeOperationIfUnreferenced(operation, context)).filter(isDefined_default);
   context.referencedTypes.operations.clear();
   if (newMembers.length === 0) {
-    return undefined;
+    return void 0;
   }
   return ts3__default.default.factory.updateInterfaceDeclaration(
     operations,
@@ -146,15 +148,15 @@ __name(removeUnreferencedOperations, "removeUnreferencedOperations");
 
 // src/typegen/openapi/transform/methods.ts
 function isMethod(node) {
-  return ts3__default.default.isPropertySignature(node) && ts3__default.default.isIdentifier(node.name) && node.type !== undefined && (ts3__default.default.isTypeLiteralNode(node.type) || ts3__default.default.isIndexedAccessTypeNode(node.type));
+  return ts3__default.default.isPropertySignature(node) && ts3__default.default.isIdentifier(node.name) && node.type !== void 0 && (ts3__default.default.isTypeLiteralNode(node.type) || ts3__default.default.isIndexedAccessTypeNode(node.type));
 }
 __name(isMethod, "isMethod");
 function isMethodMember(node) {
-  return ts3__default.default.isPropertySignature(node) && ts3__default.default.isIdentifier(node.name) && node.type !== undefined && (ts3__default.default.isTypeLiteralNode(node.type) || ts3__default.default.isIndexedAccessTypeNode(node.type) || isNeverType(node.type));
+  return ts3__default.default.isPropertySignature(node) && ts3__default.default.isIdentifier(node.name) && node.type !== void 0 && (ts3__default.default.isTypeLiteralNode(node.type) || ts3__default.default.isIndexedAccessTypeNode(node.type) || isNeverType(node.type));
 }
 __name(isMethodMember, "isMethodMember");
 function isRequestMember(node) {
-  return ts3__default.default.isPropertySignature(node) && ts3__default.default.isIdentifier(node.name) && node.type !== undefined && !isNeverType(node.type);
+  return ts3__default.default.isPropertySignature(node) && ts3__default.default.isIdentifier(node.name) && node.type !== void 0 && !isNeverType(node.type);
 }
 __name(isRequestMember, "isRequestMember");
 function isRequestHeaders(node) {
@@ -162,7 +164,7 @@ function isRequestHeaders(node) {
 }
 __name(isRequestHeaders, "isRequestHeaders");
 function isNormalizedRequestHeaders(node) {
-  return isRequestMember(node) && node.name.text === "headers" && ts3__default.default.isTypeReferenceNode(node.type) && node.type.typeArguments !== undefined && node.type.typeArguments.length === 1 && ts3__default.default.isTypeLiteralNode(node.type.typeArguments[0]);
+  return isRequestMember(node) && node.name.text === "headers" && ts3__default.default.isTypeReferenceNode(node.type) && node.type.typeArguments !== void 0 && node.type.typeArguments.length === 1 && ts3__default.default.isTypeLiteralNode(node.type.typeArguments[0]);
 }
 __name(isNormalizedRequestHeaders, "isNormalizedRequestHeaders");
 function isRequestParameters(node) {
@@ -174,11 +176,11 @@ function isContentPropertySignature(node) {
 }
 __name(isContentPropertySignature, "isContentPropertySignature");
 function isContentMember(node) {
-  return ts3__default.default.isPropertySignature(node) && (ts3__default.default.isIdentifier(node.name) || ts3__default.default.isStringLiteral(node.name)) && node.type !== undefined && !isNeverType(node.type);
+  return ts3__default.default.isPropertySignature(node) && (ts3__default.default.isIdentifier(node.name) || ts3__default.default.isStringLiteral(node.name)) && node.type !== void 0 && !isNeverType(node.type);
 }
 __name(isContentMember, "isContentMember");
 function isResponse(node) {
-  return ts3__default.default.isPropertySignature(node) && (ts3__default.default.isIdentifier(node.name) || ts3__default.default.isStringLiteral(node.name) || ts3__default.default.isNumericLiteral(node.name)) && node.type !== undefined;
+  return ts3__default.default.isPropertySignature(node) && (ts3__default.default.isIdentifier(node.name) || ts3__default.default.isStringLiteral(node.name) || ts3__default.default.isNumericLiteral(node.name)) && node.type !== void 0;
 }
 __name(isResponse, "isResponse");
 function removeRedundantNullUnionIfNecessary(type) {
@@ -228,7 +230,7 @@ function wrapURLEncodedContentType(type, context) {
 __name(wrapURLEncodedContentType, "wrapURLEncodedContentType");
 function normalizeRequestBodyMember(requestBodyMember, context, options) {
   if (!isContentMember(requestBodyMember)) {
-    return undefined;
+    return void 0;
   }
   const newIdentifier = ts3__default.default.factory.createIdentifier("body");
   const contentType = requestBodyMember.name.text;
@@ -265,12 +267,12 @@ function normalizeHeaders(headers, context) {
       return false;
     }
     if (ts3__default.default.isPropertySignature(header)) {
-      return header.type !== undefined && !isUnknownType(header.type);
+      return header.type !== void 0 && !isUnknownType(header.type);
     }
     return true;
   });
   if (newHeaderMembers.length === 0) {
-    return undefined;
+    return void 0;
   }
   const newHeaders = ts3__default.default.factory.updateTypeLiteralNode(headers, ts3__default.default.factory.createNodeArray(newHeaderMembers));
   return wrapHeadersType(newHeaders, context);
@@ -278,11 +280,11 @@ function normalizeHeaders(headers, context) {
 __name(normalizeHeaders, "normalizeHeaders");
 function normalizeRequestHeaders(requestHeader, context) {
   if (!isRequestHeaders(requestHeader)) {
-    return undefined;
+    return void 0;
   }
   const newType = normalizeHeaders(requestHeader.type, context);
   if (!newType) {
-    return undefined;
+    return void 0;
   }
   return ts3__default.default.factory.updatePropertySignature(
     requestHeader,
@@ -299,7 +301,7 @@ function createHeaderForUnionByContentType(existingHeader, contentTypeName, cont
   const contentTypeValue = ts3__default.default.factory.createLiteralTypeNode(ts3__default.default.factory.createStringLiteral(contentTypeName));
   const newHeaderType = wrapHeadersType(
     ts3__default.default.factory.createTypeLiteralNode([
-      ts3__default.default.factory.createPropertySignature(undefined, contentTypeIdentifier, undefined, contentTypeValue),
+      ts3__default.default.factory.createPropertySignature(void 0, contentTypeIdentifier, void 0, contentTypeValue),
       ...existingHeaderMembers
     ]),
     context
@@ -307,7 +309,7 @@ function createHeaderForUnionByContentType(existingHeader, contentTypeName, cont
   return ts3__default.default.factory.createPropertySignature(
     existingHeader?.modifiers,
     ts3__default.default.factory.createIdentifier("headers"),
-    undefined,
+    void 0,
     newHeaderType
   );
 }
@@ -320,16 +322,15 @@ function normalizeContentType(contentType, context, options) {
   if (!ts3__default.default.isTypeLiteralNode(contentType)) {
     return contentType;
   }
-  const newHeader = contentType.members.map((member) => normalizeRequestHeaders(member, context)).find(isDefined);
+  const newHeader = contentType.members.map((member) => normalizeRequestHeaders(member, context)).find(isDefined_default);
   const newBodyMembers = contentType.members.flatMap((body) => {
     if (isContentPropertySignature(body)) {
-      return body.type.members.map((member) => normalizeRequestBodyMember(member, context, { questionToken: bodyQuestionToken })).filter(isDefined);
+      return body.type.members.map((member) => normalizeRequestBodyMember(member, context, { questionToken: bodyQuestionToken })).filter(isDefined_default);
     }
     return [];
   });
-  if (newBodyMembers.length <= 1) {
-    const newBodyMemberPropertySignatures = newBodyMembers.map((bodyMember) => bodyMember.propertySignature);
-    const newMembers = [newHeader, ...newBodyMemberPropertySignatures].filter(isDefined);
+  if (newBodyMembers.length === 0) {
+    const newMembers = [newHeader].filter(isDefined_default);
     return ts3__default.default.factory.updateTypeLiteralNode(contentType, ts3__default.default.factory.createNodeArray(newMembers));
   } else {
     const bodyMemberUnionTypes = newBodyMembers.map((bodyMember) => {
@@ -349,7 +350,7 @@ function normalizeRequest(request, context) {
     const referencedComponentName = request.type.indexType.literal.text;
     context.pendingActions.components.requests.toMarkBodyAsOptional.add(referencedComponentName);
   }
-  return ts3__default.default.factory.updatePropertySignature(request, request.modifiers, newIdentifier, undefined, newType);
+  return ts3__default.default.factory.updatePropertySignature(request, request.modifiers, newIdentifier, void 0, newType);
 }
 __name(normalizeRequest, "normalizeRequest");
 function wrapResponseType(type, context) {
@@ -381,7 +382,7 @@ var NON_NUMERIC_RESPONSE_STATUS_TO_MAPPED_TYPE = {
 function normalizeResponse(response, context, options = {}) {
   const { isComponent: isComponent2 = false } = options;
   if (!isResponse(response)) {
-    return undefined;
+    return void 0;
   }
   const newType = normalizeResponseType(response.type, context, {
     isComponent: isComponent2,
@@ -407,7 +408,7 @@ function normalizeResponse(response, context, options = {}) {
         `Warning: Response has a non-standard status code: ${chalk__default.default.yellow(response.name.text)}. Consider replacing it with a number (e.g. '200'), a pattern ('1xx', '2xx', '3xx', '4xx', or '5xx'), or 'default'.`,
         { method: "warn" }
       );
-      return undefined;
+      return void 0;
     }
     context.typeImports.http.add("HttpStatusCode");
     const newIdentifier = ts3__default.default.factory.createIdentifier(`[StatusCode in ${mappedType}]`);
@@ -430,11 +431,11 @@ function normalizeResponse(response, context, options = {}) {
 __name(normalizeResponse, "normalizeResponse");
 function normalizeResponses(responses, context) {
   if (isNeverType(responses.type) || !ts3__default.default.isTypeLiteralNode(responses.type)) {
-    return undefined;
+    return void 0;
   }
   const newIdentifier = ts3__default.default.factory.createIdentifier("response");
-  const newQuestionToken = undefined;
-  const newMembers = responses.type.members.map((response) => normalizeResponse(response, context), context).filter(isDefined);
+  const newQuestionToken = void 0;
+  const newMembers = responses.type.members.map((response) => normalizeResponse(response, context), context).filter(isDefined_default);
   const sortedNewMembers = Array.from(newMembers).sort((response, otherResponse) => {
     return response.statusCode.value.localeCompare(otherResponse.statusCode.value);
   });
@@ -486,12 +487,12 @@ function normalizeMethodMember(methodMember, context) {
     }
     return methodMember;
   }
-  return undefined;
+  return void 0;
 }
 __name(normalizeMethodMember, "normalizeMethodMember");
 function normalizeRequestQueryWithParameters(requestMember, context) {
   const newIdentifier = ts3__default.default.factory.createIdentifier("searchParams");
-  const newQuestionToken = undefined;
+  const newQuestionToken = void 0;
   const newType = renameComponentReferences(requestMember.type, context);
   context.typeImports.http.add("HttpSearchParamsSerialized");
   const serializedWrapper = ts3__default.default.factory.createIdentifier("HttpSearchParamsSerialized");
@@ -507,7 +508,7 @@ function normalizeRequestQueryWithParameters(requestMember, context) {
 __name(normalizeRequestQueryWithParameters, "normalizeRequestQueryWithParameters");
 function normalizeRequestHeadersWithParameters(requestMember, context) {
   const newIdentifier = ts3__default.default.factory.createIdentifier("headers");
-  const newQuestionToken = undefined;
+  const newQuestionToken = void 0;
   const newType = renameComponentReferences(requestMember.type, context);
   context.typeImports.http.add("HttpHeadersSerialized");
   const serializedWrapper = ts3__default.default.factory.createIdentifier("HttpHeadersSerialized");
@@ -523,7 +524,7 @@ function normalizeRequestHeadersWithParameters(requestMember, context) {
 __name(normalizeRequestHeadersWithParameters, "normalizeRequestHeadersWithParameters");
 function normalizeRequestMemberWithParameters(requestMember, context) {
   if (!isRequestMember(requestMember) || requestMember.name.text === "path") {
-    return undefined;
+    return void 0;
   }
   if (requestMember.name.text === "query") {
     return normalizeRequestQueryWithParameters(requestMember, context);
@@ -560,18 +561,18 @@ function mergeRequestHeadersMembers(members) {
     if (!member || !isNormalizedRequestHeaders(member)) {
       return member;
     }
-    if (firstHeadersIndex === undefined || !mergedHeaders) {
+    if (firstHeadersIndex === void 0 || !mergedHeaders) {
       firstHeadersIndex = index;
       mergedHeaders = member;
       return member;
     }
     mergedHeaders = mergeRequestHeadersMember(mergedHeaders, member);
-    return undefined;
+    return void 0;
   });
-  if (firstHeadersIndex !== undefined) {
+  if (firstHeadersIndex !== void 0) {
     mergedHeadersMembers[firstHeadersIndex] = mergedHeaders;
   }
-  return mergedHeadersMembers.filter(isDefined);
+  return mergedHeadersMembers.filter(isDefined_default);
 }
 __name(mergeRequestHeadersMembers, "mergeRequestHeadersMembers");
 function mergeRequestAndParameterTypes(requestType, methodMembers, context) {
@@ -584,48 +585,48 @@ function mergeRequestAndParameterTypes(requestType, methodMembers, context) {
     })
   );
   if (newMembers.length === 0) {
-    return undefined;
+    return void 0;
   }
   return ts3__default.default.factory.createTypeLiteralNode(newMembers);
 }
 __name(mergeRequestAndParameterTypes, "mergeRequestAndParameterTypes");
 function normalizeRequestTypeWithParameters(requestType, methodMembers, context) {
   if (ts3__default.default.isUnionTypeNode(requestType)) {
-    const newTypes = requestType.types.map((type) => normalizeRequestTypeWithParameters(type, methodMembers, context)).filter(isDefined);
+    const newTypes = requestType.types.map((type) => normalizeRequestTypeWithParameters(type, methodMembers, context)).filter(isDefined_default);
     return ts3__default.default.factory.updateUnionTypeNode(requestType, ts3__default.default.factory.createNodeArray(newTypes));
   }
   if (ts3__default.default.isIndexedAccessTypeNode(requestType)) {
     const newType = normalizeRequestTypeWithParameters(ts3__default.default.factory.createTypeLiteralNode([]), methodMembers, context);
-    return ts3__default.default.factory.createIntersectionTypeNode([requestType, newType].filter(isDefined));
+    return ts3__default.default.factory.createIntersectionTypeNode([requestType, newType].filter(isDefined_default));
   }
   return mergeRequestAndParameterTypes(requestType, methodMembers, context);
 }
 __name(normalizeRequestTypeWithParameters, "normalizeRequestTypeWithParameters");
 function normalizeMethodMemberWithParameters(methodMember, methodMembers, context) {
   if (!ts3__default.default.isIdentifier(methodMember.name) || !methodMember.type) {
-    return undefined;
+    return void 0;
   }
   if (methodMember.name.text === "request") {
     const newType = normalizeRequestTypeWithParameters(methodMember.type, methodMembers, context);
     if (!newType) {
-      return undefined;
+      return void 0;
     }
     return ts3__default.default.factory.updatePropertySignature(
       methodMember,
       methodMember.modifiers,
       methodMember.name,
-      undefined,
+      void 0,
       newType
     );
   }
   if (methodMember.name.text === "response") {
     return methodMember;
   }
-  return undefined;
+  return void 0;
 }
 __name(normalizeMethodMemberWithParameters, "normalizeMethodMemberWithParameters");
 function normalizeTypeLiteralMethodType(methodType, context) {
-  const newMembers = methodType.members.map((member) => normalizeMethodMember(member, context)).filter(isDefined).map((member, _index, partialMembers) => normalizeMethodMemberWithParameters(member, partialMembers, context)).filter(isDefined);
+  const newMembers = methodType.members.map((member) => normalizeMethodMember(member, context)).filter(isDefined_default).map((member, _index, partialMembers) => normalizeMethodMemberWithParameters(member, partialMembers, context)).filter(isDefined_default);
   return ts3__default.default.factory.updateTypeLiteralNode(methodType, ts3__default.default.factory.createNodeArray(newMembers));
 }
 __name(normalizeTypeLiteralMethodType, "normalizeTypeLiteralMethodType");
@@ -646,17 +647,17 @@ function normalizeIndexedAccessMethodType(methodType, context) {
 __name(normalizeIndexedAccessMethodType, "normalizeIndexedAccessMethodType");
 function normalizeMethod(method, context, options) {
   if (!isMethod(method)) {
-    return undefined;
+    return void 0;
   }
   const methodName = method.name.text.toUpperCase();
   if (!HTTP_METHODS.includes(methodName)) {
-    return undefined;
+    return void 0;
   }
   const pathMethodCompareString = `${methodName} ${options.pathName}`;
   const matchesPositiveFilters = context.filters.paths.positive.length === 0 || context.filters.paths.positive.some((filter) => filter.test(pathMethodCompareString));
   const matchesNegativeFilters = context.filters.paths.negative.length > 0 && context.filters.paths.negative.some((filter) => filter.test(pathMethodCompareString));
   if (!matchesPositiveFilters || matchesNegativeFilters) {
-    return undefined;
+    return void 0;
   }
   const newIdentifier = ts3__default.default.factory.createIdentifier(methodName);
   const newType = ts3__default.default.isTypeLiteralNode(method.type) ? normalizeTypeLiteralMethodType(method.type, context) : normalizeIndexedAccessMethodType(method.type, context);
@@ -668,11 +669,11 @@ function createPathsIdentifier(serviceName) {
 }
 __name(createPathsIdentifier, "createPathsIdentifier");
 function isPathsDeclaration(node) {
-  return node !== undefined && (ts3__default.default.isInterfaceDeclaration(node) || ts3__default.default.isTypeAliasDeclaration(node)) && node.name.text === "paths";
+  return node !== void 0 && (ts3__default.default.isInterfaceDeclaration(node) || ts3__default.default.isTypeAliasDeclaration(node)) && node.name.text === "paths";
 }
 __name(isPathsDeclaration, "isPathsDeclaration");
 function isPath(node) {
-  return ts3__default.default.isPropertySignature(node) && (ts3__default.default.isIdentifier(node.name) || ts3__default.default.isStringLiteral(node.name)) && node.type !== undefined && (ts3__default.default.isTypeLiteralNode(node.type) || ts3__default.default.isIndexedAccessTypeNode(node.type));
+  return ts3__default.default.isPropertySignature(node) && (ts3__default.default.isIdentifier(node.name) || ts3__default.default.isStringLiteral(node.name)) && node.type !== void 0 && (ts3__default.default.isTypeLiteralNode(node.type) || ts3__default.default.isIndexedAccessTypeNode(node.type));
 }
 __name(isPath, "isPath");
 function normalizePathNameWithParameters(pathName) {
@@ -691,15 +692,15 @@ __name(wrapComponentPathType, "wrapComponentPathType");
 function normalizePath(path4, context, options = {}) {
   const { isComponent: isComponent2 = false } = options;
   if (!isPath(path4)) {
-    return undefined;
+    return void 0;
   }
   const newPathName = isComponent2 ? path4.name.text : normalizePathNameWithParameters(path4.name.text);
   const newIdentifier = isComponent2 ? path4.name : ts3__default.default.factory.createStringLiteral(newPathName);
   let newType;
   if (ts3__default.default.isTypeLiteralNode(path4.type)) {
-    const newMethods = path4.type.members.map((method) => normalizeMethod(method, context, { pathName: newPathName })).filter(isDefined);
+    const newMethods = path4.type.members.map((method) => normalizeMethod(method, context, { pathName: newPathName })).filter(isDefined_default);
     if (newMethods.length === 0) {
-      return undefined;
+      return void 0;
     }
     newType = ts3__default.default.factory.updateTypeLiteralNode(path4.type, ts3__default.default.factory.createNodeArray(newMethods));
   } else {
@@ -722,8 +723,8 @@ function wrapPathsType(type, context) {
 __name(wrapPathsType, "wrapPathsType");
 function normalizePaths(pathsOrTypeAlias, context) {
   const newIdentifier = createPathsIdentifier(context.serviceName);
-  const paths = ts3__default.default.isTypeAliasDeclaration(pathsOrTypeAlias) ? ts3__default.default.factory.createInterfaceDeclaration(pathsOrTypeAlias.modifiers, pathsOrTypeAlias.name, undefined, undefined, []) : pathsOrTypeAlias;
-  const newMembers = paths.members.map((path4) => normalizePath(path4, context)).filter(isDefined);
+  const paths = ts3__default.default.isTypeAliasDeclaration(pathsOrTypeAlias) ? ts3__default.default.factory.createInterfaceDeclaration(pathsOrTypeAlias.modifiers, pathsOrTypeAlias.name, void 0, void 0, []) : pathsOrTypeAlias;
+  const newMembers = paths.members.map((path4) => normalizePath(path4, context)).filter(isDefined_default);
   const newType = ts3__default.default.factory.createTypeLiteralNode(newMembers);
   return ts3__default.default.factory.createTypeAliasDeclaration(
     paths.modifiers,
@@ -745,15 +746,15 @@ function createComponentsIdentifier(serviceName) {
 __name(createComponentsIdentifier, "createComponentsIdentifier");
 function isComponentsDeclaration(node, context) {
   const componentIdentifiers = ["components", createComponentsIdentifierText(context.serviceName)];
-  return node !== undefined && ts3__default.default.isInterfaceDeclaration(node) && componentIdentifiers.includes(node.name.text);
+  return node !== void 0 && ts3__default.default.isInterfaceDeclaration(node) && componentIdentifiers.includes(node.name.text);
 }
 __name(isComponentsDeclaration, "isComponentsDeclaration");
 function isComponentGroup(node) {
-  return ts3__default.default.isPropertySignature(node) && node.type !== undefined && ts3__default.default.isTypeLiteralNode(node.type) && ts3__default.default.isIdentifier(node.name);
+  return ts3__default.default.isPropertySignature(node) && node.type !== void 0 && ts3__default.default.isTypeLiteralNode(node.type) && ts3__default.default.isIdentifier(node.name);
 }
 __name(isComponentGroup, "isComponentGroup");
 function isComponent(node) {
-  return ts3__default.default.isPropertySignature(node) && node.type !== undefined && !isNeverType(node.type) && (ts3__default.default.isIdentifier(node.name) || ts3__default.default.isStringLiteral(node.name));
+  return ts3__default.default.isPropertySignature(node) && node.type !== void 0 && !isNeverType(node.type) && (ts3__default.default.isIdentifier(node.name) || ts3__default.default.isStringLiteral(node.name));
 }
 __name(isComponent, "isComponent");
 function isRequestComponent(node) {
@@ -894,7 +895,7 @@ function wrapRequestComponentType(type, context) {
 __name(wrapRequestComponentType, "wrapRequestComponentType");
 function normalizeRequestComponent(component, context) {
   if (!isRequestComponent(component)) {
-    return undefined;
+    return void 0;
   }
   const { bodyQuestionToken } = processPendingRequestComponentActions(component, context);
   const newType = normalizeContentType(component.type, context, { bodyQuestionToken });
@@ -909,7 +910,7 @@ function normalizeRequestComponent(component, context) {
 __name(normalizeRequestComponent, "normalizeRequestComponent");
 function normalizeComponent(component, componentGroupName, context) {
   if (!isComponent(component)) {
-    return undefined;
+    return void 0;
   }
   if (componentGroupName === "requests") {
     return normalizeRequestComponent(component, context);
@@ -932,11 +933,11 @@ function normalizeComponent(component, componentGroupName, context) {
 __name(normalizeComponent, "normalizeComponent");
 function normalizeComponentGroup(componentGroup, context) {
   if (!isComponentGroup(componentGroup)) {
-    return undefined;
+    return void 0;
   }
   const componentGroupName = normalizeComponentGroupName(componentGroup.name.text);
   const newIdentifier = ts3__default.default.factory.createIdentifier(componentGroupName);
-  const newComponents = componentGroup.type.members.map((component) => normalizeComponent(component, componentGroupName, context)).filter(isDefined);
+  const newComponents = componentGroup.type.members.map((component) => normalizeComponent(component, componentGroupName, context)).filter(isDefined_default);
   const newType = ts3__default.default.factory.updateTypeLiteralNode(componentGroup.type, ts3__default.default.factory.createNodeArray(newComponents));
   return ts3__default.default.factory.updatePropertySignature(
     componentGroup,
@@ -949,7 +950,7 @@ function normalizeComponentGroup(componentGroup, context) {
 __name(normalizeComponentGroup, "normalizeComponentGroup");
 function normalizeComponents(components, context) {
   const newIdentifier = createComponentsIdentifier(context.serviceName);
-  const newMembers = components.members.map((componentGroup) => normalizeComponentGroup(componentGroup, context)).filter(isDefined);
+  const newMembers = components.members.map((componentGroup) => normalizeComponentGroup(componentGroup, context)).filter(isDefined_default);
   return ts3__default.default.factory.updateInterfaceDeclaration(
     components,
     components.modifiers,
@@ -996,7 +997,7 @@ function populateReferencedComponents(components, context) {
 __name(populateReferencedComponents, "populateReferencedComponents");
 function removeComponentIfUnreferenced(component, componentGroupName, context) {
   if (!isComponent(component)) {
-    return undefined;
+    return void 0;
   }
   const componentName = component.name.text;
   const componentPath = `${componentGroupName}.${componentName}`;
@@ -1004,17 +1005,17 @@ function removeComponentIfUnreferenced(component, componentGroupName, context) {
     context.referencedTypes.components.delete(componentPath);
     return component;
   }
-  return undefined;
+  return void 0;
 }
 __name(removeComponentIfUnreferenced, "removeComponentIfUnreferenced");
 function removeUnreferencedComponentsInGroup(componentGroup, context) {
   if (!isComponentGroup(componentGroup)) {
-    return undefined;
+    return void 0;
   }
   const componentGroupName = normalizeComponentGroupName(componentGroup.name.text);
-  const newComponents = componentGroup.type.members.map((component) => removeComponentIfUnreferenced(component, componentGroupName, context)).filter(isDefined);
+  const newComponents = componentGroup.type.members.map((component) => removeComponentIfUnreferenced(component, componentGroupName, context)).filter(isDefined_default);
   if (newComponents.length === 0) {
-    return undefined;
+    return void 0;
   }
   return ts3__default.default.factory.updatePropertySignature(
     componentGroup,
@@ -1026,10 +1027,10 @@ function removeUnreferencedComponentsInGroup(componentGroup, context) {
 }
 __name(removeUnreferencedComponentsInGroup, "removeUnreferencedComponentsInGroup");
 function removeUnreferencedComponents(components, context) {
-  const newComponentGroups = components.members.map((componentGroup) => removeUnreferencedComponentsInGroup(componentGroup, context)).filter(isDefined);
+  const newComponentGroups = components.members.map((componentGroup) => removeUnreferencedComponentsInGroup(componentGroup, context)).filter(isDefined_default);
   context.referencedTypes.components.clear();
   if (newComponentGroups.length === 0) {
-    return undefined;
+    return void 0;
   }
   return ts3__default.default.factory.updateInterfaceDeclaration(
     components,
@@ -1048,52 +1049,28 @@ function convertToPascalCase(value) {
 }
 __name(convertToPascalCase, "convertToPascalCase");
 
-// src/utils/urls.ts
-var InvalidURLError = class extends TypeError {
-  static {
-    __name(this, "InvalidURLError");
-  }
-  constructor(url) {
-    super(`Invalid URL: '${url}'`);
-    this.name = "InvalidURL";
-  }
-};
-function createURLOrThrow(rawURL) {
-  try {
-    const url = new URL(rawURL);
-    Object.defineProperty(url, "raw", {
-      value: rawURL.toString(),
-      writable: false,
-      enumerable: true,
-      configurable: false
-    });
-    return url;
-  } catch {
-    throw new InvalidURLError(rawURL);
-  }
-}
-__name(createURLOrThrow, "createURLOrThrow");
-function createURL(rawURL) {
-  const url = createURLOrThrow(rawURL);
-  return url;
-}
-__name(createURL, "createURL");
-function createFileURL(filePath) {
-  return createURL(`file://${filePath}`);
+// ../zimic-utils/dist/data/isNonEmpty.mjs
+function isNonEmpty(value) {
+  return isDefined_default(value) && value !== "";
 }
-__name(createFileURL, "createFileURL");
+__name(isNonEmpty, "isNonEmpty");
+__name2(isNonEmpty, "isNonEmpty");
+var isNonEmpty_default = isNonEmpty;
+
+// ../zimic-utils/dist/url/createRegExpFromWildcardPath.mjs
 function prepareURLForRegex(url) {
   const encodedURL = encodeURI(url);
   return encodedURL.replace(/([.()*?+$\\])/g, "\\$1");
 }
 __name(prepareURLForRegex, "prepareURLForRegex");
-function createRegexFromWildcardPath(path4, options) {
+__name2(prepareURLForRegex, "prepareURLForRegex");
+function createRegExpFromWildcardPath(path4, options) {
   const pathWithReplacedWildcards = prepareURLForRegex(path4).replace(/^\/+|\/+$/g, "").replace(/\\\*/g, "*").replace(/\*\*\/\*/g, "**").replace(/(^|[^*])\*([^*]|$)/g, "$1[^/]*$2").replace(/\*\*/g, ".*");
   return new RegExp(`^${options.prefix}/*${pathWithReplacedWildcards}/*$`);
 }
-__name(createRegexFromWildcardPath, "createRegexFromWildcardPath");
-
-// src/typegen/openapi/transform/filters.ts
+__name(createRegExpFromWildcardPath, "createRegExpFromWildcardPath");
+__name2(createRegExpFromWildcardPath, "createRegExpFromWildcardPath");
+var createRegExpFromWildcardPath_default = createRegExpFromWildcardPath;
 var HTTP_METHOD_OPTIONS = HTTP_METHODS.join("|");
 var MODIFIER_GROUP = "(?<modifier>!?)";
 var METHOD_FILTER_GROUP = `(?<method>(?:\\*|(?:${HTTP_METHOD_OPTIONS})(?:,\\s*(?:${HTTP_METHOD_OPTIONS}))*))`;
@@ -1107,12 +1084,12 @@ function parseRawFilter(rawFilter) {
     logWithPrefix(`Warning: Filter could not be parsed and was ignored: ${chalk__default.default.yellow(rawFilter)}`, {
       method: "warn"
     });
-    return undefined;
+    return void 0;
   }
   const methodFilterGroup = `(?:${filteredMethodsOrWildcard.toUpperCase().replace(/,/g, "|").replace(/\*/g, ".*")}) `;
   const isNegativeMatch = filterModifier === "!";
   return {
-    expression: createRegexFromWildcardPath(filteredPath, { prefix: methodFilterGroup }),
+    expression: createRegExpFromWildcardPath_default(filteredPath, { prefix: methodFilterGroup }),
     isNegativeMatch
   };
 }
@@ -1141,7 +1118,7 @@ async function readPathFiltersFromFile(filePath) {
 }
 __name(readPathFiltersFromFile, "readPathFiltersFromFile");
 function ignoreEmptyFilters(filters) {
-  return filters.map((line) => line.trim()).filter(isNonEmpty);
+  return filters.map((line) => line.trim()).filter(isNonEmpty_default);
 }
 __name(ignoreEmptyFilters, "ignoreEmptyFilters");
 
@@ -1180,20 +1157,20 @@ function createImportDeclarations(context) {
 }
 __name(createImportDeclarations, "createImportDeclarations");
 
-// src/utils/imports.ts
+// ../zimic-utils/dist/import/createCachedDynamicImport.mjs
 function createCachedDynamicImport(importModuleDynamically) {
   let cachedImportResult;
-  return /* @__PURE__ */ __name(async function importModuleDynamicallyWithCache() {
-    if (cachedImportResult === undefined) {
+  return /* @__PURE__ */ __name2(/* @__PURE__ */ __name(async function importModuleDynamicallyWithCache() {
+    if (cachedImportResult === void 0) {
       cachedImportResult = await importModuleDynamically();
     }
     return cachedImportResult;
-  }, "importModuleDynamicallyWithCache");
+  }, "importModuleDynamicallyWithCache"), "importModuleDynamicallyWithCache");
 }
 __name(createCachedDynamicImport, "createCachedDynamicImport");
-
-// src/typegen/openapi/transform/io.ts
-var importOpenapiTypeScript = createCachedDynamicImport(() => import('openapi-typescript'));
+__name2(createCachedDynamicImport, "createCachedDynamicImport");
+var createCachedDynamicImport_default = createCachedDynamicImport;
+var importOpenapiTypeScript = createCachedDynamicImport_default(() => import('openapi-typescript'));
 function transformSchemaObject(schemaObject) {
   if (schemaObject.format === "binary") {
     const blobType = createBlobType();
@@ -1207,9 +1184,9 @@ function transformSchemaObject(schemaObject) {
 __name(transformSchemaObject, "transformSchemaObject");
 function convertFilePathOrURLToURL(filePathOrURL) {
   try {
-    return createURL(filePathOrURL);
+    return new URL(filePathOrURL);
   } catch {
-    return createFileURL(path__default.default.resolve(filePathOrURL));
+    return new URL(`file://${path__default.default.resolve(filePathOrURL)}`);
   }
 }
 __name(convertFilePathOrURLToURL, "convertFilePathOrURLToURL");
@@ -1265,7 +1242,7 @@ var RESOURCES_TO_REMOVE_IF_NOT_NORMALIZED = ["paths", "webhooks", "operations",
 function removeUnknownResources(node) {
   const isUnknownResource = !node || (ts3__default.default.isTypeAliasDeclaration(node) || ts3__default.default.isInterfaceDeclaration(node)) && RESOURCES_TO_REMOVE_IF_NOT_NORMALIZED.includes(node.name.text);
   if (isUnknownResource) {
-    return undefined;
+    return void 0;
   }
   return node;
 }
@@ -1273,18 +1250,18 @@ __name(removeUnknownResources, "removeUnknownResources");
 function normalizeRawNodes(rawNodes, context, options) {
   let normalizedNodes = rawNodes.map((node) => isPathsDeclaration(node) ? normalizePaths(node, context) : node);
   if (options.prune) {
-    normalizedNodes = normalizedNodes.map((node) => isOperationsDeclaration(node) ? removeUnreferencedOperations(node, context) : node).filter(isDefined);
+    normalizedNodes = normalizedNodes.map((node) => isOperationsDeclaration(node) ? removeUnreferencedOperations(node, context) : node).filter(isDefined_default);
   }
-  normalizedNodes = normalizedNodes.map((node) => isOperationsDeclaration(node) ? normalizeOperations(node, context) : node).filter(isDefined);
+  normalizedNodes = normalizedNodes.map((node) => isOperationsDeclaration(node) ? normalizeOperations(node, context) : node).filter(isDefined_default);
   if (options.prune) {
     for (const node of normalizedNodes) {
       if (isComponentsDeclaration(node, context)) {
         populateReferencedComponents(node, context);
       }
     }
-    normalizedNodes = normalizedNodes.map((node) => isComponentsDeclaration(node, context) ? removeUnreferencedComponents(node, context) : node).filter(isDefined);
+    normalizedNodes = normalizedNodes.map((node) => isComponentsDeclaration(node, context) ? removeUnreferencedComponents(node, context) : node).filter(isDefined_default);
   }
-  normalizedNodes = normalizedNodes.map((node) => isComponentsDeclaration(node, context) ? normalizeComponents(node, context) : node).map(removeUnknownResources).filter(isDefined);
+  normalizedNodes = normalizedNodes.map((node) => isComponentsDeclaration(node, context) ? normalizeComponents(node, context) : node).map(removeUnknownResources).filter(isDefined_default);
   return normalizedNodes;
 }
 __name(normalizeRawNodes, "normalizeRawNodes");
@@ -1308,7 +1285,7 @@ async function generateTypesFromOpenAPI({
   }
   const typeOutput = await convertTypesToString(nodes, { includeComments });
   const formattedOutput = prepareTypeOutputToSave(typeOutput);
-  const shouldWriteToStdout = outputFilePath === undefined;
+  const shouldWriteToStdout = outputFilePath === void 0;
   if (shouldWriteToStdout) {
     await writeTypeOutputToStandardOutput(formattedOutput);
   } else {
@@ -1378,5 +1355,5 @@ var typegen = Object.freeze(new TypegenNamespace_default());
 exports.__name = __name;
 exports.logWithPrefix = logWithPrefix;
 exports.typegen = typegen;
-//# sourceMappingURL=chunk-343XY3VF.js.map
-//# sourceMappingURL=chunk-343XY3VF.js.map
+//# sourceMappingURL=chunk-KDDZRZK6.js.map
+//# sourceMappingURL=chunk-KDDZRZK6.js.map