@jkcfg/std/internal/__std_generated.d.ts

jk standard library

import { flatbuffers } from "./flatbuffers";
/**
 * @enum {number}
 */
export declare namespace __std {
    enum DeferredRetval {
        NONE = 0,
        Deferred = 1,
        Error = 2
    }
}
/**
 * @enum {number}
 */
export declare namespace __std {
    enum FulfilmentValue {
        NONE = 0,
        Data = 1,
        EndOfStream = 2,
        Error = 3
    }
}
/**
 * @enum {number}
 */
export declare namespace __std {
    enum Format {
        FromExtension = 0,
        JSON = 1,
        YAML = 2,
        Raw = 3,
        YAMLStream = 4,
        JSONStream = 5,
        HCL = 6
    }
}
/**
 * @enum {number}
 */
export declare namespace __std {
    enum Overwrite {
        Skip = 0,
        Write = 1,
        Err = 2
    }
}
/**
 * Encoding specifies the requested form of the contents to read;
 * either just the raw bytes, or as a UTF-16 string. Distinguishing
 * String (a UTF16-encoded string) is desirable because JavaScript
 * natively supports UTF-16, so if you want to be able
 * to decode a string value conveniently, it is best to ship it as
 * UTF-16. Similarly, JSON is there as a means of sending structured
 * data, e.g., YAML, in a way that JavaScript can digest easily.
 *
 * @enum {number}
 */
export declare namespace __std {
    enum Encoding {
        Bytes = 0,
        String = 1,
        JSON = 2
    }
}
/**
 * @enum {number}
 */
export declare namespace __std {
    enum ParamType {
        Boolean = 0,
        Number = 1,
        String = 2,
        Object = 3
    }
}
/**
 * @enum {number}
 */
export declare namespace __std {
    enum ParamRetval {
        NONE = 0,
        ParamValue = 1,
        Error = 2
    }
}
/**
 * @enum {number}
 */
export declare namespace __std {
    enum ParseUnparseRetval {
        NONE = 0,
        ParseUnparseData = 1,
        Error = 2
    }
}
/**
 * RPCValue is a union of the types that can be sent as arguments.
 *
 * @enum {number}
 */
export declare namespace __std {
    enum RPCValue {
        NONE = 0,
        RPCSerialised = 1,
        Data = 2
    }
}
/**
 * @enum {number}
 */
export declare namespace __std {
    enum RPCSyncRetval {
        NONE = 0,
        Data = 1,
        Error = 2
    }
}
/**
 * @enum {number}
 */
export declare namespace __std {
    enum Args {
        NONE = 0,
        WriteArgs = 1,
        ReadArgs = 2,
        ParseArgs = 3,
        UnparseArgs = 4,
        CancelArgs = 5,
        ParamArgs = 6,
        RPCArgs = 7
    }
}
/**
 * Error encodes an error either in accepting a request, or in fulfilling it (in deferreds).
 *
 * @constructor
 */
