sst-http 0.1.6

package/dist/infra.cjs

@@ -0,0 +1,230 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/infra.ts
+var infra_exports = {};
+__export(infra_exports, {
+  httpApiAdapter: () => httpApiAdapter,
+  loadRoutesManifest: () => loadRoutesManifest,
+  restApiAdapter: () => restApiAdapter,
+  wireApiFromManifest: () => wireApiFromManifest
+});
+module.exports = __toCommonJS(infra_exports);
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function ensureSstAws(source) {
+  if (source?.sst?.aws) {
+    return source.sst.aws;
+  }
+  const aws = globalThis.sst?.aws;
+  if (!aws) {
+    throw new Error(
+      "SST aws namespace is not available. Ensure this code runs within an SST config."
+    );
+  }
+  return aws;
+}
+function wireApiFromManifest(manifest, opts) {
+  if (!manifest || !Array.isArray(manifest.routes)) {
+    throw new Error("Invalid routes manifest");
+  }
+  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()");
+    }
+    const issuer = `https://securetoken.google.com/${opts.firebaseProjectId}`;
+    firebaseAuthorizerRef = opts.ensureJwtAuthorizer("firebase", {
+      issuer,
+      audiences: [opts.firebaseProjectId]
+    });
+  }
+  for (const route of manifest.routes) {
+    const isProtected = route.auth.type === "firebase";
+    const path = route.path.startsWith("/") ? route.path : `/${route.path}`;
+    const authConfig = isProtected && route.auth.type === "firebase" ? {
+      name: "firebase",
+      optional: route.auth.optional,
+      roles: route.auth.roles,
+      ref: firebaseAuthorizerRef
+    } : void 0;
+    opts.registerRoute(route.method, path, {
+      handler: opts.handlerFile,
+      protected: isProtected,
+      authorizer: authConfig
+    });
+  }
+}
+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 authorizers = /* @__PURE__ */ new Map();
+  const ensureJwtAuthorizer = (name, cfg) => {
+    if (authorizers.has(name)) {
+      return authorizers.get(name);
+    }
+    const apiAny = api;
+    let ref = name;
+    const payload = {
+      type: "jwt",
+      jwt: {
+        issuer: cfg.issuer,
+        audience: cfg.audiences
+      }
+    };
+    if (typeof apiAny.addAuthorizers === "function") {
+      apiAny.addAuthorizers({
+        [name]: payload
+      });
+    } else if (typeof apiAny.authorizer === "function") {
+      ref = apiAny.authorizer(name, payload);
+    } else {
+      apiAny.authorizers = {
+        ...apiAny.authorizers ?? {},
+        [name]: payload
+      };
+    }
+    authorizers.set(name, ref);
+    return ref;
+  };
+  const registerRoute = (method, path, config) => {
+    const apiAny = api;
+    const routeKey = `${method} ${path}`;
+    const routeConfig = {
+      handler: config.handler
+    };
+    if (config.protected && config.authorizer) {
+      routeConfig.authorizer = config.authorizer.ref ?? config.authorizer.name;
+      routeConfig.authorizationType = "JWT";
+      if (config.authorizer.roles && config.authorizer.roles.length > 0) {
+        routeConfig.authorizationScopes = config.authorizer.roles;
+      }
+      if (config.authorizer.optional) {
+        routeConfig.authorizerOptional = true;
+      }
+    }
+    if (typeof apiAny.route === "function") {
+      apiAny.route(routeKey, routeConfig);
+      return;
+    }
+    if (typeof apiAny.addRoutes === "function") {
+      apiAny.addRoutes({
+        [routeKey]: routeConfig
+      });
+      return;
+    }
+    if (typeof apiAny.addRoute === "function") {
+      apiAny.addRoute(routeKey, routeConfig);
+      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);
+  const authorizers = /* @__PURE__ */ new Map();
+  const ensureJwtAuthorizer = (name, cfg) => {
+    if (authorizers.has(name)) {
+      return authorizers.get(name);
+    }
+    const apiAny = api;
+    let ref = name;
+    const payload = {
+      type: "jwt",
+      jwt: {
+        issuer: cfg.issuer,
+        audience: cfg.audiences
+      }
+    };
+    if (typeof apiAny.addAuthorizers === "function") {
+      apiAny.addAuthorizers({
+        [name]: payload
+      });
+    } else if (typeof apiAny.authorizer === "function") {
+      ref = apiAny.authorizer(name, payload);
+    } else {
+      apiAny.authorizers = {
+        ...apiAny.authorizers ?? {},
+        [name]: payload
+      };
+    }
+    authorizers.set(name, ref);
+    return ref;
+  };
+  const registerRoute = (method, path, config) => {
+    const apiAny = api;
+    const routeKey = `${method} ${path}`;
+    const routeConfig = {
+      handler: config.handler
+    };
+    if (config.protected && config.authorizer) {
+      routeConfig.authorizer = config.authorizer.ref ?? config.authorizer.name;
+      routeConfig.authorizationType = "JWT";
+      if (config.authorizer.roles && config.authorizer.roles.length > 0) {
+        routeConfig.authorizationScopes = config.authorizer.roles;
+      }
+      if (config.authorizer.optional) {
+        routeConfig.authorizerOptional = true;
+      }
+    }
+    if (typeof apiAny.route === "function") {
+      apiAny.route(routeKey, routeConfig);
+      return;
+    }
+    if (typeof apiAny.addRoutes === "function") {
+      apiAny.addRoutes({
+        [routeKey]: routeConfig
+      });
+      return;
+    }
+    if (typeof apiAny.addRoute === "function") {
+      apiAny.addRoute(routeKey, routeConfig);
+      return;
+    }
+    throw new Error("Unsupported ApiGateway instance: expected route() or addRoutes() method.");
+  };
+  return {
+    api,
+    registerRoute,
+    ensureJwtAuthorizer
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  httpApiAdapter,
+  loadRoutesManifest,
+  restApiAdapter,
+  wireApiFromManifest
+});

