import * as _ from "@preserves/core";

export const $1 = 1;
export const $Boolean = Symbol.for("Boolean");
export const $ByteString = Symbol.for("ByteString");
export const $Double = Symbol.for("Double");
export const $Float = Symbol.for("Float");
export const $SignedInteger = Symbol.for("SignedInteger");
export const $String = Symbol.for("String");
export const $Symbol = Symbol.for("Symbol");
export const $and = Symbol.for("and");
export const $atom = Symbol.for("atom");
export const $definitions = Symbol.for("definitions");
export const $dict = Symbol.for("dict");
export const $dictof = Symbol.for("dictof");
export const $lit = Symbol.for("lit");
export const $named = Symbol.for("named");
export const $or = Symbol.for("or");
export const $pointer = Symbol.for("pointer");
export const $rec = Symbol.for("rec");
export const $ref = Symbol.for("ref");
export const $schema = Symbol.for("schema");
export const $setof = Symbol.for("setof");
export const $tuple = Symbol.for("tuple");
export const $tuple_STAR_ = Symbol.for("tuple*");
export const $version = Symbol.for("version");
export const __lit5 = false;

export const Schema = _.Record.makeConstructor<{
    "_field0": (
        {
            get(k: typeof $version): Version;
            get(k: typeof $pointer): PointerName;
            get(k: typeof $definitions): _.KeyedDictionary<symbol, Definition, _ptr>;
            has(k: typeof $version): true;
            has(k: typeof $pointer): true;
            has(k: typeof $definitions): true;
        } & _.Dictionary<_ptr>
    )
}, _ptr>()($schema, ["_field0"]);

export type Schema = _.Record<
    (typeof $schema),
    [
        (
            {
                get(k: typeof $version): Version;
                get(k: typeof $pointer): PointerName;
                get(k: typeof $definitions): _.KeyedDictionary<symbol, Definition, _ptr>;
                has(k: typeof $version): true;
                has(k: typeof $pointer): true;
                has(k: typeof $definitions): true;
            } & _.Dictionary<_ptr>
        )
    ],
    _ptr
>;

export type Version = (typeof $1);

export type PointerName = (Ref | (typeof __lit5));

export type Definition = (_.Record<(typeof $or), [Array<NamedAlternative>], _ptr> | Alternative);

export type NamedAlternative = [symbol, Alternative];

export type Alternative = (_.Record<(typeof $and), [Array<Pattern>], _ptr> | Pattern);

export type Pattern = (SimplePattern | CompoundPattern);

export type SimplePattern = (
    _.Record<(typeof $atom), [AtomKind], _ptr> |
    _.Record<(typeof $pointer), [], _ptr> |
    _.Record<(typeof $lit), [_val], _ptr> |
    Ref
);

export type CompoundPattern = (
    _.Record<(typeof $rec), [Pattern, Pattern], _ptr> |
    _.Record<(typeof $tuple), [Array<NamedPattern>], _ptr> |
    _.Record<(typeof $tuple_STAR_), [Array<NamedPattern>, NamedPattern], _ptr> |
    _.Record<(typeof $setof), [SimplePattern], _ptr> |
    _.Record<(typeof $dictof), [SimplePattern, SimplePattern], _ptr> |
    _.Record<(typeof $dict), [DictionaryEntries], _ptr>
);

export type DictionaryEntries = _.KeyedDictionary<_val, NamedPattern, _ptr>;

export type AtomKind = (
    (typeof $Boolean) |
    (typeof $Float) |
    (typeof $Double) |
    (typeof $SignedInteger) |
    (typeof $String) |
    (typeof $ByteString) |
    (typeof $Symbol)
);

export type NamedPattern = (_.Record<(typeof $named), [symbol, SimplePattern], _ptr> | Pattern);

export const Ref = _.Record.makeConstructor<{"module": ModulePath, "name": symbol}, _ptr>()($ref, ["module","name"]);

export type Ref = _.Record<(typeof $ref), [ModulePath, symbol], _ptr>;

export type ModulePath = Array<symbol>;

export type _ptr = never;

export type _val = _.Value<_ptr>;


