@trpc/server 11.0.0-alpha-tmp-export-from-main.221 → 11.0.0-alpha-tmp-export-from-main.222

package/dist/adapters/fastify/index.js

@@ -1,9 +1,128 @@
-'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-var fastifyRequestHandler = require('./fastifyRequestHandler.js');
-var fastifyTRPCPlugin = require('./fastifyTRPCPlugin.js');
+var node_stream = require('node:stream');
+var http = require('@trpc/server/http');
+var ws = require('@trpc/server/adapters/ws');
 
+async function fastifyRequestHandler(opts) {
+    const createContext = async (innerOpts)=>{
+        return await opts.createContext?.({
+            ...opts,
+            ...innerOpts
+        });
+    };
+    const query = opts.req.query ? new URLSearchParams(opts.req.query) : new URLSearchParams(opts.req.url.split('?')[1]);
+    const req = {
+        query,
+        method: opts.req.method,
+        headers: opts.req.headers,
+        body: opts.req.body ?? 'null'
+    };
+    let resolve;
+    const promise = new Promise((r)=>resolve = r);
+    let isStream = false;
+    let stream;
+    let formatter;
+    const unstable_onHead = (head, isStreaming)=>{
+        if (!opts.res.statusCode || opts.res.statusCode === 200) {
+            opts.res.statusCode = head.status;
+        }
+        for (const [key, value] of Object.entries(head.headers ?? {})){
+            /* istanbul ignore if -- @preserve */ if (typeof value === 'undefined') {
+                continue;
+            }
+            void opts.res.header(key, value);
+        }
+        if (isStreaming) {
+            void opts.res.header('Transfer-Encoding', 'chunked');
+            void opts.res.header('Vary', opts.res.hasHeader('Vary') ? 'trpc-batch-mode, ' + opts.res.getHeader('Vary') : 'trpc-batch-mode');
+            stream = new node_stream.Readable();
+            stream._read = ()=>{}; // eslint-disable-line @typescript-eslint/no-empty-function -- https://github.com/fastify/fastify/issues/805#issuecomment-369172154
+            resolve(opts.res.send(stream));
+            isStream = true;
+            formatter = http.getBatchStreamFormatter();
+        }
+    };
+    const unstable_onChunk = ([index, string])=>{
+        if (index === -1) {
+            // full response, no streaming
+            resolve(opts.res.send(string));
+        } else {
+            stream.push(formatter(index, string));
+        }
+    };
+    http.resolveHTTPResponse({
+        req,
+        createContext,
+        path: opts.path,
+        router: opts.router,
+        batching: opts.batching,
+        responseMeta: opts.responseMeta,
+        onError (o) {
+            opts?.onError?.({
+                ...o,
+                req: opts.req
+            });
+        },
+        unstable_onHead,
+        unstable_onChunk
+    }).then(()=>{
+        if (isStream) {
+            stream.push(formatter.end());
+            stream.push(null); // https://github.com/fastify/fastify/issues/805#issuecomment-369172154
+        }
+    }).catch(()=>{
+        if (isStream) {
+            stream.push(null);
+        }
+    });
+    return promise;
+}
 
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */ /// <reference types="@fastify/websocket" />
+function fastifyTRPCPlugin(fastify, opts, done) {
+    fastify.removeContentTypeParser('application/json');
+    fastify.addContentTypeParser('application/json', {
+        parseAs: 'string'
+    }, function(_, body, _done) {
+        _done(null, body);
+    });
+    let prefix = opts.prefix ?? '';
+    // https://github.com/fastify/fastify-plugin/blob/fe079bef6557a83794bf437e14b9b9edb8a74104/plugin.js#L11
+    // @ts-expect-error property 'default' does not exists on type ...
+    if (typeof fastifyTRPCPlugin.default !== 'function') {
+        prefix = ''; // handled by fastify internally
+    }
+    fastify.all(`${prefix}/:path`, async (req, res)=>{
+        const path = req.params.path;
+        await fastifyRequestHandler({
+            ...opts.trpcOptions,
+            req,
+            res,
+            path
+        });
+    });
+    if (opts.useWSS) {
+        ws.applyWSSHandler({
+            ...opts.trpcOptions,
+            wss: fastify.websocketServer
+        });
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        fastify.get(prefix ?? '/', {
+            websocket: true
+        }, ()=>{});
+    }
+    done();
+}
 