package/dist/infra.d.cts

@@ -0,0 +1,61 @@
+import { H as HttpMethod, R as RoutesManifest } from './types-D69iuoxv.cjs';
+export { b as RoutesManifestAuth, a as RoutesManifestRoute } from './types-D69iuoxv.cjs';
+import 'aws-lambda';
+
+type SstApiGateway = {
+    route?: (routeKey: string, config: Record<string, unknown>) => unknown;
+    addRoutes?: (routes: Record<string, Record<string, unknown>>) => unknown;
+    addRoute?: (routeKey: string, config: Record<string, unknown>) => unknown;
+    addAuthorizers?: (authorizers: Record<string, unknown>) => unknown;
+    authorizer?: (name: string, payload: unknown) => unknown;
+    authorizers?: Record<string, unknown>;
+    url?: string;
+};
+type SstAwsNamespace = {
+    ApiGatewayV2: new (name: string, args?: unknown, opts?: unknown) => SstApiGateway;
+    ApiGateway: new (name: string, args?: unknown, opts?: unknown) => SstApiGateway;
+};
+type AwsSource = {
+    sst?: {
+        aws?: SstAwsNamespace;
+    };
+};
+type RegisterRouteConfig = {
+    handler: string;
+    protected: boolean;
+    authorizer?: {
+        name: string;
+        optional?: boolean;
+        roles?: string[];
+        ref?: unknown;
+    };
+};
+type RegisterRoute = (method: HttpMethod, path: string, config: RegisterRouteConfig) => void;
+type EnsureJwtAuthorizer = (name: string, cfg: {
+    issuer: string;
+    audiences: string[];
+}) => unknown;
+declare function wireApiFromManifest(manifest: RoutesManifest, opts: {
+    handlerFile: string;
+    firebaseProjectId: string;
+    registerRoute: RegisterRoute;
+    ensureJwtAuthorizer: EnsureJwtAuthorizer;
+}): void;
+declare function loadRoutesManifest(filePath: string): RoutesManifest;
+type AdapterArgs = AwsSource & {
+    api?: SstApiGateway;
+    apiName?: string;
+    apiArgs?: unknown;
+};
+declare function httpApiAdapter(args?: AdapterArgs): {
+    api: SstApiGateway;
+    registerRoute: RegisterRoute;
+    ensureJwtAuthorizer: EnsureJwtAuthorizer;
+};
+declare function restApiAdapter(args?: AdapterArgs): {
+    api: SstApiGateway;
+    registerRoute: RegisterRoute;
+    ensureJwtAuthorizer: EnsureJwtAuthorizer;
+};
+
+export { type EnsureJwtAuthorizer, type RegisterRoute, type RegisterRouteConfig, RoutesManifest, httpApiAdapter, loadRoutesManifest, restApiAdapter, wireApiFromManifest };

