@evergonlabs/tmi-protocol-api 0.5.0 → 0.8.0

package/dist/next/fractions/sales/createNftFractions.schema.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+import { AddressSchema, FractionsChainId } from "../../../common/index.js";
+import { Int256BigInt } from "../../../common/int256.js";
+import { ISODate } from "../../../common/models/date.js";
+/**
+ * Time boundary schema for sale period
+ */
+export const TimeBoundarySchema = z.object({
+    start: ISODate().describe("Sale start date"),
+    end: ISODate().describe("Sale end date"),
+});
+/**
+ * Capitalization schema for sale limits
+ */
+export const CapitalizationSchema = z.object({
+    soft: Int256BigInt(z.bigint().positive()).describe("Soft cap - minimum funding target"),
+    hard: Int256BigInt(z.bigint().positive()).describe("Hard cap - maximum funding limit"),
+    softPerAccount: Int256BigInt(z.bigint().positive()).optional().describe("Optional soft cap per account"),
+    hardPerAccount: Int256BigInt(z.bigint().positive()).optional().describe("Optional hard cap per account"),
+});
+/**
+ * NFT details schema for ERC-721 tokens to be wrapped
+ */
+export const NftDetailsSchema = z.object({
+    contractAddress: AddressSchema.describe("ERC-721 contract address"),
+    tokenIds: z.array(Int256BigInt(z.bigint().nonnegative())).nonempty().describe("Token IDs to wrap"),
+});
+/**
+ * Fraction configuration schema
+ */
+export const FractionSchema = z.object({
+    name: z.string().min(1).describe("Fraction token name"),
+    symbol: z.string().min(1).max(11).describe("Fraction token symbol"),
+    amount: Int256BigInt(z.bigint().positive()).describe("Total supply of fractions to mint"),
+});
+/**
+ * Funding configuration schema for payment tokens
+ */
+export const FundingSchema = z.object({
+    token: AddressSchema.describe("Payment token address (e.g., USDC)"),
+    amountPerPacket: Int256BigInt(z.bigint().positive()).describe("Amount of payment token per packet"),
+});
+/**
+ * Vesting configuration schema
+ */
+export const VestingSchema = z.object({
+    cliff: ISODate().describe("Cliff date after which vesting begins"),
+    totalVestingPeriod: z.number().positive().describe("Total vesting period in seconds"),
+    portionPeriod: z.number().positive().describe("Period between vesting portions in seconds"),
+});
+/**
+ * Request schema for creating NFT fractions
+ */
+export const CreateNftFractionsRequestSchema = z
+    .object({
+    chainId: FractionsChainId.describe("Chain ID where the market is deployed"),
+    market: AddressSchema.describe("Address of the NFT Fractions market"),
+    nft: NftDetailsSchema.describe("NFT details to wrap"),
+    fractions: FractionSchema.describe("Fraction token configuration"),
+    timeBoundary: TimeBoundarySchema.describe("Purchase time window"),
+    cap: CapitalizationSchema.describe("Capitalization limits"),
+    funding: z.array(FundingSchema).nonempty().describe("Payment token configuration"),
+    amountOfPacketsPerFraction: Int256BigInt(z.bigint().positive()).describe("Number of funding packets per fraction"),
+    vesting: VestingSchema.optional().describe("Optional vesting configuration"),
+    refundAddress: AddressSchema.describe("Address to receive refunds"),
+})
+    .openapi("CreateNftFractionsRequestSchema");

package/dist/next/fractions/sales/index.d.ts

@@ -0,0 +1,55 @@
+export declare const SalesController: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    chainId: unknown;
+                    market: string;
+                    nft: {
+                        contractAddress: string;
+                        tokenIds: string[];
+                    };
+                    fractions: {
+                        name: string;
+                        symbol: string;
+                        amount: string;
+                    };
+                    timeBoundary: {
+                        start: string;
+                        end: string;
+                    };
+                    cap: {
+                        soft: string;
+                        hard: string;
+                        softPerAccount?: string | undefined;
+                        hardPerAccount?: string | undefined;
+                    };
+                    funding: {
+                        token: string;
+                        amountPerPacket: string;
+                    }[];
+                    amountOfPacketsPerFraction: string;
+                    refundAddress: string;
+                    vesting?: {
+                        cliff: string;
+                        totalVestingPeriod: number;
+                        portionPeriod: number;
+                    } | undefined;
+                };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
+                };
+            };
+            outputFormat: "json";
+            status: import("hono/utils/http-status").ContentfulStatusCode;
+        };
+    };
+}, "/nftFractions">, "/">>;
+//# sourceMappingURL=index.d.ts.map

package/dist/next/fractions/sales/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/next/fractions/sales/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAE1B,CAAC"}

