@merkl/api 0.10.78

package/dist/src/modules/v4/campaign/campaign.service.d.ts

@@ -0,0 +1,180 @@
+import { type CampaignUnique, type ConvertedCampaignType, type CreateCampaignModel, type GetCampaignQueryModel } from "./";
+import { CampaignRepository } from "./campaign.repository";
+import type { CampaignType } from "../../../../database/api/.generated";
+import type { CampaignParameters, Campaign as CampaignTypeV3, ChainId } from "@sdk";
+export declare abstract class CampaignService {
+    static hashId(campaign: CampaignUnique): string;
+    static create(campaign: Omit<CreateCampaignModel, "id">): Promise<{
+        id: string;
+        computeChainId: number;
+        distributionChainId: number;
+        identifier: string;
+        campaignId: string;
+        type: import("../../../../database/api/.generated").$Enums.CampaignType;
+        subType: number | null;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        params: import("../../../../database/api/.generated").Prisma.JsonValue;
+        creatorAddress: string;
+    } | undefined>;
+    static createMany(campaigns: Omit<CreateCampaignModel, "id">[]): Promise<{
+        success: number;
+        fail: number;
+    }>;
+    /**
+     * Get the list of campaigns satisfying the query
+     * @param query
+     * @returns A list of campaigns
+     */
+    static findMany(query: GetCampaignQueryModel): Promise<({
+        params: any;
+        chain: {
+            id: number;
+            name: string;
+            icon: string;
+        };
+        rewardToken: {
+            id: string;
+            name: string | null;
+            chainId: number;
+            address: string;
+            decimals: number;
+            symbol: string;
+            icon: string;
+            verified: boolean;
+            price: number | null;
+        };
+        distributionChain: {
+            id: number;
+            name: string;
+            icon: string;
+        } | undefined;
+        id: string;
+        computeChainId: number;
+        distributionChainId: number;
+        identifier: string;
+        campaignId: string;
+        type: import("../../../../database/api/.generated").$Enums.CampaignType;
+        subType: number | null;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        creatorAddress: string;
+    } | null)[]>;
+    /**
+     * Counts the number of campaigns that complies to query
+     * @description used for pagination purposes
+     * @param query
+     * @returns the number of campaigns
+     */
+    static countMany(query: GetCampaignQueryModel): Promise<number>;
+    static checkIfExist(campaign: CampaignUnique): Promise<boolean>;
+    static findUniqueOrThrow(campaign: CampaignUnique): Promise<{
+        id: string;
+        computeChainId: number;
+        distributionChainId: number;
+        identifier: string;
+        campaignId: string;
+        type: import("../../../../database/api/.generated").$Enums.CampaignType;
+        subType: number | null;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        params: import("../../../../database/api/.generated").Prisma.JsonValue;
+        creatorAddress: string;
+    }>;
+    static fill(campaigns: CampaignUnique[]): Promise<{
+        success: number;
+        fail: number;
+    }>;
+    static fetchMissingCampaigns(chainId: ChainId, campaignIds: CampaignUnique[]): Promise<{
+        success: number;
+        fail: number;
+    }>;
+    static findChains(): Promise<Record<string, ChainId>>;
+    /**
+     * Returns the campaign data
+     * @param type index of Campaign enum from sdk
+     * @returns CampaignType as db-related enum for v4
+     */
+    static getTypeFromV3(type: CampaignTypeV3): CampaignType;
+    /**
+     * Split a campaigns array into three array for each status
+     * @param campaigns
+     * @param timestamp to compare to campaigns timestamps
+     * @returns a status => campaigns map
+     */
+    static splitOnStatus<C extends {
+        startTimestamp: bigint | number;
+        endTimestamp: bigint | number;
+    }>(campaigns: C[], timestamp?: number): {
+        past: C[];
+        live: C[];
+        soon: C[];
+    };
+    /**
+     * Returns the campaign data
+     * @param chainId to fetch campaigns for
+     * @param timestamp from which campaigns endTimestamp are filtered
+     * @returns
+     */
+    static getFromEngineDb(chainId: number, timestamp: number): Promise<CampaignParameters<CampaignV3>[]>;
+    /**
+     * Convert raw
+     * @param query
+     * @returns A list of opportunities
+     * TODO: remove this function in favor of prisma client extensions
+     */
+    static format(campaign: NonNullable<Awaited<ReturnType<typeof CampaignRepository.findMany>>>[number] | null): {
+        params: any;
+        chain: {
+            id: number;
+            name: string;
+            icon: string;
+        };
+        rewardToken: {
+            id: string;
+            name: string | null;
+            chainId: number;
+            address: string;
+            decimals: number;
+            symbol: string;
+            icon: string;
+            verified: boolean;
+            price: number | null;
+        };
+        distributionChain: {
+            id: number;
+            name: string;
+            icon: string;
+        } | undefined;
+        id: string;
+        computeChainId: number;
+        distributionChainId: number;
+        identifier: string;
+        campaignId: string;
+        type: import("../../../../database/api/.generated").$Enums.CampaignType;
+        subType: number | null;
+        rewardTokenId: string;
+        amount: string;
+        opportunityId: string;
+        startTimestamp: bigint;
+        endTimestamp: bigint;
+        creatorAddress: string;
+    } | null;
+    /**
+     * Fetches the campaign dynamic data for a v3 campaign onchain
+     * @param chainId
+     * @param campaignType
+     * @param campaigns of v3 type
+     * @returns
+     */
+    static fetchDynamicData<C extends CampaignType>(chainId: number, campaignType: CampaignType, campaigns: CampaignParameters<ConvertedCampaignType<C>>[]): Promise<any>;
+}