package/dist/infra.d.ts

@@ -0,0 +1,61 @@
+import { H as HttpMethod, R as RoutesManifest } from './types-D69iuoxv.js';
+export { b as RoutesManifestAuth, a as RoutesManifestRoute } from './types-D69iuoxv.js';
+import 'aws-lambda';
+
+type SstApiGateway = {
+    route?: (routeKey: string, config: Record<string, unknown>) => unknown;
+    addRoutes?: (routes: Record<string, Record<string, unknown>>) => unknown;
+    addRoute?: (routeKey: string, config: Record<string, unknown>) => unknown;
+    addAuthorizers?: (authorizers: Record<string, unknown>) => unknown;
+    authorizer?: (name: string, payload: unknown) => unknown;
+    authorizers?: Record<string, unknown>;
+    url?: string;
+};
+type SstAwsNamespace = {
+    ApiGatewayV2: new (name: string, args?: unknown, opts?: unknown) => SstApiGateway;
+    ApiGateway: new (name: string, args?: unknown, opts?: unknown) => SstApiGateway;
+};
+type AwsSource = {
+    sst?: {
+        aws?: SstAwsNamespace;
+    };
+};
+type RegisterRouteConfig = {
+    handler: string;
+    protected: boolean;
+    authorizer?: {
+        name: string;
+        optional?: boolean;
+        roles?: string[];
+        ref?: unknown;
+    };
+};
+type RegisterRoute = (method: HttpMethod, path: string, config: RegisterRouteConfig) => void;
+type EnsureJwtAuthorizer = (name: string, cfg: {
+    issuer: string;
+    audiences: string[];
+}) => unknown;
+declare function wireApiFromManifest(manifest: RoutesManifest, opts: {
+    handlerFile: string;
+    firebaseProjectId: string;
+    registerRoute: RegisterRoute;
+    ensureJwtAuthorizer: EnsureJwtAuthorizer;
+}): void;
+declare function loadRoutesManifest(filePath: string): RoutesManifest;
+type AdapterArgs = AwsSource & {
+    api?: SstApiGateway;
+    apiName?: string;
+    apiArgs?: unknown;
+};
+declare function httpApiAdapter(args?: AdapterArgs): {
+    api: SstApiGateway;
+    registerRoute: RegisterRoute;
+    ensureJwtAuthorizer: EnsureJwtAuthorizer;
+};
+declare function restApiAdapter(args?: AdapterArgs): {
+    api: SstApiGateway;
+    registerRoute: RegisterRoute;
+    ensureJwtAuthorizer: EnsureJwtAuthorizer;
+};
+
+export { type EnsureJwtAuthorizer, type RegisterRoute, type RegisterRouteConfig, RoutesManifest, httpApiAdapter, loadRoutesManifest, restApiAdapter, wireApiFromManifest };

package/dist/infra.js