-exports.fastifyRequestHandler = fastifyRequestHandler.fastifyRequestHandler;
-exports.fastifyTRPCPlugin = fastifyTRPCPlugin.fastifyTRPCPlugin;
+exports.fastifyRequestHandler = fastifyRequestHandler;
+exports.fastifyTRPCPlugin = fastifyTRPCPlugin;

package/dist/adapters/fastify/index.mjs

@@ -1,2 +1,125 @@
-export { fastifyRequestHandler } from './fastifyRequestHandler.mjs';
-export { fastifyTRPCPlugin } from './fastifyTRPCPlugin.mjs';
+import { Readable } from 'node:stream';
+import { resolveHTTPResponse, getBatchStreamFormatter } from '@trpc/server/http';
+import { applyWSSHandler } from '@trpc/server/adapters/ws';
+
+async function fastifyRequestHandler(opts) {
+    const createContext = async (innerOpts)=>{
+        return await opts.createContext?.({
+            ...opts,
+            ...innerOpts
+        });
+    };
+    const query = opts.req.query ? new URLSearchParams(opts.req.query) : new URLSearchParams(opts.req.url.split('?')[1]);
+    const req = {
+        query,
+        method: opts.req.method,
+        headers: opts.req.headers,
+        body: opts.req.body ?? 'null'
+    };
+    let resolve;
+    const promise = new Promise((r)=>resolve = r);
+    let isStream = false;
+    let stream;
+    let formatter;
+    const unstable_onHead = (head, isStreaming)=>{
+        if (!opts.res.statusCode || opts.res.statusCode === 200) {
+            opts.res.statusCode = head.status;
+        }
+        for (const [key, value] of Object.entries(head.headers ?? {})){
+            /* istanbul ignore if -- @preserve */ if (typeof value === 'undefined') {
+                continue;
+            }
+            void opts.res.header(key, value);
+        }
+        if (isStreaming) {
+            void opts.res.header('Transfer-Encoding', 'chunked');
+            void opts.res.header('Vary', opts.res.hasHeader('Vary') ? 'trpc-batch-mode, ' + opts.res.getHeader('Vary') : 'trpc-batch-mode');
+            stream = new Readable();
+            stream._read = ()=>{}; // eslint-disable-line @typescript-eslint/no-empty-function -- https://github.com/fastify/fastify/issues/805#issuecomment-369172154
+            resolve(opts.res.send(stream));
+            isStream = true;
+            formatter = getBatchStreamFormatter();
+        }
+    };
+    const unstable_onChunk = ([index, string])=>{
+        if (index === -1) {
+            // full response, no streaming
+            resolve(opts.res.send(string));
+        } else {
+            stream.push(formatter(index, string));
+        }
+    };
+    resolveHTTPResponse({
+        req,
+        createContext,
+        path: opts.path,
+        router: opts.router,
+        batching: opts.batching,
+        responseMeta: opts.responseMeta,
+        onError (o) {
+            opts?.onError?.({
+                ...o,
+                req: opts.req
+            });
+        },
+        unstable_onHead,
+        unstable_onChunk
+    }).then(()=>{
+        if (isStream) {
+            stream.push(formatter.end());
+            stream.push(null); // https://github.com/fastify/fastify/issues/805#issuecomment-369172154
+        }
+    }).catch(()=>{
+        if (isStream) {
+            stream.push(null);
+        }
+    });
+    return promise;
+}
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */ /// <reference types="@fastify/websocket" />
+function fastifyTRPCPlugin(fastify, opts, done) {
+    fastify.removeContentTypeParser('application/json');
+    fastify.addContentTypeParser('application/json', {
+        parseAs: 'string'
+    }, function(_, body, _done) {
+        _done(null, body);
+    });
+    let prefix = opts.prefix ?? '';
+    // https://github.com/fastify/fastify-plugin/blob/fe079bef6557a83794bf437e14b9b9edb8a74104/plugin.js#L11
+    // @ts-expect-error property 'default' does not exists on type ...
+    if (typeof fastifyTRPCPlugin.default !== 'function') {
+        prefix = ''; // handled by fastify internally
+    }
+    fastify.all(`${prefix}/:path`, async (req, res)=>{
+        const path = req.params.path;
+        await fastifyRequestHandler({
+            ...opts.trpcOptions,
+            req,
+            res,
+            path
+        });
+    });
+    if (opts.useWSS) {
+        applyWSSHandler({
+            ...opts.trpcOptions,
+            wss: fastify.websocketServer
+        });
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        fastify.get(prefix ?? '/', {
+            websocket: true
+        }, ()=>{});
+    }
+    done();
+}
+
+export { fastifyRequestHandler, fastifyTRPCPlugin };

