triplinkclient 1.0.260201

package/README.md

@@ -0,0 +1,30 @@
+# Triplink Client for Node JS
+
+## Introduction
+
+
+## Usage
+Install the client using npm
+
+`npm i --save triplinkclient`
+
+Import the Triplink Client
+
+`import { TripLinkAirClient } from "triplinkclient/src/index";`
+
+Create a client Object using constructor
+
+```
+const clientOptions = {
+    clientId: 'REPLACEWITH_CLIENTID',
+    clientToken: 'REPLACEWITH_CLIENTTOKEN'
+};
+
+const client = new TripLinkAirClient(clientOptions);
+```
+
+
+Invoke respective methods for example for echo
+
+`const echoResponse = await client.echo(echoRequest);
+`

package/dist/defaultConfigOptions.d.ts

@@ -0,0 +1,8 @@
+declare const grpcOptions: {
+    'grpc.max_receive_message_length': number;
+    'grpc.max_send_message_length': number;
+    'grpc.max_connection_age_ms': number;
+    'grpc.max_connection_age_grace_ms': number;
+    'grpc.max_connection_idle_ms': number;
+};
+export default grpcOptions;

package/dist/defaultConfigOptions.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const grpcOptions = {
+    'grpc.max_receive_message_length': 50 * 1024 * 1024,
+    'grpc.max_send_message_length': 50 * 1024 * 1024,
+    'grpc.max_connection_age_ms': 1 * 60 * 1000, //1 Min
+    'grpc.max_connection_age_grace_ms': 10 * 60 * 1000, //10 Min
+    'grpc.max_connection_idle_ms': 20 * 1000 //20 s
+};
+exports.default = grpcOptions;
+//# sourceMappingURL=defaultConfigOptions.js.map

package/dist/defaultConfigOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultConfigOptions.js","sourceRoot":"","sources":["../src/defaultConfigOptions.ts"],"names":[],"mappings":";;AAAA,MAAM,WAAW,GAAG;IAChB,iCAAiC,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI;IACnD,8BAA8B,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI;IAChD,4BAA4B,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI,EAAE,OAAO;IACpD,kCAAkC,EAAE,EAAE,GAAG,EAAE,GAAG,IAAI,EAAE,QAAQ;IAC5D,6BAA6B,EAAE,EAAE,GAAG,IAAI,CAAC,MAAM;CAClD,CAAC;AAEF,kBAAe,WAAW,CAAC"}

package/dist/demo.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/demo.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const air_1 = require("./generated/air");
+const common_1 = require("./generated/common");
+const grpc = __importStar(require("@grpc/grpc-js"));
+console.log('Hello Starting');
+const echoReq = new common_1.EchoRequest();
+echoReq.msg = 'Hello Message Test';
+const metadata = new grpc.Metadata();
+metadata.add('clientId', 'testclient');
+metadata.add('clientToken', 'abcde');
+const client = new air_1.TripLinkAirServiceClient("tlapi.buycoins.targetagency.org:9090", grpc.ChannelCredentials.createSsl(), {}).echo(echoReq, metadata).then((v) => {
+    console.log('Fulfilled \n', v.msg);
+}, (v) => {
+    console.log('Rejected', v);
+});
+//# sourceMappingURL=demo.js.map

package/dist/demo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"demo.js","sourceRoot":"","sources":["../src/demo.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA2D;AAC3D,+CAAiD;AACjD,oDAAsC;AAEtC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;AAE9B,MAAM,OAAO,GAAgB,IAAI,oBAAW,EAAE,CAAC;AAC/C,OAAO,CAAC,GAAG,GAAG,oBAAoB,CAAC;AAEnC,MAAM,QAAQ,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;AACrC,QAAQ,CAAC,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;AACvC,QAAQ,CAAC,GAAG,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;AAErC,MAAM,MAAM,GAAG,IAAI,8BAAwB,CAAC,sCAAsC,EAAE,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,EAAE,EACxH,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;IAClC,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;AACvC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE;IACL,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;AAC/B,CAAC,CAAC,CAAC"}

package/dist/generated/account.d.ts

