@zuplo/cli 6.73.30 → 6.73.31

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/lambda-edge/handler.d.ts

@@ -0,0 +1,87 @@
+import type { Hono } from '../../hono';
+interface CloudFrontHeader {
+    key: string;
+    value: string;
+}
+interface CloudFrontHeaders {
+    [name: string]: CloudFrontHeader[];
+}
+interface CloudFrontCustomOrigin {
+    customHeaders: CloudFrontHeaders;
+    domainName: string;
+    keepaliveTimeout: number;
+    path: string;
+    port: number;
+    protocol: string;
+    readTimeout: number;
+    sslProtocols: string[];
+}
+interface CloudFrontS3Origin {
+    authMethod: 'origin-access-identity' | 'none';
+    customHeaders: CloudFrontHeaders;
+    domainName: string;
+    path: string;
+    region: string;
+}
+type CloudFrontOrigin = {
+    s3: CloudFrontS3Origin;
+    custom?: never;
+} | {
+    custom: CloudFrontCustomOrigin;
+    s3?: never;
+};
+export interface CloudFrontRequest {
+    clientIp: string;
+    headers: CloudFrontHeaders;
+    method: string;
+    querystring: string;
+    uri: string;
+    body?: {
+        inputTruncated: boolean;
+        action: string;
+        encoding: string;
+        data: string;
+    };
+    origin?: CloudFrontOrigin;
+}
+export interface CloudFrontResponse {
+    headers: CloudFrontHeaders;
+    status: string;
+    statusDescription?: string;
+}
+export interface CloudFrontConfig {
+    distributionDomainName: string;
+    distributionId: string;
+    eventType: string;
+    requestId: string;
+}
+interface CloudFrontEvent {
+    cf: {
+        config: CloudFrontConfig;
+        request: CloudFrontRequest;
+        response?: CloudFrontResponse;
+    };
+}
+export interface CloudFrontEdgeEvent {
+    Records: CloudFrontEvent[];
+}
+type CloudFrontContext = {};
+export interface Callback {
+    (err: Error | null, result?: CloudFrontRequest | CloudFrontResult): void;
+}
+interface CloudFrontResult {
+    status: string;
+    statusDescription?: string;
+    headers?: {
+        [header: string]: {
+            key: string;
+            value: string;
+        }[];
+    };
+    body?: string;
+    bodyEncoding?: 'text' | 'base64';
+}
+export declare const handle: (app: Hono<any>) => ((event: CloudFrontEdgeEvent, context?: CloudFrontContext, callback?: Callback) => Promise<CloudFrontResult | CloudFrontRequest>);
+export declare const createBody: (method: string, requestBody: CloudFrontRequest["body"]) => string | Uint8Array<ArrayBuffer> | undefined;
+export declare const isContentTypeBinary: (contentType: string) => boolean;
+export {};

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/lambda-edge/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * Lambda@Edge Adapter for Hono.
+ */
+export { handle } from './handler';
+export { getConnInfo } from './conninfo';
+export type { Callback, CloudFrontConfig, CloudFrontRequest, CloudFrontResponse, CloudFrontEdgeEvent, } from './handler';

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/netlify/conninfo.d.ts

@@ -0,0 +1,21 @@
+import type { GetConnInfo } from '../../helper/conninfo';
+/**
+ * Get connection information from Netlify
+ * @param c - Context
+ * @returns Connection information including remote address
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * import { handle, getConnInfo } from 'hono/netlify'
+ *
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => {
+ *   const info = getConnInfo(c)
+ *   return c.text(`Your IP: ${info.remote.address}`)
+ * })
+ *
+ * export default handle(app)
+ * ```
+ */
+export declare const getConnInfo: GetConnInfo;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/netlify/handler.d.ts

@@ -0,0 +1,2 @@
+import type { Hono } from '../../hono';
+export declare const handle: (app: Hono<any, any>) => ((req: Request, context: any) => Response | Promise<Response>);

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/netlify/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @module
+ * Netlify Adapter for Hono.
+ */
+export * from './mod';

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/netlify/mod.d.ts