export declare namespace __std {
    class Error {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns Error
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): Error;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param Error= obj
         * @returns Error
         */
        static getRootAsError(bb: flatbuffers.ByteBuffer, obj?: Error): Error;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        message(): string | null;
        message(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startError(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset messageOffset
         */
        static addMessage(builder: flatbuffers.Builder, messageOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endError(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createError(builder: flatbuffers.Builder, messageOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * CancelArgs encodes a message cancelling a deferred response.
 *
 * @constructor
 */
export declare namespace __std {
    class CancelArgs {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns CancelArgs
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): CancelArgs;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param CancelArgs= obj
         * @returns CancelArgs
         */
        static getRootAsCancelArgs(bb: flatbuffers.ByteBuffer, obj?: CancelArgs): CancelArgs;
        /**
         * @returns flatbuffers.Long
         */
        serial(): flatbuffers.Long;
        /**
         * @param flatbuffers.Builder builder
         */
        static startCancelArgs(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Long serial
         */
        static addSerial(builder: flatbuffers.Builder, serial: flatbuffers.Long): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endCancelArgs(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createCancelArgs(builder: flatbuffers.Builder, serial: flatbuffers.Long): flatbuffers.Offset;
    }
}
/**
 * Deferred encodes a serial number, standing in for an result or results to be fulfilled later.
 *
 * @constructor
 */
export declare namespace __std {
    class Deferred {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns Deferred
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): Deferred;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param Deferred= obj
         * @returns Deferred
         */
        static getRootAsDeferred(bb: flatbuffers.ByteBuffer, obj?: Deferred): Deferred;
        /**
         * @returns flatbuffers.Long
         */
        serial(): flatbuffers.Long;
        /**
         * @param flatbuffers.Builder builder
         */
        static startDeferred(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Long serial
         */
        static addSerial(builder: flatbuffers.Builder, serial: flatbuffers.Long): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endDeferred(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createDeferred(builder: flatbuffers.Builder, serial: flatbuffers.Long): flatbuffers.Offset;
    }
}
/**
 * Response encodes the _synchronous_ response to a message expecting a deferred value or values.
 *
 * @constructor
 */
export declare namespace __std {
    class DeferredResponse {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns DeferredResponse
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): DeferredResponse;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param DeferredResponse= obj
         * @returns DeferredResponse
         */
        static getRootAsDeferredResponse(bb: flatbuffers.ByteBuffer, obj?: DeferredResponse): DeferredResponse;
        /**
         * @returns __std.DeferredRetval
         */
        retvalType(): __std.DeferredRetval;
        /**
         * @param flatbuffers.Table obj
         * @returns ?flatbuffers.Table
         */
        retval<T extends flatbuffers.Table>(obj: T): T | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startDeferredResponse(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.DeferredRetval retvalType
         */
        static addRetvalType(builder: flatbuffers.Builder, retvalType: __std.DeferredRetval): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset retvalOffset
         */
        static addRetval(builder: flatbuffers.Builder, retvalOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endDeferredResponse(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createDeferredResponse(builder: flatbuffers.Builder, retvalType: __std.DeferredRetval, retvalOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * Data is data sent as (possibly partial) fulfilment of a deferred result.
 *
 * @constructor
 */
export declare namespace __std {
    class Data {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns Data
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): Data;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param Data= obj
         * @returns Data
         */
        static getRootAsData(bb: flatbuffers.ByteBuffer, obj?: Data): Data;
        /**
         * @param number index
         * @returns number
         */
        bytes(index: number): number | null;
        /**
         * @returns number
         */
        bytesLength(): number;
        /**
         * @returns Uint8Array
         */
        bytesArray(): Uint8Array | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startData(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset bytesOffset
         */
        static addBytes(builder: flatbuffers.Builder, bytesOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @param Array.<number> data
         * @returns flatbuffers.Offset
         */
        static createBytesVector(builder: flatbuffers.Builder, data: number[] | Uint8Array): flatbuffers.Offset;
        /**
         * @param flatbuffers.Builder builder
         * @param number numElems
         */
        static startBytesVector(builder: flatbuffers.Builder, numElems: number): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endData(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createData(builder: flatbuffers.Builder, bytesOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * EndOfStream signals that there will be no more data.
 *
 * @constructor
 */
export declare namespace __std {
    class EndOfStream {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns EndOfStream
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): EndOfStream;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param EndOfStream= obj
         * @returns EndOfStream
         */
        static getRootAsEndOfStream(bb: flatbuffers.ByteBuffer, obj?: EndOfStream): EndOfStream;
        /**
         * @param flatbuffers.Builder builder
         */
        static startEndOfStream(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endEndOfStream(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createEndOfStream(builder: flatbuffers.Builder): flatbuffers.Offset;
    }
}
/**
 * Resolution represents the _asynchronous_ fulfilment of a deferred value (possibly one of many values).
 *
 * @constructor
 */
export declare namespace __std {
    class Fulfilment {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns Fulfilment
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): Fulfilment;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param Fulfilment= obj
         * @returns Fulfilment
         */
        static getRootAsFulfilment(bb: flatbuffers.ByteBuffer, obj?: Fulfilment): Fulfilment;
        /**
         * @returns flatbuffers.Long
         */
        serial(): flatbuffers.Long;
        /**
         * @returns __std.FulfilmentValue
         */
        valueType(): __std.FulfilmentValue;
        /**
         * @param flatbuffers.Table obj
         * @returns ?flatbuffers.Table
         */
        value<T extends flatbuffers.Table>(obj: T): T | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startFulfilment(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Long serial
         */
        static addSerial(builder: flatbuffers.Builder, serial: flatbuffers.Long): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.FulfilmentValue valueType
         */
        static addValueType(builder: flatbuffers.Builder, valueType: __std.FulfilmentValue): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset valueOffset
         */
        static addValue(builder: flatbuffers.Builder, valueOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endFulfilment(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createFulfilment(builder: flatbuffers.Builder, serial: flatbuffers.Long, valueType: __std.FulfilmentValue, valueOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class WriteArgs {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns WriteArgs
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): WriteArgs;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param WriteArgs= obj
         * @returns WriteArgs
         */
        static getRootAsWriteArgs(bb: flatbuffers.ByteBuffer, obj?: WriteArgs): WriteArgs;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        path(): string | null;
        path(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        value(): string | null;
        value(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @returns __std.Format
         */
        format(): __std.Format;
        /**
         * @returns number
         */
        indent(): number;
        /**
         * @returns __std.Overwrite
         */
        overwrite(): __std.Overwrite;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        module(): string | null;
        module(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startWriteArgs(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset pathOffset
         */
        static addPath(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset valueOffset
         */
        static addValue(builder: flatbuffers.Builder, valueOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.Format format
         */
        static addFormat(builder: flatbuffers.Builder, format: __std.Format): void;
        /**
         * @param flatbuffers.Builder builder
         * @param number indent
         */
        static addIndent(builder: flatbuffers.Builder, indent: number): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.Overwrite overwrite
         */
        static addOverwrite(builder: flatbuffers.Builder, overwrite: __std.Overwrite): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset moduleOffset
         */
        static addModule(builder: flatbuffers.Builder, moduleOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endWriteArgs(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createWriteArgs(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset, valueOffset: flatbuffers.Offset, format: __std.Format, indent: number, overwrite: __std.Overwrite, moduleOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class ReadArgs {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns ReadArgs
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): ReadArgs;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param ReadArgs= obj
         * @returns ReadArgs
         */
        static getRootAsReadArgs(bb: flatbuffers.ByteBuffer, obj?: ReadArgs): ReadArgs;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        path(): string | null;
        path(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @returns number
         */
        timeout(): number;
        /**
         * @returns __std.Encoding
         */
        encoding(): __std.Encoding;
        /**
         * @returns __std.Format
         */
        format(): __std.Format;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        module(): string | null;
        module(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startReadArgs(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset pathOffset
         */
        static addPath(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @param number timeout
         */
        static addTimeout(builder: flatbuffers.Builder, timeout: number): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.Encoding encoding
         */
        static addEncoding(builder: flatbuffers.Builder, encoding: __std.Encoding): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.Format format
         */
        static addFormat(builder: flatbuffers.Builder, format: __std.Format): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset moduleOffset
         */
        static addModule(builder: flatbuffers.Builder, moduleOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endReadArgs(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createReadArgs(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset, timeout: number, encoding: __std.Encoding, format: __std.Format, moduleOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class ParamArgs {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns ParamArgs
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): ParamArgs;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param ParamArgs= obj
         * @returns ParamArgs
         */
        static getRootAsParamArgs(bb: flatbuffers.ByteBuffer, obj?: ParamArgs): ParamArgs;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        path(): string | null;
        path(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @returns __std.ParamType
         */
        type(): __std.ParamType;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        defaultValue(): string | null;
        defaultValue(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startParamArgs(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset pathOffset
         */
        static addPath(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.ParamType type
         */
        static addType(builder: flatbuffers.Builder, type: __std.ParamType): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset defaultValueOffset
         */
        static addDefaultValue(builder: flatbuffers.Builder, defaultValueOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endParamArgs(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createParamArgs(builder: flatbuffers.Builder, pathOffset: flatbuffers.Offset, type: __std.ParamType, defaultValueOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class ParamValue {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns ParamValue
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): ParamValue;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param ParamValue= obj
         * @returns ParamValue
         */
        static getRootAsParamValue(bb: flatbuffers.ByteBuffer, obj?: ParamValue): ParamValue;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        json(): string | null;
        json(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startParamValue(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset jsonOffset
         */
        static addJson(builder: flatbuffers.Builder, jsonOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endParamValue(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createParamValue(builder: flatbuffers.Builder, jsonOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class ParamResponse {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns ParamResponse
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): ParamResponse;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param ParamResponse= obj
         * @returns ParamResponse
         */
        static getRootAsParamResponse(bb: flatbuffers.ByteBuffer, obj?: ParamResponse): ParamResponse;
        /**
         * @returns __std.ParamRetval
         */
        retvalType(): __std.ParamRetval;
        /**
         * @param flatbuffers.Table obj
         * @returns ?flatbuffers.Table
         */
        retval<T extends flatbuffers.Table>(obj: T): T | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startParamResponse(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.ParamRetval retvalType
         */
        static addRetvalType(builder: flatbuffers.Builder, retvalType: __std.ParamRetval): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset retvalOffset
         */
        static addRetval(builder: flatbuffers.Builder, retvalOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endParamResponse(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createParamResponse(builder: flatbuffers.Builder, retvalType: __std.ParamRetval, retvalOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class ParseArgs {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns ParseArgs
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): ParseArgs;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param ParseArgs= obj
         * @returns ParseArgs
         */
        static getRootAsParseArgs(bb: flatbuffers.ByteBuffer, obj?: ParseArgs): ParseArgs;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        chars(): string | null;
        chars(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @returns __std.Format
         */
        format(): __std.Format;
        /**
         * @param flatbuffers.Builder builder
         */
        static startParseArgs(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset charsOffset
         */
        static addChars(builder: flatbuffers.Builder, charsOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.Format format
         */
        static addFormat(builder: flatbuffers.Builder, format: __std.Format): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endParseArgs(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createParseArgs(builder: flatbuffers.Builder, charsOffset: flatbuffers.Offset, format: __std.Format): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class ParseUnparseData {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns ParseUnparseData
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): ParseUnparseData;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param ParseUnparseData= obj
         * @returns ParseUnparseData
         */
        static getRootAsParseUnparseData(bb: flatbuffers.ByteBuffer, obj?: ParseUnparseData): ParseUnparseData;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        data(): string | null;
        data(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startParseUnparseData(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset dataOffset
         */
        static addData(builder: flatbuffers.Builder, dataOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endParseUnparseData(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createParseUnparseData(builder: flatbuffers.Builder, dataOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class ParseUnparseResponse {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns ParseUnparseResponse
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): ParseUnparseResponse;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param ParseUnparseResponse= obj
         * @returns ParseUnparseResponse
         */
        static getRootAsParseUnparseResponse(bb: flatbuffers.ByteBuffer, obj?: ParseUnparseResponse): ParseUnparseResponse;
        /**
         * @returns __std.ParseUnparseRetval
         */
        retvalType(): __std.ParseUnparseRetval;
        /**
         * @param flatbuffers.Table obj
         * @returns ?flatbuffers.Table
         */
        retval<T extends flatbuffers.Table>(obj: T): T | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startParseUnparseResponse(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.ParseUnparseRetval retvalType
         */
        static addRetvalType(builder: flatbuffers.Builder, retvalType: __std.ParseUnparseRetval): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset retvalOffset
         */
        static addRetval(builder: flatbuffers.Builder, retvalOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endParseUnparseResponse(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createParseUnparseResponse(builder: flatbuffers.Builder, retvalType: __std.ParseUnparseRetval, retvalOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class UnparseArgs {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns UnparseArgs
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): UnparseArgs;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param UnparseArgs= obj
         * @returns UnparseArgs
         */
        static getRootAsUnparseArgs(bb: flatbuffers.ByteBuffer, obj?: UnparseArgs): UnparseArgs;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        object(): string | null;
        object(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @returns __std.Format
         */
        format(): __std.Format;
        /**
         * @param flatbuffers.Builder builder
         */
        static startUnparseArgs(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset objectOffset
         */
        static addObject(builder: flatbuffers.Builder, objectOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.Format format
         */
        static addFormat(builder: flatbuffers.Builder, format: __std.Format): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endUnparseArgs(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createUnparseArgs(builder: flatbuffers.Builder, objectOffset: flatbuffers.Offset, format: __std.Format): flatbuffers.Offset;
    }
}
/**
 * RPCSerialised is a `JSON.stringify`d value, used for everything but byte
 *
 * @constructor
 */
export declare namespace __std {
    class RPCSerialised {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns RPCSerialised
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): RPCSerialised;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param RPCSerialised= obj
         * @returns RPCSerialised
         */
        static getRootAsRPCSerialised(bb: flatbuffers.ByteBuffer, obj?: RPCSerialised): RPCSerialised;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        value(): string | null;
        value(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startRPCSerialised(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset valueOffset
         */
        static addValue(builder: flatbuffers.Builder, valueOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endRPCSerialised(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createRPCSerialised(builder: flatbuffers.Builder, valueOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class RPCArg {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns RPCArg
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): RPCArg;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param RPCArg= obj
         * @returns RPCArg
         */
        static getRootAsRPCArg(bb: flatbuffers.ByteBuffer, obj?: RPCArg): RPCArg;
        /**
         * @returns __std.RPCValue
         */
        argType(): __std.RPCValue;
        /**
         * @param flatbuffers.Table obj
         * @returns ?flatbuffers.Table
         */
        arg<T extends flatbuffers.Table>(obj: T): T | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startRPCArg(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.RPCValue argType
         */
        static addArgType(builder: flatbuffers.Builder, argType: __std.RPCValue): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset argOffset
         */
        static addArg(builder: flatbuffers.Builder, argOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endRPCArg(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createRPCArg(builder: flatbuffers.Builder, argType: __std.RPCValue, argOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class RPCArgs {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns RPCArgs
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): RPCArgs;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param RPCArgs= obj
         * @returns RPCArgs
         */
        static getRootAsRPCArgs(bb: flatbuffers.ByteBuffer, obj?: RPCArgs): RPCArgs;
        /**
         * @param flatbuffers.Encoding= optionalEncoding
         * @returns string|Uint8Array|null
         */
        method(): string | null;
        method(optionalEncoding: flatbuffers.Encoding): string | Uint8Array | null;
        /**
         * @param number index
         * @param __std.RPCArg= obj
         * @returns __std.RPCArg
         */
        args(index: number, obj?: __std.RPCArg): __std.RPCArg | null;
        /**
         * @returns number
         */
        argsLength(): number;
        /**
         * @returns boolean
         */
        sync(): boolean;
        /**
         * @param flatbuffers.Builder builder
         */
        static startRPCArgs(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset methodOffset
         */
        static addMethod(builder: flatbuffers.Builder, methodOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset argsOffset
         */
        static addArgs(builder: flatbuffers.Builder, argsOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @param Array.<flatbuffers.Offset> data
         * @returns flatbuffers.Offset
         */
        static createArgsVector(builder: flatbuffers.Builder, data: flatbuffers.Offset[]): flatbuffers.Offset;
        /**
         * @param flatbuffers.Builder builder
         * @param number numElems
         */
        static startArgsVector(builder: flatbuffers.Builder, numElems: number): void;
        /**
         * @param flatbuffers.Builder builder
         * @param boolean sync
         */
        static addSync(builder: flatbuffers.Builder, sync: boolean): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endRPCArgs(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createRPCArgs(builder: flatbuffers.Builder, methodOffset: flatbuffers.Offset, argsOffset: flatbuffers.Offset, sync: boolean): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class RPCSyncResponse {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns RPCSyncResponse
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): RPCSyncResponse;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param RPCSyncResponse= obj
         * @returns RPCSyncResponse
         */
        static getRootAsRPCSyncResponse(bb: flatbuffers.ByteBuffer, obj?: RPCSyncResponse): RPCSyncResponse;
        /**
         * @returns __std.RPCSyncRetval
         */
        retvalType(): __std.RPCSyncRetval;
        /**
         * @param flatbuffers.Table obj
         * @returns ?flatbuffers.Table
         */
        retval<T extends flatbuffers.Table>(obj: T): T | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startRPCSyncResponse(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.RPCSyncRetval retvalType
         */
        static addRetvalType(builder: flatbuffers.Builder, retvalType: __std.RPCSyncRetval): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset retvalOffset
         */
        static addRetval(builder: flatbuffers.Builder, retvalOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endRPCSyncResponse(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createRPCSyncResponse(builder: flatbuffers.Builder, retvalType: __std.RPCSyncRetval, retvalOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}
/**
 * @constructor
 */
export declare namespace __std {
    class Message {
        bb: flatbuffers.ByteBuffer | null;
        bb_pos: number;
        /**
         * @param number i
         * @param flatbuffers.ByteBuffer bb
         * @returns Message
         */
        __init(i: number, bb: flatbuffers.ByteBuffer): Message;
        /**
         * @param flatbuffers.ByteBuffer bb
         * @param Message= obj
         * @returns Message
         */
        static getRootAsMessage(bb: flatbuffers.ByteBuffer, obj?: Message): Message;
        /**
         * @returns __std.Args
         */
        argsType(): __std.Args;
        /**
         * @param flatbuffers.Table obj
         * @returns ?flatbuffers.Table
         */
        args<T extends flatbuffers.Table>(obj: T): T | null;
        /**
         * @param flatbuffers.Builder builder
         */
        static startMessage(builder: flatbuffers.Builder): void;
        /**
         * @param flatbuffers.Builder builder
         * @param __std.Args argsType
         */
        static addArgsType(builder: flatbuffers.Builder, argsType: __std.Args): void;
        /**
         * @param flatbuffers.Builder builder
         * @param flatbuffers.Offset argsOffset
         */
        static addArgs(builder: flatbuffers.Builder, argsOffset: flatbuffers.Offset): void;
        /**
         * @param flatbuffers.Builder builder
         * @returns flatbuffers.Offset
         */
        static endMessage(builder: flatbuffers.Builder): flatbuffers.Offset;
        static createMessage(builder: flatbuffers.Builder, argsType: __std.Args, argsOffset: flatbuffers.Offset): flatbuffers.Offset;
    }
}