@arkstack/http 0.5.1 → 0.5.3

package/README.md

@@ -1,5 +1,7 @@
 # @arkstack/http
 
+[![@arkstack/http](https://img.shields.io/npm/dt/@arkstack/http?style=flat-square&label=@arkstack/http&link=https%3A%2F%2Fwww.npmjs.com%2Fpackage%2F@arkstack/http)](https://www.npmjs.com/package/@arkstack/http)
+
 HTTP module for Arkstack, providing framework-agnostic request and response primitives.
 
 ```ts

package/dist/app.d.ts

@@ -0,0 +1,46 @@
+import type { ErrorBag } from '.'
+import type { AuthSession } from '@arkstack/auth'
+
+declare module 'clear-router' {
+  interface ClearHttpContext {
+    errors: ErrorBag
+  }
+}
+
+
+declare module 'node:http' {
+  interface IncomingMessage {
+    rawBody?: Buffer
+    session?: AuthSession | undefined;
+  }
+}
+
+declare module 'clear-router/types/h3' {
+  interface HttpRequest {
+    rawBody?: Buffer
+    session?: AuthSession | undefined;
+  }
+}
+
+declare module 'clear-router' {
+  interface HttpRequests {
+    rawBody?: Buffer
+    session?: AuthSession | undefined;
+  }
+}
+
+declare module 'h3' {
+  interface H3EventContext {
+    rawBody?: Buffer
+    session?: AuthSession | undefined;
+  }
+}
+
+declare global {
+  namespace Express {
+    interface Request {
+      rawBody?: Buffer
+      session?: AuthSession | undefined;
+    }
+  }
+}

package/dist/index-C-YhZgaG.d.ts

@@ -0,0 +1,520 @@
+import * as _$clear_router0 from "clear-router";
+import { ClearHttpContext, Request, Response } from "clear-router";
+import * as _$kanun from "kanun";
+import { MiddlewareClass, MiddlewareInstance, RequestData } from "clear-router/types/basic";
+import { User } from "@app/models/User";
+
+//#region src/Response.d.ts
+/**
+ * Represents an HTTP response, providing a consistent interface for accessing response data.
+ *
+ * @author 3m1n3nc3
+ */
+declare class Response$1<TBody = unknown> extends Response {
+  body: TBody;
+  readonly source?: unknown;
+  constructor(options?: {
+    statusCode?: number;
+    headers?: HeaderSource;
+    body?: TBody;
+    source?: unknown;
+  });
+  static from<TBody extends RequestData = RequestData>(source?: Response$1<TBody> | ResponseSource): Response$1<TBody> | undefined;
+  status(code: number): this;
+  header(name: string, value: string): this;
+  getHeaders(): HeaderMap;
+  json(body: TBody): any;
+  send(body: TBody): any;
+}
+//#endregion
+//#region src/session/FlashBag.d.ts
+declare class FlashBag<T = unknown> {
+  protected bag: Record<string, T>;
+  private sweepKeys;
+  constructor(items?: Record<string, T>);
+  put(key: string, value: T): this;
+  set(key: string, value: T): this;
+  get(key: string, defaultValue?: T): T;
+  has(key?: string | string[] | null): boolean;
+  any(): boolean;
+  isEmpty(): boolean;
+  isNotEmpty(): boolean;
+  keys(): string[];
+  all(): {
+    [x: string]: T;
+  };
+  clear(key?: string | string[]): this;
+  forget(key: string): this;
+  markForSweep(keys?: string[]): this;
+  sweep(): this;
+  toJSON(): {
+    [x: string]: T;
+  };
+}
+//#endregion
+//#region src/session/types.d.ts
+type SessionDriverType = 'file' | 'cookie' | 'database' | SessionDriver;
+type SessionErrorValue = string | string[] | Error | unknown;
+type SessionErrorRecord = Record<string, SessionErrorValue>;
+interface SessionMessageProvider {
+  getMessageBag?: () => SessionMessageProvider;
+  getMessages?: () => SessionErrorRecord;
+  messagesRaw?: () => SessionErrorRecord;
+  toArray?: () => SessionErrorRecord;
+  all?: (...args: any[]) => SessionErrorRecord | string[];
+  errors?: (() => SessionErrorRecord | SessionMessageProvider) | SessionErrorRecord | SessionMessageProvider;
+}
+type SessionErrorSource = SessionErrorRecord | ErrorBag | SessionMessageProvider;
+interface SessionInitialState {
+  data?: Record<string, any>;
+  errors?: SessionErrorSource;
+  flash?: Record<string, any> | FlashBag;
+}
+type SessionPayload = {
+  data?: Record<string, any>;
+  errors?: SessionErrorRecord;
+  flash?: Record<string, any>;
+};
+type cookie_options = {
+  path?: string;
+  domain?: string;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: 'Strict' | 'Lax' | 'None';
+  maxAge?: number;
+  expires?: Date;
+};
+type HttpContextLike = Record<string, any>;
+type SessionDriverResult = {
+  id: string;
+  state?: SessionPayload;
+  save: (payload: SessionPayload) => void | Promise<void>;
+  destroy?: () => void | Promise<void>;
+};
+interface SessionDriver {
+  start(context: HttpContextLike): Promise<SessionDriverResult>;
+}
+type BaseSessionDriverOptions = {
+  cookie?: string;
+  secret?: string;
+  ttl?: number;
+  cookie_options?: cookie_options;
+};
+type DatabaseSessionDriverOptions = BaseSessionDriverOptions & {
+  table?: string;
+};
+type PersistentSessionConfig = {
+  driver?: SessionDriverType;
+  cookie?: string;
+  secret?: string;
+  ttl?: number;
+  cookie_options?: cookie_options;
+  file?: {
+    directory?: string;
+  };
+  database?: {
+    table?: string;
+  };
+};
+type SessionConfig = {
+  secret?: string;
+  driver?: SessionDriverType;
+  cookie?: string;
+  ttl?: number;
+  http_only?: boolean;
+  secure?: boolean;
+  same_site?: cookie_options['sameSite'];
+  path?: string;
+  table?: string;
+  directory?: string;
+};
+//#endregion
+//#region src/session/ErrorBag.d.ts
+declare class ErrorBag extends FlashBag<string[]> {
+  constructor(errors?: SessionErrorSource);
+  add(field: string, message: SessionErrorValue): this;
+  addIf(condition: boolean, field: string, message: SessionErrorValue): this;
+  merge(errors: SessionErrorSource): ErrorBag;
+  validation(error: unknown): ErrorBag;
+  keys(): string[];
+  get(field?: string): string[];
+  first(field?: string | null): string;
+  has(field?: string | string[] | null): boolean;
+  hasAny(fields: string | string[]): boolean;
+  missing(fields: string | string[]): boolean;
+  any(): boolean;
+  isEmpty(): boolean;
+  isNotEmpty(): boolean;
+  count(): number;
+  all(): never;
+  unique(): unknown[];
+  clear(field?: string | string[]): this;
+  forget(field: string): this;
+  messagesRaw(): Record<string, string[]>;
+  getMessages(): Record<string, string[]>;
+  getMessageBag(): this;
+  toArray(): Record<string, string[]>;
+  toJSON(): Record<string, string[]>;
+}
+//#endregion
+//#region src/session/Session.d.ts
+declare class Session {
+  readonly errors: ErrorBag;
+  readonly flashBag: FlashBag;
+  readonly id?: string;
+  private data;
+  private persistent?;
+  private saveQueue;
+  constructor(initial?: SessionInitialState | Record<string, any> | Session, persistent?: SessionDriverResult);
+  private snapshot;
+  private queuePersist;
+  save(): Promise<this>;
+  destroy(): Promise<this>;
+  /**
+   * Get an item from the session bag
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  get<T = any>(key: string, defaultValue?: T): T;
+  /**
+   * Add an item to the session bag
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  put<T = any>(key: string, value: T): this;
+  /**
+   * Add an item to the session bag
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  set<T = any>(key: string, value: T): this;
+  /**
+   * Check if an item exist in the session bag
+   *
+   * @param key
+   * @returns
+   */
+  has(key: string): boolean;
+  /**
+   * Remove an item from the session bag
+   *
+   * @param key
+   * @returns
+   */
+  forget(key: string): this;
+  /**
+   * Clear the session bag
+   *
+   * @returns
+   */
+  clear(): this;
+  /**
+   * Get all items in the session bag
+   *
+   * @returns
+   */
+  all(): {
+    [x: string]: any;
+  };
+  /**
+   * Add a flash item for the next request
+   *
+   * @param key
+   * @param value
+   * @returns
+   */
+  flash<T = any>(key: string, value: T): this;
+  /**
+   * Get a flash item
+   *
+   * @param key
+   * @param defaultValue
+   * @returns
+   */
+  getFlash<T = any>(key: string, defaultValue?: T): T;
+  /**
+   * Sweep flashed data that was loaded for this request
+   *
+   * @returns
+   */
+  sweepFlash(): Promise<this>;
+  /**
+   * Add an error to the session error bag
+   *
+   * @param field
+   * @param message
+   * @returns
+   */
+  addError(field: string, message: SessionErrorValue): this;
+  /**
+   * Add multiple errors to the session error bag
+   *
+   * @param errors
+   * @returns
+   */
+  addErrors(errors: SessionErrorRecord | ErrorBag): this;
+  /**
+   * Add a validation error to the session error bag
+   *
+   * @param error
+   * @returns
+   */
+  addValidationErrors(error: unknown): this;
+  /**
+   * Check if the session error bag has any errors
+   *
+   * @param field
+   * @returns
+   */
+  hasErrors(field?: string): boolean;
+  /**
+   * Clear all errors in the session error bag
+   *
+   * @param field
+   * @returns
+   */
+  clearErrors(field?: string): this;
+  /**
+   * Parse session for views
+   *
+   * @returns
+   */
+  forView(): {
+    errors: ErrorBag;
+    flash: FlashBag<unknown>;
+  };
+  /**
+   * Return session as json
+   *
+   * @returns
+   */
+  toJSON(): {
+    errors: Record<string, string[]>;
+    flash: {
+      [x: string]: unknown;
+    };
+  };
+}
+//#endregion
+//#region src/plugins.d.ts
+declare const arkstackHttpPlugin: _$clear_router0.ClearRouterPlugin<any, ClearHttpContext>;
+declare const kanunSessionPlugin: _$kanun.ValidatorPlugin;
+//#endregion
+//#region src/session/helpers.d.ts
+declare const registerResponseFlashSweep: (target: unknown, session?: Session) => void;
+declare const attachViewState: (target: Record<PropertyKey, any>, session: Session) => void;
+/**
+ * Ensure a valid session exists
+ *
+ * @param ctx
+ * @param initial
+ * @returns
+ */
+declare const ensureSession: (ctx: unknown, initial?: SessionInitialState | Record<string, any>, persistent?: SessionDriverResult) => Session;
+/**
+ * Get the current session
+ *
+ * @param ctx
+ * @returns
+ */
+declare const getSession: (ctx: unknown) => Session | undefined;
+//#endregion
+//#region src/session/config.d.ts
+declare const createSessionDriver: (config?: PersistentSessionConfig) => SessionDriver;
+declare const configureSession: (config: PersistentSessionConfig | SessionDriver) => SessionDriver;
+declare const getSessionDriver: () => SessionDriver;
+//#endregion
+//#region src/session/cookie.d.ts
+declare const generateSessionId: () => string;
+declare const signValue: (value: string, secret: string) => string;
+declare const encodeSignedValue: (value: string, secret: string) => string;
+declare const decodeSignedValue: (value: string | undefined, secret: string) => string | undefined;
+declare const encodeJson: (value: unknown) => string;
+declare const decodeJson: <T = unknown>(value: string | undefined) => T | undefined;
+declare const parseCookies: (header?: string | string[] | null) => Record<string, string>;
+declare const getCookie: (context: HttpContextLike, name: string) => string;
+declare const serializeCookie: (name: string, value: string, options?: cookie_options) => string;
+declare const setCookie: (context: HttpContextLike, name: string, value: string, options?: cookie_options) => string;
+//#endregion
+//#region src/session/encryption.d.ts
+declare const encryptSessionValue: (value: string, secret: string) => string;
+declare const decryptSessionValue: (payload: string | undefined, secret: string) => string | undefined;
+//#endregion
+//#region src/session/serialization.d.ts
+declare const encodeSessionPayload: (payload: SessionPayload & {
+  id?: string;
+}) => string;
+declare const decodeSessionPayload: <T extends SessionPayload & {
+  id?: string;
+} = SessionPayload & {
+  id?: string;
+}>(value: string | undefined) => T | undefined;
+//#endregion
+//#region src/session/drivers/BaseSessionDriver.d.ts
+declare abstract class BaseSessionDriver implements SessionDriver {
+  readonly cookie: string;
+  readonly secret: string;
+  readonly ttl?: number;
+  readonly cookie_options: cookie_options;
+  constructor(options?: BaseSessionDriverOptions);
+  protected readSessionId(context: HttpContextLike): string | undefined;
+  protected encryptPayload(value: string): string;
+  protected decryptPayload(value: string | undefined): string | undefined;
+  protected writeSessionId(context: HttpContextLike, id: string): void;
+  abstract start(context: HttpContextLike): Promise<SessionDriverResult>;
+}
+//#endregion
+//#region src/session/drivers/CookieSessionDriver.d.ts
+declare class CookieSessionDriver extends BaseSessionDriver {
+  start(context: HttpContextLike): Promise<SessionDriverResult>;
+}
+//#endregion
+//#region src/session/drivers/DatabaseSessionDriver.d.ts
+declare class DatabaseSessionDriver extends BaseSessionDriver {
+  readonly tableName: string;
+  constructor(options?: DatabaseSessionDriverOptions);
+  private table;
+  start(context: HttpContextLike): Promise<SessionDriverResult>;
+}
+//#endregion
+//#region src/session/drivers/FileSessionDriver.d.ts
+declare class FileSessionDriver extends BaseSessionDriver {
+  readonly directory: string;
+  constructor(options?: BaseSessionDriverOptions & {
+    directory?: string;
+  });
+  private path;
+  start(context: HttpContextLike): Promise<SessionDriverResult>;
+}
+//#endregion
+//#region src/types/Http.d.ts
+type HeaderValue = string | string[] | number | boolean | null | undefined;
+type HeaderMap = Record<string, string>;
+type HeaderSource = Headers | Record<string, HeaderValue>;
+type FunctionMiddleware = (...args: any[]) => any;
+type ClassMiddleware = new (...args: any[]) => {
+  handle: FunctionMiddleware;
+};
+type RequestSource<TUser = unknown> = {
+  headers?: HeaderSource;
+  method?: string;
+  url?: string;
+  originalUrl?: string;
+  path?: string;
+  ip?: string;
+  user?: TUser;
+  auth?: unknown;
+  authUser?: TUser;
+  authToken?: string;
+  req?: RequestSource<TUser>;
+  request?: RequestSource<TUser>;
+  original?: RequestSource<TUser>;
+};
+type ResponseSource = {
+  statusCode?: number;
+  status?: number | ((code: number) => unknown);
+  headers?: HeaderSource;
+  setHeader?: (name: string, value: string | string[]) => unknown;
+  getHeader?: (name: string) => string | string[] | number | undefined;
+  json?: (body: unknown) => unknown;
+  send?: (body: unknown) => unknown;
+  redirect?: (status: number, path: string) => unknown;
+};
+type RequestOptions<TUser = unknown> = {
+  headers?: HeaderSource;
+  method?: string;
+  url?: string;
+  path?: string;
+  ip?: string | null;
+  user?: TUser;
+  auth?: unknown;
+  authUser?: TUser;
+  authToken?: string;
+  source?: unknown;
+  original?: unknown;
+};
+interface RequestHelper<TUser = unknown> {
+  (): Request$1;
+  <X extends string>(key: X): Request$1<TUser>['body'][X];
+}
+interface SessionHelper {
+  (): Session;
+  <X extends string>(key: X): any;
+}
+interface RedirectHelper {
+  (): Response$1;
+  (to?: string, status?: number): Response$1;
+}
+interface OldHelper {
+  (): Record<string, any>;
+  <T = any>(key: string, defaultValue?: T): T;
+}
+//#endregion
+//#region src/Request.d.ts
+/**
+ * Represents an HTTP request, providing a consistent interface for accessing request data.
+ *
+ * @author 3m1n3nc3
+ */
+declare class Request$1<TUser = User> extends Request {
+  readonly headers: HeaderMap;
+  readonly ip: string | null;
+  readonly source?: unknown;
+  private currentUser?;
+  private currentAuth?;
+  private currentAuthUser?;
+  private currentAuthToken?;
+  get user(): TUser | undefined;
+  set user(user: TUser | undefined);
+  get auth(): unknown;
+  set auth(auth: unknown);
+  get authUser(): TUser | undefined;
+  set authUser(user: TUser | undefined);
+  get authToken(): string | undefined;
+  set authToken(token: string | undefined);
+  constructor(options?: RequestOptions<TUser>);
+  static from<TUser = unknown>(source?: Request$1<TUser> | RequestSource<TUser>): Request$1<TUser> | undefined;
+  header(name: string): string;
+  bearerToken(): string | null;
+  setUser(user: TUser): this;
+  setAuthentication<TAuth>(auth: TAuth, user: TUser, token?: string): this;
+  syncFromSource(): this;
+  private getSourceRequest;
+  clearAuthentication(): this;
+}
+//#endregion
+//#region src/helpers.d.ts
+declare const unwrapRequestSource: <TUser>(source: RequestSource<TUser>) => RequestSource<TUser>;
+declare const makeHeaders: (headers?: HeaderSource) => Headers;
+declare const normalizeHeaders: (headers?: HeaderSource) => HeaderMap;
+declare const normalizeHeaderValue: (value: HeaderValue) => string | undefined;
+declare const isHeaders: (value: unknown) => value is Headers;
+declare const isRecord: (value: unknown) => value is Record<PropertyKey, any>;
+/**
+ * Resolve Middleware
+ *
+ * @param middleware
+ * @returns
+ */
+declare const resolveMiddleware: <T extends FunctionMiddleware | MiddlewareClass | MiddlewareInstance>(middleware: T) => T extends MiddlewareClass<FunctionMiddleware> ? InstanceType<T>["handle"] : T extends MiddlewareInstance ? T["handle"] : T;
+//#endregion
+//#region src/redirect.d.ts
+declare const redirectBackTarget: (fallback?: string) => string;
+declare const resolveRedirectTarget: (to?: string, fallback?: string) => string;
+declare const redirect: (to?: string, status?: number) => Response$1<unknown>;
+//#endregion
+//#region src/old.d.ts
+declare const old: <T = any>(key?: string, defaultValue?: T) => T;
+//#endregion
+//#region src/middlewares/web.d.ts
+declare const webMiddlewareKey: unique symbol;
+declare const web: (...args: any[]) => Promise<any>;
+declare const isWebRequest: (target: unknown) => boolean;
+//#endregion
+export { arkstackHttpPlugin as $, CookieSessionDriver as A, generateSessionId as B, RequestHelper as C, SessionHelper as D, ResponseSource as E, encryptSessionValue as F, signValue as G, parseCookies as H, decodeJson as I, getSessionDriver as J, configureSession as K, decodeSignedValue as L, decodeSessionPayload as M, encodeSessionPayload as N, FileSessionDriver as O, decryptSessionValue as P, registerResponseFlashSweep as Q, encodeJson as R, RedirectHelper as S, RequestSource as T, serializeCookie as U, getCookie as V, setCookie as W, ensureSession as X, attachViewState as Y, getSession as Z, FunctionMiddleware as _, cookie_options as _t, redirect as a, HttpContextLike as at, HeaderValue as b, isHeaders as c, SessionDriver as ct, normalizeHeaderValue as d, SessionErrorRecord as dt, kanunSessionPlugin as et, normalizeHeaders as f, SessionErrorSource as ft, ClassMiddleware as g, SessionPayload as gt, Request$1 as h, SessionMessageProvider as ht, old as i, DatabaseSessionDriverOptions as it, BaseSessionDriver as j, DatabaseSessionDriver as k, isRecord as l, SessionDriverResult as lt, unwrapRequestSource as m, SessionInitialState as mt, web as n, ErrorBag as nt, redirectBackTarget as o, PersistentSessionConfig as ot, resolveMiddleware as p, SessionErrorValue as pt, createSessionDriver as q, webMiddlewareKey as r, BaseSessionDriverOptions as rt, resolveRedirectTarget as s, SessionConfig as st, isWebRequest as t, Session as tt, makeHeaders as u, SessionDriverType as ut, HeaderMap as v, FlashBag as vt, RequestOptions as w, OldHelper as x, HeaderSource as y, Response$1 as yt, encodeSignedValue as z };

package/dist/index.d.ts

@@ -1,80 +1,3 @@
-import { Request as Request$1, Response as Response$1 } from "clear-router";
-import { RequestData } from "clear-router/types/basic";
-
-//#region src/types/Http.d.ts
-type HeaderValue = string | string[] | number | boolean | null | undefined;
-type HeaderMap = Record<string, string>;
-type HeaderSource = Headers | Record<string, HeaderValue>;
-type RequestSource<TUser = unknown> = {
-  headers?: HeaderSource;
-  method?: string;
-  url?: string;
-  originalUrl?: string;
-  path?: string;
-  ip?: string;
-  user?: TUser;
-  authToken?: string;
-  req?: RequestSource<TUser>;
-  request?: RequestSource<TUser>;
-};
-type ResponseSource = {
-  statusCode?: number;
-  status?: number | ((code: number) => unknown);
-  headers?: HeaderSource;
-  setHeader?: (name: string, value: string) => unknown;
-  json?: (body: unknown) => unknown;
-  send?: (body: unknown) => unknown;
-};
-type RequestOptions<TUser = unknown> = {
-  headers?: HeaderSource;
-  method?: string;
-  url?: string;
-  path?: string;
-  ip?: string | null;
-  user?: TUser;
-  authToken?: string;
-  source?: unknown;
-};
-//#endregion
-//#region src/Request.d.ts
-declare class Request<TUser = unknown> extends Request$1 {
-  readonly headers: HeaderMap;
-  readonly ip: string | null;
-  readonly source?: unknown;
-  user?: TUser;
-  authToken?: string;
-  constructor(options?: RequestOptions<TUser>);
-  static from<TUser = unknown>(source?: Request<TUser> | RequestSource<TUser>): Request<TUser> | undefined;
-  header(name: string): string;
-  bearerToken(): string | null;
-  setUser(user: TUser): this;
-}
-//#endregion
-//#region src/Response.d.ts
-declare class Response<TBody = unknown> extends Response$1 {
-  body: TBody;
-  readonly source?: unknown;
-  constructor(options?: {
-    statusCode?: number;
-    headers?: HeaderSource;
-    body?: TBody;
-    source?: unknown;
-  });
-  static from<TBody extends RequestData = RequestData>(source?: Response<TBody> | ResponseSource): Response<TBody> | undefined;
-  status(code: number): this;
-  header(name: string, value: string): this;
-  getHeaders(): HeaderMap;
-  json(body: TBody): any;
-  send(body: TBody): any;
-}
-//#endregion
-//#region src/helpers.d.ts
-declare const unwrapRequestSource: <TUser>(source: RequestSource<TUser>) => RequestSource<TUser>;
-declare const makeHeaders: (headers?: HeaderSource) => Headers;
-declare const normalizeHeaders: (headers?: HeaderSource) => HeaderMap;
-declare const normalizeHeaderValue: (value: HeaderValue) => string | undefined;
-declare const isHeaders: (value: unknown) => value is Headers;
-declare const isRecord: (value: unknown) => value is Record<string, any>;
-//#endregion
-export { HeaderMap, HeaderSource, HeaderValue, Request, RequestOptions, RequestSource, Response, ResponseSource, isHeaders, isRecord, makeHeaders, normalizeHeaderValue, normalizeHeaders, unwrapRequestSource };
-//# sourceMappingURL=index.d.ts.map
+/// <reference path="./app.d.ts" />
+import { $ as arkstackHttpPlugin, A as CookieSessionDriver, B as generateSessionId, C as RequestHelper, D as SessionHelper, E as ResponseSource, F as encryptSessionValue, G as signValue, H as parseCookies, I as decodeJson, J as getSessionDriver, K as configureSession, L as decodeSignedValue, M as decodeSessionPayload, N as encodeSessionPayload, O as FileSessionDriver, P as decryptSessionValue, Q as registerResponseFlashSweep, R as encodeJson, S as RedirectHelper, T as RequestSource, U as serializeCookie, V as getCookie, W as setCookie, X as ensureSession, Y as attachViewState, Z as getSession, _ as FunctionMiddleware, _t as cookie_options, a as redirect, at as HttpContextLike, b as HeaderValue, c as isHeaders, ct as SessionDriver, d as normalizeHeaderValue, dt as SessionErrorRecord, et as kanunSessionPlugin, f as normalizeHeaders, ft as SessionErrorSource, g as ClassMiddleware, gt as SessionPayload, h as Request, ht as SessionMessageProvider, i as old, it as DatabaseSessionDriverOptions, j as BaseSessionDriver, k as DatabaseSessionDriver, l as isRecord, lt as SessionDriverResult, m as unwrapRequestSource, mt as SessionInitialState, n as web, nt as ErrorBag, o as redirectBackTarget, ot as PersistentSessionConfig, p as resolveMiddleware, pt as SessionErrorValue, q as createSessionDriver, r as webMiddlewareKey, rt as BaseSessionDriverOptions, s as resolveRedirectTarget, st as SessionConfig, t as isWebRequest, tt as Session, u as makeHeaders, ut as SessionDriverType, v as HeaderMap, vt as FlashBag, w as RequestOptions, x as OldHelper, y as HeaderSource, yt as Response, z as encodeSignedValue } from "./index-C-YhZgaG.js";
+export { BaseSessionDriver, BaseSessionDriverOptions, ClassMiddleware, CookieSessionDriver, DatabaseSessionDriver, DatabaseSessionDriverOptions, ErrorBag, FileSessionDriver, FlashBag, FunctionMiddleware, HeaderMap, HeaderSource, HeaderValue, HttpContextLike, OldHelper, PersistentSessionConfig, RedirectHelper, Request, RequestHelper, RequestOptions, RequestSource, Response, ResponseSource, Session, SessionConfig, SessionDriver, SessionDriverResult, SessionDriverType, SessionErrorRecord, SessionErrorSource, SessionErrorValue, SessionHelper, SessionInitialState, SessionMessageProvider, SessionPayload, arkstackHttpPlugin, attachViewState, configureSession, cookie_options, createSessionDriver, decodeJson, decodeSessionPayload, decodeSignedValue, decryptSessionValue, encodeJson, encodeSessionPayload, encodeSignedValue, encryptSessionValue, ensureSession, generateSessionId, getCookie, getSession, getSessionDriver, isHeaders, isRecord, isWebRequest, kanunSessionPlugin, makeHeaders, normalizeHeaderValue, normalizeHeaders, old, parseCookies, redirect, redirectBackTarget, registerResponseFlashSweep, resolveMiddleware, resolveRedirectTarget, serializeCookie, setCookie, signValue, unwrapRequestSource, web, webMiddlewareKey };