geniebox-shared-lib 2.1.3 → 2.2.1

package/dist/billing.client.d.ts

@@ -0,0 +1,12 @@
+import { OnModuleInit } from "@nestjs/common";
+import { ClientGrpc } from "@nestjs/microservices";
+import { BillingServiceClient } from "./billing.interface";
+export declare class BillingClient implements OnModuleInit {
+    private readonly client;
+    private readonly logger;
+    private billingClient?;
+    constructor(client: ClientGrpc);
+    onModuleInit(): void;
+    get service(): BillingServiceClient;
+    isReady(): boolean;
+}

package/dist/billing.client.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var BillingClient_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingClient = void 0;
+const common_1 = require("@nestjs/common");
+let BillingClient = BillingClient_1 = class BillingClient {
+    constructor(client) {
+        this.client = client;
+        this.logger = new common_1.Logger(BillingClient_1.name);
+    }
+    onModuleInit() {
+        this.billingClient =
+            this.client.getService("BillingService");
+        this.logger.log("BillingServiceClient initialized");
+    }
+    get service() {
+        if (!this.billingClient) {
+            throw new common_1.InternalServerErrorException("BillingService is not initialized yet");
+        }
+        return this.billingClient;
+    }
+    isReady() {
+        return !!this.billingClient;
+    }
+};
+exports.BillingClient = BillingClient;
+exports.BillingClient = BillingClient = BillingClient_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)("BILLING_PACKAGE")),
+    __metadata("design:paramtypes", [Object])
+], BillingClient);

package/dist/billing.interface.d.ts

