envio 3.0.0-alpha.21 → 3.0.0-alpha.22

package/src/vendored/Rest.res.mjs

@@ -1,155 +1,150 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Caml_option from "rescript/lib/es6/caml_option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as S$RescriptSchema from "rescript-schema/src/S.res.mjs";
-import * as Caml_js_exceptions from "rescript/lib/es6/caml_js_exceptions.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
 
 function panic(message, params) {
-  var error = new Error("[rescript-rest] " + message);
+  let error = new Error(`[rescript-rest] ` + message);
   if (params !== undefined) {
-    error.params = Caml_option.valFromOption(params);
+    error.params = Primitive_option.valFromOption(params);
   }
   throw error;
 }
 
 async function $$default(args) {
-  var result = await fetch(args.path, args);
-  var contentType = result.headers.get("content-type");
+  let result = await fetch(args.path, args);
+  let contentType = result.headers.get("content-type");
   if (contentType && contentType.includes("application/") && contentType.includes("json")) {
     return {
-            data: await result.json(),
-            status: result.status,
-            headers: result.headers
-          };
+      data: await result.json(),
+      status: result.status,
+      headers: result.headers
+    };
   } else if (contentType && contentType.includes("text/")) {
     return {
-            data: await result.text(),
-            status: result.status,
-            headers: result.headers
-          };
+      data: await result.text(),
+      status: result.status,
+      headers: result.headers
+    };
   } else {
     return {
-            data: await result.blob(),
-            status: result.status,
-            headers: result.headers
-          };
+      data: await result.blob(),
+      status: result.status,
+      headers: result.headers
+    };
   }
 }
 
