@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/general/estimateGas.d.ts

@@ -1,51 +1,24 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
 import { HttpError } from "../common/http-error.js";
-import { ITag } from "../common/tag.js";
-export declare function createEstimateGasHandlersV0<E extends Env>(factory: Factory<E>, tag: ITag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    readonly success: true;
-    readonly value: string;
-}, 200, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            chainId: "11155111" | "31337";
-            data: `0x${string}`;
-            from: `0x${string}`;
-            to: `0x${string}`;
+export declare const EstimateGasV0: import("../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    data: string;
+                    from: string;
+                    to: string;
+                };
+            };
+            output: {
+                readonly success: true;
+                readonly value: string;
+            };
+            outputFormat: "json";
+            status: 200;
         };
     };
-    out: {
-        json: {
-            chainId: "11155111" | "31337";
-            data: `0x${string}`;
-            from: `0x${string}`;
-            to: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    readonly success: true;
-    readonly value: string;
-}, 200, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        json: {
-            chainId: "11155111" | "31337";
-            data: `0x${string}`;
-            from: `0x${string}`;
-            to: `0x${string}`;
-        };
-    };
-    out: {
-        json: {
-            chainId: "11155111" | "31337";
-            data: `0x${string}`;
-            from: `0x${string}`;
-            to: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    readonly success: true;
-    readonly value: string;
-}, 200, "json">>>];
+}, "/">>;
 export declare class UnableEstimateGasError extends HttpError<500> {
     constructor(error: unknown);
 }

