tapimo 0.14.0 → 0.15.1

package/dist/apps/data/routes/rpc.d.ts

@@ -16,56 +16,98 @@ export declare namespace schema {
         id: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniNull]>>;
         jsonrpc: z.ZodMiniLiteral<"2.0">;
         method: z.ZodMiniString<string>;
-        params: z.ZodMiniOptional<z.ZodMiniUnknown>;
+        params: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniArray<z.ZodMiniUnknown>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>]>>;
     }, z.core.$strip>;
-    /** JSON-RPC response payload. */
-    const Response: z.ZodMiniObject<{
-        error: z.ZodMiniOptional<z.ZodMiniObject<{
+    /** Successful JSON-RPC response payload. */
+    const SuccessResponse: z.ZodMiniObject<{
+        id: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniNull]>;
+        jsonrpc: z.ZodMiniLiteral<"2.0">;
+        result: z.ZodMiniUnknown;
+    }, z.core.$strict>;
+    /** Failed JSON-RPC response payload. */
+    const ErrorResponse: z.ZodMiniObject<{
+        error: z.ZodMiniObject<{
             code: z.ZodMiniNumber<number>;
             data: z.ZodMiniOptional<z.ZodMiniUnknown>;
             message: z.ZodMiniString<string>;
-        }, z.core.$strip>>;
+        }, z.core.$strip>;
         id: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniNull]>;
         jsonrpc: z.ZodMiniLiteral<"2.0">;
-        result: z.ZodMiniOptional<z.ZodMiniUnknown>;
-    }, z.core.$strip>;
+    }, z.core.$strict>;
+    /** JSON-RPC success or error response payload. */
+    const Response: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+        id: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniNull]>;
+        jsonrpc: z.ZodMiniLiteral<"2.0">;
+        result: z.ZodMiniUnknown;
+    }, z.core.$strict>, z.ZodMiniObject<{
+        error: z.ZodMiniObject<{
+            code: z.ZodMiniNumber<number>;
+            data: z.ZodMiniOptional<z.ZodMiniUnknown>;
+            message: z.ZodMiniString<string>;
+        }, z.core.$strip>;
+        id: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniNull]>;
+        jsonrpc: z.ZodMiniLiteral<"2.0">;
+    }, z.core.$strict>]>;
     /** JSON-RPC request or batch request payload. */
     const RequestBody: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
         id: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniNull]>>;
         jsonrpc: z.ZodMiniLiteral<"2.0">;
         method: z.ZodMiniString<string>;
-        params: z.ZodMiniOptional<z.ZodMiniUnknown>;
+        params: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniArray<z.ZodMiniUnknown>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>]>>;
     }, z.core.$strip>, z.ZodMiniArray<z.ZodMiniObject<{
         id: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniNull]>>;
         jsonrpc: z.ZodMiniLiteral<"2.0">;
         method: z.ZodMiniString<string>;
-        params: z.ZodMiniOptional<z.ZodMiniUnknown>;
+        params: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniArray<z.ZodMiniUnknown>, z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>]>>;
     }, z.core.$strip>>]>;
     /** JSON-RPC response or batch response payload. */
-    const ResponseBody: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
-        error: z.ZodMiniOptional<z.ZodMiniObject<{
+    const ResponseBody: z.ZodMiniUnion<readonly [z.ZodMiniNull, z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+        id: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniNull]>;
+        jsonrpc: z.ZodMiniLiteral<"2.0">;
+        result: z.ZodMiniUnknown;
+    }, z.core.$strict>, z.ZodMiniObject<{
+        error: z.ZodMiniObject<{
             code: z.ZodMiniNumber<number>;
             data: z.ZodMiniOptional<z.ZodMiniUnknown>;
             message: z.ZodMiniString<string>;
-        }, z.core.$strip>>;
+        }, z.core.$strip>;
         id: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniNull]>;
         jsonrpc: z.ZodMiniLiteral<"2.0">;
