@lagoon-protocol/lagoon-mcp 0.1.0

package/dist/utils/tool-handler.js

@@ -0,0 +1,59 @@
+/**
+ * Type-Safe Tool Handler Utilities
+ *
+ * Provides type-safe wrappers for MCP tool handlers to eliminate
+ * unsafe type assertions (as never) throughout the codebase.
+ */
+/**
+ * Creates a type-safe tool handler that validates input against a schema
+ *
+ * @param handler - The tool handler function with proper typing
+ * @param schema - Zod schema for runtime validation (handles schemas with defaults)
+ * @returns A wrapper function that safely handles unknown arguments
+ *
+ * @example
+ * const safeHandler = createToolHandler(
+ *   executeQueryGraphQL,
+ *   queryGraphQLInputSchema
+ * );
+ * await safeHandler(unknownArgs);
+ */
+export function createToolHandler(handler, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+schema) {
+    return async (args) => {
+        try {
+            // Validate and parse arguments using the provided schema
+            // schema.parse returns TOutput (with defaults applied)
+            const validatedArgs = schema.parse(args ?? {});
+            // Call the handler with properly typed arguments
+            return await handler(validatedArgs);
+        }
+        catch (error) {
+            // If validation fails, return an error result
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Invalid input: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    };
+}
+/**
+ * Type-safe wrapper for tool handlers that don't need explicit validation
+ *
+ * @param handler - The tool handler function
+ * @returns A wrapper function that safely casts unknown arguments
+ *
+ * Note: Use createToolHandler with schema validation instead when possible
+ */
+export function wrapToolHandler(handler) {
+    return async (args) => {
+        return await handler(args);
+    };
+}
+//# sourceMappingURL=tool-handler.js.map

package/dist/utils/tool-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-handler.js","sourceRoot":"","sources":["../../src/utils/tool-handler.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,iBAAiB,CAC/B,OAAoD;AACpD,8DAA8D;AAC9D,MAAuC;IAEvC,OAAO,KAAK,EAAE,IAAa,EAA2B,EAAE;QACtD,IAAI,CAAC;YACH,yDAAyD;YACzD,uDAAuD;YACvD,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;YAE/C,iDAAiD;YACjD,OAAO,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC;QACtC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,8CAA8C;YAC9C,OAAO;gBACL,OAAO,EAAE;oBACP;wBACE,IAAI,EAAE,MAAM;wBACZ,IAAI,EAAE,kBAAkB,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;qBACjF;iBACF;gBACD,OAAO,EAAE,IAAI;aACd,CAAC;QACJ,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAC7B,OAA8C;IAE9C,OAAO,KAAK,EAAE,IAAa,EAA2B,EAAE;QACtD,OAAO,MAAM,OAAO,CAAC,IAAS,CAAC,CAAC;IAClC,CAAC,CAAC;AACJ,CAAC"}

package/dist/utils/tool-response.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared Response Formatter for MCP Tools
+ *
+ * Centralized response formatting logic for all MCP tools.
+ * Provides consistent JSON formatting and success response structure.
+ */
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Create a standardized success response with JSON-formatted data
+ *
+ * @param data - The data to return in the response
+ * @param prettyPrint - Whether to pretty-print the JSON (default: true)
+ * @returns Standardized success response
+ */
+export declare function createSuccessResponse(data: unknown, prettyPrint?: boolean): CallToolResult;
+//# sourceMappingURL=tool-response.d.ts.map

package/dist/utils/tool-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-response.d.ts","sourceRoot":"","sources":["../../src/utils/tool-response.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEpE;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,WAAW,UAAO,GAAG,cAAc,CAUvF"}

package/dist/utils/tool-response.js

@@ -0,0 +1,25 @@
+/**
+ * Shared Response Formatter for MCP Tools
+ *
+ * Centralized response formatting logic for all MCP tools.
+ * Provides consistent JSON formatting and success response structure.
+ */
+/**
+ * Create a standardized success response with JSON-formatted data
+ *
+ * @param data - The data to return in the response
+ * @param prettyPrint - Whether to pretty-print the JSON (default: true)
+ * @returns Standardized success response
+ */
+export function createSuccessResponse(data, prettyPrint = true) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: prettyPrint ? JSON.stringify(data, null, 2) : JSON.stringify(data),
+            },
+        ],
+        isError: false,
+    };
+}
+//# sourceMappingURL=tool-response.js.map

