libshv-js 3.17.0 → 3.21.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/dist/json.js

@@ -0,0 +1,118 @@
+"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;
+            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 (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 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]);
+                case list.length === 3 && list[0] === JSON_TAG_META:
+                case list.length === 5 && list[0] === JSON_TAG_META && list[2] === JSON_TAG_TYPE: {
+                    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 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 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':
+            return decodeMap(x);
+        case typeof x === 'number':
+        case typeof x === 'boolean':
+        case typeof x === 'string':
+            return x;
+        default:
+            throw new Error(`Unknown JSON-encoded value: ${JSON.stringify(x)}`);
+    }
+};
+const fromJson = (str) => decodeValueJson(JSON.parse(str));
+exports.fromJson = fromJson;
+const JSON_TAG_META = '!shvMeta';
+const JSON_TAG_TYPE = '!shvType';
+const encodeValueJson = (x) => {
+    switch (true) {
+        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];
+            }
+            return [...res, encoded];
+        }
+        case Array.isArray(x):
+            return x.map(value => encodeValueJson(value));
+        case (0, rpcvalue_1.isShvMap)(x): {
+            const map = x;
+            return Object.fromEntries(Object.entries(map).map(([key, value]) => [key, encodeValueJson(value)]));
+        }
+        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', (0, cpon_1.stringifyDate)(x)];
+        case x === undefined:
+            // eslint-disable-next-line unicorn/no-null
+            return null;
+        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;
+    }
+};
+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 };