hono-utils 0.4.0 → 0.5.0

package/dist/index.d.cts

@@ -4,6 +4,7 @@ import { Logger, Details } from 'hierarchical-area-logger';
 import * as hono_utils_http_status from 'hono/utils/http-status';
 import { ContentfulStatusCode, SuccessStatusCode, ClientErrorStatusCode, StatusCode } from 'hono/utils/http-status';
 import z$1, { z, ZodObject } from 'zod';
+import * as _cloudflare_workers_types from '@cloudflare/workers-types';
 import { Message, MessageBatch, Queue, Iso3166Alpha2Code, ContinentCode } from '@cloudflare/workers-types';
 import * as hono_utils_types from 'hono/utils/types';
 import { HTTPException } from 'hono/http-exception';
@@ -221,7 +222,7 @@ declare class QueueHandler<Schema extends ZodObject<any>, Environment, Context>
      * @param params - Global parameters to include in every message (e.g., trace IDs).
      * @returns A producer function that accepts a `handler` key and the corresponding typed content.
      */
-    getProducer(queue: Queue<unknown>, params: QueueSendParams): <HandlerName extends keyof z.infer<Schema>>(handler: HandlerName, content: z.infer<Schema>[HandlerName]) => Promise<void>;
+    getProducer(queue: Queue<unknown>, params: QueueSendParams): <HandlerName extends keyof z.infer<Schema>>(handler: HandlerName, content: z.infer<Schema>[HandlerName]) => Promise<_cloudflare_workers_types.QueueSendResponse>;
 }
 
 /**
@@ -410,7 +411,10 @@ declare function verify(input: string, salt: string, storedHash: string, iterati
 
 declare const pbkdf2_verify: typeof verify;
 declare namespace pbkdf2 {
-  export { hash$1 as hash, pbkdf2_verify as verify };
+  export {
+    hash$1 as hash,
+    pbkdf2_verify as verify,
+  };
 }
 
 /**
@@ -434,7 +438,10 @@ declare function hash({ input, algorithm, pepper, salt, }: {
 declare const sha_generateSalt: typeof generateSalt;
 declare const sha_hash: typeof hash;
 declare namespace sha {
-  export { sha_generateSalt as generateSalt, sha_hash as hash };
+  export {
+    sha_generateSalt as generateSalt,
+    sha_hash as hash,
+  };
 }
 
 declare const onError: <Environment extends Env>(parseError?: (err: Error | HTTPException, env: Environment["Bindings"], get: <K extends keyof Environment["Variables"]>(key: K) => Environment["Variables"][K]) => Promise<string>) => ErrorHandler<Environment>;
@@ -456,4 +463,5 @@ interface CreateTypedClientOptions {
 }
 declare const createTypedClient: <TApp extends Hono<any, any, any>>() => (options: CreateTypedClientOptions) => <TSuccessData>(fn: (c: ReturnType<typeof hc<TApp>>) => Promise<ClientResponse<TSuccessData>>, callbacks?: TypedClientCallbacks) => Promise<TSuccessData>;
 
-export { type ContextFn, type CreateTypedClientOptions, type HonoClientInfoVariables, type HonoI18nVariables, type HonoIsBotVariables, type HonoLanguageVariables, type HonoLoggerVariables, type HonoResponseVariables, type MessageHandlers, type MiddlewareWithLoggingCapability, pbkdf2 as PBKDF2, QueueHandler, sha as SHA, type TypedClientCallbacks, clientInfo, createTypedClient, i18n, isBot, jsonValidator, logger, onError, onNotFound, queue, response };
+export { pbkdf2 as PBKDF2, QueueHandler, sha as SHA, clientInfo, createTypedClient, i18n, isBot, jsonValidator, logger, onError, onNotFound, queue, response };
+export type { ContextFn, CreateTypedClientOptions, HonoClientInfoVariables, HonoI18nVariables, HonoIsBotVariables, HonoLanguageVariables, HonoLoggerVariables, HonoResponseVariables, MessageHandlers, MiddlewareWithLoggingCapability, TypedClientCallbacks };

package/dist/index.d.mts

@@ -0,0 +1,467 @@
+import * as hono from 'hono';
+import { MiddlewareHandler, Context, Env, ErrorHandler, NotFoundHandler, Hono } from 'hono';
+import { Logger, Details } from 'hierarchical-area-logger';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import { ContentfulStatusCode, SuccessStatusCode, ClientErrorStatusCode, StatusCode } from 'hono/utils/http-status';
+import z$1, { z, ZodObject } from 'zod';
+import * as _cloudflare_workers_types from '@cloudflare/workers-types';
+import { Message, MessageBatch, Queue, Iso3166Alpha2Code, ContinentCode } from '@cloudflare/workers-types';
+import * as hono_utils_types from 'hono/utils/types';
+import { HTTPException } from 'hono/http-exception';
+import { hc, ClientResponse } from 'hono/client';
+
+type HonoLoggerVariables = {
+    logger: Logger;
+    eventId: string;
+};
+/**
+ * Logger middleware
+ *
+ * @description
+ * This middleware sets up a logger.
+ *
+ * @param details - Details to pass to the logger
+ * @param parentEventIdHeader - Header name to use for parent event ID
+ *
+ * @example
+ * ```ts
+ * app.use('*', logger(
+ * {
+ *   service: 'logger',
+ * },
+ * parentEventIdHeader: 'parent-event-id',
+ * ));
+ * ```
+ */
+declare const logger: (details: Details, parentEventIdHeader?: string) => hono.MiddlewareHandler<{
+    Variables: HonoLoggerVariables;
+}, string, {}, Response>;
+
+/**
+ * @description
+ * Validator middleware for JSON data.
+ *
+ * @param schema - Zod schema for validation
+ *
+ * @example
+ * ```ts
+ * app.post('/user', jsonValidator(z.object({
+ *   name: z.string(),
+ *   age: z.number(),
+ * })), (c) => {
+ *   const { name, age } = await c.req.valid('json');
+ *   return c.json({ name, age });
+ * });
+ * ```
+ */
+declare const jsonValidator: <T extends z.ZodRawShape>(schema: z.ZodObject<T>) => hono.MiddlewareHandler<any, string, {
+    in: {
+        json: z.core.$InferObjectOutput<T, {}> extends infer T_1 ? T_1 extends z.core.$InferObjectOutput<T, {}> ? T_1 extends Promise<infer PR> ? PR extends Response | hono.TypedResponse<any, any, any> ? never : PR : T_1 extends Response | hono.TypedResponse<any, any, any> ? never : T_1 : never : never;
+    };
+    out: {
+        json: z.core.$InferObjectOutput<T, {}> extends infer T_2 ? T_2 extends z.core.$InferObjectOutput<T, {}> ? T_2 extends Promise<infer PR> ? PR extends Response | hono.TypedResponse<any, any, any> ? never : PR : T_2 extends Response | hono.TypedResponse<any, any, any> ? never : T_2 : never : never;
+    };
+}, z.core.$InferObjectOutput<T, {}> extends infer T_3 ? T_3 extends z.core.$InferObjectOutput<T, {}> ? T_3 extends Promise<infer PR_1> ? PR_1 extends hono.TypedResponse<infer T_4, infer S extends hono_utils_http_status.StatusCode, infer F extends string> ? hono.TypedResponse<T_4, S, F> : PR_1 extends Response ? PR_1 : PR_1 extends undefined ? never : never : T_3 extends hono.TypedResponse<infer T_5, infer S_1 extends hono_utils_http_status.StatusCode, infer F_1 extends string> ? hono.TypedResponse<T_5, S_1, F_1> : T_3 extends Response ? T_3 : T_3 extends undefined ? never : never : never : never>;
+
+type MiddlewareWithLoggingCapabilityProps<RestProps extends Record<string, unknown>> = {
+    useLogger?: boolean;
+} & RestProps;
+interface MiddlewareWithLoggingCapability<RestProps extends Record<string, unknown>> {
+    (props?: MiddlewareWithLoggingCapabilityProps<RestProps>): MiddlewareHandler;
+}
+
+type HonoIsBotVariables = {
+    isBot: boolean;
+};
+/**
+ * Middleware to detect and optionally block requests based on Cloudflare's Bot Management score.
+ * @param {Object} options - Configuration options for bot detection.
+ * @param {number} [options.threshold=49] - The bot score threshold (1-100).
+ * Cloudflare scores below this value are treated as bots. A lower score indicates a higher
+ * probability that the request is automated.
+ * @param {boolean} [options.allowVerifiedBot] - If true, the middleware strictly requires
+ * bots to be "verified" (e.g., Googlebot, Bingbot).
+ * Note: If this is enabled, non-verified bots will be blocked regardless of their score.
+ * @returns {MiddlewareHandler} A Hono middleware handler.
+ * @throws {HTTPException} Throws a 401 "Bot detected" error if the score is below the
+ * threshold or if a non-verified bot is detected when `allowVerifiedBot` is true.
+ * @example
+ * ```ts
+ * const app = new Hono<{ Variables: HonoIsBotVariables }>();
+ * // Block suspected bots with a score lower than 50
+ * app.use('/api/*', isBot({ threshold: 50, allowVerifiedBot: true }));
+ * ```
+ */
+declare const isBot: MiddlewareWithLoggingCapability<{
+    threshold: number;
+    allowVerifiedBot?: boolean;
+}>;
+
+type HonoLanguageVariables = {
+    language: string;
+};
+type I18nShape = {
+    [key: string]: I18nShape | string;
+};
+type HonoI18nVariables = {
+    t: ReturnType<typeof setI18n>;
+};
+/**
+ * Set i18n
+ *
+ * @param translations - Translations object
+ * @param language - Language
+ * @param defaultLanguage - Default language
+ */
+declare const setI18n: <T extends I18nShape>(translations: T, language: keyof T, defaultLanguage: string) => (input: string, params?: Record<string, string | number>, overrideLanguage?: keyof T) => string;
+/**
+ * I18n Middleware and Queue Factory.
+ * @description
+ * Sets up the `t` translation function in the Hono context.
+ * Note: Requires a preceding middleware to set the `language` variable.
+ * @template T - The shape of the translations object.
+ * @param translations - The dictionary of translations.
+ * @param defaultLanguage - The fallback language code.
+ * @returns An object containing the `middleware` for Hono and a `queue` helper for background tasks.
+ * @example
+ * ```ts
+ * const translations = { en: { hi: "Hi {{name}}" }, fr: { hi: "Salut {{name}}" } };
+ * // 1. Set language first
+ * app.use('*', async (c, next) => {
+ * c.set('language', 'en');
+ * await next();
+ * });
+ * // 2. Initialize i18n
+ * const { middleware } = i18n(translations, 'en');
+ * app.use('*', middleware);
+ * // 3. Use in routes
+ * app.get('/', (c) => c.text(c.var.t('hi', { name: 'User' })));
+ * ```
+ */
+declare const i18n: <T extends I18nShape>(translations: T, defaultLanguage: string) => {
+    middleware: hono.MiddlewareHandler<{
+        Variables: HonoLanguageVariables & HonoI18nVariables;
+    }, string, {}, Response>;
+    queue: (language?: keyof T) => (input: string, params?: Record<string, string | number>, overrideLanguage?: keyof T | undefined) => string;
+};
+
+type DataShape = Record<string, unknown>;
+
+type QueueSendParams = {
+  parentEventId?: string;
+  language?: string;
+};
+
+type GenericQueueDataParams = {
+  eventId: string;
+} & QueueSendParams;
+
+type GenericQueueData<Content extends DataShape> = {
+  handler: keyof Content;
+  content: Content[keyof Content];
+} & GenericQueueDataParams;
+
+interface Variables<Context> {
+  context: Context & Pick<Message, 'retry' | 'ack'>;
+  metadata: Omit<GenericQueueData<DataShape>, 'content'> &
+    Omit<Message, 'body' | 'retry' | 'ack'>;
+}
+
+interface Handler<Content, Context> {
+  (message: Content, context: Context): Promise<void>;
+}
+
+type MessageHandlers<QueueData extends DataShape, Context> = {
+  [Term in keyof QueueData]: Handler<QueueData[Term], Variables<Context>>;
+};
+
+interface ContextFn<Environment, Context> {
+  (env: Environment, params: GenericQueueDataParams): Context;
+}
+
+/**
+ * A type-safe wrapper for Cloudflare Worker Queues using Zod for validation.
+ * * This class orchestrates the relationship between incoming queue messages and
+ * specific logic handlers, ensuring that data is validated at the edge before
+ * reaching your business logic.
+ *
+ * @template Schema - The Zod schema defining the message shapes.
+ * @template Environment - The Cloudflare Worker environment bindings (Env).
+ * @template Context - The application context derived from the environment and message.
+ */
+declare class QueueHandler<Schema extends ZodObject<any>, Environment, Context> {
+    private readonly config;
+    private readonly handlers;
+    /**
+     * @param config - Configuration object.
+     * @param config.schema - The Zod schema used to parse and validate incoming message content.
+     * @param config.setContext - A factory function to generate context (e.g., DB connections, logging) for each message.
+     */
+    constructor(config: {
+        schema: Schema;
+        setContext: ContextFn<Environment, Context>;
+    });
+    /**
+     * Registers a specific processing function for a given message type (handlerName).
+     * * @template {keyof z.infer<Schema>} HandlerName - A specific key defined in your Zod schema.
+     * @param handlerName - The key identifying which handler to use.
+     * @param handler - The asynchronous logic to execute when this message type is received.
+     * @returns The current instance for fluent chaining.
+     */
+    addHandler<HandlerName extends keyof z.infer<Schema>>(handlerName: HandlerName, handler: Handler<z.infer<Schema>[HandlerName], Variables<Context>>): this;
+    /**
+     * Generates the Cloudflare Worker queue consumer function.
+     * * This handles the batch processing loop, parses the message body against the
+     * schema, injects context, and manages concurrency via `Promise.allSettled`.
+     * * @returns An async function compatible with the Cloudflare `queue` export.
+     */
+    getConsumer(): (batch: MessageBatch<GenericQueueData<z.infer<Schema>>>, env: Environment) => Promise<void>;
+    /**
+     * Creates a factory function for sending typed messages to a specific queue.
+     * * @param queue - The Cloudflare Queue binding (e.g., `env.MY_QUEUE`).
+     * @param params - Global parameters to include in every message (e.g., trace IDs).
+     * @returns A producer function that accepts a `handler` key and the corresponding typed content.
+     */
+    getProducer(queue: Queue<unknown>, params: QueueSendParams): <HandlerName extends keyof z.infer<Schema>>(handler: HandlerName, content: z.infer<Schema>[HandlerName]) => Promise<_cloudflare_workers_types.QueueSendResponse>;
+}
+
+/**
+ * Middleware to initialize a Queue producer and attach it to the Hono context.
+ * @description
+ * This middleware manages Cloudflare Queue interactions. If `finalizeLogHandler` is provided,
+ * it will automatically capture the current logger state and send it to the queue after
+ * the request is processed (post-`next()`).
+ * @param options.name - The name of the Queue binding defined in your `wrangler.toml`.
+ * @param options.queueHandler - An instance of your custom QueueHandler.
+ * @param [options.finalizeLogHandler] - Optional: The specific message type/key to use when finalizing the log.
+ * @example
+ * ```ts
+ * // OPTIONAL
+ * app.use('*', logger(
+ *  {
+ *   service: 'logger',
+ *  },
+ *  parentEventIdHeader: 'parent-event-id',
+ * ));
+ *
+ * app.use('*', queue({
+ *  name: 'queue',
+ *  queueHandler: new QueueHandler(),
+ *  finalizeLogHandler: 'log'
+ * }));
+ * ```
+ */
+declare const queue: <Schema extends ZodObject<any>, Environment, Context, Key extends keyof z$1.infer<Schema>>({ name, queueHandler, finalizeLogHandler, }: {
+    name: string;
+    queueHandler: QueueHandler<Schema, Environment, Context>;
+    finalizeLogHandler?: Key;
+}) => hono.MiddlewareHandler<{
+    Bindings: Record<string, Queue>;
+    Variables: HonoLoggerVariables & Record<string, ReturnType<QueueHandler<Schema, Environment, Context>["getProducer"]>>;
+}, string, {}, Response>;
+
+type HonoResponseVariables = {
+    res: ReturnType<typeof setResponseHandlers>;
+};
+declare const setResponseHandlers: (c: Context) => {
+    raw: <T extends {
+        status?: ContentfulStatusCode;
+    }>(data: T) => Response & hono.TypedResponse<hono_utils_types.JSONParsed<Omit<T, "status">, bigint | readonly bigint[]>, 100 | 102 | 103 | 200 | 201 | 202 | 203 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | -1, "json">;
+    success: <T extends object>(message: string, data: T, status?: SuccessStatusCode) => Response & hono.TypedResponse<string | T extends bigint | readonly bigint[] ? never : { [K in keyof {
+        message: string;
+        data: T;
+    } as ({
+        message: string;
+        data: T;
+    }[K] extends infer T_1 ? T_1 extends {
+        message: string;
+        data: T;
+    }[K] ? T_1 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) extends true ? never : K]: boolean extends ({
+        message: string;
+        data: T;
+    }[K] extends infer T_2 ? T_2 extends {
+        message: string;
+        data: T;
+    }[K] ? T_2 extends hono_utils_types.InvalidJSONValue ? true : false : never : never) ? hono_utils_types.JSONParsed<{
+        message: string;
+        data: T;
+    }[K], bigint | readonly bigint[]> | undefined : hono_utils_types.JSONParsed<{
+        message: string;
+        data: T;
+    }[K], bigint | readonly bigint[]>; }, 100 | 102 | 103 | 200 | 201 | 202 | 203 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | -1, "json">;
+    successNoContent: (message: string, status?: SuccessStatusCode) => Response & hono.TypedResponse<{
+        message: string;
+    }, 100 | 102 | 103 | 200 | 201 | 202 | 203 | 206 | 207 | 208 | 226 | 300 | 301 | 302 | 303 | 305 | 306 | 307 | 308 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | -1, "json">;
+    error: (message: string, status: ClientErrorStatusCode) => never;
+    websocket: (socket: WebSocket) => Response;
+};
+/**
+ * Response Middleware
+ * @description
+ * Injects a `res` object into the Hono context (`c.var.res`).
+ * This ensures all outgoing responses follow a consistent schema and include
+ * tracing metadata (like `eventId`) automatically.
+ * @example
+ * ```ts
+ * app.use('*', response());
+ * ```
+ */
+declare const response: hono.MiddlewareHandler<{
+    Variables: HonoResponseVariables & HonoLoggerVariables;
+}, string, {}, Response>;
+
+type CFData = {
+    isEUCountry: boolean;
+    latitude: string;
+    longitude: string;
+    city: string;
+    country: Iso3166Alpha2Code | 'T1';
+    continent: ContinentCode;
+    region?: string;
+    regionCode?: string;
+    postalCode: string;
+    timezone: string;
+    colo: string;
+    asn?: number;
+};
+type UserAgentData = {
+    browser: {
+        name: string;
+        version: string;
+    };
+    device: {
+        model: string;
+        vendor: string;
+        type: UAParser.IDevice['type'] | 'desktop';
+    };
+    engine: {
+        name: string;
+        version: string;
+    };
+    os: {
+        name: string;
+        version: string;
+    };
+    cpu: string;
+};
+type HonoClientInfoVariables = {
+    client: CFData & {
+        ip: string;
+        userAgent: string;
+        securityHash: string;
+    } & UserAgentData;
+};
+/**
+ * Hono middleware that extracts and injects comprehensive client information
+ * into the request context, including geolocation data from Cloudflare and
+ * parsed User-Agent details.
+ * @param {Object} [config] - Optional configuration for the middleware.
+ * @param {Function} [config.securityHashString] - A custom function to generate the seed string
+ * used for the security hash. Receives Cloudflare and User-Agent data as input.
+ * Defaults to `${city}${country}${continent}`.
+ * @param {string} [config.hashSecretBinding] - The name of the environment variable
+ * containing the hash secret. Defaults to 'HASH_SECRET'.
+ * @returns {MiddlewareHandler} A Hono middleware handler.
+ * @throws {Error} Throws an error if Cloudflare (`req.raw.cf`) data is missing.
+ * @example
+ * ```ts
+ * const app = new Hono<{ Variables: HonoClientInfoVariables }>();
+ *
+ * app.use('*', clientInfo({
+ *  useLogger: true // for debugging purposes
+ * }));
+ *
+ * app.get('/me', (c) => {
+ *  const client = c.get('client');
+ *  return c.json({
+ *    location: `${client.city}, ${client.country}`,
+ *    device: client.device.type
+ *  });
+ * });
+ * ```
+ */
+declare const clientInfo: MiddlewareWithLoggingCapability<{
+    hashSecretBinding?: string;
+    securityHashString?: (content: CFData & UserAgentData & {
+        ip: string;
+    }) => string;
+}>;
+
+/**
+ * Derives a secure hex-encoded hash from an input string using PBKDF2-HMAC-SHA256.
+ * * @example
+ * const passwordHash = await hash("myPassword123", "random-salt-string");
+ * * @param {string} input - The plain-text string to hash.
+ * @param {string} salt - The salt string used to randomize the hash.
+ * @param {number} [iterations=600000] - The CPU cost factor. Default is 600,000.
+ * @returns {Promise<string>} A hex-encoded string representing the derived key.
+ */
+declare function hash$1(input: string, salt: string, iterations?: number): Promise<string>;
+/**
+ * Verifies if an input string matches a stored hash using a constant-time comparison.
+ * This prevents timing attacks by ensuring the execution time does not reveal
+ * how many characters of the hash were correct.
+ * * @param {string} input - The plain-text string to verify.
+ * @param {string} salt - The salt used during the original hashing.
+ * @param {string} storedHash - The hex-encoded hash previously stored in the database.
+ * @param {number} iterations - The iteration count used for the original hash.
+ * @returns {Promise<boolean>} Resolves to `true` if the input matches the hash, otherwise `false`.
+ */
+declare function verify(input: string, salt: string, storedHash: string, iterations: number): Promise<boolean>;
+
+declare const pbkdf2_verify: typeof verify;
+declare namespace pbkdf2 {
+  export {
+    hash$1 as hash,
+    pbkdf2_verify as verify,
+  };
+}
+
+/**
+ * Generates a cryptographically strong random salt.
+ */
+declare function generateSalt(length?: number): string;
+/**
+ * Calculates the SHA hash of the given input string.
+ * @param algorithm - The algorithm to be used for hashing. Defaults to 256.
+ * @param pepper - An optional string to be prepended to the input before hashing.
+ * @param salt - An optional string to be appended to the input before hashing.
+ * @returns A Promise that resolves to the hashed string.
+ */
+declare function hash({ input, algorithm, pepper, salt, }: {
+    input: string;
+    algorithm: 'SHA-256' | 'SHA-384' | 'SHA-512';
+    pepper?: string;
+    salt?: string;
+}): Promise<string>;
+
+declare const sha_generateSalt: typeof generateSalt;
+declare const sha_hash: typeof hash;
+declare namespace sha {
+  export {
+    sha_generateSalt as generateSalt,
+    sha_hash as hash,
+  };
+}
+
+declare const onError: <Environment extends Env>(parseError?: (err: Error | HTTPException, env: Environment["Bindings"], get: <K extends keyof Environment["Variables"]>(key: K) => Environment["Variables"][K]) => Promise<string>) => ErrorHandler<Environment>;
+
+declare const onNotFound: NotFoundHandler;
+
+type ErrorBody = Record<string, unknown>;
+interface TypedClientCallbacks {
+    onStart?: () => void;
+    onSuccess?: (parsedData: unknown, headers: Headers) => void;
+    onError?: (parsedData: unknown, headers: Headers) => void;
+    onEnd?: () => void;
+}
+interface CreateTypedClientOptions {
+    url: string;
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    fetch?: typeof fetch;
+    errorHandler?: (status: StatusCode | number, body?: ErrorBody) => never;
+}
+declare const createTypedClient: <TApp extends Hono<any, any, any>>() => (options: CreateTypedClientOptions) => <TSuccessData>(fn: (c: ReturnType<typeof hc<TApp>>) => Promise<ClientResponse<TSuccessData>>, callbacks?: TypedClientCallbacks) => Promise<TSuccessData>;
+
+export { pbkdf2 as PBKDF2, QueueHandler, sha as SHA, clientInfo, createTypedClient, i18n, isBot, jsonValidator, logger, onError, onNotFound, queue, response };
+export type { ContextFn, CreateTypedClientOptions, HonoClientInfoVariables, HonoI18nVariables, HonoIsBotVariables, HonoLanguageVariables, HonoLoggerVariables, HonoResponseVariables, MessageHandlers, MiddlewareWithLoggingCapability, TypedClientCallbacks };

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import { Logger, Details } from 'hierarchical-area-logger';
 import * as hono_utils_http_status from 'hono/utils/http-status';
 import { ContentfulStatusCode, SuccessStatusCode, ClientErrorStatusCode, StatusCode } from 'hono/utils/http-status';
 import z$1, { z, ZodObject } from 'zod';
