import "reflect-metadata";
import { Client, Guild, GuildBan, GuildMember, ShardingManager } from "discord.js";
import { Context, Hono, Next } from "hono";

//#region src/types/ban-options.type.d.ts
interface BanOptions {
  readonly deleteMessageSeconds?: number;
}
//# sourceMappingURL=ban-options.type.d.ts.map
//#endregion
//#region src/types/constructor.type.d.ts
type Constructor<T = object> = new (...args: any[]) => T;
//#endregion
//#region src/types/http-method.type.d.ts
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
//# sourceMappingURL=http-method.type.d.ts.map
//#endregion
//#region src/types/param-source.type.d.ts
type ParamSource = 'param' | 'query' | 'body' | 'header' | 'ctx';
//# sourceMappingURL=param-source.type.d.ts.map
//#endregion
//#region src/types/param-definition.type.d.ts
interface ParamDefinition {
  readonly index: number;
  readonly source: ParamSource;
  readonly key?: string;
  readonly dto?: new (...args: Array<unknown>) => object;
}
//# sourceMappingURL=param-definition.type.d.ts.map
//#endregion
//#region src/types/route-definition.type.d.ts
interface RouteDefinition {
  readonly method: HttpMethod;
  readonly path: string;
  readonly handlerName: string;
}
//# sourceMappingURL=route-definition.type.d.ts.map
//#endregion
//#region src/types/serialized-user.type.d.ts
interface SerializedUser {
  readonly id: string;
  readonly username: string;
  readonly discriminator: string;
  readonly avatar: string | null;
  readonly bot: boolean;
  readonly createdAt: string;
}
//# sourceMappingURL=serialized-user.type.d.ts.map
//#endregion
//#region src/types/serialized-ban.type.d.ts
interface SerializedBan {
  readonly user: SerializedUser;
  readonly reason: string | null;
}
//# sourceMappingURL=serialized-ban.type.d.ts.map
//#endregion
//#region src/types/serialized-guild.type.d.ts
interface SerializedGuild {
  readonly id: string;
  readonly name: string;
  readonly icon: string | null;
  readonly memberCount: number;
  readonly ownerId: string;
  readonly createdAt: string;
  readonly features: Array<string>;
}
//# sourceMappingURL=serialized-guild.type.d.ts.map
//#endregion
//#region src/types/serialized-role.type.d.ts
interface SerializedRole {
  readonly id: string;
  readonly name: string;
  readonly color: string;
  readonly position: number;
  readonly permissions: string;
  readonly managed: boolean;
  readonly mentionable: boolean;
}
//# sourceMappingURL=serialized-role.type.d.ts.map
//#endregion
//#region src/types/serialized-member.type.d.ts
interface SerializedMember {
  readonly id: string;
  readonly username: string;
  readonly displayName: string;
  readonly discriminator: string;
  readonly avatar: string | null;
  readonly bot: boolean;
  readonly joinedAt: string | null;
  readonly createdAt: string;
  readonly roles: Array<SerializedRole>;
  readonly pending: boolean;
  readonly communicationDisabledUntil: string | null;
}
//# sourceMappingURL=serialized-member.type.d.ts.map
//#endregion
//#region src/interfaces/bot-bridge.interface.d.ts
declare abstract class BotBridge {
  abstract getGuild(guildId: string): Promise<SerializedGuild | null>;
  abstract getMember(guildId: string, userId: string): Promise<SerializedMember | null>;
  abstract getMembers(guildId: string): Promise<Array<SerializedMember> | null>;
  abstract getBan(guildId: string, userId: string): Promise<SerializedBan | null>;
  abstract getBans(guildId: string): Promise<Array<SerializedBan>>;
  abstract banMember(guildId: string, userId: string, reason: string, options?: BanOptions): Promise<boolean>;
  abstract unbanMember(guildId: string, userId: string): Promise<boolean>;
  abstract kickMember(guildId: string, userId: string, reason: string): Promise<boolean>;
  abstract timeoutMember(guildId: string, userId: string, durationMs: number, reason: string): Promise<boolean>;
  abstract removeTimeoutMember(guildId: string, userId: string): Promise<boolean>;
  abstract addRole(guildId: string, userId: string, roleId: string): Promise<boolean>;
  abstract removeRole(guildId: string, userId: string, roleId: string): Promise<boolean>;
}
//# sourceMappingURL=bot-bridge.interface.d.ts.map
//#endregion
//#region src/interfaces/http-guard.interface.d.ts
interface HttpGuard {
  canActivate(ctx: Context): Promise<boolean>;
}
//# sourceMappingURL=http-guard.interface.d.ts.map
//#endregion
//#region src/interfaces/http-middleware.interface.d.ts
interface HttpMiddleware {
  handle(ctx: Context, next: Next): Promise<undefined | Response>;
}
//# sourceMappingURL=http-middleware.interface.d.ts.map
//#endregion
//#region src/interfaces/http-client-module-metadata.interface.d.ts
interface HttpClientModuleMetadata {
  readonly services?: Array<Constructor>;
  readonly controllers?: Array<Constructor>;
  readonly guards?: Array<Constructor<HttpGuard>>;
  readonly middleware?: Array<HttpMiddleware>;
  readonly middlewareProviders?: Map<Constructor, HttpMiddleware>;
}
//# sourceMappingURL=http-client-module-metadata.interface.d.ts.map
//#endregion
//#region src/interfaces/rate-limit-config.interface.d.ts
interface RateLimitConfig {
  /** Sliding-window duration in milliseconds. */
  readonly windowMs: number;
  /** Maximum requests allowed per client within `windowMs`. */
  readonly max: number;
  /**
   * IPs of reverse proxies you trust to set the `X-Forwarded-For` header.
   * Requests whose direct peer address is in this list will use the leftmost
   * entry of `X-Forwarded-For` as the rate-limit key. For any other request
   * the header is ignored and the direct peer IP is used.
   *
   * If omitted, `X-Forwarded-For` is never trusted and only the direct peer
   * IP is used - the safe default that prevents header-spoofing bypass.
   *
   * Should mirror the `security.trustedProxies.proxies` you pass to
   * `defineHttp()`.
   *
   * @default []
   */
  readonly trustedProxies?: ReadonlyArray<string>;
}
//# sourceMappingURL=rate-limit-config.interface.d.ts.map
//#endregion
//#region src/interfaces/security-config.interface.d.ts
interface CorsConfig {
  /** Allowed origins. Use `'*'` to allow all (not recommended for production). @default [] */
  readonly origins: ReadonlyArray<string>;
  /** Allowed HTTP methods. @default ['GET','POST','PUT','PATCH','DELETE','OPTIONS'] */
  readonly methods?: ReadonlyArray<string>;
  /** Allowed request headers. @default ['Content-Type','Authorization','X-Api-Key'] */
  readonly allowedHeaders?: ReadonlyArray<string>;
  /** Headers exposed to the browser. @default [] */
  readonly exposedHeaders?: ReadonlyArray<string>;
  /** Allow credentials (cookies, auth headers). @default false */
  readonly credentials?: boolean;
  /** Preflight cache duration in seconds. @default 600 */
  readonly maxAge?: number;
}
interface SecurityHeadersConfig {
  /** X-Content-Type-Options: nosniff. @default true */
  readonly noSniff?: boolean;
  /** X-Frame-Options header value. @default 'DENY' */
  readonly frameOptions?: 'DENY' | 'SAMEORIGIN' | false;
  /** X-XSS-Protection: 1; mode=block. @default true */
  readonly xssProtection?: boolean;
  /** Strict-Transport-Security max-age in seconds. 0 to disable. @default 31536000 */
  readonly hstsMaxAge?: number;
  /** Include subdomains in HSTS. @default true */
  readonly hstsIncludeSubDomains?: boolean;
  /** Referrer-Policy value. @default 'no-referrer' */
  readonly referrerPolicy?: string | false;
  /** Permissions-Policy header value. @default 'camera=(), microphone=(), geolocation=()' */
  readonly permissionsPolicy?: string | false;
  /** Content-Security-Policy header value. Set to false to disable. @default "default-src 'none'" */
  readonly contentSecurityPolicy?: string | false;
  /** Cross-Origin-Opener-Policy. @default 'same-origin' */
  readonly crossOriginOpenerPolicy?: string | false;
  /** Cross-Origin-Resource-Policy. @default 'same-origin' */
  readonly crossOriginResourcePolicy?: string | false;
  /** X-Permitted-Cross-Domain-Policies. @default 'none' */
  readonly crossDomainPolicies?: string | false;
  /** X-DNS-Prefetch-Control. @default 'off' */
  readonly dnsPrefetchControl?: 'on' | 'off' | false;
  /** X-Download-Options: noopen (IE-specific). @default true */
  readonly downloadOptions?: boolean;
}
interface BodyLimitConfig {
  /** Maximum body size in bytes. @default 102400 (100KB) */
  readonly maxSize: number;
}
interface TrustedProxyConfig {
  /** Trusted proxy IPs or CIDR ranges. Requests from these IPs use X-Forwarded-For. @default ['127.0.0.1','::1'] */
  readonly proxies: ReadonlyArray<string>;
}
interface SecurityConfig {
  /** CORS configuration. Set to false to disable. */
  readonly cors?: CorsConfig | false;
  /** Security headers (helmet-like). Set to false to disable all. */
  readonly headers?: SecurityHeadersConfig | false;
  /** Request body size limit. Set to false to disable. */
  readonly bodyLimit?: BodyLimitConfig | false;
  /** Trusted proxy configuration. */
  readonly trustedProxies?: TrustedProxyConfig;
  /** Hide X-Powered-By / Server headers. @default true */
  readonly hidePoweredBy?: boolean;
}
//# sourceMappingURL=security-config.interface.d.ts.map
//#endregion
//#region src/interfaces/http-config.interface.d.ts
/**
 * Configures the per-request access log emitted by `LoggerMiddleware`.
 *
 * - `true` / omit - default behaviour (info on success, warn on 4xx/5xx)
 * - `false` - disable all request logging
 * - object - override the log level used for successful or error responses
 */