export function isSchema(v: any): v is Schema {
    let _tmp0, _tmp1, _tmp2: any;
    return (
        _.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
        _.is(v.label, $schema) &&
        (
            (v.length === 1) &&
            (
                _.Dictionary.isDictionary<_ptr>(v[0]) &&
                ((_tmp0 = v[0].get($version)) !== void 0 && isVersion(_tmp0)) &&
                ((_tmp1 = v[0].get($pointer)) !== void 0 && isPointerName(_tmp1)) &&
                (
                    (_tmp2 = v[0].get($definitions)) !== void 0 && (
                        _.Dictionary.isDictionary<_ptr>(_tmp2) &&
                        ((() => {
                            for (const e of _tmp2) {
                                if (!(typeof e[0] === 'symbol')) return false;
                                if (!(isDefinition(e[1]))) return false;
                            };
                            return true;
                        })())
                    )
                )
            )
        )
    );
}

export function asSchema(v: any): Schema {
    if (!isSchema(v)) {throw new TypeError(`Invalid Schema: ${_.stringify(v)}`);} else {return v;};
}

export function decodeSchema(d: _.TypedDecoder<_ptr>): Schema | undefined {
    let result;
    if (d.openRecord()) {
        let _tmp0: any;
        _tmp0 = _.asLiteral(d.nextSymbol(), $schema);
        if (_tmp0 !== void 0) {
            let _tmp1, _tmp2, _tmp3, _tmp4, _tmp5: any;
            _tmp2 = d.next();
            if (_tmp2 !== void 0 && !((
                _.Dictionary.isDictionary<_ptr>(_tmp2) &&
                ((_tmp3 = _tmp2.get($version)) !== void 0 && isVersion(_tmp3)) &&
                ((_tmp4 = _tmp2.get($pointer)) !== void 0 && isPointerName(_tmp4)) &&
                (
                    (_tmp5 = _tmp2.get($definitions)) !== void 0 && (
                        _.Dictionary.isDictionary<_ptr>(_tmp5) &&
                        ((() => {
                            for (const e of _tmp5) {
                                if (!(typeof e[0] === 'symbol')) return false;
                                if (!(isDefinition(e[1]))) return false;
                            };
                            return true;
                        })())
                    )
                )
            ))) _tmp2 = void 0;
            if (_tmp2 !== void 0) {
                if (d.closeCompound()) _tmp1 = [_tmp2] as [
                    (
                        {
                            get(k: typeof $version): Version;
                            get(k: typeof $pointer): PointerName;
                            get(k: typeof $definitions): _.KeyedDictionary<symbol, Definition, _ptr>;
                            has(k: typeof $version): true;
                            has(k: typeof $pointer): true;
                            has(k: typeof $definitions): true;
                        } & _.Dictionary<_ptr>
                    )
                ];
            };
            if (_tmp1 !== void 0) result = _.Record<
                (typeof $schema),
                [
                    (
                        {
                            get(k: typeof $version): Version;
                            get(k: typeof $pointer): PointerName;
                            get(k: typeof $definitions): _.KeyedDictionary<symbol, Definition, _ptr>;
                            has(k: typeof $version): true;
                            has(k: typeof $pointer): true;
                            has(k: typeof $definitions): true;
                        } & _.Dictionary<_ptr>
                    )
                ]
            >(_tmp0 as any, _tmp1 as any);
        };
    };
    return result;
}

export function isVersion(v: any): v is Version {return _.is(v, $1);}

export function asVersion(v: any): Version {
    if (!isVersion(v)) {throw new TypeError(`Invalid Version: ${_.stringify(v)}`);} else {return v;};
}

export function decodeVersion(d: _.TypedDecoder<_ptr>): Version | undefined {let result; result = _.asLiteral(d.nextSignedInteger(), $1); return result;}

export function isPointerName(v: any): v is PointerName {return (isRef(v) || _.is(v, __lit5));}

export function asPointerName(v: any): PointerName {
    if (!isPointerName(v)) {throw new TypeError(`Invalid PointerName: ${_.stringify(v)}`);} else {return v;};
}

export function decodePointerName(d: _.TypedDecoder<_ptr>): PointerName | undefined {
    let _tmp0: any;
    let result;
    _tmp0 = d.mark();
    result = decodeRef(d);
    if (result === void 0) {d.restoreMark(_tmp0); result = _.asLiteral(d.nextBoolean(), __lit5);};
    return result;
}

