@technova-tech/olive-proto-lib 1.2.0

package/types/google/protobuf/any.d.ts

@@ -0,0 +1,27 @@
+import * as pb_1 from "google-protobuf";
+export declare namespace google.protobuf {
+    class Any extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            typeUrl?: string;
+            value?: Uint8Array;
+        });
+        get typeUrl(): string;
+        set typeUrl(value: string);
+        get value(): Uint8Array;
+        set value(value: Uint8Array);
+        static fromObject(data: {
+            typeUrl?: string;
+            value?: Uint8Array;
+        }): Any;
+        toObject(): {
+            typeUrl?: string | undefined;
+            value?: Uint8Array | undefined;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Any;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): Any;
+    }
+}

package/types/google/protobuf/struct.d.ts

@@ -0,0 +1,175 @@
+import * as pb_1 from "google-protobuf";
+export declare namespace google.protobuf {
+    enum NullValue {
+        NULL_VALUE = 0
+    }
+    class Struct extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            fields?: Map<string, Value>;
+        });
+        get fields(): Map<string, Value>;
+        set fields(value: Map<string, Value>);
+        static fromObject(data: {
+            fields?: {
+                [key: string]: ReturnType<typeof Value.prototype.toObject>;
+            };
+        }): Struct;
+        toObject(): {
+            fields?: {
+                [key: string]: {
+                    nullValue?: NullValue | undefined;
+                    numberValue?: number | undefined;
+                    stringValue?: string | undefined;
+                    boolValue?: boolean | undefined;
+                    structValue?: {
+                        fields?: {
+                            [key: string]: any;
+                        } | undefined;
+                    } | undefined;
+                    listValue?: {
+                        values?: any[] | undefined;
+                    } | undefined;
+                };
+            } | undefined;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Struct;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): Struct;
+    }
+    class Value extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | ({} & (({
+            nullValue?: NullValue;
+            numberValue?: never;
+            stringValue?: never;
+            boolValue?: never;
+            structValue?: never;
+            listValue?: never;
+        } | {
+            nullValue?: never;
+            numberValue?: number;
+            stringValue?: never;
+            boolValue?: never;
+            structValue?: never;
+            listValue?: never;
+        } | {
+            nullValue?: never;
+            numberValue?: never;
+            stringValue?: string;
+            boolValue?: never;
+            structValue?: never;
+            listValue?: never;
+        } | {
+            nullValue?: never;
+            numberValue?: never;
+            stringValue?: never;
+            boolValue?: boolean;
+            structValue?: never;
+            listValue?: never;
+        } | {
+            nullValue?: never;
+            numberValue?: never;
+            stringValue?: never;
+            boolValue?: never;
+            structValue?: Struct;
+            listValue?: never;
+        } | {
+            nullValue?: never;
+            numberValue?: never;
+            stringValue?: never;
+            boolValue?: never;
+            structValue?: never;
+            listValue?: ListValue;
+        }))));
+        get nullValue(): NullValue;
+        set nullValue(value: NullValue);
+        get hasNullValue(): boolean;
+        get numberValue(): number;
+        set numberValue(value: number);
+        get hasNumberValue(): boolean;
+        get stringValue(): string;
+        set stringValue(value: string);
+        get hasStringValue(): boolean;
+        get boolValue(): boolean;
+        set boolValue(value: boolean);
+        get hasBoolValue(): boolean;
+        get structValue(): Struct;
+        set structValue(value: Struct);
+        get hasStructValue(): boolean;
+        get listValue(): ListValue;
+        set listValue(value: ListValue);
+        get hasListValue(): boolean;
+        get kind(): "none" | "nullValue" | "numberValue" | "stringValue" | "boolValue" | "structValue" | "listValue";
+        static fromObject(data: {
+            nullValue?: NullValue;
+            numberValue?: number;
+            stringValue?: string;
+            boolValue?: boolean;
+            structValue?: ReturnType<typeof Struct.prototype.toObject>;
+            listValue?: ReturnType<typeof ListValue.prototype.toObject>;
+        }): Value;
+        toObject(): {
+            nullValue?: NullValue | undefined;
+            numberValue?: number | undefined;
+            stringValue?: string | undefined;
+            boolValue?: boolean | undefined;
+            structValue?: {
+                fields?: {
+                    [key: string]: {
+                        nullValue?: NullValue | undefined;
+                        numberValue?: number | undefined;
+                        stringValue?: string | undefined;
+                        boolValue?: boolean | undefined;
+                        structValue?: any | undefined;
+                        listValue?: {
+                            values?: any[] | undefined;
+                        } | undefined;
+                    };
+                } | undefined;
+            } | undefined;
+            listValue?: {
+                values?: any[] | undefined;
+            } | undefined;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Value;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): Value;
+    }
+    class ListValue extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            values?: Value[];
+        });
+        get values(): Value[];
+        set values(value: Value[]);
+        static fromObject(data: {
+            values?: ReturnType<typeof Value.prototype.toObject>[];
+        }): ListValue;
+        toObject(): {
+            values?: {
+                nullValue?: NullValue | undefined;
+                numberValue?: number | undefined;
+                stringValue?: string | undefined;
+                boolValue?: boolean | undefined;
+                structValue?: {
+                    fields?: {
+                        [key: string]: any;
+                    } | undefined;
+                } | undefined;
+                listValue?: {
+                    values?: any[] | undefined;
+                } | undefined;
+            }[] | undefined;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ListValue;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): ListValue;
+    }
+}

