@jogolabs/billing-sdk-v2 0.0.1

package/src/billing/src/__generated__/schemas/$UpdateMerchantRequest.ts

@@ -0,0 +1,35 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $UpdateMerchantRequest = {
+    properties: {
+        name: {
+            type: 'string',
+        },
+        email: {
+            type: 'string',
+            format: 'email',
+        },
+        apiKey: {
+            type: 'string',
+        },
+        environment: {
+            type: 'Enum',
+        },
+        webhookUrl: {
+            type: 'string',
+            format: 'uri',
+        },
+        redirectUrl: {
+            type: 'string',
+            format: 'uri',
+        },
+        cardGroupId: {
+            type: 'string',
+        },
+        active: {
+            type: 'boolean',
+        },
+    },
+} as const;

package/src/billing/src/__generated__/schemas/$UpdatePackageRequest.ts

@@ -0,0 +1,31 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $UpdatePackageRequest = {
+    properties: {
+        name: {
+            type: 'string',
+        },
+        description: {
+            type: 'string',
+        },
+        numberOfClasses: {
+            type: 'number',
+            minimum: 1,
+        },
+        durationDays: {
+            type: 'number',
+            minimum: 1,
+        },
+        price: {
+            type: 'number',
+        },
+        autoRenewDefault: {
+            type: 'boolean',
+        },
+        active: {
+            type: 'boolean',
+        },
+    },
+} as const;

package/src/billing/src/__generated__/services/CardsService.ts

@@ -0,0 +1,115 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { SavedCard } from '../models/SavedCard';
+import type { TokenizeCardRequest } from '../models/TokenizeCardRequest';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export class CardsService {
+    constructor(public readonly httpRequest: BaseHttpRequest) {}
+    /**
+     * Tokenizar y guardar una tarjeta
+     * Envía los datos de la tarjeta al proveedor de pago configurado para el negocio, obtiene un token seguro y lo guarda asociado al cliente autenticado. Los datos de la tarjeta **nunca se almacenan** en la base de datos de este servicio.
+     *
+     * @returns SavedCard Tarjeta tokenizada y guardada exitosamente
+     * @throws ApiError
+     */
+    public postApiV1CardsTokenize({
+        requestBody,
+    }: {
+        requestBody: TokenizeCardRequest,
+    }): CancelablePromise<SavedCard> {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/cards/tokenize',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Datos de tarjeta inválidos`,
+                401: `Token JWT ausente o inválido`,
+            },
+        });
+    }
+    /**
+     * Listar tarjetas guardadas del cliente
+     * Retorna las tarjetas tokenizadas del cliente autenticado para un negocio específico.
+     * @returns SavedCard Lista de tarjetas guardadas
+     * @throws ApiError
+     */
+    public getApiV1Cards({
+        merchantId,
+    }: {
+        /**
+         * ID del merchant para filtrar las tarjetas
+         */
+        merchantId: string,
+    }): CancelablePromise<Array<SavedCard>> {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/cards',
+            query: {
+                'merchantId': merchantId,
+            },
+            errors: {
+                400: `merchantId requerido`,
+                401: `Token JWT ausente o inválido`,
+            },
+        });
+    }
+    /**
+     * Establecer tarjeta predeterminada
+     * Marca una tarjeta como predeterminada para renovaciones automáticas. Solo puede haber una tarjeta predeterminada por cliente + negocio.
+     *
+     * @returns any Tarjeta predeterminada actualizada
+     * @throws ApiError
+     */
+    public patchApiV1CardsDefault({
+        id,
+        requestBody,
+    }: {
+        id: string,
+        requestBody: {
+            merchantId: string;
+        },
+    }): CancelablePromise<{
+        message?: string;
+    }> {
+        return this.httpRequest.request({
+            method: 'PATCH',
+            url: '/api/v1/cards/{id}/default',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Token JWT ausente o inválido`,
+                404: `Tarjeta no encontrada`,
+            },
+        });
+    }
+    /**
+     * Eliminar tarjeta guardada
+     * Desactiva la tarjeta guardada (no se elimina físicamente de la base de datos).
+     * @returns void
+     * @throws ApiError
+     */
+    public deleteApiV1Cards({
+        id,
+    }: {
+        id: string,
+    }): CancelablePromise<void> {
+        return this.httpRequest.request({
+            method: 'DELETE',
+            url: '/api/v1/cards/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Token JWT ausente o inválido`,
+                403: `La tarjeta no pertenece al cliente`,
+            },
+        });
+    }
+}

package/src/billing/src/__generated__/services/HealthService.ts