type AccessLogConfig = boolean | {
  /** Level used for 2xx/3xx responses. `'off'` silences them. Defaults to `'info'`. */
  successLevel?: 'info' | 'debug' | 'off';
  /** Level used for 4xx/5xx responses. Defaults to `'warn'`. */
  errorLevel?: 'warn' | 'error';
};
interface HttpConfig {
  readonly enabled: boolean;
  readonly port: number;
  readonly host: string;
  readonly apiKey: string;
  readonly rateLimit?: RateLimitConfig;
  readonly security?: SecurityConfig;
  readonly sharding: boolean;
  readonly module?: Constructor;
  /**
   * Controls request-level access logging for `LoggerMiddleware`.
   * Pass the value through to `new LoggerMiddleware(config.accessLog)`.
   */
  readonly accessLog?: AccessLogConfig;
}
//# sourceMappingURL=http-config.interface.d.ts.map
//#endregion
//#region src/interfaces/http-module.interface.d.ts
interface HttpModuleOptions {
  readonly controllers?: Array<Constructor>;
  readonly guards?: Array<HttpGuard>;
  readonly middleware?: Array<HttpMiddleware>;
  readonly middlewareProviders?: Map<Constructor, HttpMiddleware>;
  readonly shardingManager?: ShardingManager;
}
//# sourceMappingURL=http-module.interface.d.ts.map
//#endregion
//#region src/interfaces/registered-controller.interface.d.ts
interface RegisteredController {
  readonly instance: object;
  readonly prefix: string;
  readonly routes: Array<RouteDefinition>;
  readonly classMiddlewares: Array<Constructor>;
  readonly classGuards: Array<Constructor>;
}
//# sourceMappingURL=registered-controller.interface.d.ts.map
//#endregion
//#region src/interfaces/error-validation-detail.interface.d.ts
interface ValidationDetail {
  readonly property: string;
  readonly constraints: Record<string, string>;
}
//# sourceMappingURL=error-validation-detail.interface.d.ts.map
//#endregion
//#region src/bridge/bridge.factory.d.ts
declare class BridgeFactory {
  static create(client?: Client, manager?: ShardingManager): BotBridge;
}
//# sourceMappingURL=bridge.factory.d.ts.map
//#endregion
//#region src/bridge/direct-bot.bridge.d.ts
declare class DirectBotBridge extends BotBridge {
  private readonly client;
  constructor(client: Client);
  getGuild(guildId: string): Promise<SerializedGuild | null>;
  getMember(guildId: string, userId: string): Promise<SerializedMember | null>;
  getMembers(guildId: string): Promise<Array<SerializedMember> | null>;
  getBan(guildId: string, userId: string): Promise<SerializedBan | null>;
  getBans(guildId: string): Promise<Array<SerializedBan>>;
  banMember(guildId: string, userId: string, reason: string, options?: BanOptions): Promise<boolean>;
  unbanMember(guildId: string, userId: string): Promise<boolean>;
  kickMember(guildId: string, userId: string, reason: string): Promise<boolean>;
  timeoutMember(guildId: string, userId: string, durationMs: number, reason: string): Promise<boolean>;
  removeTimeoutMember(guildId: string, userId: string): Promise<boolean>;
  addRole(guildId: string, userId: string, roleId: string): Promise<boolean>;
  removeRole(guildId: string, userId: string, roleId: string): Promise<boolean>;
}
//# sourceMappingURL=direct-bot.bridge.d.ts.map
//#endregion
//#region src/bridge/sharded-bot.bridge.d.ts
declare class ShardedBotBridge extends BotBridge {
  private readonly manager;
  constructor(manager: ShardingManager);
  getGuild(guildId: string): Promise<SerializedGuild | null>;
  getMember(guildId: string, userId: string): Promise<SerializedMember | null>;
  getMembers(guildId: string): Promise<Array<SerializedMember> | null>;
  getBan(guildId: string, userId: string): Promise<SerializedBan | null>;
  getBans(guildId: string): Promise<Array<SerializedBan>>;
  banMember(guildId: string, userId: string, reason: string, options?: BanOptions): Promise<boolean>;
  unbanMember(guildId: string, userId: string): Promise<boolean>;
  kickMember(guildId: string, userId: string, reason: string): Promise<boolean>;
  timeoutMember(guildId: string, userId: string, durationMs: number, reason: string): Promise<boolean>;
  removeTimeoutMember(guildId: string, userId: string): Promise<boolean>;
  addRole(guildId: string, userId: string, roleId: string): Promise<boolean>;
  removeRole(guildId: string, userId: string, roleId: string): Promise<boolean>;
}
//# sourceMappingURL=sharded-bot.bridge.d.ts.map
//#endregion
//#region src/bridge/serializers/guild.serializer.d.ts
declare class GuildSerializer {
  serialize(guild: Guild): SerializedGuild;
}
//# sourceMappingURL=guild.serializer.d.ts.map
//#endregion
//#region src/bridge/serializers/member.serializer.d.ts
declare class MemberSerializer {
  serialize(member: GuildMember): SerializedMember;
  serializeMany(members: Array<GuildMember>): Array<SerializedMember>;
}
//# sourceMappingURL=member.serializer.d.ts.map
//#endregion
//#region src/bridge/serializers/ban.serializer.d.ts
declare class BanSerializer {
  serialize(ban: GuildBan): SerializedBan;
  serializeMany(bans: Array<GuildBan>): Array<SerializedBan>;
}
//# sourceMappingURL=ban.serializer.d.ts.map
//#endregion
//#region src/constants/defaults.constant.d.ts
declare const HTTP_DEFAULTS: {
  readonly HOST: "0.0.0.0";
  readonly PORT: 3000;
};
//#endregion
//#region src/constants/metadata-keys.constant.d.ts
declare const HTTP_METADATA_KEYS: {
  readonly PREFIX: "spraxium:http:prefix";
  readonly ROUTES: "spraxium:http:routes";
  readonly MIDDLEWARE: "spraxium:http:middleware";
  readonly GUARDS: "spraxium:http:guards";
  readonly PARAMS: "spraxium:http:params";
  readonly STATUS_CODE: "spraxium:http:status_code";
  readonly HTTP_CLIENT_MODULE: "spraxium:http:client_module";
};
//# sourceMappingURL=metadata-keys.constant.d.ts.map
//#endregion
//#region src/constants/security-defaults.constant.d.ts
declare const SECURITY_DEFAULTS: Required<Pick<SecurityConfig, 'hidePoweredBy'>> & {
  headers: Required<SecurityHeadersConfig>;
  cors: null;
  bodyLimit: BodyLimitConfig;
  trustedProxies: TrustedProxyConfig;
};
//# sourceMappingURL=security-defaults.constant.d.ts.map
//#endregion
//#region src/decorators/route.decorator.d.ts
declare function HttpController(prefix: string): ClassDecorator;
declare function HttpGet(path?: string): MethodDecorator;
declare function HttpPost(path?: string): MethodDecorator;
declare function HttpPut(path?: string): MethodDecorator;
declare function HttpPatch(path?: string): MethodDecorator;
declare function HttpDelete(path?: string): MethodDecorator;
declare function HttpUseMiddleware(...middlewareClasses: Array<Constructor>): ClassDecorator & MethodDecorator;
declare function HttpStatus(code: number): MethodDecorator;
declare function HttpGuards(...guardClasses: Array<Constructor>): ClassDecorator & MethodDecorator;
//# sourceMappingURL=route.decorator.d.ts.map
//#endregion
//#region src/decorators/param.decorator.d.ts
declare function HttpParam(key: string): ParameterDecorator;
declare function HttpQuery(key: string): ParameterDecorator;
declare function HttpBody(dto?: new (...args: Array<unknown>) => object): ParameterDecorator;
declare function HttpHeader(key: string): ParameterDecorator;
declare function HttpCtx(): ParameterDecorator;
//# sourceMappingURL=param.decorator.d.ts.map
//#endregion
//#region src/decorators/http-client-module.decorator.d.ts
declare function HttpClientModule(metadata: HttpClientModuleMetadata): ClassDecorator;
//# sourceMappingURL=http-client-module.decorator.d.ts.map
//#endregion
//#region src/errors/http.error.d.ts
declare class HttpError extends Error {
  readonly statusCode: number;
  constructor(message: string, statusCode: number);
}
//# sourceMappingURL=http.error.d.ts.map
//#endregion
//#region src/errors/bad-request.error.d.ts
declare class BadRequestError extends HttpError {
  constructor(message?: string);
}
//# sourceMappingURL=bad-request.error.d.ts.map
//#endregion
//#region src/errors/conflict.error.d.ts
declare class ConflictError extends HttpError {
  constructor(message?: string);
}
//# sourceMappingURL=conflict.error.d.ts.map
//#endregion
//#region src/errors/forbidden.error.d.ts
declare class ForbiddenError extends HttpError {
  constructor(message?: string);
}
//# sourceMappingURL=forbidden.error.d.ts.map
//#endregion
//#region src/errors/internal-server.error.d.ts
declare class InternalServerError extends HttpError {
  constructor(message?: string);
}
//# sourceMappingURL=internal-server.error.d.ts.map
//#endregion
//#region src/errors/method-not-allowed.error.d.ts
declare class MethodNotAllowedError extends HttpError {
  constructor(message?: string);
}
//# sourceMappingURL=method-not-allowed.error.d.ts.map
//#endregion
//#region src/errors/not-found.error.d.ts
declare class NotFoundError extends HttpError {
  constructor(message?: string);
}
//# sourceMappingURL=not-found.error.d.ts.map
//#endregion
//#region src/errors/not-implemented.error.d.ts
declare class NotImplementedError extends HttpError {
  constructor(message?: string);
}
//# sourceMappingURL=not-implemented.error.d.ts.map
//#endregion
//#region src/errors/service-unavailable.error.d.ts
declare class ServiceUnavailableError extends HttpError {
  constructor(message?: string);
}
//# sourceMappingURL=service-unavailable.error.d.ts.map
//#endregion
//#region src/errors/too-many-requests.error.d.ts
declare class TooManyRequestsError extends HttpError {
  constructor(message?: string);
}
//# sourceMappingURL=too-many-requests.error.d.ts.map
//#endregion
//#region src/errors/unauthorized.error.d.ts
declare class UnauthorizedError extends HttpError {
  constructor(message?: string);
}
//# sourceMappingURL=unauthorized.error.d.ts.map
//#endregion
//#region src/errors/unprocessable-entity.error.d.ts
declare class UnprocessableEntityError extends HttpError {
  constructor(message?: string);
}
//# sourceMappingURL=unprocessable-entity.error.d.ts.map
//#endregion
//#region src/errors/validation.error.d.ts
declare class ValidationError extends HttpError {
  readonly details: Array<ValidationDetail>;
  constructor(details: Array<ValidationDetail>);
}
//# sourceMappingURL=validation.error.d.ts.map
//#endregion
//#region src/guards/api-key.guard.d.ts
declare class ApiKeyGuard implements HttpGuard {
  private readonly keyBuffer;
  constructor(apiKey: string);
  canActivate(ctx: Context): Promise<boolean>;
}
//# sourceMappingURL=api-key.guard.d.ts.map
//#endregion
//#region src/guards/guard.executor.d.ts
declare class GuardExecutor {
  private readonly guards;
  constructor(guards: ReadonlyArray<HttpGuard>);
  execute(ctx: Context): Promise<boolean>;
}
//# sourceMappingURL=guard.executor.d.ts.map