export function isDefinition(v: any): v is Definition {
    return (
        (
            _.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
            _.is(v.label, $or) &&
            (
                (v.length === 1) &&
                (
                    _.Array.isArray(v[0]) &&
                    !_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v[0]) &&
                    (v[0].length >= 0) &&
                    v[0].every(v => (isNamedAlternative(v)))
                )
            )
        ) ||
        isAlternative(v)
    );
}

export function asDefinition(v: any): Definition {
    if (!isDefinition(v)) {throw new TypeError(`Invalid Definition: ${_.stringify(v)}`);} else {return v;};
}

export function decodeDefinition(d: _.TypedDecoder<_ptr>): Definition | undefined {
    let _tmp0: any;
    let result;
    _tmp0 = d.mark();
    if (d.openRecord()) {
        let _tmp1: any;
        _tmp1 = _.asLiteral(d.nextSymbol(), $or);
        if (_tmp1 !== void 0) {
            let _tmp2, _tmp3: any;
            if (d.openSequence()) {
                let _tmp4: any;
                {
                    let vN: Array<NamedAlternative> | undefined = [];
                    while (!d.closeCompound()) {
                        _tmp4 = void 0;
                        _tmp4 = decodeNamedAlternative(d);
                        if (_tmp4 === void 0) {vN = void 0; break;};
                        vN.push(_tmp4);
                    };
                    _tmp3 = vN;
                };
            };
            if (_tmp3 !== void 0) {if (d.closeCompound()) _tmp2 = [_tmp3] as [Array<NamedAlternative>];};
            if (_tmp2 !== void 0) result = _.Record<(typeof $or), [Array<NamedAlternative>]>(_tmp1 as any, _tmp2 as any);
        };
    };
    if (result === void 0) {d.restoreMark(_tmp0); result = decodeAlternative(d);};
    return result;
}

export function isNamedAlternative(v: any): v is NamedAlternative {
    return (
        _.Array.isArray(v) &&
        !_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
        (v.length === 2) &&
        typeof v[0] === 'symbol' &&
        isAlternative(v[1])
    );
}

export function asNamedAlternative(v: any): NamedAlternative {
    if (!isNamedAlternative(v)) {throw new TypeError(`Invalid NamedAlternative: ${_.stringify(v)}`);} else {return v;};
}

export function decodeNamedAlternative(d: _.TypedDecoder<_ptr>): NamedAlternative | undefined {
    let _tmp0, _tmp1: any;
    let result;
    if (d.openSequence()) {
        _tmp0 = d.nextSymbol();
        if (_tmp0 !== void 0) {
            _tmp1 = decodeAlternative(d);
            if (_tmp1 !== void 0) {if (d.closeCompound()) result = [_tmp0, _tmp1] as [symbol, Alternative];};
        };
    };
    return result;
}

export function isAlternative(v: any): v is Alternative {
    return (
        (
            _.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
            _.is(v.label, $and) &&
            (
                (v.length === 1) &&
                (
                    _.Array.isArray(v[0]) &&
                    !_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v[0]) &&
                    (v[0].length >= 0) &&
                    v[0].every(v => (isPattern(v)))
                )
            )
        ) ||
        isPattern(v)
    );
}

export function asAlternative(v: any): Alternative {
    if (!isAlternative(v)) {throw new TypeError(`Invalid Alternative: ${_.stringify(v)}`);} else {return v;};
}

export function decodeAlternative(d: _.TypedDecoder<_ptr>): Alternative | undefined {
    let _tmp0: any;
    let result;
    _tmp0 = d.mark();
    if (d.openRecord()) {
        let _tmp1: any;
        _tmp1 = _.asLiteral(d.nextSymbol(), $and);
        if (_tmp1 !== void 0) {
            let _tmp2, _tmp3: any;
            if (d.openSequence()) {
                let _tmp4: any;
                {
                    let vN: Array<Pattern> | undefined = [];
                    while (!d.closeCompound()) {
                        _tmp4 = void 0;
                        _tmp4 = decodePattern(d);
                        if (_tmp4 === void 0) {vN = void 0; break;};
                        vN.push(_tmp4);
                    };
                    _tmp3 = vN;
                };
            };
            if (_tmp3 !== void 0) {if (d.closeCompound()) _tmp2 = [_tmp3] as [Array<Pattern>];};
            if (_tmp2 !== void 0) result = _.Record<(typeof $and), [Array<Pattern>]>(_tmp1 as any, _tmp2 as any);
        };
    };
    if (result === void 0) {d.restoreMark(_tmp0); result = decodePattern(d);};
    return result;
}

