@congruent-stack/congruent-api 0.3.3 → 0.6.0

package/dist/index.cjs

@@ -1,7 +1,710 @@
 'use strict';
 
-function getHelloWorldMessage(name) {
-  return `congruent-api: Hello, ${name}!`;
+function endpoint(definition) {
+  return new HttpMethodEndpoint(definition);
+}
+class HttpMethodEndpoint {
+  _definition;
+  get definition() {
+    return this._definition;
+  }
+  _pathSegments = [];
+  get pathSegments() {
+    return this._pathSegments;
+  }
+  _cachedGenericPath = null;
+  get genericPath() {
+    if (!this._cachedGenericPath) {
+      this._cachedGenericPath = `/${this._pathSegments.join("/")}`;
+    }
+    return this._cachedGenericPath;
+  }
+  _method = null;
+  get method() {
+    return this._method;
+  }
+  get lowerCasedMethod() {
+    return this._method.toLowerCase();
+  }
+  constructor(definition) {
+    this._definition = definition;
+  }
+  /** @internal */
+  _cloneWith(path, method) {
+    const result = new HttpMethodEndpoint({
+      headers: !!this._definition.headers ? this._definition.headers.clone() : void 0,
+      query: !!this._definition.query ? this._definition.query.clone() : void 0,
+      body: !!this._definition.body ? this._definition.body.clone() : void 0,
+      responses: Object.fromEntries(
+        Object.entries(this._definition.responses).map(([status, response]) => [
+          status,
+          response._clone()
+        ])
+      )
+    });
+    result._pathSegments = path;
+    result._method = method;
+    return result;
+  }
+}
+
+function apiContract(definition) {
+  return new ApiContract(definition);
+}
+function isApiContractDefinition(obj) {
+  return typeof obj === "object" && obj !== null && !Array.isArray(obj) && Object.values(obj).every(
+    (value) => value instanceof HttpMethodEndpoint || isApiContractDefinition(value)
+  );
+}
+class ApiContract {
+  definition;
+  constructor(definition) {
+    this.definition = definition;
+  }
+  cloneInitDef() {
+    return ApiContract._deepCloneInitDef(this.definition, []);
+  }
+  static _deepCloneInitDef(definition, path) {
+    const result = {};
+    for (const key in definition) {
+      const value = definition[key];
+      if (value instanceof HttpMethodEndpoint) {
+        result[key] = value._cloneWith(path, key);
+      } else if (isApiContractDefinition(value)) {
+        result[key] = ApiContract._deepCloneInitDef(value, [...path, key]);
+      }
+    }
+    return result;
+  }
+}
+
+function response(definition) {
+  return new HttpMethodEndpointResponse(definition);
+}
+class HttpMethodEndpointResponse {
+  _definition;
+  get definition() {
+    return this._definition;
+  }
+  constructor(definition) {
+    this._definition = definition;
+  }
+  /** @internal */
+  _clone() {
+    return new HttpMethodEndpointResponse(this._definition);
+  }
+}
+
+var HttpStatusCode = /* @__PURE__ */ ((HttpStatusCode2) => {
+  HttpStatusCode2[HttpStatusCode2["Continue_100"] = 100] = "Continue_100";
+  HttpStatusCode2[HttpStatusCode2["SwitchingProtocols_101"] = 101] = "SwitchingProtocols_101";
+  HttpStatusCode2[HttpStatusCode2["OK_200"] = 200] = "OK_200";
+  HttpStatusCode2[HttpStatusCode2["Created_201"] = 201] = "Created_201";
+  HttpStatusCode2[HttpStatusCode2["Accepted_202"] = 202] = "Accepted_202";
+  HttpStatusCode2[HttpStatusCode2["NoContent_204"] = 204] = "NoContent_204";
+  HttpStatusCode2[HttpStatusCode2["MultipleChoices_300"] = 300] = "MultipleChoices_300";
+  HttpStatusCode2[HttpStatusCode2["MovedPermanently_301"] = 301] = "MovedPermanently_301";
+  HttpStatusCode2[HttpStatusCode2["Found_302"] = 302] = "Found_302";
+  HttpStatusCode2[HttpStatusCode2["SeeOther_303"] = 303] = "SeeOther_303";
+  HttpStatusCode2[HttpStatusCode2["NotModified_304"] = 304] = "NotModified_304";
+  HttpStatusCode2[HttpStatusCode2["BadRequest_400"] = 400] = "BadRequest_400";
+  HttpStatusCode2[HttpStatusCode2["Unauthorized_401"] = 401] = "Unauthorized_401";
+  HttpStatusCode2[HttpStatusCode2["Forbidden_403"] = 403] = "Forbidden_403";
+  HttpStatusCode2[HttpStatusCode2["NotFound_404"] = 404] = "NotFound_404";
+  HttpStatusCode2[HttpStatusCode2["Conflict_409"] = 409] = "Conflict_409";
+  HttpStatusCode2[HttpStatusCode2["InternalServerError_500"] = 500] = "InternalServerError_500";
+  HttpStatusCode2[HttpStatusCode2["NotImplemented_501"] = 501] = "NotImplemented_501";
+  HttpStatusCode2[HttpStatusCode2["BadGateway_502"] = 502] = "BadGateway_502";
+  HttpStatusCode2[HttpStatusCode2["ServiceUnavailable_503"] = 503] = "ServiceUnavailable_503";
+  HttpStatusCode2[HttpStatusCode2["GatewayTimeout_504"] = 504] = "GatewayTimeout_504";
+  return HttpStatusCode2;
+})(HttpStatusCode || {});
+function isHttpStatusCode(value) {
+  return value in HttpStatusCode;
+}
+
+function isHttpResponseObject(obj) {
+  return obj !== null && typeof obj === "object" && "code" in obj && isHttpStatusCode(obj.code);
+}
+
+class MethodEndpointHandlerRegistryEntry {
+  _methodEndpoint;
+  get methodEndpoint() {
+    return this._methodEndpoint;
+  }
+  _dicontainer;
+  get dicontainer() {
+    return this._dicontainer;
+  }
+  constructor(methodEndpoint, dicontainer) {
+    this._methodEndpoint = methodEndpoint;
+    this._dicontainer = dicontainer;
+  }
+  _handler = null;
+  get handler() {
+    return this._handler;
+  }
+  register(handler) {
+    this._handler = handler;
+    if (this._onHandlerRegisteredCallback) {
+      this._onHandlerRegisteredCallback(this);
+    }
+  }
+  _onHandlerRegisteredCallback = null;
+  _onHandlerRegistered(callback) {
+    this._onHandlerRegisteredCallback = callback;
+  }
+  prepare(callback) {
+    callback(this);
+    return this;
+  }
+  _injection = (_dicontainer) => ({});
+  get injection() {
+    return this._injection;
+  }
+  inject(injection) {
+    this._injection = injection;
+    return this;
+  }
+  async trigger(data) {
+    if (!this._handler) {
+      throw new Error("Handler not set for this endpoint");
+    }
+    let badRequestResponse = null;
+    const headers = parseRequestDefinitionField(this._methodEndpoint.definition, "headers", data);
+    if (isHttpResponseObject(headers)) {
+      badRequestResponse = headers;
+      return badRequestResponse;
+    }
+    const query = parseRequestDefinitionField(this._methodEndpoint.definition, "query", data);
+    if (isHttpResponseObject(query)) {
+      badRequestResponse = query;
+      return badRequestResponse;
+    }
+    const body = parseRequestDefinitionField(this._methodEndpoint.definition, "body", data);
+    if (isHttpResponseObject(body)) {
+      badRequestResponse = body;
+      return badRequestResponse;
+    }
+    const path = `/${this._methodEndpoint.pathSegments.map(
+      (segment) => segment.startsWith(":") ? data.pathParams[segment.slice(1)] ?? "?" : segment
+    ).join("/")}`;
+    return await this._handler({
+      method: this._methodEndpoint.method,
+      path,
+      genericPath: this._methodEndpoint.genericPath,
+      pathSegments: this._methodEndpoint.pathSegments,
+      headers,
+      pathParams: data.pathParams,
+      query,
+      body,
+      injected: this._injection(this._dicontainer.createScope())
+    });
+  }
+}
+function parseRequestDefinitionField(definition, key, data) {
+  if (definition[key]) {
+    if (!(key in data) || data[key] === null || data[key] === void 0) {
+      if (!definition[key].safeParse(data[key]).success) {
+        return {
+          code: HttpStatusCode.BadRequest_400,
+          body: `'${key}' is required for this endpoint` + (key === "body" ? ", { 'Content-Type': 'application/json' } header might be missing" : "")
+        };
+      }
+      return null;
+    }
+    const result = definition[key].safeParse(data[key]);
+    if (!result.success) {
+      return {
+        code: HttpStatusCode.BadRequest_400,
+        body: result.error.issues
+      };
+    }
+    return result.data ?? null;
+  }
+  return null;
+}
+
+function middleware(apiReg, path) {
+  const reg = apiReg._middlewareRegistry;
+  const entry = new MiddlewareHandlersRegistryEntry(
+    reg,
+    path
+  );
+  return entry;
+}
+class MiddlewareHandlersRegistryEntryInternal {
+  _dicontainer;
+  _middlewareGenericPath;
+  get genericPath() {
+    return this._middlewareGenericPath;
+  }
+  _splitMiddlewarePath() {
+    const splitResult = this._middlewareGenericPath.split(" ");
+    let method = "";
+    let pathSegments = [];
+    if (splitResult.length === 2) {
+      method = splitResult[0].trim();
+      if (method === "") {
+        throw new Error(`Invalid middleware path format: "${this._middlewareGenericPath}". HTTP method is empty.`);
+      }
+      pathSegments = splitResult[1].split("/").map((segment) => segment.trim()).filter((segment) => segment !== "");
+    }
+    return {
+      method,
+      pathSegments
+    };
+  }
+  _inputSchemas;
+  _handler;
+  constructor(diContainer, middlewarePath, inputSchemas, injection, handler) {
+    this._dicontainer = diContainer;
+    this._middlewareGenericPath = middlewarePath;
+    this._inputSchemas = inputSchemas;
+    this._injection = injection;
+    this._handler = handler;
+  }
+  _injection = (_dicontainer) => ({});
+  async trigger(data, next) {
+    let badRequestResponse = null;
+    const headers = middlewareParseRequestDefinitionField(this._inputSchemas, "headers", data);
+    if (isHttpResponseObject(headers)) {
+      badRequestResponse = headers;
+      return badRequestResponse;
+    }
+    const query = middlewareParseRequestDefinitionField(this._inputSchemas, "query", data);
+    if (isHttpResponseObject(query)) {
+      badRequestResponse = query;
+      return badRequestResponse;
+    }
+    const body = middlewareParseRequestDefinitionField(this._inputSchemas, "body", data);
+    if (isHttpResponseObject(body)) {
+      badRequestResponse = body;
+      return badRequestResponse;
+    }
+    const { method, pathSegments } = this._splitMiddlewarePath();
+    const path = `/${pathSegments.map(
+      (segment) => segment.startsWith(":") ? data.pathParams[segment.slice(1)] ?? "?" : segment
+    ).join("/")}`;
+    return await this._handler({
+      method,
+      // TODO: might be empty, as middleware can be registered with path only, without method, possible fix: take it from express.request.method
+      path,
+      genericPath: this.genericPath,
+      pathSegments,
+      headers,
+      pathParams: data.pathParams,
+      query,
+      body,
+      injected: this._injection(this._dicontainer.createScope())
+    }, next);
+  }
+}
+class MiddlewareHandlersRegistryEntry {
+  _registry;
+  _path;
+  constructor(registry, path) {
+    this._registry = registry;
+    this._path = path;
+  }
+  _injection = (_dicontainer) => ({});
+  get injection() {
+    return this._injection;
+  }
+  inject(injection) {
+    this._injection = injection;
+    return this;
+  }
+  register(inputSchemas, handler) {
+    const internalEntry = new MiddlewareHandlersRegistryEntryInternal(
+      this._registry.dicontainer,
+      this._path,
+      inputSchemas,
+      this._injection,
+      handler
+    );
+    this._registry.register(internalEntry);
+  }
+}
+class MiddlewareHandlersRegistry {
+  dicontainer;
+  constructor(dicontainer, callback) {
+    this.dicontainer = dicontainer;
+    this._onHandlerRegisteredCallback = callback;
+  }
+  register(entry) {
+    if (this._onHandlerRegisteredCallback) {
+      this._onHandlerRegisteredCallback(entry);
+    }
+  }
+  _onHandlerRegisteredCallback = null;
+  _onHandlerRegistered(callback) {
+    this._onHandlerRegisteredCallback = callback;
+  }
+}
+function middlewareParseRequestDefinitionField(inputSchemas, key, data) {
+  if (inputSchemas[key]) {
+    if (!(key in data) || data[key] === null || data[key] === void 0) {
+      if (!inputSchemas[key].safeParse(data[key]).success) {
+        return {
+          code: HttpStatusCode.BadRequest_400,
+          body: `'${key}' is required for this endpoint` + (key === "body" ? ", { 'Content-Type': 'application/json' } header might be missing" : "")
+        };
+      }
+      return null;
+    }
+    const result = inputSchemas[key].safeParse(data[key]);
+    if (!result.success) {
+      return {
+        code: HttpStatusCode.BadRequest_400,
+        body: result.error.issues
+      };
+    }
+    return result.data ?? null;
+  }
+  return null;
+}
+
+function flatListAllRegistryEntries(registry) {
+  const entries = [];
+  for (const key of Object.keys(registry)) {
+    if (key === "_middlewareRegistry") {
+      continue;
+    }
+    const value = registry[key];
+    if (value instanceof MethodEndpointHandlerRegistryEntry) {
+      entries.push(value);
+    } else if (typeof value === "object" && value !== null) {
+      const innerEntries = flatListAllRegistryEntries(value);
+      for (const entry of innerEntries) {
+        entries.push(entry);
+      }
+    }
+  }
+  return entries;
+}
+function createRegistry(diContainer, contract, settings) {
+  return new ApiHandlersRegistry(diContainer, contract, settings);
+}
+class InnerApiHandlersRegistry {
+  /** @internal */
+  _middlewareRegistry;
+  constructor(dicontainer, contract, settings) {
+    const initializedDefinition = contract.cloneInitDef();
+    const proto = { ...InnerApiHandlersRegistry.prototype };
+    Object.assign(proto, Object.getPrototypeOf(initializedDefinition));
+    Object.setPrototypeOf(this, proto);
+    Object.assign(this, initializedDefinition);
+    InnerApiHandlersRegistry._initialize(this, settings.handlerRegisteredCallback, dicontainer);
+    this._middlewareRegistry = new MiddlewareHandlersRegistry(dicontainer, settings.middlewareHandlerRegisteredCallback);
+  }
+  static _initialize(currObj, callback, dicontainer) {
+    for (const key of Object.keys(currObj)) {
+      if (key === "_middlewareRegistry") {
+        continue;
+      }
+      const value = currObj[key];
+      if (value instanceof HttpMethodEndpoint) {
+        const entry = new MethodEndpointHandlerRegistryEntry(value, dicontainer);
+        entry._onHandlerRegistered(callback);
+        currObj[key] = entry;
+      } else if (typeof value === "object" && value !== null) {
+        InnerApiHandlersRegistry._initialize(value, callback, dicontainer);
+      }
+    }
+  }
+}
+const ApiHandlersRegistry = InnerApiHandlersRegistry;
+
+function partial(apiReg, path) {
+  const pathSegments = path.split("/").filter((segment) => segment.length > 0);
+  let current = apiReg;
+  for (const segment of pathSegments) {
+    if (current[segment] instanceof MethodEndpointHandlerRegistryEntry) {
+      throw new Error(`Path "${path}" is not partial`);
+    } else if (typeof current[segment] === "object") {
+      current = current[segment];
+    } else {
+      throw new Error(`Path segment "${segment}" not found in API handlers registry`);
+    }
+  }
+  return current;
+}
+
+function route(apiReg, path) {
+  const pathStr = path;
+  const spaceIndex = pathStr.indexOf(" ");
+  if (spaceIndex === -1) {
+    throw new Error(`Invalid path format: ${pathStr}. Expected format: "HTTP_METHOD /path"`);
+  }
+  const method = pathStr.substring(0, spaceIndex);
+  const urlPath = pathStr.substring(spaceIndex + 1);
+  const pathSegments = urlPath.split("/").filter((segment) => segment.length > 0);
+  let current = apiReg;
+  for (const segment of pathSegments) {
+    if (current[segment] instanceof MethodEndpointHandlerRegistryEntry) {
+      current = current[segment];
+    } else if (typeof current[segment] === "object") {
+      current = current[segment];
+    } else {
+      throw new Error(`Path segment "${segment}" not found in API handlers registry`);
+    }
+  }
+  if (!(method in current)) {
+    throw new Error(`Method "${method}" not found for path "${pathSegments.join("/")}"`);
+  }
+  if (!(current[method] instanceof MethodEndpointHandlerRegistryEntry)) {
+    throw new Error(`Method "${method}" is not a valid endpoint handler for path "${pathSegments.join("/")}"`);
+  }
+  current = current[method];
+  return current;
+}
+
+function register(apiRegOrEndpoint, pathOrHandler, handler) {
+  if (arguments.length === 3 && handler !== void 0) {
+    registerMethodPathHandler(
+      apiRegOrEndpoint,
+      pathOrHandler,
+      handler
+    );
+  } else if (arguments.length === 2) {
+    registerEntryHandler(
+      apiRegOrEndpoint,
+      pathOrHandler
+    );
+  } else {
+    throw new Error("Invalid number of arguments provided to register function");
+  }
+}
+function registerMethodPathHandler(apiReg, path, handler) {
+  const endpointEntry = route(apiReg, path);
+  return registerEntryHandler(endpointEntry, handler);
+}
+function registerEntryHandler(endpointEntry, handler) {
+  endpointEntry.register(handler);
+}
+
+function partialPathString(_apiReg, path) {
+  return path;
+}
+
+function createClient(contract, clientGenericHandler) {
+  const apiClient = new ApiClient(contract, clientGenericHandler);
+  return apiClient;
+}
+class InnerApiClient {
+  // TODO: if making __CONTEXT__ private member, the following compilation error occurs: 
+  // "Property '__CONTEXT__' of exported anonymous class type may not be private or protected.ts(4094)"
+  // Reason: exported anonymous classes can't have private or protected members if declaration emit is enabled
+  // Source: https://stackoverflow.com/questions/55242196/typescript-allows-to-use-proper-multiple-inheritance-with-mixins-but-fails-to-c
+  /** @internal */
+  __CONTEXT__;
+  constructor(contract, clientGenericHandler) {
+    const initializedDefinition = contract.cloneInitDef();
+    const proto = { ...InnerApiClient.prototype };
+    Object.assign(proto, Object.getPrototypeOf(initializedDefinition));
+    Object.setPrototypeOf(this, proto);
+    Object.assign(this, initializedDefinition);
+    InnerApiClient._initialize(this, this, clientGenericHandler);
+    this.__CONTEXT__ = InnerApiClient._initNewContext();
+  }
+  static _initNewContext() {
+    return {
+      pathParameters: {}
+    };
+  }
+  static _initialize(client, currObj, clientGenericHandler) {
+    for (const key of Object.keys(currObj)) {
+      if (key === "__CONTEXT__") {
+        continue;
+      }
+      const val = currObj[key];
+      if (key.startsWith(":")) {
+        const paramName = key.slice(1);
+        currObj[paramName] = ((value) => {
+          client.__CONTEXT__.pathParameters[paramName] = value.toString();
+          return val;
+        });
+        delete currObj[key];
+        InnerApiClient._initialize(client, val, clientGenericHandler);
+      } else if (val instanceof HttpMethodEndpoint) {
+        currObj[key] = (req) => {
+          const pathParams = { ...client.__CONTEXT__.pathParameters };
+          client.__CONTEXT__ = InnerApiClient._initNewContext();
+          const headers = clientParseRequestDefinitionField(val.definition, "headers", req);
+          const query = clientParseRequestDefinitionField(val.definition, "query", req);
+          const body = clientParseRequestDefinitionField(val.definition, "body", req);
+          const path = `/${val.pathSegments.map(
+            (segment) => segment.startsWith(":") ? pathParams[segment.slice(1)] ?? "?" : segment
+          ).join("/")}`;
+          return clientGenericHandler({
+            method: val.method,
+            pathSegments: val.pathSegments,
+            genericPath: val.genericPath,
+            path,
+            headers,
+            pathParams,
+            query,
+            body
+          });
+        };
+      } else if (typeof val === "object" && val !== null) {
+        InnerApiClient._initialize(client, val, clientGenericHandler);
+      }
+    }
+  }
+}
+const ApiClient = InnerApiClient;
+function clientParseRequestDefinitionField(definition, key, data) {
+  if (definition[key]) {
+    if (!(key in data) || data[key] === null || data[key] === void 0) {
+      if (!definition[key].safeParse(data[key]).success) {
+        throw new Error(`${key} are required for this endpoint`);
+      }
+      return null;
+    }
+    const result = definition[key].safeParse(data[key]);
+    if (!result.success) {
+      throw new Error(`Validation for '${key}' failed`, { cause: result.error });
+    }
+    return result.data ?? null;
+  }
+  return null;
+}
+
+class DIContainer {
+  registry = /* @__PURE__ */ new Map();
+  singletons = /* @__PURE__ */ new Map();
+  proxy;
+  /**
+   * The constructor returns a Proxy. This is the runtime magic that intercepts
+   * calls to methods like `getLoggerService()`. It parses the method name,
+   * finds the corresponding service class in the registry, and resolves it.
+   */
+  constructor() {
+    this.proxy = new Proxy(this, {
+      get: (target, prop, receiver) => {
+        if (typeof prop === "string" && prop.startsWith("get")) {
+          const serviceName = prop.substring(3);
+          if (target.registry.has(serviceName)) {
+            return () => target.resolveByName(serviceName);
+          } else {
+            throw new Error(`Service not registered: ${serviceName}`);
+          }
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+    return this.proxy;
+  }
+  /**
+   * Registers a service with explicit service name (fully type-safe).
+   */
+  register(serviceNameLiteral, factory, lifetime = "transient") {
+    this.registry.set(serviceNameLiteral, { factory, lifetime });
+    return this;
+  }
+  /**
+   * Resolves a service by service name.
+   */
+  resolveByName(serviceName) {
+    const registration = this.registry.get(serviceName);
+    if (!registration) {
+      throw new Error(`Service not registered: ${serviceName}`);
+    }
+    if (registration.lifetime === "singleton") {
+      if (!this.singletons.has(serviceName)) {
+        const instance = registration.factory(this.proxy);
+        this.singletons.set(serviceName, instance);
+      }
+      return this.singletons.get(serviceName);
+    }
+    return registration.factory(this.proxy);
+  }
+  /**
+   * Creates a scoped container with typed method access to services.
+   */
+  createScope() {
+    const scope = {};
+    return new Proxy(scope, {
+      get: (target, prop) => {
+        if (typeof prop === "string" && prop.startsWith("get")) {
+          const serviceName = prop.substring(3);
+          if (this.registry.has(serviceName)) {
+            const registration = this.registry.get(serviceName);
+            return () => {
+              if (registration?.lifetime === "transient") {
+                return this.resolveByName(serviceName);
+              }
+              const cacheKey = `_cached_${serviceName}`;
+              if (!target[cacheKey]) {
+                target[cacheKey] = this.resolveByName(serviceName);
+              }
+              return target[cacheKey];
+            };
+          } else {
+            throw new Error(`Service not registered: ${serviceName}`);
+          }
+        }
+        return Reflect.get(target, prop);
+      }
+    });
+  }
+  createTestClone() {
+    const clone = new DIContainer();
+    return clone;
+  }
+}
+
+function createInProcApiClient(contract, testContainer, registry) {
+  const testApiReg = createRegistry(testContainer, contract, {
+    handlerRegisteredCallback: (_entry) => {
+    },
+    middlewareHandlerRegisteredCallback: (_entry) => {
+    }
+  });
+  flatListAllRegistryEntries(registry).forEach((entry) => {
+    if (!entry.handler) {
+      return;
+    }
+    const rt = route(testApiReg, `${entry.methodEndpoint.method} ${entry.methodEndpoint.genericPath}`);
+    rt.inject(entry.injection).register(entry.handler);
+  });
+  const client = createClient(contract, async (input) => {
+    const rt = route(testApiReg, `${input.method} ${input.genericPath}`);
+    const result = rt.trigger({
+      headers: input.headers,
+      pathParams: input.pathParams,
+      body: input.body ?? {},
+      query: input.query ?? {}
+    });
+    return result;
+  });
+  return client;
 }
 
-exports.getHelloWorldMessage = getHelloWorldMessage;
+exports.ApiClient = ApiClient;
+exports.ApiContract = ApiContract;
+exports.ApiHandlersRegistry = ApiHandlersRegistry;
+exports.DIContainer = DIContainer;
+exports.HttpMethodEndpoint = HttpMethodEndpoint;
+exports.HttpMethodEndpointResponse = HttpMethodEndpointResponse;
+exports.HttpStatusCode = HttpStatusCode;
+exports.MethodEndpointHandlerRegistryEntry = MethodEndpointHandlerRegistryEntry;
+exports.MiddlewareHandlersRegistry = MiddlewareHandlersRegistry;
+exports.MiddlewareHandlersRegistryEntry = MiddlewareHandlersRegistryEntry;
+exports.MiddlewareHandlersRegistryEntryInternal = MiddlewareHandlersRegistryEntryInternal;
+exports.apiContract = apiContract;
+exports.createClient = createClient;
+exports.createInProcApiClient = createInProcApiClient;
+exports.createRegistry = createRegistry;
+exports.endpoint = endpoint;
+exports.flatListAllRegistryEntries = flatListAllRegistryEntries;
+exports.isHttpResponseObject = isHttpResponseObject;
+exports.isHttpStatusCode = isHttpStatusCode;
+exports.middleware = middleware;
+exports.partial = partial;
+exports.partialPathString = partialPathString;
+exports.register = register;
+exports.response = response;
+exports.route = route;