@authenty/authapi-types 1.0.12 → 1.0.13

package/dist/index.d.ts

@@ -1,4 +1,623 @@
-export * from './admin';
-export * from './cronjobs';
-export * from './general';
-export * from './payment-system';
+/**
+ * Namespace principal da API de autenticação
+ * Acesso aos tipos: AuthApi.objects.User, AuthApi.responses.auth.login.post, etc.
+ */
+export declare namespace AuthApi {
+    /**
+     * Objetos de domínio da aplicação
+     */
+    namespace objects {
+        enum BundleType {
+            BUNDLE = 0,
+            SYMBOLIC_PRODUCT = 1,
+            SYMBOLIC_COURSE = 2,
+            SYMBOLIC_CONSULTANCY = 3
+        }
+        type Product = {
+            id: number;
+            title: string;
+            short: string;
+            resume: string;
+            video: string;
+            imgUrls: string | null;
+            logo: string;
+            themeImage: string;
+            themeColor: string;
+            themeVideo: string;
+            url: string;
+            type: number;
+            period_test: number;
+            created: string;
+            deletedAt?: string | null;
+            Levels?: ProductLevel[];
+        };
+        type ProductLevel = {
+            id: number;
+            productID: number;
+            level: number;
+            short: string;
+            Product?: Product;
+            store_bundles_levels?: {
+                id: number;
+                bundleID: number;
+                levelID: number;
+                quantity: number;
+                Bundle?: Bundle;
+            }[];
+        };
+        type Course = {
+            id: number;
+            type: number;
+            name: string;
+            short: string;
+            resume: string;
+            img_landscape: string;
+            img_square: string;
+            workload: number;
+            langID: number;
+            num_classes?: number;
+            seats: number;
+            url?: string;
+            dates: string;
+            local: string;
+            local_url: string;
+            date_mat_s?: string;
+            date_mat_e?: string;
+            date_ends?: string;
+            email_enrollment?: string;
+            email_before?: string;
+            email_after?: string;
+            date_c: string;
+            date_r?: string | null;
+        };
+        type Consultancy = {
+            id: number;
+            teacherID: number;
+            type: number;
+            name: string;
+            short: string;
+            resume: string;
+            img_landscape: string;
+            img_square: string;
+            workload: number;
+            langID: number;
+            url?: string;
+            datetime: string;
+            date_mat_s?: string;
+            date_mat_e?: string;
+            date_ends?: string;
+            email_enrollment: string;
+            email_before: string;
+            email_after: string;
+            date_c: string;
+            date_r?: string | null;
+        };
+        type Bundle = {
+            id: number;
+            type: BundleType;
+            title?: string;
+            short?: string;
+            resume?: string;
+            img: string;
+            themeImage: string;
+            themeColor: string;
+            shareLimit: number;
+            created: string;
+            active: boolean;
+            showInSite: boolean;
+            defaultMetaArray: string;
+            deletedAt?: string | null;
+            Levels?: {
+                id: number;
+                bundleID: number;
+                levelID: number;
+                quantity: number;
+                Level: ProductLevel;
+            }[];
+            Courses?: {
+                id: number;
+                bundleID: number;
+                courseID: number;
+                quantity: number;
+                Course: Course;
+            }[];
+            Consultancies?: {
+                id: number;
+                bundleID: number;
+                consultancyID: number;
+                quantity: number;
+                Consultancy: Consultancy;
+            }[];
+            store_bundles_paymethod: PaymentMethod[];
+        };
+        type PaymentMethod = {
+            id: number;
+            bundleID: number;
+            price: number;
+            fromprice: number;
+            period_renew: number;
+            period_grace: number;
+            gatewayHash: string;
+            allowBoleto: boolean;
+            gatewayID: number;
+            Bundle?: Bundle;
+        };
+        type Purchase = {
+            paghash: string;
+            id: number;
+            price: number;
+            licenseStatus: PaymentSystem.PG_PurchaseLicenseStatus;
+            paymentStatus: PaymentSystem.PG_PurchasePaymentStatus;
+            type_step: PaymentSystem.PG_PurchaseType;
+            PaymentMethod: PaymentMethod;
+            Wallet?: Wallet;
+            walletID: number;
+            createdAt: string;
+            paymentDueAt: string | null;
+            owner: string;
+            invoiceUrl?: string;
+            nfUrl?: string;
+            isAdmin?: boolean;
+            meta_data?: Record<string, any>;
+            PurchaseShares?: PurchaseShare[];
+            Levels?: {
+                Level: ProductLevel;
+                quant: number;
+            }[];
+        };
+        type Wallet = {
+            id: number;
+            userID: number;
+            balance?: number;
+            Purchases?: Purchase[];
+        };
+        type PurchaseShare = {
+            id: number;
+            purchaseID: number;
+            userID: number;
+            Purchase: Purchase;
+        };
+        type LocalUser = {
+            id: number;
+            fullname: string;
+            email: string;
+            lang: number;
+            avatar: string;
+            end_city?: number;
+            end_comp?: string;
+            end_country: number;
+            end_district?: string;
+            end_n?: string;
+            end_state?: number;
+            end_street?: string;
+            end_zip?: string;
+            email_verif: boolean;
+            fiscal_verif: boolean;
+            terms: boolean;
+            cpf?: string;
+            newslatter?: boolean;
+            allow_purchase?: boolean;
+            allow_license?: boolean;
+            date_c?: Date | string;
+            date_r?: Date | string | null;
+            Wallets?: Wallet[];
+            PurchasesShares?: PurchaseShare[];
+            Sys_admUser_config?: AdminUserConfig;
+            Sys_adminUser?: auxiliarTypes.PrivilegeTable;
+        };
+        type AdminUserConfig = {
+            campaigns_blacklist: string;
+            deletedAt: Date | null;
+            userID: number;
+        };
+        type LogEntry = {
+            appId: string;
+            logCode: number;
+            content: string;
+            timestamp?: string;
+            metadata?: {
+                requestId: string;
+                endpoint: string;
+                method: string;
+                userId?: number;
+                ip?: string;
+                browser?: string;
+                system?: string;
+                referer?: string;
+            };
+        };
+        namespace PaymentSystem {
+            type PG_Customer = {
+                id: string;
+                email: string;
+                name: string;
+            };
+            enum PG_PurchaseLicenseStatus {
+                UNKNOWN = 0,//Nunca será atualizado automaticamente!!
+                OPEN = 3,//ABERTA - Aguardando pagamento
+                EXPIRED = 1,//VENCEU - Era PAGAMENTO, e acabou prazo pra uso acabou
+                PAID = 5,//PAGA - Pagamento realizado com sucesso - é pagamento único
+                ACTIVE = 6,//ATIVO - Assinatura ativa e em dia
+                RECYCLING = 4,//RETENTANDO - Tentativa de renovação automática falhou, mas ainda está no prazo para pagar manualmente
+                CANCELED = 2
+            }
+            const PG_PurchaseLicenseStatus_GroupActive: PG_PurchaseLicenseStatus[];
+            enum PG_PurchasePaymentStatus {
+                UNKNOWN = 0,//pendent or unknown
+                ACTIVE = 1,
+                CANCELED = 2,
+                REFUNDED = 3,
+                REMOVED = 4,// REMOVIDO DO GATEWAY - Não há mais registro do pagamento no gateway
+                PENDING = 5
+            }
+            enum PG_PurchaseType {
+                SESSION = 0,//o registro se trata de uma sessão de compra (ex: intenção de compra preparada para redirecionar o usuário ao gateway. Ainda não é um pagamento nem uma assinatura ativa)
+                STANDARD = 1,//Pagamento único
+                RECURRENT = 2
+            }
+            type PG_Purchase = {
+                id: string;
+                amount: number;
+                recurrent: boolean;
+                type: PG_PurchaseType;
+                paymentStatus: PG_PurchasePaymentStatus;
+                url: string | null;
+                dueTime: Date | null;
+            };
+            enum PG_RecurrenceType {
+                NONE = 0,
+                DAILY = 1,
+                WEEKLY = 2,
+                MONTHLY = 3,
+                YEARLY = 4
+            }
+        }
+    }
+    namespace auxiliarTypes {
+        type availableSoftware = {
+            Level: objects.ProductLevel;
+            quantity: number;
+            purchaseId: number | null;
+            type: 'free' | 'own' | 'shared';
+        };
+        enum Privilege {
+            NONE = 0,
+            READ = 1,
+            WRITE = 2
+        }
+        type PrivilegeTable = {
+            users: Privilege;
+            products: Privilege;
+            courses: Privilege;
+            consultancies: Privilege;
+            bundles: Privilege;
+            logs: Privilege;
+            support: Privilege;
+            leads: Privilege;
+            paymentSystem: Privilege;
+            adminMaster: Privilege;
+            activityTrakking: Privilege;
+            financial: Privilege;
+        };
+        type CronJob = {
+            startAt: Date | null;
+            latestRunErrorCount: number;
+            latestCompletedAt: Date | null;
+        };
+        type CronjobsStatuses = {
+            purchasesStatusUpdate: CronJob;
+        };
+        type LogFilters = {
+            page: number;
+            itemsPerPage: number;
+            search: string;
+            logCode?: number;
+            appId?: string;
+            userId?: number;
+            method?: string;
+            startDate?: string;
+            endDate?: string;
+        };
+        type PaginationInfo = {
+            total: number;
+            page: number;
+            itemsPerPage: number;
+            totalPages: number;
+        };
+    }
+    /**
+     * Tipos de resposta padrão da API
+     */
+    namespace responses {
+        type ApiResponse<T = any> = {
+            conex: boolean;
+            reqStat: number;
+            success: boolean;
+            data: T;
+            msg: string;
+        };
+        namespace auth {
+            namespace login {
+                type POST = ApiResponse<{
+                    user: objects.LocalUser;
+                    msg?: string;
+                }>;
+            }
+            namespace logout {
+                type GET = ApiResponse<{}>;
+            }
+            namespace checkSession {
+                type GET = ApiResponse<{
+                    user?: objects.LocalUser;
+                    msg?: string;
+                }>;
+            }
+        }
+        namespace users {
+            type GET = ApiResponse<objects.LocalUser[]>;
+        }
+        namespace user {
+            type GET = ApiResponse<objects.LocalUser & {
+                Wallets?: objects.Wallet[];
+                PurchasesShares?: objects.PurchaseShare[];
+            }>;
+            type PUT = ApiResponse<objects.LocalUser>;
+            namespace updateConfig {
+                type PUT = ApiResponse<{
+                    msg?: string;
+                }>;
+            }
+            namespace updateAdmin {
+                type PUT = ApiResponse<objects.LocalUser>;
+            }
+            namespace license {
+                type PUT = ApiResponse<{
+                    availableLicenses: number;
+                    heldLicenses: number;
+                    usedLicenses: number;
+                    msg?: string;
+                }>;
+            }
+        }
+        namespace purchase {
+            namespace create {
+                type POST = ApiResponse<{
+                    msg?: string;
+                    purchase: objects.Purchase;
+                    url?: string;
+                }>;
+            }
+            namespace id {
+                namespace sync {
+                    type POST = ApiResponse<objects.Purchase & {
+                        msg?: string;
+                    }>;
+                }
+            }
+            type PUT = ApiResponse<objects.Purchase | {
+                msg?: string;
+            }>;
+            namespace cancel {
+                type PUT = ApiResponse<objects.Purchase>;
+            }
+            type DELETE = ApiResponse<{
+                msg?: string;
+            }>;
+            namespace getFromGateway {
+                type GET = ApiResponse<objects.PaymentSystem.PG_Purchase>;
+            }
+        }
+        namespace purchases {
+            type post_list = ApiResponse<{
+                purchases: objects.Purchase[];
+                pagination: {
+                    page: number;
+                    pageSize: number;
+                    count: number;
+                };
+            }>;
+        }
+        namespace product {
+            type GET = ApiResponse<objects.Product>;
+            type PUT = ApiResponse<objects.Product>;
+        }
+        namespace products {
+            type GET = ApiResponse<objects.Product[]>;
+        }
+        namespace paymentMethod {
+            type POST = ApiResponse<objects.PaymentMethod>;
+            type PUT = ApiResponse<objects.PaymentMethod>;
+            type DELETE = ApiResponse<{
+                msg?: string;
+            }>;
+        }
+        namespace logs {
+            type POST_SEARCH = ApiResponse<{
+                data: {
+                    logs: objects.LogEntry[];
+                    pagination: auxiliarTypes.PaginationInfo;
+                    available: boolean;
+                };
+            }>;
+            namespace status {
+                type GET = ApiResponse<{
+                    saveToFile: boolean;
+                    logPretty: boolean;
+                    fileExists: boolean;
+                    filePath: string;
+                    logLevel: string;
+                    canListLogs: boolean;
+                }>;
+            }
+        }
+        namespace cronJobs {
+            namespace status {
+                type GET = ApiResponse<auxiliarTypes.CronjobsStatuses>;
+            }
+            namespace run {
+                type POST = ApiResponse<{
+                    msg: string;
+                }>;
+            }
+        }
+        namespace aux {
+            namespace countries {
+                type GET = ApiResponse<Array<{
+                    id: number;
+                    nome: string;
+                    nome_pt: string;
+                }>>;
+            }
+            namespace states {
+                type GET = ApiResponse<Array<{
+                    id: number;
+                    nome: string;
+                    uf: string;
+                    ibge: number;
+                    pais?: number;
+                    ddd?: string;
+                }>>;
+            }
+            namespace cities {
+                type GET = ApiResponse<Array<{
+                    id: number;
+                    nome: string;
+                    uf: number;
+                    ibge: number;
+                }>>;
+            }
+        }
+        namespace report {
+            type POST = ApiResponse<{
+                msg?: string;
+            }>;
+        }
+    }
+    /**
+     * Configuração do Client
+     */
+    type ClientConfig = {
+        baseURL: string;
+        tokenStorage?: {
+            getToken: () => string | null;
+            setToken: (token: string) => void;
+            getPin1: () => string | null;
+            setPin1: (pin1: string) => void;
+        };
+        onTokenUpdate?: (token: string) => void;
+        onPin1Update?: (pin1: string) => void;
+        retryAttempts?: number;
+        retryDelay?: number;
+    };
+    /**
+     * Client para comunicação com a API de autenticação
+     */
+    class Client {
+        private baseURL;
+        private bearer;
+        private pin1;
+        private tokenStorage?;
+        private onTokenUpdate?;
+        private onPin1Update?;
+        private retryAttempts;
+        private retryDelay;
+        private isHealth;
+        constructor(config: ClientConfig);
+        /**
+         * Define o token de autenticação
+         */
+        setToken(token: string): void;
+        /**
+         * Define o PIN1
+         */
+        setPin1(pin1: string): void;
+        /**
+         * Obtém o token atual
+         */
+        getToken(): string;
+        /**
+         * Obtém o PIN1 atual
+         */
+        getPin1(): string;
+        /**
+         * Verifica se o servidor está saudável
+         */
+        isHealthy(): Promise<boolean>;
+        /**
+         * Requisição base para a API
+         */
+        private request;
+        /**
+         * Constrói query string a partir de um objeto
+         */
+        private buildQueryString;
+        auth: {
+            /**
+             * Faz login na API
+             */
+            login: (email: string, password: string) => Promise<responses.auth.login.POST>;
+            /**
+             * Faz logout da API
+             */
+            logout: () => Promise<responses.auth.logout.GET>;
+            /**
+             * Verifica a sessão atual
+             */
+            checkSession: () => Promise<responses.auth.checkSession.GET>;
+        };
+        checkHealth(): Promise<boolean>;
+        user: {
+            list: () => Promise<responses.ApiResponse<responses.users.GET>>;
+            get: (userId: number, includePurchases?: boolean) => Promise<responses.ApiResponse<responses.user.GET>>;
+            update: (userId: number, userData: Partial<objects.LocalUser>) => Promise<responses.ApiResponse<responses.user.PUT>>;
+            updateConfig: (obj: {
+                id: number;
+                config_ihm_showRates?: boolean;
+            }) => Promise<responses.ApiResponse<responses.user.updateConfig.PUT>>;
+            updateAdmin: (userId: number, isAdmin: boolean) => Promise<responses.ApiResponse<responses.user.updateAdmin.PUT>>;
+            license: (userId: number) => Promise<responses.ApiResponse<responses.user.license.PUT>>;
+        };
+        purchase: {
+            new: (paymentMethodId: number, userId: number) => Promise<responses.ApiResponse<responses.purchase.create.POST>>;
+            sync: (purchaseId: number, userId: number, async?: boolean) => Promise<responses.ApiResponse<responses.purchase.id.sync.POST>>;
+            update: (userId: number, purchase: objects.Purchase) => Promise<responses.ApiResponse<responses.purchase.PUT>>;
+            cancel: (purchaseId: number, userId: number) => Promise<responses.ApiResponse<responses.purchase.cancel.PUT>>;
+            delete: (purchaseId: number, userId: number) => Promise<responses.ApiResponse<responses.purchase.DELETE>>;
+            list: (page?: number, pageSize?: number, userId?: number) => Promise<responses.ApiResponse<responses.purchases.post_list>>;
+            getFromGateway: (purchaseId: number, userId: number, async?: boolean) => Promise<responses.ApiResponse<responses.purchase.getFromGateway.GET>>;
+        };
+        products: {
+            list: () => Promise<responses.ApiResponse<responses.products.GET>>;
+            get: (productId: number) => Promise<responses.ApiResponse<responses.product.GET>>;
+            update: (productId: number, productData: any) => Promise<responses.ApiResponse<responses.product.PUT>>;
+        };
+        paymentMethods: {
+            create: (id: number, paymentMethodData: objects.PaymentMethod) => Promise<responses.ApiResponse<responses.paymentMethod.POST>>;
+            update: (id: number, paymentMethodId: number, paymentMethodData: objects.PaymentMethod) => Promise<responses.ApiResponse<responses.paymentMethod.PUT>>;
+            delete: (id: number, paymentMethodId: number) => Promise<responses.ApiResponse<responses.paymentMethod.DELETE>>;
+        };
+        aux: {
+            countries: () => Promise<responses.ApiResponse<responses.aux.countries.GET>>;
+            states: (countryId: number) => Promise<responses.ApiResponse<responses.aux.states.GET>>;
+            cities: (countryId: number, stateId: number) => Promise<responses.ApiResponse<responses.aux.cities.GET>>;
+        };
+        admin: {
+            logs: {
+                /**
+                 * @param filters
+                 * @returns
+                 */
+                list: (filters?: Partial<auxiliarTypes.LogFilters>) => Promise<responses.ApiResponse<responses.logs.POST_SEARCH>>;
+                status: () => Promise<responses.ApiResponse<responses.logs.status.GET>>;
+            };
+            cronJobs: {
+                status: () => Promise<responses.ApiResponse<responses.cronJobs.status.GET>>;
+                run: (name: string) => Promise<responses.ApiResponse<responses.cronJobs.run.POST>>;
+            };
+        };
+        report: {
+            new: (id: string, data: any) => Promise<responses.ApiResponse<responses.report.POST>>;
+        };
+    }
+}
+export default AuthApi;