@@ -0,0 +1,576 @@
+/**
+ * Generated by the protoc-gen-ts.  DO NOT EDIT!
+ * compiler version: 6.33.2
+ * source: account.proto
+ * git: https://github.com/thesayyn/protoc-gen-ts */
+import * as dependency_1 from "./common";
+import * as pb_1 from "google-protobuf";
+import * as grpc_1 from "@grpc/grpc-js";
+export declare enum TransactionType {
+    CREDIT = 0,
+    DEBIT = 1
+}
+export declare enum TransactionStatus {
+    PENDING = 0,
+    COMPLETED = 1,
+    FAILED = 2
+}
+export declare class GetBalanceRequest extends pb_1.Message {
+    #private;
+    constructor(data?: any[] | {});
+    static fromObject(data: {}): GetBalanceRequest;
+    toObject(): {};
+    serialize(): Uint8Array;
+    serialize(w: pb_1.BinaryWriter): void;
+    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GetBalanceRequest;
+    serializeBinary(): Uint8Array;
+    static deserializeBinary(bytes: Uint8Array): GetBalanceRequest;
+}
+export declare class GetBalanceResponse extends pb_1.Message {
+    #private;
+    constructor(data?: any[] | {
+        result?: dependency_1.ResultStatus;
+        balance?: number;
+        creditLimit?: number;
+        availableBalance?: number;
+        currency?: string;
+    });
+    get result(): dependency_1.ResultStatus;
+    set result(value: dependency_1.ResultStatus);
+    get hasResult(): boolean;
+    get balance(): number;
+    set balance(value: number);
+    get creditLimit(): number;
+    set creditLimit(value: number);
+    get availableBalance(): number;
+    set availableBalance(value: number);
+    get currency(): string;
+    set currency(value: string);
+    static fromObject(data: {
+        result?: ReturnType<typeof dependency_1.ResultStatus.prototype.toObject>;
+        balance?: number;
+        creditLimit?: number;
+        availableBalance?: number;
+        currency?: string;
+    }): GetBalanceResponse;
+    toObject(): {
+        result?: ReturnType<typeof dependency_1.ResultStatus.prototype.toObject>;
+        balance?: number;
+        creditLimit?: number;
+        availableBalance?: number;
+        currency?: string;
+    };
+    serialize(): Uint8Array;
+    serialize(w: pb_1.BinaryWriter): void;
+    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GetBalanceResponse;
+    serializeBinary(): Uint8Array;
+    static deserializeBinary(bytes: Uint8Array): GetBalanceResponse;
+}
+export declare class GetTransactionHistoryRequest extends pb_1.Message {
+    #private;
+    constructor(data?: any[] | ({
+        pageNumber?: number;
+        pageSize?: number;
+    } & (({
+        startDate?: string;
+    }) | ({
+        endDate?: string;
+    }) | ({
+        transactionType?: TransactionType;
+    }) | ({
+        status?: TransactionStatus;
+    }))));
+    get pageNumber(): number;
+    set pageNumber(value: number);
+    get pageSize(): number;
+    set pageSize(value: number);
+    get startDate(): string;
+    set startDate(value: string);
+    get hasStartDate(): boolean;
+    get endDate(): string;
+    set endDate(value: string);
+    get hasEndDate(): boolean;
+    get transactionType(): TransactionType;
+    set transactionType(value: TransactionType);
+    get hasTransactionType(): boolean;
+    get status(): TransactionStatus;
+    set status(value: TransactionStatus);
+    get hasStatus(): boolean;
+    get _startDate(): "none" | "startDate";
+    get _endDate(): "none" | "endDate";
+    get _transactionType(): "none" | "transactionType";
+    get _status(): "none" | "status";
+    static fromObject(data: {
+        pageNumber?: number;
+        pageSize?: number;
+        startDate?: string;
+        endDate?: string;
+        transactionType?: TransactionType;
+        status?: TransactionStatus;
+    }): GetTransactionHistoryRequest;
+    toObject(): {
+        pageNumber?: number;
+        pageSize?: number;
+        startDate?: string;
+        endDate?: string;
+        transactionType?: TransactionType;
+        status?: TransactionStatus;
+    };
+    serialize(): Uint8Array;
+    serialize(w: pb_1.BinaryWriter): void;
+    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GetTransactionHistoryRequest;
+    serializeBinary(): Uint8Array;
+    static deserializeBinary(bytes: Uint8Array): GetTransactionHistoryRequest;
+}
+export declare class GetTransactionHistoryResponse extends pb_1.Message {
+    #private;
+    constructor(data?: any[] | {
+        result?: dependency_1.ResultStatus;
+        transactions?: Transaction[];
+        totalRecords?: number;
+        pageNumber?: number;
+        pageSize?: number;
+    });
+    get result(): dependency_1.ResultStatus;
+    set result(value: dependency_1.ResultStatus);
+    get hasResult(): boolean;
+    get transactions(): Transaction[];
+    set transactions(value: Transaction[]);
+    get totalRecords(): number;
+    set totalRecords(value: number);
+    get pageNumber(): number;
+    set pageNumber(value: number);
+    get pageSize(): number;
+    set pageSize(value: number);
+    static fromObject(data: {
+        result?: ReturnType<typeof dependency_1.ResultStatus.prototype.toObject>;
+        transactions?: ReturnType<typeof Transaction.prototype.toObject>[];
+        totalRecords?: number;
+        pageNumber?: number;
+        pageSize?: number;
+    }): GetTransactionHistoryResponse;
+    toObject(): {
+        result?: ReturnType<typeof dependency_1.ResultStatus.prototype.toObject>;
+        transactions?: ReturnType<typeof Transaction.prototype.toObject>[];
+        totalRecords?: number;
+        pageNumber?: number;
+        pageSize?: number;
+    };
+    serialize(): Uint8Array;
+    serialize(w: pb_1.BinaryWriter): void;
+    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GetTransactionHistoryResponse;
+    serializeBinary(): Uint8Array;
+    static deserializeBinary(bytes: Uint8Array): GetTransactionHistoryResponse;
+}
+export declare class Transaction extends pb_1.Message {
+    #private;
+    constructor(data?: any[] | {
+        transactionId?: string;
+        type?: TransactionType;
+        status?: TransactionStatus;
+        amount?: number;
+        balanceAfter?: number;
+        description?: string;
+        referenceId?: string;
+        createdOn?: string;
+        currency?: string;
+    });
+    get transactionId(): string;
+    set transactionId(value: string);
+    get type(): TransactionType;
+    set type(value: TransactionType);
+    get status(): TransactionStatus;
+    set status(value: TransactionStatus);
+    get amount(): number;
+    set amount(value: number);
+    get balanceAfter(): number;
+    set balanceAfter(value: number);
+    get description(): string;
+    set description(value: string);
+    get referenceId(): string;
+    set referenceId(value: string);
+    get createdOn(): string;
+    set createdOn(value: string);
+    get currency(): string;
+    set currency(value: string);
+    static fromObject(data: {
+        transactionId?: string;
+        type?: TransactionType;
+        status?: TransactionStatus;
+        amount?: number;
+        balanceAfter?: number;
+        description?: string;
+        referenceId?: string;
+        createdOn?: string;
+        currency?: string;
+    }): Transaction;
+    toObject(): {
+        transactionId?: string;
+        type?: TransactionType;
+        status?: TransactionStatus;
+        amount?: number;
+        balanceAfter?: number;
+        description?: string;
+        referenceId?: string;
+        createdOn?: string;
+        currency?: string;
+    };
+    serialize(): Uint8Array;
+    serialize(w: pb_1.BinaryWriter): void;
+    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Transaction;
+    serializeBinary(): Uint8Array;
+    static deserializeBinary(bytes: Uint8Array): Transaction;
+}
+export declare class AddBalanceRequest extends pb_1.Message {
+    #private;
+    constructor(data?: any[] | ({
+        amount?: number;
+        description?: string;
+    } & (({
+        referenceId?: string;
+    }) | ({
+        paymentMethod?: string;
+    }) | ({
+        transactionRef?: string;
+    }))));
+    get amount(): number;
+    set amount(value: number);
+    get description(): string;
+    set description(value: string);
+    get referenceId(): string;
+    set referenceId(value: string);
+    get hasReferenceId(): boolean;
+    get paymentMethod(): string;
+    set paymentMethod(value: string);
+    get hasPaymentMethod(): boolean;
+    get transactionRef(): string;
+    set transactionRef(value: string);
+    get hasTransactionRef(): boolean;
+    get _referenceId(): "none" | "referenceId";
+    get _paymentMethod(): "none" | "paymentMethod";
+    get _transactionRef(): "none" | "transactionRef";
+    static fromObject(data: {
+        amount?: number;
+        description?: string;
+        referenceId?: string;
+        paymentMethod?: string;
+        transactionRef?: string;
+    }): AddBalanceRequest;
+    toObject(): {
+        amount?: number;
+        description?: string;
+        referenceId?: string;
+        paymentMethod?: string;
+        transactionRef?: string;
+    };
+    serialize(): Uint8Array;
+    serialize(w: pb_1.BinaryWriter): void;
+    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AddBalanceRequest;
+    serializeBinary(): Uint8Array;
+    static deserializeBinary(bytes: Uint8Array): AddBalanceRequest;
+}
+export declare class AddBalanceResponse extends pb_1.Message {
+    #private;
+    constructor(data?: any[] | {
+        result?: dependency_1.ResultStatus;
+        transactionId?: string;
+        previousBalance?: number;
+        amountAdded?: number;
+        newBalance?: number;
+        createdOn?: string;
+    });
+    get result(): dependency_1.ResultStatus;
+    set result(value: dependency_1.ResultStatus);
+    get hasResult(): boolean;
+    get transactionId(): string;
+    set transactionId(value: string);
+    get previousBalance(): number;
+    set previousBalance(value: number);
+    get amountAdded(): number;
+    set amountAdded(value: number);
+    get newBalance(): number;
+    set newBalance(value: number);
+    get createdOn(): string;
+    set createdOn(value: string);
+    static fromObject(data: {
+        result?: ReturnType<typeof dependency_1.ResultStatus.prototype.toObject>;
+        transactionId?: string;
+        previousBalance?: number;
+        amountAdded?: number;
+        newBalance?: number;
+        createdOn?: string;
+    }): AddBalanceResponse;
+    toObject(): {
+        result?: ReturnType<typeof dependency_1.ResultStatus.prototype.toObject>;
+        transactionId?: string;
+        previousBalance?: number;
+        amountAdded?: number;
+        newBalance?: number;
+        createdOn?: string;
+    };
+    serialize(): Uint8Array;
+    serialize(w: pb_1.BinaryWriter): void;
+    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AddBalanceResponse;
+    serializeBinary(): Uint8Array;
+    static deserializeBinary(bytes: Uint8Array): AddBalanceResponse;
+}
+export declare class DeductBalanceRequest extends pb_1.Message {
+    #private;
+    constructor(data?: any[] | ({
+        amount?: number;
+        description?: string;
+    } & (({
+        referenceId?: string;
+    }) | ({
+        orderId?: string;
+    }))));
+    get amount(): number;
+    set amount(value: number);
+    get description(): string;
+    set description(value: string);
+    get referenceId(): string;
+    set referenceId(value: string);
+    get hasReferenceId(): boolean;
+    get orderId(): string;
+    set orderId(value: string);
+    get hasOrderId(): boolean;
+    get _referenceId(): "none" | "referenceId";
+    get _orderId(): "none" | "orderId";
+    static fromObject(data: {
+        amount?: number;
+        description?: string;
+        referenceId?: string;
+        orderId?: string;
+    }): DeductBalanceRequest;
+    toObject(): {
+        amount?: number;
+        description?: string;
+        referenceId?: string;
+        orderId?: string;
+    };
+    serialize(): Uint8Array;
+    serialize(w: pb_1.BinaryWriter): void;
+    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): DeductBalanceRequest;
+    serializeBinary(): Uint8Array;
+    static deserializeBinary(bytes: Uint8Array): DeductBalanceRequest;
+}
+export declare class DeductBalanceResponse extends pb_1.Message {
+    #private;
+    constructor(data?: any[] | {
+        result?: dependency_1.ResultStatus;
+        transactionId?: string;
+        previousBalance?: number;
+        amountDeducted?: number;
+        newBalance?: number;
+        createdOn?: string;
+    });
+    get result(): dependency_1.ResultStatus;
+    set result(value: dependency_1.ResultStatus);
+    get hasResult(): boolean;
+    get transactionId(): string;
+    set transactionId(value: string);
+    get previousBalance(): number;
+    set previousBalance(value: number);
+    get amountDeducted(): number;
+    set amountDeducted(value: number);
+    get newBalance(): number;
+    set newBalance(value: number);
+    get createdOn(): string;
+    set createdOn(value: string);
+    static fromObject(data: {
+        result?: ReturnType<typeof dependency_1.ResultStatus.prototype.toObject>;
+        transactionId?: string;
+        previousBalance?: number;
+        amountDeducted?: number;
+        newBalance?: number;
+        createdOn?: string;
+    }): DeductBalanceResponse;
+    toObject(): {
+        result?: ReturnType<typeof dependency_1.ResultStatus.prototype.toObject>;
+        transactionId?: string;
+        previousBalance?: number;
+        amountDeducted?: number;
+        newBalance?: number;
+        createdOn?: string;
+    };
+    serialize(): Uint8Array;
+    serialize(w: pb_1.BinaryWriter): void;
+    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): DeductBalanceResponse;
+    serializeBinary(): Uint8Array;
+    static deserializeBinary(bytes: Uint8Array): DeductBalanceResponse;
+}
+export declare class GetStatementRequest extends pb_1.Message {
+    #private;
+    constructor(data?: any[] | ({
+        startDate?: string;
+        endDate?: string;
+    } & (({
+        format?: string;
+    }))));
+    get startDate(): string;
+    set startDate(value: string);
+    get endDate(): string;
+    set endDate(value: string);
+    get format(): string;
+    set format(value: string);
+    get hasFormat(): boolean;
+    get _format(): "none" | "format";
+    static fromObject(data: {
+        startDate?: string;
+        endDate?: string;
+        format?: string;
+    }): GetStatementRequest;
+    toObject(): {
+        startDate?: string;
+        endDate?: string;
+        format?: string;
+    };
+    serialize(): Uint8Array;
+    serialize(w: pb_1.BinaryWriter): void;
+    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GetStatementRequest;
+    serializeBinary(): Uint8Array;
+    static deserializeBinary(bytes: Uint8Array): GetStatementRequest;
+}
+export declare class GetStatementResponse extends pb_1.Message {
+    #private;
+    constructor(data?: any[] | ({
+        result?: dependency_1.ResultStatus;
+        startDate?: string;
+        endDate?: string;
+        openingBalance?: number;
+        closingBalance?: number;
+        totalCredits?: number;
+        totalDebits?: number;
+        transactions?: Transaction[];
+    } & (({
+        documentData?: Uint8Array;
+    }))));
+    get result(): dependency_1.ResultStatus;
+    set result(value: dependency_1.ResultStatus);
+    get hasResult(): boolean;
+    get startDate(): string;
+    set startDate(value: string);
+    get endDate(): string;
+    set endDate(value: string);
+    get openingBalance(): number;
+    set openingBalance(value: number);
+    get closingBalance(): number;
+    set closingBalance(value: number);
+    get totalCredits(): number;
+    set totalCredits(value: number);
+    get totalDebits(): number;
+    set totalDebits(value: number);
+    get transactions(): Transaction[];
+    set transactions(value: Transaction[]);
+    get documentData(): Uint8Array;
+    set documentData(value: Uint8Array);
+    get hasDocumentData(): boolean;
+    get _documentData(): "none" | "documentData";
+    static fromObject(data: {
+        result?: ReturnType<typeof dependency_1.ResultStatus.prototype.toObject>;
+        startDate?: string;
+        endDate?: string;
+        openingBalance?: number;
+        closingBalance?: number;
+        totalCredits?: number;
+        totalDebits?: number;
+        transactions?: ReturnType<typeof Transaction.prototype.toObject>[];
+        documentData?: Uint8Array;
+    }): GetStatementResponse;
+    toObject(): {
+        result?: ReturnType<typeof dependency_1.ResultStatus.prototype.toObject>;
+        startDate?: string;
+        endDate?: string;
+        openingBalance?: number;
+        closingBalance?: number;
+        totalCredits?: number;
+        totalDebits?: number;
+        transactions?: ReturnType<typeof Transaction.prototype.toObject>[];
+        documentData?: Uint8Array;
+    };
+    serialize(): Uint8Array;
+    serialize(w: pb_1.BinaryWriter): void;
+    static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GetStatementResponse;
+    serializeBinary(): Uint8Array;
+    static deserializeBinary(bytes: Uint8Array): GetStatementResponse;
+}
+interface GrpcPromiseServiceInterface<P, R> {
+    (message: P, metadata: grpc_1.Metadata, options?: grpc_1.CallOptions): Promise<R>;
+    (message: P, options?: grpc_1.CallOptions): Promise<R>;
+}
+export declare abstract class UnimplementedTripLinkAccountServiceService {
+    static definition: {
+        echo: {
+            path: string;
+            requestStream: boolean;
+            responseStream: boolean;
+            requestSerialize: (message: dependency_1.EchoRequest) => Buffer<ArrayBuffer>;
+            requestDeserialize: (bytes: Buffer) => dependency_1.EchoRequest;
+            responseSerialize: (message: dependency_1.EchoResponse) => Buffer<ArrayBuffer>;
+            responseDeserialize: (bytes: Buffer) => dependency_1.EchoResponse;
+        };
+        getBalance: {
+            path: string;
+            requestStream: boolean;
+            responseStream: boolean;
+            requestSerialize: (message: GetBalanceRequest) => Buffer<ArrayBuffer>;
+            requestDeserialize: (bytes: Buffer) => GetBalanceRequest;
+            responseSerialize: (message: GetBalanceResponse) => Buffer<ArrayBuffer>;
+            responseDeserialize: (bytes: Buffer) => GetBalanceResponse;
+        };
+        getTransactionHistory: {
+            path: string;
+            requestStream: boolean;
+            responseStream: boolean;
+            requestSerialize: (message: GetTransactionHistoryRequest) => Buffer<ArrayBuffer>;
+            requestDeserialize: (bytes: Buffer) => GetTransactionHistoryRequest;
+            responseSerialize: (message: GetTransactionHistoryResponse) => Buffer<ArrayBuffer>;
+            responseDeserialize: (bytes: Buffer) => GetTransactionHistoryResponse;
+        };
+        addBalance: {
+            path: string;
+            requestStream: boolean;
+            responseStream: boolean;
+            requestSerialize: (message: AddBalanceRequest) => Buffer<ArrayBuffer>;
+            requestDeserialize: (bytes: Buffer) => AddBalanceRequest;
+            responseSerialize: (message: AddBalanceResponse) => Buffer<ArrayBuffer>;
+            responseDeserialize: (bytes: Buffer) => AddBalanceResponse;
+        };
+        deductBalance: {
+            path: string;
+            requestStream: boolean;
+            responseStream: boolean;
+            requestSerialize: (message: DeductBalanceRequest) => Buffer<ArrayBuffer>;
+            requestDeserialize: (bytes: Buffer) => DeductBalanceRequest;
+            responseSerialize: (message: DeductBalanceResponse) => Buffer<ArrayBuffer>;
+            responseDeserialize: (bytes: Buffer) => DeductBalanceResponse;
+        };
+        getStatement: {
+            path: string;
+            requestStream: boolean;
+            responseStream: boolean;
+            requestSerialize: (message: GetStatementRequest) => Buffer<ArrayBuffer>;
+            requestDeserialize: (bytes: Buffer) => GetStatementRequest;
+            responseSerialize: (message: GetStatementResponse) => Buffer<ArrayBuffer>;
+            responseDeserialize: (bytes: Buffer) => GetStatementResponse;
+        };
+    };
+    [method: string]: grpc_1.UntypedHandleCall;
+    abstract echo(call: grpc_1.ServerUnaryCall<dependency_1.EchoRequest, dependency_1.EchoResponse>, callback: grpc_1.sendUnaryData<dependency_1.EchoResponse>): void;
+    abstract getBalance(call: grpc_1.ServerUnaryCall<GetBalanceRequest, GetBalanceResponse>, callback: grpc_1.sendUnaryData<GetBalanceResponse>): void;
+    abstract getTransactionHistory(call: grpc_1.ServerUnaryCall<GetTransactionHistoryRequest, GetTransactionHistoryResponse>, callback: grpc_1.sendUnaryData<GetTransactionHistoryResponse>): void;
+    abstract addBalance(call: grpc_1.ServerUnaryCall<AddBalanceRequest, AddBalanceResponse>, callback: grpc_1.sendUnaryData<AddBalanceResponse>): void;
+    abstract deductBalance(call: grpc_1.ServerUnaryCall<DeductBalanceRequest, DeductBalanceResponse>, callback: grpc_1.sendUnaryData<DeductBalanceResponse>): void;
+    abstract getStatement(call: grpc_1.ServerUnaryCall<GetStatementRequest, GetStatementResponse>, callback: grpc_1.sendUnaryData<GetStatementResponse>): void;
+}
+declare const TripLinkAccountServiceClient_base: grpc_1.ServiceClientConstructor;
+export declare class TripLinkAccountServiceClient extends TripLinkAccountServiceClient_base {
+    constructor(address: string, credentials: grpc_1.ChannelCredentials, options?: Partial<grpc_1.ChannelOptions>);
+    echo: GrpcPromiseServiceInterface<dependency_1.EchoRequest, dependency_1.EchoResponse>;
+    getBalance: GrpcPromiseServiceInterface<GetBalanceRequest, GetBalanceResponse>;
+    getTransactionHistory: GrpcPromiseServiceInterface<GetTransactionHistoryRequest, GetTransactionHistoryResponse>;
+    addBalance: GrpcPromiseServiceInterface<AddBalanceRequest, AddBalanceResponse>;
+    deductBalance: GrpcPromiseServiceInterface<DeductBalanceRequest, DeductBalanceResponse>;
+    getStatement: GrpcPromiseServiceInterface<GetStatementRequest, GetStatementResponse>;
+}
+export {};