@@ -0,0 +1,434 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { handleUnaryCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
+import { Observable } from "rxjs";
+export declare const protobufPackage = "billing";
+export interface Balance {
+    userId: string;
+    balance: number;
+    currency: string;
+    updatedAt: string;
+}
+export interface Transaction {
+    id: string;
+    userId: string;
+    /** deposit, charge, refund */
+    type: string;
+    amount: number;
+    currency: string;
+    /** pending, completed, failed */
+    status: string;
+    description: string;
+    /** JSON string */
+    metadata: string;
+    createdAt: string;
+}
+export interface Usage {
+    id: string;
+    keyId: string;
+    requestId: string;
+    userId: string;
+    tokensInput: number;
+    tokensOutput: number;
+    cost: number;
+    endpointId: string;
+    modelId: string;
+    /** pending, completed, failed */
+    status: string;
+    createdAt: string;
+}
+export interface Payment {
+    id: string;
+    userId: string;
+    transactionId: string;
+    /** yookassa */
+    provider: string;
+    providerPaymentId: string;
+    amount: number;
+    currency: string;
+    /** pending, succeeded, failed, cancelled */
+    status: string;
+    /** JSON string */
+    metadata: string;
+    createdAt: string;
+}
+export interface UsageStats {
+    totalTokensInput: number;
+    totalTokensOutput: number;
+    totalCost: number;
+    requestCount: number;
+    records: Usage[];
+}
+export interface GetBalanceRequest {
+    userId: string;
+}
+export interface ChargeRequest {
+    userId: string;
+    amount: number;
+    description: string;
+    /** JSON string, optional */
+    metadata: string;
+}
+export interface DepositRequest {
+    userId: string;
+    amount: number;
+    description: string;
+    /** JSON string, optional */
+    metadata: string;
+}
+export interface GetBalanceResponse {
+    balance?: Balance | undefined;
+}
+export interface ChargeResponse {
+    transaction?: Transaction | undefined;
+    balance?: Balance | undefined;
+}
+export interface DepositResponse {
+    transaction?: Transaction | undefined;
+    balance?: Balance | undefined;
+}
+export interface CreateTransactionRequest {
+    userId: string;
+    /** deposit, charge, refund */
+    type: string;
+    amount: number;
+    description: string;
+    /** JSON string, optional */
+    metadata: string;
+}
+export interface GetTransactionsRequest {
+    userId: string;
+    /** ISO date, optional */
+    startDate: string;
+    /** ISO date, optional */
+    endDate: string;
+    /** optional filter */
+    type: string;
+    /** optional, default 100 */
+    limit: number;
+    /** optional, default 0 */
+    offset: number;
+}
+export interface GetTransactionRequest {
+    id: string;
+}
+export interface CreateTransactionResponse {
+    transaction?: Transaction | undefined;
+}
+export interface GetTransactionsResponse {
+    transactions: Transaction[];
+    total: number;
+}
+export interface GetTransactionResponse {
+    transaction?: Transaction | undefined;
+}
+export interface RecordUsageRequest {
+    keyId: string;
+    requestId: string;
+    userId: string;
+    tokensInput: number;
+    tokensOutput: number;
+    cost: number;
+    endpointId: string;
+    modelId: string;
+    /** pending, completed, failed */
+    status: string;
+}
+export interface GetUsageStatsRequest {
+    keyId: string;
+    /** ISO date, optional */
+    startDate: string;
+    /** ISO date, optional */
+    endDate: string;
+}
+export interface GetUsageByKeyRequest {
+    keyId: string;
+    /** optional, default 100 */
+    limit: number;
+    /** optional, default 0 */
+    offset: number;
+}
+export interface GetUsageByUserRequest {
+    userId: string;
+    /** optional, default 100 */
+    limit: number;
+    /** optional, default 0 */
+    offset: number;
+}
+export interface RecordUsageResponse {
+    usage?: Usage | undefined;
+}
+export interface GetUsageStatsResponse {
+    stats?: UsageStats | undefined;
+}
+export interface GetUsageByKeyResponse {
+    usages: Usage[];
+    total: number;
+}
+export interface GetUsageByUserResponse {
+    usages: Usage[];
+    total: number;
+}
+export interface CreatePaymentRequest {
+    userId: string;
+    amount: number;
+    /** default USD */
+    currency: string;
+    description: string;
+    /** URL for redirect after payment */
+    returnUrl: string;
+    /** JSON string, optional */
+    metadata: string;
+}
+export interface GetPaymentRequest {
+    id: string;
+}
+export interface GetPaymentsByUserRequest {
+    userId: string;
+    /** optional, default 100 */
+    limit: number;
+    /** optional, default 0 */
+    offset: number;
+}
+export interface ProcessWebhookRequest {
+    /** webhook event type */
+    event: string;
+    /** JSON string with webhook data */
+    data: string;
+}
+export interface CreatePaymentResponse {
+    payment?: Payment | undefined;
+    /** URL for user to complete payment */
+    paymentUrl: string;
+}
+export interface GetPaymentResponse {
+    payment?: Payment | undefined;
+}
+export interface GetPaymentsByUserResponse {
+    payments: Payment[];
+    total: number;
+}
+export interface ProcessWebhookResponse {
+    success: boolean;
+    message: string;
+}
+export declare const BILLING_PACKAGE_NAME = "billing";
+export declare const Balance: MessageFns<Balance>;
+export declare const Transaction: MessageFns<Transaction>;
+export declare const Usage: MessageFns<Usage>;
+export declare const Payment: MessageFns<Payment>;
+export declare const UsageStats: MessageFns<UsageStats>;
+export declare const GetBalanceRequest: MessageFns<GetBalanceRequest>;
+export declare const ChargeRequest: MessageFns<ChargeRequest>;
+export declare const DepositRequest: MessageFns<DepositRequest>;
+export declare const GetBalanceResponse: MessageFns<GetBalanceResponse>;
+export declare const ChargeResponse: MessageFns<ChargeResponse>;
+export declare const DepositResponse: MessageFns<DepositResponse>;
+export declare const CreateTransactionRequest: MessageFns<CreateTransactionRequest>;
+export declare const GetTransactionsRequest: MessageFns<GetTransactionsRequest>;
+export declare const GetTransactionRequest: MessageFns<GetTransactionRequest>;
+export declare const CreateTransactionResponse: MessageFns<CreateTransactionResponse>;
+export declare const GetTransactionsResponse: MessageFns<GetTransactionsResponse>;
+export declare const GetTransactionResponse: MessageFns<GetTransactionResponse>;
+export declare const RecordUsageRequest: MessageFns<RecordUsageRequest>;
+export declare const GetUsageStatsRequest: MessageFns<GetUsageStatsRequest>;
+export declare const GetUsageByKeyRequest: MessageFns<GetUsageByKeyRequest>;
+export declare const GetUsageByUserRequest: MessageFns<GetUsageByUserRequest>;
+export declare const RecordUsageResponse: MessageFns<RecordUsageResponse>;
+export declare const GetUsageStatsResponse: MessageFns<GetUsageStatsResponse>;
+export declare const GetUsageByKeyResponse: MessageFns<GetUsageByKeyResponse>;
+export declare const GetUsageByUserResponse: MessageFns<GetUsageByUserResponse>;
+export declare const CreatePaymentRequest: MessageFns<CreatePaymentRequest>;
+export declare const GetPaymentRequest: MessageFns<GetPaymentRequest>;
+export declare const GetPaymentsByUserRequest: MessageFns<GetPaymentsByUserRequest>;
+export declare const ProcessWebhookRequest: MessageFns<ProcessWebhookRequest>;
+export declare const CreatePaymentResponse: MessageFns<CreatePaymentResponse>;
+export declare const GetPaymentResponse: MessageFns<GetPaymentResponse>;
+export declare const GetPaymentsByUserResponse: MessageFns<GetPaymentsByUserResponse>;
+export declare const ProcessWebhookResponse: MessageFns<ProcessWebhookResponse>;
+export interface BillingServiceClient {
+    /** Balance operations */
+    getBalance(request: GetBalanceRequest, metadata?: Metadata): Observable<GetBalanceResponse>;
+    charge(request: ChargeRequest, metadata?: Metadata): Observable<ChargeResponse>;
+    deposit(request: DepositRequest, metadata?: Metadata): Observable<DepositResponse>;
+    /** Transaction operations */
+    createTransaction(request: CreateTransactionRequest, metadata?: Metadata): Observable<CreateTransactionResponse>;
+    getTransactions(request: GetTransactionsRequest, metadata?: Metadata): Observable<GetTransactionsResponse>;
+    getTransaction(request: GetTransactionRequest, metadata?: Metadata): Observable<GetTransactionResponse>;
+    /** Usage operations */
+    recordUsage(request: RecordUsageRequest, metadata?: Metadata): Observable<RecordUsageResponse>;
+    getUsageStats(request: GetUsageStatsRequest, metadata?: Metadata): Observable<GetUsageStatsResponse>;
+    getUsageByKey(request: GetUsageByKeyRequest, metadata?: Metadata): Observable<GetUsageByKeyResponse>;
+    getUsageByUser(request: GetUsageByUserRequest, metadata?: Metadata): Observable<GetUsageByUserResponse>;
+    /** Payment operations */
+    createPayment(request: CreatePaymentRequest, metadata?: Metadata): Observable<CreatePaymentResponse>;
+    getPayment(request: GetPaymentRequest, metadata?: Metadata): Observable<GetPaymentResponse>;
+    getPaymentsByUser(request: GetPaymentsByUserRequest, metadata?: Metadata): Observable<GetPaymentsByUserResponse>;
+}
+export interface BillingServiceController {
+    /** Balance operations */
+    getBalance(request: GetBalanceRequest, metadata?: Metadata): Promise<GetBalanceResponse> | Observable<GetBalanceResponse> | GetBalanceResponse;
+    charge(request: ChargeRequest, metadata?: Metadata): Promise<ChargeResponse> | Observable<ChargeResponse> | ChargeResponse;
+    deposit(request: DepositRequest, metadata?: Metadata): Promise<DepositResponse> | Observable<DepositResponse> | DepositResponse;
+    /** Transaction operations */
+    createTransaction(request: CreateTransactionRequest, metadata?: Metadata): Promise<CreateTransactionResponse> | Observable<CreateTransactionResponse> | CreateTransactionResponse;
+    getTransactions(request: GetTransactionsRequest, metadata?: Metadata): Promise<GetTransactionsResponse> | Observable<GetTransactionsResponse> | GetTransactionsResponse;
+    getTransaction(request: GetTransactionRequest, metadata?: Metadata): Promise<GetTransactionResponse> | Observable<GetTransactionResponse> | GetTransactionResponse;
+    /** Usage operations */
+    recordUsage(request: RecordUsageRequest, metadata?: Metadata): Promise<RecordUsageResponse> | Observable<RecordUsageResponse> | RecordUsageResponse;
+    getUsageStats(request: GetUsageStatsRequest, metadata?: Metadata): Promise<GetUsageStatsResponse> | Observable<GetUsageStatsResponse> | GetUsageStatsResponse;
+    getUsageByKey(request: GetUsageByKeyRequest, metadata?: Metadata): Promise<GetUsageByKeyResponse> | Observable<GetUsageByKeyResponse> | GetUsageByKeyResponse;
+    getUsageByUser(request: GetUsageByUserRequest, metadata?: Metadata): Promise<GetUsageByUserResponse> | Observable<GetUsageByUserResponse> | GetUsageByUserResponse;
+    /** Payment operations */
+    createPayment(request: CreatePaymentRequest, metadata?: Metadata): Promise<CreatePaymentResponse> | Observable<CreatePaymentResponse> | CreatePaymentResponse;
+    getPayment(request: GetPaymentRequest, metadata?: Metadata): Promise<GetPaymentResponse> | Observable<GetPaymentResponse> | GetPaymentResponse;
+    getPaymentsByUser(request: GetPaymentsByUserRequest, metadata?: Metadata): Promise<GetPaymentsByUserResponse> | Observable<GetPaymentsByUserResponse> | GetPaymentsByUserResponse;
+}
+export declare function BillingServiceControllerMethods(): (constructor: Function) => void;
+export declare const BILLING_SERVICE_NAME = "BillingService";
+export type BillingServiceService = typeof BillingServiceService;
+export declare const BillingServiceService: {
+    /** Balance operations */
+    readonly getBalance: {
+        readonly path: "/billing.BillingService/GetBalance";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetBalanceRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetBalanceRequest;
+        readonly responseSerialize: (value: GetBalanceResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetBalanceResponse;
+    };
+    readonly charge: {
+        readonly path: "/billing.BillingService/Charge";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ChargeRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ChargeRequest;
+        readonly responseSerialize: (value: ChargeResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ChargeResponse;
+    };
+    readonly deposit: {
+        readonly path: "/billing.BillingService/Deposit";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DepositRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DepositRequest;
+        readonly responseSerialize: (value: DepositResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => DepositResponse;
+    };
+    /** Transaction operations */
+    readonly createTransaction: {
+        readonly path: "/billing.BillingService/CreateTransaction";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreateTransactionRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CreateTransactionRequest;
+        readonly responseSerialize: (value: CreateTransactionResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => CreateTransactionResponse;
+    };
+    readonly getTransactions: {
+        readonly path: "/billing.BillingService/GetTransactions";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetTransactionsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetTransactionsRequest;
+        readonly responseSerialize: (value: GetTransactionsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetTransactionsResponse;
+    };
+    readonly getTransaction: {
+        readonly path: "/billing.BillingService/GetTransaction";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetTransactionRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetTransactionRequest;
+        readonly responseSerialize: (value: GetTransactionResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetTransactionResponse;
+    };
+    /** Usage operations */
+    readonly recordUsage: {
+        readonly path: "/billing.BillingService/RecordUsage";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: RecordUsageRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => RecordUsageRequest;
+        readonly responseSerialize: (value: RecordUsageResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => RecordUsageResponse;
+    };
+    readonly getUsageStats: {
+        readonly path: "/billing.BillingService/GetUsageStats";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetUsageStatsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetUsageStatsRequest;
+        readonly responseSerialize: (value: GetUsageStatsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetUsageStatsResponse;
+    };
+    readonly getUsageByKey: {
+        readonly path: "/billing.BillingService/GetUsageByKey";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetUsageByKeyRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetUsageByKeyRequest;
+        readonly responseSerialize: (value: GetUsageByKeyResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetUsageByKeyResponse;
+    };
+    readonly getUsageByUser: {
+        readonly path: "/billing.BillingService/GetUsageByUser";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetUsageByUserRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetUsageByUserRequest;
+        readonly responseSerialize: (value: GetUsageByUserResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetUsageByUserResponse;
+    };
+    /** Payment operations */
+    readonly createPayment: {
+        readonly path: "/billing.BillingService/CreatePayment";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreatePaymentRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CreatePaymentRequest;
+        readonly responseSerialize: (value: CreatePaymentResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => CreatePaymentResponse;
+    };
+    readonly getPayment: {
+        readonly path: "/billing.BillingService/GetPayment";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetPaymentRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetPaymentRequest;
+        readonly responseSerialize: (value: GetPaymentResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetPaymentResponse;
+    };
+    readonly getPaymentsByUser: {
+        readonly path: "/billing.BillingService/GetPaymentsByUser";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetPaymentsByUserRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetPaymentsByUserRequest;
+        readonly responseSerialize: (value: GetPaymentsByUserResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetPaymentsByUserResponse;
+    };
+};
+export interface BillingServiceServer extends UntypedServiceImplementation {
+    /** Balance operations */
+    getBalance: handleUnaryCall<GetBalanceRequest, GetBalanceResponse>;
+    charge: handleUnaryCall<ChargeRequest, ChargeResponse>;
+    deposit: handleUnaryCall<DepositRequest, DepositResponse>;
+    /** Transaction operations */
+    createTransaction: handleUnaryCall<CreateTransactionRequest, CreateTransactionResponse>;
+    getTransactions: handleUnaryCall<GetTransactionsRequest, GetTransactionsResponse>;
+    getTransaction: handleUnaryCall<GetTransactionRequest, GetTransactionResponse>;
+    /** Usage operations */
+    recordUsage: handleUnaryCall<RecordUsageRequest, RecordUsageResponse>;
+    getUsageStats: handleUnaryCall<GetUsageStatsRequest, GetUsageStatsResponse>;
+    getUsageByKey: handleUnaryCall<GetUsageByKeyRequest, GetUsageByKeyResponse>;
+    getUsageByUser: handleUnaryCall<GetUsageByUserRequest, GetUsageByUserResponse>;
+    /** Payment operations */
+    createPayment: handleUnaryCall<CreatePaymentRequest, CreatePaymentResponse>;
+    getPayment: handleUnaryCall<GetPaymentRequest, GetPaymentResponse>;
+    getPaymentsByUser: handleUnaryCall<GetPaymentsByUserRequest, GetPaymentsByUserResponse>;
+}
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}