package/dist/index.js

@@ -1,20 +1,421 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./admin"), exports);
-__exportStar(require("./cronjobs"), exports);
-__exportStar(require("./general"), exports);
-__exportStar(require("./payment-system"), exports);
+exports.AuthApi = void 0;
+const tools_1 = require("./tools");
+/**
+ * Namespace principal da API de autenticação
+ * Acesso aos tipos: AuthApi.objects.User, AuthApi.responses.auth.login.post, etc.
+ */
+var AuthApi;
+(function (AuthApi) {
+    /**
+     * Objetos de domínio da aplicação
+     */
+    let objects;
+    (function (objects) {
+        let BundleType;
+        (function (BundleType) {
+            BundleType[BundleType["BUNDLE"] = 0] = "BUNDLE";
+            BundleType[BundleType["SYMBOLIC_PRODUCT"] = 1] = "SYMBOLIC_PRODUCT";
+            BundleType[BundleType["SYMBOLIC_COURSE"] = 2] = "SYMBOLIC_COURSE";
+            BundleType[BundleType["SYMBOLIC_CONSULTANCY"] = 3] = "SYMBOLIC_CONSULTANCY";
+        })(BundleType = objects.BundleType || (objects.BundleType = {}));
+        let PaymentSystem;
+        (function (PaymentSystem) {
+            let PG_PurchaseLicenseStatus;
+            (function (PG_PurchaseLicenseStatus) {
+                // Pagamentos ou Assinaturas
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["UNKNOWN"] = 0] = "UNKNOWN";
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["OPEN"] = 3] = "OPEN";
+                // Pagamentos
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["EXPIRED"] = 1] = "EXPIRED";
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["PAID"] = 5] = "PAID";
+                // Assinaturas
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["ACTIVE"] = 6] = "ACTIVE";
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["RECYCLING"] = 4] = "RECYCLING";
+                PG_PurchaseLicenseStatus[PG_PurchaseLicenseStatus["CANCELED"] = 2] = "CANCELED";
+            })(PG_PurchaseLicenseStatus = PaymentSystem.PG_PurchaseLicenseStatus || (PaymentSystem.PG_PurchaseLicenseStatus = {}));
+            PaymentSystem.PG_PurchaseLicenseStatus_GroupActive = [
+                PG_PurchaseLicenseStatus.PAID,
+                PG_PurchaseLicenseStatus.ACTIVE,
+                PG_PurchaseLicenseStatus.RECYCLING,
+            ];
+            let PG_PurchasePaymentStatus;
+            (function (PG_PurchasePaymentStatus) {
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["UNKNOWN"] = 0] = "UNKNOWN";
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["ACTIVE"] = 1] = "ACTIVE";
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["CANCELED"] = 2] = "CANCELED";
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["REFUNDED"] = 3] = "REFUNDED";
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["REMOVED"] = 4] = "REMOVED";
+                PG_PurchasePaymentStatus[PG_PurchasePaymentStatus["PENDING"] = 5] = "PENDING";
+            })(PG_PurchasePaymentStatus = PaymentSystem.PG_PurchasePaymentStatus || (PaymentSystem.PG_PurchasePaymentStatus = {}));
+            let PG_PurchaseType;
+            (function (PG_PurchaseType) {
+                PG_PurchaseType[PG_PurchaseType["SESSION"] = 0] = "SESSION";
+                PG_PurchaseType[PG_PurchaseType["STANDARD"] = 1] = "STANDARD";
+                PG_PurchaseType[PG_PurchaseType["RECURRENT"] = 2] = "RECURRENT";
+            })(PG_PurchaseType = PaymentSystem.PG_PurchaseType || (PaymentSystem.PG_PurchaseType = {}));
+            let PG_RecurrenceType;
+            (function (PG_RecurrenceType) {
+                PG_RecurrenceType[PG_RecurrenceType["NONE"] = 0] = "NONE";
+                PG_RecurrenceType[PG_RecurrenceType["DAILY"] = 1] = "DAILY";
+                PG_RecurrenceType[PG_RecurrenceType["WEEKLY"] = 2] = "WEEKLY";
+                PG_RecurrenceType[PG_RecurrenceType["MONTHLY"] = 3] = "MONTHLY";
+                PG_RecurrenceType[PG_RecurrenceType["YEARLY"] = 4] = "YEARLY";
+            })(PG_RecurrenceType = PaymentSystem.PG_RecurrenceType || (PaymentSystem.PG_RecurrenceType = {}));
+        })(PaymentSystem = objects.PaymentSystem || (objects.PaymentSystem = {}));
+    })(objects = AuthApi.objects || (AuthApi.objects = {}));
+    let auxiliarTypes;
+    (function (auxiliarTypes) {
+        let Privilege;
+        (function (Privilege) {
+            Privilege[Privilege["NONE"] = 0] = "NONE";
+            Privilege[Privilege["READ"] = 1] = "READ";
+            Privilege[Privilege["WRITE"] = 2] = "WRITE";
+        })(Privilege = auxiliarTypes.Privilege || (auxiliarTypes.Privilege = {}));
+    })(auxiliarTypes = AuthApi.auxiliarTypes || (AuthApi.auxiliarTypes = {}));
+    /**
+     * Client para comunicação com a API de autenticação
+     */
+    class Client {
+        constructor(config) {
+            this.bearer = '';
+            this.pin1 = '';
+            this.retryAttempts = 0;
+            this.retryDelay = 500;
+            this.isHealth = true;
+            // ==================== MÉTODOS DE AUTENTICAÇÃO ====================
+            this.auth = {
+                /**
+                 * Faz login na API
+                 */
+                login: async (email, password) => {
+                    return this.request('POST', 'auth/login', { email, password });
+                },
+                /**
+                 * Faz logout da API
+                 */
+                logout: async () => {
+                    const result = await this.request('GET', 'auth/logout', {});
+                    this.setToken('');
+                    this.setPin1('');
+                    return result;
+                },
+                /**
+                 * Verifica a sessão atual
+                 */
+                checkSession: async () => {
+                    if (!this.bearer) {
+                        return {
+                            conex: true,
+                            reqStat: 401,
+                            success: false,
+                            data: {},
+                            msg: 'Token not found'
+                        };
+                    }
+                    return this.request('GET', 'auth', {}, { retryAttempts: 2, retryDelay: 1000 });
+                }
+            };
+            this.user = {
+                list: async () => {
+                    return await this.request('GET', 'users', {});
+                },
+                get: async (userId, includePurchases = true) => {
+                    return await this.request('GET', `user/${userId}?includePurchases=${includePurchases}`, {});
+                },
+                update: async (userId, userData) => {
+                    return await this.request('PUT', `user/${userId}`, userData);
+                },
+                updateConfig: async (obj) => {
+                    return await this.request('PUT', `user/${obj.id}/config`, obj);
+                },
+                updateAdmin: async (userId, isAdmin) => {
+                    return await this.request('PUT', `user/${userId}/admin`, { isAdmin });
+                },
+                license: async (userId) => {
+                    return await this.request('GET', `user/${userId}/license`, {});
+                }
+            };
+            this.purchase = {
+                new: async (paymentMethodId, userId) => {
+                    return await this.request('POST', `user/${userId}/purchase/new/${paymentMethodId}`, {});
+                },
+                sync: async (purchaseId, userId, async = false) => {
+                    return await this.request('POST', `user/${userId}/purchase/${purchaseId}/sync`, { async });
+                },
+                update: async (userId, purchase) => {
+                    return await this.request('PUT', `user/${userId}/purchase/${purchase.id}`, purchase);
+                },
+                cancel: async (purchaseId, userId) => {
+                    return await this.request('PUT', `user/${userId}/purchase/${purchaseId}/cancel`, {});
+                },
+                delete: async (purchaseId, userId) => {
+                    return await this.request('DELETE', `user/${userId}/purchase/${purchaseId}`, {});
+                },
+                list: async (page = 1, pageSize, userId) => {
+                    return await this.request('POST', `admin/purchases/search`, { page, pageSize, userId });
+                },
+                getFromGateway: async (purchaseId, userId, async = false) => {
+                    return await this.request('GET', `user/${userId}/purchase/${purchaseId}/getFromGateway`, {});
+                },
+            };
+            this.products = {
+                list: async () => {
+                    return await this.request('GET', 'products', {});
+                },
+                get: async (productId) => {
+                    return await this.request('GET', `product/${productId}`, { mode: 'admin' });
+                },
+                update: async (productId, productData) => {
+                    return await this.request('PUT', `product/${productId}`, productData);
+                }
+            };
+            this.paymentMethods = {
+                create: async (id, paymentMethodData) => {
+                    return await this.request('POST', `bundle/${id}/payment-method`, paymentMethodData);
+                },
+                update: async (id, paymentMethodId, paymentMethodData) => {
+                    return await this.request('PUT', `bundle/${id}/payment-method/${paymentMethodId}`, paymentMethodData);
+                },
+                delete: async (id, paymentMethodId) => {
+                    return await this.request('DELETE', `bundle/${id}/payment-method/${paymentMethodId}`, {});
+                }
+            };
+            this.aux = {
+                countries: async () => {
+                    return await this.request('GET', 'aux/countries', {});
+                },
+                states: async (countryId) => {
+                    return await this.request('GET', `aux/country/${countryId}/states`, {});
+                },
+                cities: async (countryId, stateId) => {
+                    return await this.request('GET', `aux/country/${countryId}/state/${stateId}/cities`, {});
+                }
+            };
+            this.admin = {
+                logs: {
+                    /**
+                     * @param filters
+                     * @returns
+                     */
+                    list: async (filters = {}) => {
+                        const defaultFilters = {
+                            page: 1,
+                            itemsPerPage: 50,
+                            search: '',
+                            ...filters
+                        };
+                        return await this.request('POST', 'logs', defaultFilters);
+                    },
+                    status: async () => {
+                        return await this.request('GET', 'logs/status', {});
+                    }
+                },
+                cronJobs: {
+                    status: async () => {
+                        return await this.request('GET', 'admin/cronjobs/status', {});
+                    },
+                    run: async (name) => {
+                        return await this.request('POST', `admin/cronjobs/run/${name}`, {});
+                    }
+                }
+            };
+            this.report = {
+                new: async (id, data) => {
+                    return await this.request('POST', 'report', {
+                        id,
+                        data: (0, tools_1.safeStringify)(data),
+                        appVersion: 'unknown'
+                    });
+                }
+            };
+            this.baseURL = config.baseURL;
+            this.tokenStorage = config.tokenStorage;
+            this.onTokenUpdate = config.onTokenUpdate;
+            this.onPin1Update = config.onPin1Update;
+            this.retryAttempts = config.retryAttempts ?? 0;
+            this.retryDelay = config.retryDelay ?? 500;
+            // Carrega tokens do storage se disponível
+            if (this.tokenStorage) {
+                this.bearer = this.tokenStorage.getToken() ?? '';
+                this.pin1 = this.tokenStorage.getPin1() ?? '';
+            }
+        }
+        /**
+         * Define o token de autenticação
+         */
+        setToken(token) {
+            this.bearer = token;
+            if (this.tokenStorage) {
+                this.tokenStorage.setToken(token);
+            }
+            if (this.onTokenUpdate) {
+                this.onTokenUpdate(token);
+            }
+        }
+        /**
+         * Define o PIN1
+         */
+        setPin1(pin1) {
+            this.pin1 = pin1;
+            if (this.tokenStorage) {
+                this.tokenStorage.setPin1(pin1);
+            }
+            if (this.onPin1Update) {
+                this.onPin1Update(pin1);
+            }
+        }
+        /**
+         * Obtém o token atual
+         */
+        getToken() {
+            return this.bearer;
+        }
+        /**
+         * Obtém o PIN1 atual
+         */
+        getPin1() {
+            return this.pin1;
+        }
+        /**
+         * Verifica se o servidor está saudável
+         */
+        async isHealthy() {
+            if (!this.isHealth) {
+                try {
+                    const r = await this.request('GET', '', {});
+                    if (r.success) {
+                        this.isHealth = true;
+                        return true;
+                    }
+                }
+                catch { }
+                return false;
+            }
+            return true;
+        }
+        /**
+         * Requisição base para a API
+         */
+        async request(method, endpoint, params = {}, options) {
+            const result = {
+                conex: true,
+                reqStat: 0,
+                success: false,
+                data: {},
+                msg: ''
+            };
+            const headers = {};
+            if (this.bearer)
+                headers['authorization'] = `Bearer ${this.bearer}`;
+            if (this.pin1)
+                headers['pin1'] = this.pin1;
+            const maxAttempts = 1 + (options?.retryAttempts ?? this.retryAttempts);
+            const retryDelay = options?.retryDelay ?? this.retryDelay;
+            let attempts = 0;
+            let response = null;
+            while (attempts < maxAttempts) {
+                attempts++;
+                try {
+                    const url = `${this.baseURL}/${endpoint}${method === 'GET' || method === 'DELETE' ? this.buildQueryString(params) : ''}`;
+                    const fetchOptions = {
+                        method,
+                        headers: {
+                            'Content-Type': 'application/json',
+                            ...headers
+                        },
+                        credentials: 'include'
+                    };
+                    if (method === 'POST' || method === 'PUT') {
+                        fetchOptions.body = JSON.stringify(params);
+                    }
+                    response = await fetch(url, fetchOptions);
+                    // Atualiza tokens se presentes nos headers
+                    const newToken = response.headers.get('authorization');
+                    if (newToken) {
+                        this.setToken(newToken.replace('Bearer ', ''));
+                    }
+                    const newPin1 = response.headers.get('pin1');
+                    if (newPin1) {
+                        this.setPin1(newPin1);
+                    }
+                    // Se receber 503, marca como unhealthy e tenta novamente
+                    if (response.status === 503) {
+                        this.isHealth = false;
+                        if (attempts >= maxAttempts)
+                            break;
+                        await new Promise(res => setTimeout(res, retryDelay));
+                        continue;
+                    }
+                    this.isHealth = true;
+                    result.reqStat = response.status;
+                    result.success = response.status >= 200 && response.status < 300;
+                    try {
+                        const jsonData = await response.json();
+                        result.data = jsonData;
+                        result.msg = jsonData.msg ?? '';
+                    }
+                    catch {
+                        result.msg = `stat_${response.status}`;
+                    }
+                    break;
+                }
+                catch (e) {
+                    this.isHealth = false;
+                    if (attempts >= maxAttempts) {
+                        result.conex = false;
+                        result.msg = `connectionError_${e.code ?? 'unknown'}`;
+                    }
+                    else {
+                        await new Promise(res => setTimeout(res, retryDelay));
+                    }
+                }
+            }
+            if (!result.conex) {
+                result.msg = result.msg || 'generic connection error';
+            }
+            return result;
+        }
+        /**
+         * Constrói query string a partir de um objeto
+         */
+        buildQueryString(params) {
+            if (!params || Object.keys(params).length === 0)
+                return '';
+            const queryParams = new URLSearchParams();
+            Object.keys(params).forEach(key => {
+                const value = params[key];
+                if (value !== undefined && value !== null) {
+                    if (Array.isArray(value)) {
+                        queryParams.append(key, JSON.stringify(value));
+                    }
+                    else if (typeof value === 'object') {
+                        queryParams.append(key, JSON.stringify(value));
+                    }
+                    else {
+                        queryParams.append(key, String(value));
+                    }
+                }
+            });
+            return `?${queryParams.toString()}`;
+        }
+        async checkHealth() {
+            if (!this.isHealth) {
+                try {
+                    const r = await this.request('GET', '', {});
+                    if (r.success) {
+                        this.isHealth = true;
+                        return true;
+                    }
+                }
+                catch { }
+                return false;
+            }
+            return true;
+        }
+    }
+    AuthApi.Client = Client;
+})(AuthApi || (exports.AuthApi = AuthApi = {}));
+// Exporta o namespace como default também
+exports.default = AuthApi;

package/dist/tools.d.ts

@@ -0,0 +1 @@
+export declare function safeStringify(obj: any): string;

package/dist/tools.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeStringify = safeStringify;
+function safeStringify(obj) {
+    const seen = new WeakSet();
+    return JSON.stringify(obj, (key, val) => {
+        if (val != null && typeof val === "object") {
+            if (seen.has(val)) {
+                return '[Circular]';
+            }
+            seen.add(val);
+        }
+        return val;
+    });
+}
+;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@authenty/authapi-types",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "Shared types for Authenty API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1,4 +1,3 @@
-import packageJson from '../package.json';
 import { safeStringify } from "./tools";
 
 /**
@@ -909,7 +908,7 @@ export namespace AuthApi {
                 return await this.request<responses.report.POST>('POST', 'report', {
                     id,
                     data: safeStringify(data),
-                    appVersion: packageJson.version
+                    appVersion: 'unknown'
                 });
             }
         }