+import * as _cloudflare_workers_types from '@cloudflare/workers-types';
 import { Message, MessageBatch, Queue, Iso3166Alpha2Code, ContinentCode } from '@cloudflare/workers-types';
 import * as hono_utils_types from 'hono/utils/types';
 import { HTTPException } from 'hono/http-exception';
@@ -221,7 +222,7 @@ declare class QueueHandler<Schema extends ZodObject<any>, Environment, Context>
      * @param params - Global parameters to include in every message (e.g., trace IDs).
      * @returns A producer function that accepts a `handler` key and the corresponding typed content.
      */
-    getProducer(queue: Queue<unknown>, params: QueueSendParams): <HandlerName extends keyof z.infer<Schema>>(handler: HandlerName, content: z.infer<Schema>[HandlerName]) => Promise<void>;
+    getProducer(queue: Queue<unknown>, params: QueueSendParams): <HandlerName extends keyof z.infer<Schema>>(handler: HandlerName, content: z.infer<Schema>[HandlerName]) => Promise<_cloudflare_workers_types.QueueSendResponse>;
 }
 
 /**
@@ -410,7 +411,10 @@ declare function verify(input: string, salt: string, storedHash: string, iterati
 
 declare const pbkdf2_verify: typeof verify;
 declare namespace pbkdf2 {
-  export { hash$1 as hash, pbkdf2_verify as verify };
+  export {
+    hash$1 as hash,
+    pbkdf2_verify as verify,
+  };
 }
 
 /**
@@ -434,7 +438,10 @@ declare function hash({ input, algorithm, pepper, salt, }: {
 declare const sha_generateSalt: typeof generateSalt;
 declare const sha_hash: typeof hash;
 declare namespace sha {
-  export { sha_generateSalt as generateSalt, sha_hash as hash };
+  export {
+    sha_generateSalt as generateSalt,
+    sha_hash as hash,
+  };
 }
 
 declare const onError: <Environment extends Env>(parseError?: (err: Error | HTTPException, env: Environment["Bindings"], get: <K extends keyof Environment["Variables"]>(key: K) => Environment["Variables"][K]) => Promise<string>) => ErrorHandler<Environment>;
@@ -456,4 +463,5 @@ interface CreateTypedClientOptions {
 }
 declare const createTypedClient: <TApp extends Hono<any, any, any>>() => (options: CreateTypedClientOptions) => <TSuccessData>(fn: (c: ReturnType<typeof hc<TApp>>) => Promise<ClientResponse<TSuccessData>>, callbacks?: TypedClientCallbacks) => Promise<TSuccessData>;
 
-export { type ContextFn, type CreateTypedClientOptions, type HonoClientInfoVariables, type HonoI18nVariables, type HonoIsBotVariables, type HonoLanguageVariables, type HonoLoggerVariables, type HonoResponseVariables, type MessageHandlers, type MiddlewareWithLoggingCapability, pbkdf2 as PBKDF2, QueueHandler, sha as SHA, type TypedClientCallbacks, clientInfo, createTypedClient, i18n, isBot, jsonValidator, logger, onError, onNotFound, queue, response };
+export { pbkdf2 as PBKDF2, QueueHandler, sha as SHA, clientInfo, createTypedClient, i18n, isBot, jsonValidator, logger, onError, onNotFound, queue, response };
+export type { ContextFn, CreateTypedClientOptions, HonoClientInfoVariables, HonoI18nVariables, HonoIsBotVariables, HonoLanguageVariables, HonoLoggerVariables, HonoResponseVariables, MessageHandlers, MiddlewareWithLoggingCapability, TypedClientCallbacks };