package/dist/adapters/fetch/index.d.mts

@@ -0,0 +1,51 @@
+import { AnyRouter, inferRouterContext } from '@trpc/server';
+import { TRPCRequestInfo, HTTPBaseHandlerOptions } from '@trpc/core';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+type FetchCreateContextFnOptions = {
+    req: Request;
+    resHeaders: Headers;
+    info: TRPCRequestInfo;
+};
+type FetchCreateContextFn<TRouter extends AnyRouter> = (opts: FetchCreateContextFnOptions) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
+type FetchCreateContextOption<TRouter extends AnyRouter> = unknown extends inferRouterContext<TRouter> ? {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext?: FetchCreateContextFn<TRouter>;
+} : {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext: FetchCreateContextFn<TRouter>;
+};
+type FetchHandlerOptions<TRouter extends AnyRouter> = FetchCreateContextOption<TRouter> & HTTPBaseHandlerOptions<TRouter, Request>;
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+type FetchHandlerRequestOptions<TRouter extends AnyRouter> = FetchHandlerOptions<TRouter> & {
+    req: Request;
+    endpoint: string;
+};
+declare function fetchRequestHandler<TRouter extends AnyRouter>(opts: FetchHandlerRequestOptions<TRouter>): Promise<Response>;
+
+export { type FetchCreateContextFn, type FetchCreateContextFnOptions, type FetchCreateContextOption, type FetchHandlerOptions, type FetchHandlerRequestOptions, fetchRequestHandler };

package/dist/adapters/fetch/index.d.ts

@@ -1,3 +1,51 @@
-export * from './fetchRequestHandler';
-export * from './types';
-//# sourceMappingURL=index.d.ts.map
+import { AnyRouter, inferRouterContext } from '@trpc/server';
+import { TRPCRequestInfo, HTTPBaseHandlerOptions } from '@trpc/core';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+type FetchCreateContextFnOptions = {
+    req: Request;
+    resHeaders: Headers;
+    info: TRPCRequestInfo;
+};
+type FetchCreateContextFn<TRouter extends AnyRouter> = (opts: FetchCreateContextFnOptions) => inferRouterContext<TRouter> | Promise<inferRouterContext<TRouter>>;
+type FetchCreateContextOption<TRouter extends AnyRouter> = unknown extends inferRouterContext<TRouter> ? {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext?: FetchCreateContextFn<TRouter>;
+} : {
+    /**
+     * @link https://trpc.io/docs/v11/context
+     **/
+    createContext: FetchCreateContextFn<TRouter>;
+};
+type FetchHandlerOptions<TRouter extends AnyRouter> = FetchCreateContextOption<TRouter> & HTTPBaseHandlerOptions<TRouter, Request>;
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+type FetchHandlerRequestOptions<TRouter extends AnyRouter> = FetchHandlerOptions<TRouter> & {
+    req: Request;
+    endpoint: string;
+};
+declare function fetchRequestHandler<TRouter extends AnyRouter>(opts: FetchHandlerRequestOptions<TRouter>): Promise<Response>;
+
+export { type FetchCreateContextFn, type FetchCreateContextFnOptions, type FetchCreateContextOption, type FetchHandlerOptions, type FetchHandlerRequestOptions, fetchRequestHandler };

package/dist/adapters/fetch/index.js

