@rosen-bridge/fastify-enhanced 0.1.0

package/.eslintignore

@@ -0,0 +1 @@
+dist

package/README.md

@@ -0,0 +1,114 @@
+# @rosen-bridge/fastify-enhanced
+
+## Table of contents
+
+- [Introduction](#introduction)
+- [Installation](#installation)
+- [Usage](#usage)
+
+## Introduction
+
+A wrapper around fastify web framework to make it even better
+
+## Installation
+
+npm:
+
+```sh
+npm i @rosen-bridge/fastify-enhanced
+```
+
+yarn:
+
+```sh
+yarn add @rosen-bridge/fastify-enhanced
+```
+
+## Usage
+
+To use the enhanced Fastify, import `createFastify` and use it to create a fastify instance and register routes. Use data types defined under `types` object, to define validation constraints for requests and responses:
+
+```ts
+import {
+  ZodTypeProvider,
+  createFastify,
+  types,
+} from '@rosen-bridge/fastify-enhanced';
+import { FastifyBaseLogger, FastifyInstance } from 'fastify';
+import { IncomingMessage, Server, ServerResponse } from 'http';
+
+const addTokenPaymentRoute = (
+  fastify: FastifyInstance<
+    Server<typeof IncomingMessage, typeof ServerResponse>,
+    IncomingMessage,
+    ServerResponse<IncomingMessage>,
+    FastifyBaseLogger,
+    ZodTypeProvider
+  >
+) => {
+  const bodySchema = types.object({
+    tokenName: types.string(),
+    tokenAmount: types.bigint(),
+    tokenDecimals: types.number(),
+  });
+
+  const res200Schema = types.object({
+    name: types.string(),
+    amount: types.bigint(),
+    decimal: types.number(),
+  });
+
+  const payTokenOpts = {
+    schema: {
+      body: bodySchema,
+      response: {
+        200: res200Schema,
+      },
+    },
+  };
+
+  fastify.post('/payToken', payTokenOpts, async (request, reply) => {
+    return reply.status(200).send({
+      name: request.body.tokenName,
+      amount: request.body.tokenAmount,
+      decimal: request.body.tokenDecimals,
+    });
+  });
+
+  return fastify;
+};
+
+const fastify = await createFastify(
+  {
+    path: '/swagger',
+    title: '',
+    description: '',
+    version: '0.0.1',
+  },
+  { logger: false }
+);
+addTokenPaymentRoute(fastify);
+
+const start = async () => {
+  try {
+    await fastify.listen({ port: 8000 });
+  } catch (err) {
+    console.log(err);
+    process.exit(1);
+  }
+};
+start();
+```
+
+To define a nested route don't forget to add `ZodTypeProvider` to the Fastify instance that is passed to the `register` method, to enable Zod typing validation:
+
+```ts
+fastify.register(
+  (instance, opts, next) => {
+    const subFastify = instance.withTypeProvider<ZodTypeProvider>();
+    addTokenPaymentRoute(subFastify);
+    next();
+  },
+  { prefix: 'subroute' }
+);
+```

package/dist/dataTypes.d.ts

@@ -0,0 +1,456 @@
+import zod from 'zod';
+export declare const types: {
+  bigint: () => zod.ZodPipeline<
+    zod.ZodUnion<[zod.ZodNumber, zod.ZodBigInt]>,
+    zod.ZodBigInt
+  >;
+  string: (
+    params?:
+      | ({
+          errorMap?: zod.ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: true | undefined;
+        })
+      | undefined
+  ) => zod.ZodString;
+  number: (
+    params?:
+      | ({
+          errorMap?: zod.ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: boolean | undefined;
+        })
+      | undefined
+  ) => zod.ZodNumber;
+  boolean: (
+    params?:
+      | ({
+          errorMap?: zod.ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: boolean | undefined;
+        })
+      | undefined
+  ) => zod.ZodBoolean;
+  symbol: (params?: zod.RawCreateParams) => zod.ZodSymbol;
+  undefined: (params?: zod.RawCreateParams) => zod.ZodUndefined;
+  object: <T extends zod.ZodRawShape>(
+    shape: T,
+    params?: zod.RawCreateParams
+  ) => zod.ZodObject<
+    T,
+    'strip',
+    zod.ZodTypeAny,
+    {
+      [k_1 in keyof zod.objectUtil.addQuestionMarks<
+        zod.baseObjectOutputType<T>,
+        {
+          [k in keyof zod.baseObjectOutputType<T>]: undefined extends zod.baseObjectOutputType<T>[k]
+            ? never
+            : k;
+        }[keyof T]
+      >]: zod.objectUtil.addQuestionMarks<
+        zod.baseObjectOutputType<T>,
+        {
+          [k_2 in keyof zod.baseObjectOutputType<T>]: undefined extends zod.baseObjectOutputType<T>[k_2]
+            ? never
+            : k_2;
+        }[keyof T]
+      >[k_1];
+    },
+    {
+      [k_2 in keyof zod.baseObjectInputType<T>]: zod.baseObjectInputType<T>[k_2];
+    }
+  >;
+  function: typeof zod.ZodFunction.create;
+  z: typeof zod.z;
+  setErrorMap: typeof zod.setErrorMap;
+  getErrorMap: typeof zod.getErrorMap;
+  defaultErrorMap: zod.ZodErrorMap;
+  addIssueToContext: typeof zod.addIssueToContext;
+  makeIssue: (params: {
+    data: any;
+    path: (string | number)[];
+    errorMaps: zod.ZodErrorMap[];
+    issueData: zod.IssueData;
+  }) => zod.ZodIssue;
+  EMPTY_PATH: zod.ParsePath;
+  ParseStatus: typeof zod.ParseStatus;
+  INVALID: zod.INVALID;
+  DIRTY: <T_1>(value: T_1) => zod.DIRTY<T_1>;
+  OK: <T_2>(value: T_2) => zod.OK<T_2>;
+  isAborted: (x: zod.ParseReturnType<any>) => x is zod.INVALID;
+  isDirty: <T_3>(
+    x: zod.ParseReturnType<T_3>
+  ) => x is zod.OK<T_3> | zod.DIRTY<T_3>;
+  isValid: <T_4>(
+    x: zod.ParseReturnType<T_4>
+  ) => x is zod.OK<T_4> | zod.DIRTY<T_4>;
+  isAsync: <T_5>(
+    x: zod.ParseReturnType<T_5>
+  ) => x is zod.AsyncParseReturnType<T_5>;
+  util: typeof zod.util;
+  objectUtil: typeof zod.objectUtil;
+  ZodParsedType: {
+    function: 'function';
+    number: 'number';
+    string: 'string';
+    nan: 'nan';
+    integer: 'integer';
+    float: 'float';
+    boolean: 'boolean';
+    date: 'date';
+    bigint: 'bigint';
+    symbol: 'symbol';
+    undefined: 'undefined';
+    null: 'null';
+    array: 'array';
+    object: 'object';
+    unknown: 'unknown';
+    promise: 'promise';
+    void: 'void';
+    never: 'never';
+    map: 'map';
+    set: 'set';
+  };
+  getParsedType: (
+    data: any
+  ) =>
+    | 'string'
+    | 'number'
+    | 'bigint'
+    | 'boolean'
+    | 'symbol'
+    | 'undefined'
+    | 'object'
+    | 'function'
+    | 'array'
+    | 'date'
+    | 'map'
+    | 'nan'
+    | 'never'
+    | 'null'
+    | 'promise'
+    | 'set'
+    | 'unknown'
+    | 'void'
+    | 'integer'
+    | 'float';
+  ZodType: typeof zod.ZodType;
+  ZodString: typeof zod.ZodString;
+  ZodNumber: typeof zod.ZodNumber;
+  ZodBigInt: typeof zod.ZodBigInt;
+  ZodBoolean: typeof zod.ZodBoolean;
+  ZodDate: typeof zod.ZodDate;
+  ZodSymbol: typeof zod.ZodSymbol;
+  ZodUndefined: typeof zod.ZodUndefined;
+  ZodNull: typeof zod.ZodNull;
+  ZodAny: typeof zod.ZodAny;
+  ZodUnknown: typeof zod.ZodUnknown;
+  ZodNever: typeof zod.ZodNever;
+  ZodVoid: typeof zod.ZodVoid;
+  ZodArray: typeof zod.ZodArray;
+  ZodObject: typeof zod.ZodObject;
+  ZodUnion: typeof zod.ZodUnion;
+  ZodDiscriminatedUnion: typeof zod.ZodDiscriminatedUnion;
+  ZodIntersection: typeof zod.ZodIntersection;
+  ZodTuple: typeof zod.ZodTuple;
+  ZodRecord: typeof zod.ZodRecord;
+  ZodMap: typeof zod.ZodMap;
+  ZodSet: typeof zod.ZodSet;
+  ZodFunction: typeof zod.ZodFunction;
+  ZodLazy: typeof zod.ZodLazy;
+  ZodLiteral: typeof zod.ZodLiteral;
+  ZodEnum: typeof zod.ZodEnum;
+  ZodNativeEnum: typeof zod.ZodNativeEnum;
+  ZodPromise: typeof zod.ZodPromise;
+  ZodEffects: typeof zod.ZodEffects;
+  ZodTransformer: typeof zod.ZodEffects;
+  ZodOptional: typeof zod.ZodOptional;
+  ZodNullable: typeof zod.ZodNullable;
+  ZodDefault: typeof zod.ZodDefault;
+  ZodCatch: typeof zod.ZodCatch;
+  ZodNaN: typeof zod.ZodNaN;
+  BRAND: typeof zod.BRAND;
+  ZodBranded: typeof zod.ZodBranded;
+  ZodPipeline: typeof zod.ZodPipeline;
+  ZodReadonly: typeof zod.ZodReadonly;
+  custom: <T_6>(
+    check?: ((data: unknown) => any) | undefined,
+    params?:
+      | string
+      | (Partial<zod.util.Omit<zod.ZodCustomIssue, 'code'>> & {
+          fatal?: boolean | undefined;
+        })
+      | ((input: any) => Partial<zod.util.Omit<zod.ZodCustomIssue, 'code'>> & {
+          fatal?: boolean | undefined;
+        })
+      | undefined,
+    fatal?: boolean | undefined
+  ) => zod.ZodType<T_6, zod.ZodTypeDef, T_6>;
+  Schema: typeof zod.ZodType;
+  ZodSchema: typeof zod.ZodType;
+  late: {
+    object: <T_7 extends zod.ZodRawShape>(
+      shape: () => T_7,
+      params?: zod.RawCreateParams
+    ) => zod.ZodObject<
+      T_7,
+      'strip',
+      zod.ZodTypeAny,
+      {
+        [k_1_1 in keyof zod.objectUtil.addQuestionMarks<
+          zod.baseObjectOutputType<T_7>,
+          {
+            [k_3 in keyof zod.baseObjectOutputType<T_7>]: undefined extends zod.baseObjectOutputType<T_7>[k_3]
+              ? never
+              : k_3;
+          }[keyof T_7]
+        >]: zod.objectUtil.addQuestionMarks<
+          zod.baseObjectOutputType<T_7>,
+          {
+            [k_4 in keyof zod.baseObjectOutputType<T_7>]: undefined extends zod.baseObjectOutputType<T_7>[k_4]
+              ? never
+              : k_4;
+          }[keyof T_7]
+        >[k_1_1];
+      },
+      {
+        [k_2_1 in keyof zod.baseObjectInputType<T_7>]: zod.baseObjectInputType<T_7>[k_2_1];
+      }
+    >;
+  };
+  ZodFirstPartyTypeKind: typeof zod.ZodFirstPartyTypeKind;
+  coerce: {
+    string: (
+      params?:
+        | ({
+            errorMap?: zod.ZodErrorMap | undefined;
+            invalid_type_error?: string | undefined;
+            required_error?: string | undefined;
+            description?: string | undefined;
+          } & {
+            coerce?: true | undefined;
+          })
+        | undefined
+    ) => zod.ZodString;
+    number: (
+      params?:
+        | ({
+            errorMap?: zod.ZodErrorMap | undefined;
+            invalid_type_error?: string | undefined;
+            required_error?: string | undefined;
+            description?: string | undefined;
+          } & {
+            coerce?: boolean | undefined;
+          })
+        | undefined
+    ) => zod.ZodNumber;
+    boolean: (
+      params?:
+        | ({
+            errorMap?: zod.ZodErrorMap | undefined;
+            invalid_type_error?: string | undefined;
+            required_error?: string | undefined;
+            description?: string | undefined;
+          } & {
+            coerce?: boolean | undefined;
+          })
+        | undefined
+    ) => zod.ZodBoolean;
+    bigint: (
+      params?:
+        | ({
+            errorMap?: zod.ZodErrorMap | undefined;
+            invalid_type_error?: string | undefined;
+            required_error?: string | undefined;
+            description?: string | undefined;
+          } & {
+            coerce?: boolean | undefined;
+          })
+        | undefined
+    ) => zod.ZodBigInt;
+    date: (
+      params?:
+        | ({
+            errorMap?: zod.ZodErrorMap | undefined;
+            invalid_type_error?: string | undefined;
+            required_error?: string | undefined;
+            description?: string | undefined;
+          } & {
+            coerce?: boolean | undefined;
+          })
+        | undefined
+    ) => zod.ZodDate;
+  };
+  any: (params?: zod.RawCreateParams) => zod.ZodAny;
+  array: <T_8 extends zod.ZodTypeAny>(
+    schema: T_8,
+    params?: zod.RawCreateParams
+  ) => zod.ZodArray<T_8, 'many'>;
+  date: (
+    params?:
+      | ({
+          errorMap?: zod.ZodErrorMap | undefined;
+          invalid_type_error?: string | undefined;
+          required_error?: string | undefined;
+          description?: string | undefined;
+        } & {
+          coerce?: boolean | undefined;
+        })
+      | undefined
+  ) => zod.ZodDate;
+  discriminatedUnion: typeof zod.ZodDiscriminatedUnion.create;
+  effect: <I extends zod.ZodTypeAny>(
+    schema: I,
+    effect: zod.Effect<I['_output']>,
+    params?: zod.RawCreateParams
+  ) => zod.ZodEffects<I, I['_output'], zod.input<I>>;
+  enum: {
+    <U extends string, T_9 extends readonly [U, ...U[]]>(
+      values: T_9,
+      params?: zod.RawCreateParams
+    ): zod.ZodEnum<zod.Writeable<T_9>>;
+    <U_1 extends string, T_10 extends [U_1, ...U_1[]]>(
+      values: T_10,
+      params?: zod.RawCreateParams
+    ): zod.ZodEnum<T_10>;
+  };
+  instanceof: <T_11 extends abstract new (..._: any[]) => {}>(
+    cls: T_11,
+    params?:
+      | (Partial<zod.util.Omit<zod.ZodCustomIssue, 'code'>> & {
+          fatal?: boolean | undefined;
+        })
+      | undefined
+  ) => zod.ZodType<InstanceType<T_11>, zod.ZodTypeDef, InstanceType<T_11>>;
+  intersection: <T_12 extends zod.ZodTypeAny, U_2 extends zod.ZodTypeAny>(
+    left: T_12,
+    right: U_2,
+    params?: zod.RawCreateParams
+  ) => zod.ZodIntersection<T_12, U_2>;
+  lazy: <T_13 extends zod.ZodTypeAny>(
+    getter: () => T_13,
+    params?: zod.RawCreateParams
+  ) => zod.ZodLazy<T_13>;
+  literal: <T_14 extends zod.Primitive>(
+    value: T_14,
+    params?: zod.RawCreateParams
+  ) => zod.ZodLiteral<T_14>;
+  map: <
+    Key extends zod.ZodTypeAny = zod.ZodTypeAny,
+    Value extends zod.ZodTypeAny = zod.ZodTypeAny
+  >(
+    keyType: Key,
+    valueType: Value,
+    params?: zod.RawCreateParams
+  ) => zod.ZodMap<Key, Value>;
+  nan: (params?: zod.RawCreateParams) => zod.ZodNaN;
+  nativeEnum: <T_15 extends zod.EnumLike>(
+    values: T_15,
+    params?: zod.RawCreateParams
+  ) => zod.ZodNativeEnum<T_15>;
+  never: (params?: zod.RawCreateParams) => zod.ZodNever;
+  null: (params?: zod.RawCreateParams) => zod.ZodNull;
+  nullable: <T_16 extends zod.ZodTypeAny>(
+    type: T_16,
+    params?: zod.RawCreateParams
+  ) => zod.ZodNullable<T_16>;
+  oboolean: () => zod.ZodOptional<zod.ZodBoolean>;
+  onumber: () => zod.ZodOptional<zod.ZodNumber>;
+  optional: <T_17 extends zod.ZodTypeAny>(
+    type: T_17,
+    params?: zod.RawCreateParams
+  ) => zod.ZodOptional<T_17>;
+  ostring: () => zod.ZodOptional<zod.ZodString>;
+  pipeline: typeof zod.ZodPipeline.create;
+  preprocess: <I_1 extends zod.ZodTypeAny>(
+    preprocess: (arg: unknown, ctx: zod.RefinementCtx) => unknown,
+    schema: I_1,
+    params?: zod.RawCreateParams
+  ) => zod.ZodEffects<I_1, I_1['_output'], unknown>;
+  promise: <T_18 extends zod.ZodTypeAny>(
+    schema: T_18,
+    params?: zod.RawCreateParams
+  ) => zod.ZodPromise<T_18>;
+  record: typeof zod.ZodRecord.create;
+  set: <Value_1 extends zod.ZodTypeAny = zod.ZodTypeAny>(
+    valueType: Value_1,
+    params?: zod.RawCreateParams
+  ) => zod.ZodSet<Value_1>;
+  strictObject: <T_19 extends zod.ZodRawShape>(
+    shape: T_19,
+    params?: zod.RawCreateParams
+  ) => zod.ZodObject<
+    T_19,
+    'strict',
+    zod.ZodTypeAny,
+    {
+      [k_1_2 in keyof zod.objectUtil.addQuestionMarks<
+        zod.baseObjectOutputType<T_19>,
+        {
+          [k_5 in keyof zod.baseObjectOutputType<T_19>]: undefined extends zod.baseObjectOutputType<T_19>[k_5]
+            ? never
+            : k_5;
+        }[keyof T_19]
+      >]: zod.objectUtil.addQuestionMarks<
+        zod.baseObjectOutputType<T_19>,
+        {
+          [k_6 in keyof zod.baseObjectOutputType<T_19>]: undefined extends zod.baseObjectOutputType<T_19>[k_6]
+            ? never
+            : k_6;
+        }[keyof T_19]
+      >[k_1_2];
+    },
+    {
+      [k_2_2 in keyof zod.baseObjectInputType<T_19>]: zod.baseObjectInputType<T_19>[k_2_2];
+    }
+  >;
+  transformer: <I extends zod.ZodTypeAny>(
+    schema: I,
+    effect: zod.Effect<I['_output']>,
+    params?: zod.RawCreateParams
+  ) => zod.ZodEffects<I, I['_output'], zod.input<I>>;
+  tuple: <T_20 extends [] | [zod.ZodTypeAny, ...zod.ZodTypeAny[]]>(
+    schemas: T_20,
+    params?: zod.RawCreateParams
+  ) => zod.ZodTuple<T_20, null>;
+  union: <
+    T_21 extends readonly [zod.ZodTypeAny, zod.ZodTypeAny, ...zod.ZodTypeAny[]]
+  >(
+    types: T_21,
+    params?: zod.RawCreateParams
+  ) => zod.ZodUnion<T_21>;
+  unknown: (params?: zod.RawCreateParams) => zod.ZodUnknown;
+  void: (params?: zod.RawCreateParams) => zod.ZodVoid;
+  NEVER: never;
+  ZodIssueCode: {
+    invalid_type: 'invalid_type';
+    invalid_literal: 'invalid_literal';
+    custom: 'custom';
+    invalid_union: 'invalid_union';
+    invalid_union_discriminator: 'invalid_union_discriminator';
+    invalid_enum_value: 'invalid_enum_value';
+    unrecognized_keys: 'unrecognized_keys';
+    invalid_arguments: 'invalid_arguments';
+    invalid_return_type: 'invalid_return_type';
+    invalid_date: 'invalid_date';
+    invalid_string: 'invalid_string';
+    too_small: 'too_small';
+    too_big: 'too_big';
+    invalid_intersection_types: 'invalid_intersection_types';
+    not_multiple_of: 'not_multiple_of';
+    not_finite: 'not_finite';
+  };
+  quotelessJson: (obj: any) => string;
+  ZodError: typeof zod.ZodError;
+};
+//# sourceMappingURL=dataTypes.d.ts.map

package/dist/dataTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataTypes.d.ts","sourceRoot":"","sources":["../lib/dataTypes.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIjB,CAAC"}

package/dist/dataTypes.js

@@ -0,0 +1,7 @@
+import zod from 'zod';
+export const types = {
+  ...zod,
+  bigint: () =>
+    zod.union([zod.number(), zod.bigint()]).pipe(zod.coerce.bigint()),
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YVR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vbGliL2RhdGFUeXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFFdEIsTUFBTSxDQUFDLE1BQU0sS0FBSyxHQUFHO0lBQ25CLEdBQUksR0FBa0M7SUFDdEMsTUFBTSxFQUFFLEdBQUcsRUFBRSxDQUNYLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQyxHQUFHLENBQUMsTUFBTSxFQUFFLEVBQUUsR0FBRyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLE1BQU0sQ0FBQyxNQUFNLEVBQUUsQ0FBQztDQUNwRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHpvZCBmcm9tICd6b2QnO1xuXG5leHBvcnQgY29uc3QgdHlwZXMgPSB7XG4gIC4uLih6b2QgYXMgT21pdDx0eXBlb2Ygem9kLCAnYmlnaW50Jz4pLFxuICBiaWdpbnQ6ICgpID0+XG4gICAgem9kLnVuaW9uKFt6b2QubnVtYmVyKCksIHpvZC5iaWdpbnQoKV0pLnBpcGUoem9kLmNvZXJjZS5iaWdpbnQoKSksXG59O1xuIl19

package/dist/fastify.d.ts

@@ -0,0 +1,46 @@
+import { FastifyWithZod, SwaggerOpts } from './types';
+/**
+ * creates an instance of Fastify with Zod validation library as validator and
+ * type provider
+ *
+ * @param {string} [swaggerPath='/swagger']
+ * @param {boolean} [jsonHandler=JsonBigIntFactory({
+ *     alwaysParseAsBig: false,
+ *     useNativeBigInt: true,
+ *   })]
+ * @param {*} [opts={ logger: true }]
+ * @return {Promise<
+ *   FastifyInstance<
+ *     http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>,
+ *     http.IncomingMessage,
+ *     http.ServerResponse<http.IncomingMessage>,
+ *     FastifyBaseLogger,
+ *     ZodTypeProvider
+ *   >
+ * >}
+ */
+export declare const createFastify: (
+  swaggerOpts?: SwaggerOpts,
+  opts?: {
+    logger: boolean;
+  },
+  jsonHandler?: {
+    parse: (
+      text: string,
+      reviver?: ((this: any, key: string, value: any) => any) | undefined
+    ) => any;
+    stringify: {
+      (
+        value: any,
+        replacer?: ((this: any, key: string, value: any) => any) | undefined,
+        space?: string | number | undefined
+      ): string;
+      (
+        value: any,
+        replacer?: (string | number)[] | null | undefined,
+        space?: string | number | undefined
+      ): string;
+    };
+  }
+) => Promise<FastifyWithZod>;
+//# sourceMappingURL=fastify.d.ts.map

package/dist/fastify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastify.d.ts","sourceRoot":"","sources":["../lib/fastify.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,iBACX,WAAW;;;;;;;;MAWvB,QAAQ,cAAc,CA8BxB,CAAC"}