package/dist/src/modules/v4/campaign/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./campaign.model";
+export * from "./campaign.service";
+export * from "./campaign.controller";

package/dist/src/modules/v4/chain/chain.controller.d.ts

@@ -0,0 +1,91 @@
+import Elysia from "elysia";
+export declare const ChainController: Elysia<"/chains", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    chains: {
+        ":chainId": {
+            get: {
+                body: unknown;
+                params: {
+                    chainId: number;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: ({
+                        Explorer: {
+                            id: string;
+                            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+                            url: string;
+                            chainId: number;
+                        }[];
+                    } & {
+                        id: number;
+                        name: string;
+                        icon: string;
+                    }) | null;
+                };
+            };
+        };
+    };
+} & {
+    chains: {
+        index: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: {
+                    search?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: ({
+                        Explorer: {
+                            id: string;
+                            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+                            url: string;
+                            chainId: number;
+                        }[];
+                    } & {
+                        id: number;
+                        name: string;
+                        icon: string;
+                    })[];
+                };
+            };
+        };
+    };
+} & {
+    chains: {
+        count: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: {
+                    search?: string | undefined;
+                };
+                headers: unknown;
+                response: {
+                    200: number;
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/modules/v4/chain/chain.model.d.ts

@@ -0,0 +1,19 @@
+import type { Resource } from "../prisma";
+/**
+ * Chain
+ * @description Metadata for each supported network
+ * @see {@link Resource}
+ */
+export type Chain = Resource<"Chain">;
+export declare const GetChainQueryDto: import("@sinclair/typebox").TObject<{
+    search: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const ChainUniqueDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+}>;
+export declare const ChainArrayDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNumber, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>;
+}>;
+export type ChainUniqueModel = typeof ChainUniqueDto.static;
+export type ChainSearchDto = typeof GetChainQueryDto.static;
+export type ChainsArrayModel = typeof ChainArrayDto.static;

package/dist/src/modules/v4/chain/chain.repository.d.ts

@@ -0,0 +1,66 @@
+import type { Campaign, CampaignParameters } from "@sdk";
+import type { Chain, ChainSearchDto } from "./chain.model";
+export declare abstract class ChainRepository {
+    #private;
+    /**
+     * @param id ChainId
+     * @returns
+     */
+    static read(id: number): Promise<({
+        Explorer: {
+            id: string;
+            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+            url: string;
+            chainId: number;
+        }[];
+    } & {
+        id: number;
+        name: string;
+        icon: string;
+    }) | null>;
+    /** Returns many chains based on query
+     * @param query object with fields to search for
+     * @returns
+     */
+    static readMany(query: ChainSearchDto): Promise<({
+        Explorer: {
+            id: string;
+            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+            url: string;
+            chainId: number;
+        }[];
+    } & {
+        id: number;
+        name: string;
+        icon: string;
+    })[]>;
+    static countMany(query: ChainSearchDto): Promise<number>;
+    /** Returns all chainIds in the database
+     */
+    static readIds(): Promise<{
+        id: number;
+    }[]>;
+    /**
+     * Creates a new chain
+     * @param template for chain creation
+     * @returns
+     */
+    static create(template: Chain["action"]["create"]["args"]): Promise<{
+        id: number;
+        name: string;
+        icon: string;
+    }>;
+    static findMany(): Promise<{
+        id: number;
+        name: string;
+        icon: string;
+    }[]>;
+    /**
+     * Fetches the campaign dynamic data for a v3 campaign onchain
+     * @param chainId
+     * @param campaignType
+     * @param campaigns of v3 type
+     * @returns
+     */
+    static fetchDynamicDataV3<CampaignType extends Campaign>(chainId: number, campaignType: CampaignType, campaigns: CampaignParameters<CampaignType>[]): Promise<any>;
+}

package/dist/src/modules/v4/chain/chain.service.d.ts

@@ -0,0 +1,42 @@
+import type { ChainSearchDto } from "./chain.model";
+export declare abstract class ChainService {
+    static get(chainId: number): Promise<({
+        Explorer: {
+            id: string;
+            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+            url: string;
+            chainId: number;
+        }[];
+    } & {
+        id: number;
+        name: string;
+        icon: string;
+    }) | null>;
+    static findMany(): Promise<{
+        id: number;
+        name: string;
+        icon: string;
+    }[]>;
+    static getMany(query: ChainSearchDto): Promise<({
+        Explorer: {
+            id: string;
+            type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+            url: string;
+            chainId: number;
+        }[];
+    } & {
+        id: number;
+        name: string;
+        icon: string;
+    })[]>;
+    static countMany(query: ChainSearchDto): Promise<number>;
+    /** List all chainIds available in the databse
+     * @warning some chains may not be fully integrated yet
+     * @returns an array of chainId
+     */
+    static getIds(): Promise<number[]>;
+    /** List all chainIds which have a distribituor (i.e. which is fully integrated)
+     * @returns an array of chainId
+     */
+    static getSupportedIds(): Promise<number[]>;
+}

package/dist/src/modules/v4/chain/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./chain.controller";
+export * from "./chain.service";
+export * from "./chain.model";

package/dist/src/modules/v4/enso/enso.model.d.ts

@@ -0,0 +1,130 @@
+export declare const slugToProtocolId: {
+    readonly "uniswap-v2": "uniswap-v2";
+    readonly "aave-v2": "aave";
+    readonly "camelot-v2": "camelot";
+};
+export type EnsoSlug = keyof typeof slugToProtocolId;
+export declare const apiTypes: {
+    readonly "/v1/protocols": {
+        readonly query: import("@sinclair/typebox").TObject<{
+            slug: import("@sinclair/typebox").TString;
+        }>;
+        readonly response: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            slug: import("@sinclair/typebox").TString;
+            name: import("@sinclair/typebox").TString;
+            desription: import("@sinclair/typebox").TString;
+            url: import("@sinclair/typebox").TString;
+            logosUri: import("@sinclair/typebox").TString;
+            chains: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                id: import("@sinclair/typebox").TNumber;
+                name: import("@sinclair/typebox").TString;
+            }>>;
+        }>>;
+    };
+    readonly "/v1/tokens": {
+        readonly query: import("@sinclair/typebox").TObject<{
+            protocolSlug: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            primaryAddress: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            address: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            chainId: import("@sinclair/typebox").TNumber;
+            type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TEnum<{
+                defi: "defi";
+                base: "base";
+            }>>;
+            page: import("@sinclair/typebox").TNumber;
+            inludeMetadatra: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+        }>;
+        readonly response: import("@sinclair/typebox").TObject<{
+            data: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                chainId: import("@sinclair/typebox").TNumber;
+                address: import("@sinclair/typebox").TString;
+                type: import("@sinclair/typebox").TEnum<{
+                    defi: "defi";
+                    base: "base";
+                }>;
+                primaryAddress: import("@sinclair/typebox").TString;
+                underlyingTokens: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    address: import("@sinclair/typebox").TString;
+                    chainId: import("@sinclair/typebox").TNumber;
+                    type: import("@sinclair/typebox").TEnum<{
+                        defi: "defi";
+                        base: "base";
+                    }>;
+                }>>;
+                apy: import("@sinclair/typebox").TNumber;
+            }>>;
+            meta: import("@sinclair/typebox").TObject<{
+                total: import("@sinclair/typebox").TNumber;
+                lastPage: import("@sinclair/typebox").TNumber;
+                currentPage: import("@sinclair/typebox").TNumber;
+                perPage: import("@sinclair/typebox").TNumber;
+                prev: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TNumber]>;
+                next: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TNull, import("@sinclair/typebox").TNumber]>;
+            }>;
+        }>;
+    };
+    readonly "/v1/shortcuts/quote": {
+        readonly query: import("@sinclair/typebox").TObject<{
+            chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            fromAddress: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            routingStrategy: import("@sinclair/typebox").TEnum<{
+                ensowallet: "ensowallet";
+                delegate: "delegate";
+                router: "router";
+            }>;
+            feeReceiver: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            tokenIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            tokenOut: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            amountIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            fee: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            disableRFQs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            ignoreAggregators: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            ignoreStandards: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+        }>;
+        readonly response: import("@sinclair/typebox").TObject<{
+            gas: import("@sinclair/typebox").TString;
+            amountOut: import("@sinclair/typebox").TObject<{}>;
+            priceImpact: import("@sinclair/typebox").TNumber;
+            feeAmount: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        }>;
+    };
+    readonly "/v1/shortcuts/route": {
+        readonly query: import("@sinclair/typebox").TObject<{
+            chainId: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+            fromAddress: import("@sinclair/typebox").TString;
+            routingStrategy: import("@sinclair/typebox").TEnum<{
+                ensowallet: "ensowallet";
+                delegate: "delegate";
+                router: "router";
+            }>;
+            receiver: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            spender: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            amountIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            amountOut: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            minAmountOut: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            slippage: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            fee: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            feeReceiver: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+            disableRFQs: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+            ignoreAggregators: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            ignoreStandards: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
+            tokenIn: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            tokenOut: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+        }>;
+        readonly response: import("@sinclair/typebox").TObject<{
+            gas: import("@sinclair/typebox").TString;
+            amountOut: import("@sinclair/typebox").TString;
+            priceImpact: import("@sinclair/typebox").TNumber;
+            feeAmount: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            createAt: import("@sinclair/typebox").TNumber;
+            tx: import("@sinclair/typebox").TObject<{
+                data: import("@sinclair/typebox").TString;
+                to: import("@sinclair/typebox").TString;
+                from: import("@sinclair/typebox").TString;
+                value: import("@sinclair/typebox").TString;
+            }>;
+        }>;
+    };
+};
+export type EnsoRoute = keyof typeof apiTypes;
+export type EnsoApi<T extends EnsoRoute> = (typeof apiTypes)[T];

