@technova-tech/olive-proto-lib 1.6.3

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,41 @@
+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 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;
+        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 };