New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@types/flatbuffers

Package Overview
Dependencies
Maintainers
1
Versions
12
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@types/flatbuffers - npm Package Compare versions

Comparing version 1.6.2 to 1.6.3

1034

flatbuffers/index.d.ts

@@ -6,69 +6,22 @@ // Type definitions for flatbuffers 1.6

declare namespace flatbuffers {
/**
* @typedef {number}
*/
type Offset = number;
export { flatbuffers };
/**
* @typedef {{
* bb: flatbuffers.ByteBuffer,
* bb_pos: number
* }}
*/
interface Table {
bb: ByteBuffer;
bb_pos: number;
}
declare global {
namespace flatbuffers {
/**
* @typedef {number}
*/
type Offset = number;
/**
* @type {number}
* @const
*/
const SIZEOF_SHORT: number;
/**
* @typedef {{
* bb: flatbuffers.ByteBuffer,
* bb_pos: number
* }}
*/
interface Table {
bb: ByteBuffer;
bb_pos: number;
}
/**
* @type {number}
* @const
*/
const SIZEOF_INT: number;
/**
* @type {number}
* @const
*/
const FILE_IDENTIFIER_LENGTH: number;
/**
* @enum {number}
*/
enum Encoding { UTF8_BYTES, UTF16_STRING }
/**
* @type {Int32Array}
* @const
*/
const int32: Int32Array;
/**
* @type {Float32Array}
* @const
*/
const float32: Float32Array;
/**
* @type {Float64Array}
* @const
*/
const float64: Float64Array;
/**
* @type {boolean}
* @const
*/
const isLittleEndian: boolean;
////////////////////////////////////////////////////////////////////////////////
class Long {
/**

@@ -78,3 +31,3 @@ * @type {number}

*/
low: number;
const SIZEOF_SHORT: number;

@@ -85,546 +38,597 @@ /**

*/
high: number;
const SIZEOF_INT: number;
/**
* @type {flatbuffers.Long}
* @type {number}
* @const
*/
static ZERO: Long;
const FILE_IDENTIFIER_LENGTH: number;
/**
* @constructor
* @param {number} high
* @param {number} low
* @enum {number}
*/
constructor(low: number, high: number);
enum Encoding { UTF8_BYTES, UTF16_STRING }
/**
* @returns {number}
* @type {Int32Array}
* @const
*/
toFloat64(): number;
const int32: Int32Array;
/**
* @param {flatbuffers.Long} other
* @returns {boolean}
* @type {Float32Array}
* @const
*/
equals(other: any): boolean;
const float32: Float32Array;
/**
* @param {number} low
* @param {number} high
* @type {Float64Array}
* @const
*/
static create(low: number, high: number): Long;
}
const float64: Float64Array;
////////////////////////////////////////////////////////////////////////////////
class Builder {
/**
* @constructor
* @param {number=} initial_size
* @type {boolean}
* @const
*/
constructor(initial_size?: number);
const isLittleEndian: boolean;
/**
* In order to save space, fields that are set to their default value
* don't get serialized into the buffer. Forcing defaults provides a
* way to manually disable this optimization.
*
* @param {boolean} forceDefaults true always serializes default values
*/
forceDefaults(forceDefaults: boolean): void;
////////////////////////////////////////////////////////////////////////////////
/**
* Get the ByteBuffer representing the FlatBuffer. Only call this after you've
* called finish(). The actual data starts at the ByteBuffer's current position,
* not necessarily at 0.
*
* @returns {flatbuffers.ByteBuffer}
*/
dataBuffer(): ByteBuffer;
class Long {
/**
* @type {number}
* @const
*/
low: number;
/**
* Get the ByteBuffer representing the FlatBuffer. Only call this after you've
* called finish(). The actual data starts at the ByteBuffer's current position,
* not necessarily at 0.
*
* @returns {Uint8Array}
*/
asUint8Array(): Uint8Array;
/**
* @type {number}
* @const
*/
high: number;
/**
* Prepare to write an element of `size` after `additional_bytes` have been
* written, e.g. if you write a string, you need to align such the int length
* field is aligned to 4 bytes, and the string data follows it directly. If all
* you need to do is alignment, `additional_bytes` will be 0.
*
* @param {number} size This is the of the new element to write
* @param {number} additional_bytes The padding size
*/
prep(size: number, additional_bytes: number): void;
/**
* @type {flatbuffers.Long}
* @const
*/
static ZERO: Long;
/**
* @param {number} byte_size
*/
pad(byte_size: number): void;
/**
* @constructor
* @param {number} high
* @param {number} low
*/
constructor(low: number, high: number);
/**
* @param {number} value
*/
writeInt8(value: number): void;
/**
* @returns {number}
*/
toFloat64(): number;
/**
* @param {number} value
*/
writeInt16(value: number): void;
/**
* @param {flatbuffers.Long} other
* @returns {boolean}
*/
equals(other: any): boolean;
/**
* @param {number} value
*/
writeInt32(value: number): void;
/**
* @param {number} low
* @param {number} high
*/
static create(low: number, high: number): Long;
}
/**
* @param {flatbuffers.Long} value
*/
writeInt64(value: Long): void;
////////////////////////////////////////////////////////////////////////////////
/**
* @param {number} value
*/
writeFloat32(value: number): void;
class Builder {
/**
* @constructor
* @param {number=} initial_size
*/
constructor(initial_size?: number);
/**
* @param {number} value
*/
writeFloat64(value: number): void;
/**
* In order to save space, fields that are set to their default value
* don't get serialized into the buffer. Forcing defaults provides a
* way to manually disable this optimization.
*
* @param {boolean} forceDefaults true always serializes default values
*/
forceDefaults(forceDefaults: boolean): void;
/**
* @param {number} value
*/
addInt8(value: number): void;
/**
* Get the ByteBuffer representing the FlatBuffer. Only call this after you've
* called finish(). The actual data starts at the ByteBuffer's current position,
* not necessarily at 0.
*
* @returns {flatbuffers.ByteBuffer}
*/
dataBuffer(): ByteBuffer;
/**
* @param {number} value
*/
addInt16(value: number): void;
/**
* Get the ByteBuffer representing the FlatBuffer. Only call this after you've
* called finish(). The actual data starts at the ByteBuffer's current position,
* not necessarily at 0.
*
* @returns {Uint8Array}
*/
asUint8Array(): Uint8Array;
/**
* @param {number} value
*/
addInt32(value: number): void;
/**
* Prepare to write an element of `size` after `additional_bytes` have been
* written, e.g. if you write a string, you need to align such the int length
* field is aligned to 4 bytes, and the string data follows it directly. If all
* you need to do is alignment, `additional_bytes` will be 0.
*
* @param {number} size This is the of the new element to write
* @param {number} additional_bytes The padding size
*/
prep(size: number, additional_bytes: number): void;
/**
* @param {flatbuffers.Long} value
*/
addInt64(value: Long): void;
/**
* @param {number} byte_size
*/
pad(byte_size: number): void;
/**
* @param {number} value
*/
addFloat32(value: number): void;
/**
* @param {number} value
*/
writeInt8(value: number): void;
/**
* @param {number} value
*/
addFloat64(value: number): void;
/**
* @param {number} value
*/
writeInt16(value: number): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldInt8(voffset: number, value: number, defaultValue: number): void;
/**
* @param {number} value
*/
writeInt32(value: number): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldInt16(voffset: number, value: number, defaultValue: number): void;
/**
* @param {flatbuffers.Long} value
*/
writeInt64(value: Long): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldInt32(voffset: number, value: number, defaultValue: number): void;
/**
* @param {number} value
*/
writeFloat32(value: number): void;
/**
* @param {number} voffset
* @param {flatbuffers.Long} value
* @param {flatbuffers.Long} defaultValue
*/
addFieldInt64(voffset: number, value: Long, defaultValue: Long): void;
/**
* @param {number} value
*/
writeFloat64(value: number): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldFloat32(voffset: number, value: number, defaultValue: number): void;
/**
* @param {number} value
*/
addInt8(value: number): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldFloat64(voffset: number, value: number, defaultValue: number): void;
/**
* @param {number} value
*/
addInt16(value: number): void;
/**
* @param {number} voffset
* @param {flatbuffers.Offset} value
* @param {flatbuffers.Offset} defaultValue
*/
addFieldOffset(voffset: number, value: Offset, defaultValue: Offset): void;
/**
* @param {number} value
*/
addInt32(value: number): void;
/**
* Structs are stored inline, so nothing additional is being added. `d` is always 0.
*
* @param {number} voffset
* @param {flatbuffers.Offset} value
* @param {flatbuffers.Offset} defaultValue
*/
addFieldStruct(voffset: number, value: Offset, defaultValue: Offset): void;
/**
* @param {flatbuffers.Long} value
*/
addInt64(value: Long): void;
/**
* Structures are always stored inline, they need to be created right
* where they're used. You'll get this assertion failure if you
* created it elsewhere.
*
* @param {flatbuffers.Offset} obj The offset of the created object
*/
nested(obj: Offset): void;
/**
* @param {number} value
*/
addFloat32(value: number): void;
/**
* Should not be creating any other object, string or vector
* while an object is being constructed
*/
notNested(): void;
/**
* @param {number} value
*/
addFloat64(value: number): void;
/**
* Set the current vtable at `voffset` to the current location in the buffer.
*
* @param {number} voffset
*/
slot(voffset: number): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldInt8(voffset: number, value: number, defaultValue: number): void;
/**
* @returns {flatbuffers.Offset} Offset relative to the end of the buffer.
*/
offset(): Offset;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldInt16(voffset: number, value: number, defaultValue: number): void;
/**
* Doubles the size of the backing ByteBuffer and copies the old data towards
* the end of the new buffer (since we build the buffer backwards).
*
* @param {flatbuffers.ByteBuffer} bb The current buffer with the existing data
* @returns {flatbuffers.ByteBuffer} A new byte buffer with the old data copied
* to it. The data is located at the end of the buffer.
*/
static growByteBuffer(bb: ByteBuffer): ByteBuffer;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldInt32(voffset: number, value: number, defaultValue: number): void;
/**
* Adds on offset, relative to where it will be written.
*
* @param {flatbuffers.Offset} offset The offset to add
*/
addOffset(offset: Offset): void;
/**
* @param {number} voffset
* @param {flatbuffers.Long} value
* @param {flatbuffers.Long} defaultValue
*/
addFieldInt64(voffset: number, value: Long, defaultValue: Long): void;
/**
* Start encoding a new object in the buffer. Users will not usually need to
* call this directly. The FlatBuffers compiler will generate helper methods
* that call this method internally.
*
* @param {number} numfields
*/
startObject(numfields: number): void;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldFloat32(voffset: number, value: number, defaultValue: number): void;
/**
* Finish off writing the object that is under construction.
*
* @returns {flatbuffers.Offset} The offset to the object inside `dataBuffer`
*/
endObject(): Offset;
/**
* @param {number} voffset
* @param {number} value
* @param {number} defaultValue
*/
addFieldFloat64(voffset: number, value: number, defaultValue: number): void;
/**
* @param {flatbuffers.Offset} root_table
* @param {string=} file_identifier
*/
finish(root_table: Offset, file_identifier?: string): void;
/**
* @param {number} voffset
* @param {flatbuffers.Offset} value
* @param {flatbuffers.Offset} defaultValue
*/
addFieldOffset(voffset: number, value: Offset, defaultValue: Offset): void;
/**
* This checks a required field has been set in a given table that has
* just been constructed.
*
* @param {flatbuffers.Offset} table
* @param {number} field
*/
requiredField(table: Offset, field: number): void;
/**
* Structs are stored inline, so nothing additional is being added. `d` is always 0.
*
* @param {number} voffset
* @param {flatbuffers.Offset} value
* @param {flatbuffers.Offset} defaultValue
*/
addFieldStruct(voffset: number, value: Offset, defaultValue: Offset): void;
/**
* Start a new array/vector of objects. Users usually will not call
* this directly. The FlatBuffers compiler will create a start/end
* method for vector types in generated code.
*
* @param {number} elem_size The size of each element in the array
* @param {number} num_elems The number of elements in the array
* @param {number} alignment The alignment of the array
*/
startVector(elem_size: number, num_elems: number, alignment: number): void;
/**
* Structures are always stored inline, they need to be created right
* where they're used. You'll get this assertion failure if you
* created it elsewhere.
*
* @param {flatbuffers.Offset} obj The offset of the created object
*/
nested(obj: Offset): void;
/**
* Finish off the creation of an array and all its elements. The array must be
* created with `startVector`.
*
* @returns {flatbuffers.Offset} The offset at which the newly created array
* starts.
*/
endVector(): Offset;
/**
* Should not be creating any other object, string or vector
* while an object is being constructed
*/
notNested(): void;
/**
* Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed
* instead of a string, it is assumed to contain valid UTF-8 encoded data.
*
* @param {string|Uint8Array} s The string to encode
* @return {flatbuffers.Offset} The offset in the buffer where the encoded string starts
*/
createString(s: string|Uint8Array): Offset;
/**
* Set the current vtable at `voffset` to the current location in the buffer.
*
* @param {number} voffset
*/
slot(voffset: number): void;
/**
* Conveniance function for creating Long objects.
*
* @param {number} low
* @param {number} high
* @returns {Long}
*/
createLong(low: number, high: number): Long;
}
/**
* @returns {flatbuffers.Offset} Offset relative to the end of the buffer.
*/
offset(): Offset;
////////////////////////////////////////////////////////////////////////////////
/**
* Doubles the size of the backing ByteBuffer and copies the old data towards
* the end of the new buffer (since we build the buffer backwards).
*
* @param {flatbuffers.ByteBuffer} bb The current buffer with the existing data
* @returns {flatbuffers.ByteBuffer} A new byte buffer with the old data copied
* to it. The data is located at the end of the buffer.
*/
static growByteBuffer(bb: ByteBuffer): ByteBuffer;
class ByteBuffer {
/**
* @constructor
* @param {Uint8Array} bytes
*/
constructor(bytes: Uint8Array);
/**
* Adds on offset, relative to where it will be written.
*
* @param {flatbuffers.Offset} offset The offset to add
*/
addOffset(offset: Offset): void;
/**
* @param {number} byte_size
* @returns {flatbuffers.ByteBuffer}
*/
static allocate(byte_size: number): ByteBuffer;
/**
* Start encoding a new object in the buffer. Users will not usually need to
* call this directly. The FlatBuffers compiler will generate helper methods
* that call this method internally.
*
* @param {number} numfields
*/
startObject(numfields: number): void;
/**
* @returns {Uint8Array}
*/
bytes(): Uint8Array;
/**
* Finish off writing the object that is under construction.
*
* @returns {flatbuffers.Offset} The offset to the object inside `dataBuffer`
*/
endObject(): Offset;
/**
* @returns {number}
*/
position(): number;
/**
* @param {flatbuffers.Offset} root_table
* @param {string=} file_identifier
*/
finish(root_table: Offset, file_identifier?: string): void;
/**
* @param {number} position
*/
setPosition(position: number): void;
/**
* This checks a required field has been set in a given table that has
* just been constructed.
*
* @param {flatbuffers.Offset} table
* @param {number} field
*/
requiredField(table: Offset, field: number): void;
/**
* @returns {number}
*/
capacity(): number;
/**
* Start a new array/vector of objects. Users usually will not call
* this directly. The FlatBuffers compiler will create a start/end
* method for vector types in generated code.
*
* @param {number} elem_size The size of each element in the array
* @param {number} num_elems The number of elements in the array
* @param {number} alignment The alignment of the array
*/
startVector(elem_size: number, num_elems: number, alignment: number): void;
/**
* @param {number} offset
* @returns {number}
*/
readInt8(offset: number): number;
/**
* Finish off the creation of an array and all its elements. The array must be
* created with `startVector`.
*
* @returns {flatbuffers.Offset} The offset at which the newly created array
* starts.
*/
endVector(): Offset;
/**
* @param {number} offset
* @returns {number}
*/
readUint8(offset: number): number;
/**
* Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed
* instead of a string, it is assumed to contain valid UTF-8 encoded data.
*
* @param {string|Uint8Array} s The string to encode
* @return {flatbuffers.Offset} The offset in the buffer where the encoded string starts
*/
createString(s: string|Uint8Array): Offset;
/**
* @param {number} offset
* @returns {number}
*/
readInt16(offset: number): number;
/**
* Conveniance function for creating Long objects.
*
* @param {number} low
* @param {number} high
* @returns {Long}
*/
createLong(low: number, high: number): Long;
}
/**
* @param {number} offset
* @returns {number}
*/
readUint16(offset: number): number;
////////////////////////////////////////////////////////////////////////////////
/**
* @param {number} offset
* @returns {number}
*/
readInt32(offset: number): number;
class ByteBuffer {
/**
* @constructor
* @param {Uint8Array} bytes
*/
constructor(bytes: Uint8Array);
/**
* @param {number} offset
* @returns {number}
*/
readUint32(offset: number): number;
/**
* @param {number} byte_size
* @returns {flatbuffers.ByteBuffer}
*/
static allocate(byte_size: number): ByteBuffer;
/**
* @param {number} offset
* @returns {flatbuffers.Long}
*/
readInt64(offset: number): Long;
/**
* @returns {Uint8Array}
*/
bytes(): Uint8Array;
/**
* @param {number} offset
* @returns {flatbuffers.Long}
*/
readUint64(offset: number): Long;
/**
* @returns {number}
*/
position(): number;
/**
* @param {number} offset
* @returns {number}
*/
readFloat32(offset: number): number;
/**
* @param {number} position
*/
setPosition(position: number): void;
/**
* @param {number} offset
* @returns {number}
*/
readFloat64(offset: number): number;
/**
* @returns {number}
*/
capacity(): number;
/**
* @param {number} offset
* @param {number} value
*/
writeInt8(offset: number, value: number): void;
/**
* @param {number} offset
* @returns {number}
*/
readInt8(offset: number): number;
/**
* @param {number} offset
* @param {number} value
*/
writeUint8(offset: number, value: number): void;
/**
* @param {number} offset
* @returns {number}
*/
readUint8(offset: number): number;
/**
* @param {number} offset
* @param {number} value
*/
writeInt16(offset: number, value: number): void;
/**
* @param {number} offset
* @returns {number}
*/
readInt16(offset: number): number;
/**
* @param {number} offset
* @param {number} value
*/
writeUint16(offset: number, value: number): void;
/**
* @param {number} offset
* @returns {number}
*/
readUint16(offset: number): number;
/**
* @param {number} offset
* @param {number} value
*/
writeInt32(offset: number, value: number): void;
/**
* @param {number} offset
* @returns {number}
*/
readInt32(offset: number): number;
/**
* @param {number} offset
* @param {number} value
*/
writeUint32(offset: number, value: number): void;
/**
* @param {number} offset
* @returns {number}
*/
readUint32(offset: number): number;
/**
* @param {number} offset
* @param {flatbuffers.Long} value
*/
writeInt64(offset: number, value: Long): void;
/**
* @param {number} offset
* @returns {flatbuffers.Long}
*/
readInt64(offset: number): Long;
/**
* @param {number} offset
* @param {flatbuffers.Long} value
*/
writeUint64(offset: number, value: Long): void;
/**
* @param {number} offset
* @returns {flatbuffers.Long}
*/
readUint64(offset: number): Long;
/**
* @param {number} offset
* @param {number} value
*/
writeFloat32(offset: number, value: number): void;
/**
* @param {number} offset
* @returns {number}
*/
readFloat32(offset: number): number;
/**
* @param {number} offset
* @param {number} value
*/
writeFloat64(offset: number, value: number): void;
/**
* @param {number} offset
* @returns {number}
*/
readFloat64(offset: number): number;
/**
* Look up a field in the vtable, return an offset into the object, or 0 if the
* field is not present.
*
* @param {number} bb_pos
* @param {number} vtable_offset
* @returns {number}
*/
__offset(bb_pos: number, vtable_offset: number): number;
/**
* @param {number} offset
* @param {number} value
*/
writeInt8(offset: number, value: number): void;
/**
* Initialize any Table-derived type to point to the union at the given offset.
*
* @param {flatbuffers.Table} t
* @param {number} offset
* @returns {flatbuffers.Table}
*/
__union<T extends flatbuffers.Table>(t: T, offset: number): T;
/**
* @param {number} offset
* @param {number} value
*/
writeUint8(offset: number, value: number): void;
/**
* Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.
* This allocates a new string and converts to wide chars upon each access.
*
* To avoid the conversion to UTF-16, pass flatbuffers.Encoding.UTF8_BYTES as
* the "optionalEncoding" argument. This is useful for avoiding conversion to
* and from UTF-16 when the data will just be packaged back up in another
* FlatBuffer later on.
*
* @param {number} offset
* @param {flatbuffers.Encoding=} optionalEncoding Defaults to UTF16_STRING
* @returns {string|Uint8Array}
*/
__string(offset: number, optionalEncoding?: Encoding): string|Uint8Array;
/**
* @param {number} offset
* @param {number} value
*/
writeInt16(offset: number, value: number): void;
/**
* Retrieve the relative offset stored at "offset"
* @param {number} offset
* @returns {number}
*/
__indirect(offset: number): number;
/**
* @param {number} offset
* @param {number} value
*/
writeUint16(offset: number, value: number): void;
/**
* Get the start of data of a vector whose offset is stored at "offset" in this object.
*
* @param {number} offset
* @returns {number}
*/
__vector(offset: number): number;
/**
* @param {number} offset
* @param {number} value
*/
writeInt32(offset: number, value: number): void;
/**
* Get the length of a vector whose offset is stored at "offset" in this object.
*
* @param {number} offset
* @returns {number}
*/
__vector_len(offset: number): number;
/**
* @param {number} offset
* @param {number} value
*/
writeUint32(offset: number, value: number): void;
/**
* @param {string} ident
* @returns {boolean}
*/
__has_identifier(ident: string): boolean;
/**
* @param {number} offset
* @param {flatbuffers.Long} value
*/
writeInt64(offset: number, value: Long): void;
/**
* Conveniance function for creating Long objects.
*
* @param {number} low
* @param {number} high
* @returns {Long}
*/
createLong(low: number, high: number): Long;
/**
* @param {number} offset
* @param {flatbuffers.Long} value
*/
writeUint64(offset: number, value: Long): void;
/**
* @param {number} offset
* @param {number} value
*/
writeFloat32(offset: number, value: number): void;
/**
* @param {number} offset
* @param {number} value
*/
writeFloat64(offset: number, value: number): void;
/**
* Look up a field in the vtable, return an offset into the object, or 0 if the
* field is not present.
*
* @param {number} bb_pos
* @param {number} vtable_offset
* @returns {number}
*/
__offset(bb_pos: number, vtable_offset: number): number;
/**
* Initialize any Table-derived type to point to the union at the given offset.
*
* @param {flatbuffers.Table} t
* @param {number} offset
* @returns {flatbuffers.Table}
*/
__union<T extends flatbuffers.Table>(t: T, offset: number): T;
/**
* Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.
* This allocates a new string and converts to wide chars upon each access.
*
* To avoid the conversion to UTF-16, pass flatbuffers.Encoding.UTF8_BYTES as
* the "optionalEncoding" argument. This is useful for avoiding conversion to
* and from UTF-16 when the data will just be packaged back up in another
* FlatBuffer later on.
*
* @param {number} offset
* @param {flatbuffers.Encoding=} optionalEncoding Defaults to UTF16_STRING
* @returns {string|Uint8Array}
*/
__string(offset: number, optionalEncoding?: Encoding): string|Uint8Array;
/**
* Retrieve the relative offset stored at "offset"
* @param {number} offset
* @returns {number}
*/
__indirect(offset: number): number;
/**
* Get the start of data of a vector whose offset is stored at "offset" in this object.
*
* @param {number} offset
* @returns {number}
*/
__vector(offset: number): number;
/**
* Get the length of a vector whose offset is stored at "offset" in this object.
*
* @param {number} offset
* @returns {number}
*/
__vector_len(offset: number): number;
/**
* @param {string} ident
* @returns {boolean}
*/
__has_identifier(ident: string): boolean;
/**
* Conveniance function for creating Long objects.
*
* @param {number} low
* @param {number} high
* @returns {Long}
*/
createLong(low: number, high: number): Long;
}
}
}

4

flatbuffers/package.json
{
"name": "@types/flatbuffers",
"version": "1.6.2",
"version": "1.6.3",
"description": "TypeScript definitions for flatbuffers",

@@ -20,4 +20,4 @@ "license": "MIT",

"peerDependencies": {},
"typesPublisherContentHash": "3caff8faf6200b3b5b2b6998179a23b7298157b303b7bed9d3d84da963fdd8fa",
"typesPublisherContentHash": "50fac7ed1620c70ce938b7c6a20fb1c020dbea25c1e8257a7ea469133881e45a",
"typeScriptVersion": "2.0"
}

4

flatbuffers/README.md

@@ -11,7 +11,7 @@ # Installation

Additional Details
* Last updated: Mon, 17 Apr 2017 17:55:17 GMT
* Last updated: Fri, 02 Jun 2017 01:33:56 GMT
* Dependencies: none
* Global values: flatbuffers
* Global values: none
# Credits
These definitions were written by Kamil Rojewski <kamil.rojewski@gmail.com>.
flatbuffers/LICENSE

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc