@rosen-bridge/fastify-enhanced 0.1.1 → 1.0.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @rosen-bridge/fastify-enhanced
 
+## 1.0.0
+
+### Major Changes
+
+- Update fastify-enhanced package to support swagger and bigint
+
+### Minor Changes
+
+- Update versions of nodejs to 20.11 & typescript to 5.8
+
 ## 0.1.1
 
 ### Patch Changes

package/dist/dataTypes.d.ts

@@ -27,7 +27,7 @@ export declare const types: {
     }) | 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]; }>;
+    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 in keyof zod.baseObjectOutputType<T>]: undefined extends zod.baseObjectOutputType<T>[k] ? never : k; }[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;
@@ -43,12 +43,12 @@ export declare const types: {
     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>;
+    DIRTY: <T>(value: T) => zod.DIRTY<T>;
+    OK: <T>(value: T) => zod.OK<T>;
     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>;
+    isDirty: <T>(x: zod.ParseReturnType<T>) => x is zod.OK<T> | zod.DIRTY<T>;
+    isValid: <T>(x: zod.ParseReturnType<T>) => x is zod.OK<T> | zod.DIRTY<T>;
+    isAsync: <T>(x: zod.ParseReturnType<T>) => x is zod.AsyncParseReturnType<T>;
     util: typeof zod.util;
     objectUtil: typeof zod.objectUtil;
     ZodParsedType: {
@@ -73,7 +73,7 @@ export declare const types: {
         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";
+    getParsedType: (data: any) => zod.ZodParsedType;
     ZodType: typeof zod.ZodType;
     ZodString: typeof zod.ZodString;
     ZodNumber: typeof zod.ZodNumber;
@@ -113,15 +113,15 @@ export declare const types: {
     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;
+    custom: <T>(check?: ((data: unknown) => any) | undefined, params?: string | (Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
+        fatal?: boolean;
     }) | ((input: any) => Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
-        fatal?: boolean | undefined;
-    }) | undefined, fatal?: boolean | undefined) => zod.ZodType<T_6, zod.ZodTypeDef, T_6>;
+        fatal?: boolean;
+    }), fatal?: boolean | undefined) => zod.ZodType<T, zod.ZodTypeDef, T>;
     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]; }>;
+        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 in keyof zod.baseObjectOutputType<T>]: undefined extends zod.baseObjectOutputType<T>[k] ? never : k; }[keyof T]>[k_1]; }, { [k_2 in keyof zod.baseObjectInputType<T>]: zod.baseObjectInputType<T>[k_2]; }>;
     };
     ZodFirstPartyTypeKind: typeof zod.ZodFirstPartyTypeKind;
     coerce: {
@@ -167,7 +167,7 @@ export declare const types: {
         }) | 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">;
+    array: <T extends zod.ZodTypeAny>(schema: T, params?: zod.RawCreateParams) => zod.ZodArray<T, "many">;
     date: (params?: ({
         errorMap?: zod.ZodErrorMap | undefined;
         invalid_type_error?: string | undefined;
@@ -179,34 +179,34 @@ export declare const types: {
     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>;
+        <U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: zod.RawCreateParams): zod.ZodEnum<zod.Writeable<T>>;
+        <U extends string, T extends [U, ...U[]]>(values: T, params?: zod.RawCreateParams): zod.ZodEnum<T>;
     };
-    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>;
+    instanceof: <T extends abstract new (..._: any[]) => {}>(cls: T, params?: Partial<zod.util.Omit<zod.ZodCustomIssue, "code">> & {
+        fatal?: boolean;
+    }) => zod.ZodType<InstanceType<T>, zod.ZodTypeDef, InstanceType<T>>;
+    intersection: <T extends zod.ZodTypeAny, U extends zod.ZodTypeAny>(left: T, right: U, params?: zod.RawCreateParams) => zod.ZodIntersection<T, U>;
+    lazy: <T extends zod.ZodTypeAny>(getter: () => T, params?: zod.RawCreateParams) => zod.ZodLazy<T>;
+    literal: <T extends zod.Primitive>(value: T, params?: zod.RawCreateParams) => zod.ZodLiteral<T>;
     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>;
+    nativeEnum: <T extends zod.EnumLike>(values: T, params?: zod.RawCreateParams) => zod.ZodNativeEnum<T>;
     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>;
+    nullable: <T extends zod.ZodTypeAny>(type: T, params?: zod.RawCreateParams) => zod.ZodNullable<T>;
     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>;
+    optional: <T extends zod.ZodTypeAny>(type: T, params?: zod.RawCreateParams) => zod.ZodOptional<T>;
     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>;
+    preprocess: <I extends zod.ZodTypeAny>(preprocess: (arg: unknown, ctx: zod.RefinementCtx) => unknown, schema: I, params?: zod.RawCreateParams) => zod.ZodEffects<I, I["_output"], unknown>;
+    promise: <T extends zod.ZodTypeAny>(schema: T, params?: zod.RawCreateParams) => zod.ZodPromise<T>;
     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]; }>;