package/dist/src/modules/v4/enso/enso.service.d.ts

@@ -0,0 +1,47 @@
+import type { GetParticipateProtocolsQuery } from "../participate/participate.model";
+import { type ProtocolId } from "../protocol";
+import { type EnsoApi, type EnsoSlug } from "./enso.model";
+export declare abstract class EnsoService {
+    #private;
+    static getSlug(protocolId: ProtocolId | string): EnsoSlug | undefined;
+    static getProtocolId(slug: EnsoSlug | string): ProtocolId | undefined;
+    static getCompatibleProtocols(query: GetParticipateProtocolsQuery): Promise<({
+        name: string;
+        url: string;
+        description: string;
+        tags: import("../../../../database/api/.generated").$Enums.ProtocolTag[];
+        icon: string;
+    } & {})[] | null>;
+    static getTokens(chainId: number, slug: EnsoSlug, identifier?: string): Promise<{
+        type: "base" | "defi";
+        chainId: number;
+        address: string;
+        primaryAddress: string;
+        underlyingTokens: {
+            type: "base" | "defi";
+            chainId: number;
+            address: string;
+        }[];
+        apy: number;
+    }[]>;
+    static getQuote(query: EnsoApi<"/v1/shortcuts/quote">["query"]["static"]): Promise<{
+        amountOut: {};
+        gas: string;
+        feeAmount: string[];
+        priceImpact: number;
+    }>;
+    static getTransaction(query: EnsoApi<"/v1/shortcuts/route">["query"]["static"]): Promise<{
+        amountOut: string;
+        gas: string;
+        feeAmount: string[];
+        priceImpact: number;
+        createAt: number;
+        tx: {
+            data: string;
+            from: string;
+            value: string;
+            to: string;
+        };
+    }>;
+    static getDepositSchema(protocolId: ProtocolId): void;
+}