package/dist/next/fractions/sales/index.js

@@ -0,0 +1,5 @@
+import { createController } from "../../../common/controller.js";
+import { CreateNftFractionsV0 } from "./createNftFractions.routes.js";
+export const SalesController = createController({
+    build: (factory) => factory.createApp().route("/nftFractions", CreateNftFractionsV0.build(factory)),
+});

package/dist/staking/index.d.ts

@@ -1,242 +1,233 @@
-import { Factory } from "hono/factory";
-import { AppContext } from "../common/context.js";
-export declare const stakingApi: {
-    name: string;
-    createApp: (factory: Factory<AppContext>) => import("hono/hono-base").HonoBase<AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
-        "/v0": {
-            $get: {
-                input: {
-                    query: {
-                        chainId: "11155111" | "31337";
-                        address: `0x${string}`;
-                    };
-                };
-                output: {
-                    chainId: "11155111" | "31337";
-                    createdAt: string;
-                    contractAddress: `0x${string}`;
-                    adminAddress: `0x${string}`;
-                    updatedAt: string;
-                    transactionHash: `0x${string}`;
+export declare const StakingApi: import("../common/controller.js").IApi<import("hono/hono-base").HonoBase<import("../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    address: string | string[];
                 };
-                outputFormat: "json";
-                status: 200;
             };
+            output: {
+                chainId: 11155111 | 31337;
+                transactionHash: `0x${string}`;
+                createdAt: string & import("zod").$brand<"ISO">;
+                contractAddress: `0x${string}`;
+                adminAddress: `0x${string}`;
+                updatedAt: string & import("zod").$brand<"ISO">;
+            };
+            outputFormat: "json";
+            status: 200;
         };
-    }, "/get"> | import("hono/types").MergeSchemaPath<{
-        "/v0": {
-            $post: {
-                input: {
-                    json: {
-                        filter: {
-                            chainId?: "11155111" | "31337" | undefined;
-                            owner?: `0x${string}` | undefined;
-                        };
-                        page: {
-                            skip: number;
-                            limit: number;
-                        };
+    };
+}, "/v0">, "/get"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    page: {
+                        skip: number;
+                        limit: number;
+                    };
+                    filter: {
+                        chainId?: unknown;
+                        owner?: string | undefined;
                     };
                 };
-                output: {
-                    chainId: "11155111" | "31337";
-                    createdAt: string;
-                    contractAddress: `0x${string}`;
-                    adminAddress: `0x${string}`;
-                    updatedAt: string;
-                    transactionHash: `0x${string}`;
-                }[];
-                outputFormat: "json";
-                status: 200;
             };
+            output: {
+                chainId: 11155111 | 31337;
+                transactionHash: `0x${string}`;
+                createdAt: string & import("zod").$brand<"ISO">;
+                contractAddress: `0x${string}`;
+                adminAddress: `0x${string}`;
+                updatedAt: string & import("zod").$brand<"ISO">;
+            }[];
+            outputFormat: "json";
+            status: 200;
         };
-    }, "/search">, "/platforms"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
-        "/v0": {
-            $post: {
-                input: {
-                    json: {
-                        filter: {
-                            chainId?: "11155111" | "31337" | undefined;
-                            platform?: `0x${string}` | undefined;
-                        };
-                        page: {
-                            skip: number;
-                            limit: number;
-                        };
+    };
+}, "/v0">, "/search">, "/platforms"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    page: {
+                        skip: number;
+                        limit: number;
+                    };
+                    filter: {
+                        chainId?: unknown;
+                        platform?: string | undefined;
                     };
                 };
-                output: never;
-                outputFormat: "json";
-                status: 200;
             };
+            output: never;
+            outputFormat: "json";
+            status: 200;
         };
-    }, "/searchPools"> | import("hono/types").MergeSchemaPath<{
-        "/v0": {
-            $get: {
-                input: {
-                    query: {
-                        poolId: string | string[];
-                        chainId: string | string[];
-                        platform: string | string[];
-                    };
+    };
+}, "/v0">, "/searchPools"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    poolId: string | string[];
+                    platform: string | string[];
                 };
-                output: never;
-                outputFormat: "json";
-                status: 200;
             };
+            output: never;
+            outputFormat: "json";
+            status: 200;
         };
-    }, "/getPool">, "/pools"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
-        "/v0": {
-            $post: {
-                input: {
-                    json: {
-                        filter: {
-                            poolId?: string | number | bigint | undefined;
-                            chainId?: "11155111" | "31337" | undefined;
-                            platform?: `0x${string}` | undefined;
-                            owner?: `0x${string}` | undefined;
-                        };
-                        page: {
-                            skip: number;
-                            limit: number;
-                        };
+    };
+}, "/v0">, "/getPool">, "/pools"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    page: {
+                        skip: number;
+                        limit: number;
+                    };
+                    filter: {
+                        chainId?: unknown;
+                        owner?: string | undefined;
+                        platform?: string | undefined;
+                        poolId?: string | undefined;
                     };
                 };
-                output: never;
-                outputFormat: "json";
-                status: 200;
             };