//#endregion
//#region ../core/dist/index.d.ts

//#endregion
//#region src/config/interfaces/config.interface.d.ts
interface SpraxiumPlugin<N extends string = string, C = unknown> {
  readonly namespace: N;
  readonly config: C;
}
type PluginFactory<N extends string, C> = ((config: C) => SpraxiumPlugin<N, C>) & {
  readonly namespace: N;
};
//#endregion
//#region src/http.config.d.ts
declare const defineHttp: PluginFactory<"http", HttpConfig>;
//# sourceMappingURL=http.config.d.ts.map
//#endregion
//#region src/http.module.d.ts
declare class HttpModule {}
//# sourceMappingURL=http.module.d.ts.map
//#endregion
//#region src/middleware/body-limit.middleware.d.ts
declare class BodyLimitMiddleware implements HttpMiddleware {
  private readonly handler;
  constructor(config?: BodyLimitConfig);
  handle(ctx: Context, next: Next): Promise<undefined | Response>;
}
//# sourceMappingURL=body-limit.middleware.d.ts.map
//#endregion
//#region src/middleware/cors.middleware.d.ts
declare class CorsMiddleware implements HttpMiddleware {
  private readonly handler;
  constructor(config: CorsConfig);
  handle(ctx: Context, next: Next): Promise<undefined | Response>;
}
//# sourceMappingURL=cors.middleware.d.ts.map
//#endregion
//#region src/middleware/logger.middleware.d.ts
declare class LoggerMiddleware implements HttpMiddleware {
  private readonly config?;
  constructor(config?: AccessLogConfig | undefined);
  handle(ctx: Context, next: Next): Promise<undefined>;
}
//# sourceMappingURL=logger.middleware.d.ts.map
//#endregion
//#region src/middleware/rate-limit.middleware.d.ts
declare class RateLimitMiddleware implements HttpMiddleware {
  private readonly config;
  private readonly store;
  private readonly cleanupInterval;
  private readonly trustedProxies;
  constructor(config: RateLimitConfig);
  handle(ctx: Context, next: Next): Promise<undefined>;
  destroy(): void;
  /**
   * Resolves the bucket key for the request. Direct peer IP is used by default;
   * `X-Forwarded-For` is honoured only when the direct peer is explicitly listed
   * as a trusted proxy. This prevents an unauthenticated client from bypassing
   * the limiter by spoofing the header.
   */
  private resolveClientIp;
  private static getDirectIp;
  private static parseLeftmost;
  private static normalizeIp;
  private evict;
}
//# sourceMappingURL=rate-limit.middleware.d.ts.map
//#endregion
//#region src/middleware/security-headers.middleware.d.ts
declare class SecurityHeadersMiddleware implements HttpMiddleware {
  private readonly handler;
  constructor(config?: SecurityHeadersConfig | false);
  handle(ctx: Context, next: Next): Promise<undefined | Response>;
}
//# sourceMappingURL=security-headers.middleware.d.ts.map
//#endregion
//#region src/service/http-registry.service.d.ts
declare class HttpRegistry {
  static shardingManager: ShardingManager | undefined;
  static reset(): void;
}
//# sourceMappingURL=http-registry.service.d.ts.map