@@ -0,0 +1,2 @@
+export { handle } from './handler';
+export { getConnInfo } from './conninfo';

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/service-worker/handler.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Handler for Service Worker
+ * @module
+ */
+import type { Hono } from '../../hono';
+import type { Env, Schema } from '../../types';
+import type { FetchEvent } from './types';
+type Handler = (evt: FetchEvent) => void;
+export type HandleOptions = {
+    fetch?: typeof fetch;
+};
+/**
+ * Adapter for Service Worker
+ */
+export declare const handle: <E extends Env, S extends Schema, BasePath extends string>(app: Hono<E, S, BasePath>, opts?: HandleOptions) => Handler;
+export {};

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/service-worker/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Service Worker Adapter for Hono.
+ * @module
+ */
+import type { Hono } from '../../hono';
+import type { Env, Schema } from '../../types';
+import { handle } from './handler';
+import type { HandleOptions } from './handler';
+/**
+ * Registers a Hono app to handle fetch events in a service worker.
+ * This sets up `addEventListener('fetch', handle(app, options))` for the provided app.
+ *
+ * @param app - The Hono application instance
+ * @param options - Options for handling requests (fetch defaults to undefined)
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * import { fire } from 'hono/service-worker'
+ *
+ * const app = new Hono()
+ *
+ * app.get('/', (c) => c.text('Hi'))
+ *
+ * fire(app)
+ * ```
+ */
+declare const fire: <E extends Env, S extends Schema, BasePath extends string>(app: Hono<E, S, BasePath>, options?: HandleOptions) => void;
+export { handle, fire };

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/service-worker/types.d.ts

@@ -0,0 +1,12 @@
+interface ExtendableEvent extends Event {
+    waitUntil(f: Promise<any>): void;
+}
+export interface FetchEvent extends ExtendableEvent {
+    readonly clientId: string;
+    readonly handled: Promise<void>;
+    readonly preloadResponse: Promise<any>;
+    readonly request: Request;
+    readonly resultingClientId: string;
+    respondWith(r: Response | PromiseLike<Response>): void;
+}
+export {};

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/vercel/conninfo.d.ts

@@ -0,0 +1,2 @@
+import type { GetConnInfo } from '../../helper/conninfo';
+export declare const getConnInfo: GetConnInfo;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/vercel/handler.d.ts

@@ -0,0 +1,2 @@
+import type { Hono } from '../../hono';
+export declare const handle: (app: Hono<any, any, any>) => (req: Request) => Response | Promise<Response>;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/adapter/vercel/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * Vercel Adapter for Hono.
+ */
+export { handle } from './handler';
+export { getConnInfo } from './conninfo';

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/client/client.d.ts