+            output: never;
+            outputFormat: "json";
+            status: 200;
         };
-    }, "/searchStakes"> | import("hono/types").MergeSchemaPath<{
-        "/v0": {
-            $post: {
-                input: {
-                    json: {
-                        filter: {
-                            poolId?: string | number | bigint | undefined;
-                            chainId?: "11155111" | "31337" | undefined;
-                            platform?: `0x${string}` | undefined;
-                            owner?: `0x${string}` | undefined;
-                        };
-                        page: {
-                            skip: number;
-                            limit: number;
-                        };
+    };
+}, "/v0">, "/searchStakes"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    page: {
+                        skip: number;
+                        limit: number;
+                    };
+                    filter: {
+                        chainId?: unknown;
+                        owner?: string | undefined;
+                        platform?: string | undefined;
+                        poolId?: string | undefined;
                     };
                 };
-                output: never;
-                outputFormat: "json";
-                status: 200;
             };
+            output: never;
+            outputFormat: "json";
+            status: 200;
         };
-    }, "/searchStakeEvents"> | import("hono/types").MergeSchemaPath<{
-        "/v0": {
-            $get: {
-                input: {
-                    query: {
-                        chainId: string | string[];
-                        stakeId: string | string[];
-                        platform: string | string[];
-                    };
+    };
+}, "/v0">, "/searchStakeEvents"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {
+                query: {
+                    chainId: string | string[];
+                    platform: string | string[];
+                    stakeId: string | string[];
                 };
-                output: never;
-                outputFormat: "json";
-                status: 200;
             };
+            output: never;
+            outputFormat: "json";
+            status: 200;
         };
-    }, "/getStake">, "/stakes"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
-        "/v0": {
-            $get: {
-                input: {};
-                output: ({
-                    name: string;
-                    value: `0x${string}`;
-                } | {
-                    name: string;
-                    value: `0x${string}`;
-                } | {
-                    name: string;
-                    value: `0x${string}`;
-                } | {
-                    name: string;
-                    value: `0x${string}`;
-                })[];
-                outputFormat: "json";
-                status: 200;
-            };
+    };
+}, "/v0">, "/getStake">, "/stakes"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $get: {
+            input: {};
+            output: ({
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            } | {
+                name: string;
+                value: `0x${string}`;
+            })[];
+            outputFormat: "json";
+            status: 200;
         };
-    }, "/getRoles"> | import("hono/types").MergeSchemaPath<{
-        "/v0": {
-            $post: {
-                input: {
-                    json: {
-                        platform: `0x${string}`;
-                        addresses: `0x${string}`[];
-                        role: `0x${string}` | import("@evergonlabs/tmi-protocol-staking-sdk").StakingRole;
-                    };
+    };
+}, "/v0">, "/getRoles"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    platform: string;
+                    addresses: string[];
+                    role: string;
                 };
-                output: {
-                    data: `0x${string}`;
-                    to: `0x${string}`;
-                    details: {
-                        address: `0x${string}`;
-                        functionName: string;
-                        abi: any[];
-                        args: any[];
-                    };
+            };
+            output: {
+                data: `0x${string}`;
+                to: `0x${string}`;
+                details: {
+                    functionName: string;
+                    address: `0x${string}`;
+                    abi: any[];
+                    args: any[];
                 };
-                outputFormat: "json";
-                status: 200;
             };
+            outputFormat: "json";
+            status: 200;
         };
-    }, "/grantRole"> | import("hono/types").MergeSchemaPath<{
-        "/v0": {
-            $post: {
-                input: {
-                    json: {
-                        filter: {
-                            poolId?: string | number | bigint | undefined;
-                            chainId?: "11155111" | "31337" | undefined;
-                            platform?: `0x${string}` | undefined;
-                            owner?: `0x${string}` | undefined;
-                        };
-                        page: {
-                            skip: number;
-                            limit: number;
-                        };
+    };
+}, "/v0">, "/grantRole"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    page: {
+                        skip: number;
+                        limit: number;
+                    };
+                    filter: {
+                        chainId?: unknown;
+                        owner?: string | undefined;
+                        platform?: string | undefined;
+                        poolId?: string | undefined;
                     };
                 };
-                output: never;
-                outputFormat: "json";
-                status: 200;
             };
+            output: never;
+            outputFormat: "json";
+            status: 200;
         };
