@tahminator/sapling 2.0.5 → 2.1.0-beta.a2de2fb9

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import e, { ErrorRequestHandler, NextFunction, Request, Response, Router } from "express";
+import e, { ErrorRequestHandler, NextFunction, Request as Request$1, RequestHandler, Response as Response$1, Router } from "express";
 
 //#region src/html/404.d.ts
 /**
@@ -26,7 +26,7 @@ type RouteDefinition = {
 };
 type Class<T> = new (...args: any[]) => T;
 type HttpHeaders = Record<string, string>;
-type ExpressMiddlewareFn = ($1: Request, $2: Response, $3: NextFunction) => void;
+type ExpressMiddlewareFn = ($1: Request$1, $2: Response$1, $3: NextFunction) => void;
 //#endregion
 //#region src/annotation/controller.d.ts
 declare const _ControllerRegistry: WeakMap<Function, Router | ErrorRequestHandler>;
@@ -230,6 +230,45 @@ declare namespace StandardSchemaV1 {
   type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
 }
 /** The Standard JSON Schema interface. */
+interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard JSON Schema properties. */
+  readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardJSONSchemaV1 {
+  /** The Standard JSON Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Methods for generating the input/output JSON Schema. */
+    readonly jsonSchema: StandardJSONSchemaV1.Converter;
+  }
+  /** The Standard JSON Schema converter interface. */
+  interface Converter {
+    /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+    readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+    readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+  }
+  /**
+   * The target version of the generated JSON Schema.
+   *
+   * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+   *
+   * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+   */
+  type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+  /** The options for the input/output methods. */
+  interface Options {
+    /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+    readonly target: Target;
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
 //#endregion
 //#region src/helper/redirect.d.ts
 /**
@@ -398,16 +437,373 @@ declare class ResponseStatusError extends Error {
 }
 //#endregion
 //#region src/helper/error/parse.d.ts
-type ParserErrorLocation = "reqbody" | "reqparams" | "reqquery";
+type ParserErrorLocation = "reqbody" | "reqparams" | "reqquery" | "resbody";
 /**
- * This error should be thrown when some data cannot be parsed by a given schema.
+ * This error should be thrown when some data cannot be parsed by a given Standard Schema compatible schema.
  */
 declare class ParserError extends ResponseStatusError {
-  constructor(location: ParserErrorLocation, issues: readonly StandardSchemaV1.Issue[], vendor: string);
+  constructor(location: ParserErrorLocation, issues: readonly StandardSchemaV1.Issue[], vendor: string, functionName: string);
   private static formatMessage;
+  static getPrettyLocationString(location: ParserErrorLocation): "request body" | "request params" | "request query" | "response body";
 }
 //#endregion
+//#region node_modules/.pnpm/openapi-types@12.1.3/node_modules/openapi-types/dist/index.d.ts
+declare namespace OpenAPIV3 {
+  interface Document<T extends {} = {}> {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject<T>;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+    'x-express-openapi-additional-middleware'?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
+    'x-express-openapi-validation-strict'?: boolean;
+  }
+  interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+  }
+  interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+  }
+  interface LicenseObject {
+    name: string;
+    url?: string;
+  }
+  interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: {
+      [variable: string]: ServerVariableObject;
+    };
+  }
+  interface ServerVariableObject {
+    enum?: string[];
+    default: string;
+    description?: string;
+  }
+  interface PathsObject<T extends {} = {}, P extends {} = {}> {
+    [pattern: string]: (PathItemObject<T> & P) | undefined;
+  }
+  enum HttpMethods {
+    GET = "get",
+    PUT = "put",
+    POST = "post",
+    DELETE = "delete",
+    OPTIONS = "options",
+    HEAD = "head",
+    PATCH = "patch",
+    TRACE = "trace"
+  }
+  type PathItemObject<T extends {} = {}> = {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    servers?: ServerObject[];
+    parameters?: (ReferenceObject | ParameterObject)[];
+  } & { [method in HttpMethods]?: OperationObject<T> };
+  type OperationObject<T extends {} = {}> = {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ReferenceObject | ParameterObject)[];
+    requestBody?: ReferenceObject | RequestBodyObject;
+    responses: ResponsesObject;
+    callbacks?: {
+      [callback: string]: ReferenceObject | CallbackObject;
+    };
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+  } & T;
+  interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+  }
+  interface ParameterObject extends ParameterBaseObject {
+    name: string;
+    in: string;
+  }
+  interface HeaderObject extends ParameterBaseObject {}
+  interface ParameterBaseObject {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: ReferenceObject | SchemaObject;
+    example?: any;
+    examples?: {
+      [media: string]: ReferenceObject | ExampleObject;
+    };
+    content?: {
+      [media: string]: MediaTypeObject;
+    };
+  }
+  type NonArraySchemaObjectType = 'boolean' | 'object' | 'number' | 'string' | 'integer';
+  type ArraySchemaObjectType = 'array';
+  type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+  interface ArraySchemaObject extends BaseSchemaObject {
+    type: ArraySchemaObjectType;
+    items: ReferenceObject | SchemaObject;
+  }
+  interface NonArraySchemaObject extends BaseSchemaObject {
+    type?: NonArraySchemaObjectType;
+  }
+  interface BaseSchemaObject {
+    title?: string;
+    description?: string;
+    format?: string;
+    default?: any;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    additionalProperties?: boolean | ReferenceObject | SchemaObject;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+    properties?: {
+      [name: string]: ReferenceObject | SchemaObject;
+    };
+    allOf?: (ReferenceObject | SchemaObject)[];
+    oneOf?: (ReferenceObject | SchemaObject)[];
+    anyOf?: (ReferenceObject | SchemaObject)[];
+    not?: ReferenceObject | SchemaObject;
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XMLObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    deprecated?: boolean;
+  }
+  interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: {
+      [value: string]: string;
+    };
+  }
+  interface XMLObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+  }
+  interface ReferenceObject {
+    $ref: string;
+  }
+  interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+  }
+  interface MediaTypeObject {
+    schema?: ReferenceObject | SchemaObject;
+    example?: any;
+    examples?: {
+      [media: string]: ReferenceObject | ExampleObject;
+    };
+    encoding?: {
+      [media: string]: EncodingObject;
+    };
+  }
+  interface EncodingObject {
+    contentType?: string;
+    headers?: {
+      [header: string]: ReferenceObject | HeaderObject;
+    };
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+  }
+  interface RequestBodyObject {
+    description?: string;
+    content: {
+      [media: string]: MediaTypeObject;
+    };
+    required?: boolean;
+  }
+  interface ResponsesObject {
+    [code: string]: ReferenceObject | ResponseObject;
+  }
+  interface ResponseObject {
+    description: string;
+    headers?: {
+      [header: string]: ReferenceObject | HeaderObject;
+    };
+    content?: {
+      [media: string]: MediaTypeObject;
+    };
+    links?: {
+      [link: string]: ReferenceObject | LinkObject;
+    };
+  }
+  interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: {
+      [parameter: string]: any;
+    };
+    requestBody?: any;
+    description?: string;
+    server?: ServerObject;
+  }
+  interface CallbackObject {
+    [url: string]: PathItemObject;
+  }
+  interface SecurityRequirementObject {
+    [name: string]: string[];
+  }
+  interface ComponentsObject {
+    schemas?: {
+      [key: string]: ReferenceObject | SchemaObject;
+    };
+    responses?: {
+      [key: string]: ReferenceObject | ResponseObject;
+    };
+    parameters?: {
+      [key: string]: ReferenceObject | ParameterObject;
+    };
+    examples?: {
+      [key: string]: ReferenceObject | ExampleObject;
+    };
+    requestBodies?: {
+      [key: string]: ReferenceObject | RequestBodyObject;
+    };
+    headers?: {
+      [key: string]: ReferenceObject | HeaderObject;
+    };
+    securitySchemes?: {
+      [key: string]: ReferenceObject | SecuritySchemeObject;
+    };
+    links?: {
+      [key: string]: ReferenceObject | LinkObject;
+    };
+    callbacks?: {
+      [key: string]: ReferenceObject | CallbackObject;
+    };
+  }
+  type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
+  interface HttpSecurityScheme {
+    type: 'http';
+    description?: string;
+    scheme: string;
+    bearerFormat?: string;
+  }
+  interface ApiKeySecurityScheme {
+    type: 'apiKey';
+    description?: string;
+    name: string;
+    in: string;
+  }
+  interface OAuth2SecurityScheme {
+    type: 'oauth2';
+    description?: string;
+    flows: {
+      implicit?: {
+        authorizationUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      password?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      clientCredentials?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      authorizationCode?: {
+        authorizationUrl: string;
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+    };
+  }
+  interface OpenIdSecurityScheme {
+    type: 'openIdConnect';
+    description?: string;
+    openIdConnectUrl: string;
+  }
+  interface TagObject {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+  }
+}
+//#endregion
+//#region src/helper/openapi.d.ts
+type OpenAPIMetadata = {
+  title: string;
+  version: string;
+  description?: string;
+};
+declare class OpenAPIGenerator {
+  private OPENAPI_VERSION;
+  private controllers;
+  registerController(controllerClass: Function, prefix: string): void;
+  /**
+   * visible for testing
+   */
+  _clearControllers(): void;
+  private get metadata();
+  generateSpec(): OpenAPIV3.Document;
+  private toJsonSchema;
+}
+declare const openApiGenerator: OpenAPIGenerator;
+declare function _registerController(controllerClass: Function, prefix: string): void;
+declare function generateOpenApiSpec(): OpenAPIV3.Document;
+declare function _clearOpenApiRegistry(): void;
+//#endregion
 //#region src/helper/sapling.d.ts
+type Settings = {
+  serialize: (value: any) => string;
+  deserialize: (value: string) => any;
+  health: {
+    path: string;
+  };
+  doc: {
+    openApiPath: string;
+    swaggerPath: string;
+    metadata: OpenAPIMetadata;
+  };
+};
+declare const _settings: Settings;
 /**
  * Collection of utility functions which are essential for Sapling to function.
  */
@@ -452,7 +848,8 @@ declare class Sapling {
    * app.registerApp(app);
    * ```
    */
-  static registerApp(app: e.Express): void;
+  static registerApp(app: e.Express): e.Express;
+  static onStartup(): void;
   /**
    * Serialize a value into a JSON string.
    *
@@ -481,111 +878,242 @@ declare class Sapling {
    * Replace the function used for `deserialize`
    */
   static setDeserializeFn(this: void, fn: (value: string) => any): void;
+  /**
+   * Modify extra settings
+   */
+  static Extras: {
+    /**
+     * Modify default settings applied to OpenAPI & Swagger
+     */
+    swaggerAndOpenApi: {
+      /**
+       * Set base OpenAPI metadata values.
+       *
+       * @default { title: "API", version: "1.0.0" }
+       */
+      setMetadata(metadata: OpenAPIMetadata): void;
+      /**
+       * change default endpoint that will serve OpenAPI spec.
+       * Swagger will also load this endpoint on load.
+       *
+       * @default `/openapi.json`
+       */
+      setOpenApiPath(this: void, path: string): void;
+      /**
+       * change Swagger endpoint.
+       *
+       * @default `/swagger.html`
+       */
+      setSwaggerPath(this: void, path: string): void;
+    };
+  };
+  /**
+   * This method can be used in a `@MiddlewareClass` to register any libraries
+   * that expect you to register multiple registers at once. An example is `swagger-ui-express`
+   *
+   * @example
+   * ```ts
+   * ⠀@MiddlewareClass()
+   *  class Serve {
+   *    // `swagger.serve` returns multiple Express handlers for all the assets and routes
+   *    // that will be served
+   *    private readonly handlers: RequestHandler[] = swagger.serve;
+   *
+   *   ⠀@Middleware(_settings.doc.swaggerPath)
+   *    handle(request: Request, response: Response, next: NextFunction) {
+   *      return Sapling.chainHandlers(this.handlers, request, response, next);
+   *    }
+   *  }
+   * ```
+   */
+  static chainHandlers(this: void, handlers: RequestHandler[], request: Request$1, response: Response$1, next: NextFunction, index?: number): void;
 }
 //#endregion
-//#region src/annotation/request.d.ts
-type RequestSchemaDefinition = {
-  body?: StandardSchemaV1;
-  param?: StandardSchemaV1;
-  query?: StandardSchemaV1;
+//#region src/annotation/validator.d.ts
+type ValidatorSchema = {
+  requestBody?: StandardSchemaV1 & StandardJSONSchemaV1;
+  requestParam?: StandardSchemaV1 & StandardJSONSchemaV1;
+  requestQuery?: StandardSchemaV1 & StandardJSONSchemaV1;
+  responseBody?: StandardSchemaV1 & StandardJSONSchemaV1;
+};
+declare function ResponseBody(schema: StandardSchemaV1 & StandardJSONSchemaV1): MethodDecorator;
+declare function RequestBody(schema: StandardSchemaV1 & StandardJSONSchemaV1): MethodDecorator;
+declare function RequestParam(schema: StandardSchemaV1 & StandardJSONSchemaV1): MethodDecorator;
+declare function RequestQuery(schema: StandardSchemaV1 & StandardJSONSchemaV1): MethodDecorator;
+declare function _getOrCreateSchemaDefinition(ctor: Function, fnName: string): ValidatorSchema;
+declare function _parseOrThrow<TSchema extends StandardSchemaV1>(schema: TSchema, input: unknown, location: ParserErrorLocation, fnName: string): Promise<StandardSchemaV1.InferOutput<TSchema>>;
+declare function _saveValidatorSchema(def: ValidatorSchema, key: keyof ValidatorSchema, schema: StandardSchemaV1 & StandardJSONSchemaV1, fnName: string): void;
+declare function _getValidatorSchema(ctor: Function, fnName: string): ValidatorSchema | undefined;
+//#endregion
+//#region src/annotation/schema.d.ts
+type ResponseSchema = {
+  statusCode: HttpStatus;
+  description?: string;
+  schema?: StandardSchemaV1 & StandardJSONSchemaV1;
+};
+type RouteSchemaDefinition = {
+  summary?: string;
+  description?: string;
+  responses?: ResponseSchema[];
 };
+type ControllerSchemaDefinition = {
+  title?: string;
+  description?: string;
+};
+declare function ControllerSchema(options: {
+  title?: string;
+  description?: string;
+}): ClassDecorator;
+declare function RouteSchema(options: {
+  summary?: string;
+  description?: string;
+  responses?: ResponseSchema[];
+}): MethodDecorator;
+declare function _setRouteSchema(ctor: Function, fnName: string, options: RouteSchemaDefinition): void;
+declare function _setControllerSchema(ctor: Function, options: ControllerSchemaDefinition): void;
+declare function _getRouteSchema(ctor: Function, fnName: string): RouteSchemaDefinition | undefined;
+declare function _getControllerSchema(ctor: Function): ControllerSchemaDefinition | undefined;
+//#endregion
+//#region src/middleware/default/error/base.d.ts
 /**
- * Apply to a route method to have `request.body` be parsed by `schema`.
+ * This should be registered last in the middleware chain.
  *
- * This annotation will parse `request.body` & then override `request.body`.
- * You can then just simply cast `request.body` for your use
+ * All exception messages are hidden from the request by default.
+ * If the default is not suitable, you may also easily write your own.
+ */
+declare class DefaultBaseErrorMiddleware {
+  handle(err: unknown, _request: Request$1, _response: Response$1, _next: NextFunction): ResponseEntity<{
+    message: string;
+  }>;
+}
+//#endregion
+//#region src/middleware/default/error/parse.d.ts
+/**
+ * Default error middleware that handles `ParserError`.
+ * If the default is not suitable, you may also easily write your own.
+ */
+declare class DefaultParserErrorMiddleware {
+  handle(err: unknown, _request: Request$1, _response: Response$1, next: NextFunction): ResponseEntity<{
+    message: string;
+  }> | undefined;
+}
+//#endregion
+//#region src/middleware/default/error/responsestatus.d.ts
+/**
+ * Default error middleware that handles `ResponseStatusError`.
+ * If the default is not suitable, you may also easily write your own.
+ */
+declare class DefaultResponseStatusErrorMiddleware {
+  handle(err: unknown, _request: Request$1, _response: Response$1, next: NextFunction): ResponseEntity<{
+    message: string;
+  }> | undefined;
+}
+//#endregion
+//#region src/middleware/default/openapi/index.d.ts
+/**
+ * Enable the serving of the OpenAPI spec autogenerated by Sapling.
  *
- * @example
- * ```ts
- *  const CREATE_BOOK_REQUEST_BODY_SCHEMA = z.object({
- *    name: z.string(),
- *    description: z.string().optional(),
- *  });
+ * Configure any middleware-specific settings with `Sapling.Extras.swaggerAndOpenApi`
+ *
+ * You must register `DefaultSwaggerMiddleware.Serve` & `DefaultSwaggerMiddleware.Setup` after `DefaultOpenApiMiddleware`
  *
- * ⠀@Controller({ prefix: "/api/book" })
- *  class BookController {
- *   ⠀@RequestBody(CREATE_BOOK_REQUEST_BODY_SCHEMA)
- *   ⠀@POST()
- *    public createBook(request: e.Request) {
- *      const { name, description } = request.body as unknown as z.infer<
- *        typeof CREATE_BOOK_REQUEST_BODY_SCHEMA
- *      >;
- *    }
- *  }
+ * ```ts
+ *  const middlewares = [
+ *    DefaultOpenApiMiddleware,
+ *    DefaultSwaggerMiddleware.Serve,
+ *    DefaultSwaggerMiddleware.Setup,
+ *  ];
+ *  middlewares.map(Sapling.resolve).forEach((r) => app.use(r));
  * ```
  */
-declare function RequestBody(schema: StandardSchemaV1): MethodDecorator;
+declare class DefaultOpenApiMiddleware {
+  handle(_request: Request$1, _response: Response$1, _next: NextFunction): ResponseEntity<OpenAPIV3.Document<{}>>;
+}
+//#endregion
+//#region src/middleware/default/swagger/index.d.ts
 /**
- * Apply to a route method to have `request.param` be parsed by `schema`.
+ * Enable the serving of the Swagger endpoint used to serve the OpenAPI spec generated by Sapling.
  *
- * This annotation will parse `request.param` & then override `request.param`.
- * You can then just simply cast `request.param` for your use
+ * Configure any middleware-specific settings with `Sapling.Extras.swaggerAndOpenApi`
  *
- * @example
- * ```ts
- *  const GET_BOOK_REQUEST_PARAM_SCHEMA = z.object({
- *    bookId: z.string(),
- *  });
+ * You must register `DefaultSwaggerMiddleware.Serve` & `DefaultSwaggerMiddleware.Setup` after `DefaultOpenApiMiddleware`
  *
- * ⠀@Controller({ prefix: "/api/book" })
- *  class BookController {
- *   ⠀@RequestParam(GET_BOOK_REQUEST_PARAM_SCHEMA)
- *   ⠀@GET("/:bookId")
- *    public getBook(request: e.Request) {
- *      const { bookId } = request.param as unknown as z.infer<
- *        typeof GET_BOOK_REQUEST_PARAM_SCHEMA
- *      >;
- *    }
- *  }
+ * ```ts
+ *  const middlewares = [
+ *    DefaultOpenApiMiddleware,
+ *    DefaultSwaggerMiddleware.Serve,
+ *    DefaultSwaggerMiddleware.Setup,
+ *  ];
+ *  middlewares.map(Sapling.resolve).forEach((r) => app.use(r));
  * ```
  */
-declare function RequestParam(schema: StandardSchemaV1): MethodDecorator;
+declare class Serve {
+  private readonly handlers;
+  handle(request: Request$1, response: Response$1, next: NextFunction): void;
+}
 /**
- * Apply to a route method to have `request.query` be parsed by `schema`.
+ * Enable the serving of the Swagger endpoint used to serve the OpenAPI spec generated by Sapling.
  *
- * This annotation will parse `request.query` & then override `request.query`.
- * You can then just simply cast `request.query` for your use
+ * Configure any middleware-specific settings with `Sapling.Extras.swaggerAndOpenApi`
  *
- * @example
- * ```ts
- *  const LIST_BOOKS_REQUEST_QUERY_SCHEMA = z.object({
- *    sort: z.enum(["name", "createdAt"]).optional(),
- *    q: z.string().optional(),
- *  });
+ * You must register `DefaultSwaggerMiddleware.Serve` & `DefaultSwaggerMiddleware.Setup` after `DefaultOpenApiMiddleware`
  *
- * ⠀@Controller({ prefix: "/api/book" })
- *  class BookController {
- *   ⠀@RequestQuery(LIST_BOOKS_REQUEST_QUERY_SCHEMA)
- *   ⠀@GET()
- *    public listBooks(request: e.Request) {
- *      const { sort, q } = request.query as unknown as z.infer<
- *        typeof LIST_BOOKS_REQUEST_QUERY_SCHEMA
- *      >;
- *    }
- *  }
+ * ```ts
+ *  const middlewares = [
+ *    DefaultOpenApiMiddleware,
+ *    DefaultSwaggerMiddleware.Serve,
+ *    DefaultSwaggerMiddleware.Setup,
+ *  ];
+ *  middlewares.map(Sapling.resolve).forEach((r) => app.use(r));
  * ```
  */
-declare function RequestQuery(schema: StandardSchemaV1): MethodDecorator;
-declare function _getRequestSchemas(ctor: Function, fnName: string): RequestSchemaDefinition | undefined;
-declare function _parseOrThrow<TSchema extends StandardSchemaV1>(schema: TSchema, input: unknown, kind: ParserErrorLocation): Promise<StandardSchemaV1.InferOutput<TSchema>>;
-//#endregion
-//#region src/middleware/default/base.d.ts
+declare class Setup {
+  private readonly handler;
+  constructor();
+  handle(request: Request$1, response: Response$1, next: NextFunction): unknown;
+}
 /**
- * This should be registered last in the middleware chain.
+ * Enable the serving of the Swagger endpoint used to serve the OpenAPI spec generated by Sapling.
  *
- * All exception messages are hidden from the request by default.
+ * Configure any middleware-specific settings with `Sapling.Extras.swaggerAndOpenApi`
+ *
+ * You must register `DefaultSwaggerMiddleware.Serve` & `DefaultSwaggerMiddleware.Setup` after `DefaultOpenApiMiddleware`
+ *
+ * ```ts
+ *  const middlewares = [
+ *    DefaultOpenApiMiddleware,
+ *    DefaultSwaggerMiddleware.Serve,
+ *    DefaultSwaggerMiddleware.Setup,
+ *  ];
+ *  middlewares.map(Sapling.resolve).forEach((r) => app.use(r));
+ * ```
  */
-declare class DefaultBaseErrorMiddleware {
-  handle(err: unknown, _request: Request, _response: Response, _next: NextFunction): ResponseEntity<{
-    message: string;
-  }>;
+declare const DefaultSwaggerMiddleware: {
+  Serve: typeof Serve;
+  Setup: typeof Setup;
+};
+//#endregion
+//#region src/middleware/health/registrar.d.ts
+type HealthCheck = () => boolean | Promise<boolean>;
+declare class HealthRegistrar {
+  private _checks;
+  private _sealed;
+  constructor();
+  add(healthCheck: HealthCheck): void;
+  /**
+   * @internal used by Sapling library
+   */
+  _seal(): void;
+  check(): Promise<boolean>;
 }
 //#endregion
-//#region src/middleware/default/responsestatus.d.ts
-declare class DefaultResponseStatusErrorMiddleware {
-  handle(err: unknown, _request: Request, _response: Response, next: NextFunction): ResponseEntity<{
-    message: string;
-  }> | undefined;
+//#region src/middleware/default/health/index.d.ts
+declare class DefaultHealthMiddleware {
+  private readonly healthRegistrar;
+  constructor(healthRegistrar: HealthRegistrar);
+  serve(_request: Request, _response: Response, _next: NextFunction): Promise<ResponseEntity<{
+    up: boolean;
+  }>>;
 }
 //#endregion
-export { Class, Controller, DELETE, DefaultBaseErrorMiddleware, DefaultResponseStatusErrorMiddleware, ExpressMiddlewareFn, ExpressRouterMethodKey, ExpressRouterMethods, GET, HEAD, Html404ErrorPage, HttpHeaders, HttpStatus, Injectable, Middleware, MiddlewareClass, OPTIONS, PATCH, POST, PUT, ParserError, ParserErrorLocation, RedirectView, RequestBody, RequestParam, RequestQuery, ResponseEntity, ResponseEntityBuilder, ResponseStatusError, RouteDefinition, Sapling, _ControllerRegistry, _InjectableDeps, _InjectableRegistry, _Route, _getRequestSchemas, _getRoutes, _parseOrThrow, _resolve, methodResolve };
+export { Class, Controller, ControllerSchema, ControllerSchemaDefinition, DELETE, DefaultBaseErrorMiddleware, DefaultHealthMiddleware, DefaultOpenApiMiddleware, DefaultParserErrorMiddleware, DefaultResponseStatusErrorMiddleware, DefaultSwaggerMiddleware, ExpressMiddlewareFn, ExpressRouterMethodKey, ExpressRouterMethods, GET, HEAD, HealthCheck, HealthRegistrar, Html404ErrorPage, HttpHeaders, HttpStatus, Injectable, Middleware, MiddlewareClass, OPTIONS, OpenAPIMetadata, PATCH, POST, PUT, ParserError, ParserErrorLocation, RedirectView, RequestBody, RequestParam, RequestQuery, ResponseBody, ResponseEntity, ResponseEntityBuilder, ResponseSchema, ResponseStatusError, RouteDefinition, RouteSchema, RouteSchemaDefinition, Sapling, ValidatorSchema, _ControllerRegistry, _InjectableDeps, _InjectableRegistry, _Route, _clearOpenApiRegistry, _getControllerSchema, _getOrCreateSchemaDefinition, _getRouteSchema, _getRoutes, _getValidatorSchema, _parseOrThrow, _registerController, _resolve, _saveValidatorSchema, _setControllerSchema, _setRouteSchema, _settings, generateOpenApiSpec, methodResolve, openApiGenerator };