@@ -1,7 +1,118 @@
-'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 
-var fetchRequestHandler = require('./fetchRequestHandler.js');
+var http = require('@trpc/server/http');
 
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */ // @trpc/server
+const trimSlashes = (path)=>{
+    path = path.startsWith('/') ? path.slice(1) : path;
+    path = path.endsWith('/') ? path.slice(0, -1) : path;
+    return path;
+};
+async function fetchRequestHandler(opts) {
+    const resHeaders = new Headers();
+    const createContext = async (innerOpts)=>{
+        return opts.createContext?.({
+            req: opts.req,
+            resHeaders,
+            ...innerOpts
+        });
+    };
+    const url = new URL(opts.req.url);
+    const pathname = trimSlashes(url.pathname);
+    const endpoint = trimSlashes(opts.endpoint);
+    const path = trimSlashes(pathname.slice(endpoint.length));
+    const req = {
+        query: url.searchParams,
+        method: opts.req.method,
+        headers: Object.fromEntries(opts.req.headers),
+        body: opts.req.headers.get('content-type')?.startsWith('application/json') ? await opts.req.text() : ''
+    };
+    let resolve;
+    const promise = new Promise((r)=>resolve = r);
+    let status = 200;
+    let isStream = false;
+    let controller;
+    let encoder;
+    let formatter;
+    const unstable_onHead = (head, isStreaming)=>{
+        for (const [key, value] of Object.entries(head.headers ?? {})){
+            /* istanbul ignore if -- @preserve */ if (typeof value === 'undefined') {
+                continue;
+            }
+            if (typeof value === 'string') {
+                resHeaders.set(key, value);
+                continue;
+            }
+            for (const v of value){
+                resHeaders.append(key, v);
+            }
+        }
+        status = head.status;
+        if (isStreaming) {
+            resHeaders.set('Transfer-Encoding', 'chunked');
+            resHeaders.append('Vary', 'trpc-batch-mode');
+            const stream = new ReadableStream({
+                start (c) {
+                    controller = c;
+                }
+            });
+            const response = new Response(stream, {
+                status,
+                headers: resHeaders
+            });
+            resolve(response);
+            encoder = new TextEncoder();
+            formatter = http.getBatchStreamFormatter();
+            isStream = true;
+        }
+    };
+    const unstable_onChunk = ([index, string])=>{
+        if (index === -1) {
+            // full response, no streaming
+            const response = new Response(string || null, {
+                status,
+                headers: resHeaders
+            });
+            resolve(response);
+        } else {
+            controller.enqueue(encoder.encode(formatter(index, string)));
+        }
+    };
+    http.resolveHTTPResponse({
+        req,
+        createContext,
+        path,
+        router: opts.router,
+        batching: opts.batching,
+        responseMeta: opts.responseMeta,
+        onError (o) {
+            opts?.onError?.({
+                ...o,
+                req: opts.req
+            });
+        },
+        unstable_onHead,
+        unstable_onChunk
+    }).then(()=>{
+        if (isStream) {
+            controller.enqueue(encoder.encode(formatter.end()));
+            controller.close();
+        }
+    }).catch(()=>{
+        if (isStream) {
+            controller.close();
+        }
+    });
+    return promise;
+}
 
-
-exports.fetchRequestHandler = fetchRequestHandler.fetchRequestHandler;
+exports.fetchRequestHandler = fetchRequestHandler;

package/dist/adapters/fetch/index.mjs