package/dist/src/modules/v4/explorer/explorer.repository.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class ExplorerRepository {
+    static getByChainId(chainId: number): Promise<{
+        id: string;
+        type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+        url: string;
+        chainId: number;
+    }>;
+}

package/dist/src/modules/v4/explorer/explorer.service.d.ts

@@ -0,0 +1,8 @@
+export declare abstract class ExplorerService {
+    static getByChainId(chainId: number): Promise<{
+        id: string;
+        type: import("../../../../database/api/.generated").$Enums.ExplorerType;
+        url: string;
+        chainId: number;
+    }>;
+}

package/dist/src/modules/v4/explorer/index.d.ts

@@ -0,0 +1 @@
+export * from "./explorer.service";

package/dist/src/modules/v4/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./opportunity";
+export * from "./campaign";
+export * from "./token";
+export * from "./apr";

package/dist/src/modules/v4/merklRoot/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./merklRoot.service";
+export * from "./merklRoot.model";
+export * from "./merklRoot.controller";

package/dist/src/modules/v4/merklRoot/merklRoot.controller.d.ts

@@ -0,0 +1,44 @@
+import Elysia from "elysia";
+export declare const MerklRootController: Elysia<"/roots", false, {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+}, {
+    roots: {
+        index: {
+            get: {
+                body: unknown;
+                params: Record<never, string>;
+                query: {
+                    chainId: number;
+                    fromTimestamp: string;
+                    toTimestamp: string;
+                };
+                headers: unknown;
+                response: {
+                    200: {
+                        root: string;
+                        chainId: number;
+                        epoch: number;
+                        timestamp: bigint;
+                    }[];
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/src/modules/v4/merklRoot/merklRoot.model.d.ts

@@ -0,0 +1,6 @@
+export declare const RootByTimestampsDto: import("@sinclair/typebox").TObject<{
+    chainId: import("@sinclair/typebox").TNumber;
+    fromTimestamp: import("@sinclair/typebox").TString;
+    toTimestamp: import("@sinclair/typebox").TString;
+}>;
+export type RootByTimestampModel = typeof RootByTimestampsDto.static;