jishushell 0.6.18 → 0.7.3

package/node_modules/fastify/test/types/content-type-parser.tst.ts

@@ -0,0 +1,70 @@
+import { IncomingMessage } from 'node:http'
+import { expect } from 'tstyche'
+import fastify, { FastifyBodyParser } from '../../fastify.js'
+import { FastifyRequest } from '../../types/request.js'
+
+expect(fastify().addContentTypeParser('contentType', function (request, payload, done) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(payload).type.toBe<IncomingMessage>()
+  done(null)
+})).type.toBe<void>()
+
+// Body limit options
+
+expect(fastify().addContentTypeParser('contentType', { bodyLimit: 99 }, function (request, payload, done) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(payload).type.toBe<IncomingMessage>()
+  done(null)
+})).type.toBe<void>()
+
+// Array for contentType
+
+expect(fastify().addContentTypeParser(['contentType'], function (request, payload, done) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(payload).type.toBe<IncomingMessage>()
+  done(null)
+})).type.toBe<void>()
+
+// Body Parser - the generic after addContentTypeParser enforces the type of the `body` parameter as well as the value of the `parseAs` property
+
+expect(fastify().addContentTypeParser<string>('bodyContentType', { parseAs: 'string' }, function (request, body, done) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(body).type.toBe<string>()
+  done(null)
+})).type.toBe<void>()
+
+expect(fastify().addContentTypeParser<Buffer>('bodyContentType', { parseAs: 'buffer' }, function (request, body, done) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(body).type.toBe<Buffer>()
+  done(null)
+})).type.toBe<void>()
+
+expect(fastify().addContentTypeParser('contentType', async function (request: FastifyRequest, payload: IncomingMessage) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(payload).type.toBe<IncomingMessage>()
+  return null
+})).type.toBe<void>()
+
+expect(fastify().addContentTypeParser<string>('bodyContentType', { parseAs: 'string' }, async function (request: FastifyRequest, body: string) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(body).type.toBe<string>()
+  return null
+})).type.toBe<void>()
+
+expect(fastify().addContentTypeParser<Buffer>('bodyContentType', { parseAs: 'buffer' }, async function (request: FastifyRequest, body: Buffer) {
+  expect(request).type.toBe<FastifyRequest>()
+  expect(body).type.toBe<Buffer>()
+  return null
+})).type.toBe<void>()
+
+expect(fastify().getDefaultJsonParser('error', 'ignore')).type.toBe<FastifyBodyParser<string>>()
+expect(fastify().getDefaultJsonParser).type.not.toBeCallableWith('error', 'skip')
+expect(fastify().getDefaultJsonParser).type.not.toBeCallableWith('nothing', 'ignore')
+
+expect(fastify().removeAllContentTypeParsers()).type.toBe<void>()
+expect(fastify().removeAllContentTypeParsers).type.not.toBeCallableWith('contentType')
+
+expect(fastify().removeContentTypeParser('contentType')).type.toBe<void>()
+expect(fastify().removeContentTypeParser(/contentType+.*/)).type.toBe<void>()
+expect(fastify().removeContentTypeParser(['contentType', /contentType+.*/])).type.toBe<void>()
+expect(fastify().removeContentTypeParser).type.not.toBeCallableWith({})

package/node_modules/fastify/test/types/{decorate-request-reply.test-d.ts → decorate-request-reply.tst.ts}

@@ -1,5 +1,5 @@
-import fastify from '../../fastify'
-import { expectType } from 'tsd'
+import { expect } from 'tstyche'
+import fastify from '../../fastify.js'
 
 type TestType = void
 
@@ -13,6 +13,6 @@ declare module '../../fastify' {
 }
 
 fastify().get('/', (req, res) => {
-  expectType<TestType>(req.testProp)
-  expectType<TestType>(res.testProp)
+  expect(req.testProp).type.toBe<TestType>()
+  expect(res.testProp).type.toBe<TestType>()
 })

package/node_modules/fastify/test/types/{dummy-plugin.ts → dummy-plugin.mts}