-        result: z.ZodMiniOptional<z.ZodMiniUnknown>;
-    }, z.core.$strip>, z.ZodMiniArray<z.ZodMiniObject<{
-        error: z.ZodMiniOptional<z.ZodMiniObject<{
+    }, z.core.$strict>]>, z.ZodMiniArray<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+        id: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniNull]>;
+        jsonrpc: z.ZodMiniLiteral<"2.0">;
+        result: z.ZodMiniUnknown;
+    }, z.core.$strict>, z.ZodMiniObject<{
+        error: z.ZodMiniObject<{
             code: z.ZodMiniNumber<number>;
             data: z.ZodMiniOptional<z.ZodMiniUnknown>;
             message: z.ZodMiniString<string>;
-        }, z.core.$strip>>;
+        }, z.core.$strip>;
         id: z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>, z.ZodMiniNull]>;
         jsonrpc: z.ZodMiniLiteral<"2.0">;
-        result: z.ZodMiniOptional<z.ZodMiniUnknown>;
-    }, z.core.$strip>>]>;
+    }, z.core.$strict>]>>]>;
 }
 /** Creates the raw Tempo RPC passthrough handler. */
 export declare function rpc(): import("hono/hono-base").HonoBase<App.Environment, {
-    "/rpc/:chain{(mainnet|testnet|[0-9]+)}?": {
+    "/rpc": {
         $post: {
+            output: null;
+            outputFormat: "body";
+            status: 204;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            };
+        } | {
             output: {
                 error: {
                     code: "api_key_malformed";
@@ -77,7 +119,17 @@ export declare function rpc(): import("hono/hono-base").HonoBase<App.Environment
             outputFormat: "json";
             status: 400;
             input: {
-                param: Record<"chain", string | undefined>;
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
             };
         } | {
             output: {
@@ -91,7 +143,17 @@ export declare function rpc(): import("hono/hono-base").HonoBase<App.Environment
             outputFormat: "json";
             status: 401;
             input: {
-                param: Record<"chain", string | undefined>;
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
             };
         } | {
             output: {
@@ -105,7 +167,17 @@ export declare function rpc(): import("hono/hono-base").HonoBase<App.Environment
             outputFormat: "json";
             status: 403;
             input: {
-                param: Record<"chain", string | undefined>;
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
             };
         } | {
             output: {
@@ -119,7 +191,41 @@ export declare function rpc(): import("hono/hono-base").HonoBase<App.Environment
             outputFormat: "json";
             status: 429;
             input: {
-                param: Record<"chain", string | undefined>;
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
             };
         } | {
             output: {
@@ -133,34 +239,402 @@ export declare function rpc(): import("hono/hono-base").HonoBase<App.Environment
             outputFormat: "json";
             status: 400;
             input: {
-                param: Record<"chain", string | undefined>;
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
             };
         } | {
             output: {
-                error?: {
+                error: {
+                    code: "payload_too_large";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 413;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "chain_id_unsupported";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            };
+        } | {
+            output: ({
+                id: string | number | null;
+                jsonrpc: "2.0";
+                result: import("hono/utils/types").JSONValue;
+            } | {
+                error: {
                     code: number;
                     data?: import("hono/utils/types").JSONValue;
                     message: string;
-                } | undefined;
+                };
                 id: string | number | null;
                 jsonrpc: "2.0";
-                result?: import("hono/utils/types").JSONValue;
-            }[] | {
-                error?: {
+            })[] | {
+                id: string | number | null;
+                jsonrpc: "2.0";
+                result: import("hono/utils/types").JSONValue;
+            } | {
+                error: {
                     code: number;
                     data?: import("hono/utils/types").JSONValue;
                     message: string;
-                } | undefined;
+                };
                 id: string | number | null;
                 jsonrpc: "2.0";
-                result?: import("hono/utils/types").JSONValue;
+            } | null;
+            outputFormat: "json";
+            status: 200;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            };
+        };
+    };
+} & {
+    "/rpc/:chain{(mainnet|testnet|[0-9]+)}": {
+        $post: {
+            output: null;
+            outputFormat: "body";
+            status: 204;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            } & {
+                param: {
+                    chain: string;
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_malformed";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            } & {
+                param: {
+                    chain: string;
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_invalid" | "api_key_missing";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 401;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            } & {
+                param: {
+                    chain: string;
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "api_key_forbidden" | "api_key_ip_forbidden";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 403;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            } & {
+                param: {
+                    chain: string;
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "payment_required" | "rate_limit_exceeded";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 429;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            } & {
+                param: {
+                    chain: string;
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "upstream_error";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 502;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            } & {
+                param: {
+                    chain: string;
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "chain_id_invalid";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
             };
             outputFormat: "json";
+            status: 400;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            } & {
+                param: {
+                    chain: string;
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "payload_too_large";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 413;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            } & {
+                param: {
+                    chain: string;
+                };
+            };
+        } | {
+            output: {
+                error: {
+                    code: "chain_id_unsupported";
+                    details?: readonly Response.error.Detail[] | undefined;
+                    message: string;
+                };
+                requestId: string;
+            };
+            outputFormat: "json";
+            status: 400;
+            input: {
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            } & {
+                param: {
+                    chain: string;
+                };
+            };
+        } | {
+            output: ({
+                id: string | number | null;
+                jsonrpc: "2.0";
+                result: import("hono/utils/types").JSONValue;
+            } | {
+                error: {
+                    code: number;
+                    data?: import("hono/utils/types").JSONValue;
+                    message: string;
+                };
+                id: string | number | null;
+                jsonrpc: "2.0";
+            })[] | {
+                id: string | number | null;
+                jsonrpc: "2.0";
+                result: import("hono/utils/types").JSONValue;
+            } | {
+                error: {
+                    code: number;
+                    data?: import("hono/utils/types").JSONValue;
+                    message: string;
+                };
+                id: string | number | null;
+                jsonrpc: "2.0";
+            } | null;
+            outputFormat: "json";
             status: 200;
             input: {
-                param: Record<"chain", string | undefined>;
+                json: {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                }[] | {
+                    id?: string | number | null | undefined;
+                    jsonrpc: "2.0";
+                    method: string;
+                    params?: unknown[] | Record<string, unknown> | undefined;
+                };
+            } & {
+                param: {
+                    chain: string;
+                };
             };
         };
     };
-}, "/", "/rpc/:chain{(mainnet|testnet|[0-9]+)}?">;
+}, "/", "/rpc/:chain{(mainnet|testnet|[0-9]+)}">;
 //# sourceMappingURL=rpc.d.ts.map

package/dist/apps/data/routes/rpc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/rpc.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAK3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AAgFzD,oDAAoD;AACpD,yBAAiB,MAAM,CAAC;IACtB,mCAAmC;IAC5B,MAAM,EAAE,4FAEiF,CAAA;IAEhG,8BAA8B;IACvB,MAAM,KAAK;;;;qBAayD,CAAA;IAE3E,gCAAgC;IACzB,MAAM,OAAO;;;;;qBAemD,CAAA;IAEvE,iCAAiC;IAC1B,MAAM,QAAQ;;;;;;;;;qBAkBlB,CAAA;IAEH,iDAAiD;IAC1C,MAAM,WAAW;;;;;;;;;;wBAEkE,CAAA;IAE1F,mDAAmD;IAC5C,MAAM,YAAY;;;;;;;;;;;;;;;;;;wBAEmE,CAAA;CAC7F;AAED,qDAAqD;AACrD,wBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAwGlB"}
+{"version":3,"file":"rpc.d.ts","sourceRoot":"","sources":["../../../../src/apps/data/routes/rpc.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAA;AAE7B,OAAO,KAAK,KAAK,GAAG,MAAM,iBAAiB,CAAA;AAK3C,OAAO,KAAK,QAAQ,MAAM,+BAA+B,CAAA;AA4CzD,oDAAoD;AACpD,yBAAiB,MAAM,CAAC;IACtB,mCAAmC;IAC5B,MAAM,EAAE,4FAYd,CAAA;IAED,8BAA8B;IACvB,MAAM,KAAK;;;;qBAyBjB,CAAA;IAED,gCAAgC;IACzB,MAAM,OAAO;;;;;qBAgCnB,CAAA;IAED,4CAA4C;IACrC,MAAM,eAAe;;;;sBAmB3B,CAAA;IAED,wCAAwC;IACjC,MAAM,aAAa;;;;;;;;sBAczB,CAAA;IAED,kDAAkD;IAC3C,MAAM,QAAQ;;;;;;;;;;;;wBAKpB,CAAA;IAED,iDAAiD;IAC1C,MAAM,WAAW;;;;;;;;;;wBAuBvB,CAAA;IAED,mDAAmD;IAC5C,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;2BAwBxB,CAAA;CACF;AAUD,qDAAqD;AACrD,wBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAoBlB"}