@beff/client 0.0.113 → 0.0.115

package/dist/esm/codegen-v2.js

@@ -0,0 +1,1230 @@
+import { z } from "zod";
+import { generateHashFromString, generateHashFromNumbers, unknownHash, stringHash, numberHash, booleanHash, nullishHash, undefinedHash, arrayHash, objectHash, dateHash, bigintHash, stringWithFormatHash, numberWithFormatHash, anyOfConstsHash, tupleHash, allOfHash, anyOfHash, optionalFieldHash, } from "./hash";
+import { printErrors } from "./err";
+const JSON_PROTO = Object.getPrototypeOf({});
+function deepmergeConstructor(options) {
+    function isNotPrototypeKey(value) {
+        return value !== "constructor" && value !== "prototype" && value !== "__proto__";
+    }
+    function cloneArray(value) {
+        let i = 0;
+        const il = value.length;
+        const result = new Array(il);
+        for (i; i < il; ++i) {
+            result[i] = clone(value[i]);
+        }
+        return result;
+    }
+    function cloneObject(target) {
+        const result = {};
+        if (cloneProtoObject && Object.getPrototypeOf(target) !== JSON_PROTO) {
+            return cloneProtoObject(target);
+        }
+        const targetKeys = getKeys(target);
+        let i, il, key;
+        for (i = 0, il = targetKeys.length; i < il; ++i) {
+            //@ts-ignore
+            isNotPrototypeKey((key = targetKeys[i])) && (result[key] = clone(target[key]));
+        }
+        return result;
+    }
+    function concatArrays(target, source) {
+        const tl = target.length;
+        const sl = source.length;
+        let i = 0;
+        const result = new Array(tl + sl);
+        for (i; i < tl; ++i) {
+            result[i] = clone(target[i]);
+        }
+        for (i = 0; i < sl; ++i) {
+            result[i + tl] = clone(source[i]);
+        }
+        return result;
+    }
+    const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+    function getSymbolsAndKeys(value) {
+        const result = Object.keys(value);
+        const keys = Object.getOwnPropertySymbols(value);
+        for (let i = 0, il = keys.length; i < il; ++i) {
+            //@ts-ignore
+            propertyIsEnumerable.call(value, keys[i]) && result.push(keys[i]);
+        }
+        return result;
+    }
+    const getKeys = options?.symbols ? getSymbolsAndKeys : Object.keys;
+    const cloneProtoObject = typeof options?.cloneProtoObject === "function" ? options.cloneProtoObject : undefined;
+    function isMergeableObject(value) {
+        return (typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Date));
+    }
+    function isPrimitive(value) {
+        return typeof value !== "object" || value === null;
+    }
+    const isPrimitiveOrBuiltIn = 
+    // @ts-ignore
+    typeof Buffer !== "undefined"
+        ? (value) => typeof value !== "object" ||
+            value === null ||
+            value instanceof RegExp ||
+            value instanceof Date ||
+            // @ts-ignore
+            value instanceof Buffer
+        : (value) => typeof value !== "object" || value === null || value instanceof RegExp || value instanceof Date;
+    const mergeArray = options && typeof options.mergeArray === "function"
+        ? options.mergeArray({ clone, deepmerge: _deepmerge, getKeys, isMergeableObject })
+        : concatArrays;
+    function clone(entry) {
+        return isMergeableObject(entry) ? (Array.isArray(entry) ? cloneArray(entry) : cloneObject(entry)) : entry;
+    }
+    function mergeObject(target, source) {
+        const result = {};
+        const targetKeys = getKeys(target);
+        const sourceKeys = getKeys(source);
+        let i, il, key;
+        for (i = 0, il = targetKeys.length; i < il; ++i) {
+            isNotPrototypeKey((key = targetKeys[i])) &&
+                sourceKeys.indexOf(key) === -1 &&
+                // @ts-ignore
+                (result[key] = clone(target[key]));
+        }
+        for (i = 0, il = sourceKeys.length; i < il; ++i) {
+            if (!isNotPrototypeKey((key = sourceKeys[i]))) {
+                continue;
+            }
+            if (key in target) {
+                if (targetKeys.indexOf(key) !== -1) {
+                    if (cloneProtoObject &&
+                        isMergeableObject(source[key]) &&
+                        Object.getPrototypeOf(source[key]) !== JSON_PROTO) {
+                        // @ts-ignore
+                        result[key] = cloneProtoObject(source[key]);
+                    }
+                    else {
+                        // @ts-ignore
+                        result[key] = _deepmerge(target[key], source[key]);
+                    }
+                }
+            }
+            else {
+                // @ts-ignore
+                result[key] = clone(source[key]);
+            }
+        }
+        return result;
+    }
+    function _deepmerge(target, source) {
+        const sourceIsArray = Array.isArray(source);
+        const targetIsArray = Array.isArray(target);
+        if (isPrimitive(source)) {
+            return source;
+        }
+        else if (isPrimitiveOrBuiltIn(target)) {
+            return clone(source);
+        }
+        else if (sourceIsArray && targetIsArray) {
+            return mergeArray(target, source);
+        }
+        else if (sourceIsArray !== targetIsArray) {
+            return clone(source);
+        }
+        else {
+            return mergeObject(target, source);
+        }
+    }
+    function _deepmergeAll() {
+        switch (arguments.length) {
+            case 0:
+                return {};
+            case 1:
+                return clone(arguments[0]);
+            case 2:
+                return _deepmerge(arguments[0], arguments[1]);
+        }
+        let result;
+        for (let i = 0, il = arguments.length; i < il; ++i) {
+            result = _deepmerge(result, arguments[i]);
+        }
+        return result;
+    }
+    return _deepmergeAll;
+}
+function deepmergeArray(options) {
+    const deepmerge = options.deepmerge;
+    const clone = options.clone;
+    return function (target, source) {
+        let i = 0;
+        //const tl = target.length;
+        const sl = source.length;
+        const il = Math.max(target.length, source.length);
+        const result = new Array(il);
+        for (i = 0; i < il; ++i) {
+            if (i < sl) {
+                result[i] = deepmerge(target[i], source[i]);
+            }
+            else {
+                result[i] = clone(target[i]);
+            }
+        }
+        return result;
+    };
+}
+const deepmerge = deepmergeConstructor({ mergeArray: deepmergeArray });
+function buildUnionError(ctx, errors, received) {
+    return [
+        {
+            path: [...ctx.path],
+            received,
+            errors,
+            isUnionError: true,
+        },
+    ];
+}
+function buildError(ctx, message, received) {
+    return [
+        {
+            message,
+            path: [...ctx.path],
+            received,
+        },
+    ];
+}
+function pushPath(ctx, key) {
+    ctx.path.push(key);
+}
+function popPath(ctx) {
+    ctx.path.pop();
+}
+function printPath(ctx) {
+    return ctx.path.join(".");
+}
+function buildSchemaErrorMessage(ctx, message) {
+    return `Failed to print schema. At ${printPath(ctx)}: ${message}`;
+}
+const limitedCommaJoinJson = (arr) => {
+    const limit = 3;
+    if (arr.length < limit) {
+        return arr.map((it) => JSON.stringify(it)).join(", ");
+    }
+    return (arr
+        .slice(0, limit)
+        .map((it) => JSON.stringify(it))
+        .join(", ") + `...`);
+};
+const stringFormatters = {};
+export function registerStringFormatter(name, validator) {
+    stringFormatters[name] = validator;
+}
+const numberFormatters = {};
+export function registerNumberFormatter(name, validator) {
+    numberFormatters[name] = validator;
+}
+export class TypeofRuntype {
+    typeName;
+    constructor(typeName) {
+        this.typeName = typeName;
+    }
+    describe(_ctx) {
+        return this.typeName;
+    }
+    schema(_ctx) {
+        return { type: this.typeName };
+    }
+    validate(_ctx, input) {
+        return typeof input === this.typeName;
+    }
+    parseAfterValidation(_ctx, input) {
+        return input;
+    }
+    reportDecodeError(ctx, input) {
+        return buildError(ctx, "expected " + this.typeName, input);
+    }
+    hash(_ctx) {
+        switch (this.typeName) {
+            case "string":
+                return stringHash;
+            case "number":
+                return numberHash;
+            case "boolean":
+                return booleanHash;
+        }
+    }
+}
+export class AnyRuntype {
+    describe(_ctx) {
+        return "any";
+    }
+    schema(_ctx) {
+        return {};
+    }
+    validate(_ctx, _input) {
+        return true;
+    }
+    parseAfterValidation(_ctx, input) {
+        return input;
+    }
+    reportDecodeError(ctx, input) {
+        return buildError(ctx, "expected any", input);
+    }
+    hash(_ctx) {
+        return unknownHash;
+    }
+}
+export class NullishRuntype {
+    description;
+    constructor(description) {
+        this.description = description;
+    }
+    describe(_ctx) {
+        return this.description;
+    }
+    schema(_ctx) {
+        return { type: "null" };
+    }
+    validate(_ctx, input) {
+        return input == null;
+    }
+    parseAfterValidation(_ctx, input) {
+        return input;
+    }
+    reportDecodeError(ctx, input) {
+        return buildError(ctx, "expected nullish value", input);
+    }
+    hash(_ctx) {
+        return nullishHash;
+    }
+}
+export class NeverRuntype {
+    describe(_ctx) {
+        return "never";
+    }
+    schema(_ctx) {
+        return { anyOf: [] };
+    }
+    validate(_ctx, _input) {
+        return false;
+    }
+    parseAfterValidation(_ctx, _input) {
+        throw new Error("unreachable");
+    }
+    reportDecodeError(ctx, input) {
+        return buildError(ctx, "expected never", input);
+    }
+    hash(_ctx) {
+        return undefinedHash;
+    }
+}
+export class ConstRuntype {
+    value;
+    constructor(value) {
+        this.value = value ?? null;
+    }
+    describe(_ctx) {
+        return JSON.stringify(this.value);
+    }
+    schema(_ctx) {
+        return { const: this.value };
+    }
+    validate(_ctx, input) {
+        if (this.value == null) {
+            return input == this.value;
+        }
+        return input === this.value;
+    }
+    parseAfterValidation(_ctx, input) {
+        return input;
+    }
+    reportDecodeError(ctx, input) {
+        return buildError(ctx, `expected ${JSON.stringify(this.value)}`, input);
+    }
+    hash(_ctx) {
+        if (this.value == null) {
+            return nullishHash;
+        }
+        switch (typeof this.value) {
+            case "string":
+                return generateHashFromString(this.value);
+            case "number":
+                return generateHashFromNumbers([this.value]);
+            case "boolean":
+                return generateHashFromString(this.value ? "true" : "false");
+        }
+    }
+}
+export class RegexRuntype {
+    regex;
+    description;
+    constructor(regex, description) {
+        this.regex = regex;
+        this.description = description;
+    }
+    describe(_ctx) {
+        return this.description;
+    }
+    schema(_ctx) {
+        return { type: "string", pattern: this.description };
+    }
+    validate(_ctx, input) {
+        if (typeof input === "string") {
+            return this.regex.test(input);
+        }
+        return false;
+    }
+    parseAfterValidation(_ctx, input) {
+        return input;
+    }
+    reportDecodeError(ctx, input) {
+        return buildError(ctx, `expected string matching ${this.description}`, input);
+    }
+    hash(_ctx) {
+        return generateHashFromString(this.description);
+    }
+}
+export class DateRuntype {
+    describe(_ctx) {
+        return "Date";
+    }
+    schema(ctx) {
+        throw new Error(buildSchemaErrorMessage(ctx, "Cannot generate JSON Schema for Date"));
+    }
+    validate(_ctx, input) {
+        return input instanceof Date;
+    }
+    parseAfterValidation(_ctx, input) {
+        return input;
+    }
+    reportDecodeError(ctx, input) {
+        return buildError(ctx, `expected Date`, input);
+    }
+    hash(_ctx) {
+        return dateHash;
+    }
+}
+export class BigIntRuntype {
+    describe(_ctx) {
+        return "BigInt";
+    }
+    schema(ctx) {
+        throw new Error(buildSchemaErrorMessage(ctx, "Cannot generate JSON Schema for BigInt"));
+    }
+    validate(_ctx, input) {
+        return typeof input === "bigint";
+    }
+    parseAfterValidation(_ctx, input) {
+        return input;
+    }
+    reportDecodeError(ctx, input) {
+        return buildError(ctx, `expected BigInt`, input);
+    }
+    hash(_ctx) {
+        return bigintHash;
+    }
+}
+export class StringWithFormatRuntype {
+    formats;
+    constructor(formats) {
+        this.formats = formats;
+    }
+    describe(_ctx) {
+        if (this.formats.length === 0) {
+            throw new Error("INTERNAL ERROR: No formats provided");
+        }
+        const [first, ...rest] = this.formats;
+        let acc = `StringFormat<"${first}">`;
+        for (const r of rest) {
+            acc = `StringFormatExtends<${acc}, "${r}">`;
+        }
+        return acc;
+    }
+    schema(_ctx) {
+        return {
+            type: "string",
+            format: this.formats.join(" and "),
+        };
+    }
+    validate(_ctx, input) {
+        if (typeof input !== "string") {
+            return false;
+        }
+        for (const f of this.formats) {
+            const validator = stringFormatters[f];
+            if (validator == null) {
+                return false;
+            }
+            if (!validator(input)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    parseAfterValidation(_ctx, input) {
+        return input;
+    }
+    reportDecodeError(ctx, input) {
+        return buildError(ctx, `expected string with format "${this.formats.join(" and ")}"`, input);
+    }
+    hash(_ctx) {
+        let acc = [stringWithFormatHash];
+        for (const f of [...this.formats].sort()) {
+            acc.push(generateHashFromString(f));
+        }
+        return generateHashFromNumbers(acc);
+    }
+}
+export class NumberWithFormatRuntype {
+    formats;
+    constructor(formats) {
+        this.formats = formats;
+    }
+    describe(_ctx) {
+        if (this.formats.length === 0) {
+            throw new Error("INTERNAL ERROR: No formats provided");
+        }
+        const [first, ...rest] = this.formats;
+        let acc = `NumberFormat<"${first}">`;
+        for (const r of rest) {
+            acc = `NumberFormatExtends<${acc}, "${r}">`;
+        }
+        return acc;
+    }
+    schema(_ctx) {
+        return {
+            type: "number",
+            format: this.formats.join(" and "),
+        };
+    }
+    validate(_ctx, input) {
+        if (typeof input !== "number") {
+            return false;
+        }
+        for (const f of this.formats) {
+            const validator = numberFormatters[f];
+            if (validator == null) {
+                return false;
+            }
+            if (!validator(input)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    parseAfterValidation(_ctx, input) {
+        return input;
+    }
+    reportDecodeError(ctx, input) {
+        return buildError(ctx, `expected number with format "${this.formats.join(" and ")}"`, input);
+    }
+    hash(_ctx) {
+        let acc = [numberWithFormatHash];
+        for (const f of [...this.formats].sort()) {
+            acc.push(generateHashFromString(f));
+        }
+        return generateHashFromNumbers(acc);
+    }
+}
+export class AnyOfConstsRuntype {
+    values;
+    constructor(values) {
+        this.values = values;
+    }
+    describe(_ctx) {
+        const parts = this.values.map((it) => JSON.stringify(it));
+        const inner = parts.join(" | ");
+        return `(${inner})`;
+    }
+    schema(_ctx) {
+        return {
+            enum: this.values,
+        };
+    }
+    validate(_ctx, input) {
+        if (input == null) {
+            if (this.values.includes(null)) {
+                return true;
+            }
+        }
+        return this.values.includes(input);
+    }
+    parseAfterValidation(_ctx, input) {
+        return input;
+    }
+    reportDecodeError(ctx, input) {
+        return buildError(ctx, `expected one of ${limitedCommaJoinJson(this.values)}`, input);
+    }
+    hash(_ctx) {
+        let acc = [anyOfConstsHash];
+        for (const v of [...this.values].sort()) {
+            if (v == null) {
+                acc.push(nullishHash);
+            }
+            else {
+                switch (typeof v) {
+                    case "string":
+                        acc.push(generateHashFromString(v));
+                        break;
+                    case "number":
+                        acc.push(generateHashFromNumbers([v]));
+                        break;
+                    case "boolean":
+                        acc.push(generateHashFromString(v ? "true" : "false"));
+                        break;
+                }
+            }
+        }
+        return generateHashFromNumbers(acc);
+    }
+}
+export class TupleRuntype {
+    prefix;
+    rest;
+    constructor(prefix, rest) {
+        this.prefix = prefix;
+        this.rest = rest;
+    }
+    describe(ctx) {
+        const prefix = this.prefix.map((it) => it.describe(ctx)).join(", ");
+        const rest = this.rest != null ? `...Array<${this.rest.describe(ctx)}>` : null;
+        const inner = [prefix, rest].filter((it) => it != null && it.length > 0).join(", ");
+        return `[${inner}]`;
+    }
+    schema(ctx) {
+        pushPath(ctx, "[]");
+        const prefixItems = this.prefix.map((it) => it.schema(ctx));
+        const items = this.rest != null ? this.rest.schema(ctx) : false;
+        popPath(ctx);
+        return {
+            type: "array",
+            prefixItems,
+            items,
+        };
+    }
+    validate(ctx, input) {
+        if (Array.isArray(input)) {
+            let idx = 0;
+            for (const prefixItem of this.prefix) {
+                if (!prefixItem.validate(ctx, input[idx])) {
+                    return false;
+                }
+                idx++;
+            }
+            if (this.rest != null) {
+                for (let i = idx; i < input.length; i++) {
+                    if (!this.rest.validate(ctx, input[i])) {
+                        return false;
+                    }
+                }
+            }
+            else {
+                if (input.length > idx) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    parseAfterValidation(ctx, input) {
+        let idx = 0;
+        let acc = [];
+        for (const prefixItem of this.prefix) {
+            acc.push(prefixItem.parseAfterValidation(ctx, input[idx]));
+            idx++;
+        }
+        if (this.rest != null) {
+            for (let i = idx; i < input.length; i++) {
+                acc.push(this.rest.parseAfterValidation(ctx, input[i]));
+            }
+        }
+        return acc;
+    }
+    reportDecodeError(ctx, input) {
+        if (!Array.isArray(input)) {
+            return buildError(ctx, "expected tuple", input);
+        }
+        let idx = 0;
+        let acc = [];
+        for (const prefixItem of this.prefix) {
+            const ok = prefixItem.validate(ctx, input[idx]);
+            if (!ok) {
+                pushPath(ctx, `[${idx}]`);
+                const errors = prefixItem.reportDecodeError(ctx, input[idx]);
+                acc.push(...errors);
+                popPath(ctx);
+            }
+            idx++;
+        }
+        if (this.rest != null) {
+            for (let i = idx; i < input.length; i++) {
+                const ok = this.rest.validate(ctx, input[i]);
+                if (!ok) {
+                    pushPath(ctx, `[${i}]`);
+                    const errors = this.rest.reportDecodeError(ctx, input[i]);
+                    acc.push(...errors);
+                    popPath(ctx);
+                }
+            }
+        }
+        return acc;
+    }
+    hash(ctx) {
+        let acc = [tupleHash];
+        for (const p of this.prefix) {
+            acc.push(p.hash(ctx));
+        }
+        if (this.rest != null) {
+            acc.push(this.rest.hash(ctx));
+        }
+        else {
+            acc.push(0);
+        }
+        return generateHashFromNumbers(acc);
+    }
+}
+export class AllOfRuntype {
+    schemas;
+    constructor(schemas) {
+        this.schemas = schemas;
+    }
+    describe(ctx) {
+        return `(${this.schemas.map((it) => it.describe(ctx)).join(" & ")})`;
+    }
+    schema(ctx) {
+        return {
+            allOf: this.schemas.map((it) => it.schema(ctx)),
+        };
+    }
+    validate(ctx, input) {
+        for (const it of this.schemas) {
+            const isObj = typeof input === "object";
+            if (!isObj) {
+                return false;
+            }
+            if (!it.validate(ctx, input)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    parseAfterValidation(ctx, input) {
+        let acc = {};
+        for (const it of this.schemas) {
+            const parsed = it.parseAfterValidation(ctx, input);
+            if (typeof parsed !== "object") {
+                throw new Error("INTERNAL ERROR: AllOfParser: Expected object");
+            }
+            acc = { ...acc, ...parsed };
+        }
+        return acc;
+    }
+    reportDecodeError(ctx, input) {
+        const acc = [];
+        for (const v of this.schemas) {
+            const errors = v.reportDecodeError(ctx, input);
+            acc.push(...errors);
+        }
+        return acc;
+    }
+    hash(ctx) {
+        let acc = [allOfHash];
+        for (const s of this.schemas) {
+            acc.push(s.hash(ctx));
+        }
+        return generateHashFromNumbers(acc);
+    }
+}
+export class AnyOfRuntype {
+    schemas;
+    constructor(schemas) {
+        this.schemas = schemas;
+    }
+    schema(ctx) {
+        return {
+            anyOf: this.schemas.map((it) => it.schema(ctx)),
+        };
+    }
+    validate(ctx, input) {
+        for (const it of this.schemas) {
+            if (it.validate(ctx, input)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    parseAfterValidation(ctx, input) {
+        const items = [];
+        for (const it of this.schemas) {
+            if (it.validate(ctx, input)) {
+                items.push(it.parseAfterValidation(ctx, input));
+            }
+        }
+        return deepmerge(...items);
+    }
+    reportDecodeError(ctx, input) {
+        const acc = [];
+        const oldPaths = ctx.path;
+        ctx.path = [];
+        for (const v of this.schemas) {
+            const errors = v.reportDecodeError(ctx, input);
+            acc.push(...errors);
+        }
+        ctx.path = oldPaths;
+        return buildUnionError(ctx, acc, input);
+    }
+    describe(ctx) {
+        return `(${this.schemas.map((it) => it.describe(ctx)).join(" | ")})`;
+    }
+    hash(ctx) {
+        let acc = [anyOfHash];
+        for (const s of this.schemas) {
+            acc.push(s.hash(ctx));
+        }
+        return generateHashFromNumbers(acc);
+    }
+}
+export class ArrayRuntype {
+    itemParser;
+    constructor(itemParser) {
+        this.itemParser = itemParser;
+    }
+    schema(ctx) {
+        pushPath(ctx, "[]");
+        const items = this.itemParser.schema(ctx);
+        popPath(ctx);
+        return {
+            type: "array",
+            items,
+        };
+    }
+    validate(ctx, input) {
+        if (Array.isArray(input)) {
+            for (let i = 0; i < input.length; i++) {
+                const v = input[i];
+                const ok = this.itemParser.validate(ctx, v);
+                if (!ok) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    parseAfterValidation(ctx, input) {
+        return input.map((v) => this.itemParser.parseAfterValidation(ctx, v));
+    }
+    reportDecodeError(ctx, input) {
+        if (!Array.isArray(input)) {
+            return buildError(ctx, "expected array", input);
+        }
+        let acc = [];
+        for (let i = 0; i < input.length; i++) {
+            const ok = this.itemParser.validate(ctx, input[i]);
+            if (!ok) {
+                pushPath(ctx, `[${i}]`);
+                const v = input[i];
+                const arr2 = this.itemParser.reportDecodeError(ctx, v);
+                acc.push(...arr2);
+                popPath(ctx);
+            }
+        }
+        return acc;
+    }
+    describe(ctx) {
+        return `Array<${this.itemParser.describe(ctx)}>`;
+    }
+    hash(ctx) {
+        return generateHashFromNumbers([arrayHash, this.itemParser.hash(ctx)]);
+    }
+}
+export class AnyOfDiscriminatedRuntype {
+    schemas;
+    discriminator;
+    mapping;
+    constructor(schemas, discriminator, mapping) {
+        this.schemas = schemas;
+        this.discriminator = discriminator;
+        this.mapping = mapping;
+    }
+    schema(ctx) {
+        return {
+            anyOf: this.schemas.map((it) => it.schema(ctx)),
+        };
+    }
+    validate(ctx, input) {
+        if (typeof input !== "object" || input == null) {
+            return false;
+        }
+        const d = input[this.discriminator];
+        if (d == null) {
+            return false;
+        }
+        const v = this.mapping[d];
+        if (v == null) {
+            return false;
+        }
+        return v.validate(ctx, input);
+    }
+    parseAfterValidation(ctx, input) {
+        const parser = this.mapping[input[this.discriminator]];
+        if (parser == null) {
+            throw new Error("INTERNAL ERROR: Missing parser for discriminator " + JSON.stringify(input[this.discriminator]));
+        }
+        return {
+            ...parser.parseAfterValidation(ctx, input),
+            [this.discriminator]: input[this.discriminator],
+        };
+    }
+    reportDecodeError(ctx, input) {
+        if (input == null || typeof input !== "object") {
+            return buildError(ctx, "expected object", input);
+        }
+        const d = input[this.discriminator];
+        if (d == null) {
+            return buildError(ctx, "expected discriminator key " + JSON.stringify(this.discriminator), input);
+        }
+        const v = this.mapping[d];
+        if (v == null) {
+            pushPath(ctx, this.discriminator);
+            const errs = buildError(ctx, "expected one of " +
+                Object.keys(this.mapping)
+                    .map((it) => JSON.stringify(it))
+                    .join(", "), d);
+            popPath(ctx);
+            return errs;
+        }
+        return v.reportDecodeError(ctx, input);
+    }
+    describe(ctx) {
+        return `(${this.schemas.map((it) => it.describe(ctx)).join(" | ")})`;
+    }
+    hash(ctx) {
+        let acc = [anyOfHash];
+        for (const s of this.schemas) {
+            acc.push(s.hash(ctx));
+        }
+        return generateHashFromNumbers(acc);
+    }
+}
+export class OptionalFieldRuntype {
+    t;
+    constructor(t) {
+        this.t = t;
+    }
+    schema(ctx) {
+        const inner = this.t.schema(ctx);
+        return {
+            anyOf: [inner, { type: "null" }],
+        };
+    }
+    validate(ctx, input) {
+        if (input == null) {
+            return true;
+        }
+        return this.t.validate(ctx, input);
+    }
+    parseAfterValidation(ctx, input) {
+        if (input == null) {
+            return input;
+        }
+        return this.t.parseAfterValidation(ctx, input);
+    }
+    reportDecodeError(ctx, input) {
+        const acc = [];
+        acc.push(...buildError(ctx, "expected nullish value", input));
+        return [...acc, ...this.t.reportDecodeError(ctx, input)];
+    }
+    describe(ctx) {
+        return this.t.describe(ctx);
+    }
+    hash(ctx) {
+        let acc = [optionalFieldHash, this.t.hash(ctx)];
+        return generateHashFromNumbers(acc);
+    }
+}
+export class ObjectRuntype {
+    properties;
+    indexedPropertiesParser;
+    constructor(properties, indexedPropertiesParser) {
+        this.properties = properties;
+        this.indexedPropertiesParser = indexedPropertiesParser;
+    }
+    describe(ctx) {
+        const sortedKeys = Object.keys(this.properties).sort();
+        const props = sortedKeys
+            .map((k) => {
+            const it = this.properties[k];
+            const optionalMark = it instanceof OptionalFieldRuntype ? "?" : "";
+            return `${k}${optionalMark}: ${it.describe(ctx)}`;
+        })
+            .join(", ");
+        const indexPropsParats = this.indexedPropertiesParser.map(({ key, value }) => {
+            return `[K in ${key.describe(ctx)}]: ${value.describe(ctx)}`;
+        });
+        const rest = indexPropsParats.join(", ");
+        const content = [props, rest].filter((it) => it != null && it.length > 0).join(", ");
+        return `{ ${content} }`;
+    }
+    schema(ctx) {
+        const properties = {};
+        for (const k in this.properties) {
+            pushPath(ctx, k);
+            const item = this.properties[k];
+            properties[k] = item.schema(ctx);
+            popPath(ctx);
+        }
+        const required = Object.keys(this.properties);
+        const base = {
+            type: "object",
+            properties,
+            required,
+        };
+        const indexSchemas = this.indexedPropertiesParser.map(({ key, value }) => {
+            pushPath(ctx, "[key]");
+            const keySchema = key.schema(ctx);
+            popPath(ctx);
+            pushPath(ctx, "[value]");
+            const valueSchema = value.schema(ctx);
+            popPath(ctx);
+            return {
+                type: "object",
+                additionalProperties: valueSchema,
+                propertyNames: keySchema,
+            };
+        });
+        if (indexSchemas.length === 0) {
+            return { ...base, additionalProperties: false };
+        }
+        return {
+            allOf: [base, ...indexSchemas],
+        };
+    }
+    validate(ctx, input) {
+        if (typeof input === "object" && !Array.isArray(input) && input !== null) {
+            const configKeys = Object.keys(this.properties);
+            for (const k of configKeys) {
+                const validator = this.properties[k];
+                if (!validator.validate(ctx, input[k])) {
+                    return false;
+                }
+            }
+            if (this.indexedPropertiesParser.length > 0) {
+                const inputKeys = Object.keys(input);
+                const extraKeys = inputKeys.filter((k) => !configKeys.includes(k));
+                for (const k of extraKeys) {
+                    let isValid = false;
+                    for (const p of this.indexedPropertiesParser) {
+                        if (!p.key.validate(ctx, k)) {
+                            continue;
+                        }
+                        const v = input[k];
+                        if (!p.value.validate(ctx, v)) {
+                            continue;
+                        }
+                        isValid = true;
+                        break;
+                    }
+                    if (!isValid) {
+                        return false;
+                    }
+                }
+            }
+            else {
+                if (ctx.disallowExtraProperties) {
+                    const inputKeys = Object.keys(input);
+                    const extraKeys = inputKeys.filter((k) => !configKeys.includes(k));
+                    if (extraKeys.length > 0) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    parseAfterValidation(ctx, input) {
+        let acc = {};
+        const inputKeys = Object.keys(input);
+        for (const k of inputKeys) {
+            const v = input[k];
+            if (k in this.properties) {
+                const itemParsed = this.properties[k].parseAfterValidation(ctx, v);
+                acc[k] = itemParsed;
+            }
+            else if (this.indexedPropertiesParser.length > 0) {
+                for (const p of this.indexedPropertiesParser) {
+                    const isValid = p.key.validate(ctx, k) && p.value.validate(ctx, v);
+                    if (isValid) {
+                        const itemParsed = p.value.parseAfterValidation(ctx, v);
+                        const keyParsed = p.key.parseAfterValidation(ctx, k);
+                        acc[keyParsed] = itemParsed;
+                    }
+                }
+            }
+        }
+        return acc;
+    }
+    reportDecodeError(ctx, input) {
+        if (typeof input !== "object" || Array.isArray(input) || input === null) {
+            return buildError(ctx, "expected object", input);
+        }
+        let acc = [];
+        const configKeys = Object.keys(this.properties);
+        for (const k of configKeys) {
+            const ok = this.properties[k].validate(ctx, input[k]);
+            if (!ok) {
+                pushPath(ctx, k);
+                const arr2 = this.properties[k].reportDecodeError(ctx, input[k]);
+                acc.push(...arr2);
+                popPath(ctx);
+            }
+        }
+        if (this.indexedPropertiesParser.length > 0) {
+            const inputKeys = Object.keys(input);
+            const extraKeys = inputKeys.filter((k) => !configKeys.includes(k));
+            for (const k of extraKeys) {
+                for (const p of this.indexedPropertiesParser) {
+                    const keyOk = p.key.validate(ctx, k);
+                    const valueOk = p.value.validate(ctx, input[k]);
+                    const ok = keyOk && valueOk;
+                    if (!ok) {
+                        pushPath(ctx, k);
+                        if (!keyOk) {
+                            const keyReported = p.key.reportDecodeError(ctx, k);
+                            acc.push(...keyReported);
+                        }
+                        if (!valueOk) {
+                            const valueReported = p.value.reportDecodeError(ctx, input[k]);
+                            acc.push(...valueReported);
+                        }
+                        popPath(ctx);
+                    }
+                }
+            }
+        }
+        else {
+            if (ctx.disallowExtraProperties) {
+                const inputKeys = Object.keys(input);
+                const extraKeys = inputKeys.filter((k) => !configKeys.includes(k));
+                if (extraKeys.length > 0) {
+                    return extraKeys
+                        .map((k) => {
+                        pushPath(ctx, k);
+                        const err = buildError(ctx, `extra property`, input[k]);
+                        popPath(ctx);
+                        return err;
+                    })
+                        .reduce((a, b) => a.concat(b), []);
+                }
+            }
+        }
+        return acc;
+    }
+    hash(ctx) {
+        let acc = [objectHash];
+        for (const key of Object.keys(this.properties).sort()) {
+            acc.push(generateHashFromString(key));
+            const parser = this.properties[key];
+            acc.push(parser.hash(ctx));
+        }
+        if (this.indexedPropertiesParser.length > 0) {
+            for (const p of this.indexedPropertiesParser) {
+                acc.push(p.key.hash(ctx));
+                acc.push(p.value.hash(ctx));
+            }
+        }
+        return generateHashFromNumbers(acc);
+    }
+}
+export const buildParserFromRuntype = (runtype, name, isB) => {
+    const validate = ((input, options) => {
+        const disallowExtraProperties = options?.disallowExtraProperties ?? false;
+        const ctx = { disallowExtraProperties };
+        const ok = runtype.validate(ctx, input);
+        if (typeof ok !== "boolean") {
+            throw new Error("INTERNAL ERROR: Expected boolean");
+        }
+        return ok;
+    });
+    const schema = () => {
+        const ctx = {
+            path: [],
+            seen: {},
+        };
+        return runtype.schema(ctx);
+    };
+    const hash = () => {
+        const ctx = {
+            seen: {},
+        };
+        return runtype.hash(ctx);
+    };
+    const describe = () => {
+        const ctx = {
+            deps: {},
+            deps_counter: {},
+            measure: true,
+        };
+        let out = runtype.describe(ctx);
+        ctx["deps"] = {};
+        ctx["measure"] = false;
+        out = runtype.describe(ctx);
+        let sortedDepsKeys = Object.keys(ctx.deps).sort();
+        // if sorted deps includes k, make it last
+        // if (sortedDepsKeys.includes(k)) {
+        //   sortedDepsKeys = sortedDepsKeys.filter(it => it !== k).concat([k]);
+        // }
+        const depsPart = sortedDepsKeys
+            .map((key) => {
+            return `type ${key} = ${ctx.deps[key]};`;
+        })
+            .join("\n\n");
+        if (isB) {
+            return [depsPart, out].filter((it) => it != null && it.length > 0).join("\n\n");
+        }
+        // if (k in ctx.deps) {
+        //   return depsPart;
+        // }
+        const outPart = `type Codec${name} = ${out};`;
+        return [depsPart, outPart].filter((it) => it != null && it.length > 0).join("\n\n");
+    };
+    const safeParse = (input, options) => {
+        const disallowExtraProperties = options?.disallowExtraProperties ?? false;
+        const ok = validate(input, options);
+        if (ok) {
+            let ctx = { disallowExtraProperties };
+            const parsed = runtype.parseAfterValidation(ctx, input);
+            return { success: true, data: parsed };
+        }
+        let ctx = { path: [], disallowExtraProperties };
+        return {
+            success: false,
+            errors: runtype.reportDecodeError(ctx, input).slice(0, 10),
+        };
+    };
+    const parse = (input, options) => {
+        const safe = safeParse(input, options);
+        if (safe.success) {
+            return safe.data;
+        }
+        const explained = printErrors(safe.errors, []);
+        throw new Error(`Failed to parse ${name} - ${explained}`);
+    };
+    const zod = () => {
+        //@ts-ignore
+        return z.custom((data) => validate(data), 
+        //@ts-ignore
+        (val) => {
+            const errors = runtype.reportDecodeError({ path: [], disallowExtraProperties: false }, val);
+            return printErrors(errors, []);
+        });
+    };
+    const it = {
+        validate,
+        schema,
+        describe,
+        safeParse,
+        parse,
+        zod,
+        name: name,
+        hash,
+        _runtype: runtype,
+    };
+    return it;
+};