package/types/image/recognition.d.ts

@@ -0,0 +1,147 @@
+/// <reference types="node" />
+import * as pb_1 from "google-protobuf";
+import * as grpc_1 from "@grpc/grpc-js";
+export declare namespace com.pkg.image {
+    export class ValidationErrors extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            field?: string;
+            message?: string;
+        });
+        get field(): string;
+        set field(value: string);
+        get message(): string;
+        set message(value: string);
+        static fromObject(data: {
+            field?: string;
+            message?: string;
+        }): ValidationErrors;
+        toObject(): {
+            field?: string | undefined;
+            message?: string | undefined;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ValidationErrors;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): ValidationErrors;
+    }
+    export class CompareFacesRequest extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            first?: string;
+            second?: string;
+        });
+        get first(): string;
+        set first(value: string);
+        get second(): string;
+        set second(value: string);
+        static fromObject(data: {
+            first?: string;
+            second?: string;
+        }): CompareFacesRequest;
+        toObject(): {
+            first?: string | undefined;
+            second?: string | undefined;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): CompareFacesRequest;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): CompareFacesRequest;
+    }
+    export class CompareFacesData extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            similarity?: number;
+        });
+        get similarity(): number;
+        set similarity(value: number);
+        static fromObject(data: {
+            similarity?: number;
+        }): CompareFacesData;
+        toObject(): {
+            similarity?: number | undefined;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): CompareFacesData;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): CompareFacesData;
+    }
+    export class CompareFacesResponse extends pb_1.Message {
+        #private;
+        constructor(data?: any[] | {
+            status?: string;
+            data?: CompareFacesData;
+            error?: string;
+            message?: string;
+            validationErrors?: ValidationErrors[];
+            success?: boolean;
+        });
+        get status(): string;
+        set status(value: string);
+        get data(): CompareFacesData;
+        set data(value: CompareFacesData);
+        get hasData(): boolean;
+        get error(): string;
+        set error(value: string);
+        get message(): string;
+        set message(value: string);
+        get validationErrors(): ValidationErrors[];
+        set validationErrors(value: ValidationErrors[]);
+        get success(): boolean;
+        set success(value: boolean);
+        static fromObject(data: {
+            status?: string;
+            data?: ReturnType<typeof CompareFacesData.prototype.toObject>;
+            error?: string;
+            message?: string;
+            validationErrors?: ReturnType<typeof ValidationErrors.prototype.toObject>[];
+            success?: boolean;
+        }): CompareFacesResponse;
+        toObject(): {
+            status?: string | undefined;
+            data?: {
+                similarity?: number | undefined;
+            } | undefined;
+            error?: string | undefined;
+            message?: string | undefined;
+            validationErrors?: {
+                field?: string | undefined;
+                message?: string | undefined;
+            }[] | undefined;
+            success?: boolean | undefined;
+        };
+        serialize(): Uint8Array;
+        serialize(w: pb_1.BinaryWriter): void;
+        static deserialize(bytes: Uint8Array | pb_1.BinaryReader): CompareFacesResponse;
+        serializeBinary(): Uint8Array;
+        static deserializeBinary(bytes: Uint8Array): CompareFacesResponse;
+    }
+    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 abstract class UnimplementedImageRecognitionService {
+        static definition: {
+            CompareFaces: {
+                path: string;
+                requestStream: boolean;
+                responseStream: boolean;
+                requestSerialize: (message: CompareFacesRequest) => Buffer;
+                requestDeserialize: (bytes: Buffer) => CompareFacesRequest;
+                responseSerialize: (message: CompareFacesResponse) => Buffer;
+                responseDeserialize: (bytes: Buffer) => CompareFacesResponse;
+            };
+        };
+        [method: string]: grpc_1.UntypedHandleCall;
+        abstract CompareFaces(call: grpc_1.ServerUnaryCall<CompareFacesRequest, CompareFacesResponse>, callback: grpc_1.sendUnaryData<CompareFacesResponse>): void;
+    }
+    const ImageRecognitionClient_base: grpc_1.ServiceClientConstructor;
+    export class ImageRecognitionClient extends ImageRecognitionClient_base {
+        constructor(address: string, credentials: grpc_1.ChannelCredentials, options?: Partial<grpc_1.ChannelOptions>);
+        CompareFaces: GrpcPromiseServiceInterface<CompareFacesRequest, CompareFacesResponse>;
+    }
+    export {};
+}