+    set: <Value extends zod.ZodTypeAny = zod.ZodTypeAny>(valueType: Value, params?: zod.RawCreateParams) => zod.ZodSet<Value>;
+    strictObject: <T extends zod.ZodRawShape>(shape: T, params?: zod.RawCreateParams) => zod.ZodObject<T, "strict", 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 in keyof zod.baseObjectOutputType<T>]: undefined extends zod.baseObjectOutputType<T>[k] ? never : k; }[keyof T]>[k_1]; }, { [k_2 in keyof zod.baseObjectInputType<T>]: zod.baseObjectInputType<T>[k_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>;
+    tuple: <T extends [] | [zod.ZodTypeAny, ...zod.ZodTypeAny[]]>(schemas: T, params?: zod.RawCreateParams) => zod.ZodTuple<T, null>;
+    union: <T extends readonly [zod.ZodTypeAny, zod.ZodTypeAny, ...zod.ZodTypeAny[]]>(types: T, params?: zod.RawCreateParams) => zod.ZodUnion<T>;
     unknown: (params?: zod.RawCreateParams) => zod.ZodUnknown;
     void: (params?: zod.RawCreateParams) => zod.ZodVoid;
     NEVER: never;

package/dist/dataTypes.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"dataTypes.d.ts","sourceRoot":"","sources":["../lib/dataTypes.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,KAAK;;;gBAKkh9C,CAAC;0BAAiD,CAAC;sBAAwC,CAAC;mBAAqC,CAAC;;cAAsC,CAAC;;;gBAAqG,CAAC;0BAAiD,CAAC;sBAAwC,CAAC;mBAAqC,CAAC;;cAAsC,CAAC;;;gBAAub,CAAC;0BAAiD,CAAC;sBAAwC,CAAC;mBAAqC,CAAC;;cAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAA5wH,CAAC,8CAA8C,CAAC;;;;aAA+D,CAAC;;;;kEAAgM,CAAC;;;;uBAAmkP,CAAC;oBAAqB,CAAC;8BAAqD,CAAC;0BAA4C,CAAC;uBAAyC,CAAC;;kBAA8C,CAAC;;uBAAyE,CAAC;oBAAqB,CAAC;8BAAqD,CAAC;0BAA4C,CAAC;uBAAyC,CAAC;;kBAA8C,CAAC;;wBAA6E,CAAC;oBAAqB,CAAC;8BAAqD,CAAC;0BAA4C,CAAC;uBAAyC,CAAC;;kBAA8C,CAAC;;uBAA6E,CAAC;oBAAqB,CAAC;8BAAqD,CAAC;0BAA4C,CAAC;uBAAyC,CAAC;;kBAA8C,CAAC;;qBAA0E,CAAC;oBAAqB,CAAC;8BAAqD,CAAC;0BAA4C,CAAC;uBAAyC,CAAC;;kBAA8C,CAAC;;;;;;gBAA70K,CAAC;0BAAiD,CAAC;sBAAwC,CAAC;mBAAqC,CAAC;;cAAsC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAD10/C,CAAC"}

package/dist/error.d.ts

@@ -0,0 +1,5 @@
+export declare class ResponseValidationError extends Error {
+    details: Record<string, any>;
+    constructor(validationResult: Record<string, any>);
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../lib/error.ts"],"names":[],"mappings":"AAAA,qBAAa,uBAAwB,SAAQ,KAAK;IACzC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;gBAExB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAKlD"}

package/dist/error.js

@@ -0,0 +1,9 @@
+export class ResponseValidationError extends Error {
+    details;
+    constructor(validationResult) {
+        super("Response doesn't match the schema");
+        this.name = 'ResponseValidationError';
+        this.details = validationResult.error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLHVCQUF3QixTQUFRLEtBQUs7SUFDekMsT0FBTyxDQUFzQjtJQUVwQyxZQUFZLGdCQUFxQztRQUMvQyxLQUFLLENBQUMsbUNBQW1DLENBQUMsQ0FBQztRQUMzQyxJQUFJLENBQUMsSUFBSSxHQUFHLHlCQUF5QixDQUFDO1FBQ3RDLElBQUksQ0FBQyxPQUFPLEdBQUcsZ0JBQWdCLENBQUMsS0FBSyxDQUFDO0lBQ3hDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBSZXNwb25zZVZhbGlkYXRpb25FcnJvciBleHRlbmRzIEVycm9yIHtcbiAgcHVibGljIGRldGFpbHM6IFJlY29yZDxzdHJpbmcsIGFueT47XG5cbiAgY29uc3RydWN0b3IodmFsaWRhdGlvblJlc3VsdDogUmVjb3JkPHN0cmluZywgYW55Pikge1xuICAgIHN1cGVyKFwiUmVzcG9uc2UgZG9lc24ndCBtYXRjaCB0aGUgc2NoZW1hXCIpO1xuICAgIHRoaXMubmFtZSA9ICdSZXNwb25zZVZhbGlkYXRpb25FcnJvcic7XG4gICAgdGhpcy5kZXRhaWxzID0gdmFsaWRhdGlvblJlc3VsdC5lcnJvcjtcbiAgfVxufVxuIl19

package/dist/fastify.d.ts

@@ -1,31 +1,16 @@
+import 'zod-openapi/extend';
 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?: {
+export declare const makeFastify: (swaggerOpts?: SwaggerOpts, opts?: {
     logger: boolean;
 }, jsonHandler?: {
-    parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
+    parse: (text: string, reviver?: (this: any, key: string, value: any) => any) => 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;
+        (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+        (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
     };
 }) => Promise<FastifyWithZod>;
 //# sourceMappingURL=fastify.d.ts.map

package/dist/fastify.d.ts.map

@@ -1 +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"}
+{"version":3,"file":"fastify.d.ts","sourceRoot":"","sources":["../lib/fastify.ts"],"names":[],"mappings":"AAAA,OAAO,oBAAoB,CAAC;AAU5B,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAKtD;;;GAGG;AACH,eAAO,MAAM,WAAW,GACtB,cAAa,WAKZ,EACD;;CAAuB,EACvB;;;;;;CAIE,KACD,OAAO,CAAC,cAAc,CAoBxB,CAAC"}

package/dist/fastify.js

@@ -1,151 +1,31 @@
-import swagger from '@fastify/swagger';
-import swaggerUi from '@fastify/swagger-ui';
+import 'zod-openapi/extend';
+import { fastifyZodOpenApiPlugin, validatorCompiler, } from 'fastify-zod-openapi';
 import Fastify from 'fastify';
-import { jsonSchemaTransform, validatorCompiler, } from 'fastify-type-provider-zod';
 import JsonBigIntFactory from 'json-bigint';
+import { registerSwagger } from './swagger';
+import { makeJsonParser } from './jsonParser';
+import { makeSerializerCompiler } from './serializerCompiler';
 /**
  * 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 const createFastify = async (swaggerOpts = {
+export const makeFastify = async (swaggerOpts = {
     path: '/swagger',
-    title: '',
+    title: 'api',
     description: '',
     version: '0.0.1',
 }, opts = { logger: true }, jsonHandler = JsonBigIntFactory({
     alwaysParseAsBig: false,
     useNativeBigInt: true,
+    storeAsString: true,
 })) => {
     const fastify = Fastify(opts).withTypeProvider();
     fastify.setValidatorCompiler(validatorCompiler);
-    const serializerCompiler = getSerializerCompiler(jsonHandler);
+    const serializerCompiler = makeSerializerCompiler(jsonHandler);
     fastify.setSerializerCompiler(serializerCompiler);
-    fastify.addContentTypeParser('application/json', { parseAs: 'string' }, function (req, body, done) {
-        try {
-            const json = jsonHandler.parse(body);
-            done(null, json);
-        }
-        catch (err) {
-            if (err instanceof Error || err === null) {
-                done(err, undefined);
-            }
-            else {
-                const wrappedErr = new Error(`An unexpected error occurred while trying to parse request body`, { cause: err });
-                done(wrappedErr, undefined);
-            }
-        }
-    });
-    await addSwaggerRoute(fastify, swaggerOpts);
+    await fastify.register(fastifyZodOpenApiPlugin);
+    fastify.addContentTypeParser('application/json', { parseAs: 'string' }, makeJsonParser(jsonHandler));
+    await registerSwagger(fastify, swaggerOpts);
     return fastify;
 };
-/**
- * creates a Fastify serializer compiler based on Zod validation library and
- * using the passed json parser/serializer
- *
- * @param {typeof JSON} jsonHandler
- * @return {(FastifySerializerCompiler<
- *   | ZodAny
- *   | {
- *       properties: ZodAny;
- *     }
- * >)}
- */
-const getSerializerCompiler = (jsonHandler) => {
-    const hasOwnProperty = (obj, prop) => {
-        return Object.prototype.hasOwnProperty.call(obj, prop);
-    };
-    /**
-     * resolve the right schema to be used
-     *
-     * @param {(ZodAny | { properties: ZodAny })} maybeSchema
-     * @return {Pick<ZodAny, 'safeParse'>}
-     */
-    function resolveSchema(maybeSchema) {
-        if (hasOwnProperty(maybeSchema, 'safeParse')) {
-            return maybeSchema;
-        }
-        if (hasOwnProperty(maybeSchema, 'properties')) {
-            return maybeSchema.properties;
-        }
-        throw new Error(`Invalid schema passed: ${JSON.stringify(maybeSchema)}`);
-    }
-    class ResponseValidationError extends Error {
-        details;
-        constructor(validationResult) {
-            super("Response doesn't match the schema");
-            this.name = 'ResponseValidationError';
-            this.details = validationResult.error;
-        }
-    }
-    /**
-     * creates a serializer compiler based on Zod library
-     *
-     * @param { schema: maybeSchema }
-     */
-    const serializerCompiler = ({ schema: maybeSchema }) => (data) => {
-        const schema = resolveSchema(maybeSchema);
-        const result = schema.safeParse(data);
-        if (result.success) {
-            return jsonHandler.stringify(result.data);
-        }
-        throw new ResponseValidationError(result);
-    };
-    return serializerCompiler;
-};
-/**
- * adds swagger to the fastify instance
- *
- * @param {Awaited<ReturnType<typeof createFastify>>} fastify
- * @param {string} path
- */
-const addSwaggerRoute = async (fastify, opts) => {
-    fastify.register(swagger, {
-        openapi: {
-            info: {
-                title: opts.title,
-                description: opts.description,
-                version: opts.version,
-            },
-            servers: [],
-        },
-        transform: jsonSchemaTransform,
-    });
-    fastify.register(swaggerUi, {
-        routePrefix: opts.path,
-        uiConfig: {
-            docExpansion: 'full',
-            deepLinking: false,
-        },
-        uiHooks: {
-            onRequest: function (request, reply, next) {
-                next();
-            },
-            preHandler: function (request, reply, next) {
-                next();
-            },
-        },
-        staticCSP: true,
-        transformStaticCSP: (header) => header,
-        transformSpecification: (swaggerObject, request, reply) => {
-            return swaggerObject;
-        },
-        transformSpecificationClone: true,
-    });
-};
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fastify.js","sourceRoot":"","sources":["../lib/fastify.ts"],"names":[],"mappings":"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","sourcesContent":["import swagger from '@fastify/swagger';\nimport swaggerUi from '@fastify/swagger-ui';\nimport Fastify, { FastifyBaseLogger, FastifyInstance } from 'fastify';\nimport {\n  ZodTypeProvider,\n  jsonSchemaTransform,\n  validatorCompiler,\n} from 'fastify-type-provider-zod';\nimport type { FastifySerializerCompiler } from 'fastify/types/schema';\nimport * as http from 'http';\nimport JsonBigIntFactory from 'json-bigint';\nimport type { ZodAny } from 'zod';\nimport { FastifyWithZod, SwaggerOpts } from './types';\n\n/**\n * creates an instance of Fastify with Zod validation library as validator and\n * type provider\n *\n * @param {string} [swaggerPath='/swagger']\n * @param {boolean} [jsonHandler=JsonBigIntFactory({\n *     alwaysParseAsBig: false,\n *     useNativeBigInt: true,\n *   })]\n * @param {*} [opts={ logger: true }]\n * @return {Promise<\n *   FastifyInstance<\n *     http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>,\n *     http.IncomingMessage,\n *     http.ServerResponse<http.IncomingMessage>,\n *     FastifyBaseLogger,\n *     ZodTypeProvider\n *   >\n * >}\n */\nexport const createFastify = async (\n  swaggerOpts: SwaggerOpts = {\n    path: '/swagger',\n    title: '',\n    description: '',\n    version: '0.0.1',\n  },\n  opts = { logger: true },\n  jsonHandler = JsonBigIntFactory({\n    alwaysParseAsBig: false,\n    useNativeBigInt: true,\n  })\n): Promise<FastifyWithZod> => {\n  const fastify = Fastify(opts).withTypeProvider<ZodTypeProvider>();\n  fastify.setValidatorCompiler(validatorCompiler);\n\n  const serializerCompiler = getSerializerCompiler(jsonHandler);\n  fastify.setSerializerCompiler(serializerCompiler);\n\n  fastify.addContentTypeParser<string>(\n    'application/json',\n    { parseAs: 'string' },\n    function (req, body, done) {\n      try {\n        const json = jsonHandler.parse(body);\n        done(null, json);\n      } catch (err) {\n        if (err instanceof Error || err === null) {\n          done(err, undefined);\n        } else {\n          const wrappedErr = new Error(\n            `An unexpected error occurred while trying to parse request body`,\n            { cause: err }\n          );\n          done(wrappedErr, undefined);\n        }\n      }\n    }\n  );\n\n  await addSwaggerRoute(fastify, swaggerOpts);\n  return fastify;\n};\n\n/**\n * creates a Fastify serializer compiler based on Zod validation library and\n * using the passed json parser/serializer\n *\n * @param {typeof JSON} jsonHandler\n * @return {(FastifySerializerCompiler<\n *   | ZodAny\n *   | {\n *       properties: ZodAny;\n *     }\n * >)}\n */\nconst getSerializerCompiler = (\n  jsonHandler: ReturnType<typeof JsonBigIntFactory>\n): FastifySerializerCompiler<\n  | ZodAny\n  | {\n      properties: ZodAny;\n    }\n> => {\n  const hasOwnProperty = <T, K extends PropertyKey>(\n    obj: T,\n    prop: K\n  ): obj is T & Record<K, any> => {\n    return Object.prototype.hasOwnProperty.call(obj, prop);\n  };\n\n  /**\n   * resolve the right schema to be used\n   *\n   * @param {(ZodAny | { properties: ZodAny })} maybeSchema\n   * @return {Pick<ZodAny, 'safeParse'>}\n   */\n  function resolveSchema(\n    maybeSchema: ZodAny | { properties: ZodAny }\n  ): Pick<ZodAny, 'safeParse'> {\n    if (hasOwnProperty(maybeSchema, 'safeParse')) {\n      return maybeSchema;\n    }\n    if (hasOwnProperty(maybeSchema, 'properties')) {\n      return maybeSchema.properties;\n    }\n    throw new Error(`Invalid schema passed: ${JSON.stringify(maybeSchema)}`);\n  }\n\n  class ResponseValidationError extends Error {\n    public details: Record<string, any>;\n\n    constructor(validationResult: Record<string, any>) {\n      super(\"Response doesn't match the schema\");\n      this.name = 'ResponseValidationError';\n      this.details = validationResult.error;\n    }\n  }\n\n  /**\n   * creates a serializer compiler based on Zod library\n   *\n   * @param { schema: maybeSchema }\n   */\n  const serializerCompiler: FastifySerializerCompiler<\n    ZodAny | { properties: ZodAny }\n  > =\n    ({ schema: maybeSchema }) =>\n    (data) => {\n      const schema: Pick<ZodAny, 'safeParse'> = resolveSchema(maybeSchema);\n\n      const result = schema.safeParse(data);\n      if (result.success) {\n        return jsonHandler.stringify(result.data);\n      }\n\n      throw new ResponseValidationError(result);\n    };\n\n  return serializerCompiler;\n};\n\n/**\n * adds swagger to the fastify instance\n *\n * @param {Awaited<ReturnType<typeof createFastify>>} fastify\n * @param {string} path\n */\nconst addSwaggerRoute = async (fastify: FastifyWithZod, opts: SwaggerOpts) => {\n  fastify.register(swagger, {\n    openapi: {\n      info: {\n        title: opts.title,\n        description: opts.description,\n        version: opts.version,\n      },\n      servers: [],\n    },\n    transform: jsonSchemaTransform,\n  });\n\n  fastify.register(swaggerUi, {\n    routePrefix: opts.path,\n    uiConfig: {\n      docExpansion: 'full',\n      deepLinking: false,\n    },\n    uiHooks: {\n      onRequest: function (request: any, reply: any, next: () => void) {\n        next();\n      },\n      preHandler: function (request: any, reply: any, next: () => void) {\n        next();\n      },\n    },\n    staticCSP: true,\n    transformStaticCSP: (header: any) => header,\n    transformSpecification: (swaggerObject: any, request: any, reply: any) => {\n      return swaggerObject;\n    },\n    transformSpecificationClone: true,\n  });\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFzdGlmeS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL2xpYi9mYXN0aWZ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sb0JBQW9CLENBQUM7QUFFNUIsT0FBTyxFQUVMLHVCQUF1QixFQUN2QixpQkFBaUIsR0FDbEIsTUFBTSxxQkFBcUIsQ0FBQztBQUM3QixPQUFPLE9BQU8sTUFBTSxTQUFTLENBQUM7QUFDOUIsT0FBTyxpQkFBaUIsTUFBTSxhQUFhLENBQUM7QUFHNUMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUM1QyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQzlDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRTlEOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxLQUFLLEVBQzlCLGNBQTJCO0lBQ3pCLElBQUksRUFBRSxVQUFVO0lBQ2hCLEtBQUssRUFBRSxLQUFLO0lBQ1osV0FBVyxFQUFFLEVBQUU7SUFDZixPQUFPLEVBQUUsT0FBTztDQUNqQixFQUNELElBQUksR0FBRyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsRUFDdkIsV0FBVyxHQUFHLGlCQUFpQixDQUFDO0lBQzlCLGdCQUFnQixFQUFFLEtBQUs7SUFDdkIsZUFBZSxFQUFFLElBQUk7SUFDckIsYUFBYSxFQUFFLElBQUk7Q0FDcEIsQ0FBQyxFQUN1QixFQUFFO0lBQzNCLE1BQU0sT0FBTyxHQUNYLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxnQkFBZ0IsRUFBaUMsQ0FBQztJQUVsRSxPQUFPLENBQUMsb0JBQW9CLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUVoRCxNQUFNLGtCQUFrQixHQUFHLHNCQUFzQixDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQy9ELE9BQU8sQ0FBQyxxQkFBcUIsQ0FBQyxrQkFBa0IsQ0FBQyxDQUFDO0lBRWxELE1BQU0sT0FBTyxDQUFDLFFBQVEsQ0FBQyx1QkFBdUIsQ0FBQyxDQUFDO0lBRWhELE9BQU8sQ0FBQyxvQkFBb0IsQ0FDMUIsa0JBQWtCLEVBQ2xCLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxFQUNyQixjQUFjLENBQUMsV0FBVyxDQUFDLENBQzVCLENBQUM7SUFFRixNQUFNLGVBQWUsQ0FBQyxPQUFPLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFFNUMsT0FBTyxPQUFPLENBQUM7QUFDakIsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0ICd6b2Qtb3BlbmFwaS9leHRlbmQnO1xuXG5pbXBvcnQge1xuICB0eXBlIEZhc3RpZnlab2RPcGVuQXBpVHlwZVByb3ZpZGVyLFxuICBmYXN0aWZ5Wm9kT3BlbkFwaVBsdWdpbixcbiAgdmFsaWRhdG9yQ29tcGlsZXIsXG59IGZyb20gJ2Zhc3RpZnktem9kLW9wZW5hcGknO1xuaW1wb3J0IEZhc3RpZnkgZnJvbSAnZmFzdGlmeSc7XG5pbXBvcnQgSnNvbkJpZ0ludEZhY3RvcnkgZnJvbSAnanNvbi1iaWdpbnQnO1xuXG5pbXBvcnQgeyBGYXN0aWZ5V2l0aFpvZCwgU3dhZ2dlck9wdHMgfSBmcm9tICcuL3R5cGVzJztcbmltcG9ydCB7IHJlZ2lzdGVyU3dhZ2dlciB9IGZyb20gJy4vc3dhZ2dlcic7XG5pbXBvcnQgeyBtYWtlSnNvblBhcnNlciB9IGZyb20gJy4vanNvblBhcnNlcic7XG5pbXBvcnQgeyBtYWtlU2VyaWFsaXplckNvbXBpbGVyIH0gZnJvbSAnLi9zZXJpYWxpemVyQ29tcGlsZXInO1xuXG4vKipcbiAqIGNyZWF0ZXMgYW4gaW5zdGFuY2Ugb2YgRmFzdGlmeSB3aXRoIFpvZCB2YWxpZGF0aW9uIGxpYnJhcnkgYXMgdmFsaWRhdG9yIGFuZFxuICogdHlwZSBwcm92aWRlclxuICovXG5leHBvcnQgY29uc3QgbWFrZUZhc3RpZnkgPSBhc3luYyAoXG4gIHN3YWdnZXJPcHRzOiBTd2FnZ2VyT3B0cyA9IHtcbiAgICBwYXRoOiAnL3N3YWdnZXInLFxuICAgIHRpdGxlOiAnYXBpJyxcbiAgICBkZXNjcmlwdGlvbjogJycsXG4gICAgdmVyc2lvbjogJzAuMC4xJyxcbiAgfSxcbiAgb3B0cyA9IHsgbG9nZ2VyOiB0cnVlIH0sXG4gIGpzb25IYW5kbGVyID0gSnNvbkJpZ0ludEZhY3Rvcnkoe1xuICAgIGFsd2F5c1BhcnNlQXNCaWc6IGZhbHNlLFxuICAgIHVzZU5hdGl2ZUJpZ0ludDogdHJ1ZSxcbiAgICBzdG9yZUFzU3RyaW5nOiB0cnVlLFxuICB9KVxuKTogUHJvbWlzZTxGYXN0aWZ5V2l0aFpvZD4gPT4ge1xuICBjb25zdCBmYXN0aWZ5ID1cbiAgICBGYXN0aWZ5KG9wdHMpLndpdGhUeXBlUHJvdmlkZXI8RmFzdGlmeVpvZE9wZW5BcGlUeXBlUHJvdmlkZXI+KCk7XG5cbiAgZmFzdGlmeS5zZXRWYWxpZGF0b3JDb21waWxlcih2YWxpZGF0b3JDb21waWxlcik7XG5cbiAgY29uc3Qgc2VyaWFsaXplckNvbXBpbGVyID0gbWFrZVNlcmlhbGl6ZXJDb21waWxlcihqc29uSGFuZGxlcik7XG4gIGZhc3RpZnkuc2V0U2VyaWFsaXplckNvbXBpbGVyKHNlcmlhbGl6ZXJDb21waWxlcik7XG5cbiAgYXdhaXQgZmFzdGlmeS5yZWdpc3RlcihmYXN0aWZ5Wm9kT3BlbkFwaVBsdWdpbik7XG5cbiAgZmFzdGlmeS5hZGRDb250ZW50VHlwZVBhcnNlcjxzdHJpbmc+KFxuICAgICdhcHBsaWNhdGlvbi9qc29uJyxcbiAgICB7IHBhcnNlQXM6ICdzdHJpbmcnIH0sXG4gICAgbWFrZUpzb25QYXJzZXIoanNvbkhhbmRsZXIpXG4gICk7XG5cbiAgYXdhaXQgcmVnaXN0ZXJTd2FnZ2VyKGZhc3RpZnksIHN3YWdnZXJPcHRzKTtcblxuICByZXR1cm4gZmFzdGlmeTtcbn07XG4iXX0=

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-export { ZodTypeProvider } from 'fastify-type-provider-zod';
-export * from './dataTypes';
+export type { FastifyZodOpenApiTypeProvider } from 'fastify-zod-openapi';
 export * from './fastify';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AACzE,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -1,4 +1,3 @@
-export * from './dataTypes';
 export * from './fastify';
 export * from './types';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBab2RUeXBlUHJvdmlkZXIgfSBmcm9tICdmYXN0aWZ5LXR5cGUtcHJvdmlkZXItem9kJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0YVR5cGVzJztcbmV4cG9ydCAqIGZyb20gJy4vZmFzdGlmeSc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSB7IEZhc3RpZnlab2RPcGVuQXBpVHlwZVByb3ZpZGVyIH0gZnJvbSAnZmFzdGlmeS16b2Qtb3BlbmFwaSc7XG5leHBvcnQgKiBmcm9tICcuL2Zhc3RpZnknO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=

package/dist/jsonParser.d.ts

@@ -0,0 +1,4 @@
+import { ContentTypeParserDoneFunction } from 'fastify/types/content-type-parser';
+import JsonBigIntFactory from 'json-bigint';
+export declare const makeJsonParser: (jsonHandler: ReturnType<typeof JsonBigIntFactory>) => (req: unknown, body: string, done: ContentTypeParserDoneFunction) => void;
+//# sourceMappingURL=jsonParser.d.ts.map

package/dist/jsonParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonParser.d.ts","sourceRoot":"","sources":["../lib/jsonParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,mCAAmC,CAAC;AAClF,OAAO,iBAAiB,MAAM,aAAa,CAAC;AAE5C,eAAO,MAAM,cAAc,GACzB,aAAa,UAAU,CAAC,OAAO,iBAAiB,CAAC,MAEzC,KAAK,OAAO,EAAE,MAAM,MAAM,EAAE,MAAM,6BAA6B,SAgBxE,CAAC"}

package/dist/jsonParser.js

@@ -0,0 +1,18 @@
+export const makeJsonParser = (jsonHandler) => {
+    return (req, body, done) => {
+        try {
+            const json = jsonHandler.parse(body);
+            done(null, json);
+        }
+        catch (err) {
+            if (err instanceof Error || err === null) {
+                done(err, undefined);
+            }
+            else {
+                const wrappedErr = new Error(`An unexpected error occurred while trying to parse request body`, { cause: err });
+                done(wrappedErr, undefined);
+            }
+        }
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvblBhcnNlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL2xpYi9qc29uUGFyc2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUM1QixXQUFpRCxFQUNqRCxFQUFFO0lBQ0YsT0FBTyxDQUFDLEdBQVksRUFBRSxJQUFZLEVBQUUsSUFBbUMsRUFBRSxFQUFFO1FBQ3pFLElBQUksQ0FBQztZQUNILE1BQU0sSUFBSSxHQUFHLFdBQVcsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDckMsSUFBSSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztRQUNuQixDQUFDO1FBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLElBQUksR0FBRyxZQUFZLEtBQUssSUFBSSxHQUFHLEtBQUssSUFBSSxFQUFFLENBQUM7Z0JBQ3pDLElBQUksQ0FBQyxHQUFHLEVBQUUsU0FBUyxDQUFDLENBQUM7WUFDdkIsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLE1BQU0sVUFBVSxHQUFHLElBQUksS0FBSyxDQUMxQixpRUFBaUUsRUFDakUsRUFBRSxLQUFLLEVBQUUsR0FBRyxFQUFFLENBQ2YsQ0FBQztnQkFDRixJQUFJLENBQUMsVUFBVSxFQUFFLFNBQVMsQ0FBQyxDQUFDO1lBQzlCLENBQUM7UUFDSCxDQUFDO0lBQ0gsQ0FBQyxDQUFDO0FBQ0osQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udGVudFR5cGVQYXJzZXJEb25lRnVuY3Rpb24gfSBmcm9tICdmYXN0aWZ5L3R5cGVzL2NvbnRlbnQtdHlwZS1wYXJzZXInO1xuaW1wb3J0IEpzb25CaWdJbnRGYWN0b3J5IGZyb20gJ2pzb24tYmlnaW50JztcblxuZXhwb3J0IGNvbnN0IG1ha2VKc29uUGFyc2VyID0gKFxuICBqc29uSGFuZGxlcjogUmV0dXJuVHlwZTx0eXBlb2YgSnNvbkJpZ0ludEZhY3Rvcnk+XG4pID0+IHtcbiAgcmV0dXJuIChyZXE6IHVua25vd24sIGJvZHk6IHN0cmluZywgZG9uZTogQ29udGVudFR5cGVQYXJzZXJEb25lRnVuY3Rpb24pID0+IHtcbiAgICB0cnkge1xuICAgICAgY29uc3QganNvbiA9IGpzb25IYW5kbGVyLnBhcnNlKGJvZHkpO1xuICAgICAgZG9uZShudWxsLCBqc29uKTtcbiAgICB9IGNhdGNoIChlcnIpIHtcbiAgICAgIGlmIChlcnIgaW5zdGFuY2VvZiBFcnJvciB8fCBlcnIgPT09IG51bGwpIHtcbiAgICAgICAgZG9uZShlcnIsIHVuZGVmaW5lZCk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICBjb25zdCB3cmFwcGVkRXJyID0gbmV3IEVycm9yKFxuICAgICAgICAgIGBBbiB1bmV4cGVjdGVkIGVycm9yIG9jY3VycmVkIHdoaWxlIHRyeWluZyB0byBwYXJzZSByZXF1ZXN0IGJvZHlgLFxuICAgICAgICAgIHsgY2F1c2U6IGVyciB9XG4gICAgICAgICk7XG4gICAgICAgIGRvbmUod3JhcHBlZEVyciwgdW5kZWZpbmVkKTtcbiAgICAgIH1cbiAgICB9XG4gIH07XG59O1xuIl19

package/dist/serializerCompiler.d.ts

@@ -0,0 +1,14 @@
+import { FastifySerializerCompiler } from 'fastify/types/schema';
+import { ZodAny } from 'zod';
+import JsonBigIntFactory from 'json-bigint';
+type SerType = FastifySerializerCompiler<ZodAny | {
+    properties: ZodAny;
+}>;
+type JsonHandler = ReturnType<typeof JsonBigIntFactory>;
+/**
+ * creates a Fastify serializer compiler based on Zod validation library and
+ * using the passed json parser/serializer
+ */
+export declare const makeSerializerCompiler: (jsonHandler: JsonHandler) => SerType;
+export {};
+//# sourceMappingURL=serializerCompiler.d.ts.map

package/dist/serializerCompiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializerCompiler.d.ts","sourceRoot":"","sources":["../lib/serializerCompiler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,iBAAiB,MAAM,aAAa,CAAC;AAK5C,KAAK,OAAO,GAAG,yBAAyB,CAAC,MAAM,GAAG;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAC1E,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAExD;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAChC,aAAa,WAAW,KAAG,OAW3B,CAAC"}

package/dist/serializerCompiler.js

@@ -0,0 +1,27 @@
+import { ResponseValidationError } from './error';
+import { hasOwnProperty } from './utils';
+/**
+ * creates a Fastify serializer compiler based on Zod validation library and
+ * using the passed json parser/serializer
+ */
+export const makeSerializerCompiler = (jsonHandler) => (schemaDef) => (data) => {
+    const schema = resolveSchema(schemaDef.schema);
+    const result = schema.safeParse(data);
+    if (result.success) {
+        return jsonHandler.stringify(result.data);
+    }
+    throw new ResponseValidationError(result);
+};
+/**
+ * resolve the right schema to be used
+ */
+const resolveSchema = (maybeSchema) => {
+    if (hasOwnProperty(maybeSchema, 'safeParse')) {
+        return maybeSchema;
+    }
+    if (hasOwnProperty(maybeSchema, 'properties')) {
+        return maybeSchema.properties;
+    }
+    throw new Error(`Invalid schema passed: ${JSON.stringify(maybeSchema)}`);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/swagger.d.ts

@@ -0,0 +1,6 @@
+import { FastifyWithZod, SwaggerOpts } from './types';
+/**
+ * adds swagger to the fastify instance
+ */
+export declare const registerSwagger: (fastify: FastifyWithZod, opts: SwaggerOpts) => Promise<void>;
+//# sourceMappingURL=swagger.d.ts.map

package/dist/swagger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swagger.d.ts","sourceRoot":"","sources":["../lib/swagger.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtD;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,SAAS,cAAc,EACvB,MAAM,WAAW,kBAoClB,CAAC"}

package/dist/swagger.js

@@ -0,0 +1,42 @@
+import swagger from '@fastify/swagger';
+import swaggerUi from '@fastify/swagger-ui';
+import { fastifyZodOpenApiTransform, fastifyZodOpenApiTransformObject, } from 'fastify-zod-openapi';
+/**
+ * adds swagger to the fastify instance
+ */
+export const registerSwagger = async (fastify, opts) => {
+    await fastify.register(swagger, {
+        openapi: {
+            openapi: '3.1.0',
+            info: {
+                title: opts.title,
+                description: opts.description,
+                version: opts.version,
+            },
+        },
+        transform: fastifyZodOpenApiTransform,
+        transformObject: fastifyZodOpenApiTransformObject,
+    });
+    await fastify.register(swaggerUi, {
+        routePrefix: opts.path,
+        uiConfig: {
+            docExpansion: 'full',
+            deepLinking: false,
+        },
+        uiHooks: {
+            onRequest: (request, reply, next) => {
+                next();
+            },
+            preHandler: (request, reply, next) => {
+                next();
+            },
+        },
+        staticCSP: true,
+        transformStaticCSP: (header) => header,
+        transformSpecification: (swaggerObject, request, reply) => {
+            return swaggerObject;
+        },
+        transformSpecificationClone: true,
+    });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dhZ2dlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL2xpYi9zd2FnZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sT0FBTyxNQUFNLGtCQUFrQixDQUFDO0FBQ3ZDLE9BQU8sU0FBUyxNQUFNLHFCQUFxQixDQUFDO0FBQzVDLE9BQU8sRUFDTCwwQkFBMEIsRUFDMUIsZ0NBQWdDLEdBQ2pDLE1BQU0scUJBQXFCLENBQUM7QUFLN0I7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsS0FBSyxFQUNsQyxPQUF1QixFQUN2QixJQUFpQixFQUNqQixFQUFFO0lBQ0YsTUFBTSxPQUFPLENBQUMsUUFBUSxDQUFDLE9BQU8sRUFBRTtRQUM5QixPQUFPLEVBQUU7WUFDUCxPQUFPLEVBQUUsT0FBNEI7WUFDckMsSUFBSSxFQUFFO2dCQUNKLEtBQUssRUFBRSxJQUFJLENBQUMsS0FBSztnQkFDakIsV0FBVyxFQUFFLElBQUksQ0FBQyxXQUFXO2dCQUM3QixPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU87YUFDdEI7U0FDRjtRQUNELFNBQVMsRUFBRSwwQkFBMEI7UUFDckMsZUFBZSxFQUFFLGdDQUFnQztLQUNsRCxDQUFDLENBQUM7SUFFSCxNQUFNLE9BQU8sQ0FBQyxRQUFRLENBQUMsU0FBUyxFQUFFO1FBQ2hDLFdBQVcsRUFBRSxJQUFJLENBQUMsSUFBSTtRQUN0QixRQUFRLEVBQUU7WUFDUixZQUFZLEVBQUUsTUFBTTtZQUNwQixXQUFXLEVBQUUsS0FBSztTQUNuQjtRQUNELE9BQU8sRUFBRTtZQUNQLFNBQVMsRUFBRSxDQUFDLE9BQVksRUFBRSxLQUFVLEVBQUUsSUFBZ0IsRUFBRSxFQUFFO2dCQUN4RCxJQUFJLEVBQUUsQ0FBQztZQUNULENBQUM7WUFDRCxVQUFVLEVBQUUsQ0FBQyxPQUFZLEVBQUUsS0FBVSxFQUFFLElBQWdCLEVBQUUsRUFBRTtnQkFDekQsSUFBSSxFQUFFLENBQUM7WUFDVCxDQUFDO1NBQ0Y7UUFDRCxTQUFTLEVBQUUsSUFBSTtRQUNmLGtCQUFrQixFQUFFLENBQUMsTUFBVyxFQUFFLEVBQUUsQ0FBQyxNQUFNO1FBQzNDLHNCQUFzQixFQUFFLENBQUMsYUFBa0IsRUFBRSxPQUFZLEVBQUUsS0FBVSxFQUFFLEVBQUU7WUFDdkUsT0FBTyxhQUFhLENBQUM7UUFDdkIsQ0FBQztRQUNELDJCQUEyQixFQUFFLElBQUk7S0FDbEMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHN3YWdnZXIgZnJvbSAnQGZhc3RpZnkvc3dhZ2dlcic7XG5pbXBvcnQgc3dhZ2dlclVpIGZyb20gJ0BmYXN0aWZ5L3N3YWdnZXItdWknO1xuaW1wb3J0IHtcbiAgZmFzdGlmeVpvZE9wZW5BcGlUcmFuc2Zvcm0sXG4gIGZhc3RpZnlab2RPcGVuQXBpVHJhbnNmb3JtT2JqZWN0LFxufSBmcm9tICdmYXN0aWZ5LXpvZC1vcGVuYXBpJztcbmltcG9ydCB7IFpvZE9wZW5BcGlWZXJzaW9uIH0gZnJvbSAnem9kLW9wZW5hcGknO1xuXG5pbXBvcnQgeyBGYXN0aWZ5V2l0aFpvZCwgU3dhZ2dlck9wdHMgfSBmcm9tICcuL3R5cGVzJztcblxuLyoqXG4gKiBhZGRzIHN3YWdnZXIgdG8gdGhlIGZhc3RpZnkgaW5zdGFuY2VcbiAqL1xuZXhwb3J0IGNvbnN0IHJlZ2lzdGVyU3dhZ2dlciA9IGFzeW5jIChcbiAgZmFzdGlmeTogRmFzdGlmeVdpdGhab2QsXG4gIG9wdHM6IFN3YWdnZXJPcHRzXG4pID0+IHtcbiAgYXdhaXQgZmFzdGlmeS5yZWdpc3Rlcihzd2FnZ2VyLCB7XG4gICAgb3BlbmFwaToge1xuICAgICAgb3BlbmFwaTogJzMuMS4wJyBhcyBab2RPcGVuQXBpVmVyc2lvbixcbiAgICAgIGluZm86IHtcbiAgICAgICAgdGl0bGU6IG9wdHMudGl0bGUsXG4gICAgICAgIGRlc2NyaXB0aW9uOiBvcHRzLmRlc2NyaXB0aW9uLFxuICAgICAgICB2ZXJzaW9uOiBvcHRzLnZlcnNpb24sXG4gICAgICB9LFxuICAgIH0sXG4gICAgdHJhbnNmb3JtOiBmYXN0aWZ5Wm9kT3BlbkFwaVRyYW5zZm9ybSxcbiAgICB0cmFuc2Zvcm1PYmplY3Q6IGZhc3RpZnlab2RPcGVuQXBpVHJhbnNmb3JtT2JqZWN0LFxuICB9KTtcblxuICBhd2FpdCBmYXN0aWZ5LnJlZ2lzdGVyKHN3YWdnZXJVaSwge1xuICAgIHJvdXRlUHJlZml4OiBvcHRzLnBhdGgsXG4gICAgdWlDb25maWc6IHtcbiAgICAgIGRvY0V4cGFuc2lvbjogJ2Z1bGwnLFxuICAgICAgZGVlcExpbmtpbmc6IGZhbHNlLFxuICAgIH0sXG4gICAgdWlIb29rczoge1xuICAgICAgb25SZXF1ZXN0OiAocmVxdWVzdDogYW55LCByZXBseTogYW55LCBuZXh0OiAoKSA9PiB2b2lkKSA9PiB7XG4gICAgICAgIG5leHQoKTtcbiAgICAgIH0sXG4gICAgICBwcmVIYW5kbGVyOiAocmVxdWVzdDogYW55LCByZXBseTogYW55LCBuZXh0OiAoKSA9PiB2b2lkKSA9PiB7XG4gICAgICAgIG5leHQoKTtcbiAgICAgIH0sXG4gICAgfSxcbiAgICBzdGF0aWNDU1A6IHRydWUsXG4gICAgdHJhbnNmb3JtU3RhdGljQ1NQOiAoaGVhZGVyOiBhbnkpID0+IGhlYWRlcixcbiAgICB0cmFuc2Zvcm1TcGVjaWZpY2F0aW9uOiAoc3dhZ2dlck9iamVjdDogYW55LCByZXF1ZXN0OiBhbnksIHJlcGx5OiBhbnkpID0+IHtcbiAgICAgIHJldHVybiBzd2FnZ2VyT2JqZWN0O1xuICAgIH0sXG4gICAgdHJhbnNmb3JtU3BlY2lmaWNhdGlvbkNsb25lOiB0cnVlLFxuICB9KTtcbn07XG4iXX0=

package/dist/types.d.ts

@@ -1,8 +1,7 @@
-/// <reference types="node" />
-import { FastifyBaseLogger, FastifyInstance } from 'fastify';
-import { ZodTypeProvider } from 'fastify-type-provider-zod';
 import * as http from 'http';
-export type FastifyWithZod = FastifyInstance<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>, http.IncomingMessage, http.ServerResponse<http.IncomingMessage>, FastifyBaseLogger, ZodTypeProvider>;
+import { FastifyBaseLogger, FastifyInstance } from 'fastify';
+import type { FastifyZodOpenApiTypeProvider } from 'fastify-zod-openapi';
+export type FastifyWithZod = FastifyInstance<http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>, http.IncomingMessage, http.ServerResponse<http.IncomingMessage>, FastifyBaseLogger, FastifyZodOpenApiTypeProvider>;
 export interface SwaggerOpts {
     path: string;
     title: string;

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../lib/types.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAE7B,MAAM,MAAM,cAAc,GAAG,eAAe,CAC1C,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,eAAe,EAAE,OAAO,IAAI,CAAC,cAAc,CAAC,EACpE,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,eAAe,CAAC,EACzC,iBAAiB,EACjB,eAAe,CAChB,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,qBAAqB,CAAC;AAEzE,MAAM,MAAM,cAAc,GAAG,eAAe,CAC1C,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,eAAe,EAAE,OAAO,IAAI,CAAC,cAAc,CAAC,EACpE,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,eAAe,CAAC,EACzC,iBAAiB,EACjB,6BAA6B,CAC9B,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEZhc3RpZnlCYXNlTG9nZ2VyLCBGYXN0aWZ5SW5zdGFuY2UgfSBmcm9tICdmYXN0aWZ5JztcbmltcG9ydCB7IFpvZFR5cGVQcm92aWRlciB9IGZyb20gJ2Zhc3RpZnktdHlwZS1wcm92aWRlci16b2QnO1xuaW1wb3J0ICogYXMgaHR0cCBmcm9tICdodHRwJztcblxuZXhwb3J0IHR5cGUgRmFzdGlmeVdpdGhab2QgPSBGYXN0aWZ5SW5zdGFuY2U8XG4gIGh0dHAuU2VydmVyPHR5cGVvZiBodHRwLkluY29taW5nTWVzc2FnZSwgdHlwZW9mIGh0dHAuU2VydmVyUmVzcG9uc2U+LFxuICBodHRwLkluY29taW5nTWVzc2FnZSxcbiAgaHR0cC5TZXJ2ZXJSZXNwb25zZTxodHRwLkluY29taW5nTWVzc2FnZT4sXG4gIEZhc3RpZnlCYXNlTG9nZ2VyLFxuICBab2RUeXBlUHJvdmlkZXJcbj47XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3dhZ2dlck9wdHMge1xuICBwYXRoOiBzdHJpbmc7XG4gIHRpdGxlOiBzdHJpbmc7XG4gIGRlc2NyaXB0aW9uOiBzdHJpbmc7XG4gIHZlcnNpb246IHN0cmluZztcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIGh0dHAgZnJvbSAnaHR0cCc7XG5pbXBvcnQgeyBGYXN0aWZ5QmFzZUxvZ2dlciwgRmFzdGlmeUluc3RhbmNlIH0gZnJvbSAnZmFzdGlmeSc7XG5pbXBvcnQgdHlwZSB7IEZhc3RpZnlab2RPcGVuQXBpVHlwZVByb3ZpZGVyIH0gZnJvbSAnZmFzdGlmeS16b2Qtb3BlbmFwaSc7XG5cbmV4cG9ydCB0eXBlIEZhc3RpZnlXaXRoWm9kID0gRmFzdGlmeUluc3RhbmNlPFxuICBodHRwLlNlcnZlcjx0eXBlb2YgaHR0cC5JbmNvbWluZ01lc3NhZ2UsIHR5cGVvZiBodHRwLlNlcnZlclJlc3BvbnNlPixcbiAgaHR0cC5JbmNvbWluZ01lc3NhZ2UsXG4gIGh0dHAuU2VydmVyUmVzcG9uc2U8aHR0cC5JbmNvbWluZ01lc3NhZ2U+LFxuICBGYXN0aWZ5QmFzZUxvZ2dlcixcbiAgRmFzdGlmeVpvZE9wZW5BcGlUeXBlUHJvdmlkZXJcbj47XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3dhZ2dlck9wdHMge1xuICBwYXRoOiBzdHJpbmc7XG4gIHRpdGxlOiBzdHJpbmc7XG4gIGRlc2NyaXB0aW9uOiBzdHJpbmc7XG4gIHZlcnNpb246IHN0cmluZztcbn1cbiJdfQ==

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const hasOwnProperty: <T, K extends PropertyKey>(obj: T, prop: K) => obj is T & Record<K, any>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../lib/utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,GAAI,CAAC,EAAE,CAAC,SAAS,WAAW,EACrD,KAAK,CAAC,EACN,MAAM,CAAC,KACN,GAAG,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,GAAG,CAE1B,CAAC"}