@evergonlabs/tmi-protocol-api 0.4.1 → 0.7.0

package/dist/staking/index.d.ts

@@ -1,242 +1,233 @@
-import { Env } from "hono";
-import { Factory } from "hono/factory";
-export declare const stakingApi: {
-    name: string;
-    createApp: <E extends Env>(factory: Factory<E>) => import("hono/hono-base").HonoBase<E, 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: {
-                        address: `0x${string}`;
-                        chainId: "11155111" | "31337";
-                    };
-                };
-                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: {
-                        chainId: string | string[];
-                        platform: string | string[];
-                        poolId: 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: {
-                            chainId?: "11155111" | "31337" | undefined;
-                            platform?: `0x${string}` | undefined;
-                            poolId?: string | number | bigint | 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: {
-                            chainId?: "11155111" | "31337" | undefined;
-                            platform?: `0x${string}` | undefined;
-                            poolId?: string | number | bigint | 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[];
-                        platform: string | string[];
-                        stakeId: 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: {
-                        functionName: string;
-                        address: `0x${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: {
-                            chainId?: "11155111" | "31337" | undefined;
-                            platform?: `0x${string}` | undefined;
-                            poolId?: string | number | bigint | 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: {
-                            chainId?: "11155111" | "31337" | undefined;
-                            platform?: `0x${string}` | undefined;
-                            poolId?: string | number | bigint | 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,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAOvC,eAAO,MAAM,UAAU;;gBAET,CAAC,SAAS,GAAG,WAAW,OAAO,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB/C,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

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

@@ -1 +1 @@
-{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../../src/staking/platforms/common/platform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;EAWvB,CAAC;AAEL,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,cAAc,CAAC,QAAQ,CAAC,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CASnH"}
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../../../src/staking/platforms/common/platform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAGpE,eAAO,MAAM,cAAc;;;;;;;iBASL,CAAC;AAEvB,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,cAAc,CAAC,QAAQ,CAAC,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CASnH"}

package/dist/staking/platforms/common/platform.js

@@ -1,26 +1,24 @@
 import { z } from "zod";
 import { unixToDate } from "@evergonlabs/tmi-protocol-utils/date";
 import { AddressSchema, HashSchema, StakingChainId } from "../../../common/index.js";
-import { ISOSchema } from "../../../common/models/date.js";
+import { ISOJson, toISOJson } from "../../../common/models/date.js";
 export const PlatformSchema = z
     .object({
     chainId: StakingChainId,
     transactionHash: HashSchema,
-    createdAt: ISOSchema,
+    createdAt: ISOJson,
     contractAddress: AddressSchema,
     adminAddress: AddressSchema,
-    updatedAt: ISOSchema,
+    updatedAt: ISOJson,
 })
-    .openapi({
-    ref: "Platform",
-});
+    .openapi("Platform");
 export function mapToPlatform(diamond) {
     return {
         chainId: StakingChainId.parse(diamond.chainId),
         transactionHash: diamond.txHash,
         contractAddress: diamond.contractAddress,
         adminAddress: diamond.adminAddress,
-        createdAt: unixToDate(diamond.createdAt).toISOString(),
-        updatedAt: unixToDate(diamond.updatedAt).toISOString(),
+        createdAt: toISOJson(unixToDate(diamond.createdAt)),
+        updatedAt: toISOJson(unixToDate(diamond.updatedAt)),
     };
 }

package/dist/staking/platforms/getPlatform/index.d.ts

@@ -1,26 +1,23 @@
-import { Factory } from "hono/factory";
-import { Env } from "hono";
-import { ITag } from "../../../common/tag.js";
-export declare function createGetPlatformApp<E extends Env>(factory: Factory<E>, tag: ITag): import("hono/hono-base").HonoBase<E, {
-    "/v0": {
+export declare const GetPlatformController: import("../../../common/controller.js").IController<import("hono/hono-base").HonoBase<import("../../../common/context.js").AppContext, import("hono/types").BlankSchema | import("hono/types").MergeSchemaPath<{
+    "/": {
         $get: {
             input: {
                 query: {
-                    address: `0x${string}`;
-                    chainId: "11155111" | "31337";
+                    chainId: string | string[];
+                    address: string | string[];
                 };
             };
             output: {
-                chainId: "11155111" | "31337";
-                createdAt: string;
+                chainId: 11155111 | 31337;
+                transactionHash: `0x${string}`;
+                createdAt: string & import("zod").$brand<"ISO">;
                 contractAddress: `0x${string}`;
                 adminAddress: `0x${string}`;
-                updatedAt: string;
-                transactionHash: `0x${string}`;
+                updatedAt: string & import("zod").$brand<"ISO">;
             };
             outputFormat: "json";
             status: 200;
         };
     };
-}, "/">;
+}, "/v0">, "/">>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/staking/platforms/getPlatform/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAC3B,OAAO,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAE9C,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;QAEjF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/staking/platforms/getPlatform/index.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;gBAEhC,CAAC"}

package/dist/staking/platforms/getPlatform/index.js

@@ -1,4 +1,5 @@
-import { createGetPlatformV0App } from "./v0/getPlatform.js";
-export function createGetPlatformApp(factory, tag) {
-    return factory.createApp().get("/v0", ...createGetPlatformV0App(factory, tag));
-}
+import { createController } from "../../../common/controller.js";
+import { GetPlatformV0 } from "./v0/getPlatform.js";
+export const GetPlatformController = createController({
+    build: (factory) => factory.createApp().route("/v0", GetPlatformV0.build(factory)),
+});