@@ -0,0 +1,4 @@
+import type { Hono } from '../hono';
+import type { UnionToIntersection } from '../utils/types';
+import type { Client, ClientRequestOptions } from './types';
+export declare const hc: <T extends Hono<any, any, any>, Prefix extends string = string>(baseUrl: Prefix, options?: ClientRequestOptions) => UnionToIntersection<Client<T, Prefix>>;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/client/fetch-result-please.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @description This file is a modified version of `fetch-result-please` (`ofetch`), minimalized and adapted to Hono's custom needs.
+ *
+ * @link https://www.npmjs.com/package/fetch-result-please
+ */
+/**
+ * Smartly parses and return the consumable result from a fetch `Response`.
+ *
+ * Throwing a structured error if the response is not `ok`. ({@link DetailedError})
+ */
+export declare function fetchRP(fetchRes: Response | Promise<Response>): Promise<any>;
+export declare class DetailedError extends Error {
+    /**
+     * Additional `message` that will be logged AND returned to client
+     */
+    detail?: any;
+    /**
+     * Additional `code` that will be logged AND returned to client
+     */
+    code?: any;
+    /**
+     * Additional value that will be logged AND NOT returned to client
+     */
+    log?: any;
+    /**
+     * Optionally set the status code to return, in a web server context
+     */
+    statusCode?: any;
+    constructor(message: string, options?: {
+        detail?: any;
+        code?: any;
+        statusCode?: number;
+        log?: any;
+    });
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/client/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * The HTTP Client for Hono.
+ */
+export { hc } from './client';
+export { parseResponse, DetailedError } from './utils';
+export type { InferResponseType, InferRequestType, Fetch, ClientRequestOptions, ClientRequest, ClientResponse, ApplyGlobalResponse, PickResponseByStatusCode, } from './types';

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/client/types.d.ts

@@ -0,0 +1,229 @@
+import type { Hono } from '../hono';
+import type { HonoBase } from '../hono-base';
+import type { METHODS, METHOD_NAME_ALL_LOWERCASE } from '../router';
+import type { Endpoint, ExtractSchema, KnownResponseFormat, ResponseFormat, Schema } from '../types';
+import type { StatusCode, SuccessStatusCode } from '../utils/http-status';
+import type { HasRequiredKeys } from '../utils/types';
+/**
+ * Type representing the '$all' method name
+ */
+type MethodNameAll = `$${typeof METHOD_NAME_ALL_LOWERCASE}`;
+/**
+ * Type representing all standard HTTP methods prefixed with '$'
+ * e.g., '$get' | '$post' | '$put' | '$delete' | '$options' | '$patch'
+ */
+type StandardMethods = `$${(typeof METHODS)[number]}`;
+/**
+ * Expands '$all' into all standard HTTP methods.
+ * If the schema contains '$all', it creates a type where all standard HTTP methods
+ * point to the same endpoint definition as '$all', while removing '$all' itself.
+ */
+type ExpandAllMethod<S> = MethodNameAll extends keyof S ? {
+    [M in StandardMethods]: S[MethodNameAll];
+} & Omit<S, MethodNameAll> : S;
+type HonoRequest = (typeof Hono.prototype)['request'];
+export type BuildSearchParamsFn = (query: Record<string, string | string[]>) => URLSearchParams;
+export type ClientRequestOptions<T = unknown> = {
+    fetch?: typeof fetch | HonoRequest;
+    webSocket?: (...args: ConstructorParameters<typeof WebSocket>) => WebSocket;
+    /**
+     * Standard `RequestInit`, caution that this take highest priority
+     * and could be used to overwrite things that Hono sets for you, like `body | method | headers`.
+     *
+     * If you want to add some headers, use in `headers` instead of `init`
+     */
+    init?: RequestInit;
+    /**
+     * Custom function to serialize query parameters into URLSearchParams.
+     * By default, arrays are serialized as multiple parameters with the same key (e.g., `key=a&key=b`).
+     * You can provide a custom function to change this behavior, for example to use bracket notation (e.g., `key[]=a&key[]=b`).
+     *
+     * @example
+     * ```ts
+     * const client = hc('http://localhost', {
+     *   buildSearchParams: (query) => {
+     *     return new URLSearchParams(qs.stringify(query))
+     *   }
+     * })
+     * ```
+     */
+    buildSearchParams?: BuildSearchParamsFn;
+} & (keyof T extends never ? {
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+} : {
+    headers: T | (() => T | Promise<T>);
+});
+export type ClientRequest<Prefix extends string, Path extends string, S extends Schema> = {
+    [M in keyof ExpandAllMethod<S>]: ExpandAllMethod<S>[M] extends Endpoint & {
+        input: infer R;
+    } ? R extends object ? HasRequiredKeys<R> extends true ? (args: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : (args?: R, options?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<ExpandAllMethod<S>[M]>> : never : never;
+} & {
+    $url: <const Arg extends (S[keyof S] extends {
+        input: infer R;
+    } ? R extends {
+        param: infer P;
+    } ? R extends {
+        query: infer Q;
+    } ? {
+        param: P;
+        query: Q;
+    } : {
+        param: P;
+    } : R extends {
+        query: infer Q;
+    } ? {
+        query: Q;
+    } : {} : {}) | undefined = undefined>(arg?: Arg) => HonoURL<Prefix, Path, Arg>;
+    $path: <const Arg extends (S[keyof S] extends {
+        input: infer R;
+    } ? R extends {
+        param: infer P;
+    } ? R extends {
+        query: infer Q;
+    } ? {
+        param: P;
+        query: Q;
+    } : {
+        param: P;
+    } : R extends {
+        query: infer Q;
+    } ? {
+        query: Q;
+    } : {} : {}) | undefined = undefined>(arg?: Arg) => BuildPath<Path, Arg>;
+} & (S['$get'] extends {
+    outputFormat: 'ws';
+} ? S['$get'] extends {
+    input: infer I;
+} ? {
+    $ws: (args?: I) => WebSocket;
+} : {} : {});
+type ClientResponseOfEndpoint<T extends Endpoint = Endpoint> = T extends {
+    output: infer O;
+    outputFormat: infer F;
+    status: infer S;
+} ? ClientResponse<O, S extends number ? S : never, F extends ResponseFormat ? F : never> : never;
+export interface ClientResponse<T, U extends number = StatusCode, F extends ResponseFormat = ResponseFormat> {
+    readonly body: ReadableStream | null;
+    readonly bodyUsed: boolean;
+    ok: U extends SuccessStatusCode ? true : U extends Exclude<StatusCode, SuccessStatusCode> ? false : boolean;
+    redirected: boolean;
+    status: U;
+    statusText: string;
+    type: 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
+    headers: Headers;
+    url: string;
+    redirect(url: string, status: number): Response;
+    clone(): Response;
+    bytes(): Promise<Uint8Array<ArrayBuffer>>;
+    json(): F extends 'text' ? Promise<never> : F extends 'json' ? Promise<T> : Promise<unknown>;
+    text(): F extends 'text' ? (T extends string ? Promise<T> : Promise<never>) : Promise<string>;
+    blob(): Promise<Blob>;
+    formData(): Promise<FormData>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+}
+type BuildSearch<Arg, Key extends 'query'> = Arg extends {
+    [K in Key]: infer Query;
+} ? IsEmptyObject<Query> extends true ? '' : `?${string}` : '';
+type BuildPathname<P extends string, Arg> = Arg extends {
+    param: infer Param;
+} ? `${ApplyParam<TrimStartSlash<P>, Param>}` : `/${TrimStartSlash<P>}`;
+type BuildPath<P extends string, Arg> = `${BuildPathname<P, Arg>}${BuildSearch<Arg, 'query'>}`;
+type BuildTypedURL<Protocol extends string, Host extends string, Port extends string, P extends string, Arg> = TypedURL<`${Protocol}:`, Host, Port, BuildPathname<P, Arg>, BuildSearch<Arg, 'query'>>;
+type HonoURL<Prefix extends string, Path extends string, Arg> = IsLiteral<Prefix> extends true ? TrimEndSlash<Prefix> extends `${infer Protocol}://${infer Rest}` ? Rest extends `${infer Hostname}/${infer P}` ? ParseHostName<Hostname> extends [infer Host extends string, infer Port extends string] ? BuildTypedURL<Protocol, Host, Port, P, Arg> : never : ParseHostName<Rest> extends [infer Host extends string, infer Port extends string] ? BuildTypedURL<Protocol, Host, Port, Path, Arg> : never : URL : URL;
+type ParseHostName<T extends string> = T extends `${infer Host}:${infer Port}` ? [Host, Port] : [T, ''];
+type TrimStartSlash<T extends string> = T extends `/${infer R}` ? TrimStartSlash<R> : T;
+type TrimEndSlash<T extends string> = T extends `${infer R}/` ? TrimEndSlash<R> : T;
+type IsLiteral<T extends string> = [T] extends [never] ? false : string extends T ? false : true;
+type ApplyParam<Path extends string, P, Result extends string = ''> = Path extends `${infer Head}/${infer Rest}` ? Head extends `:${infer Param}` ? P extends Record<Param, infer Value extends string> ? IsLiteral<Value> extends true ? ApplyParam<Rest, P, `${Result}/${Value & string}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : ApplyParam<Rest, P, `${Result}/${Head}`> : Path extends `:${infer Param}` ? P extends Record<Param, infer Value extends string> ? IsLiteral<Value> extends true ? `${Result}/${Value & string}` : `${Result}/${Path}` : `${Result}/${Path}` : `${Result}/${Path}`;
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+export interface TypedURL<Protocol extends string, Hostname extends string, Port extends string, Pathname extends string, Search extends string> extends URL {
+    protocol: Protocol;
+    hostname: Hostname;
+    port: Port;
+    host: Port extends '' ? Hostname : `${Hostname}:${Port}`;
+    origin: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}`;
+    pathname: Pathname;
+    search: Search;
+    href: `${Protocol}//${Hostname}${Port extends '' ? '' : `:${Port}`}${Pathname}${Search}`;
+}
+export interface Response extends ClientResponse<unknown> {
+}
+export type Fetch<T> = (args?: InferRequestType<T>, opt?: ClientRequestOptions) => Promise<ClientResponseOfEndpoint<InferEndpointType<T>>>;
+type InferEndpointType<T> = T extends (args: infer R, options: any | undefined) => Promise<infer U> ? U extends ClientResponse<infer O, infer S, infer F> ? {
+    input: NonNullable<R>;
+    output: O;
+    outputFormat: F;
+    status: S;
+} extends Endpoint ? {
+    input: NonNullable<R>;
+    output: O;
+    outputFormat: F;
+    status: S;
+} : never : never : never;
+export type InferResponseType<T, U extends StatusCode = StatusCode> = InferResponseTypeFromEndpoint<InferEndpointType<T>, U>;
+type InferResponseTypeFromEndpoint<T extends Endpoint, U extends StatusCode> = T extends {
+    output: infer O;
+    status: infer S;
+} ? S extends U ? O : never : never;
+export type InferRequestType<T> = T extends (args: infer R, options: any | undefined) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
+export type InferRequestOptionsType<T> = T extends (args: any, options: infer R) => Promise<ClientResponse<unknown>> ? NonNullable<R> : never;
+/**
+ * Filter a ClientResponse type so it only includes responses of specific status codes.
+ */
+export type FilterClientResponseByStatusCode<T extends ClientResponse<any, any, any>, U extends number = StatusCode> = T extends ClientResponse<infer RT, infer RC, infer RF> ? RC extends U ? ClientResponse<RT, RC, RF> : never : never;
+type PathToChain<Prefix extends string, Path extends string, E extends Schema, Original extends string = Path> = Path extends `/${infer P}` ? PathToChain<Prefix, P, E, Path> : Path extends `${infer P}/${infer R}` ? {
+    [K in P]: PathToChain<Prefix, R, E, Original>;
+} : {
+    [K in Path extends '' ? 'index' : Path]: ClientRequest<Prefix, Original, E extends Record<string, unknown> ? E[Original] : never>;
+};
+export type Client<T, Prefix extends string> = T extends HonoBase<any, infer S, any> ? S extends Record<infer K, Schema> ? K extends string ? PathToChain<Prefix, K, S> : never : never : never;
+export type Callback = (opts: CallbackOptions) => unknown;
+interface CallbackOptions {
+    path: string[];
+    args: any[];
+}
+export type ObjectType<T = unknown> = {
+    [key: string]: T;
+};
+type GlobalResponseDefinition = {
+    [S in StatusCode]?: {
+        [F in KnownResponseFormat]?: unknown;
+    };
+};
+type ToEndpoints<Def extends GlobalResponseDefinition, R> = {
+    [S in keyof Def & StatusCode]: {
+        [F in keyof Def[S] & KnownResponseFormat]: Omit<R, 'output' | 'status' | 'outputFormat'> & {
+            output: Def[S][F];
+            status: S;
+            outputFormat: F;
+        };
+    }[keyof Def[S] & KnownResponseFormat];
+}[keyof Def & StatusCode];
+type ModRoute<R, Def extends GlobalResponseDefinition> = R extends Endpoint ? R | ToEndpoints<Def, R> : R;
+type ModSchema<D, Def extends GlobalResponseDefinition> = {
+    [K in keyof D]: {
+        [M in keyof D[K]]: ModRoute<D[K][M], Def>;
+    };
+};
+export type ApplyGlobalResponse<App, Def extends GlobalResponseDefinition> = App extends HonoBase<infer E, infer _ extends Schema, infer B> ? ModSchema<ExtractSchema<App>, Def> extends infer S extends Schema ? Hono<E, S, B> : never : never;
+type PickRoute<R, U extends StatusCode> = R extends Endpoint ? R extends {
+    status: U;
+} ? R : never : R;
+type PickSchema<D, U extends StatusCode> = {
+    [K in keyof D]: {
+        [M in keyof D[K]]: PickRoute<D[K][M], U>;
+    };
+};
+/**
+ * Keep only specific status code responses from all routes of an app.
+ * Useful when error responses are handled centrally (e.g., via custom fetch)
+ * and you want the client to only expose success response types.
+ *
+ * @example
+ * ```ts
+ * type AppSuccessOnly = PickResponseByStatusCode<typeof app, 200>
+ * const client = hc<AppSuccessOnly>('http://localhost')
+ * ```
+ */
+export type PickResponseByStatusCode<App, U extends StatusCode> = App extends HonoBase<infer E, infer _ extends Schema, infer B> ? PickSchema<ExtractSchema<App>, U> extends infer S extends Schema ? Hono<E, S, B> : never : never;
+export {};

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/client/utils.d.ts

@@ -0,0 +1,18 @@
+import type { ClientErrorStatusCode, ContentfulStatusCode, ServerErrorStatusCode } from '../utils/http-status';
+import { DetailedError } from './fetch-result-please';
+import type { ClientResponse, FilterClientResponseByStatusCode } from './types';
+export { DetailedError };
+export declare const mergePath: (base: string, path: string) => string;
+export declare const replaceUrlParam: (urlString: string, params: Record<string, string | undefined>) => string;
+export declare const buildSearchParams: (query: Record<string, string | string[]>) => URLSearchParams;
+export declare const replaceUrlProtocol: (urlString: string, protocol: "ws" | "http") => string;
+export declare const removeIndexString: (urlString: string) => string;
+export declare function deepMerge<T>(target: T, source: Record<string, unknown>): T;
+/**
+ * Shortcut to get a consumable response from `hc`'s fetch calls (Response), with types inference.
+ *
+ * Smartly parse the response data, throwing a structured error if the response is not `ok`. ({@link DetailedError})
+ *
+ * @example const result = await parseResponse(client.posts.$get())
+ */
+export declare function parseResponse<T extends ClientResponse<any>>(fetchRes: T | Promise<T>): Promise<FilterClientResponseByStatusCode<T, Exclude<ContentfulStatusCode, ClientErrorStatusCode | ServerErrorStatusCode>> extends never ? undefined : FilterClientResponseByStatusCode<T, Exclude<ContentfulStatusCode, ClientErrorStatusCode | ServerErrorStatusCode>> extends ClientResponse<infer RT, infer _, infer RF> ? RF extends 'json' ? RT : RT extends string ? RT : string : undefined>;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/compose.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from './context';
+import type { Env, ErrorHandler, Next, NotFoundHandler } from './types';
+/**
+ * Compose middleware functions into a single function based on `koa-compose` package.
+ *
+ * @template E - The environment type.
+ *
+ * @param {[[Function, unknown], unknown][] | [[Function]][]} middleware - An array of middleware functions and their corresponding parameters.
+ * @param {ErrorHandler<E>} [onError] - An optional error handler function.
+ * @param {NotFoundHandler<E>} [onNotFound] - An optional not-found handler function.
+ *
+ * @returns {(context: Context, next?: Next) => Promise<Context>} - A composed middleware function.
+ */
+export declare const compose: <E extends Env = Env>(middleware: [[Function, unknown], unknown][] | [[Function]][], onError?: ErrorHandler<E>, onNotFound?: NotFoundHandler<E>) => ((context: Context, next?: Next) => Promise<Context>);