export function isPattern(v: any): v is Pattern {return (isSimplePattern(v) || isCompoundPattern(v));}

export function asPattern(v: any): Pattern {
    if (!isPattern(v)) {throw new TypeError(`Invalid Pattern: ${_.stringify(v)}`);} else {return v;};
}

export function decodePattern(d: _.TypedDecoder<_ptr>): Pattern | undefined {
    let _tmp0: any;
    let result;
    _tmp0 = d.mark();
    result = decodeSimplePattern(d);
    if (result === void 0) {d.restoreMark(_tmp0); result = decodeCompoundPattern(d);};
    return result;
}

export function isSimplePattern(v: any): v is SimplePattern {
    return _.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) && (
        (
            (_.is(v.label, $atom) && ((v.length === 1) && isAtomKind(v[0]))) ||
            (_.is(v.label, $pointer) && ((v.length === 0))) ||
            (_.is(v.label, $lit) && ((v.length === 1) && true)) ||
            (
                _.is(v.label, $ref) && ((v.length === 2) && isModulePath(v[0]) && typeof v[1] === 'symbol')
            )
        )
    );
}

export function asSimplePattern(v: any): SimplePattern {
    if (!isSimplePattern(v)) {throw new TypeError(`Invalid SimplePattern: ${_.stringify(v)}`);} else {return v;};
}

export function decodeSimplePattern(d: _.TypedDecoder<_ptr>): SimplePattern | undefined {
    let result;
    if (d.openRecord()) {
        let _tmp0, _tmp1: any;
        _tmp0 = d.next();
        _tmp1 = d.mark();
        if (_.is(_tmp0, $atom)) {
            let _tmp2, _tmp3: any;
            _tmp3 = decodeAtomKind(d);
            if (_tmp3 !== void 0) {if (d.closeCompound()) _tmp2 = [_tmp3] as [AtomKind];};
            if (_tmp2 !== void 0) result = _.Record<(typeof $atom), [AtomKind]>(_tmp0 as any, _tmp2 as any);
        };
        if (result === void 0) {
            d.restoreMark(_tmp1);
            if (_.is(_tmp0, $pointer)) {
                let _tmp4: any;
                if (d.closeCompound()) _tmp4 = [] as [];
                if (_tmp4 !== void 0) result = _.Record<(typeof $pointer), []>(_tmp0 as any, _tmp4 as any);
            };
            if (result === void 0) {
                d.restoreMark(_tmp1);
                if (_.is(_tmp0, $lit)) {
                    let _tmp5, _tmp6: any;
                    _tmp6 = d.next();
                    if (_tmp6 !== void 0) {if (d.closeCompound()) _tmp5 = [_tmp6] as [_val];};
                    if (_tmp5 !== void 0) result = _.Record<(typeof $lit), [_val]>(_tmp0 as any, _tmp5 as any);
                };
                if (result === void 0) {
                    d.restoreMark(_tmp1);
                    if (_.is(_tmp0, $ref)) {
                        let _tmp7, _tmp8, _tmp9: any;
                        _tmp8 = decodeModulePath(d);
                        if (_tmp8 !== void 0) {
                            _tmp9 = d.nextSymbol();
                            if (_tmp9 !== void 0) {if (d.closeCompound()) _tmp7 = [_tmp8, _tmp9] as [ModulePath, symbol];};
                        };
                        if (_tmp7 !== void 0) result = _.Record<(typeof $ref), [ModulePath, symbol]>(_tmp0 as any, _tmp7 as any);
                    };
                };
            };
        };
    };
    return result;
}