-var ApiFetcher = {
+let ApiFetcher = {
   $$default: $$default
 };
 
 function register(map, status, builder) {
-  if (map[status]) {
-    return panic("Response for the \"" + status + "\" status registered multiple times", undefined);
+  if (status in map) {
+    return panic(`Response for the "` + status + `" status registered multiple times`, undefined);
   } else {
     map[status] = builder;
-    return ;
+    return;
   }
 }
 
 function parsePath(_path, pathItems, pathParams) {
-  while(true) {
-    var path = _path;
+  while (true) {
+    let path = _path;
     if (path === "") {
-      return ;
+      return;
     }
-    var paramStartIdx = path.indexOf("{");
+    let paramStartIdx = path.indexOf("{");
     if (paramStartIdx !== -1) {
-      var paramEndIdx = path.indexOf("}");
+      let paramEndIdx = path.indexOf("}");
       if (paramEndIdx === -1) {
         return panic("Path contains an unclosed parameter", undefined);
       }
       if (paramStartIdx > paramEndIdx) {
         panic("Path parameter is not enclosed in curly braces", undefined);
       }
-      var paramName = path.slice(paramStartIdx + 1 | 0, paramEndIdx);
+      let paramName = path.slice(paramStartIdx + 1 | 0, paramEndIdx);
       if (paramName === "") {
         panic("Path parameter name cannot be empty", undefined);
       }
-      var param = {
+      let param = {
         name: paramName
       };
       pathItems.push(path.slice(0, paramStartIdx));
       pathItems.push(param);
       pathParams[paramName] = param;
       _path = path.slice(paramEndIdx + 1 | 0);
-      continue ;
+      continue;
     }
     pathItems.push(path);
-    return ;
+    return;
   };
 }
 
 function coerceSchema(schema) {
-  return S$RescriptSchema.preprocess(schema, (function (s) {
-                var optionalSchema = s.schema.t;
-                var tagged;
-                tagged = typeof optionalSchema !== "object" || optionalSchema.TAG !== "option" ? optionalSchema : optionalSchema._0.t;
-                var exit = 0;
-                if (typeof tagged !== "object") {
-                  switch (tagged) {
-                    case "int32" :
-                    case "number" :
-                        exit = 2;
-                        break;
-                    case "boolean" :
-                        exit = 1;
-                        break;
-                    default:
-                      return {};
-                  }
-                } else {
-                  switch (tagged.TAG) {
-                    case "literal" :
-                        switch (tagged._0.kind) {
-                          case "Number" :
-                              exit = 2;
-                              break;
-                          case "Boolean" :
-                              exit = 1;
-                              break;
-                          default:
-                            return {};
-                        }
-                        break;
-                    default:
-                      return {};
-                  }
-                }
-                switch (exit) {
-                  case 1 :
-                      return {
-                              p: (function (unknown) {
-                                  switch (unknown) {
-                                    case "false" :
-                                        return false;
-                                    case "true" :
-                                        return true;
-                                    default:
-                                      return unknown;
-                                  }
-                                })
-                            };
-                  case 2 :
-                      return {
-                              p: (function (unknown) {
-                                  var $$float = (+unknown);
-                                  if (Number.isNaN($$float)) {
-                                    return unknown;
-                                  } else {
-                                    return $$float;
-                                  }
-                                })
-                            };
-                  
-                }
-              }));
-}
-
-function stripInPlace(schema) {
-  schema.t.unknownKeys = "Strip";
+  return S$RescriptSchema.preprocess(schema, s => {
+    let optionalSchema = s.schema.t;
+    let tagged;
+    tagged = typeof optionalSchema !== "object" || optionalSchema.TAG !== "option" ? optionalSchema : optionalSchema._0.t;
+    let exit = 0;
+    if (typeof tagged !== "object") {
+      switch (tagged) {
+        case "int32" :
+        case "number" :
+          exit = 2;
+          break;
+        case "boolean" :
+          exit = 1;
+          break;
+        default:
+          return {};
+      }
+    } else {
+      switch (tagged.TAG) {
+        case "literal" :
+          switch (tagged._0.kind) {
+            case "Number" :
+              exit = 2;
+              break;
+            case "Boolean" :
+              exit = 1;
+              break;
+            default:
+              return {};
+          }
+          break;
+        default:
+          return {};
+      }
+    }
+    switch (exit) {
+      case 1 :
+        return {
+          p: unknown => {
+            switch (unknown) {
+              case "false" :
+                return false;
+              case "true" :
+                return true;
+              default:
+                return unknown;
+            }
+          }
+        };
+      case 2 :
+        return {
+          p: unknown => {
+            let float = (+unknown);
+            if (Number.isNaN(float)) {
+              return unknown;
+            } else {
+              return float;
+            }
+          }
+        };
+    }
+  });
 }
 
 function getSchemaField(schema, fieldName) {
@@ -157,7 +152,7 @@ function getSchemaField(schema, fieldName) {
 }
 
 function isNestedFlattenSupported(schema) {
-  var match = schema.t;
+  let match = schema.t;
   if (typeof match !== "object") {
     return false;
   }
@@ -167,86 +162,74 @@ function isNestedFlattenSupported(schema) {
   if (match.advanced) {
     return false;
   }
-  var match$1 = S$RescriptSchema.reverse(schema).t;
-  if (typeof match$1 !== "object" || !(match$1.TAG === "object" && !match$1.advanced)) {
+  let match$1 = S$RescriptSchema.reverse(schema).t;
+  if (typeof match$1 !== "object" || match$1.TAG !== "object") {
     return false;
   } else {
-    return true;
+    return !match$1.advanced;
   }
 }
 
-var bearerAuthSchema = S$RescriptSchema.transform(S$RescriptSchema.string, (function (s) {
-        return {
-                p: (function (string) {
-                    var match = string.split(" ");
-                    if (match.length !== 2) {
-                      return s.fail("Invalid Bearer token", undefined);
-                    }
-                    var match$1 = match[0];
-                    if (match$1 === "Bearer") {
-                      return match[1];
-                    } else {
-                      return s.fail("Invalid Bearer token", undefined);
-                    }
-                  }),
-                s: (function (token) {
-                    return "Bearer " + token;
-                  })
-              };
-      }));
+let bearerAuthSchema = S$RescriptSchema.transform(S$RescriptSchema.string, s => ({
+  p: string => {
+    let match = string.split(" ");
+    if (match.length !== 2) {
+      return s.fail("Invalid Bearer token", undefined);
+    }
+    let match$1 = match[0];
+    if (match$1 === "Bearer") {
+      return match[1];
+    } else {
+      return s.fail("Invalid Bearer token", undefined);
+    }
+  },
+  s: token => `Bearer ` + token
+}));
 
-var basicAuthSchema = S$RescriptSchema.transform(S$RescriptSchema.string, (function (s) {
-        return {
-                p: (function (string) {
-                    var match = string.split(" ");
-                    if (match.length !== 2) {
-                      return s.fail("Invalid Basic token", undefined);
-                    }
-                    var match$1 = match[0];
-                    if (match$1 === "Basic") {
-                      return match[1];
-                    } else {
-                      return s.fail("Invalid Basic token", undefined);
-                    }
-                  }),
-                s: (function (token) {
-                    return "Basic " + token;
-                  })
-              };
-      }));
+let basicAuthSchema = S$RescriptSchema.transform(S$RescriptSchema.string, s => ({
+  p: string => {
+    let match = string.split(" ");
+    if (match.length !== 2) {
+      return s.fail("Invalid Basic token", undefined);
+    }
+    let match$1 = match[0];
+    if (match$1 === "Basic") {
+      return match[1];
+    } else {
+      return s.fail("Invalid Basic token", undefined);
+    }
+  },
+  s: token => `Basic ` + token
+}));
 
 function params(route) {
-  var params$1 = route._rest;
+  let params$1 = route._rest;
   if (params$1 !== undefined) {
     return params$1;
   }
-  var definition = route();
-  var params$2;
+  let definition = route();
+  let params$2;
   if (definition.output) {
-    var p = definition.operationId;
-    var path = "/" + (
+    let p = definition.operationId;
+    let path = `/` + (
       p !== undefined ? p : route.name
     );
-    var inputSchema = S$RescriptSchema.object(function (s) {
-          return s.f("body", definition.input);
-        });
-    stripInPlace(inputSchema);
+    let inputSchema = S$RescriptSchema.object(s => s.f("body", definition.input));
+    inputSchema.t.unknownKeys = "Strip";
     inputSchema.f = undefined;
-    var outputSchema = S$RescriptSchema.object(function (s) {
-          return s.f("data", definition.output);
-        });
-    stripInPlace(outputSchema);
+    let outputSchema = S$RescriptSchema.object(s => s.f("data", definition.output));
+    outputSchema.t.unknownKeys = "Strip";
     outputSchema.f = undefined;
-    var response_status = 200;
-    var response_dataSchema = definition.input;
-    var response = {
+    let response_status = 200;
+    let response_dataSchema = definition.input;
+    let response = {
       status: response_status,
       description: undefined,
       dataSchema: response_dataSchema,
       emptyData: false,
       schema: outputSchema
     };
-    var responsesMap = {};
+    let responsesMap = {};
     responsesMap["200"] = response;
     params$2 = {
       method: "POST",
@@ -264,137 +247,123 @@ function params(route) {
       tags: definition.tags
     };
   } else {
-    var pathItems = [];
-    var pathParams = {};
+    let pathItems = [];
+    let pathParams = {};
     parsePath(definition.path, pathItems, pathParams);
-    var isRawBody = false;
-    var inputSchema$1 = S$RescriptSchema.object(function (s) {
-          return definition.input({
-                      field: (function (fieldName, schema) {
-                          return s.nested("body").f(fieldName, schema);
-                        }),
-                      body: (function (schema) {
-                          if (isNestedFlattenSupported(schema)) {
-                            return s.nested("body").flatten(schema);
-                          } else {
-                            return s.f("body", schema);
-                          }
-                        }),
-                      rawBody: (function (schema) {
-                          var match = schema.t;
-                          var isNonStringBased;
-                          isNonStringBased = typeof match !== "object" ? (
-                              match === "string" ? false : true
-                            ) : (
-                              match.TAG === "literal" && match._0.kind === "String" ? false : true
-                            );
-                          if (isNonStringBased) {
-                            panic("Only string-based schemas are allowed in rawBody", undefined);
-                          }
-                          ((isRawBody = true));
-                          return s.f("body", schema);
-                        }),
-                      header: (function (fieldName, schema) {
-                          return s.nested("headers").f(fieldName.toLowerCase(), coerceSchema(schema));
-                        }),
-                      query: (function (fieldName, schema) {
-                          return s.nested("query").f(fieldName, coerceSchema(schema));
-                        }),
-                      param: (function (fieldName, schema) {
-                          if (!pathParams[fieldName]) {
-                            panic("Path parameter \"" + fieldName + "\" is not defined in the path", undefined);
-                          }
-                          return s.nested("params").f(fieldName, coerceSchema(schema));
-                        }),
-                      auth: (function (auth) {
-                          var tmp;
-                          tmp = auth === "Bearer" ? bearerAuthSchema : basicAuthSchema;
-                          return s.nested("headers").f("authorization", tmp);
-                        })
-                    });
-        });
-    stripInPlace(inputSchema$1);
+    let isRawBody = false;
+    let inputSchema$1 = S$RescriptSchema.object(s => definition.input({
+      field: (fieldName, schema) => s.nested("body").f(fieldName, schema),
+      body: schema => {
+        if (isNestedFlattenSupported(schema)) {
+          return s.nested("body").flatten(schema);
+        } else {
+          return s.f("body", schema);
+        }
+      },
+      rawBody: schema => {
+        let match = schema.t;
+        let isNonStringBased;
+        isNonStringBased = typeof match !== "object" ? match !== "string" : (
+            match.TAG === "literal" ? match._0.kind !== "String" : true
+          );
+        if (isNonStringBased) {
+          panic("Only string-based schemas are allowed in rawBody", undefined);
+        }
+        ((isRawBody = true));
+        return s.f("body", schema);
+      },
+      header: (fieldName, schema) => s.nested("headers").f(fieldName.toLowerCase(), coerceSchema(schema)),
+      query: (fieldName, schema) => s.nested("query").f(fieldName, coerceSchema(schema)),
+      param: (fieldName, schema) => {
+        if (!(fieldName in pathParams)) {
+          panic(`Path parameter "` + fieldName + `" is not defined in the path`, undefined);
+        }
+        return s.nested("params").f(fieldName, coerceSchema(schema));
+      },
+      auth: auth => {
+        let tmp;
+        tmp = auth === "Bearer" ? bearerAuthSchema : basicAuthSchema;
+        return s.nested("headers").f("authorization", tmp);
+      }
+    }));
+    inputSchema$1.t.unknownKeys = "Strip";
     inputSchema$1.f = undefined;
-    var match = getSchemaField(inputSchema$1, "headers");
+    let match = getSchemaField(inputSchema$1, "headers");
     if (match !== undefined) {
-      var schema = match.schema;
-      stripInPlace(schema);
+      let schema = match.schema;
+      schema.t.unknownKeys = "Strip";
       schema.f = undefined;
     }
-    var match$1 = getSchemaField(inputSchema$1, "params");
+    let match$1 = getSchemaField(inputSchema$1, "params");
     if (match$1 !== undefined) {
       match$1.schema.f = undefined;
     }
-    var match$2 = getSchemaField(inputSchema$1, "query");
+    let match$2 = getSchemaField(inputSchema$1, "query");
     if (match$2 !== undefined) {
       match$2.schema.f = undefined;
     }
-    var responsesMap$1 = {};
-    var responses = [];
-    definition.responses.forEach(function (r) {
-          var builder = {
-            emptyData: true
-          };
-          var schema = S$RescriptSchema.object(function (s) {
-                var status = function (status$1) {
-                  builder.status = status$1;
-                  register(responsesMap$1, status$1, builder);
-                  s.tag("status", status$1);
-                };
-                var header = function (fieldName, schema) {
-                  return s.nested("headers").f(fieldName.toLowerCase(), coerceSchema(schema));
-                };
-                var definition = r({
-                      status: status,
-                      description: (function (d) {
-                          builder.description = d;
-                        }),
-                      data: (function (schema) {
-                          builder.emptyData = false;
-                          if (isNestedFlattenSupported(schema)) {
-                            return s.nested("data").flatten(schema);
-                          } else {
-                            return s.f("data", schema);
-                          }
-                        }),
-                      field: (function (fieldName, schema) {
-                          builder.emptyData = false;
-                          return s.nested("data").f(fieldName, schema);
-                        }),
-                      header: header,
-                      redirect: (function (schema) {
-                          status(307);
-                          return header("location", coerceSchema(schema));
-                        })
-                    });
-                if (builder.emptyData) {
-                  s.tag("data", null);
-                }
-                return definition;
-              });
-          if (builder.status === undefined) {
-            register(responsesMap$1, "default", builder);
-          }
-          stripInPlace(schema);
-          schema.f = undefined;
-          var dataSchema = getSchemaField(schema, "data").schema;
-          builder.dataSchema = dataSchema;
-          var match = dataSchema.t;
-          if (typeof match === "object" && match.TAG === "literal") {
-            var dataTypeValidation = dataSchema.f;
-            schema.f = (function (b, inputVar) {
-                return dataTypeValidation(b, inputVar + ".data");
-              });
-          }
-          var match$1 = getSchemaField(schema, "headers");
-          if (match$1 !== undefined) {
-            var schema$1 = match$1.schema;
-            stripInPlace(schema$1);
-            schema$1.f = undefined;
+    let responsesMap$1 = {};
+    let responses = [];
+    definition.responses.forEach(r => {
+      let builder = {
+        emptyData: true
+      };
+      let schema = S$RescriptSchema.object(s => {
+        let status = status$1 => {
+          builder.status = status$1;
+          register(responsesMap$1, status$1, builder);
+          s.tag("status", status$1);
+        };
+        let header = (fieldName, schema) => s.nested("headers").f(fieldName.toLowerCase(), coerceSchema(schema));
+        let definition = r({
+          status: status,
+          description: d => {
+            builder.description = d;
+          },
+          data: schema => {
+            builder.emptyData = false;
+            if (isNestedFlattenSupported(schema)) {
+              return s.nested("data").flatten(schema);
+            } else {
+              return s.f("data", schema);
+            }
+          },
+          field: (fieldName, schema) => {
+            builder.emptyData = false;
+            return s.nested("data").f(fieldName, schema);
+          },
+          header: header,
+          redirect: schema => {
+            status(307);
+            return header("location", coerceSchema(schema));
           }
-          builder.schema = schema;
-          responses.push(builder);
         });
+        if (builder.emptyData) {
+          s.tag("data", null);
+        }
+        return definition;
+      });
+      if (builder.status === undefined) {
+        register(responsesMap$1, "default", builder);
+      }
+      schema.t.unknownKeys = "Strip";
+      schema.f = undefined;
+      let dataSchema = getSchemaField(schema, "data").schema;
+      builder.dataSchema = dataSchema;
+      let match = dataSchema.t;
+      if (typeof match === "object" && match.TAG === "literal") {
+        let dataTypeValidation = dataSchema.f;
+        schema.f = (b, inputVar) => dataTypeValidation(b, inputVar + `.data`);
+      }
+      let match$1 = getSchemaField(schema, "headers");
+      if (match$1 !== undefined) {
+        let schema$1 = match$1.schema;
+        schema$1.t.unknownKeys = "Strip";
+        schema$1.f = undefined;
+      }
+      builder.schema = schema;
+      responses.push(builder);
+    });
     if (responses.length === 0) {
       panic("At least single response should be registered", undefined);
     }
@@ -403,9 +372,7 @@ function params(route) {
       path: definition.path,
       pathItems: pathItems,
       inputSchema: inputSchema$1,
-      outputSchema: S$RescriptSchema.union(responses.map(function (r) {
-                return r.schema;
-              })),
+      outputSchema: S$RescriptSchema.union(responses.map(r => r.schema)),
       responses: responses,
       responsesMap: responsesMap$1,
       isRawBody: isRawBody,
@@ -423,90 +390,84 @@ function params(route) {
 
 function tokeniseValue(key, value, append) {
   if (Array.isArray(value)) {
-    value.forEach(function (v, idx) {
-          tokeniseValue(key + "[" + idx.toString() + "]", v, append);
-        });
-    return ;
+    value.forEach((v, idx) => tokeniseValue(key + `[` + idx.toString() + `]`, v, append));
+    return;
   } else if (value === null) {
     return append(key, "");
   } else if (value === (void 0)) {
-    return ;
+    return;
   } else if (typeof value === "object") {
-    Object.keys(value).forEach(function (k) {
-          tokeniseValue(key + "[" + encodeURIComponent(k) + "]", value[k], append);
-        });
-    return ;
+    Object.keys(value).forEach(k => tokeniseValue(key + `[` + encodeURIComponent(k) + `]`, value[k], append));
+    return;
   } else {
     return append(key, value);
   }
 }
 
 function getCompletePath(baseUrl, pathItems, maybeQuery, maybeParams, jsonQueryOpt) {
-  var jsonQuery = jsonQueryOpt !== undefined ? jsonQueryOpt : false;
-  var path = baseUrl;
-  for(var idx = 0 ,idx_finish = pathItems.length; idx < idx_finish; ++idx){
-    var pathItem = pathItems[idx];
+  let jsonQuery = jsonQueryOpt !== undefined ? jsonQueryOpt : false;
+  let path = baseUrl;
+  for (let idx = 0, idx_finish = pathItems.length; idx < idx_finish; ++idx) {
+    let pathItem = pathItems[idx];
     if (typeof pathItem === "string") {
       path = path + pathItem;
     } else {
-      var name = pathItem.name;
-      var param = maybeParams && maybeParams[name];
+      let name = pathItem.name;
+      let param = maybeParams && maybeParams[name];
       if (param !== undefined) {
         path = path + param;
       } else {
-        panic("Path parameter \"" + name + "\" is not defined in input", undefined);
+        panic(`Path parameter "` + name + `" is not defined in input`, undefined);
       }
     }
   }
   if (maybeQuery !== undefined) {
-    var queryItems = [];
-    var append = function (key, value) {
+    let queryItems = [];
+    let append = (key, value) => {
       queryItems.push(key + "=" + encodeURIComponent(value));
     };
-    var queryNames = Object.keys(maybeQuery);
-    for(var idx$1 = 0 ,idx_finish$1 = queryNames.length; idx$1 < idx_finish$1; ++idx$1){
-      var queryName = queryNames[idx$1];
-      var value = maybeQuery[queryName];
-      var key = encodeURIComponent(queryName);
+    let queryNames = Object.keys(maybeQuery);
+    for (let idx$1 = 0, idx_finish$1 = queryNames.length; idx$1 < idx_finish$1; ++idx$1) {
+      let queryName = queryNames[idx$1];
+      let value = maybeQuery[queryName];
+      let key = encodeURIComponent(queryName);
       if (value !== (void 0)) {
         if (jsonQuery) {
-          append(key, typeof value === "string" && value !== "true" && value !== "false" && value !== "null" && Number.isNaN(Number(value)) ? value : JSON.stringify(value));
+          append(key, typeof value === "string" && value !== "true" && value !== "false" && value !== "null" && Number.isNaN(parseFloat(value)) ? value : JSON.stringify(value));
         } else {
           tokeniseValue(key, value, append);
         }
       }
-      
     }
-    if (queryItems.length > 0) {
+    if (queryItems.length !== 0) {
       path = path + "?" + queryItems.join("&");
     }
-    
   }
   return path;
 }
 
 function url(route, input, baseUrlOpt) {
-  var baseUrl = baseUrlOpt !== undefined ? baseUrlOpt : "";
-  var match = params(route);
-  var data = S$RescriptSchema.reverseConvertOrThrow(input, match.inputSchema);
+  let baseUrl = baseUrlOpt !== undefined ? baseUrlOpt : "";
+  let match = params(route);
+  let data = S$RescriptSchema.reverseConvertOrThrow(input, match.inputSchema);
   return getCompletePath(baseUrl, match.pathItems, data.query, data.params, false);
 }
 
-var $$global = {
+let global = {
   c: undefined
 };
 
-function $$fetch$1(route, input, client) {
-  var match = params(route);
-  var responsesMap = match.responsesMap;
-  var client$1;
+function fetch$1(route, input, client) {
+  let match = params(route);
+  let responsesMap = match.responsesMap;
+  let client$1;
   if (client !== undefined) {
     client$1 = client;
   } else {
-    var client$2 = $$global.c;
-    client$1 = client$2 !== undefined ? client$2 : panic("Client is not set for the " + match.path + " fetch request. Please, use Rest.setGlobalClient or pass a client explicitly to the Rest.fetch arguments", undefined);
+    let client$2 = global.c;
+    client$1 = client$2 !== undefined ? client$2 : panic(`Client is not set for the ` + match.path + ` fetch request. Please, use Rest.setGlobalClient or pass a client explicitly to the Rest.fetch arguments`, undefined);
   }
-  var data = S$RescriptSchema.reverseConvertOrThrow(input, match.inputSchema);
+  let data = S$RescriptSchema.reverseConvertOrThrow(input, match.inputSchema);
   if (data.body !== (void 0)) {
     if (!match.isRawBody) {
       data.body = (JSON.stringify(data["body"]));
@@ -517,68 +478,67 @@ function $$fetch$1(route, input, client) {
     data.headers["content-type"] = "application/json";
   }
   return client$1.fetcher({
-                body: data.body,
-                headers: data.headers,
-                method: match.method,
-                path: getCompletePath(client$1.baseUrl, match.pathItems, data.query, data.params, match.jsonQuery)
-              }).then(function (fetcherResponse) {
-              var responseStatus = fetcherResponse.status;
-              var response = responsesMap[responseStatus] || responsesMap[(responseStatus / 100 | 0) + "XX"] || responsesMap["default"];
-              if (response !== undefined) {
-                try {
-                  return S$RescriptSchema.parseOrThrow(fetcherResponse, response.schema);
-                }
-                catch (raw_error){
-                  var error = Caml_js_exceptions.internalToOCamlException(raw_error);
-                  if (error.RE_EXN_ID === S$RescriptSchema.Raised) {
-                    var error$1 = error._1;
-                    var match = error$1.code;
-                    if (typeof match === "object" && match.TAG === "InvalidType" && error$1.path === S$RescriptSchema.Path.empty) {
-                      return panic("Failed parsing response data. Reason: Expected " + getSchemaField(match.expected, "data").schema.n() + ", received " + match.received.data, undefined);
-                    }
-                    return panic("Failed parsing response at " + error$1.path + ". Reason: " + S$RescriptSchema.$$Error.reason(error$1), {
-                                response: fetcherResponse
-                              });
-                  }
-                  throw error;
-                }
-              } else {
-                var error$2 = "Unexpected response status \"" + fetcherResponse.status.toString() + "\"";
-                if (fetcherResponse.data && typeof fetcherResponse.data.message === "string") {
-                  error$2 = error$2 + ". Message: " + fetcherResponse.data.message;
-                }
-                return panic(error$2, undefined);
-              }
-            });
+    body: data.body,
+    headers: data.headers,
+    method: match.method,
+    path: getCompletePath(client$1.baseUrl, match.pathItems, data.query, data.params, match.jsonQuery)
+  }).then(fetcherResponse => {
+    let responseStatus = fetcherResponse.status;
+    let response = responsesMap[responseStatus] || responsesMap[(responseStatus / 100 | 0) + "XX"] || responsesMap["default"];
+    if (response !== undefined) {
+      try {
+        return S$RescriptSchema.parseOrThrow(fetcherResponse, response.schema);
+      } catch (raw_error) {
+        let error = Primitive_exceptions.internalToException(raw_error);
+        if (error.RE_EXN_ID === S$RescriptSchema.Raised) {
+          let error$1 = error._1;
+          let match = error$1.code;
+          if (typeof match === "object" && match.TAG === "InvalidType" && error$1.path === S$RescriptSchema.Path.empty) {
+            return panic(`Failed parsing response data. Reason: Expected ` + getSchemaField(match.expected, "data").schema.n() + `, received ` + match.received.data, undefined);
+          }
+          return panic(`Failed parsing response at ` + error$1.path + `. Reason: ` + S$RescriptSchema.$$Error.reason(error$1), {
+            response: fetcherResponse
+          });
+        }
+        throw error;
+      }
+    } else {
+      let error$2 = `Unexpected response status "` + fetcherResponse.status.toString() + `"`;
+      if (fetcherResponse.data && typeof fetcherResponse.data.message === "string") {
+        error$2 = error$2 + ". Message: " + fetcherResponse.data.message;
+      }
+      return panic(error$2, undefined);
+    }
+  });
 }
 
 function client(baseUrl, fetcherOpt) {
-  var fetcher = fetcherOpt !== undefined ? fetcherOpt : $$default;
+  let fetcher = fetcherOpt !== undefined ? fetcherOpt : $$default;
   return {
-          baseUrl: baseUrl,
-          fetcher: fetcher
-        };
+    baseUrl: baseUrl,
+    fetcher: fetcher
+  };
 }
 
 function setGlobalClient(baseUrl, fetcher) {
-  var match = $$global.c;
+  let match = global.c;
   if (match !== undefined) {
     return panic("There's already a global client defined. You can have only one global client at a time.", undefined);
   } else {
-    $$global.c = client(baseUrl, fetcher);
-    return ;
+    global.c = client(baseUrl, fetcher);
+    return;
   }
 }
 
-var $$Response = {};
+let Response = {};
 
 export {
-  $$Response ,
-  params ,
-  ApiFetcher ,
-  url ,
-  client ,
-  setGlobalClient ,
-  $$fetch$1 as $$fetch,
+  Response,
+  params,
+  ApiFetcher,
+  url,
+  client,
+  setGlobalClient,
+  fetch$1 as fetch,
 }
 /* bearerAuthSchema Not a pure module */