sst-http 1.3.2 → 1.3.3-beta.2

package/dist/infra.cjs

@@ -20,6 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/infra.ts
 var infra_exports = {};
 __export(infra_exports, {
+  createBus: () => createBus,
+  getBus: () => getBus,
   httpApiAdapter: () => httpApiAdapter,
   loadRoutesManifest: () => loadRoutesManifest,
   restApiAdapter: () => restApiAdapter,
@@ -29,18 +31,32 @@ module.exports = __toCommonJS(infra_exports);
 var import_node_fs = require("fs");
 var import_node_path = require("path");
 
-// src/paths.ts
-var API_GATEWAY_PARAM_RE = /(^|\/):([A-Za-z0-9_]+(?:[+*])?)(?=\/|$)/g;
-function normalizeApiGatewayPath(path) {
-  return path.replace(API_GATEWAY_PARAM_RE, (_match, prefix, name) => `${prefix}{${name}}`);
+// src/core/infra.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
 }
-
-// src/infra.ts
-function ensureSstAws(source) {
-  if (source?.sst?.aws) {
-    return source.sst.aws;
+function getFunction(value, key) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const candidate = value[key];
+  return typeof candidate === "function" ? candidate : void 0;
+}
+function getStringProp(value, key) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const candidate = value[key];
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
+}
+function ensureRecord(value, message) {
+  if (!isRecord(value)) {
+    throw new Error(message);
   }
-  const aws = globalThis.sst?.aws;
+  return value;
+}
+function ensureSstAws(source) {
+  const aws = typeof sst !== "undefined" ? sst.aws : source?.sst?.aws ?? globalThis.sst?.aws;
   if (!aws) {
     throw new Error(
       "SST aws namespace is not available. Ensure this code runs within an SST config."
@@ -48,32 +64,133 @@ function ensureSstAws(source) {
   }
   return aws;
 }
-function wireApiFromManifest(manifest, opts) {
-  if (!manifest || !Array.isArray(manifest.routes)) {
-    throw new Error("Invalid routes manifest");
+function resolveHandlerInput(handler) {
+  if (handler === void 0) {
+    return void 0;
   }
-  const firebaseRoutes = manifest.routes.filter((route) => route.auth.type === "firebase");
-  let firebaseAuthorizerRef;
-  if (firebaseRoutes.length > 0) {
-    if (!opts.firebaseProjectId) {
-      throw new Error("firebaseProjectId is required when using @FirebaseAuth()");
+  if (typeof handler === "string") {
+    return handler;
+  }
+  if (!isRecord(handler)) {
+    throw new Error("Unsupported handler type: provide a handler string, FunctionArgs, or a Function ARN/output");
+  }
+  if ("arn" in handler) {
+    return handler.arn;
+  }
+  if (typeof handler.handler === "string") {
+    return handler;
+  }
+  throw new Error("Unsupported handler type: provide a handler string, FunctionArgs, or a Function ARN/output");
+}
+
+// src/bus/infra.ts
+var MAX_SUBSCRIBER_NAME_LENGTH = 60;
+function createBus() {
+  const aws = ensureSstAws();
+  return new aws.Bus("default");
+}
+function getBus() {
+  const aws = ensureSstAws();
+  return aws.Bus.get("default", "default");
+}
+function wireEventsFromManifest(events, opts) {
+  if (!events || events.length === 0) {
+    return;
+  }
+  const aws = ensureSstAws(opts.source);
+  const busMap = normalizeBusInput(opts.buses);
+  const subscriber = resolveHandlerInput(opts.handler);
+  const seen = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    const key = `default:${event.event}`;
+    if (seen.has(key)) {
+      continue;
     }
-    const issuer = `https://securetoken.google.com/${opts.firebaseProjectId}`;
-    firebaseAuthorizerRef = opts.ensureJwtAuthorizer("firebase", {
-      issuer,
-      audiences: [opts.firebaseProjectId]
-    });
+    seen.add(key);
+    const bus = resolveBusForEvent(busMap, aws);
+    const subscriberName = buildSubscriberName(event.event);
+    subscribeToBus(bus, subscriberName, subscriber, event.event);
+  }
+}
+function normalizeBusInput(input) {
+  if (!input) {
+    return void 0;
+  }
+  const map = /* @__PURE__ */ new Map();
+  if (Array.isArray(input)) {
+    for (const bus of input) {
+      const key2 = getBusKey(bus);
+      if (key2) {
+        map.set(key2, bus);
+      }
+    }
+    if (map.size === 1 && !map.has("default")) {
+      const [bus] = map.values();
+      map.set("default", bus);
+    }
+    return map;
   }
+  if (isBusRecord(input)) {
+    for (const [key2, bus] of Object.entries(input)) {
+      map.set(key2, bus);
+    }
+    return map;
+  }
+  const key = getBusKey(input) ?? "default";
+  map.set(key, input);
+  return map;
+}
+function isBusRecord(input) {
+  return !Array.isArray(input) && isRecord(input) && !("subscribe" in input);
+}
+function getBusKey(bus) {
+  return getStringProp(bus, "name") ?? getStringProp(bus, "constructorName");
+}
+function resolveBusForEvent(busMap, aws) {
+  if (busMap && busMap.size > 0) {
+    const direct = busMap.get("default");
+    if (direct) {
+      return direct;
+    }
+    if (busMap.size === 1) {
+      return busMap.values().next().value;
+    }
+  }
+  return aws.Bus.get("default", "default");
+}
+function subscribeToBus(bus, subscriberName, subscriber, eventName) {
+  if (typeof bus.subscribe !== "function") {
+    throw new Error("Bus instance does not support subscribe().");
+  }
+  bus.subscribe(subscriberName, subscriber, {
+    pattern: {
+      detailType: [eventName]
+    }
+  });
+}
+function buildSubscriberName(eventName) {
+  const base = `default-${eventName}`.replace(/[^a-zA-Z0-9]/g, "");
+  if (base.length === 0) {
+    return "Event";
+  }
+  return base.length > MAX_SUBSCRIBER_NAME_LENGTH ? base.slice(0, MAX_SUBSCRIBER_NAME_LENGTH) : base;
+}
+
+// src/http/paths.ts
+var API_GATEWAY_PARAM_RE = /(^|\/):([A-Za-z0-9_]+(?:[+*])?)(?=\/|$)/g;
+function normalizeApiGatewayPath(path) {
+  return path.replace(API_GATEWAY_PARAM_RE, (_match, prefix, name) => `${prefix}{${name}}`);
+}
+
+// src/http/infra.ts
+function wireRoutesFromManifest(manifest, opts) {
+  const firebaseRoutes = manifest.routes.filter((route) => route.auth.type === "firebase");
+  const firebaseAuthorizerRef = ensureFirebaseAuthorizer(firebaseRoutes.length, opts);
   for (const route of manifest.routes) {
     const isProtected = route.auth.type === "firebase";
     const rawPath = route.path.startsWith("/") ? route.path : `/${route.path}`;
     const path = normalizeApiGatewayPath(rawPath);
-    const authConfig = isProtected && route.auth.type === "firebase" ? {
-      name: "firebase",
-      optional: route.auth.optional,
-      roles: route.auth.roles,
-      ref: firebaseAuthorizerRef
-    } : void 0;
+    const authConfig = buildAuthorizerConfig(route, firebaseAuthorizerRef);
     opts.registerRoute(route.method, path, {
       handler: opts.handler,
       protected: isProtected,
@@ -81,33 +198,74 @@ function wireApiFromManifest(manifest, opts) {
     });
   }
 }
-function loadRoutesManifest(filePath) {
-  const resolved = (0, import_node_path.resolve)(filePath);
-  const contents = (0, import_node_fs.readFileSync)(resolved, "utf8");
-  const manifest = JSON.parse(contents);
-  if (!manifest || !Array.isArray(manifest.routes)) {
-    throw new Error(`Invalid routes manifest at ${resolved}`);
-  }
-  return manifest;
-}
 function httpApiAdapter(args) {
   const aws = args?.api ? void 0 : ensureSstAws(args);
   const api = args?.api ?? new aws.ApiGatewayV2(args?.apiName ?? "HttpApi", args?.apiArgs);
+  const ensureJwtAuthorizer = createHttpAuthorizerManager(api);
+  const registerRoute = createRouteRegistrar(api, "ApiGatewayV2");
+  return {
+    api,
+    registerRoute,
+    ensureJwtAuthorizer
+  };
+}
+function restApiAdapter(args) {
+  const aws = args?.api ? void 0 : ensureSstAws(args);
+  const api = args?.api ?? new aws.ApiGateway(args?.apiName ?? "RestApi", args?.apiArgs);
+  const ensureJwtAuthorizer = createRestAuthorizerManager(api);
+  const registerRoute = createRouteRegistrar(api, "ApiGateway");
+  return {
+    api,
+    registerRoute,
+    ensureJwtAuthorizer
+  };
+}
+function ensureFirebaseAuthorizer(firebaseRouteCount, opts) {
+  if (firebaseRouteCount === 0) {
+    return void 0;
+  }
+  if (!opts.firebaseProjectId) {
+    throw new Error("firebaseProjectId is required when using @FirebaseAuth()");
+  }
+  const issuer = `https://securetoken.google.com/${opts.firebaseProjectId}`;
+  return opts.ensureJwtAuthorizer("firebase", {
+    issuer,
+    audiences: [opts.firebaseProjectId]
+  });
+}
+function buildAuthorizerConfig(route, firebaseAuthorizerRef) {
+  if (route.auth.type !== "firebase") {
+    return void 0;
+  }
+  return {
+    name: "firebase",
+    optional: route.auth.optional,
+    roles: route.auth.roles,
+    ref: firebaseAuthorizerRef
+  };
+}
+function createHttpAuthorizerManager(api) {
   const authorizers = /* @__PURE__ */ new Map();
-  const ensureJwtAuthorizer = (name, cfg) => {
+  return (name, cfg) => {
     if (authorizers.has(name)) {
       return authorizers.get(name);
     }
-    const apiAny = api;
+    const addAuthorizer = getFunction(api, "addAuthorizer");
+    const addAuthorizers = getFunction(api, "addAuthorizers");
+    const authorizer = getFunction(api, "authorizer");
     let ref = void 0;
-    if (typeof apiAny["addAuthorizer"] === "function") {
-      const created = apiAny.addAuthorizer({
+    if (addAuthorizer) {
+      const created = addAuthorizer.call(api, {
         name,
         jwt: { issuer: cfg.issuer, audiences: cfg.audiences }
       });
-      ref = created.id;
-    } else if (typeof apiAny.addAuthorizers === "function") {
-      apiAny.addAuthorizers({
+      if (isRecord(created) && "id" in created) {
+        ref = created.id ?? created;
+      } else {
+        ref = created;
+      }
+    } else if (addAuthorizers) {
+      addAuthorizers.call(api, {
         [name]: {
           type: "jwt",
           jwt: {
@@ -117,8 +275,8 @@ function httpApiAdapter(args) {
         }
       });
       ref = name;
-    } else if (typeof apiAny.authorizer === "function") {
-      ref = apiAny.authorizer(name, {
+    } else if (authorizer) {
+      ref = authorizer.call(api, name, {
         type: "jwt",
         jwt: {
           issuer: cfg.issuer,
@@ -131,58 +289,13 @@ function httpApiAdapter(args) {
     authorizers.set(name, ref);
     return ref;
   };
-  const registerRoute = (method, path, config) => {
-    const apiAny = api;
-    const normalizedPath = normalizeApiGatewayPath(path);
-    const routeKey = `${method} ${normalizedPath}`;
-    const asAny = config.handler;
-    const handlerInput = typeof asAny === "string" ? asAny : asAny && typeof asAny.arn !== "undefined" ? asAny.arn : asAny && typeof asAny.handler === "string" ? asAny.handler : asAny === void 0 ? void 0 : (() => {
-      throw new Error("Unsupported handler type: provide a handler string, FunctionArgs, or a Function ARN/output");
-    })();
-    const args2 = {};
-    if (config.protected && config.authorizer) {
-      args2.auth = {
-        jwt: {
-          authorizer: config.authorizer.ref ?? config.authorizer.name,
-          scopes: config.authorizer.roles
-        }
-      };
-    }
-    if (typeof apiAny.route === "function") {
-      apiAny.route(routeKey, handlerInput, args2);
-      return;
-    }
-    if (typeof apiAny.addRoutes === "function") {
-      apiAny.addRoutes({
-        [routeKey]: {
-          handler: handlerInput,
-          ...args2
-        }
-      });
-      return;
-    }
-    if (typeof apiAny.addRoute === "function") {
-      apiAny.addRoute(routeKey, { handler: handlerInput, ...args2 });
-      return;
-    }
-    throw new Error("Unsupported ApiGatewayV2 instance: expected route() or addRoutes() method.");
-  };
-  return {
-    api,
-    registerRoute,
-    ensureJwtAuthorizer
-  };
 }
-function restApiAdapter(args) {
-  const aws = args?.api ? void 0 : ensureSstAws(args);
-  const api = args?.api ?? new aws.ApiGateway(args?.apiName ?? "RestApi", args?.apiArgs);
+function createRestAuthorizerManager(api) {
   const authorizers = /* @__PURE__ */ new Map();
-  const ensureJwtAuthorizer = (name, cfg) => {
+  return (name, cfg) => {
     if (authorizers.has(name)) {
       return authorizers.get(name);
     }
-    const apiAny = api;
-    let ref = name;
     const payload = {
       type: "jwt",
       jwt: {
@@ -190,65 +303,99 @@ function restApiAdapter(args) {
         audience: cfg.audiences
       }
     };
-    if (typeof apiAny.addAuthorizers === "function") {
-      apiAny.addAuthorizers({
+    const addAuthorizers = getFunction(api, "addAuthorizers");
+    const authorizer = getFunction(api, "authorizer");
+    let ref = name;
+    if (addAuthorizers) {
+      addAuthorizers.call(api, {
         [name]: payload
       });
-    } else if (typeof apiAny.authorizer === "function") {
-      ref = apiAny.authorizer(name, payload);
+    } else if (authorizer) {
+      ref = authorizer.call(api, name, payload);
     } else {
-      apiAny.authorizers = {
-        ...apiAny.authorizers ?? {},
+      const apiRecord = ensureRecord(api, "ApiGateway instance does not support authorizers.");
+      const current = isRecord(apiRecord.authorizers) ? apiRecord.authorizers : {};
+      apiRecord.authorizers = {
+        ...current,
         [name]: payload
       };
     }
     authorizers.set(name, ref);
     return ref;
   };
-  const registerRoute = (method, path, config) => {
-    const apiAny = api;
+}
+function createRouteRegistrar(api, apiLabel) {
+  return (method, path, config) => {
     const normalizedPath = normalizeApiGatewayPath(path);
     const routeKey = `${method} ${normalizedPath}`;
-    const asAny = config.handler;
-    const handlerInput = typeof asAny === "string" ? asAny : asAny && typeof asAny.arn !== "undefined" ? asAny.arn : asAny && typeof asAny.handler === "string" ? asAny.handler : asAny === void 0 ? void 0 : (() => {
-      throw new Error("Unsupported handler type: provide a handler string, FunctionArgs, or a Function ARN/output");
-    })();
-    const args2 = {};
-    if (config.protected && config.authorizer) {
-      args2.auth = {
-        jwt: {
-          authorizer: config.authorizer.ref ?? config.authorizer.name,
-          scopes: config.authorizer.roles
-        }
-      };
-    }
-    if (typeof apiAny.route === "function") {
-      apiAny.route(routeKey, handlerInput, args2);
+    const handlerInput = resolveHandlerInput(config.handler);
+    const args = buildRouteArgs(config);
+    const route = getFunction(api, "route");
+    if (route) {
+      route.call(api, routeKey, handlerInput, args);
       return;
     }
-    if (typeof apiAny.addRoutes === "function") {
-      apiAny.addRoutes({
+    const addRoutes = getFunction(api, "addRoutes");
+    if (addRoutes) {
+      addRoutes.call(api, {
         [routeKey]: {
           handler: handlerInput,
-          ...args2
+          ...args
         }
       });
       return;
     }
-    if (typeof apiAny.addRoute === "function") {
-      apiAny.addRoute(routeKey, { handler: handlerInput, ...args2 });
+    const addRoute = getFunction(api, "addRoute");
+    if (addRoute) {
+      addRoute.call(api, routeKey, { handler: handlerInput, ...args });
       return;
     }
-    throw new Error("Unsupported ApiGateway instance: expected route() or addRoutes() method.");
+    throw new Error(`Unsupported ${apiLabel} instance: expected route() or addRoutes() method.`);
   };
+}
+function buildRouteArgs(config) {
+  if (!config.protected || !config.authorizer) {
+    return {};
+  }
   return {
-    api,
-    registerRoute,
-    ensureJwtAuthorizer
+    auth: {
+      jwt: {
+        authorizer: config.authorizer.ref ?? config.authorizer.name,
+        scopes: config.authorizer.roles
+      }
+    }
   };
 }
+
+// src/infra.ts
+function wireApiFromManifest(manifest, opts) {
+  if (!manifest || !Array.isArray(manifest.routes)) {
+    throw new Error("Invalid routes manifest");
+  }
+  wireRoutesFromManifest(manifest, {
+    handler: opts.handler,
+    firebaseProjectId: opts.firebaseProjectId,
+    registerRoute: opts.registerRoute,
+    ensureJwtAuthorizer: opts.ensureJwtAuthorizer
+  });
+  wireEventsFromManifest(manifest.events, {
+    handler: opts.handler,
+    buses: opts.buses
+  });
+}
+function loadRoutesManifest(filePath) {
+  const resolved = (0, import_node_path.resolve)(filePath);
+  const contents = (0, import_node_fs.readFileSync)(resolved, "utf8");
+  const manifest = JSON.parse(contents);
+  if (!manifest || !Array.isArray(manifest.routes)) {
+    throw new Error(`Invalid routes manifest at ${resolved}`);
+  }
+  return manifest;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createBus,
+  getBus,
   httpApiAdapter,
   loadRoutesManifest,
   restApiAdapter,

package/dist/infra.d.cts

@@ -1,17 +1,32 @@
-import { H as HttpMethod, R as RoutesManifest } from './types-BF3w-wTx.cjs';
-export { b as RoutesManifestAuth, a as RoutesManifestRoute } from './types-BF3w-wTx.cjs';
+import { f as RoutesManifestEvent, b as HttpMethod, g as RoutesManifest } from './types-w1A7o_rd.cjs';
+export { i as RoutesManifestAuth, h as RoutesManifestRoute } from './types-w1A7o_rd.cjs';
 import 'aws-lambda';
 
-type SstApiGateway = any;
-type SstAwsNamespace = {
-    ApiGatewayV2: new (name: string, args?: unknown, opts?: unknown) => SstApiGateway;
-    ApiGateway: new (name: string, args?: unknown, opts?: unknown) => SstApiGateway;
+type BusSubscriberArgs = {
+    pattern?: {
+        detailType?: string[];
+    };
+};
+type BusLike = {
+    name?: unknown;
+    arn?: unknown;
+    subscribe: (name: string, subscriber: unknown, args?: BusSubscriberArgs) => unknown;
 };
 type AwsSource = {
     sst?: {
-        aws?: SstAwsNamespace;
+        aws?: unknown;
     };
 };
+
+type BusInput = BusLike | BusLike[] | Record<string, BusLike>;
+declare function createBus(): BusLike;
+declare function getBus(): BusLike;
+declare function wireEventsFromManifest(events: RoutesManifestEvent[] | undefined, opts: {
+    handler: unknown;
+    buses?: BusInput;
+    source?: AwsSource;
+}): void;
+
 type RegisterRouteConfig = {
     handler: unknown;
     protected: boolean;
@@ -27,27 +42,29 @@ type EnsureJwtAuthorizer = (name: string, cfg: {
     issuer: string;
     audiences: string[];
 }) => unknown;
-declare function wireApiFromManifest(manifest: RoutesManifest, opts: {
-    handler: unknown;
-    firebaseProjectId: string;
-    registerRoute: RegisterRoute;
-    ensureJwtAuthorizer: EnsureJwtAuthorizer;
-}): void;
-declare function loadRoutesManifest(filePath: string): RoutesManifest;
 type AdapterArgs = AwsSource & {
-    api?: SstApiGateway;
+    api?: unknown;
     apiName?: string;
     apiArgs?: unknown;
 };
 declare function httpApiAdapter(args?: AdapterArgs): {
-    api: any;
+    api: unknown;
     registerRoute: RegisterRoute;
     ensureJwtAuthorizer: EnsureJwtAuthorizer;
 };
 declare function restApiAdapter(args?: AdapterArgs): {
-    api: any;
+    api: unknown;
     registerRoute: RegisterRoute;
     ensureJwtAuthorizer: EnsureJwtAuthorizer;
 };
 
-export { type EnsureJwtAuthorizer, type RegisterRoute, type RegisterRouteConfig, RoutesManifest, httpApiAdapter, loadRoutesManifest, restApiAdapter, wireApiFromManifest };
+declare function wireApiFromManifest(manifest: RoutesManifest, opts: {
+    handler: unknown;
+    firebaseProjectId: string;
+    registerRoute: RegisterRoute;
+    ensureJwtAuthorizer: EnsureJwtAuthorizer;
+    buses?: Parameters<typeof wireEventsFromManifest>[1]["buses"];
+}): void;
+declare function loadRoutesManifest(filePath: string): RoutesManifest;
+
+export { type EnsureJwtAuthorizer, type RegisterRoute, type RegisterRouteConfig, RoutesManifest, RoutesManifestEvent, createBus, getBus, httpApiAdapter, loadRoutesManifest, restApiAdapter, wireApiFromManifest };

package/dist/infra.d.ts

@@ -1,17 +1,32 @@
-import { H as HttpMethod, R as RoutesManifest } from './types-BF3w-wTx.js';
-export { b as RoutesManifestAuth, a as RoutesManifestRoute } from './types-BF3w-wTx.js';
+import { f as RoutesManifestEvent, b as HttpMethod, g as RoutesManifest } from './types-w1A7o_rd.js';
+export { i as RoutesManifestAuth, h as RoutesManifestRoute } from './types-w1A7o_rd.js';
 import 'aws-lambda';
 
-type SstApiGateway = any;
-type SstAwsNamespace = {
-    ApiGatewayV2: new (name: string, args?: unknown, opts?: unknown) => SstApiGateway;
-    ApiGateway: new (name: string, args?: unknown, opts?: unknown) => SstApiGateway;
+type BusSubscriberArgs = {
+    pattern?: {
+        detailType?: string[];
+    };
+};
+type BusLike = {
+    name?: unknown;
+    arn?: unknown;
+    subscribe: (name: string, subscriber: unknown, args?: BusSubscriberArgs) => unknown;
 };
 type AwsSource = {
     sst?: {
-        aws?: SstAwsNamespace;
+        aws?: unknown;
     };
 };
+
+type BusInput = BusLike | BusLike[] | Record<string, BusLike>;
+declare function createBus(): BusLike;
+declare function getBus(): BusLike;
+declare function wireEventsFromManifest(events: RoutesManifestEvent[] | undefined, opts: {
+    handler: unknown;
+    buses?: BusInput;
+    source?: AwsSource;
+}): void;
+
 type RegisterRouteConfig = {
     handler: unknown;
     protected: boolean;
@@ -27,27 +42,29 @@ type EnsureJwtAuthorizer = (name: string, cfg: {
     issuer: string;
     audiences: string[];
 }) => unknown;
-declare function wireApiFromManifest(manifest: RoutesManifest, opts: {
-    handler: unknown;
-    firebaseProjectId: string;
-    registerRoute: RegisterRoute;
-    ensureJwtAuthorizer: EnsureJwtAuthorizer;
-}): void;
-declare function loadRoutesManifest(filePath: string): RoutesManifest;
 type AdapterArgs = AwsSource & {
-    api?: SstApiGateway;
+    api?: unknown;
     apiName?: string;
     apiArgs?: unknown;
 };
 declare function httpApiAdapter(args?: AdapterArgs): {
-    api: any;
+    api: unknown;
     registerRoute: RegisterRoute;
     ensureJwtAuthorizer: EnsureJwtAuthorizer;
 };
 declare function restApiAdapter(args?: AdapterArgs): {
-    api: any;
+    api: unknown;
     registerRoute: RegisterRoute;
     ensureJwtAuthorizer: EnsureJwtAuthorizer;
 };
 
-export { type EnsureJwtAuthorizer, type RegisterRoute, type RegisterRouteConfig, RoutesManifest, httpApiAdapter, loadRoutesManifest, restApiAdapter, wireApiFromManifest };
+declare function wireApiFromManifest(manifest: RoutesManifest, opts: {
+    handler: unknown;
+    firebaseProjectId: string;
+    registerRoute: RegisterRoute;
+    ensureJwtAuthorizer: EnsureJwtAuthorizer;
+    buses?: Parameters<typeof wireEventsFromManifest>[1]["buses"];
+}): void;
+declare function loadRoutesManifest(filePath: string): RoutesManifest;
+
+export { type EnsureJwtAuthorizer, type RegisterRoute, type RegisterRouteConfig, RoutesManifest, RoutesManifestEvent, createBus, getBus, httpApiAdapter, loadRoutesManifest, restApiAdapter, wireApiFromManifest };