export function isCompoundPattern(v: any): v is CompoundPattern {
    return _.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) && (
        (
            (
                _.is(v.label, $rec) && ((v.length === 2) && isPattern(v[0]) && isPattern(v[1]))
            ) ||
            (
                _.is(v.label, $tuple) && (
                    (v.length === 1) &&
                    (
                        _.Array.isArray(v[0]) &&
                        !_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v[0]) &&
                        (v[0].length >= 0) &&
                        v[0].every(v => (isNamedPattern(v)))
                    )
                )
            ) ||
            (
                _.is(v.label, $tuple_STAR_) && (
                    (v.length === 2) &&
                    (
                        _.Array.isArray(v[0]) &&
                        !_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v[0]) &&
                        (v[0].length >= 0) &&
                        v[0].every(v => (isNamedPattern(v)))
                    ) &&
                    isNamedPattern(v[1])
                )
            ) ||
            (_.is(v.label, $setof) && ((v.length === 1) && isSimplePattern(v[0]))) ||
            (
                _.is(v.label, $dictof) && ((v.length === 2) && isSimplePattern(v[0]) && isSimplePattern(v[1]))
            ) ||
            (_.is(v.label, $dict) && ((v.length === 1) && isDictionaryEntries(v[0])))
        )
    );
}

export function asCompoundPattern(v: any): CompoundPattern {
    if (!isCompoundPattern(v)) {throw new TypeError(`Invalid CompoundPattern: ${_.stringify(v)}`);} else {return v;};
}

export function decodeCompoundPattern(d: _.TypedDecoder<_ptr>): CompoundPattern | undefined {
    let result;
    if (d.openRecord()) {
        let _tmp0, _tmp1: any;
        _tmp0 = d.next();
        _tmp1 = d.mark();
        if (_.is(_tmp0, $rec)) {
            let _tmp2, _tmp3, _tmp4: any;
            _tmp3 = decodePattern(d);
            if (_tmp3 !== void 0) {
                _tmp4 = decodePattern(d);
                if (_tmp4 !== void 0) {if (d.closeCompound()) _tmp2 = [_tmp3, _tmp4] as [Pattern, Pattern];};
            };
            if (_tmp2 !== void 0) result = _.Record<(typeof $rec), [Pattern, Pattern]>(_tmp0 as any, _tmp2 as any);
        };
        if (result === void 0) {
            d.restoreMark(_tmp1);
            if (_.is(_tmp0, $tuple)) {
                let _tmp5, _tmp6: any;
                if (d.openSequence()) {
                    let _tmp7: any;
                    {
                        let vN: Array<NamedPattern> | undefined = [];
                        while (!d.closeCompound()) {
                            _tmp7 = void 0;
                            _tmp7 = decodeNamedPattern(d);
                            if (_tmp7 === void 0) {vN = void 0; break;};
                            vN.push(_tmp7);
                        };
                        _tmp6 = vN;
                    };
                };
                if (_tmp6 !== void 0) {if (d.closeCompound()) _tmp5 = [_tmp6] as [Array<NamedPattern>];};
                if (_tmp5 !== void 0) result = _.Record<(typeof $tuple), [Array<NamedPattern>]>(_tmp0 as any, _tmp5 as any);
            };
            if (result === void 0) {
                d.restoreMark(_tmp1);
                if (_.is(_tmp0, $tuple_STAR_)) {
                    let _tmp8, _tmp9, _tmp10: any;
                    if (d.openSequence()) {
                        let _tmp11: any;
                        {
                            let vN: Array<NamedPattern> | undefined = [];
                            while (!d.closeCompound()) {
                                _tmp11 = void 0;
                                _tmp11 = decodeNamedPattern(d);
                                if (_tmp11 === void 0) {vN = void 0; break;};
                                vN.push(_tmp11);
                            };
                            _tmp9 = vN;
                        };
                    };
                    if (_tmp9 !== void 0) {
                        _tmp10 = decodeNamedPattern(d);
                        if (_tmp10 !== void 0) {
                            if (d.closeCompound()) _tmp8 = [_tmp9, _tmp10] as [Array<NamedPattern>, NamedPattern];
                        };
                    };
                    if (_tmp8 !== void 0) result = _.Record<(typeof $tuple_STAR_), [Array<NamedPattern>, NamedPattern]>(_tmp0 as any, _tmp8 as any);
                };
                if (result === void 0) {
                    d.restoreMark(_tmp1);
                    if (_.is(_tmp0, $setof)) {
                        let _tmp12, _tmp13: any;
                        _tmp13 = decodeSimplePattern(d);
                        if (_tmp13 !== void 0) {if (d.closeCompound()) _tmp12 = [_tmp13] as [SimplePattern];};
                        if (_tmp12 !== void 0) result = _.Record<(typeof $setof), [SimplePattern]>(_tmp0 as any, _tmp12 as any);
                    };
                    if (result === void 0) {
                        d.restoreMark(_tmp1);
                        if (_.is(_tmp0, $dictof)) {
                            let _tmp14, _tmp15, _tmp16: any;
                            _tmp15 = decodeSimplePattern(d);
                            if (_tmp15 !== void 0) {
                                _tmp16 = decodeSimplePattern(d);
                                if (_tmp16 !== void 0) {
                                    if (d.closeCompound()) _tmp14 = [_tmp15, _tmp16] as [SimplePattern, SimplePattern];
                                };
                            };
                            if (_tmp14 !== void 0) result = _.Record<(typeof $dictof), [SimplePattern, SimplePattern]>(_tmp0 as any, _tmp14 as any);
                        };
                        if (result === void 0) {
                            d.restoreMark(_tmp1);
                            if (_.is(_tmp0, $dict)) {
                                let _tmp17, _tmp18: any;
                                _tmp18 = decodeDictionaryEntries(d);
                                if (_tmp18 !== void 0) {if (d.closeCompound()) _tmp17 = [_tmp18] as [DictionaryEntries];};
                                if (_tmp17 !== void 0) result = _.Record<(typeof $dict), [DictionaryEntries]>(_tmp0 as any, _tmp17 as any);
                            };
                        };
                    };
                };
            };
        };
    };
    return result;
}