package/dist/general/estimateGas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"estimateGas.d.ts","sourceRoot":"","sources":["../../src/general/estimateGas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAG3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAMvC,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAExC,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA0DxF;AAED,qBAAa,sBAAuB,SAAQ,SAAS,CAAC,GAAG,CAAC;gBAC5C,KAAK,EAAE,OAAO;CAM3B"}
+{"version":3,"file":"estimateGas.d.ts","sourceRoot":"","sources":["../../src/general/estimateGas.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AA8BpD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;QAoCxB,CAAC;AAEH,qBAAa,sBAAuB,SAAQ,SAAS,CAAC,GAAG,CAAC;gBAC5C,KAAK,EAAE,OAAO;CAM3B"}

package/dist/general/estimateGas.js

@@ -1,43 +1,45 @@
-import { Int256Positive } from "@evergonlabs/tmi-utils/models";
-import { getErrorMessage } from "@evergonlabs/tmi-utils/errors";
-import { estimateGas } from "viem/actions";
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
+import { resolver, validator } from "hono-openapi";
+import { estimateGas } from "viem/actions";
+import { z } from "zod";
+import { getErrorMessage } from "@evergonlabs/tmi-utils/errors";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
 import { getPublicClient } from "../common/blockchain.js";
-import { AddressSchema, HexStringSchema, StakingChainId } from "../common/index.js";
+import { createController } from "../common/controller.js";
 import { HttpError } from "../common/http-error.js";
-import { z } from "../common/zod.js";
-export function createEstimateGasHandlersV0(factory, tag) {
-    return factory.createHandlers(describeRoute({
-        summary: "Estimate gas",
-        description: "Checks given transaction data whether it can be executed and returns estimated gas consumption",
-        tags: [tag.tag],
-        responses: {
-            200: {
-                description: "Returns estimated gas or estimation error",
-                content: {
-                    "application/json": {
-                        schema: resolver(z
-                            .object({
-                            value: Int256Positive.openapi({
-                                description: "Amount of gas (in WEI) that is needed for specified transaction",
-                            }),
-                        })
-                            .openapi({
-                            ref: "EstimateGasResponse",
-                        })),
-                    },
+import { AddressSchema, HexStringSchema, StakingChainId } from "../common/index.js";
+import { createTag } from "../common/tag.js";
+const tag = createTag("General");
+const estimateGasRoute = describeRoute({
+    summary: "Estimate gas",
+    description: "Checks given transaction data whether it can be executed and returns estimated gas consumption",
+    tags: [tag.tag],
+    responses: {
+        200: {
+            description: "Returns estimated gas or estimation error",
+            content: {
+                "application/json": {
+                    schema: resolver(z
+                        .object({
+                        value: Int256Json.openapi({
+                            description: "Amount of gas (in WEI) that is needed for specified transaction",
+                        }),
+                    })
+                        .openapi("EstimateGasResponse")),
                 },
             },
         },
-    }), validator("json", z.object({
+    },
+});
+export const EstimateGasV0 = createController({
+    build: (factory) => factory.createApp().post("/", estimateGasRoute, validator("json", z.object({
         chainId: StakingChainId,
         data: HexStringSchema,
         from: AddressSchema,
         to: AddressSchema,
     })), async (c) => {
         const { chainId, data, to, from } = c.req.valid("json");
-        const publicClient = getPublicClient(chainId);
+        const publicClient = getPublicClient(chainId, c.env.config);
         try {
             const estimated = await estimateGas(publicClient, {
                 data: data,
@@ -52,8 +54,8 @@ export function createEstimateGasHandlersV0(factory, tag) {
         catch (error) {
             throw new UnableEstimateGasError(error);
         }
-    });
-}
+    }),
+});
 export class UnableEstimateGasError extends HttpError {
     constructor(error) {
         super(500, {

package/dist/general/getBalance.d.ts

@@ -1,40 +1,19 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import { ITag } from "../common/tag.js";
-export declare function createGetBalanceV0<E extends Env, TTag extends ITag>(factory: Factory<E>, tag: TTag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    address: `0x${string}`;
-    balance: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        query: {
-            chainId: string | string[];
-            address: string | string[];
+export declare const GetBalanceV0: import("../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, {
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    address: string | string[];
+                };
+            };
+            output: {
+                address: `0x${string}`;
+                balance: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-    out: {
-        query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    address: `0x${string}`;
-    balance: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        query: {
-            chainId: string | string[];
-            address: string | string[];
-        };
-    };
-    out: {
-        query: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    address: `0x${string}`;
-    balance: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+}, "/">>;
 //# sourceMappingURL=getBalance.d.ts.map

package/dist/general/getBalance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getBalance.d.ts","sourceRoot":"","sources":["../../src/general/getBalance.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAKvC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAGxC,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,SAAS,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEA8ClG"}
+{"version":3,"file":"getBalance.d.ts","sourceRoot":"","sources":["../../src/general/getBalance.ts"],"names":[],"mappings":"AAkCA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;QA2BvB,CAAC"}

package/dist/general/getBalance.js

@@ -1,35 +1,39 @@
-import { z } from "zod";
-import { Int256 } from "@evergonlabs/tmi-utils/models";
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { AddressSchema, TmiChainIdSchema } from "../common/index.js";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { Int256Json } from "@evergonlabs/tmi-utils/models";
+import { createController } from "../common/controller.js";
+import { AddressSchema, FractionsChainId } from "../common/index.js";
+import { createTag } from "../common/tag.js";
 import { getQuicknode } from "./common.js";
-export function createGetBalanceV0(factory, tag) {
-    return factory.createHandlers(describeRoute({
-        summary: "Get balance",
-        description: "Returns native balance of a wallet for specific token",
-        tags: [tag.tag],
-        responses: {
-            200: {
-                description: "Returns native balance of a wallet",
-                content: {
-                    "application/json": {
-                        schema: resolver(z.object({
-                            address: AddressSchema,
-                            balance: Int256.openapi({
-                                description: "Native tokens in WEI",
-                            }),
-                        })),
-                    },
+const tag = createTag("General");
+const getBalanceRoute = describeRoute({
+    summary: "Get balance",
+    description: "Returns native balance of a wallet for specific token",
+    tags: [tag.tag],
+    responses: {
+        200: {
+            description: "Returns native balance of a wallet",
+            content: {
+                "application/json": {
+                    schema: resolver(z.object({
+                        address: AddressSchema,
+                        balance: Int256Json.openapi({
+                            description: "Native tokens in WEI",
+                        }),
+                    })),
                 },
             },
         },
-    }), validator("query", z.object({
-        chainId: TmiChainIdSchema,
+    },
+});
+export const GetBalanceV0 = createController({
+    build: (factory) => factory.createApp().get("/", getBalanceRoute, validator("query", z.object({
+        chainId: FractionsChainId,
         address: AddressSchema,
     })), async (c) => {
         const { chainId, address } = c.req.valid("query");
-        const quicknode = getQuicknode(chainId);
+        const quicknode = getQuicknode(chainId, c.env.config);
         const result = await quicknode.client.getBalance({
             address: address,
             blockTag: "safe",
@@ -38,5 +42,5 @@ export function createGetBalanceV0(factory, tag) {
             address: address,
             balance: result.toString(),
         });
-    });
-}
+    }),
+});

package/dist/general/getBalancesBatch.d.ts

@@ -1,59 +1,25 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-import { ITag } from "../common/tag.js";
-export declare function createGetBalancesBatchV0<E extends Env, TTag extends ITag>(factory: Factory<E>, tag: TTag): [import("hono/types").H<any, string, {}, Promise<Response & import("hono").TypedResponse<{
-    quantityIn: string;
-    quantityOut: string;
-    name: string | null;
-    symbol: string | null;
-    decimals: string | null;
-    address: string;
-    totalBalance: string;
-}[], import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<Env, string, {
-    in: {
-        json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            contracts: `0x${string}`[];
+export declare const GetBalancesBatchV0: import("../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, {
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    address: string;
+                    contracts: string[];
+                };
+            };
+            output: {
+                quantityIn: string;
+                quantityOut: string;
+                name: string | null;
+                symbol: string | null;
+                decimals: string | null;
+                address: string;
+                totalBalance: string;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
     };
-    out: {
-        json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            contracts: `0x${string}`[];
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    quantityIn: string;
-    quantityOut: string;
-    name: string | null;
-    symbol: string | null;
-    decimals: string | null;
-    address: string;
-    totalBalance: string;
-}[], import("hono/utils/http-status").ContentfulStatusCode, "json">>>, import("hono/types").H<import("hono/utils/types").IfAnyThenEmptyObject<E extends Env ? Env extends E ? {} : E : E> & {}, string, {
-    in: {
-        json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            contracts: `0x${string}`[];
-        };
-    };
-    out: {
-        json: {
-            chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-            address: `0x${string}`;
-            contracts: `0x${string}`[];
-        };
-    };
-}, Promise<Response & import("hono").TypedResponse<{
-    quantityIn: string;
-    quantityOut: string;
-    name: string | null;
-    symbol: string | null;
-    decimals: string | null;
-    address: string;
-    totalBalance: string;
-}[], import("hono/utils/http-status").ContentfulStatusCode, "json">>>];
+}, "/">>;
 //# sourceMappingURL=getBalancesBatch.d.ts.map

package/dist/general/getBalancesBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getBalancesBatch.d.ts","sourceRoot":"","sources":["../../src/general/getBalancesBatch.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAIvC,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAGxC,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,SAAS,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEAqCxG"}
+{"version":3,"file":"getBalancesBatch.d.ts","sourceRoot":"","sources":["../../src/general/getBalancesBatch.ts"],"names":[],"mappings":"AA0BA,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;QAyB7B,CAAC"}

package/dist/general/getBalancesBatch.js

@@ -1,34 +1,38 @@
-import { z } from "zod";
 import { describeRoute } from "hono-openapi";
-import { resolver, validator } from "hono-openapi/zod";
-import { AddressSchema, TmiChainIdSchema } from "../common/index.js";
+import { resolver, validator } from "hono-openapi";
+import { z } from "zod";
+import { createController } from "../common/controller.js";
+import { AddressSchema, FractionsChainId } from "../common/index.js";
+import { createTag } from "../common/tag.js";
 import { getQuicknode, TokenBalanceSchema } from "./common.js";
-export function createGetBalancesBatchV0(factory, tag) {
-    return factory.createHandlers(describeRoute({
-        summary: "Get balances batch",
-        description: "Returns ERC20 balances of a wallet for specific tokens",
-        tags: [tag.tag],
-        responses: {
-            200: {
-                description: "Returns ERC20 balances",
-                content: {
-                    "application/json": {
-                        schema: resolver(z.array(TokenBalanceSchema)),
-                    },
+const tag = createTag("General");
+const getBalancesBatchRoute = describeRoute({
+    summary: "Get balances batch",
+    description: "Returns ERC20 balances of a wallet for specific tokens",
+    tags: [tag.tag],
+    responses: {
+        200: {
+            description: "Returns ERC20 balances",
+            content: {
+                "application/json": {
+                    schema: resolver(z.array(TokenBalanceSchema)),
                 },
             },
         },
-    }), validator("json", z.object({
-        chainId: TmiChainIdSchema,
+    },
+});
+export const GetBalancesBatchV0 = createController({
+    build: (factory) => factory.createApp().post("/", getBalancesBatchRoute, validator("json", z.object({
+        chainId: FractionsChainId,
         address: AddressSchema,
         contracts: z.array(AddressSchema),
     })), async (c) => {
         const { chainId, address, contracts } = c.req.valid("json");
-        const quicknode = getQuicknode(chainId);
+        const quicknode = getQuicknode(chainId, c.env.config);
         const result = await quicknode.client.qn_getWalletTokenBalance({
             wallet: address,
             contracts: contracts,
         });
         return c.json(result.result);
-    });
-}
+    }),
+});

package/dist/general/index.d.ts

@@ -1,97 +1,88 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare const generalApis: {
-    name: string;
-    createApp: <E extends Env>(factory: Factory<E>) => import("hono/hono-base").HonoBase<E, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
-        "/estimateGas": {
-            $post: {
-                input: {
-                    json: {
-                        chainId: "11155111" | "31337";
-                        data: `0x${string}`;
-                        from: `0x${string}`;
-                        to: `0x${string}`;
-                    };
+export declare const GeneralApi: import("../common/controller.js").IApi<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    data: string;
+                    from: string;
+                    to: string;
                 };
-                output: {
-                    readonly success: true;
-                    readonly value: string;
-                };
-                outputFormat: "json";
-                status: 200;
             };
+            output: {
+                readonly success: true;
+                readonly value: string;
+            };
+            outputFormat: "json";
+            status: 200;
         };
-    } & {
-        "/balance": {
-            $get: {
-                input: {
-                    query: {
-                        chainId: string | string[];
-                        address: string | string[];
-                    };
-                };
-                output: {
-                    address: `0x${string}`;
-                    balance: string;
+    };
+}, "/estimateGas"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    address: string | string[];
                 };
-                outputFormat: "json";
-                status: import("hono/utils/http-status").ContentfulStatusCode;
             };
+            output: {
+                address: `0x${string}`;
+                balance: string;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
-    } & {
-        "/balances": {
-            $post: {
-                input: {
-                    json: {
-                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-                        address: `0x${string}`;
-                        contracts: `0x${string}`[];
-                    };
-                };
-                output: {
-                    quantityIn: string;
-                    quantityOut: string;
-                    name: string | null;
-                    symbol: string | null;
-                    decimals: string | null;
+    };
+}, "/balance"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
                     address: string;
-                    totalBalance: string;
-                }[];
-                outputFormat: "json";
-                status: import("hono/utils/http-status").ContentfulStatusCode;
+                    contracts: string[];
+                };
             };
+            output: {
+                quantityIn: string;
+                quantityOut: string;
+                name: string | null;
+                symbol: string | null;
+                decimals: string | null;
+                address: string;
+                totalBalance: string;
+            }[];
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
-    } & {
-        "/searchBalances": {
-            $post: {
-                input: {
-                    json: {
-                        chainId: import("@evergonlabs/tmi-protocol-fractions-sdk").TmiChainId;
-                        address: `0x${string}`;
-                    };
-                };
-                output: {
-                    balances: {
-                        tokenAddress: `0x${string}`;
-                        balance: string;
-                        decimals: number;
-                        symbol: string;
-                        name: string;
-                        tokenId: string | null;
-                        type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
-                    }[];
-                    totalItems: number;
-                    totalPages: number;
-                    pageNumber: number;
+    };
+}, "/balances"> | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    address: string;
                 };
-                outputFormat: "json";
-                status: import("hono/utils/http-status").ContentfulStatusCode;
             };
+            output: {
+                balances: {
+                    tokenAddress: `0x${string}`;
+                    balance: string & import("zod").$brand<"Int256">;
+                    decimals: number;
+                    symbol: string;
+                    name: string;
+                    tokenId: (string & import("zod").$brand<"Int256">) | null;
+                    type: import("@evergonlabs/tmi-protocol-types/evm").TokenTypeEnum | null;
+                }[];
+                totalItems: number;
+                totalPages: number;
+                pageNumber: number;
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
         };
-    }, "/general">, "/">;
-    config: {
-        title: string;
-        description: string;
     };
-};
+}, "/searchBalances">, "/">>;
 //# sourceMappingURL=index.d.ts.map

package/dist/general/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/general/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AASvC,eAAO,MAAM,WAAW;;gBAEV,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAc/C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/general/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAUrB,CAAC"}