@defjs/core 0.0.0-test-005 → 0.2.0

package/index.js

@@ -1,14 +1,16 @@
-const ERR_ABORTED = new Error("ERR_ABORTED");
-const ERR_TIMEOUT = new Error("ERR_TIMEOUT");
-const ERR_NETWORK = new Error("ERR_NETWORK");
-const ERR_NOT_FOUND_HANDLER = new Error("ERR_NOT_FOUND_HANDLER");
-const ERR_OBSERVE = new Error("ERR_OBSERVE");
-const ERR_NOT_SET_ALIAS = new Error("ERR_NOT_SET_ALIAS");
-const ERR_UNSUPPORTED_FIELD_TYPE = new Error("ERR_UNSUPPORTED_FIELD_TYPE");
-const ERR_INVALID_CLIENT = new Error("ERR_INVALID_CLIENT");
-const ERR_NOT_FOUND_GLOBAL_CLIENT = new Error("ERR_NOT_FOUND_GLOBAL_CLIENT");
-const ERR_INVALID_HTTP_CONTEXT_TOKEN = new Error("ERR_INVALID_HTTP_CONTEXT_TOKEN");
-const ERR_UNKNOWN = new Error("ERR_UNKNOWN");
+// src/error.ts
+var ERR_ABORTED = new Error("ERR_ABORTED");
+var ERR_TIMEOUT = new Error("ERR_TIMEOUT");
+var ERR_NETWORK = new Error("ERR_NETWORK");
+var ERR_NOT_FOUND_HANDLER = new Error("ERR_NOT_FOUND_HANDLER");
+var ERR_OBSERVE = new Error("ERR_OBSERVE");
+var ERR_NOT_SET_ALIAS = new Error("ERR_NOT_SET_ALIAS");
+var ERR_UNSUPPORTED_FIELD_TYPE = new Error("ERR_UNSUPPORTED_FIELD_TYPE");
+var ERR_INVALID_CLIENT = new Error("ERR_INVALID_CLIENT");
+var ERR_NOT_FOUND_GLOBAL_CLIENT = new Error("ERR_NOT_FOUND_GLOBAL_CLIENT");
+var ERR_INVALID_HTTP_CONTEXT_TOKEN = new Error("ERR_INVALID_HTTP_CONTEXT_TOKEN");
+var ERR_UNKNOWN = new Error("ERR_UNKNOWN");
+
 class HttpErrorResponse extends Error {
   status;
   statusText;
@@ -19,7 +21,7 @@ class HttpErrorResponse extends Error {
     const status = init?.status ?? 0;
     const statusText = init?.statusText ?? "";
     const ok = status >= 200 && status < 300;
-    const headers = init?.headers ?? new Headers();
+    const headers = init?.headers ?? new Headers;
     const url = init?.url ?? "";
     const body = init?.body ?? null;
     let message;
@@ -41,6 +43,7 @@ class HttpErrorResponse extends Error {
   }
 }
 
+// src/handler/util.ts
 function __getContentLength(headers) {
   const value = headers.get("Content-Length");
   if (!value) {
@@ -87,7 +90,7 @@ function __concatChunks(chunks, totalLength) {
   return chunksAll;
 }
 
-const HTTP_CONTEXT_TOKEN = Symbol("HttpContextToken");
+// src/context.ts
 function makeHttpContextToken(defaultValue) {
   Object.defineProperty(defaultValue, HTTP_CONTEXT_TOKEN, { value: defaultValue });
   return defaultValue;
@@ -95,12 +98,11 @@ function makeHttpContextToken(defaultValue) {
 function isHttpContextToken(value) {
   return typeof value === "function" && HTTP_CONTEXT_TOKEN in value;
 }
-const HTTP_CONTEXT = Symbol("HttpContext");
 function isHttpContext(value) {
   return typeof value === "object" && value !== null && HTTP_CONTEXT in value;
 }
 function makeHttpContext(entries) {
-  const ctx = /* @__PURE__ */ new Map();
+  const ctx = new Map;
   switch (true) {
     case Array.isArray(entries): {
       for (const [token, value] of entries) {
@@ -150,23 +152,14 @@ function makeHttpContext(entries) {
     [HTTP_CONTEXT]: ctx
   };
 }
+var HTTP_CONTEXT_TOKEN = Symbol("HttpContextToken");
+var HTTP_CONTEXT = Symbol("HttpContext");
 
-const FIELD = Symbol("field");
-var FieldType = /* @__PURE__ */ ((FieldType2) => {
-  FieldType2[FieldType2["Json"] = 0] = "Json";
-  FieldType2[FieldType2["Query"] = 1] = "Query";
-  FieldType2[FieldType2["Param"] = 2] = "Param";
-  FieldType2[FieldType2["Header"] = 3] = "Header";
-  FieldType2[FieldType2["Form"] = 4] = "Form";
-  FieldType2[FieldType2["Body"] = 5] = "Body";
-  FieldType2[FieldType2["UrlForm"] = 6] = "UrlForm";
-  return FieldType2;
-})(FieldType || {});
+// src/field.ts
 function field(defaultValue) {
   const meta = {
-    // todo
     required: typeof defaultValue !== "undefined",
-    alias: /* @__PURE__ */ new Map(),
+    alias: new Map,
     validators: [],
     asyncValidator: []
   };
@@ -199,7 +192,7 @@ function field(defaultValue) {
     return getter;
   };
   getter.withBody = () => {
-    meta.alias.set(5 /* Body */, void 0);
+    meta.alias.set(5 /* Body */, undefined);
     return getter;
   };
   getter.withValidators = (...fn) => {
@@ -224,24 +217,25 @@ function isField(value) {
 function isFieldGroup(value) {
   return !!value && typeof value === "object" && Object.entries(value).every(([, v]) => isField(v));
 }
+var FIELD = Symbol("field");
 
-let globalHttpHandler = void 0;
-const getGlobalHttpHandler = () => globalHttpHandler;
+// src/handler/handler.ts
+var globalHttpHandler = undefined;
+var getGlobalHttpHandler = () => globalHttpHandler;
 
+// src/interceptor/interceptor.ts
 function makeInterceptorChain(interceptors) {
-  return interceptors.reduceRight(
-    (fn, interceptor) => {
-      return (initReq, finalHandlerFn) => interceptor(initReq, (req) => fn(req, finalHandlerFn));
-    },
-    (req, fn) => fn(req)
-  );
+  return interceptors.reduceRight((fn, interceptor) => {
+    return (initReq, finalHandlerFn) => interceptor(initReq, (req) => fn(req, finalHandlerFn));
+  }, (req, fn) => fn(req));
 }
 
+// src/response.ts
 function __makeResponse(options) {
   const status = options?.status ?? 0;
   const statusText = options?.statusText ?? "";
   const url = options?.url ?? "";
-  const headers = options?.headers ?? new Headers();
+  const headers = options?.headers ?? new Headers;
   const body = options?.body ?? null;
   return {
     status,
@@ -252,6 +246,7 @@ function __makeResponse(options) {
   };
 }
 
+// src/request.ts
 function __serializeBody(body) {
   switch (true) {
     case body instanceof FormData:
@@ -297,121 +292,124 @@ function __buildFieldDefaultValue(input) {
   }
   if (isFieldGroup(input)) {
     const obj = {};
-    for (const [key, field] of Object.entries(input)) {
-      obj[key] = field();
+    for (const [key, field3] of Object.entries(input)) {
+      obj[key] = field3();
     }
     return obj;
   }
-  return void 0;
+  return;
 }
-function defineRequest(method, endpoint) {
+function defineRequest(...args) {
+  let method;
+  let endpoint;
   let requiredInput = false;
-  let field;
+  let field3;
   let interceptors = [];
   let responseType = "json";
-  let context;
-  let observe = "body";
+  let context2;
   let withCredentials = false;
   let validators = [];
   let transformResponse;
-  const fn = () => {
+  switch (args.length) {
+    case 1: {
+      method = "GET";
+      endpoint = args[0];
+      break;
+    }
+    case 2: {
+      method = args[0];
+      endpoint = args[1];
+      break;
+    }
+    default:
+      throw new Error("Invalid arguments");
+  }
+  const fn = (options) => {
+    const timeout = options?.timeout || 0;
+    const client2 = options?.client || getGlobalClient();
+    const clientOptions = getClientConfig(client2);
+    const handler2 = options?.handler || clientOptions?.handler || getGlobalHttpHandler();
+    if (!handler2) {
+      throw ERR_NOT_FOUND_HANDLER;
+    }
     let uploadProgress;
     let downloadProgress;
-    let abortSignal;
-    const getInitValue = () => __buildFieldDefaultValue(field);
+    let abortController;
+    const abortSignal = [];
+    if (options?.abort) {
+      abortSignal.push(options.abort);
+    } else {
+      abortController = new AbortController;
+      abortSignal.push(abortController.signal);
+    }
+    if (timeout > 0) {
+      abortSignal.push(AbortSignal.timeout(timeout));
+    }
+    const cancel = () => {
+      abortController?.abort();
+    };
+    const getInitValue = () => __buildFieldDefaultValue(field3);
     const setUploadProgress = (fn2) => {
       uploadProgress = fn2;
     };
     const setDownloadProgress = (fn2) => {
       downloadProgress = fn2;
     };
-    const doRequest = async (...args) => {
+    const doRequest = async (...args2) => {
       let input;
-      let doRequestOptions;
-      switch (args.length) {
-        case 1: {
-          if (requiredInput) {
-            input = args[0];
-          } else {
-            doRequestOptions = args[0];
-          }
-          break;
-        }
-        case 2: {
-          input = args[0];
-          doRequestOptions = args[1];
-          break;
-        }
+      if (requiredInput && args2.length === 1) {
+        input = args2[0];
       }
       if (requiredInput && !input) {
-        throw new Error(`Because the request has input, the first argument must be the input value`);
+        throw new Error(`Because the request has input, the argument must be the input value`);
       }
       if (validators.length > 0) {
         for (const fn2 of validators) {
           fn2(input);
         }
       }
-      const timeout = doRequestOptions?.timeout || 0;
-      if (doRequestOptions?.abort) {
-        abortSignal = doRequestOptions.abort;
-      } else if (timeout > 0) {
-        abortSignal = AbortSignal.timeout(timeout);
-      }
-      const client = isClient(doRequestOptions?.client) ? doRequestOptions.client : getGlobalClient();
-      const clientOptions = getClientConfig(client);
       const req = {
         host: clientOptions?.host,
         method,
         endpoint,
-        queryParams: new URLSearchParams(),
-        headers: new Headers(),
-        body: void 0,
+        queryParams: new URLSearchParams,
+        headers: new Headers,
+        body: undefined,
         withCredentials,
         responseType,
-        context: context || makeHttpContext(),
-        observe,
+        context: context2 || makeHttpContext(),
         uploadProgress,
         downloadProgress,
         timeout,
-        abort: abortSignal
+        abort: AbortSignal.any(abortSignal)
       };
-      const handler = doRequestOptions?.handler || clientOptions?.handler || getGlobalHttpHandler();
-      if (!handler) {
-        throw ERR_NOT_FOUND_HANDLER;
+      if (requiredInput && field3) {
+        await __fillRequestFromField(req, field3, input);
       }
-      if (requiredInput && field) {
-        await __fillRequestFromField(req, field, input);
-      }
-      const chain = makeInterceptorChain([...interceptors]);
-      let res = await chain(req, handler);
+      const chain = makeInterceptorChain([...clientOptions.interceptors, ...interceptors]);
+      let res = await chain(req, handler2);
       if (typeof transformResponse === "function") {
         try {
           res = __makeResponse({
             ...res,
             body: transformResponse(res)
           });
-        } catch (error) {
-          throw new HttpErrorResponse({ error });
+        } catch (error3) {
+          throw new HttpErrorResponse({ error: error3 });
         }
       }
-      switch (req.observe) {
-        case "body":
-          return res.body;
-        case "response":
-          return res;
-        default:
-          throw ERR_OBSERVE;
-      }
+      return res;
     };
     return {
       doRequest,
+      cancel,
       getInitValue,
       setUploadProgress,
       setDownloadProgress
     };
   };
   fn.withField = (value) => {
-    field = value;
+    field3 = value;
     requiredInput = true;
     return fn;
   };
@@ -420,7 +418,7 @@ function defineRequest(method, endpoint) {
     return fn;
   };
   fn.withContext = (value) => {
-    context = value;
+    context2 = value;
     return fn;
   };
   fn.withCredentials = (value) => {
@@ -435,10 +433,6 @@ function defineRequest(method, endpoint) {
     transformResponse = value;
     return fn;
   };
-  fn.withObserve = (value) => {
-    observe = value;
-    return fn;
-  };
   fn.withResponseType = (value) => {
     responseType = value;
     return fn;
@@ -501,49 +495,49 @@ async function __fillRequestFromField(request, fieldOrFieldGroup, input) {
     let params;
     let queryParams;
     let headers;
-    let body = void 0;
+    let body = undefined;
     const validValue = getValidValue(input, fieldOrFieldGroup());
     const meta = __getFieldMetadata(fieldOrFieldGroup);
     await doValid([...meta.validators, ...meta.asyncValidator], validValue);
     for (const [type, aliasName] of meta.alias) {
       switch (type) {
-        case FieldType.Query: {
+        case 1 /* Query */: {
           if (!aliasName) {
             throw ERR_NOT_SET_ALIAS;
           }
-          queryParams = appendValue(new URLSearchParams(), aliasName, validValue);
+          queryParams = appendValue(new URLSearchParams, aliasName, validValue);
           break;
         }
-        case FieldType.Param: {
+        case 2 /* Param */: {
           if (!aliasName) {
             throw ERR_NOT_SET_ALIAS;
           }
-          params = setValue(/* @__PURE__ */ new Map(), aliasName, validValue);
+          params = setValue(new Map, aliasName, validValue);
           break;
         }
-        case FieldType.Header: {
+        case 3 /* Header */: {
           if (!aliasName) {
             throw ERR_NOT_SET_ALIAS;
           }
-          headers = appendValue(new Headers(), aliasName, validValue);
+          headers = appendValue(new Headers, aliasName, validValue);
           break;
         }
-        case FieldType.Form: {
+        case 4 /* Form */: {
           if (!aliasName) {
             throw ERR_NOT_SET_ALIAS;
           }
-          body = appendValue(new FormData(), aliasName, validValue);
+          body = appendValue(new FormData, aliasName, validValue);
           break;
         }
-        case FieldType.UrlForm: {
+        case 6 /* UrlForm */: {
           if (!aliasName) {
             throw ERR_NOT_SET_ALIAS;
           }
-          body = appendValue(new URLSearchParams(), aliasName, validValue);
+          body = appendValue(new URLSearchParams, aliasName, validValue);
           break;
         }
-        case FieldType.Json:
-        case FieldType.Body:
+        case 0 /* Json */:
+        case 5 /* Body */:
           body = validValue;
           break;
       }
@@ -557,52 +551,52 @@ async function __fillRequestFromField(request, fieldOrFieldGroup, input) {
     return;
   }
   if (isFieldGroup(fieldOrFieldGroup) && inputIsObject(input)) {
-    let params = /* @__PURE__ */ new Map();
-    let queryParams = new URLSearchParams();
-    let headers = new Headers();
-    let urlForm = new URLSearchParams();
-    let formData = new FormData();
+    let params = new Map;
+    let queryParams = new URLSearchParams;
+    let headers = new Headers;
+    let urlForm = new URLSearchParams;
+    let formData = new FormData;
     const json = {};
-    let body = void 0;
+    let body = undefined;
     let lastBodyField;
-    for (const [propertyKey, field] of Object.entries(fieldOrFieldGroup)) {
-      const meta = __getFieldMetadata(field);
+    for (const [propertyKey, field3] of Object.entries(fieldOrFieldGroup)) {
+      const meta = __getFieldMetadata(field3);
       for (const [type, aliasName] of meta.alias) {
         const valueKey = aliasName || propertyKey;
-        const value = getValidValue(input[propertyKey], field());
+        const value = getValidValue(input[propertyKey], field3());
         await doValid([...meta.validators, ...meta.asyncValidator], value);
         switch (type) {
-          case FieldType.Json: {
+          case 0 /* Json */: {
             Object.defineProperty(json, valueKey, {
               value,
               writable: true,
               enumerable: true
             });
-            lastBodyField = FieldType.Json;
+            lastBodyField = 0 /* Json */;
             break;
           }
-          case FieldType.Query:
+          case 1 /* Query */:
             queryParams = appendValue(queryParams, valueKey, value);
             break;
-          case FieldType.Param:
+          case 2 /* Param */:
             params = setValue(params, valueKey, value);
             break;
-          case FieldType.Header:
+          case 3 /* Header */:
             headers = appendValue(headers, valueKey, value);
             break;
-          case FieldType.Form: {
+          case 4 /* Form */: {
             formData = appendValue(formData, valueKey, value);
-            lastBodyField = FieldType.Form;
+            lastBodyField = 4 /* Form */;
             break;
           }
-          case FieldType.UrlForm: {
+          case 6 /* UrlForm */: {
             urlForm = appendValue(urlForm, valueKey, value);
-            lastBodyField = FieldType.UrlForm;
+            lastBodyField = 6 /* UrlForm */;
             break;
           }
-          case FieldType.Body: {
+          case 5 /* Body */: {
             body = value;
-            lastBodyField = FieldType.Body;
+            lastBodyField = 5 /* Body */;
             break;
           }
         }
@@ -612,16 +606,16 @@ async function __fillRequestFromField(request, fieldOrFieldGroup, input) {
     request.queryParams = queryParams;
     request.headers = headers;
     switch (lastBodyField) {
-      case FieldType.Body:
+      case 5 /* Body */:
         request.body = body;
         break;
-      case FieldType.Form:
+      case 4 /* Form */:
         request.body = formData;
         break;
-      case FieldType.UrlForm:
+      case 6 /* UrlForm */:
         request.body = urlForm;
         break;
-      case FieldType.Json:
+      case 0 /* Json */:
         request.body = json;
         break;
     }
@@ -630,14 +624,15 @@ async function __fillRequestFromField(request, fieldOrFieldGroup, input) {
   throw ERR_UNSUPPORTED_FIELD_TYPE;
 }
 
-function __createRequest(request) {
-  const url = new URL(request.endpoint, request.host);
-  if (request.queryParams) {
-    url.search = request.queryParams.toString();
+// src/handler/fetch/fetch.ts
+function __createRequest(request2) {
+  const url = new URL(request2.endpoint, request2.host);
+  if (request2.queryParams) {
+    url.search = request2.queryParams.toString();
   }
-  const headers = request.headers ?? new Headers();
+  const headers = request2.headers ?? new Headers;
   if (!headers.has("Content-Type")) {
-    const detectedType = __detectContentTypeHeader(request.body);
+    const detectedType = __detectContentTypeHeader(request2.body);
     if (detectedType) {
       headers.set("Content-Type", detectedType);
     }
@@ -645,23 +640,23 @@ function __createRequest(request) {
   if (!headers.has("Accept")) {
     headers.set("Accept", "application/json, text/plain, */*");
   }
-  const credentials = request.withCredentials ? "include" : void 0;
+  const credentials = request2.withCredentials ? "include" : undefined;
   return new Request(url, {
     headers,
-    method: request.method,
-    body: __serializeBody(request.body),
-    signal: request.abort,
+    method: request2.method,
+    body: __serializeBody(request2.body),
+    signal: request2.abort,
     credentials
   });
 }
 async function fetchHandler(httpRequest) {
   const downloadProgress = httpRequest.downloadProgress;
-  const request = __createRequest(httpRequest);
+  const request2 = __createRequest(httpRequest);
   const abortSignal = httpRequest.abort;
-  let response;
+  let response3;
   try {
-    response = await globalThis.fetch(request);
-  } catch (error) {
+    response3 = await globalThis.fetch(request2);
+  } catch (error4) {
     if (abortSignal?.aborted && abortSignal.reason instanceof Error) {
       switch (true) {
         case abortSignal.reason.name === "AbortError":
@@ -670,15 +665,15 @@ async function fetchHandler(httpRequest) {
           throw new HttpErrorResponse({ error: ERR_TIMEOUT });
       }
     }
-    throw new HttpErrorResponse({ error });
+    throw new HttpErrorResponse({ error: error4 });
   }
-  const { ok, headers, status, statusText, url } = response;
+  const { ok, headers, status, statusText, url } = response3;
   const contentLength = __getContentLength(headers);
   const contentType = __getContentType(headers);
   let body = null;
-  if (response.body) {
+  if (response3.body) {
     const chunks = [];
-    const reader = response.body.getReader();
+    const reader = response3.body.getReader();
     let receivedLength = 0;
     while (true) {
       const { done, value } = await reader.read();
@@ -700,9 +695,9 @@ async function fetchHandler(httpRequest) {
         content: chunksAll,
         contentType
       });
-    } catch (error) {
+    } catch (error4) {
       throw new HttpErrorResponse({
-        error,
+        error: error4,
         status,
         statusText,
         headers,
@@ -727,22 +722,19 @@ async function fetchHandler(httpRequest) {
     body
   });
 }
-
-const CLIENT = Symbol("Client");
-let globalClient;
+// src/client.ts
 function isClient(value) {
   return typeof value === "object" && value !== null && CLIENT in value;
 }
-function getClientConfig(client) {
-  if (!isClient(client)) {
+function getClientConfig(client2) {
+  if (!isClient(client2)) {
     throw ERR_INVALID_CLIENT;
   }
-  return client[CLIENT];
+  return client2[CLIENT];
 }
 function createClient(options) {
   const conf = {
     host: options.host,
-    strict: options.strict ?? true,
     interceptors: options.interceptors ?? [],
     handler: options.handler || fetchHandler
   };
@@ -750,8 +742,8 @@ function createClient(options) {
     [CLIENT]: conf
   };
 }
-function cloneClient(client, options) {
-  const preConf = getClientConfig(client);
+function cloneClient(client2, options) {
+  const preConf = getClientConfig(client2);
   const conf = {
     ...preConf,
     ...options
@@ -766,16 +758,18 @@ function getGlobalClient() {
   }
   return globalClient;
 }
-function setGlobalClient(client) {
-  globalClient = client;
+function setGlobalClient(client2) {
+  globalClient = client2;
 }
 function restGlobalClient() {
-  globalClient = void 0;
+  globalClient = undefined;
 }
 function createGlobalClient(options) {
   globalClient = createClient(options);
 }
-
+var CLIENT = Symbol("Client");
+var globalClient;
+// src/interceptor/authorization/basic_auth_interceptor.ts
 function basicAuthInterceptor(fn, options) {
   let encode = options?.encode;
   if (!encode) {
@@ -786,48 +780,48 @@ function basicAuthInterceptor(fn, options) {
     encode = (data) => btoa(`${data.username}:${data.password}`);
   }
   return (req, next) => {
-    const headers = req.headers || new Headers();
+    const headers = req.headers || new Headers;
     headers.set("Authorization", `Basic ${encode(fn())}`);
     req.headers = headers;
     return next(req);
   };
 }
-
-const required = (value) => {
+// src/validator.ts
+var required = (value) => {
   if (!value) {
     return new Error("required");
   }
   return null;
 };
-const requiredTrue = (value) => {
+var requiredTrue = (value) => {
   if (typeof value !== "boolean" || !value) {
     return new Error("requiredTrue");
   }
   return null;
 };
-const minLength = (min2) => {
+var minLength = (min) => {
   return (value) => {
     if (typeof value !== "string") {
       return new Error("invalid string");
     }
-    if (value.length < min2) {
-      return new Error(`minLength ${min2}`);
+    if (value.length < min) {
+      return new Error(`minLength ${min}`);
     }
     return null;
   };
 };
-const maxLength = (max2) => {
+var maxLength = (max) => {
   return (value) => {
     if (typeof value !== "string") {
       return new Error("invalid string");
     }
-    if (value.length > max2) {
-      return new Error(`maxLength ${max2}`);
+    if (value.length > max) {
+      return new Error(`maxLength ${max}`);
     }
     return null;
   };
 };
-const min = (min2) => {
+var min = (min2) => {
   return (value) => {
     if (typeof value !== "number" || isNaN(value)) {
       return new Error("invalid number");
@@ -838,7 +832,7 @@ const min = (min2) => {
     return null;
   };
 };
-const max = (max2) => {
+var max = (max2) => {
   return (value) => {
     if (typeof value !== "number" || isNaN(value)) {
       return new Error("invalid number");
@@ -849,7 +843,7 @@ const max = (max2) => {
     return null;
   };
 };
-const pattern = (pattern2) => {
+var pattern = (pattern2) => {
   return (value) => {
     if (typeof value !== "string") {
       return new Error("invalid string");
@@ -860,5 +854,41 @@ const pattern = (pattern2) => {
     return null;
   };
 };
-
-export { ERR_ABORTED, ERR_INVALID_CLIENT, ERR_INVALID_HTTP_CONTEXT_TOKEN, ERR_NETWORK, ERR_NOT_FOUND_GLOBAL_CLIENT, ERR_NOT_FOUND_HANDLER, ERR_NOT_SET_ALIAS, ERR_OBSERVE, ERR_TIMEOUT, ERR_UNKNOWN, ERR_UNSUPPORTED_FIELD_TYPE, HttpErrorResponse, basicAuthInterceptor, cloneClient, createClient, createGlobalClient, defineRequest, doValid, fetchHandler, field, getGlobalClient, isClient, isField, isFieldGroup, isHttpContextToken, makeHttpContext, makeHttpContextToken, max, maxLength, min, minLength, pattern, required, requiredTrue, restGlobalClient, setGlobalClient };
+export {
+  setGlobalClient,
+  restGlobalClient,
+  requiredTrue,
+  required,
+  pattern,
+  minLength,
+  min,
+  maxLength,
+  max,
+  makeHttpContextToken,
+  makeHttpContext,
+  isHttpContextToken,
+  isFieldGroup,
+  isField,
+  isClient,
+  getGlobalClient,
+  field,
+  fetchHandler,
+  doValid,
+  defineRequest,
+  createGlobalClient,
+  createClient,
+  cloneClient,
+  basicAuthInterceptor,
+  HttpErrorResponse,
+  ERR_UNSUPPORTED_FIELD_TYPE,
+  ERR_UNKNOWN,
+  ERR_TIMEOUT,
+  ERR_OBSERVE,
+  ERR_NOT_SET_ALIAS,
+  ERR_NOT_FOUND_HANDLER,
+  ERR_NOT_FOUND_GLOBAL_CLIENT,
+  ERR_NETWORK,
+  ERR_INVALID_HTTP_CONTEXT_TOKEN,
+  ERR_INVALID_CLIENT,
+  ERR_ABORTED
+};