diff options
Diffstat (limited to 'src/jaegertracing/thrift/lib/ts/thrift.d.ts')
| -rw-r--r-- | src/jaegertracing/thrift/lib/ts/thrift.d.ts | 699 |
1 files changed, 699 insertions, 0 deletions
diff --git a/src/jaegertracing/thrift/lib/ts/thrift.d.ts b/src/jaegertracing/thrift/lib/ts/thrift.d.ts new file mode 100644 index 000000000..0ba46c914 --- /dev/null +++ b/src/jaegertracing/thrift/lib/ts/thrift.d.ts @@ -0,0 +1,699 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +declare module Thrift { + /** + * Thrift JavaScript library version. + */ + var Version: string; + + /** + * Thrift IDL type string to Id mapping. + * @property {number} STOP - End of a set of fields. + * @property {number} VOID - No value (only legal for return types). + * @property {number} BOOL - True/False integer. + * @property {number} BYTE - Signed 8 bit integer. + * @property {number} I08 - Signed 8 bit integer. + * @property {number} DOUBLE - 64 bit IEEE 854 floating point. + * @property {number} I16 - Signed 16 bit integer. + * @property {number} I32 - Signed 32 bit integer. + * @property {number} I64 - Signed 64 bit integer. + * @property {number} STRING - Array of bytes representing a string of characters. + * @property {number} UTF7 - Array of bytes representing a string of UTF7 encoded characters. + * @property {number} STRUCT - A multifield type. + * @property {number} MAP - A collection type (map/associative-array/dictionary). + * @property {number} SET - A collection type (unordered and without repeated values). + * @property {number} LIST - A collection type (unordered). + * @property {number} UTF8 - Array of bytes representing a string of UTF8 encoded characters. + * @property {number} UTF16 - Array of bytes representing a string of UTF16 encoded characters. + */ + interface Type { + 'STOP': number; + 'VOID': number; + 'BOOL': number; + 'BYTE': number; + 'I08': number; + 'DOUBLE': number; + 'I16': number; + 'I32': number; + 'I64': number; + 'STRING': number; + 'UTF7': number; + 'STRUCT': number; + 'MAP': number; + 'SET': number; + 'LIST': number; + 'UTF8': number; + 'UTF16': number; + } + var Type: Type; + + /** + * Thrift RPC message type string to Id mapping. + * @property {number} CALL - RPC call sent from client to server. + * @property {number} REPLY - RPC call normal response from server to client. + * @property {number} EXCEPTION - RPC call exception response from server to client. + * @property {number} ONEWAY - Oneway RPC call from client to server with no response. + */ + interface MessageType { + 'CALL': number; + 'REPLY': number; + 'EXCEPTION': number; + 'ONEWAY': number; + } + var MessageType: MessageType; + + /** + * Utility function returning the count of an object's own properties. + * @param {object} obj - Object to test. + * @returns {number} number of object's own properties + */ + function objectLength(obj: Object): number; + + /** + * Utility function to establish prototype inheritance. + * @param {function} constructor - Contstructor function to set as derived. + * @param {function} superConstructor - Contstructor function to set as base. + * @param {string} [name] - Type name to set as name property in derived prototype. + */ + function inherits(constructor: Function, superConstructor: Function, name?: string): void; + + /** + * TException is the base class for all Thrift exceptions types. + */ + class TException implements Error { + name: string; + message: string; + + /** + * Initializes a Thrift TException instance. + * @param {string} message - The TException message (distinct from the Error message). + */ + constructor(message: string); + + /** + * Returns the message set on the exception. + * @returns {string} exception message + */ + getMessage(): string; + } + + /** + * Thrift Application Exception type string to Id mapping. + * @property {number} UNKNOWN - Unknown/undefined. + * @property {number} UNKNOWN_METHOD - Client attempted to call a method unknown to the server. + * @property {number} INVALID_MESSAGE_TYPE - Client passed an unknown/unsupported MessageType. + * @property {number} WRONG_METHOD_NAME - Unused. + * @property {number} BAD_SEQUENCE_ID - Unused in Thrift RPC, used to flag proprietary sequence number errors. + * @property {number} MISSING_RESULT - Raised by a server processor if a handler fails to supply the required return result. + * @property {number} INTERNAL_ERROR - Something bad happened. + * @property {number} PROTOCOL_ERROR - The protocol layer failed to serialize or deserialize data. + * @property {number} INVALID_TRANSFORM - Unused. + * @property {number} INVALID_PROTOCOL - The protocol (or version) is not supported. + * @property {number} UNSUPPORTED_CLIENT_TYPE - Unused. + */ + interface TApplicationExceptionType { + 'UNKNOWN': number; + 'UNKNOWN_METHOD': number; + 'INVALID_MESSAGE_TYPE': number; + 'WRONG_METHOD_NAME': number; + 'BAD_SEQUENCE_ID': number; + 'MISSING_RESULT': number; + 'INTERNAL_ERROR': number; + 'PROTOCOL_ERROR': number; + 'INVALID_TRANSFORM': number; + 'INVALID_PROTOCOL': number; + 'UNSUPPORTED_CLIENT_TYPE': number; + } + var TApplicationExceptionType: TApplicationExceptionType; + + /** + * TApplicationException is the exception class used to propagate exceptions from an RPC server back to a calling client. + */ + class TApplicationException extends TException { + message: string; + code: number; + + /** + * Initializes a Thrift TApplicationException instance. + * @param {string} message - The TApplicationException message (distinct from the Error message). + * @param {Thrift.TApplicationExceptionType} [code] - The TApplicationExceptionType code. + */ + constructor(message: string, code?: number); + + /** + * Read a TApplicationException from the supplied protocol. + * @param {object} input - The input protocol to read from. + */ + read(input: Object): void; + + /** + * Write a TApplicationException to the supplied protocol. + * @param {object} output - The output protocol to write to. + */ + write(output: Object): void; + + /** + * Returns the application exception code set on the exception. + * @returns {Thrift.TApplicationExceptionType} exception code + */ + getCode(): number; + } + + /** + * The Apache Thrift Transport layer performs byte level I/O between RPC + * clients and servers. The JavaScript Transport object type uses Http[s]/XHR and is + * the sole browser based Thrift transport. Target servers must implement the http[s] + * transport (see: node.js example server). + */ + class TXHRTransport { + url: string; + wpos: number; + rpos: number; + useCORS: any; + send_buf: string; + recv_buf: string; + + /** + * If you do not specify a url then you must handle XHR operations on + * your own. This type can also be constructed using the Transport alias + * for backward compatibility. + * @param {string} [url] - The URL to connect to. + * @param {object} [options] - Options. + */ + constructor(url?: string, options?: Object); + + /** + * Gets the browser specific XmlHttpRequest Object. + * @returns {object} the browser XHR interface object + */ + getXmlHttpRequestObject(): Object; + + /** + * Sends the current XRH request if the transport was created with a URL and + * the async parameter if false. If the transport was not created with a URL + * or the async parameter is True or the URL is an empty string, the current + * send buffer is returned. + * @param {object} async - If true the current send buffer is returned. + * @param {function} callback - Optional async completion callback. + * @returns {undefined|string} Nothing or the current send buffer. + */ + flush(async: any, callback?: Function): string; + + /** + * Creates a jQuery XHR object to be used for a Thrift server call. + * @param {object} client - The Thrift Service client object generated by the IDL compiler. + * @param {object} postData - The message to send to the server. + * @param {function} args - The function to call if the request succeeds. + * @param {function} recv_method - The Thrift Service Client receive method for the call. + * @returns {object} A new jQuery XHR object. + */ + jqRequest(client: Object, postData: any, args: Function, recv_method: Function): Object; + + /** + * Sets the buffer to use when receiving server responses. + * @param {string} buf - The buffer to receive server responses. + */ + setRecvBuffer(buf: string): void; + + /** + * Returns true if the transport is open, in browser based JavaScript + * this function always returns true. + * @returns {boolean} Always True. + */ + isOpen(): boolean; + + /** + * Opens the transport connection, in browser based JavaScript + * this function is a nop. + */ + open(): void; + + /** + * Closes the transport connection, in browser based JavaScript + * this function is a nop. + */ + close(): void; + + /** + * Returns the specified number of characters from the response + * buffer. + * @param {number} len - The number of characters to return. + * @returns {string} Characters sent by the server. + */ + read(len: number): string; + + /** + * Returns the entire response buffer. + * @returns {string} Characters sent by the server. + */ + readAll(): string; + + /** + * Sets the send buffer to buf. + * @param {string} buf - The buffer to send. + */ + write(buf: string): void; + + /** + * Returns the send buffer. + * @returns {string} The send buffer. + */ + getSendBuffer(): string; + } + + /** + * Old alias of the TXHRTransport for backwards compatibility. + */ + class Transport extends TXHRTransport { } + + /** + * The Apache Thrift Transport layer performs byte level I/O + * between RPC clients and servers. The JavaScript TWebSocketTransport object + * uses the WebSocket protocol. Target servers must implement WebSocket. + */ + class TWebSocketTransport { + url: string; //Where to connect + socket: any; //The web socket + callbacks: Function[]; //Pending callbacks + send_pending: any[]; //Buffers/Callback pairs waiting to be sent + send_buf: string; //Outbound data, immutable until sent + recv_buf: string; //Inbound data + rb_wpos: number; //Network write position in receive buffer + rb_rpos: number; //Client read position in receive buffer + + /** + * Constructor Function for the WebSocket transport. + * @param {string } [url] - The URL to connect to. + */ + constructor(url: string); + + __reset(url: string): void; + + /** + * Sends the current WS request and registers callback. The async + * parameter is ignored (WS flush is always async) and the callback + * function parameter is required. + * @param {object} async - Ignored. + * @param {function} callback - The client completion callback. + * @returns {undefined|string} Nothing (undefined) + */ + flush(async: any, callback: Function): string; + + __onOpen(): void; + + __onClose(): void; + + __onMessage(): void; + + __onError(): void; + + /** + * Sets the buffer to use when receiving server responses. + * @param {string} buf - The buffer to receive server responses. + */ + setRecvBuffer(buf: string): void; + + /** + * Returns true if the transport is open + * @returns {boolean} + */ + isOpen(): boolean; + + /** + * Opens the transport connection + */ + open(): void; + + /** + * Closes the transport connection + */ + close(): void; + + /** + * Returns the specified number of characters from the response + * buffer. + * @param {number} len - The number of characters to return. + * @returns {string} Characters sent by the server. + */ + read(len: number): string; + + /** + * Returns the entire response buffer. + * @returns {string} Characters sent by the server. + */ + readAll(): string; + + /** + * Sets the send buffer to buf. + * @param {string} buf - The buffer to send. + */ + write(buf: string): void; + + /** + * Returns the send buffer. + * @returns {string} The send buffer. + */ + getSendBuffer(): string; + } + + /** + * Apache Thrift Protocols perform serialization which enables cross + * language RPC. The Protocol type is the JavaScript browser implementation + * of the Apache Thrift TJSONProtocol. + */ + class TJSONProtocol { + transport: Object; + + /** + * Thrift IDL type Id to string mapping. + * The mapping table looks as follows: + * Thrift.Type.BOOL -> "tf": True/False integer. + * Thrift.Type.BYTE -> "i8": Signed 8 bit integer. + * Thrift.Type.I16 -> "i16": Signed 16 bit integer. + * Thrift.Type.I32 -> "i32": Signed 32 bit integer. + * Thrift.Type.I64 -> "i64": Signed 64 bit integer. + * Thrift.Type.DOUBLE -> "dbl": 64 bit IEEE 854 floating point. + * Thrift.Type.STRUCT -> "rec": A multifield type. + * Thrift.Type.STRING -> "str": Array of bytes representing a string of characters. + * Thrift.Type.MAP -> "map": A collection type (map/associative-array/dictionary). + * Thrift.Type.LIST -> "lst": A collection type (unordered). + * Thrift.Type.SET -> "set": A collection type (unordered and without repeated values). + */ + Type: { [k: number]: string }; + + /** + * Thrift IDL type string to Id mapping. + * The mapping table looks as follows: + * "tf" -> Thrift.Type.BOOL + * "i8" -> Thrift.Type.BYTE + * "i16" -> Thrift.Type.I16 + * "i32" -> Thrift.Type.I32 + * "i64" -> Thrift.Type.I64 + * "dbl" -> Thrift.Type.DOUBLE + * "rec" -> Thrift.Type.STRUCT + * "str" -> Thrift.Type.STRING + * "map" -> Thrift.Type.MAP + * "lst" -> Thrift.Type.LIST + * "set" -> Thrift.Type.SET + */ + RType: { [k: string]: number }; + + /** + * The TJSONProtocol version number. + */ + Version: number; + + /** + * Initializes a Thrift JSON protocol instance. + * @param {Thrift.Transport} transport - The transport to serialize to/from. + */ + constructor(transport: Object); + + /** + * Returns the underlying transport. + * @returns {Thrift.Transport} The underlying transport. + */ + getTransport(): Object; + + /** + * Serializes the beginning of a Thrift RPC message. + * @param {string} name - The service method to call. + * @param {Thrift.MessageType} messageType - The type of method call. + * @param {number} seqid - The sequence number of this call (always 0 in Apache Thrift). + */ + writeMessageBegin(name: string, messageType: number, seqid: number): void; + + /** + * Serializes the end of a Thrift RPC message. + */ + writeMessageEnd(): void; + + /** + * Serializes the beginning of a struct. + * @param {string} name - The name of the struct. + */ + writeStructBegin(name?: string): void; + + /** + * Serializes the end of a struct. + */ + writeStructEnd(): void; + + /** + * Serializes the beginning of a struct field. + * @param {string} name - The name of the field. + * @param {Thrift.Protocol.Type} fieldType - The data type of the field. + * @param {number} fieldId - The field's unique identifier. + */ + writeFieldBegin(name: string, fieldType: number, fieldId: number): void; + + /** + * Serializes the end of a field. + */ + writeFieldEnd(): void; + + /** + * Serializes the end of the set of fields for a struct. + */ + writeFieldStop(): void; + + /** + * Serializes the beginning of a map collection. + * @param {Thrift.Type} keyType - The data type of the key. + * @param {Thrift.Type} valType - The data type of the value. + * @param {number} [size] - The number of elements in the map (ignored). + */ + writeMapBegin(keyType: number, valType: number, size?: number): void; + + /** + * Serializes the end of a map. + */ + writeMapEnd(): void; + + /** + * Serializes the beginning of a list collection. + * @param {Thrift.Type} elemType - The data type of the elements. + * @param {number} size - The number of elements in the list. + */ + writeListBegin(elemType: number, size: number): void; + + /** + * Serializes the end of a list. + */ + writeListEnd(): void; + + /** + * Serializes the beginning of a set collection. + * @param {Thrift.Type} elemType - The data type of the elements. + * @param {number} size - The number of elements in the list. + */ + writeSetBegin(elemType: number, size: number): void; + + /** + * Serializes the end of a set. + */ + writeSetEnd(): void; + + /** Serializes a boolean */ + writeBool(value: boolean): void; + + /** Serializes a number */ + writeByte(i8: number): void; + + /** Serializes a number */ + writeI16(i16: number): void; + + /** Serializes a number */ + writeI32(i32: number): void; + + /** Serializes a number */ + writeI64(i64: number): void; + + /** Serializes a number */ + writeDouble(dbl: number): void; + + /** Serializes a string */ + writeString(str: string): void; + + /** Serializes a string */ + writeBinary(str: string): void; + + /** + @class + @name AnonReadMessageBeginReturn + @property {string} fname - The name of the service method. + @property {Thrift.MessageType} mtype - The type of message call. + @property {number} rseqid - The sequence number of the message (0 in Thrift RPC). + */ + /** + * Deserializes the beginning of a message. + * @returns {AnonReadMessageBeginReturn} + */ + readMessageBegin(): { fname: string; mtype: number; rseqid: number }; + + /** Deserializes the end of a message. */ + readMessageEnd(): void; + + /** + * Deserializes the beginning of a struct. + * @param {string} [name] - The name of the struct (ignored). + * @returns {object} - An object with an empty string fname property. + */ + readStructBegin(name?: string): { fname: string }; + + /** Deserializes the end of a struct. */ + readStructEnd(): void; + + /** + @class + @name AnonReadFieldBeginReturn + @property {string} fname - The name of the field (always ''). + @property {Thrift.Type} ftype - The data type of the field. + @property {number} fid - The unique identifier of the field. + */ + /** + * Deserializes the beginning of a field. + * @returns {AnonReadFieldBeginReturn} + */ + readFieldBegin(): { fname: string; ftype: number; fid: number }; + + /** Deserializes the end of a field. */ + readFieldEnd(): void; + + /** + @class + @name AnonReadMapBeginReturn + @property {Thrift.Type} ktype - The data type of the key. + @property {Thrift.Type} vtype - The data type of the value. + @property {number} size - The number of elements in the map. + */ + /** + * Deserializes the beginning of a map. + * @returns {AnonReadMapBeginReturn} + */ + readMapBegin(): { ktype: number; vtype: number; size: number }; + + /** Deserializes the end of a map. */ + readMapEnd(): void; + + /** + @class + @name AnonReadColBeginReturn + @property {Thrift.Type} etype - The data type of the element. + @property {number} size - The number of elements in the collection. + */ + /** + * Deserializes the beginning of a list. + * @returns {AnonReadColBeginReturn} + */ + readListBegin(): { etype: number; size: number }; + + /** Deserializes the end of a list. */ + readListEnd(): void; + + /** + * Deserializes the beginning of a set. + * @param {Thrift.Type} elemType - The data type of the elements (ignored). + * @param {number} size - The number of elements in the list (ignored). + * @returns {AnonReadColBeginReturn} + */ + readSetBegin(elemType?: number, size?: number): { etype: number; size: number }; + + /** Deserializes the end of a set. */ + readSetEnd(): void; + + /** Returns an object with a value property set to + * False unless the next number in the protocol buffer + * is 1, in which case the value property is True. */ + readBool(): Object; + + /** Returns an object with a value property set to the + next value found in the protocol buffer. */ + readByte(): Object; + + /** Returns an object with a value property set to the + next value found in the protocol buffer. */ + readI16(): Object; + + /** Returns an object with a value property set to the + next value found in the protocol buffer. */ + readI32(f?: any): Object; + + /** Returns an object with a value property set to the + next value found in the protocol buffer. */ + readI64(): Object; + + /** Returns an object with a value property set to the + next value found in the protocol buffer. */ + readDouble(): Object; + + /** Returns an object with a value property set to the + next value found in the protocol buffer. */ + readString(): Object; + + /** Returns an object with a value property set to the + next value found in the protocol buffer. */ + readBinary(): Object; + + /** + * Method to arbitrarily skip over data (not implemented). + */ + skip(type: number): void; + } + + /** + * Old alias of the TXHRTransport for backwards compatibility. + */ + class Protocol extends TJSONProtocol { } + + class MultiplexProtocol extends TJSONProtocol { + serviceName: string; + + /** + * Initializes a MutilplexProtocol Implementation as a Wrapper for Thrift.Protocol. + * @param {string} srvName + * @param {Thrift.Transport} trans + * @param {any} [strictRead] + * @param {any} [strictWrite] + */ + constructor(srvName: string, trans: Object, strictRead?: any, strictWrite?: any); + + /** + * Override writeMessageBegin method of prototype + * Serializes the beginning of a Thrift RPC message. + * @param {string} name - The service method to call. + * @param {Thrift.MessageType} messageType - The type of method call. + * @param {number} seqid - The sequence number of this call (always 0 in Apache Thrift). + */ + writeMessageBegin(name: string, type: number, seqid: number): void; + } + + class Multiplexer { + seqid: number; + + /** + * Instantiates a multiplexed client for a specific service. + * @param {String} serviceName - The transport to serialize to/from. + * @param {Thrift.ServiceClient} SCl - The Service Client Class. + * @param {Thrift.Transport} transport - Thrift.Transport instance which provides remote host:port. + */ + createClient(serviceName: string, SCl: any, transport: Object): any; + } +} |