@@ -1 +1,116 @@
-export { fetchRequestHandler } from './fetchRequestHandler.mjs';
+import { resolveHTTPResponse, getBatchStreamFormatter } from '@trpc/server/http';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */ // @trpc/server
+const trimSlashes = (path)=>{
+    path = path.startsWith('/') ? path.slice(1) : path;
+    path = path.endsWith('/') ? path.slice(0, -1) : path;
+    return path;
+};
+async function fetchRequestHandler(opts) {
+    const resHeaders = new Headers();
+    const createContext = async (innerOpts)=>{
+        return opts.createContext?.({
+            req: opts.req,
+            resHeaders,
+            ...innerOpts
+        });
+    };
+    const url = new URL(opts.req.url);
+    const pathname = trimSlashes(url.pathname);
+    const endpoint = trimSlashes(opts.endpoint);
+    const path = trimSlashes(pathname.slice(endpoint.length));
+    const req = {
+        query: url.searchParams,
+        method: opts.req.method,
+        headers: Object.fromEntries(opts.req.headers),
+        body: opts.req.headers.get('content-type')?.startsWith('application/json') ? await opts.req.text() : ''
+    };
+    let resolve;
+    const promise = new Promise((r)=>resolve = r);
+    let status = 200;
+    let isStream = false;
+    let controller;
+    let encoder;
+    let formatter;
+    const unstable_onHead = (head, isStreaming)=>{
+        for (const [key, value] of Object.entries(head.headers ?? {})){
+            /* istanbul ignore if -- @preserve */ if (typeof value === 'undefined') {
+                continue;
+            }
+            if (typeof value === 'string') {
+                resHeaders.set(key, value);
+                continue;
+            }
+            for (const v of value){
+                resHeaders.append(key, v);
+            }
+        }
+        status = head.status;
+        if (isStreaming) {
+            resHeaders.set('Transfer-Encoding', 'chunked');
+            resHeaders.append('Vary', 'trpc-batch-mode');
+            const stream = new ReadableStream({
+                start (c) {
+                    controller = c;
+                }
+            });
+            const response = new Response(stream, {
+                status,
+                headers: resHeaders
+            });
+            resolve(response);
+            encoder = new TextEncoder();
+            formatter = getBatchStreamFormatter();
+            isStream = true;
+        }
+    };
+    const unstable_onChunk = ([index, string])=>{
+        if (index === -1) {
+            // full response, no streaming
+            const response = new Response(string || null, {
+                status,
+                headers: resHeaders
+            });
+            resolve(response);
+        } else {
+            controller.enqueue(encoder.encode(formatter(index, string)));
+        }
+    };
+    resolveHTTPResponse({
+        req,
+        createContext,
+        path,
+        router: opts.router,
+        batching: opts.batching,
+        responseMeta: opts.responseMeta,
+        onError (o) {
+            opts?.onError?.({
+                ...o,
+                req: opts.req
+            });
+        },
+        unstable_onHead,
+        unstable_onChunk
+    }).then(()=>{
+        if (isStream) {
+            controller.enqueue(encoder.encode(formatter.end()));
+            controller.close();
+        }
+    }).catch(()=>{
+        if (isStream) {
+            controller.close();
+        }
+    });
+    return promise;
+}
+
+export { fetchRequestHandler };

package/dist/adapters/next.d.mts

@@ -0,0 +1,21 @@
+import { NextApiRequest, NextApiResponse, NextApiHandler } from 'next';
+export { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
+import { AnyRouter } from '@trpc/server';
+import { NodeHTTPCreateContextFnOptions, NodeHTTPHandlerOptions } from '@trpc/server/adapters/node-http';
+
+/**
+ * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
+ *
+ * Do **not** import from `@trpc/core`
+ * @example
+ * ```ts
+ * import type { AnyTRPCRouter } from '@trpc/server'
+ * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
+ * ```
+ */
+
+type CreateNextContextOptions = NodeHTTPCreateContextFnOptions<NextApiRequest, NextApiResponse>;
+
+declare function createNextApiHandler<TRouter extends AnyRouter>(opts: NodeHTTPHandlerOptions<TRouter, NextApiRequest, NextApiResponse>): NextApiHandler;
+
+export { type CreateNextContextOptions, createNextApiHandler };

package/dist/adapters/next.d.ts

@@ -1,3 +1,8 @@
+import { NextApiRequest, NextApiResponse, NextApiHandler } from 'next';
+export { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
+import { AnyRouter } from '@trpc/server';
+import { NodeHTTPCreateContextFnOptions, NodeHTTPHandlerOptions } from '@trpc/server/adapters/node-http';
+
 /**
  * If you're making an adapter for tRPC and looking at this file for reference, you should import types and functions from `@trpc/server` and `@trpc/server/http`
  *
@@ -8,10 +13,9 @@
  * import type { HTTPBaseHandlerOptions } from '@trpc/server/http'
  * ```
  */
-import type { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
-import type { AnyRouter } from '..';
-import type { NodeHTTPCreateContextFnOptions, NodeHTTPHandlerOptions } from './node-http';
-export type CreateNextContextOptions = NodeHTTPCreateContextFnOptions<NextApiRequest, NextApiResponse>;
-export type { NextApiHandler, NextApiRequest, NextApiResponse } from 'next';
-export declare function createNextApiHandler<TRouter extends AnyRouter>(opts: NodeHTTPHandlerOptions<TRouter, NextApiRequest, NextApiResponse>): NextApiHandler;
-//# sourceMappingURL=next.d.ts.map
+
+type CreateNextContextOptions = NodeHTTPCreateContextFnOptions<NextApiRequest, NextApiResponse>;
+
+declare function createNextApiHandler<TRouter extends AnyRouter>(opts: NodeHTTPHandlerOptions<TRouter, NextApiRequest, NextApiResponse>): NextApiHandler;
+
+export { type CreateNextContextOptions, createNextApiHandler };