/* * 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; } }