@@ -0,0 +1,24 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export class HealthService {
+    constructor(public readonly httpRequest: BaseHttpRequest) {}
+    /**
+     * Health check
+     * Verifica que el servicio está funcionando correctamente.
+     * @returns any Servicio en línea
+     * @throws ApiError
+     */
+    public getHealth(): CancelablePromise<{
+        status?: string;
+        service?: string;
+    }> {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/health',
+        });
+    }
+}

package/src/billing/src/__generated__/services/MerchantsService.ts

@@ -0,0 +1,90 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CreateMerchantRequest } from '../models/CreateMerchantRequest';
+import type { Merchant } from '../models/Merchant';
+import type { UpdateMerchantRequest } from '../models/UpdateMerchantRequest';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export class MerchantsService {
+    constructor(public readonly httpRequest: BaseHttpRequest) {}
+    /**
+     * Registrar negocio con proveedor de pago
+     * Registra un negocio y su configuración de proveedor de pago (Wompi). La API Key se encripta con AES-256 antes de guardarse en la base de datos.
+     *
+     * @returns Merchant Negocio registrado exitosamente
+     * @throws ApiError
+     */
+    public postApiV1Merchants({
+        requestBody,
+    }: {
+        requestBody: CreateMerchantRequest,
+    }): CancelablePromise<Merchant> {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/merchants',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `No autorizado`,
+                409: `El negocio ya está registrado`,
+            },
+        });
+    }
+    /**
+     * Obtener negocio por businessId
+     * Retorna la configuración del negocio sin incluir la API Key del proveedor de pago.
+     *
+     * @returns Merchant Configuración del negocio (sin API Key)
+     * @throws ApiError
+     */
+    public getApiV1MerchantsBusiness({
+        businessId,
+    }: {
+        /**
+         * ID del negocio en jogo-backend
+         */
+        businessId: string,
+    }): CancelablePromise<Merchant> {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/merchants/business/{businessId}',
+            path: {
+                'businessId': businessId,
+            },
+            errors: {
+                401: `Token JWT ausente o inválido`,
+                404: `Negocio no encontrado`,
+            },
+        });
+    }
+    /**
+     * Actualizar configuración del negocio
+     * Actualiza los datos del negocio. Si se envía `apiKey`, se re-encripta antes de guardarse.
+     *
+     * @returns Merchant Negocio actualizado
+     * @throws ApiError
+     */
+    public putApiV1MerchantsBusiness({
+        businessId,
+        requestBody,
+    }: {
+        businessId: string,
+        requestBody: UpdateMerchantRequest,
+    }): CancelablePromise<Merchant> {
+        return this.httpRequest.request({
+            method: 'PUT',
+            url: '/api/v1/merchants/business/{businessId}',
+            path: {
+                'businessId': businessId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Token JWT ausente o inválido`,
+                404: `Negocio no encontrado`,
+            },
+        });
+    }
+}

package/src/billing/src/__generated__/services/PackagesService.ts

@@ -0,0 +1,150 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CreatePackageRequest } from '../models/CreatePackageRequest';
+import type { Package } from '../models/Package';
+import type { UpdatePackageRequest } from '../models/UpdatePackageRequest';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export class PackagesService {
+    constructor(public readonly httpRequest: BaseHttpRequest) {}
+    /**
+     * Crear paquete de clases
+     * Crea un nuevo paquete de clases para el negocio especificado.
+     * @returns Package Paquete creado
+     * @throws ApiError
+     */
+    public postApiV1MerchantsPackages({
+        merchantId,
+        requestBody,
+    }: {
+        /**
+         * ID del merchant en este servicio
+         */
+        merchantId: string,
+        requestBody: CreatePackageRequest,
+    }): CancelablePromise<Package> {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/merchants/{merchantId}/packages',
+            path: {
+                'merchantId': merchantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Token JWT ausente o inválido`,
+            },
+        });
+    }
+    /**
+     * Listar paquetes del negocio
+     * Retorna los paquetes de clases disponibles para un negocio. Por defecto solo retorna los activos. Usa `?all=true` para incluir inactivos.
+     *
+     * @returns Package Lista de paquetes
+     * @throws ApiError
+     */
+    public getApiV1MerchantsPackages({
+        merchantId,
+        all,
+    }: {
+        merchantId: string,
+        /**
+         * Si es `true`, incluye paquetes inactivos
+         */
+        all?: 'true' | 'false',
+    }): CancelablePromise<Array<Package>> {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/merchants/{merchantId}/packages',
+            path: {
+                'merchantId': merchantId,
+            },
+            query: {
+                'all': all,
+            },
+        });
+    }
+    /**
+     * Obtener paquete por ID
+     * @returns Package Detalle del paquete
+     * @throws ApiError
+     */
+    public getApiV1MerchantsPackages1({
+        merchantId,
+        id,
+    }: {
+        merchantId: string,
+        id: string,
+    }): CancelablePromise<Package> {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/merchants/{merchantId}/packages/{id}',
+            path: {
+                'merchantId': merchantId,
+                'id': id,
+            },
+            errors: {
+                404: `Paquete no encontrado`,
+            },
+        });
+    }
+    /**
+     * Actualizar paquete
+     * @returns Package Paquete actualizado
+     * @throws ApiError
+     */
+    public putApiV1MerchantsPackages({
+        merchantId,
+        id,
+        requestBody,
+    }: {
+        merchantId: string,
+        id: string,
+        requestBody: UpdatePackageRequest,
+    }): CancelablePromise<Package> {
+        return this.httpRequest.request({
+            method: 'PUT',
+            url: '/api/v1/merchants/{merchantId}/packages/{id}',
+            path: {
+                'merchantId': merchantId,
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                401: `Token JWT ausente o inválido`,
+                403: `El paquete no pertenece a este negocio`,
+                404: `Paquete no encontrado`,
+            },
+        });
+    }
+    /**
+     * Desactivar paquete
+     * Desactiva el paquete (no lo elimina físicamente). Las suscripciones existentes no se ven afectadas.
+     *
+     * @returns Package Paquete desactivado
+     * @throws ApiError
+     */
+    public deleteApiV1MerchantsPackages({
+        merchantId,
+        id,
+    }: {
+        merchantId: string,
+        id: string,
+    }): CancelablePromise<Package> {
+        return this.httpRequest.request({
+            method: 'DELETE',
+            url: '/api/v1/merchants/{merchantId}/packages/{id}',
+            path: {
+                'merchantId': merchantId,
+                'id': id,
+            },
+            errors: {
+                401: `Token JWT ausente o inválido`,
+                403: `Forbidden`,
+            },
+        });
+    }
+}

