arri 0.0.6 → 0.0.7

package/dist/codegen.mjs

@@ -1,7 +1,7 @@
-import { u as unflattenObject, p as pascalCase, i as isProcedureDefinition, a as isJsonSchemaScalarType, b as isJsonSchemaNullType, c as isJsonSchemaObject, d as isJsonSchemaEnum, e as isJsonSchemaArray, f as camelCase } from './shared/arri.b4c5ce27.mjs';
-import { f as format2 } from './shared/arri.34695f7b.mjs';
+import { u as unflattenObject, i as isServiceDefinition, p as pascalCase, a as isProcedureDefinition, b as isJsonSchemaScalarType, c as isJsonSchemaNullType, d as isJsonSchemaObject, e as isJsonSchemaEnum, f as isJsonSchemaArray } from './shared/arri.1f1b9dfc.mjs';
+import { d as defineClientGeneratorPlugin, f as format2 } from './shared/arri.0e69fc28.mjs';
+export { k as classListTransformer, j as classTransformer, c as createDartClient, a as dartClientGenerator, g as dartModelFromJsonSchema, i as dartParsedJsonField, e as dartProcedureFromServiceDefinition, h as dartPropertyTypeFromSchema, b as dartServiceFromServiceDefinition, l as isDartType, m as isDartTypeWithNullables, t as transformers } from './shared/arri.0e69fc28.mjs';
 import { writeFileSync } from 'fs';
-import { execSync } from 'child_process';
 import 'module';
 import 'url';
 import 'path';
@@ -12,10 +12,7 @@ import 'assert';
 import 'fs/promises';
 import 'v8';
 import 'util';
