libshv-js 3.16.1 → 3.20.0

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './access';
+export * from './chainpack';
+export * from './cpcontext';
+export * from './cpon';
+export * from './json';
+export * from './rpcmessage';
+export * from './rpcvalue';
+export * from './vue-shv';
+export * from './ws-client';
+export * from './zod';

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./access"), exports);
+__exportStar(require("./chainpack"), exports);
+__exportStar(require("./cpcontext"), exports);
+__exportStar(require("./cpon"), exports);
+__exportStar(require("./json"), exports);
+__exportStar(require("./rpcmessage"), exports);
+__exportStar(require("./rpcvalue"), exports);
+__exportStar(require("./vue-shv"), exports);
+__exportStar(require("./ws-client"), exports);
+__exportStar(require("./zod"), exports);

package/dist/json.d.ts

@@ -0,0 +1,3 @@
+import { type RpcValue } from './rpcvalue';
+export declare const fromJson: (str: string) => RpcValue | Error;
+export declare const toJson: (value: RpcValue) => string | Error;

package/{src/json.ts → dist/json.js}

@@ -1,53 +1,46 @@
-import {UnpackContext} from './cpcontext';
-import {CponReader, stringifyDate} from './cpon';
-import {Decimal, Double, isIMap, isShvMap, makeIMap, makeMap, makeMetaMap, RpcValueWithMetaData, UInt, type RpcValue} from './rpcvalue';
-
-const decodeMap = (x: object) => makeMap(Object.fromEntries(Object.entries(x).map(([key, value]) => [key, decodeValueJson(value)])));
-
-const decodeValueJson = (x: unknown): RpcValue => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toJson = exports.fromJson = void 0;
+const cpcontext_1 = require("./cpcontext");
+const cpon_1 = require("./cpon");
+const rpcvalue_1 = require("./rpcvalue");
+const decodeMap = (x) => (0, rpcvalue_1.makeMap)(Object.fromEntries(Object.entries(x).map(([key, value]) => [key, decodeValueJson(value)])));
+const decodeValueJson = (x) => {
     switch (true) {
         case Array.isArray(x): {
-            const list = x as unknown[];
-            const handleType = (typeName: unknown, typeValue: unknown) => {
+            const list = x;
+            const handleType = (typeName, typeValue) => {
                 switch (true) {
                     case typeName === 'Blob': {
                         if (typeof typeValue !== 'string' || typeValue.length % 2 !== 0) {
                             throw new TypeError(`Invalid JSON-encoded Blob: '${JSON.stringify(typeValue)}'`);
                         }
-
                         const buffer = new ArrayBuffer(typeValue.length / 2);
                         const array = new Uint8Array(buffer);
-
                         // I can assume even length because of the previous check.
                         for (let i = 0; i < typeValue.length / 2; i++) {
                             array[i] = Number.parseInt(typeValue.slice(i * 2, (i * 2) + 2), 16);
                         }
-
                         return buffer;
                     }
-
                     case typeName === 'IMap':
                         if (typeof typeValue !== 'object' || typeValue === null) {
                             throw new TypeError(`Invalid JSON-encoded IMap: '${JSON.stringify(typeValue)}'`);
                         }
-
                         if (Object.keys(typeValue).some(key => !/^-?\d+$/.test(key))) {
                             throw new TypeError(`Invalid JSON-encoded IMap (non-Int key): '${JSON.stringify(typeValue)}'`);
                         }
-
-                        return makeIMap(decodeMap(typeValue));
+                        return (0, rpcvalue_1.makeIMap)(decodeMap(typeValue));
                     case typeName === 'DateTime':
                         if (typeof typeValue !== 'string') {
                             throw new TypeError(`Invalid JSON-encoded DateTime: '${JSON.stringify(typeValue)}'`);
                         }
-
                         // Kinda lame that I'm encoding the datetime string, but this is the easiest way right now.
-                        return new CponReader(new UnpackContext(new TextEncoder().encode(typeValue).buffer)).readDateTimeInner();
+                        return new cpon_1.CponReader(new cpcontext_1.UnpackContext(new TextEncoder().encode(typeValue).buffer)).readDateTimeInner();
                     default:
                         throw new TypeError(`Invalid JSON-encoded type name: '${JSON.stringify(typeName)}'`);
                 }
             };
-
             switch (true) {
                 case list.length === 3 && list[0] === JSON_TAG_TYPE:
                     return handleType(list[1], list[2]);
@@ -56,28 +49,22 @@ const decodeValueJson = (x: unknown): RpcValue => {
                     if (typeof list[1] !== 'object' || list[1] === null) {
                         throw new TypeError(`Invalid JSON-encoded MetaData: '${JSON.stringify(list[1])}'`);
                     }
-
                     const value = (() => {
                         if (list.length === 3) {
                             const decoded = decodeValueJson(list[2]);
-                            if (decoded instanceof RpcValueWithMetaData) {
+                            if (decoded instanceof rpcvalue_1.RpcValueWithMetaData) {
                                 throw new TypeError('Logic error: got RpcValueWithMetaData as the value in JSON-encoded RpcValueWithMetaData, please report this bug to the maintainer.');
                             }
-
                             return decoded;
                         }
-
                         return handleType(list[3], list[4]);
                     })();
-
-                    return new RpcValueWithMetaData(makeMetaMap(decodeMap(list[1])), value);
+                    return new rpcvalue_1.RpcValueWithMetaData((0, rpcvalue_1.makeMetaMap)(decodeMap(list[1])), value);
                 }
-
                 default:
                     return list.map(value => decodeValueJson(value));
             }
         }
-
         case x === null:
             return undefined;
         case typeof x === 'object':
@@ -90,47 +77,42 @@ const decodeValueJson = (x: unknown): RpcValue => {
             throw new Error(`Unknown JSON-encoded value: ${JSON.stringify(x)}`);
     }
 };
-
-export const fromJson = (str: string): RpcValue | Error => decodeValueJson(JSON.parse(str));
-
+const fromJson = (str) => decodeValueJson(JSON.parse(str));
+exports.fromJson = fromJson;
 const JSON_TAG_META = '!shvMeta';
 const JSON_TAG_TYPE = '!shvType';
-
-const encodeValueJson = (x: RpcValue): unknown => {
+const encodeValueJson = (x) => {
     switch (true) {
-        case x instanceof RpcValueWithMetaData: {
-            const res = [JSON_TAG_META, encodeValueJson(makeMap(x.meta))] as const;
+        case x instanceof rpcvalue_1.RpcValueWithMetaData: {
+            const res = [JSON_TAG_META, encodeValueJson((0, rpcvalue_1.makeMap)(x.meta))];
             const encoded = encodeValueJson(x.value);
             if (Array.isArray(encoded) && encoded[0] === JSON_TAG_TYPE) {
-                return [...res, ...encoded as unknown[]];
+                return [...res, ...encoded];
             }
-
             return [...res, encoded];
         }
-
         case Array.isArray(x):
             return x.map(value => encodeValueJson(value));
-        case isShvMap(x): {
-            const map = x as Record<string, RpcValue>;
-            return Object.fromEntries(Object.entries(map).map(([key, value]) => [key, encodeValueJson(value)] as const));
+        case (0, rpcvalue_1.isShvMap)(x): {
+            const map = x;
+            return Object.fromEntries(Object.entries(map).map(([key, value]) => [key, encodeValueJson(value)]));
         }
-
-        case isIMap(x):
-            return [JSON_TAG_TYPE, 'IMap', encodeValueJson(makeMap(x))];
+        case (0, rpcvalue_1.isIMap)(x):
+            return [JSON_TAG_TYPE, 'IMap', encodeValueJson((0, rpcvalue_1.makeMap)(x))];
         case x instanceof ArrayBuffer:
             return [JSON_TAG_TYPE, 'Blob', new Uint8Array(x).reduce((acc, v) => acc + v.toString(16).padStart(2, '0'), '')];
         case x instanceof Date:
-            return [JSON_TAG_TYPE, 'DateTime', stringifyDate(x)];
+            return [JSON_TAG_TYPE, 'DateTime', (0, cpon_1.stringifyDate)(x)];
         case x === undefined:
             // eslint-disable-next-line unicorn/no-null
             return null;
-        case x instanceof Decimal:
-        case x instanceof UInt:
-        case x instanceof Double:
+        case x instanceof rpcvalue_1.Decimal:
+        case x instanceof rpcvalue_1.UInt:
+        case x instanceof rpcvalue_1.Double:
             throw new TypeError('Decimal/Double/UInt not supported in JSON');
         default:
             return x;
     }
 };
-
-export const toJson = (value: RpcValue): string | Error => JSON.stringify(encodeValueJson(value));
+const toJson = (value) => JSON.stringify(encodeValueJson(value));
+exports.toJson = toJson;

package/dist/rpcmessage.d.ts

@@ -0,0 +1,285 @@
+import * as z from './zod';
+import { type shvMapType } from './rpcvalue';
+export declare const RPC_MESSAGE_REQUEST_ID = 8;
+export declare const RPC_MESSAGE_SHV_PATH = 9;
+export declare const RPC_MESSAGE_METHOD = 10;
+export declare const RPC_MESSAGE_CALLER_IDS = 11;
+export declare const RPC_MESSAGE_ACCESS_LEVEL = 17;
+export declare const RPC_MESSAGE_PARAMS = 1;
+export declare const RPC_MESSAGE_RESULT = 2;
+export declare const RPC_MESSAGE_ERROR = 3;
+export declare const RPC_MESSAGE_DELAY = 4;
+export declare const RPC_MESSAGE_ABORT = 5;
+export declare const ERROR_CODE = 1;
+export declare const ERROR_MESSAGE = 2;
+export declare const ERROR_DATA = 3;
+declare enum ErrorCode {
+    InvalidRequest = 1,
+    MethodNotFound = 2,
+    InvalidParams = 3,
+    InternalError = 4,
+    ParseError = 5,
+    MethodCallTimeout = 6,
+    MethodCallCancelled = 7,
+    MethodCallException = 8,
+    Unknown = 9,
+    LoginRequired = 10,
+    UserIDRequired = 11,
+    NotImplemented = 12
+}
+declare const ErrorMapZod: z.ZodCustom<{
+    1: number;
+    2?: string | undefined;
+    3?: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}, {
+    1: number;
+    2?: string | undefined;
+    3?: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}>;
+export type ErrorMap = z.infer<typeof ErrorMapZod>;
+declare const RpcResponseValueZod: z.ZodUnion<[z.ZodUnion<[z.ZodCustom<{
+    2: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}, {
+    2: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}>, z.ZodCustom<{
+    3: {
+        1: number;
+        2?: string | undefined;
+        3?: import("./rpcvalue").RpcValue;
+    } & {
+        [shvMapType]: "imap";
+    };
+} & {
+    [shvMapType]: "imap";
+}, {
+    3: {
+        1: number;
+        2?: string | undefined;
+        3?: import("./rpcvalue").RpcValue;
+    } & {
+        [shvMapType]: "imap";
+    };
+} & {
+    [shvMapType]: "imap";
+}>]>, z.ZodCustom<{
+    4: import("./rpcvalue").Double;
+} & {
+    [shvMapType]: "imap";
+}, {
+    4: import("./rpcvalue").Double;
+} & {
+    [shvMapType]: "imap";
+}>]>;
+declare const RpcRequestZod: z.ZodCustom<import("./rpcvalue").RpcValueWithMetaData<{
+    8: number;
+    10: string;
+    9: string;
+    11?: number | number[] | undefined;
+    17?: number | undefined;
+} & {
+    [shvMapType]: "metamap";
+}, ({
+    1?: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    5: boolean;
+} & {
+    [shvMapType]: "imap";
+})>, import("./rpcvalue").RpcValueWithMetaData<{
+    8: number;
+    10: string;
+    9: string;
+    11?: number | number[] | undefined;
+    17?: number | undefined;
+} & {
+    [shvMapType]: "metamap";
+}, ({
+    1?: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    5: boolean;
+} & {
+    [shvMapType]: "imap";
+})>>;
+declare const RpcResponseZod: z.ZodCustom<import("./rpcvalue").RpcValueWithMetaData<{
+    8: number;
+    11?: number | number[] | undefined;
+} & {
+    [shvMapType]: "metamap";
+}, ({
+    2: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    3: {
+        1: number;
+        2?: string | undefined;
+        3?: import("./rpcvalue").RpcValue;
+    } & {
+        [shvMapType]: "imap";
+    };
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    4: import("./rpcvalue").Double;
+} & {
+    [shvMapType]: "imap";
+})>, import("./rpcvalue").RpcValueWithMetaData<{
+    8: number;
+    11?: number | number[] | undefined;
+} & {
+    [shvMapType]: "metamap";
+}, ({
+    2: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    3: {
+        1: number;
+        2?: string | undefined;
+        3?: import("./rpcvalue").RpcValue;
+    } & {
+        [shvMapType]: "imap";
+    };
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    4: import("./rpcvalue").Double;
+} & {
+    [shvMapType]: "imap";
+})>>;
+declare const RpcSignalZod: z.ZodCustom<import("./rpcvalue").RpcValueWithMetaData<{
+    9: string;
+    10: string;
+} & {
+    [shvMapType]: "metamap";
+}, {
+    1?: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}>, import("./rpcvalue").RpcValueWithMetaData<{
+    9: string;
+    10: string;
+} & {
+    [shvMapType]: "metamap";
+}, {
+    1?: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}>>;
+declare const RpcMessageZod: z.ZodUnion<readonly [z.ZodCustom<import("./rpcvalue").RpcValueWithMetaData<{
+    8: number;
+    10: string;
+    9: string;
+    11?: number | number[] | undefined;
+    17?: number | undefined;
+} & {
+    [shvMapType]: "metamap";
+}, ({
+    1?: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    5: boolean;
+} & {
+    [shvMapType]: "imap";
+})>, import("./rpcvalue").RpcValueWithMetaData<{
+    8: number;
+    10: string;
+    9: string;
+    11?: number | number[] | undefined;
+    17?: number | undefined;
+} & {
+    [shvMapType]: "metamap";
+}, ({
+    1?: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    5: boolean;
+} & {
+    [shvMapType]: "imap";
+})>>, z.ZodCustom<import("./rpcvalue").RpcValueWithMetaData<{
+    8: number;
+    11?: number | number[] | undefined;
+} & {
+    [shvMapType]: "metamap";
+}, ({
+    2: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    3: {
+        1: number;
+        2?: string | undefined;
+        3?: import("./rpcvalue").RpcValue;
+    } & {
+        [shvMapType]: "imap";
+    };
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    4: import("./rpcvalue").Double;
+} & {
+    [shvMapType]: "imap";
+})>, import("./rpcvalue").RpcValueWithMetaData<{
+    8: number;
+    11?: number | number[] | undefined;
+} & {
+    [shvMapType]: "metamap";
+}, ({
+    2: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    3: {
+        1: number;
+        2?: string | undefined;
+        3?: import("./rpcvalue").RpcValue;
+    } & {
+        [shvMapType]: "imap";
+    };
+} & {
+    [shvMapType]: "imap";
+}) | ({
+    4: import("./rpcvalue").Double;
+} & {
+    [shvMapType]: "imap";
+})>>, z.ZodCustom<import("./rpcvalue").RpcValueWithMetaData<{
+    9: string;
+    10: string;
+} & {
+    [shvMapType]: "metamap";
+}, {
+    1?: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}>, import("./rpcvalue").RpcValueWithMetaData<{
+    9: string;
+    10: string;
+} & {
+    [shvMapType]: "metamap";
+}, {
+    1?: import("./rpcvalue").RpcValue;
+} & {
+    [shvMapType]: "imap";
+}>>]>;
+export type RpcRequest = z.infer<typeof RpcRequestZod>;
+export type RpcResponse = z.infer<typeof RpcResponseZod>;
+export type RpcResponseValue = z.infer<typeof RpcResponseValueZod>;
+export type RpcSignal = z.infer<typeof RpcSignalZod>;
+export type RpcMessage = z.infer<typeof RpcMessageZod>;
+export declare const isSignal: (message: RpcMessage) => message is RpcSignal;
+export declare const isRequest: (message: RpcMessage) => message is RpcRequest;
+export declare const isResponse: (message: RpcMessage) => message is RpcResponse;
+export { RpcMessageZod, ErrorCode };

package/dist/rpcmessage.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorCode = exports.RpcMessageZod = exports.isResponse = exports.isRequest = exports.isSignal = exports.ERROR_DATA = exports.ERROR_MESSAGE = exports.ERROR_CODE = exports.RPC_MESSAGE_ABORT = exports.RPC_MESSAGE_DELAY = exports.RPC_MESSAGE_ERROR = exports.RPC_MESSAGE_RESULT = exports.RPC_MESSAGE_PARAMS = exports.RPC_MESSAGE_ACCESS_LEVEL = exports.RPC_MESSAGE_CALLER_IDS = exports.RPC_MESSAGE_METHOD = exports.RPC_MESSAGE_SHV_PATH = exports.RPC_MESSAGE_REQUEST_ID = void 0;
+const z = __importStar(require("./zod"));
+exports.RPC_MESSAGE_REQUEST_ID = 8;
+exports.RPC_MESSAGE_SHV_PATH = 9;
+exports.RPC_MESSAGE_METHOD = 10;
+exports.RPC_MESSAGE_CALLER_IDS = 11;
+exports.RPC_MESSAGE_ACCESS_LEVEL = 17;
+exports.RPC_MESSAGE_PARAMS = 1;
+exports.RPC_MESSAGE_RESULT = 2;
+exports.RPC_MESSAGE_ERROR = 3;
+exports.RPC_MESSAGE_DELAY = 4;
+exports.RPC_MESSAGE_ABORT = 5;
+exports.ERROR_CODE = 1;
+exports.ERROR_MESSAGE = 2;
+exports.ERROR_DATA = 3;
+var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode[ErrorCode["InvalidRequest"] = 1] = "InvalidRequest";
+    ErrorCode[ErrorCode["MethodNotFound"] = 2] = "MethodNotFound";
+    ErrorCode[ErrorCode["InvalidParams"] = 3] = "InvalidParams";
+    ErrorCode[ErrorCode["InternalError"] = 4] = "InternalError";
+    ErrorCode[ErrorCode["ParseError"] = 5] = "ParseError";
+    ErrorCode[ErrorCode["MethodCallTimeout"] = 6] = "MethodCallTimeout";
+    ErrorCode[ErrorCode["MethodCallCancelled"] = 7] = "MethodCallCancelled";
+    ErrorCode[ErrorCode["MethodCallException"] = 8] = "MethodCallException";
+    ErrorCode[ErrorCode["Unknown"] = 9] = "Unknown";
+    ErrorCode[ErrorCode["LoginRequired"] = 10] = "LoginRequired";
+    ErrorCode[ErrorCode["UserIDRequired"] = 11] = "UserIDRequired";
+    ErrorCode[ErrorCode["NotImplemented"] = 12] = "NotImplemented";
+})(ErrorCode || (exports.ErrorCode = ErrorCode = {}));
+const ErrorMapZod = z.imap({
+    [exports.ERROR_CODE]: z.number(),
+    [exports.ERROR_MESSAGE]: z.string().optional(),
+    [exports.ERROR_DATA]: z.rpcvalue().optional(),
+});
+const RpcRequestMetaZod = z.metamap({
+    [exports.RPC_MESSAGE_CALLER_IDS]: z.int().or(z.array(z.int())).optional(),
+    [exports.RPC_MESSAGE_REQUEST_ID]: z.number(),
+    [exports.RPC_MESSAGE_METHOD]: z.string(),
+    [exports.RPC_MESSAGE_SHV_PATH]: z.string(),
+    [exports.RPC_MESSAGE_ACCESS_LEVEL]: z.int().gte(0).lte(63).optional(),
+});
+const RpcRequestValueZod = z.imap({
+    [exports.RPC_MESSAGE_PARAMS]: z.rpcvalue().optional(),
+}).or(z.imap({
+    [exports.RPC_MESSAGE_ABORT]: z.boolean(),
+}));
+const RpcResponseMetaZod = z.metamap({
+    [exports.RPC_MESSAGE_CALLER_IDS]: z.int().or(z.array(z.int())).optional(),
+    [exports.RPC_MESSAGE_REQUEST_ID]: z.number(),
+});
+const RpcResponseValueZod = z.imap({
+    [exports.RPC_MESSAGE_RESULT]: z.rpcvalue(),
+}).or(z.imap({
+    [exports.RPC_MESSAGE_ERROR]: ErrorMapZod,
+})).or(z.imap({
+    [exports.RPC_MESSAGE_DELAY]: z.double(),
+}));
+const RpcSignalMetaZod = z.metamap({
+    [exports.RPC_MESSAGE_SHV_PATH]: z.string(),
+    [exports.RPC_MESSAGE_METHOD]: z.string(),
+});
+const RpcSignalValueZod = z.imap({
+    [exports.RPC_MESSAGE_PARAMS]: z.rpcvalue().optional(),
+});
+const RpcRequestZod = z.withMeta(RpcRequestMetaZod, RpcRequestValueZod);
+const RpcResponseZod = z.withMeta(RpcResponseMetaZod, RpcResponseValueZod);
+const RpcSignalZod = z.withMeta(RpcSignalMetaZod, RpcSignalValueZod);
+const RpcMessageZod = z.union([RpcRequestZod, RpcResponseZod, RpcSignalZod]);
+exports.RpcMessageZod = RpcMessageZod;
+const isSignal = (message) => !(exports.RPC_MESSAGE_REQUEST_ID in message.meta) && exports.RPC_MESSAGE_METHOD in message.meta;
+exports.isSignal = isSignal;
+const isRequest = (message) => exports.RPC_MESSAGE_REQUEST_ID in message.meta && exports.RPC_MESSAGE_METHOD in message.meta;
+exports.isRequest = isRequest;
+const isResponse = (message) => exports.RPC_MESSAGE_REQUEST_ID in message.meta && !(exports.RPC_MESSAGE_METHOD in message.meta);
+exports.isResponse = isResponse;

package/dist/rpcvalue.d.ts

@@ -0,0 +1,56 @@
+declare class UInt<T extends number = number> {
+    readonly value: T;
+    constructor(u: T | UInt<T>);
+    [Symbol.toPrimitive](): T;
+    toString(): string;
+}
+declare class Double {
+    readonly value: number;
+    constructor(u: number);
+}
+declare class Decimal {
+    mantisa: number;
+    exponent: number;
+    constructor(mantisa: number, exponent: number);
+}
+export type Null = undefined;
+export type Bool = boolean;
+export type Blob = ArrayBuffer;
+export type ShvString = string;
+export type DateTime = Date & {
+    utc_offset?: number;
+};
+declare const withOffset: (date: Date, utcOffset?: number) => DateTime;
+export type List = RpcValue[];
+declare const shvMapType: unique symbol;
+type IMap<T extends Record<number, RpcValue> = Record<number, any>> = {
+    [Key in keyof T]: T[Key];
+} & {
+    [shvMapType]: 'imap';
+};
+type ShvMap<T extends Record<string, RpcValue> = Record<string, any>> = {
+    [Key in keyof T]: T[Key];
+} & {
+    [shvMapType]: 'map';
+};
+export type Int = number;
+export type RpcValueType = Null | Bool | Int | UInt | Double | Decimal | Blob | ShvString | DateTime | List | ShvMap | IMap;
+type MetaMap<T extends Record<string | number, RpcValue> = Record<string | number, RpcValue>> = {
+    [Key in keyof T]: T[Key];
+} & {
+    [shvMapType]: 'metamap';
+};
+declare const isShvMap: (x: unknown) => x is ShvMap;
+declare const isIMap: (x: unknown) => x is IMap;
+declare const isMetaMap: (x: unknown) => x is IMap;
+export declare const typeName: (x: unknown) => string;
+declare const makeMetaMap: <T extends Record<string | number, RpcValue> = Record<string | number, RpcValue>, U extends Record<number, RpcValue> = Omit<T, typeof shvMapType>>(x?: U) => MetaMap<U>;
+declare const makeIMap: <T extends Record<number, RpcValue> = Record<number, RpcValue>, U extends Record<number, RpcValue> = Omit<T, typeof shvMapType>>(x?: U) => IMap<U>;
+declare const makeMap: <T extends Record<string, RpcValue> = Record<string, RpcValue>, U extends Record<string, RpcValue> = Omit<T, typeof shvMapType>>(x?: U) => ShvMap<U>;
+declare class RpcValueWithMetaData<MetaSchema extends MetaMap = MetaMap, ValueSchema extends RpcValueType = RpcValueType> {
+    meta: MetaSchema;
+    value: ValueSchema;
+    constructor(meta: MetaSchema, value: ValueSchema);
+}
+export type RpcValue = RpcValueType | RpcValueWithMetaData;
+export { shvMapType, Decimal, Double, type IMap, type MetaMap, RpcValueWithMetaData, type ShvMap, UInt, withOffset, makeMap, makeIMap, makeMetaMap, isIMap, isMetaMap, isShvMap };