@@ -1,4 +1,4 @@
-import { FastifyPluginAsync } from '../../fastify'
+import { FastifyPluginAsync } from '../../fastify.js'
 
 export interface DummyPluginOptions {
   foo?: number

package/node_modules/fastify/test/types/errors.tst.ts

@@ -0,0 +1,91 @@
+import { FastifyErrorConstructor } from '@fastify/error'
+import { expect } from 'tstyche'
+import { errorCodes } from '../../fastify.js'
+
+expect(errorCodes.FST_ERR_NOT_FOUND).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_OPTIONS_NOT_OBJ).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_QSP_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_VALIDATION).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LISTEN_OPTIONS_INVALID).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ERROR_HANDLER_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ERROR_HANDLER_ALREADY_SET).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_ALREADY_PRESENT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_EMPTY_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_PARSE_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_BODY_TOO_LARGE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_MEDIA_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_CONTENT_LENGTH).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_EMPTY_JSON_BODY).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INVALID_JSON_BODY).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_CTP_INSTANCE_ALREADY_STARTED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_ALREADY_PRESENT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_DEPENDENCY_INVALID_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_MISSING_DEPENDENCY).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_AFTER_START).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_REFERENCE_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DEC_UNDECLARED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_HOOK_INVALID_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_HOOK_INVALID_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_HOOK_NOT_SUPPORTED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_MISSING_MIDDLEWARE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_HOOK_TIMEOUT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LOG_INVALID_DESTINATION).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LOG_INVALID_LOGGER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LOG_INVALID_LOGGER_INSTANCE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LOG_INVALID_LOGGER_CONFIG).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REP_INVALID_PAYLOAD_TYPE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REP_RESPONSE_BODY_CONSUMED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REP_READABLE_STREAM_LOCKED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REP_ALREADY_SENT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REP_SENT_VALUE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SEND_INSIDE_ONERR).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SEND_UNDEFINED_ERR).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_BAD_STATUS_CODE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_BAD_TRAILER_NAME).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_BAD_TRAILER_VALUE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_FAILED_ERROR_SERIALIZATION).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_MISSING_SERIALIZATION_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REQ_INVALID_VALIDATION_INVOCATION).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_MISSING_ID).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_ALREADY_PRESENT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_CONTENT_MISSING_SCHEMA).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_DUPLICATE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_VALIDATION_BUILD).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_SERIALIZATION_BUILD).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_INIT_OPTS_INVALID).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_DUPLICATED_ROUTE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_BAD_URL).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ASYNC_CONSTRAINT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_INVALID_URL).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_OPTIONS_NOT_OBJ).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_DUPLICATED_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_HANDLER_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_MISSING_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_METHOD_INVALID).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_METHOD_NOT_SUPPORTED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROUTE_REWRITE_NOT_STR).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REOPENED_CLOSE_SERVER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_REOPENED_SERVER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_INSTANCE_ALREADY_LISTENING).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_VERSION_MISMATCH).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_CALLBACK_NOT_FN).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_NOT_VALID).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_ROOT_PLG_BOOTED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PARENT_PLUGIN_BOOTED).type.toBeAssignableTo<FastifyErrorConstructor>()
+expect(errorCodes.FST_ERR_PLUGIN_TIMEOUT).type.toBeAssignableTo<FastifyErrorConstructor>()

package/node_modules/fastify/test/types/fastify.tst.ts