package/types/index.d.ts

@@ -0,0 +1,43 @@
+import { com as account } from './accounts/accounts';
+import { com as admin } from './admin/admin';
+import { com as user } from './users/users';
+import { com as verification } from './verifications/verifications';
+import { com as bills } from './bills/bills';
+import { com as image } from './image/recognition';
+import { com as storage } from './storage/storage';
+import { com as transfer } from './transfer/transfer';
+import { com as business } from './business/business';
+import { com as audit } from './audit/audit';
+import { com as pos_transactions } from './pos/transactions';
+import { com as pov1Transaction } from './pos.v1/transactions';
+import { com as pov1Auth } from './pos.v1/auth';
+import { com as pov1Merchants } from './pos.v1/merchants';
+import { com as pov1Eod } from './pos.v1/eod';
+import { com as pov1TerminalTypes } from './pos.v1/terminal-types';
+import { com as pov1TerminalTransactions } from './pos.v1/terminal-transactions';
+import { com as pov1TerminalCardTransactions } from './pos.v1/card-transactions';
+import { com as pov1Terminals } from './pos.v1/terminals';
+declare const proto: {
+    import: {
+        admin: typeof admin;
+        account: typeof account;
+        audit: typeof audit;
+        user: typeof user;
+        verification: typeof verification;
+        bills: typeof bills;
+        image: typeof image;
+        storage: typeof storage;
+        transfer: typeof transfer;
+        business: typeof business;
+        pos_transactions: typeof pos_transactions;
+        pov1Transaction: typeof pov1Transaction;
+        pov1Auth: typeof pov1Auth;
+        pov1Merchants: typeof pov1Merchants;
+        pov1Eod: typeof pov1Eod;
+        pov1TerminalTypes: typeof pov1TerminalTypes;
+        pov1Terminals: typeof pov1Terminals;
+        pov1TerminalTransactions: typeof pov1TerminalTransactions;
+        pov1TerminalCardTransactions: typeof pov1TerminalCardTransactions;
+    };
+};
+export { proto };