package/src/billing/src/__generated__/services/PaymentsService.ts

@@ -0,0 +1,96 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Payment } from '../models/Payment';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export class PaymentsService {
+    constructor(public readonly httpRequest: BaseHttpRequest) {}
+    /**
+     * Webhook de notificación de Wompi
+     * Endpoint que Wompi llama para notificar el resultado de una transacción. **No requiere autenticación** — es invocado directamente por Wompi.
+     * Al recibir un pago completado (`APROBADA`), activa automáticamente la suscripción asociada.
+     * Configurar esta URL en el `webhookUrl` del merchant: `POST https://tu-servidor.com/api/v1/webhooks/{merchantId}`
+     *
+     * @returns any Webhook recibido y procesado
+     * @throws ApiError
+     */
+    public postApiV1Webhooks({
+        merchantId,
+        requestBody,
+    }: {
+        /**
+         * ID del merchant en este servicio (no el businessId de jogo-backend)
+         */
+        merchantId: string,
+        requestBody: {
+            /**
+             * ID de la transacción en Wompi
+             */
+            idTransaccion?: string;
+            monto?: number;
+            estado?: 'APROBADA' | 'RECHAZADA' | 'PENDIENTE' | 'ERROR';
+            /**
+             * Metadata enviada al crear la transacción
+             */
+            datosAdicionales?: Record<string, any>;
+        },
+    }): CancelablePromise<{
+        received?: boolean;
+    }> {
+        return this.httpRequest.request({
+            method: 'POST',
+            url: '/api/v1/webhooks/{merchantId}',
+            path: {
+                'merchantId': merchantId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Detalle de un pago
+     * @returns Payment Detalle del pago incluyendo respuesta del proveedor
+     * @throws ApiError
+     */
+    public getApiV1Payments({
+        id,
+    }: {
+        id: string,
+    }): CancelablePromise<Payment> {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/payments/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                401: `Token JWT ausente o inválido`,
+                404: `Pago no encontrado`,
+            },
+        });
+    }
+    /**
+     * Historial de pagos de una suscripción
+     * Retorna todos los pagos realizados para una suscripción específica, ordenados por fecha descendente.
+     * @returns Payment Historial de pagos
+     * @throws ApiError
+     */
+    public getApiV1PaymentsSubscription({
+        subscriptionId,
+    }: {
+        subscriptionId: string,
+    }): CancelablePromise<Array<Payment>> {
+        return this.httpRequest.request({
+            method: 'GET',
+            url: '/api/v1/payments/subscription/{subscriptionId}',
+            path: {
+                'subscriptionId': subscriptionId,
+            },
+            errors: {
+                401: `Token JWT ausente o inválido`,
+            },
+        });
+    }
+}