-    }, "/searchRoles"> | import("hono/types").MergeSchemaPath<{
-        "/v0": {
-            $post: {
-                input: {
-                    json: {
-                        filter: {
-                            poolId?: string | number | bigint | undefined;
-                            chainId?: "11155111" | "31337" | undefined;
-                            platform?: `0x${string}` | undefined;
-                            owner?: `0x${string}` | undefined;
-                        };
-                        page: {
-                            skip: number;
-                            limit: number;
-                        };
+    };
+}, "/v0">, "/searchRoles"> | import("hono/types").MergeSchemaPath<import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
+        $post: {
+            input: {
+                json: {
+                    page: {
+                        skip: number;
+                        limit: number;
+                    };
+                    filter: {
+                        chainId?: unknown;
+                        owner?: string | undefined;
+                        platform?: string | undefined;
+                        poolId?: string | undefined;
                     };
                 };
-                output: never;
-                outputFormat: "json";
-                status: 200;
             };
+            output: never;
+            outputFormat: "json";
+            status: 200;
         };
-    }, "/searchRoleEvents">, "/roles">, "/staking">, "/">;
-    config: {
-        title: string;
-        description: string;
     };
-};
+}, "/v0">, "/searchRoleEvents">, "/roles">, "/">>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/staking/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAMvC,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD,eAAO,MAAM,UAAU;;yBAEA,OAAO,CAAC,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBzC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/staking/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAUrB,CAAC"}

package/dist/staking/index.js

@@ -1,20 +1,15 @@
-import { createRolesApp } from "./roles/index.js";
-import { createPlatformsApp } from "./platforms/index.js";
-import { createStakesApp } from "./stakes/index.js";
-import { createPoolsApp } from "./pools/index.js";
-import { createApiConfig } from "../common/app.js";
-export const stakingApi = {
-    name: "Staking API",
-    createApp: (factory) => factory
+import { createApi } from "../common/controller.js";
+import { PlatformsController } from "./platforms/index.js";
+import { PoolsController } from "./pools/index.js";
+import { RolesController } from "./roles/index.js";
+import { StakesController } from "./stakes/index.js";
+export const StakingApi = createApi({
+    title: "Staking API",
+    description: "Staking API for Decentralized finance",
+    build: (factory) => factory
         .createApp()
-        .route("/staking", factory
-        .createApp()
-        .route("/platforms", createPlatformsApp(factory))
-        .route("/pools", createPoolsApp(factory))
-        .route("/stakes", createStakesApp(factory))
-        .route("/roles", createRolesApp(factory))),
-    config: createApiConfig({
-        title: "Staking API",
-        description: "Staking API for Decentralized finance",
-    }),
-};
+        .route("/platforms", PlatformsController.build(factory))
+        .route("/pools", PoolsController.build(factory))
+        .route("/stakes", StakesController.build(factory))
+        .route("/roles", RolesController.build(factory)),
+});

package/dist/staking/platforms/common/platform.d.ts

@@ -1,26 +1,12 @@
 import { z } from "zod";
 import { indexerSchemas } from "../../../common/indexer/schemas.js";
 export declare const PlatformSchema: z.ZodObject<{
-    chainId: z.ZodType<"11155111" | "31337", z.ZodTypeDef, "11155111" | "31337">;
-    transactionHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    createdAt: z.ZodString;
-    contractAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    adminAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
-    updatedAt: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    chainId: "11155111" | "31337";
-    createdAt: string;
-    contractAddress: `0x${string}`;
-    adminAddress: `0x${string}`;
-    updatedAt: string;
-    transactionHash: `0x${string}`;
-}, {
-    chainId: "11155111" | "31337";
-    createdAt: string;
-    contractAddress: `0x${string}`;
-    adminAddress: `0x${string}`;
-    updatedAt: string;
-    transactionHash: `0x${string}`;
-}>;
+    chainId: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodUnion<[z.ZodLiteral<11155111 | 31337>, z.ZodLiteral<11155111 | 31337>, ...z.ZodLiteral<11155111 | 31337>[]]>>;
+    transactionHash: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    createdAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+    contractAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    adminAddress: z.ZodPipe<z.ZodString & z.ZodType<`0x${string}`, string, z.core.$ZodTypeInternals<`0x${string}`, string>>, z.ZodTransform<`0x${string}`, `0x${string}`>>;
+    updatedAt: z.core.$ZodBranded<z.ZodString, "ISO", "out">;
+}, z.core.$strip>;
 export declare function mapToPlatform(diamond: typeof indexerSchemas.diamonds.$inferSelect): z.output<typeof PlatformSchema>;
 //# sourceMappingURL=platform.d.ts.map