authhero 8.7.1 → 8.8.0

package/dist/types/authentication-flows/passwordless.d.ts

@@ -239,6 +239,7 @@ export declare function passwordlessGrantUser(ctx: Context<{
             provisioning_state_changed_at?: string | undefined;
             bundle_configuration?: string | undefined;
             worker_version?: string | undefined;
+            database_version?: string | undefined;
             worker_script_name?: string | undefined;
             storage_kind?: "own_d1" | "existing_d1" | "shared_planetscale" | undefined;
             d1_database_id?: string | undefined;
@@ -457,7 +458,7 @@ export declare function passwordlessGrantUser(ctx: Context<{
         custom_login_page_preview?: string | undefined;
         form_template?: string | undefined;
         addons?: Record<string, any> | undefined;
-        token_endpoint_auth_method?: "none" | "private_key_jwt" | "client_secret_post" | "client_secret_basic" | "client_secret_jwt" | undefined;
+        token_endpoint_auth_method?: "client_secret_post" | "client_secret_basic" | "none" | "client_secret_jwt" | "private_key_jwt" | undefined;
         client_metadata?: Record<string, string> | undefined;
         hide_sign_up_disabled_error?: boolean | undefined;
         mobile?: Record<string, any> | undefined;
@@ -540,8 +541,8 @@ export declare function passwordlessGrantUser(ctx: Context<{
         } | undefined;
         authenticated_at?: string | undefined;
     };
-    connectionType: "username" | "sms" | "email";
-    authConnection: "username" | "sms" | "email";
+    connectionType: "username" | "email" | "sms";
+    authConnection: "username" | "email" | "sms";
     session_id: string | undefined;
     authParams: {
         client_id: string;

package/dist/types/helpers/client.d.ts

@@ -255,6 +255,7 @@ export declare const enrichedClientSchema: z.ZodObject<{
         provisioning_state_changed_at: z.ZodOptional<z.ZodString>;
         bundle_configuration: z.ZodOptional<z.ZodString>;
         worker_version: z.ZodOptional<z.ZodString>;
+        database_version: z.ZodOptional<z.ZodString>;
         worker_script_name: z.ZodOptional<z.ZodString>;
         storage_kind: z.ZodOptional<z.ZodEnum<{
             own_d1: "own_d1";

package/dist/types/helpers/dcr/metadata-mapping.d.ts

@@ -23,11 +23,11 @@ export declare const dcrRequestSchema: z.ZodObject<{
     grant_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
     response_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
     token_endpoint_auth_method: z.ZodOptional<z.ZodEnum<{
-        none: "none";
-        private_key_jwt: "private_key_jwt";
         client_secret_post: "client_secret_post";
         client_secret_basic: "client_secret_basic";
+        none: "none";
         client_secret_jwt: "client_secret_jwt";
+        private_key_jwt: "private_key_jwt";
     }>>;
     jwks_uri: z.ZodOptional<z.ZodString>;
     jwks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;

package/dist/types/helpers/mutable-response.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Normalizing a response so middleware can write headers onto it.
+ *
+ * A response that the worker *received* — from `fetch()`, a Workers-for-Platforms
+ * dispatch (`DISPATCHER.get(name).fetch()`), the Cache API, or R2 — carries an
+ * *immutable* header guard. Calling `headers.set()` / `headers.append()` on it
+ * throws `TypeError: Can't modify immutable headers.`. Responses built in-worker
+ * (`c.json()`, `c.text()`, `new Response(...)`) are mutable.
+ *
+ * Any middleware that annotates the response after `next()` (CORS, Server-Timing,
+ * `Preference-Applied`, …) must therefore tolerate an immutable response. Rather
+ * than guard each write with a try/catch, normalize once: re-wrapping is cheap
+ * (the body stream is passed through, not copied) and deterministic, so there is
+ * nothing to detect.
+ */
+/**
+ * Return a response whose headers are mutable. A received response is re-wrapped
+ * into a fresh `Response` (which has the mutable "response" header guard); an
+ * already-mutable response is re-wrapped too, harmlessly, preserving every header
+ * already set on it.
+ *
+ * A `101 Switching Protocols` upgrade is returned untouched: it carries a
+ * `webSocket` handle that reconstruction would drop, breaking the upgrade. Its
+ * headers stay immutable, so callers must not write to an upgrade response.
+ */
+export declare function toMutableResponse(res: Response): Response;
+/**
+ * Ensure `c.res` is safe to write headers onto, re-wrapping a received
+ * (immutable) response in place. Typed structurally so it accepts any Hono
+ * `Context` regardless of its `Bindings`/`Variables` generics.
+ *
+ * Note the 101 carve-out in {@link toMutableResponse}: for an upgrade response
+ * this is a no-op and the headers remain immutable, so a caller that may face a
+ * 101 must still skip its header writes for it.
+ */
+export declare function ensureMutableResponse(c: {
+    res: Response;
+}): void;