@@ -0,0 +1,351 @@
+import * as http from 'node:http'
+import * as http2 from 'node:http2'
+import * as https from 'node:https'
+import { Socket } from 'node:net'
+import Ajv, { ErrorObject as AjvErrorObject } from 'ajv'
+import { expect } from 'tstyche'
+import fastify, {
+  ConnectionError,
+  FastifyBaseLogger,
+  FastifyError,
+  FastifyErrorCodes,
+  FastifyInstance,
+  FastifyPlugin,
+  FastifyPluginAsync,
+  FastifyPluginCallback,
+  InjectOptions,
+  LightMyRequestCallback,
+  LightMyRequestChain,
+  LightMyRequestResponse,
+  RawRequestDefaultExpression,
+  RouteGenericInterface,
+  SafePromiseLike
+} from '../../fastify.js'
+import { Bindings, ChildLoggerOptions } from '../../types/logger.js'
+
+// FastifyInstance
+// http server
+expect(fastify()).type.not.toBeAssignableTo<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  Promise<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+expect(fastify()).type.toBeAssignableTo<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  PromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+expect(fastify()).type.toBe<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+expect(fastify({})).type.toBe<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+expect(fastify({ http: {} })).type.toBe<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+// https server
+expect(fastify({ https: {} })).type.toBe<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+expect(fastify({ https: null })).type.toBe<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+// http2 server
+expect(fastify({ http2: true, http2SessionTimeout: 1000 })).type.toBe<
+  FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse> &
+  SafePromiseLike<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>>
+>()
+expect(fastify({ http2: true, https: {}, http2SessionTimeout: 1000 })).type.toBe<
+  FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse> &
+  SafePromiseLike<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse>>
+>()
+expect(fastify({ http2: true, https: {} }).inject()).type.toBe<LightMyRequestChain>()
+expect(fastify({ schemaController: {} })).type.toBe<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+expect(
+  fastify({
+    schemaController: {
+      compilersFactory: {}
+    }
+  })
+).type.toBe<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+
+// @ts-expect-error  Type 'false' is not assignable to type 'true'.
+fastify<http2.Http2Server>({ http2: false })
+// @ts-expect-error  Type 'false' is not assignable to type 'true'.
+fastify<http2.Http2SecureServer>({ http2: false })
+fastify({
+  schemaController: {
+    // @ts-expect-error  No overload matches this call.
+    bucket: () => ({})
+  }
+})
+
+// light-my-request
+expect<InjectOptions>().type.toBeAssignableFrom({ query: '' })
+fastify({ http2: true, https: {} }).inject().then((resp) => {
+  expect(resp).type.toBe<LightMyRequestResponse>()
+})
+const lightMyRequestCallback: LightMyRequestCallback = (
+  err: Error | undefined,
+  response: LightMyRequestResponse | undefined
+) => {
+  if (err) throw err
+}
+fastify({ http2: true, https: {} }).inject({}, lightMyRequestCallback)
+
+// server options
+expect(fastify({ http2: true })).type.toBeAssignableTo<
+  FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>
+>()
+expect(fastify({ ignoreTrailingSlash: true })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ ignoreDuplicateSlashes: true })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ connectionTimeout: 1000 })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ forceCloseConnections: true })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ keepAliveTimeout: 1000 })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ pluginTimeout: 1000 })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ bodyLimit: 100 })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ handlerTimeout: 5000 })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ maxParamLength: 100 })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ disableRequestLogging: true })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ disableRequestLogging: (req) => req.url?.includes('/health') ?? false })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ requestIdLogLabel: 'request-id' })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ onProtoPoisoning: 'error' })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ onConstructorPoisoning: 'error' })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ serializerOpts: { rounding: 'ceil' } })).type.toBeAssignableTo<FastifyInstance>()
+expect(
+  fastify({ serializerOpts: { ajv: { missingRefs: 'ignore' } } })
+).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ serializerOpts: { schema: {} } })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ serializerOpts: { otherProp: {} } })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ logger: true })).type.toBeAssignableTo<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>
+>()
+expect(fastify({ logger: true })).type.toBeAssignableTo<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>
+>()
+expect(fastify({
+  logger: {
+    level: 'info',
+    genReqId: () => 'request-id',
+    serializers: {
+      req: () => {
+        return {
+          method: 'GET',
+          url: '/',
+          version: '1.0.0',
+          host: 'localhost',
+          remoteAddress: '127.0.0.1',
+          remotePort: 3000
+        }
+      },
+      res: () => {
+        return {
+          statusCode: 200
+        }
+      },
+      err: () => {
+        return {
+          type: 'Error',
+          message: 'foo',
+          stack: ''
+        }
+      }
+    }
+  }
+})).type.toBeAssignableTo<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>>()
+const customLogger = {
+  level: 'info',
+  info: () => { },
+  warn: () => { },
+  error: () => { },
+  fatal: () => { },
+  trace: () => { },
+  debug: () => { },
+  child: () => customLogger
+}
+expect(fastify({ logger: customLogger })).type.toBeAssignableTo<
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse, FastifyBaseLogger>
+>()
+expect(fastify({ serverFactory: () => http.createServer() })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ caseSensitive: true })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ requestIdHeader: 'request-id' })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ requestIdHeader: false })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({
+  genReqId: (req) => {
+    expect(req).type.toBe<RawRequestDefaultExpression>()
+    return 'foo'
+  }
+})).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ trustProxy: true })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ querystringParser: () => ({ foo: 'bar' }) })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ querystringParser: () => ({ foo: { bar: 'fuzz' } }) })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ querystringParser: () => ({ foo: ['bar', 'fuzz'] }) })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ constraints: {} })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({
+  constraints: {
+    version: {
+      name: 'version',
+      storage: () => ({
+        get: () => () => { },
+        set: () => { },
+        del: () => { },
+        empty: () => { }
+      }),
+      validate () { },
+      deriveConstraint: () => 'foo'
+    },
+    host: {
+      name: 'host',
+      storage: () => ({
+        get: () => () => { },
+        set: () => { },
+        del: () => { },
+        empty: () => { }
+      }),
+      validate () { },
+      deriveConstraint: () => 'foo'
+    },
+    withObjectValue: {
+      name: 'withObjectValue',
+      storage: () => ({
+        get: () => () => { },
+        set: () => { },
+        del: () => { },
+        empty: () => { }
+      }),
+      validate () { },
+      deriveConstraint: () => { }
+
+    }
+  }
+})).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ return503OnClosing: true })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({
+  ajv: {
+    customOptions: {
+      removeAdditional: 'all'
+    },
+    plugins: [(ajv: Ajv): Ajv => ajv]
+  }
+})).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({
+  ajv: {
+    plugins: [[(ajv: Ajv): Ajv => ajv, ['keyword1', 'keyword2']]]
+  }
+})).type.toBeAssignableTo<FastifyInstance>()
+fastify({
+  ajv: {
+    customOptions: {
+      removeAdditional: 'all'
+    },
+    plugins: [
+      // @ts-expect-error  Type 'void' is not assignable to type 'Ajv'.
+      () => { }
+    ]
+  }
+})
+expect(fastify({
+  ajv: {
+    onCreate: (ajvInstance) => {
+      expect(ajvInstance).type.toBe<Ajv>()
+      return ajvInstance
+    }
+  }
+})).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ frameworkErrors: () => { } })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({
+  rewriteUrl: function (req) {
+    this.log.debug('rewrite url')
+    return req.url === '/hi' ? '/hello' : req.url!
+  }
+})).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({
+  schemaErrorFormatter: (errors, dataVar) => {
+    console.log(
+      errors[0].keyword.toLowerCase(),
+      errors[0].message?.toLowerCase(),
+      errors[0].params,
+      errors[0].instancePath.toLowerCase(),
+      errors[0].schemaPath.toLowerCase()
+    )
+    return new Error()
+  }
+})).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({
+  clientErrorHandler: (err, socket) => {
+    expect(err).type.toBe<ConnectionError>()
+    expect(socket).type.toBe<Socket>()
+  }
+})).type.toBeAssignableTo<FastifyInstance>()
+
+expect(fastify({
+  childLoggerFactory: function (
+    this,
+    logger,
+    bindings,
+    opts,
+    req
+  ) {
+    expect(logger).type.toBe<FastifyBaseLogger>()
+    expect(bindings).type.toBe<Bindings>()
+    expect(opts).type.toBe<ChildLoggerOptions>()
+    expect(req).type.toBe<RawRequestDefaultExpression>()
+    expect(this).type.toBeAssignableTo<FastifyInstance>()
+    return logger.child(bindings, opts)
+  }
+})).type.toBeAssignableTo<FastifyInstance>()
+
+// Thenable
+expect(fastify({ return503OnClosing: true })).type.toBeAssignableTo<PromiseLike<FastifyInstance>>()
+fastify().then(fastifyInstance => expect(fastifyInstance).type.toBeAssignableTo<FastifyInstance>())
+
+expect<FastifyPluginAsync>().type.toBeAssignableFrom(async () => { })
+expect<FastifyPluginCallback>().type.toBeAssignableFrom(() => { })
+expect<FastifyPlugin>().type.toBeAssignableFrom(() => { })
+
+const ajvErrorObject: AjvErrorObject = {
+  keyword: '',
+  instancePath: '',
+  schemaPath: '',
+  params: {},
+  message: ''
+}
+expect<AjvErrorObject>().type.not.toBeAssignableFrom({
+  keyword: '',
+  instancePath: '',
+  schemaPath: '',
+  params: '',
+  message: ''
+})
+
+expect<FastifyError['validation']>().type.toBeAssignableFrom([ajvErrorObject])
+expect<FastifyError['validationContext']>().type.toBeAssignableFrom('body')
+expect<FastifyError['validationContext']>().type.toBeAssignableFrom('headers')
+expect<FastifyError['validationContext']>().type.toBeAssignableFrom('params')
+expect<FastifyError['validationContext']>().type.toBeAssignableFrom('querystring')
+
+expect<RouteGenericInterface['Body']>().type.toBe<unknown>()
+expect<RouteGenericInterface['Headers']>().type.toBe<unknown>()
+expect<RouteGenericInterface['Params']>().type.toBe<unknown>()
+expect<RouteGenericInterface['Querystring']>().type.toBe<unknown>()
+expect<RouteGenericInterface['Reply']>().type.toBe<unknown>()
+
+// ErrorCodes
+expect(fastify.errorCodes).type.toBe<FastifyErrorCodes>()
+
+fastify({ allowUnsafeRegex: true })
+fastify({ allowUnsafeRegex: false })
+expect(fastify).type.not.toBeCallableWith({ allowUnsafeRegex: 'invalid' })
+
+expect(fastify({ allowErrorHandlerOverride: true })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify({ allowErrorHandlerOverride: false })).type.toBeAssignableTo<FastifyInstance>()