//#endregion
//#region ../common/dist/index.d.ts
//# sourceMappingURL=spraxium-guard.interface.d.ts.map
//#endregion
//#region src/interfaces/lifecycle.interface.d.ts
interface SpraxiumOnBoot {
  onBoot(): void | Promise<void>;
}
interface SpraxiumOnShutdown {
  onShutdown(): void | Promise<void>;
}
//# sourceMappingURL=lifecycle.interface.d.ts.map
//#endregion
//#region src/interfaces/readonly-container.interface.d.ts
declare abstract class ReadonlyContainer {
  abstract get<T = unknown>(token: unknown): T | undefined;
}
//# sourceMappingURL=readonly-container.interface.d.ts.map
//#endregion
//#region src/interfaces/guard-entry.interface.d.ts
//#endregion
//#region src/service/http-server.service.d.ts
declare class HttpServer implements SpraxiumOnBoot, SpraxiumOnShutdown {
  private readonly client?;
  private readonly coreContainer?;
  private readonly log;
  private server;
  private readonly middlewareDisposables;
  constructor(client?: Client | undefined, coreContainer?: ReadonlyContainer | undefined);
  onBoot(): Promise<void>;
  start(client?: Client): Promise<void>;
  onShutdown(): Promise<void>;
}
//# sourceMappingURL=http-server.service.d.ts.map
//#endregion
//#region src/service/param-resolver.service.d.ts
declare class ParamResolver {
  private readonly validation;
  resolve(instance: object, handlerName: string, ctx: Context): Promise<Array<unknown>>;
}
//# sourceMappingURL=param-resolver.service.d.ts.map
//#endregion
//#region src/service/route-builder.service.d.ts
declare class RouteBuilder {
  private static readonly paramResolver;
  static register(app: Hono, controllers: Array<RegisteredController>, middlewareProviders?: Map<Constructor, HttpMiddleware>, deps?: Map<unknown, unknown>, fallback?: ReadonlyContainer): void;
}
//# sourceMappingURL=route-builder.service.d.ts.map
//#endregion
//#region src/service/route-registry.service.d.ts
declare class RouteRegistry {
  resolveServices(serviceCls: Array<Constructor>, deps: Map<unknown, unknown>, fallback?: ReadonlyContainer): void;
  resolveGuards(guardClasses: Array<Constructor>, deps: Map<unknown, unknown>, fallback?: ReadonlyContainer): Array<object>;
  resolveAll(controllerClasses: Array<Constructor>, deps: Map<unknown, unknown>, fallback?: ReadonlyContainer): Array<RegisteredController>;
  private resolve;
  private sortByDependency;
  private instantiate;
}
//# sourceMappingURL=route-registry.service.d.ts.map
//#endregion
//#region src/service/validation-pipe.service.d.ts
declare class ValidationPipe {
  transform<T extends object>(dto: new (...args: Array<unknown>) => T, body: unknown): Promise<T>;
}
//# sourceMappingURL=validation-pipe.service.d.ts.map