package/dist/utils/tool-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-response.js","sourceRoot":"","sources":["../../src/utils/tool-response.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAa,EAAE,WAAW,GAAG,IAAI;IACrE,OAAO;QACL,OAAO,EAAE;YACP;gBACE,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;aACzE;SACF;QACD,OAAO,EAAE,KAAK;KACf,CAAC;AACJ,CAAC"}

package/dist/utils/validators.d.ts

@@ -0,0 +1,359 @@
+/**
+ * Input Validation Schemas
+ *
+ * Zod schemas for runtime type validation of tool inputs
+ */
+import { z } from 'zod';
+/**
+ * Reusable validation schemas
+ */
+export declare const ethereumAddressSchema: z.ZodString;
+export declare const chainIdSchema: z.ZodNumber;
+export declare const paginationFirstSchema: z.ZodDefault<z.ZodNumber>;
+export declare const paginationSkipSchema: z.ZodDefault<z.ZodNumber>;
+/**
+ * Tool-specific validation schemas
+ */
+export declare const queryGraphQLInputSchema: z.ZodObject<{
+    query: z.ZodString;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    variables?: Record<string, unknown> | undefined;
+}, {
+    query: string;
+    variables?: Record<string, unknown> | undefined;
+}>;
+export declare const getVaultDataInputSchema: z.ZodObject<{
+    vaultAddress: z.ZodString;
+    chainId: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    vaultAddress: string;
+    chainId: number;
+}, {
+    vaultAddress: string;
+    chainId: number;
+}>;
+export declare const getUserPortfolioInputSchema: z.ZodObject<{
+    userAddress: z.ZodString;
+    responseFormat: z.ZodDefault<z.ZodEnum<["list", "summary", "full"]>>;
+}, "strip", z.ZodTypeAny, {
+    userAddress: string;
+    responseFormat: "full" | "list" | "summary";
+}, {
+    userAddress: string;
+    responseFormat?: "full" | "list" | "summary" | undefined;
+}>;
+export declare const searchVaultsInputSchema: z.ZodObject<{
+    filters: z.ZodOptional<z.ZodObject<{
+        assetSymbol_eq: z.ZodOptional<z.ZodString>;
+        assetSymbol_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        assetId_eq: z.ZodOptional<z.ZodString>;
+        assetId_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        chainId_eq: z.ZodOptional<z.ZodNumber>;
+        chainId_in: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+        state_totalAssetsUsd_gte: z.ZodOptional<z.ZodNumber>;
+        state_totalAssetsUsd_lte: z.ZodOptional<z.ZodNumber>;
+        curatorIds_contains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        curatorIds_contains_any: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        isVisible_eq: z.ZodOptional<z.ZodBoolean>;
+        address_eq: z.ZodOptional<z.ZodString>;
+        address_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        symbol_eq: z.ZodOptional<z.ZodString>;
+        symbol_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        integratorId_eq: z.ZodOptional<z.ZodString>;
+        integratorId_in: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        assetSymbol_eq?: string | undefined;
+        assetSymbol_in?: string[] | undefined;
+        assetId_eq?: string | undefined;
+        assetId_in?: string[] | undefined;
+        chainId_eq?: number | undefined;
+        chainId_in?: number[] | undefined;
+        state_totalAssetsUsd_gte?: number | undefined;
+        state_totalAssetsUsd_lte?: number | undefined;
+        curatorIds_contains?: string[] | undefined;
+        curatorIds_contains_any?: string[] | undefined;
+        isVisible_eq?: boolean | undefined;
+        address_eq?: string | undefined;
+        address_in?: string[] | undefined;
+        symbol_eq?: string | undefined;
+        symbol_in?: string[] | undefined;
+        integratorId_eq?: string | undefined;
+        integratorId_in?: string[] | undefined;
+    }, {
+        assetSymbol_eq?: string | undefined;
+        assetSymbol_in?: string[] | undefined;
+        assetId_eq?: string | undefined;
+        assetId_in?: string[] | undefined;
+        chainId_eq?: number | undefined;
+        chainId_in?: number[] | undefined;
+        state_totalAssetsUsd_gte?: number | undefined;
+        state_totalAssetsUsd_lte?: number | undefined;
+        curatorIds_contains?: string[] | undefined;
+        curatorIds_contains_any?: string[] | undefined;
+        isVisible_eq?: boolean | undefined;
+        address_eq?: string | undefined;
+        address_in?: string[] | undefined;
+        symbol_eq?: string | undefined;
+        symbol_in?: string[] | undefined;
+        integratorId_eq?: string | undefined;
+        integratorId_in?: string[] | undefined;
+    }>>;
+    pagination: z.ZodOptional<z.ZodObject<{
+        first: z.ZodDefault<z.ZodNumber>;
+        skip: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        first: number;
+        skip: number;
+    }, {
+        first?: number | undefined;
+        skip?: number | undefined;
+    }>>;
+    orderBy: z.ZodDefault<z.ZodString>;
+    orderDirection: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+    responseFormat: z.ZodDefault<z.ZodEnum<["list", "summary", "full"]>>;
+    maxResults: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    responseFormat: "full" | "list" | "summary";
+    orderBy: string;
+    orderDirection: "asc" | "desc";
+    maxResults: number;
+    filters?: {
+        assetSymbol_eq?: string | undefined;
+        assetSymbol_in?: string[] | undefined;
+        assetId_eq?: string | undefined;
+        assetId_in?: string[] | undefined;
+        chainId_eq?: number | undefined;
+        chainId_in?: number[] | undefined;
+        state_totalAssetsUsd_gte?: number | undefined;
+        state_totalAssetsUsd_lte?: number | undefined;
+        curatorIds_contains?: string[] | undefined;
+        curatorIds_contains_any?: string[] | undefined;
+        isVisible_eq?: boolean | undefined;
+        address_eq?: string | undefined;
+        address_in?: string[] | undefined;
+        symbol_eq?: string | undefined;
+        symbol_in?: string[] | undefined;
+        integratorId_eq?: string | undefined;
+        integratorId_in?: string[] | undefined;
+    } | undefined;
+    pagination?: {
+        first: number;
+        skip: number;
+    } | undefined;
+}, {
+    responseFormat?: "full" | "list" | "summary" | undefined;
+    filters?: {
+        assetSymbol_eq?: string | undefined;
+        assetSymbol_in?: string[] | undefined;
+        assetId_eq?: string | undefined;
+        assetId_in?: string[] | undefined;
+        chainId_eq?: number | undefined;
+        chainId_in?: number[] | undefined;
+        state_totalAssetsUsd_gte?: number | undefined;
+        state_totalAssetsUsd_lte?: number | undefined;
+        curatorIds_contains?: string[] | undefined;
+        curatorIds_contains_any?: string[] | undefined;
+        isVisible_eq?: boolean | undefined;
+        address_eq?: string | undefined;
+        address_in?: string[] | undefined;
+        symbol_eq?: string | undefined;
+        symbol_in?: string[] | undefined;
+        integratorId_eq?: string | undefined;
+        integratorId_in?: string[] | undefined;
+    } | undefined;
+    pagination?: {
+        first?: number | undefined;
+        skip?: number | undefined;
+    } | undefined;
+    orderBy?: string | undefined;
+    orderDirection?: "asc" | "desc" | undefined;
+    maxResults?: number | undefined;
+}>;
+export declare const getVaultPerformanceInputSchema: z.ZodObject<{
+    vaultAddress: z.ZodString;
+    chainId: z.ZodNumber;
+    timeRange: z.ZodEnum<["7d", "30d", "90d", "1y"]>;
+    includeSDKCalculations: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    responseFormat: z.ZodDefault<z.ZodEnum<["summary", "detailed"]>>;
+}, "strip", z.ZodTypeAny, {
+    vaultAddress: string;
+    chainId: number;
+    responseFormat: "summary" | "detailed";
+    timeRange: "7d" | "30d" | "90d" | "1y";
+    includeSDKCalculations: boolean;
+}, {
+    vaultAddress: string;
+    chainId: number;
+    timeRange: "7d" | "30d" | "90d" | "1y";
+    responseFormat?: "summary" | "detailed" | undefined;
+    includeSDKCalculations?: boolean | undefined;
+}>;
+export declare const getTransactionsInputSchema: z.ZodObject<{
+    vaultAddress: z.ZodString;
+    chainId: z.ZodNumber;
+    transactionTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["SettleDeposit", "SettleRedeem", "DepositRequest", "RedeemRequest", "NewTotalAssetsUpdated", "TotalAssetsUpdated", "PeriodSummary", "DepositSync", "DepositRequestCanceled", "RatesUpdated", "StateUpdated"]>, "many">>;
+    pagination: z.ZodOptional<z.ZodObject<{
+        first: z.ZodDefault<z.ZodNumber>;
+        skip: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        first: number;
+        skip: number;
+    }, {
+        first?: number | undefined;
+        skip?: number | undefined;
+    }>>;
+    orderBy: z.ZodDefault<z.ZodEnum<["blockNumber", "timestamp", "id", "chainId"]>>;
+    orderDirection: z.ZodDefault<z.ZodEnum<["asc", "desc"]>>;
+    responseFormat: z.ZodDefault<z.ZodEnum<["summary", "list", "detailed"]>>;
+}, "strip", z.ZodTypeAny, {
+    vaultAddress: string;
+    chainId: number;
+    responseFormat: "list" | "summary" | "detailed";
+    orderBy: "chainId" | "blockNumber" | "timestamp" | "id";
+    orderDirection: "asc" | "desc";
+    pagination?: {
+        first: number;
+        skip: number;
+    } | undefined;
+    transactionTypes?: ("SettleDeposit" | "SettleRedeem" | "DepositRequest" | "RedeemRequest" | "NewTotalAssetsUpdated" | "TotalAssetsUpdated" | "PeriodSummary" | "DepositSync" | "DepositRequestCanceled" | "RatesUpdated" | "StateUpdated")[] | undefined;
+}, {
+    vaultAddress: string;
+    chainId: number;
+    responseFormat?: "list" | "summary" | "detailed" | undefined;
+    pagination?: {
+        first?: number | undefined;
+        skip?: number | undefined;
+    } | undefined;
+    orderBy?: "chainId" | "blockNumber" | "timestamp" | "id" | undefined;
+    orderDirection?: "asc" | "desc" | undefined;
+    transactionTypes?: ("SettleDeposit" | "SettleRedeem" | "DepositRequest" | "RedeemRequest" | "NewTotalAssetsUpdated" | "TotalAssetsUpdated" | "PeriodSummary" | "DepositSync" | "DepositRequestCanceled" | "RatesUpdated" | "StateUpdated")[] | undefined;
+}>;
+export declare const compareVaultsInputSchema: z.ZodObject<{
+    vaultAddresses: z.ZodArray<z.ZodString, "many">;
+    chainId: z.ZodNumber;
+    responseFormat: z.ZodDefault<z.ZodEnum<["summary", "full"]>>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    responseFormat: "full" | "summary";
+    vaultAddresses: string[];
+}, {
+    chainId: number;
+    vaultAddresses: string[];
+    responseFormat?: "full" | "summary" | undefined;
+}>;
+export declare const priceHistoryInputSchema: z.ZodObject<{
+    vaultAddress: z.ZodString;
+    chainId: z.ZodNumber;
+    timeRange: z.ZodEnum<["7d", "30d", "90d", "1y", "all"]>;
+    responseFormat: z.ZodDefault<z.ZodEnum<["summary", "detailed"]>>;
+}, "strip", z.ZodTypeAny, {
+    vaultAddress: string;
+    chainId: number;
+    responseFormat: "summary" | "detailed";
+    timeRange: "all" | "7d" | "30d" | "90d" | "1y";
+}, {
+    vaultAddress: string;
+    chainId: number;
+    timeRange: "all" | "7d" | "30d" | "90d" | "1y";
+    responseFormat?: "summary" | "detailed" | undefined;
+}>;
+export declare const exportDataInputSchema: z.ZodObject<{
+    vaultAddresses: z.ZodArray<z.ZodString, "many">;
+    chainId: z.ZodNumber;
+    dataType: z.ZodEnum<["vaults", "transactions", "price_history", "performance"]>;
+    format: z.ZodEnum<["csv", "json"]>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    vaultAddresses: string[];
+    dataType: "price_history" | "vaults" | "transactions" | "performance";
+    format: "csv" | "json";
+}, {
+    chainId: number;
+    vaultAddresses: string[];
+    dataType: "price_history" | "vaults" | "transactions" | "performance";
+    format: "csv" | "json";
+}>;
+export declare const analyzeRiskInputSchema: z.ZodObject<{
+    vaultAddress: z.ZodString;
+    chainId: z.ZodNumber;
+    responseFormat: z.ZodDefault<z.ZodEnum<["score", "summary", "detailed"]>>;
+}, "strip", z.ZodTypeAny, {
+    vaultAddress: string;
+    chainId: number;
+    responseFormat: "summary" | "detailed" | "score";
+}, {
+    vaultAddress: string;
+    chainId: number;
+    responseFormat?: "summary" | "detailed" | "score" | undefined;
+}>;
+export declare const predictYieldInputSchema: z.ZodObject<{
+    vaultAddress: z.ZodString;
+    chainId: z.ZodNumber;
+    timeRange: z.ZodEnum<["7d", "30d", "90d"]>;
+    responseFormat: z.ZodDefault<z.ZodEnum<["quick", "detailed"]>>;
+}, "strip", z.ZodTypeAny, {
+    vaultAddress: string;
+    chainId: number;
+    responseFormat: "detailed" | "quick";
+    timeRange: "7d" | "30d" | "90d";
+}, {
+    vaultAddress: string;
+    chainId: number;
+    timeRange: "7d" | "30d" | "90d";
+    responseFormat?: "detailed" | "quick" | undefined;
+}>;
+export declare const optimizePortfolioInputSchema: z.ZodObject<{
+    vaultAddresses: z.ZodArray<z.ZodString, "many">;
+    chainId: z.ZodNumber;
+    currentPositions: z.ZodArray<z.ZodObject<{
+        vaultAddress: z.ZodString;
+        valueUsd: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        vaultAddress: string;
+        valueUsd: number;
+    }, {
+        vaultAddress: string;
+        valueUsd: number;
+    }>, "many">;
+    strategy: z.ZodDefault<z.ZodEnum<["equal_weight", "risk_parity", "max_sharpe", "min_variance"]>>;
+    rebalanceThreshold: z.ZodDefault<z.ZodNumber>;
+    responseFormat: z.ZodDefault<z.ZodEnum<["quick", "balanced", "detailed"]>>;
+}, "strip", z.ZodTypeAny, {
+    chainId: number;
+    responseFormat: "detailed" | "quick" | "balanced";
+    vaultAddresses: string[];
+    currentPositions: {
+        vaultAddress: string;
+        valueUsd: number;
+    }[];
+    strategy: "equal_weight" | "risk_parity" | "max_sharpe" | "min_variance";
+    rebalanceThreshold: number;
+}, {
+    chainId: number;
+    vaultAddresses: string[];
+    currentPositions: {
+        vaultAddress: string;
+        valueUsd: number;
+    }[];
+    responseFormat?: "detailed" | "quick" | "balanced" | undefined;
+    strategy?: "equal_weight" | "risk_parity" | "max_sharpe" | "min_variance" | undefined;
+    rebalanceThreshold?: number | undefined;
+}>;
+/**
+ * Type inference helpers
+ */
+export type QueryGraphQLInput = z.infer<typeof queryGraphQLInputSchema>;
+export type GetVaultDataInput = z.infer<typeof getVaultDataInputSchema>;
+export type GetUserPortfolioInput = z.infer<typeof getUserPortfolioInputSchema>;
+export type SearchVaultsInput = z.infer<typeof searchVaultsInputSchema>;
+export type GetVaultPerformanceInput = z.infer<typeof getVaultPerformanceInputSchema>;
+export type GetTransactionsInput = z.infer<typeof getTransactionsInputSchema>;
+export type CompareVaultsInput = z.infer<typeof compareVaultsInputSchema>;
+export type PriceHistoryInput = z.infer<typeof priceHistoryInputSchema>;
+export type ExportDataInput = z.infer<typeof exportDataInputSchema>;
+export type AnalyzeRiskInput = z.infer<typeof analyzeRiskInputSchema>;
+export type PredictYieldInput = z.infer<typeof predictYieldInputSchema>;
+export type OptimizePortfolioInput = z.infer<typeof optimizePortfolioInputSchema>;
+//# sourceMappingURL=validators.d.ts.map

package/dist/utils/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../src/utils/validators.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AAGH,eAAO,MAAM,qBAAqB,aAK/B,CAAC;AAGJ,eAAO,MAAM,aAAa,aAAmE,CAAC;AAG9F,eAAO,MAAM,qBAAqB,2BAKnB,CAAC;AAGhB,eAAO,MAAM,oBAAoB,2BAIpB,CAAC;AAEd;;GAEG;AAGH,eAAO,MAAM,uBAAuB;;;;;;;;;EAGlC,CAAC;AAGH,eAAO,MAAM,uBAAuB;;;;;;;;;EAGlC,CAAC;AAGH,eAAO,MAAM,2BAA2B;;;;;;;;;EAQtC,CAAC;AAGH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDlC,CAAC;AAGH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;EAazC,CAAC;AAGH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCrC,CAAC;AAGH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;EAYnC,CAAC;AAGH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;EAYlC,CAAC;AAGH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAWhC,CAAC;AAGH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;EASjC,CAAC;AAGH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;EAYlC,CAAC;AAGH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BvC,CAAC;AAEH;;GAEG;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAC9E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC"}