export function isDictionaryEntries(v: any): v is DictionaryEntries {
    return (
        _.Dictionary.isDictionary<_ptr>(v) &&
        ((() => {
            for (const e of v) {if (!(true)) return false; if (!(isNamedPattern(e[1]))) return false;};
            return true;
        })())
    );
}

export function asDictionaryEntries(v: any): DictionaryEntries {
    if (!isDictionaryEntries(v)) {throw new TypeError(`Invalid DictionaryEntries: ${_.stringify(v)}`);} else {return v;};
}

export function decodeDictionaryEntries(d: _.TypedDecoder<_ptr>): DictionaryEntries | undefined {
    let result;
    if (d.openDictionary()) {
        let r: _.KeyedDictionary<_val, NamedPattern, _ptr> | undefined = new _.KeyedDictionary();
        while (!d.closeCompound()) {
            let K: undefined | _val = void 0;
            K = d.next();
            if (K === void 0) { r = void 0; break; };
            let V: undefined | NamedPattern = void 0;
            V = decodeNamedPattern(d);
            if (V === void 0) { r = void 0; break; };
            r.set(K, V);
        };
        result = r;
    };
    return result;
}

export function isAtomKind(v: any): v is AtomKind {
    return (
        _.is(v, $Boolean) ||
        _.is(v, $Float) ||
        _.is(v, $Double) ||
        _.is(v, $SignedInteger) ||
        _.is(v, $String) ||
        _.is(v, $ByteString) ||
        _.is(v, $Symbol)
    );
}

export function asAtomKind(v: any): AtomKind {
    if (!isAtomKind(v)) {throw new TypeError(`Invalid AtomKind: ${_.stringify(v)}`);} else {return v;};
}

export function decodeAtomKind(d: _.TypedDecoder<_ptr>): AtomKind | undefined {
    let _tmp0: any;
    let result;
    _tmp0 = d.mark();
    result = _.asLiteral(d.nextSymbol(), $Boolean);
    if (result === void 0) {
        d.restoreMark(_tmp0);
        result = _.asLiteral(d.nextSymbol(), $Float);
        if (result === void 0) {
            d.restoreMark(_tmp0);
            result = _.asLiteral(d.nextSymbol(), $Double);
            if (result === void 0) {
                d.restoreMark(_tmp0);
                result = _.asLiteral(d.nextSymbol(), $SignedInteger);
                if (result === void 0) {
                    d.restoreMark(_tmp0);
                    result = _.asLiteral(d.nextSymbol(), $String);
                    if (result === void 0) {
                        d.restoreMark(_tmp0);
                        result = _.asLiteral(d.nextSymbol(), $ByteString);
                        if (result === void 0) {d.restoreMark(_tmp0); result = _.asLiteral(d.nextSymbol(), $Symbol);};
                    };
                };
            };
        };
    };
    return result;
}