@@ -0,0 +1,202 @@
+// src/infra.ts
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function ensureSstAws(source) {
+  if (source?.sst?.aws) {
+    return source.sst.aws;
+  }
+  const aws = globalThis.sst?.aws;
+  if (!aws) {
+    throw new Error(
+      "SST aws namespace is not available. Ensure this code runs within an SST config."
+    );
+  }
+  return aws;
+}
+function wireApiFromManifest(manifest, opts) {
+  if (!manifest || !Array.isArray(manifest.routes)) {
+    throw new Error("Invalid routes manifest");
+  }
+  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()");
+    }
+    const issuer = `https://securetoken.google.com/${opts.firebaseProjectId}`;
+    firebaseAuthorizerRef = opts.ensureJwtAuthorizer("firebase", {
+      issuer,
+      audiences: [opts.firebaseProjectId]
+    });
+  }
+  for (const route of manifest.routes) {
+    const isProtected = route.auth.type === "firebase";
+    const path = route.path.startsWith("/") ? route.path : `/${route.path}`;
+    const authConfig = isProtected && route.auth.type === "firebase" ? {
+      name: "firebase",
+      optional: route.auth.optional,
+      roles: route.auth.roles,
+      ref: firebaseAuthorizerRef
+    } : void 0;
+    opts.registerRoute(route.method, path, {
+      handler: opts.handlerFile,
+      protected: isProtected,
+      authorizer: authConfig
+    });
+  }
+}
+function loadRoutesManifest(filePath) {
+  const resolved = resolve(filePath);
+  const contents = 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 authorizers = /* @__PURE__ */ new Map();
+  const ensureJwtAuthorizer = (name, cfg) => {
+    if (authorizers.has(name)) {
+      return authorizers.get(name);
+    }
+    const apiAny = api;
+    let ref = name;
+    const payload = {
+      type: "jwt",
+      jwt: {
+        issuer: cfg.issuer,
+        audience: cfg.audiences
+      }
+    };
+    if (typeof apiAny.addAuthorizers === "function") {
+      apiAny.addAuthorizers({
+        [name]: payload
+      });
+    } else if (typeof apiAny.authorizer === "function") {
+      ref = apiAny.authorizer(name, payload);
+    } else {
+      apiAny.authorizers = {
+        ...apiAny.authorizers ?? {},
+        [name]: payload
+      };
+    }
+    authorizers.set(name, ref);
+    return ref;
+  };
+  const registerRoute = (method, path, config) => {
+    const apiAny = api;
+    const routeKey = `${method} ${path}`;
+    const routeConfig = {
+      handler: config.handler
+    };
+    if (config.protected && config.authorizer) {
+      routeConfig.authorizer = config.authorizer.ref ?? config.authorizer.name;
+      routeConfig.authorizationType = "JWT";
+      if (config.authorizer.roles && config.authorizer.roles.length > 0) {
+        routeConfig.authorizationScopes = config.authorizer.roles;
+      }
+      if (config.authorizer.optional) {
+        routeConfig.authorizerOptional = true;
+      }
+    }
+    if (typeof apiAny.route === "function") {
+      apiAny.route(routeKey, routeConfig);
+      return;
+    }
+    if (typeof apiAny.addRoutes === "function") {
+      apiAny.addRoutes({
+        [routeKey]: routeConfig
+      });
+      return;
+    }
+    if (typeof apiAny.addRoute === "function") {
+      apiAny.addRoute(routeKey, routeConfig);
+      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);
+  const authorizers = /* @__PURE__ */ new Map();
+  const ensureJwtAuthorizer = (name, cfg) => {
+    if (authorizers.has(name)) {
+      return authorizers.get(name);
+    }
+    const apiAny = api;
+    let ref = name;
+    const payload = {
+      type: "jwt",
+      jwt: {
+        issuer: cfg.issuer,
+        audience: cfg.audiences
+      }
+    };
+    if (typeof apiAny.addAuthorizers === "function") {
+      apiAny.addAuthorizers({
+        [name]: payload
+      });
+    } else if (typeof apiAny.authorizer === "function") {
+      ref = apiAny.authorizer(name, payload);
+    } else {
+      apiAny.authorizers = {
+        ...apiAny.authorizers ?? {},
+        [name]: payload
+      };
+    }
+    authorizers.set(name, ref);
+    return ref;
+  };
+  const registerRoute = (method, path, config) => {
+    const apiAny = api;
+    const routeKey = `${method} ${path}`;
+    const routeConfig = {
+      handler: config.handler
+    };
+    if (config.protected && config.authorizer) {
+      routeConfig.authorizer = config.authorizer.ref ?? config.authorizer.name;
+      routeConfig.authorizationType = "JWT";
+      if (config.authorizer.roles && config.authorizer.roles.length > 0) {
+        routeConfig.authorizationScopes = config.authorizer.roles;
+      }
+      if (config.authorizer.optional) {
+        routeConfig.authorizerOptional = true;
+      }
+    }
+    if (typeof apiAny.route === "function") {
+      apiAny.route(routeKey, routeConfig);
+      return;
+    }
+    if (typeof apiAny.addRoutes === "function") {
+      apiAny.addRoutes({
+        [routeKey]: routeConfig
+      });
+      return;
+    }
+    if (typeof apiAny.addRoute === "function") {
+      apiAny.addRoute(routeKey, routeConfig);
+      return;
+    }
+    throw new Error("Unsupported ApiGateway instance: expected route() or addRoutes() method.");
+  };
+  return {
+    api,
+    registerRoute,
+    ensureJwtAuthorizer
+  };
+}
+export {
+  httpApiAdapter,
+  loadRoutesManifest,
+  restApiAdapter,
+  wireApiFromManifest
+};

package/dist/types-D69iuoxv.d.cts

@@ -0,0 +1,54 @@
+import { APIGatewayProxyResult, APIGatewayProxyResultV2, APIGatewayProxyEvent, APIGatewayProxyEventV2 } from 'aws-lambda';
+
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+type FirebaseClaims = Record<string, unknown>;
+type FirebaseAuthOptions = {
+    roles?: string[];
+    optional?: boolean;
+};
+type FirebaseAuthMetadata = FirebaseAuthOptions & {
+    type: "firebase";
+};
+type ResponseLike = APIGatewayProxyResult | APIGatewayProxyResultV2 | {
+    statusCode: number;
+    headers?: Record<string, string>;
+    body?: string;
+    cookies?: string[];
+    isBase64Encoded?: boolean;
+};
+type ResponseHelpers = {
+    json: (status: number, data: unknown, headers?: Record<string, string>) => ResponseLike;
+    text: (status: number, body: string, headers?: Record<string, string>) => ResponseLike;
+    noContent: (headers?: Record<string, string>) => ResponseLike;
+};
+type HandlerContext = {
+    event: APIGatewayProxyEvent | APIGatewayProxyEventV2;
+    lambdaContext: unknown;
+    params: Record<string, string>;
+    query: Record<string, string | undefined>;
+    body: unknown;
+    headers: Record<string, string | undefined>;
+    auth?: FirebaseClaims;
+    response: ResponseHelpers;
+};
+type Handler = (...args: unknown[]) => Promise<ResponseLike | void | undefined> | ResponseLike | void | undefined;
+type RouteOptions = {
+    inferPathFromName?: boolean;
+};
+type RoutesManifestAuth = {
+    type: "none";
+} | {
+    type: "firebase";
+    optional?: boolean;
+    roles?: string[];
+};
+type RoutesManifestRoute = {
+    method: HttpMethod;
+    path: string;
+    auth: RoutesManifestAuth;
+};
+type RoutesManifest = {
+    routes: RoutesManifestRoute[];
+};
+
+export type { FirebaseAuthOptions as F, HttpMethod as H, RoutesManifest as R, RoutesManifestRoute as a, RoutesManifestAuth as b, ResponseLike as c, RouteOptions as d, Handler as e, HandlerContext as f, FirebaseAuthMetadata as g };

package/dist/types-D69iuoxv.d.ts

@@ -0,0 +1,54 @@
+import { APIGatewayProxyResult, APIGatewayProxyResultV2, APIGatewayProxyEvent, APIGatewayProxyEventV2 } from 'aws-lambda';
+
+type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "HEAD" | "OPTIONS";
+type FirebaseClaims = Record<string, unknown>;
+type FirebaseAuthOptions = {
+    roles?: string[];
+    optional?: boolean;
+};
+type FirebaseAuthMetadata = FirebaseAuthOptions & {
+    type: "firebase";
+};
+type ResponseLike = APIGatewayProxyResult | APIGatewayProxyResultV2 | {
+    statusCode: number;
+    headers?: Record<string, string>;
+    body?: string;
+    cookies?: string[];
+    isBase64Encoded?: boolean;
+};
+type ResponseHelpers = {
+    json: (status: number, data: unknown, headers?: Record<string, string>) => ResponseLike;
+    text: (status: number, body: string, headers?: Record<string, string>) => ResponseLike;
+    noContent: (headers?: Record<string, string>) => ResponseLike;
+};
+type HandlerContext = {
+    event: APIGatewayProxyEvent | APIGatewayProxyEventV2;
+    lambdaContext: unknown;
+    params: Record<string, string>;
+    query: Record<string, string | undefined>;
+    body: unknown;
+    headers: Record<string, string | undefined>;
+    auth?: FirebaseClaims;
+    response: ResponseHelpers;
+};
+type Handler = (...args: unknown[]) => Promise<ResponseLike | void | undefined> | ResponseLike | void | undefined;
+type RouteOptions = {
+    inferPathFromName?: boolean;
+};
+type RoutesManifestAuth = {
+    type: "none";
+} | {
+    type: "firebase";
+    optional?: boolean;
+    roles?: string[];
+};
+type RoutesManifestRoute = {
+    method: HttpMethod;
+    path: string;
+    auth: RoutesManifestAuth;
+};
+type RoutesManifest = {
+    routes: RoutesManifestRoute[];
+};
+
+export type { FirebaseAuthOptions as F, HttpMethod as H, RoutesManifest as R, RoutesManifestRoute as a, RoutesManifestAuth as b, ResponseLike as c, RouteOptions as d, Handler as e, HandlerContext as f, FirebaseAuthMetadata as g };