//#endregion
export { ApiKeyGuard, BadRequestError, type BanOptions, BanSerializer, type BodyLimitConfig, BodyLimitMiddleware, BotBridge, BridgeFactory, ConflictError, type Constructor, type CorsConfig, CorsMiddleware, DirectBotBridge, ForbiddenError, GuardExecutor, GuildSerializer, HTTP_DEFAULTS, HTTP_METADATA_KEYS, HttpBody, HttpClientModule, type HttpClientModuleMetadata, type HttpConfig, HttpController, HttpCtx, HttpDelete, HttpError, HttpGet, type HttpGuard, HttpGuards, HttpHeader, type HttpMethod, type HttpMiddleware, HttpModule, type HttpModuleOptions, HttpParam, HttpPatch, HttpPost, HttpPut, HttpQuery, HttpRegistry, HttpServer, HttpStatus, HttpUseMiddleware, InternalServerError, LoggerMiddleware, MemberSerializer, MethodNotAllowedError, NotFoundError, NotImplementedError, type ParamDefinition, ParamResolver, type ParamSource, type RateLimitConfig, RateLimitMiddleware, type RegisteredController, RouteBuilder, type RouteDefinition, RouteRegistry, SECURITY_DEFAULTS, type SecurityConfig, type SecurityHeadersConfig, SecurityHeadersMiddleware, type SerializedBan, type SerializedGuild, type SerializedMember, type SerializedRole, type SerializedUser, ServiceUnavailableError, ShardedBotBridge, TooManyRequestsError, type TrustedProxyConfig, UnauthorizedError, UnprocessableEntityError, type ValidationDetail, ValidationError, ValidationPipe, defineHttp };
//# sourceMappingURL=index.d.ts.map