export function isNamedPattern(v: any): v is NamedPattern {
    return (
        (
            _.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
            _.is(v.label, $named) &&
            ((v.length === 2) && typeof v[0] === 'symbol' && isSimplePattern(v[1]))
        ) ||
        isPattern(v)
    );
}

export function asNamedPattern(v: any): NamedPattern {
    if (!isNamedPattern(v)) {throw new TypeError(`Invalid NamedPattern: ${_.stringify(v)}`);} else {return v;};
}

export function decodeNamedPattern(d: _.TypedDecoder<_ptr>): NamedPattern | undefined {
    let _tmp0: any;
    let result;
    _tmp0 = d.mark();
    if (d.openRecord()) {
        let _tmp1: any;
        _tmp1 = _.asLiteral(d.nextSymbol(), $named);
        if (_tmp1 !== void 0) {
            let _tmp2, _tmp3, _tmp4: any;
            _tmp3 = d.nextSymbol();
            if (_tmp3 !== void 0) {
                _tmp4 = decodeSimplePattern(d);
                if (_tmp4 !== void 0) {if (d.closeCompound()) _tmp2 = [_tmp3, _tmp4] as [symbol, SimplePattern];};
            };
            if (_tmp2 !== void 0) result = _.Record<(typeof $named), [symbol, SimplePattern]>(_tmp1 as any, _tmp2 as any);
        };
    };
    if (result === void 0) {d.restoreMark(_tmp0); result = decodePattern(d);};
    return result;
}

export function isRef(v: any): v is Ref {
    return (
        _.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
        _.is(v.label, $ref) &&
        ((v.length === 2) && isModulePath(v[0]) && typeof v[1] === 'symbol')
    );
}

export function asRef(v: any): Ref {
    if (!isRef(v)) {throw new TypeError(`Invalid Ref: ${_.stringify(v)}`);} else {return v;};
}

export function decodeRef(d: _.TypedDecoder<_ptr>): Ref | undefined {
    let result;
    if (d.openRecord()) {
        let _tmp0: any;
        _tmp0 = _.asLiteral(d.nextSymbol(), $ref);
        if (_tmp0 !== void 0) {
            let _tmp1, _tmp2, _tmp3: any;
            _tmp2 = decodeModulePath(d);
            if (_tmp2 !== void 0) {
                _tmp3 = d.nextSymbol();
                if (_tmp3 !== void 0) {if (d.closeCompound()) _tmp1 = [_tmp2, _tmp3] as [ModulePath, symbol];};
            };
            if (_tmp1 !== void 0) result = _.Record<(typeof $ref), [ModulePath, symbol]>(_tmp0 as any, _tmp1 as any);
        };
    };
    return result;
}

export function isModulePath(v: any): v is ModulePath {
    return (
        _.Array.isArray(v) &&
        !_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v) &&
        (v.length >= 0) &&
        v.every(v => (typeof v === 'symbol'))
    );
}

export function asModulePath(v: any): ModulePath {
    if (!isModulePath(v)) {throw new TypeError(`Invalid ModulePath: ${_.stringify(v)}`);} else {return v;};
}

export function decodeModulePath(d: _.TypedDecoder<_ptr>): ModulePath | undefined {
    let result;
    if (d.openSequence()) {
        let _tmp0: any;
        {
            let vN: Array<symbol> | undefined = [];
            while (!d.closeCompound()) {
                _tmp0 = void 0;
                _tmp0 = d.nextSymbol();
                if (_tmp0 === void 0) {vN = void 0; break;};
                vN.push(_tmp0);
            };
            result = vN;
        };
    };
    return result;
}

export const _decodePtr = () => { throw new _.DecodeError("Pointers forbidden"); };