-
-function defineClientGeneratorPlugin(plugin) {
-  return plugin;
-}
+import 'child_process';
 
 let createdModels = [];
 const typescriptClientGenerator = defineClientGeneratorPlugin(
@@ -40,14 +37,20 @@ async function createTypescriptClient(def, prefix = "Client") {
   createdModels = [];
   const services = unflattenObject(def.procedures);
   const serviceParts = [];
+  const procedureParts = [];
   const modelParts = [];
   Object.keys(services).forEach((key) => {
-    const serviceName = pascalCase(`${prefix}_${key}_service`);
-    serviceParts.push({
-      name: serviceName,
-      key,
-      content: tsServiceFromServiceDefinition(serviceName, services[key])
-    });
+    const item = services[key];
+    if (isServiceDefinition(item)) {
+      const serviceName = pascalCase(`${prefix}_${key}_service`);
+      serviceParts.push({
+        name: serviceName,
+        key,
+        content: tsServiceFromServiceDefinition(serviceName, item)
+      });
+      return;
+    }
+    procedureParts.push(tsRpcFromProcedureDefinition(key, item));
   });
   Object.keys(def.models).forEach((key) => {
     const modelName = pascalCase(`${key}`);
@@ -61,12 +64,18 @@ async function createTypescriptClient(def, prefix = "Client") {
     import { arriRequest, ArriRequestError } from 'arri-client';
     
     export class ${prefix} {
+        private baseUrl: string;
+        private headers: Record<string, string>;
         ${serviceParts.map((service) => `${service.key}: ${service.name}`).join("\n")}
         constructor(opts: { baseUrl?: string; headers?: Record<string, string> }) {
+            this.baseUrl = opts.baseUrl ?? "";
+            this.headers = opts.headers ?? {};
             ${serviceParts.map(
       (service) => `this.${service.key} = new ${service.name}(opts);`
     ).join("\n")}
         }
+
+        ${procedureParts.join("\n")}
     }
 
     ${serviceParts.map((service) => service.content).join("\n")}
@@ -225,602 +234,4 @@ function tsInterfaceScalarField(key, prop, isOptional = false) {
   }
 }
 
-const dartClientGenerator = defineClientGeneratorPlugin(
-  (options) => {
-    return {
-      generator: async (def) => {
-        if (!options.clientName) {
-          throw new Error(
-            'Missing "clientName" cannot generate dart client'
-          );
-        }
-        if (!options.outputFile) {
-          throw new Error(
-            'Missing "outputFile" cannot generate dart client'
-          );
-        }
-        const result = createDartClient(def, options.clientName);
-        writeFileSync(options.outputFile, result);
-        execSync(`dart format ${options.outputFile}`);
-      },
-      options
-    };
-  }
-);
-const generatedModels = [];
-function createDartClient(appDef, prefix = "Client") {
-  const { models, procedures } = appDef;
-  const serviceParts = [];
-  const services = unflattenObject(procedures);
-  Object.keys(services).forEach((k) => {
-    const service = services[k];
-    const serviceName = pascalCase(`$_${prefix}_${k}_service`);
-    serviceParts.push({
-      name: serviceName,
-      key: k,
-      content: dartServiceFromServiceDefinition(
-        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-        serviceName,
-        service,
-        prefix
-      )
-    });
-  });
-  const endpoints = {};
-  Object.keys(procedures).forEach((key) => {
-    const rpc = procedures[key];
-    endpoints[rpc.path] = rpc.method;
-  });
-  const modelParts = [];
-  Object.keys(models).forEach((key) => {
-    const model = models[key];
-    const typeName = `${prefix}${pascalCase(key)}`;
-    const objModel = model;
-    if (!generatedModels.includes(typeName)) {
-      modelParts.push(
-        dartModelFromJsonSchema(
-          `${prefix}${pascalCase(key)}`,
-          objModel
-        )
-      );
-      generatedModels.push(typeName);
-    }
-  });
-  return `// This code was autogenerated by arri. Do not modify directly.
-import "dart:convert";
-import "package:http/http.dart" as http;
-import "package:arri_client/arri_client.dart";
-
-class ${prefix} {
-  final String _baseUrl;
-  final Map<String, String> _headers;
-  const ${prefix}({
-    String baseUrl = "",
-    Map<String, String> headers = const {},
-  }): _headers = headers,
-    _baseUrl = baseUrl;
-  ${prefix} withHeaders(Map<String, String> headers) {
-    return ${prefix}(
-      baseUrl: _baseUrl,
-      headers: headers,
-    );
-  }
-  ${serviceParts.map(
-    (service) => `${service.name} get ${service.key} {
-    return ${service.name}(
-      baseUrl: _baseUrl, headers: _headers,
-    );
-  }`
-  ).join("\n  ")}
-  Future<http.Response> rawRequest(
-    ${prefix}Endpoints endpoint, {
-    Map<String, String>? query,
-    dynamic body,
-    Map<String, String>? headers,
-    Encoding? encoding,
-  }) async {
-    return arriRequest(
-      "$_baseUrl\${endpoint.path}",
-      method: endpoint.method,
-      headers: headers ?? this._headers,
-      body: body,
-      query: query,
-      encoding: encoding,
-    );
-  }
-}
-${serviceParts.map((item) => item.content).join("\n")}
-${modelParts.join("\n")}
-
-enum ${prefix}Endpoints implements Comparable<${prefix}Endpoints>, ArriEndpoint {
-  ${Object.keys(endpoints).map(
-    (key) => `${camelCase(key.split("/").join("_"))}(
-        path: "${key}",
-        method: HttpMethod.${endpoints[key]},
-      )`
-  ).join(",\n  ")};
-
-  const ${prefix}Endpoints({
-    required this.path, required this.method,
-  });
-  @override
-  final String path;
-  @override
-  final HttpMethod method;
-
-  @override
-  compareTo(${prefix}Endpoints other) => name.compareTo(other.name);
-}`;
-}
-function dartServiceFromServiceDefinition(name, def, prefix = "") {
-  const rpcParts = [];
-  const subServiceParts = [];
-  const serviceName = `${name}`;
-  Object.keys(def).forEach((key) => {
-    const item = def[key];
-    if (isProcedureDefinition(item)) {
-      let returnType = `Future<String>`;
-      let returnTypeName = "String";
-      if (item.response) {
-        returnType = `Future<${prefix}${item.response}>`;
-        returnTypeName = `${prefix}${item.response}`;
-      } else {
-        returnType = "Future<void>";
-      }
-      let paramsInput = "";
-      if (item.params) {
-        paramsInput = `${prefix}${item.params} params`;
-      }
-      let responseParser = "(body) => body;";
-      switch (returnType) {
-        case "Future<String>":
-          break;
-        case "Future<int>":
-          responseParser = `(body) => Int.parse(body)`;
-          break;
-        case "Future<double>":
-          responseParser = `(body) => Double.parse(body)`;
-          break;
-        case "Future<void>":
-          responseParser = `(body) {}`;
-          break;
-        case "Future<bool>":
-          responseParser = `(body) {
-                        switch(body) {
-                            case "true":
-                            case "1":
-                                return true;
-                            case "false":
-                            case "0":
-                            default:
-                                return false;
-                        }
-                    }`;
-          break;
-        default:
-          responseParser = `(body) => ${returnTypeName}.fromJson(json.decode(body))`;
-          break;
-      }
-      rpcParts.push(`${returnType} ${key}(${paramsInput}) {
-    return parsedArriRequest(
-      "$_baseUrl${item.path}",
-      method: HttpMethod.${item.method},
-      headers: _headers,
-      params: ${paramsInput.length ? `params.toJson()` : "null"},
-      parser: ${responseParser},
-    );
-  }`);
-      return;
-    }
-    const subServiceName = pascalCase(`${name}_${key}_Service`);
-    const subService = dartServiceFromServiceDefinition(
-      pascalCase(`${name}_${key}_Service`),
-      item,
-      prefix
-    );
-    subServiceParts.push({
-      name: subServiceName,
-      key,
-      content: subService
-    });
-  });
-  return `class ${serviceName} {
-  final String _baseUrl;
-  final Map<String, String> _headers;
-  const ${serviceName}({
-    String baseUrl = "",
-    Map<String, String> headers = const {},
-  }): _baseUrl = baseUrl,
-  _headers = headers;
-  ${subServiceParts.map(
-    (sub) => `${sub.name} get ${sub.key} {
-    return ${sub.name}(
-        baseUrl: _baseUrl,
-        headers: _headers,
-    );
-  }`
-  ).join("\n")}
-  ${rpcParts.join("\n  ")}
-}
-${subServiceParts.map((sub) => sub.content).join("\n")}
-`;
-}
-function dartModelFromJsonSchema(name, schema) {
-  const fields = [];
-  const subModelParts = [];
-  Object.entries(schema.properties ?? {}).forEach(([key, val]) => {
-    if (typeof val !== "object") {
-      return;
-    }
-    const [dartType, subTypes] = dartPropertyTypeFromSchema(
-      name,
-      key,
-      schema
-    );
-    if (subTypes?.length) {
-      for (const sub of subTypes) {
-        subModelParts.push(sub);
-      }
-    }
-    fields.push({ type: dartType, name: key });
-    if (!isDartType(dartType) && "type" in val && val.type === "object") {
-      subModelParts.push(
-        dartModelFromJsonSchema(dartType.replace("?", ""), val)
-      );
-    }
-  });
-  return `class ${name} {
-  ${fields.map((field) => `final ${field.type} ${field.name};`).join("\n  ")}
-  const ${name}({
-    ${fields.map(
-    (field) => field.type.includes("?") ? `this.${field.name},` : `required this.${field.name},`
-  ).join("\n    ")}
-  });
-  factory ${name}.fromJson(Map<String, dynamic> json) {
-    return ${name}(
-      ${fields.map((field) => `${dartParsedJsonField(field.name, field.type)},`).join("\n      ")}
-    );
-  }
-  Map<String, dynamic> toJson() {
-    return {
-      ${fields.map((field) => {
-    const isNullable = field.type.endsWith("?");
-    const typeName = field.type.replace("?", "");
-    if (isDartTypeWithNullables(field.type)) {
-      const transformer = transformers[typeName];
-      return transformer.toJsonBody(field.name, isNullable);
-    }
-    if (field.type.includes("List<")) {
-      return classListTransformer(typeName).toJsonBody(
-        field.name,
-        isNullable
-      );
-    }
-    return classTransformer(typeName, isNullable).toJsonBody(
-      field.name,
-      isNullable
-    );
-  }).join(",\n      ")},
-    };
-  }
-  ${name} copyWith({
-    ${fields.map((field) => `${field.type.replace("?", "")}? ${field.name},`).join("\n    ")}
-  }) {
-    return ${name}(
-      ${fields.map((field) => `${field.name}: ${field.name} ?? this.${field.name},`).join("\n      ")}
-    );
-  }
-}
-
-${subModelParts.join("\n")}`;
-}
-function dartPropertyTypeFromSchema(objectName, propertyName, schema) {
-  const prop = schema.properties?.[propertyName];
-  const isOptional = !schema.required?.includes(propertyName);
-  let finalType = "";
-  const subTypes = [];
-  if (isJsonSchemaEnum(prop)) {
-    const enumName = pascalCase(`${objectName}_${propertyName}`);
-    finalType = isOptional ? `${enumName}?` : enumName;
-    const options = [];
-    for (const opt of prop.anyOf) {
-      if (opt.type === "string") {
-        options.push({
-          name: opt.const.toString(),
-          type: "String",
-          value: opt.const
-        });
-      }
-      if (opt.type === "number" || opt.type === "integer") {
-        options.push({
-          name: camelCase(
-            `num_${opt.const}`.split(".").join("Point")
-          ),
-          type: opt.type === "number" ? "double" : "int",
-          value: opt.const
-        });
-      }
-    }
-    subTypes.push(`enum ${enumName} implements Comparable<${enumName}> {
-  ${options.map(
-      (opt) => `${opt.name}(${opt.type === "String" ? `"${opt.value}"` : opt.value})`
-    ).join(",\n  ")};
-  const ${enumName}(this.value);
-  final dynamic value;
-
-  @override
-  compareTo(${enumName} other) => name.compareTo(other.name);
-
-  factory ${enumName}.fromJson(dynamic input) {
-    for(final val in values) {
-      if(val.value == input) {
-        return val;
-      }
-    }
-    return ${options[0].name};
-  }
-
-  dynamic toJson() {
-    return value;
-  }
-}`);
-    return [finalType, subTypes];
-  }
-  if (isJsonSchemaNullType(prop)) {
-    finalType = "null";
-    return [finalType, subTypes];
-  }
-  if (isJsonSchemaScalarType(prop)) {
-    switch (prop.type) {
-      case "string":
-        finalType = isOptional ? "String?" : "String";
-        break;
-      case "integer":
-        finalType = isOptional ? "int?" : "int";
-        break;
-      case "number":
-        finalType = isOptional ? "double?" : "double";
-        break;
-      case "Date":
-        finalType = isOptional ? "DateTime?" : "DateTime";
-        break;
-      case "boolean":
-        finalType = isOptional ? "bool?" : "bool";
-        break;
-    }
-  }
-  if (isJsonSchemaObject(prop)) {
-    const joinedPropName = pascalCase(
-      `${objectName}_${propertyName}`
-    );
-    finalType = isOptional ? `${joinedPropName}?` : joinedPropName;
-  }
-  if (isJsonSchemaArray(prop)) {
-    const item = prop.items;
-    const type = item.type;
-    if (typeof type !== "string") {
-      throw new Error(
-        "Union types are not supported in arrays at this time"
-      );
-    }
-    switch (type) {
-      case "string":
-        finalType = isOptional ? "List<String>?" : "List<String>";
-        break;
-      case "integer":
-        finalType = isOptional ? "List<int>?" : "List<int>";
-        break;
-      case "number":
-        finalType = isOptional ? "List<double>?" : "List<double>";
-        break;
-      case "null":
-        finalType = isOptional ? "List<null>?" : "List<null>";
-        break;
-      case "boolean":
-        finalType = isOptional ? "List<bool>?" : "List<bool>";
-        break;
-      case "Date":
-        finalType = isOptional ? "List<DateTime>?" : "List<DateTime>";
-        break;
-      case "object": {
-        const subTypeName = item.$id ?? pascalCase(`${objectName}_${propertyName}_item`);
-        const model = dartModelFromJsonSchema(subTypeName, item);
-        if (!generatedModels.includes(subTypeName)) {
-          subTypes.push(model);
-          generatedModels.push(subTypeName);
-        }
-        finalType = isOptional ? `List<${subTypeName}>?` : `List<${subTypeName}>`;
-        break;
-      }
-    }
-  }
-  return [finalType, subTypes.length ? subTypes : void 0];
-}
-function dartParsedJsonField(fieldName, dartType) {
-  if (isDartTypeWithNullables(dartType)) {
-    switch (dartType) {
-      case "String":
-        return transformers.String.fromJsonBody(fieldName, '""');
-      case "String?":
-        return transformers.String.fromJsonBody(fieldName, "null");
-      case "bool":
-        return transformers.bool.fromJsonBody(fieldName, "false");
-      case "double":
-        return transformers.double.fromJsonBody(fieldName, "0.0");
-      case "int":
-        return transformers.int.fromJsonBody(fieldName, "0");
-      case "null":
-        return transformers.null.fromJsonBody(fieldName, "");
-      case "DateTime":
-        return transformers.DateTime.fromJsonBody(
-          fieldName,
-          "DateTime(0)"
-        );
-      case "DateTime?":
-        return transformers.DateTime.fromJsonBody(fieldName, "null");
-      case "List<String>":
-      case "List<bool>":
-      case "List<double>":
-      case "List<int>":
-      case "List<null>":
-        return defaultListFromJsonBody(
-          fieldName,
-          dartType.replace("List<", "").replace(">", ""),
-          "[]"
-        );
-      default:
-        return `${fieldName}: json["${fieldName}"] is ${dartType.replace(
-          "?",
-          ""
-        )} ? json["${fieldName}"] : null`;
-    }
-  }
-  if (dartType.includes("List<")) {
-    const innerType = dartType.replace("List<", "").replace(">", "").replace("?", "");
-    return classListTransformer(innerType).fromJsonBody(
-      fieldName,
-      dartType.endsWith("?") ? "null" : "[]"
-    );
-  }
-  const classType = dartType.split("?").join("").trim();
-  return classTransformer(classType, dartType.endsWith("?")).fromJsonBody(
-    fieldName,
-    classType
-  );
-}
-const dartTypeMap = {
-  integer: "int",
-  bigint: "int",
-  number: "double",
-  string: "String",
-  boolean: "bool",
-  null: "null",
-  Date: "DateTime",
-  object: void 0,
-  list: void 0,
-  // eslint-disable-next-line object-shorthand
-  undefined: void 0,
-  array: void 0,
-  Uint8Array: "Uint8List"
-};
-const transformers = {
-  null: {
-    fromJsonBody: (_) => `null`,
-    toJsonBody: defaultToJsonBody
-  },
-  int: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "int", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  double: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "double", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  String: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "String", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  bool: {
-    fromJsonBody: (key, fallback) => defaultFromJsonBody(key, "bool", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  DateTime: {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is String ? DateTime.parse(json["${key}"]) : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toIso8601String()`
-  },
-  "List<null>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "null", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<int>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "int", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<double>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "double", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<String>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "String", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<bool>": {
-    fromJsonBody: (key, fallback) => defaultListFromJsonBody(key, "bool", fallback),
-    toJsonBody: defaultToJsonBody
-  },
-  "List<DateTime>": {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List<String> ?
-            (json["${key}"] as List<String>)
-                .map((item) => DateTime.parse(item)).toList() : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toIso8601String()).toList()`
-  },
-  Uint8List: {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List ? Uint8List.fromList(json["${key}"]) : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toList()`
-  },
-  "List<Uint8List>": {
-    fromJsonBody: (key, fallback) => `${key}: json["${key}"] is List && (json["${key}"] as List).isNotEmpty && (json["${key}"] as List).first is List ? json["${key}"] : ${fallback}`,
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toList()).toList()`
-  }
-};
-function defaultFromJsonBody(key, typename, fallback) {
-  return `${key}: json["${key}"] is ${typename} ? json["${key}"] : ${fallback}`;
-}
-function defaultListFromJsonBody(key, typename, fallback) {
-  return `${key}: json["${key}"] is List<${typename}> ? json["${key}"] : ${fallback}`;
-}
-function defaultToJsonBody(key) {
-  return `"${key}": ${key}`;
-}
-const classTransformer = (typename, nullable) => {
-  return {
-    fromJsonBody: (key, fallback) => {
-      if (nullable) {
-        return `${key}: json["${key}"] is Map<String, dynamic> ? 
-                ${typename}.fromJson(json["${key}"]) : null`;
-      }
-      return `${key}: ${typename}.fromJson(json["${key}"])`;
-    },
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.toJson()`
-  };
-};
-const classListTransformer = (typename) => {
-  return {
-    fromJsonBody: (key, fallback) => {
-      return `${key}: json["${key}"] is List<Map<String, dynamic>> ? 
-                (json["${key}"] as List<Map<String, dynamic>>)
-                    .map((val) => ${typename}.fromJson(val)).toList() : ${fallback}`;
-    },
-    toJsonBody: (key, isNullable) => `"${key}": ${key}${isNullable ? "?" : ""}.map((val) => val.toJson()).toList()`
-  };
-};
-function isDartType(input) {
-  if (typeof input !== "string") {
-    return false;
-  }
-  for (const val of Object.values(dartTypeMap)) {
-    if (input === val) {
-      return true;
-    }
-    if (input.replace("List<", "").replace(">", "") === val) {
-      return true;
-    }
-  }
-  return false;
-}
-function isDartTypeWithNullables(input) {
-  if (typeof input !== "string") {
-    return false;
-  }
-  for (const val of Object.values(dartTypeMap)) {
-    if (input.replace("?", "") === val) {
-      return true;
-    }
-    if (input.replace("?", "").replace("List<", "").replace(">", "") === val) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export { classListTransformer, classTransformer, createDartClient, createTypescriptClient, dartClientGenerator, dartModelFromJsonSchema, dartParsedJsonField, dartPropertyTypeFromSchema, dartServiceFromServiceDefinition, defineClientGeneratorPlugin, isDartType, isDartTypeWithNullables, transformers, tsModelFromDefinition, tsRpcFromProcedureDefinition, tsServiceFromServiceDefinition, typescriptClientGenerator };
+export { createTypescriptClient, defineClientGeneratorPlugin, tsModelFromDefinition, tsRpcFromProcedureDefinition, tsServiceFromServiceDefinition, typescriptClientGenerator };

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const index = require('./shared/arri.d77f4d0e.cjs');
+const index = require('./shared/arri.8e602d87.cjs');
 
 
 

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-export { d as ArriProcedure, c as ArriProcedureBase, g as ArriProcedureHandler, h as ArriProcedurePostHandler, q as ArriRoute, v as ArriRouteHandler, y as ArriRoutePostHandler, A as ArriServer, a as ArriService, E as ExtractParam, u as ExtractParams, e as HandlerContext, b as HttpMethod, H as HttpMethodValues, M as Middleware, w as RouteHandlerContext, x as RoutePostHandlerContext, R as RpcHandlerContext, f as RpcPostHandlerContext, l as createRpcDefinition, t as defineMiddleware, s as defineRoute, k as defineRpc, o as getRpcParamDefinition, n as getRpcParamName, m as getRpcPath, p as getRpcResponseName, i as isHttpMethod, j as isRpc, z as registerRoute, r as registerRpc } from './shared/arri.c20aaf19.cjs';
+export { d as ArriProcedure, c as ArriProcedureBase, g as ArriProcedureHandler, h as ArriProcedurePostHandler, q as ArriRoute, v as ArriRouteHandler, y as ArriRoutePostHandler, A as ArriServer, a as ArriService, E as ExtractParam, u as ExtractParams, e as HandlerContext, b as HttpMethod, H as HttpMethodValues, M as Middleware, w as RouteHandlerContext, x as RoutePostHandlerContext, R as RpcHandlerContext, f as RpcPostHandlerContext, l as createRpcDefinition, t as defineMiddleware, s as defineRoute, k as defineRpc, o as getRpcParamDefinition, n as getRpcParamName, m as getRpcPath, p as getRpcResponseName, i as isHttpMethod, j as isRpc, z as registerRoute, r as registerRpc } from './shared/arri.2ff96786.cjs';
 import * as _sinclair_typebox from '@sinclair/typebox';
 import { Static } from '@sinclair/typebox';
 import { ValueError } from '@sinclair/typebox/errors';

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-export { d as ArriProcedure, c as ArriProcedureBase, g as ArriProcedureHandler, h as ArriProcedurePostHandler, q as ArriRoute, v as ArriRouteHandler, y as ArriRoutePostHandler, A as ArriServer, a as ArriService, E as ExtractParam, u as ExtractParams, e as HandlerContext, b as HttpMethod, H as HttpMethodValues, M as Middleware, w as RouteHandlerContext, x as RoutePostHandlerContext, R as RpcHandlerContext, f as RpcPostHandlerContext, l as createRpcDefinition, t as defineMiddleware, s as defineRoute, k as defineRpc, o as getRpcParamDefinition, n as getRpcParamName, m as getRpcPath, p as getRpcResponseName, i as isHttpMethod, j as isRpc, z as registerRoute, r as registerRpc } from './shared/arri.c20aaf19.mjs';
+export { d as ArriProcedure, c as ArriProcedureBase, g as ArriProcedureHandler, h as ArriProcedurePostHandler, q as ArriRoute, v as ArriRouteHandler, y as ArriRoutePostHandler, A as ArriServer, a as ArriService, E as ExtractParam, u as ExtractParams, e as HandlerContext, b as HttpMethod, H as HttpMethodValues, M as Middleware, w as RouteHandlerContext, x as RoutePostHandlerContext, R as RpcHandlerContext, f as RpcPostHandlerContext, l as createRpcDefinition, t as defineMiddleware, s as defineRoute, k as defineRpc, o as getRpcParamDefinition, n as getRpcParamName, m as getRpcPath, p as getRpcResponseName, i as isHttpMethod, j as isRpc, z as registerRoute, r as registerRpc } from './shared/arri.2ff96786.mjs';
 import * as _sinclair_typebox from '@sinclair/typebox';
 import { Static } from '@sinclair/typebox';
 import { ValueError } from '@sinclair/typebox/errors';