@authenty/authapi-types 1.0.9 → 1.0.11

package/src/index.ts

@@ -1,7 +1,921 @@
-export * from './admin';
-export * from './cronjobs';
-export * from './general';
-export * from './payment-system';
+import packageJson from '../package.json';
+import { safeStringify } from "./tools";
 
+/**
+ * Namespace principal da API de autenticação
+ * Acesso aos tipos: AuthApi.objects.User, AuthApi.responses.auth.login.post, etc.
+ */
+export namespace AuthApi {
 
+    /**
+     * Objetos de domínio da aplicação
+     */
+    export namespace objects {
+        export enum BundleType {
+            BUNDLE = 0,
+            SYMBOLIC_PRODUCT = 1,
+            SYMBOLIC_COURSE = 2,
+            SYMBOLIC_CONSULTANCY = 3,
+        }
 
+        export 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[];
+        }
+
+        export 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
+            }[];
+        }
+
+        export 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;
+        }
+
+        export 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;
+        }
+
+        export 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[];
+        }
+
+        export type PaymentMethod = {
+            id: number;
+            bundleID: number;
+            price: number;
+            fromprice: number;
+            period_renew: number;
+            period_grace: number;
+            gatewayHash: string;
+            allowBoleto: boolean;
+            gatewayID: number;
+            Bundle?: Bundle;
+        }
+
+        export 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
+            }[]
+        }
+
+        export type Wallet = {
+            id: number;
+            userID: number;
+            balance?: number;
+            Purchases?: Purchase[];
+        }
+
+        export type PurchaseShare = {
+            id: number;
+            purchaseID: number;
+            userID: number;
+            Purchase: Purchase;
+        }
+
+        export 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
+        }
+        export type AdminUserConfig = {
+            campaigns_blacklist: string,
+            deletedAt: Date | null,
+            userID: number
+        }
+
+        // Tipos para logs do sistema
+        export 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;
+            };
+        }
+
+        export namespace PaymentSystem {
+
+            export type PG_Customer = {
+                id: string,
+                email: string,
+                name: string
+            }
+
+            export enum PG_PurchaseLicenseStatus {
+
+                // Pagamentos ou Assinaturas
+                UNKNOWN = 0,//Nunca será atualizado automaticamente!!
+                OPEN = 3, //ABERTA - Aguardando pagamento
+
+                // Pagamentos
+                EXPIRED = 1, //VENCEU - Era PAGAMENTO, e acabou prazo pra uso acabou
+                PAID = 5, //PAGA - Pagamento realizado com sucesso - é pagamento único
+
+                // Assinaturas
+                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, //CANCELADA - Foi cancelada pelo usuário ou admin
+            }
+
+            export const PG_PurchaseLicenseStatus_GroupActive = [//quais são os Status que são considerados ATIVOS (aptos a usar a licença)
+                PG_PurchaseLicenseStatus.PAID,
+                PG_PurchaseLicenseStatus.ACTIVE,
+                PG_PurchaseLicenseStatus.RECYCLING,
+            ]
+
+            export 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, //não paga ainda
+            }
+
+            export 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, //Assinatura recorrente
+            }
+
+            export type PG_Purchase = {
+                id: string,
+                amount: number,
+                recurrent: boolean,
+                type: PG_PurchaseType,
+                // licenseStatus: PG_PurchaseLicenseStatus,
+                paymentStatus: PG_PurchasePaymentStatus,
+                url: string | null,
+                dueTime: Date | null
+            }
+
+            export enum PG_RecurrenceType {
+                NONE = 0,
+                DAILY = 1,
+                WEEKLY = 2,
+                MONTHLY = 3,
+                YEARLY = 4
+            }
+        }
+    }
+
+    export namespace auxiliarTypes {
+
+        export type availableSoftware = {
+            Level: objects.ProductLevel,
+            quantity: number,//acessos simultâneos permitidos por esta COMPRA
+            purchaseId: number | null, //null when free
+            type: 'free' | 'own' | 'shared'
+        }
+
+        export enum Privilege {
+            NONE = 0,
+            READ = 1,
+            WRITE = 2
+        }
+
+        export type PrivilegeTable = {// ESTES PRIVILÉGIOS JÁ SÃO CONVERTIDOS NO `server.ts` para que quando é externo tenha que ter maior nível de acesso...
+            users: Privilege;
+            products: Privilege;
+            courses: Privilege;
+            consultancies: Privilege;
+            bundles: Privilege;
+            logs: Privilege;
+            support: Privilege;
+            leads: Privilege;
+            paymentSystem: Privilege;
+            adminMaster: Privilege;
+            activityTrakking: Privilege;
+            financial: Privilege;
+        }
+
+        export type CronJob = { //Também definido em ~/server/src/cronjobs.ts
+            startAt: Date | null //null se não está rodando
+            latestRunErrorCount: number //zero se não teve erro
+            latestCompletedAt: Date | null
+        }
+
+        export type CronjobsStatuses = {
+            purchasesStatusUpdate: CronJob
+        }
+
+        export type LogFilters = {
+            page: number;
+            itemsPerPage: number;
+            search: string;
+            logCode?: number;
+            appId?: string;
+            userId?: number;
+            method?: string;
+            startDate?: string;
+            endDate?: string;
+        }
+
+        export type PaginationInfo = {
+            total: number;
+            page: number;
+            itemsPerPage: number;
+            totalPages: number;
+        }
+    }
+
+    /**
+     * Tipos de resposta padrão da API
+     */
+    export namespace responses {
+
+        export type ApiResponse<T = any> = {
+            conex: boolean;
+            reqStat: number;
+            success: boolean;
+            data: T;
+            msg: string;
+        }
+
+        export namespace auth {
+            export namespace login {
+                export type POST = ApiResponse<{ user: objects.LocalUser; msg?: string }>;
+            }
+            export namespace logout {
+                export type GET = ApiResponse<{}>;
+            }
+            export namespace checkSession {
+                export type GET = ApiResponse<{ user?: objects.LocalUser; msg?: string }>;
+            }
+        }
+
+        export namespace users {
+            export type GET = ApiResponse<objects.LocalUser[]>;
+        }
+
+        export namespace user {
+            export type GET = ApiResponse<objects.LocalUser & { Wallets?: objects.Wallet[]; PurchasesShares?: objects.PurchaseShare[] }>;
+            export type PUT = ApiResponse<objects.LocalUser>;
+            
+            export namespace updateConfig {
+                export type PUT = ApiResponse<{ msg?: string }>;
+            }
+            export namespace updateAdmin {
+                export type PUT = ApiResponse<objects.LocalUser>;
+            }
+            export namespace license {
+                export type PUT = ApiResponse<{ availableLicenses: number; heldLicenses: number; usedLicenses: number; msg?: string }>;
+            }
+        }
+
+        export namespace purchase {
+            export namespace create {
+                export type POST = ApiResponse<{ msg?: string; purchase: objects.Purchase; url?: string }>;
+            }
+            export namespace id {
+                export namespace sync {
+                    export type POST = ApiResponse<objects.Purchase & { msg?: string }>;
+                }
+            }
+            export type PUT = ApiResponse<objects.Purchase | { msg?: string }>;
+            export namespace cancel {
+                export type PUT = ApiResponse<objects.Purchase>;
+            }
+            export type DELETE = ApiResponse<{ msg?: string }>;
+            export namespace getFromGateway {
+                export type GET = ApiResponse<objects.PaymentSystem.PG_Purchase>;
+            }
+        }
+
+        export namespace purchases {
+            export type post_list = ApiResponse<{
+                purchases: objects.Purchase[];
+                pagination: {
+                    page: number;
+                    pageSize: number;
+                    count: number;
+                };
+            }>;
+        }
+
+        export namespace product {
+            export type GET = ApiResponse<objects.Product>;
+            export type PUT = ApiResponse<objects.Product>;
+        }
+        export namespace products {
+            
+            export type GET = ApiResponse<objects.Product[]>;
+        }
+
+        export namespace paymentMethod {
+            export type POST = ApiResponse<objects.PaymentMethod>;
+            export type PUT = ApiResponse<objects.PaymentMethod>;
+            export type DELETE = ApiResponse<{ msg?: string }>;
+        }
+
+        export namespace logs {
+
+            export type POST_SEARCH = ApiResponse<{ data: {
+                logs: objects.LogEntry[];
+                pagination: auxiliarTypes.PaginationInfo;
+                available: boolean;
+            } }>;
+            export namespace status {
+                export type GET = ApiResponse<{
+                    saveToFile: boolean;
+                    logPretty: boolean;
+                    fileExists: boolean;
+                    filePath: string;
+                    logLevel: string;
+                    canListLogs: boolean;
+                }>;
+            }
+        }
+
+        export namespace cronJobs {
+            export namespace status {
+                export type GET = ApiResponse<auxiliarTypes.CronjobsStatuses>;
+            }
+            export namespace run {
+                export type POST = ApiResponse<{ msg: string }>;
+            }
+        }
+
+        export namespace aux {
+            export namespace countries {
+                export type GET = ApiResponse<Array<{ id: number; nome: string; nome_pt: string }>>;
+            }
+            export namespace states {
+                export type GET = ApiResponse<Array<{ id: number; nome: string; uf: string; ibge: number; pais?: number; ddd?: string }>>;
+            }
+            export namespace cities {
+                export type GET = ApiResponse<Array<{ id: number; nome: string; uf: number; ibge: number }>>;
+            }
+        }
+        
+        export namespace report {
+            export type POST = ApiResponse<{ msg?: string }>;
+        }
+    }
+
+    /**
+     * Configuração do Client
+     */
+    export 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
+     */
+    export class Client {
+        private baseURL: string;
+        private bearer: string = '';
+        private pin1: string = '';
+        private tokenStorage?: ClientConfig['tokenStorage'];
+        private onTokenUpdate?: (token: string) => void;
+        private onPin1Update?: (pin1: string) => void;
+        private retryAttempts: number = 0;
+        private retryDelay: number = 500;
+        private isHealth: boolean = true;
+
+        constructor(config: ClientConfig) {
+            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
+         */
+        public setToken(token: string): void {
+            this.bearer = token;
+            if (this.tokenStorage) {
+                this.tokenStorage.setToken(token);
+            }
+            if (this.onTokenUpdate) {
+                this.onTokenUpdate(token);
+            }
+        }
+
+        /**
+         * Define o PIN1
+         */
+        public setPin1(pin1: string): void {
+            this.pin1 = pin1;
+            if (this.tokenStorage) {
+                this.tokenStorage.setPin1(pin1);
+            }
+            if (this.onPin1Update) {
+                this.onPin1Update(pin1);
+            }
+        }
+
+        /**
+         * Obtém o token atual
+         */
+        public getToken(): string {
+            return this.bearer;
+        }
+
+        /**
+         * Obtém o PIN1 atual
+         */
+        public getPin1(): string {
+            return this.pin1;
+        }
+
+        /**
+         * Verifica se o servidor está saudável
+         */
+        public async isHealthy(): Promise<boolean> {
+            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
+         */
+        private async request<T = any>(
+            method: 'GET' | 'POST' | 'PUT' | 'DELETE',
+            endpoint: string,
+            params: any = {},
+            options?: {
+                retryAttempts?: number;
+                retryDelay?: number;
+            }
+        ): Promise<responses.ApiResponse<T>> {
+            const result: responses.ApiResponse<T> = {
+                conex: true,
+                reqStat: 0,
+                success: false,
+                data: {} as T,
+                msg: ''
+            };
+
+            const headers: Record<string, string> = {};
+            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: Response | null = null;
+
+            while (attempts < maxAttempts) {
+                attempts++;
+                try {
+                    const url = `${this.baseURL}/${endpoint}${method === 'GET' || method === 'DELETE' ? this.buildQueryString(params) : ''}`;
+                    const fetchOptions: RequestInit = {
+                        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: any) {
+                    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
+         */
+        private buildQueryString(params: any): string {
+            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()}`;
+        }
+
+        // ==================== MÉTODOS DE AUTENTICAÇÃO ====================
+
+        public auth = {
+            
+            /**
+             * Faz login na API
+             */
+            login: async (email: string, password: string): Promise<responses.auth.login.POST> => {
+                return this.request<responses.auth.login.POST['data']>('POST', 'auth/login', { email, password });
+            },
+
+            /**
+             * Faz logout da API
+             */
+            logout: async (): Promise<responses.auth.logout.GET> => {
+                const result = await this.request<responses.auth.logout.GET['data']>('GET', 'auth/logout', {});
+                this.setToken('');
+                this.setPin1('');
+                return result;
+            },
+
+            /**
+             * Verifica a sessão atual
+             */
+            checkSession: async (): Promise<responses.auth.checkSession.GET> => {
+                if (!this.bearer) {
+                    return {
+                        conex: true,
+                        reqStat: 401,
+                        success: false,
+                        data: {},
+                        msg: 'Token not found'
+                    };
+                }
+                return this.request<responses.auth.checkSession.GET['data']>('GET', 'auth', {}, { retryAttempts: 2, retryDelay: 1000 });
+            }
+        }
+
+        public 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;
+        }
+
+        public user = {
+            list: async () => {
+                return await this.request<responses.users.GET>('GET', 'users', {});
+            },
+            get: async (userId: number, includePurchases: boolean = true) => {
+                return await this.request<responses.user.GET>('GET', `user/${userId}?includePurchases=${includePurchases}`, {});
+            },
+            update: async (userId: number, userData: Partial<objects.LocalUser>) => {
+                return await this.request<responses.user.PUT>('PUT', `user/${userId}`, userData);
+            },
+            updateConfig: async ( obj:{id: number, config_ihm_showRates?: boolean} ) => {
+                return await this.request<responses.user.updateConfig.PUT>('PUT', `user/${obj.id}/config`, obj);
+            },
+            updateAdmin: async (userId: number, isAdmin: boolean) => {
+                return await this.request<responses.user.updateAdmin.PUT>('PUT', `user/${userId}/admin`, { isAdmin });
+            },
+            license: async (userId:number) => {
+                return await this.request<responses.user.license.PUT>('GET', `user/${userId}/license`, {});
+            }
+        }
+
+        public purchase = {
+            new: async (paymentMethodId: number, userId: number) => {
+                return await this.request<responses.purchase.create.POST>('POST', `user/${userId}/purchase/new/${paymentMethodId}`, {});
+            },
+            sync: async (purchaseId: number, userId: number, async: boolean = false) => {
+                return await this.request<responses.purchase.id.sync.POST>('POST', `user/${userId}/purchase/${purchaseId}/sync`, { async });
+            },
+            update: async (userId: number, purchase: objects.Purchase) => {
+                return await this.request<responses.purchase.PUT>('PUT', `user/${userId}/purchase/${purchase.id}`, purchase );
+            },
+            cancel: async (purchaseId: number, userId: number) => {
+                return await this.request<responses.purchase.cancel.PUT>('PUT', `user/${userId}/purchase/${purchaseId}/cancel`, {} );
+            },
+            delete: async (purchaseId: number, userId: number) => {
+                return await this.request<responses.purchase.DELETE>('DELETE', `user/${userId}/purchase/${purchaseId}`, { });
+            },
+            list: async (page:number=1, pageSize?:number, userId?: number) => {
+                return await this.request<responses.purchases.post_list>('POST', `admin/purchases/search`, { page, pageSize, userId });
+            },
+            getFromGateway: async (purchaseId: number, userId: number, async: boolean = false) => {
+                return await this.request<responses.purchase.getFromGateway.GET>('GET', `user/${userId}/purchase/${purchaseId}/getFromGateway`, {});
+            },
+        }
+
+        public products = {
+
+            list: async () => {
+                return await this.request<responses.products.GET>('GET', 'products', {});
+            },
+            get: async (productId: number) => {
+                return await this.request<responses.product.GET>('GET', `product/${productId}`, { mode: 'admin' });
+            },
+            update: async (productId: number, productData: any) => {
+                return await this.request<responses.product.PUT>('PUT', `product/${productId}`, productData);
+            }
+        }
+
+        public paymentMethods = {
+
+            create: async (id: number, paymentMethodData: objects.PaymentMethod) => {
+                return await this.request<responses.paymentMethod.POST>('POST', `bundle/${id}/payment-method`, paymentMethodData);
+            },
+            update: async (id: number, paymentMethodId: number, paymentMethodData: objects.PaymentMethod) => {
+                return await this.request<responses.paymentMethod.PUT>('PUT', `bundle/${id}/payment-method/${paymentMethodId}`, paymentMethodData);
+            },
+            delete: async (id: number, paymentMethodId: number) => {
+                return await this.request<responses.paymentMethod.DELETE>('DELETE', `bundle/${id}/payment-method/${paymentMethodId}`, {});
+            }
+        }
+
+        public aux = {
+            countries: async () => {
+                return await this.request<responses.aux.countries.GET>('GET', 'aux/countries', {});
+            },
+            
+            states: async (countryId: number) => {
+                return await this.request<responses.aux.states.GET>('GET', `aux/country/${countryId}/states`, {});
+            },
+            
+            cities: async (countryId: number, stateId: number) => {
+                return await this.request<responses.aux.cities.GET>('GET', `aux/country/${countryId}/state/${stateId}/cities`, {});
+            }
+        }
+
+        public admin = {
+
+            logs: {
+                /**
+                 * @param filters 
+                 * @returns 
+                 */
+                list: async (filters: Partial<auxiliarTypes.LogFilters> = {}) => {
+                    const defaultFilters: auxiliarTypes.LogFilters = {
+                        page: 1,
+                        itemsPerPage: 50,
+                        search: '',
+                        ...filters
+                    };
+                    return await this.request<responses.logs.POST_SEARCH>('POST', 'logs', defaultFilters);
+                },
+                
+                status: async () => {
+                    return await this.request<responses.logs.status.GET>('GET', 'logs/status', {});
+                }
+            },
+    
+            cronJobs: {
+                status: async () => {
+                    return await this.request<responses.cronJobs.status.GET>('GET', 'admin/cronjobs/status', {});
+                },
+                run: async (name: string) => {
+                    return await this.request<responses.cronJobs.run.POST>('POST', `admin/cronjobs/run/${name}`, {});
+                }
+            }
+        }
+        
+        public report = {
+            new: async (id: string, data: any) => {
+
+                return await this.request<responses.report.POST>('POST', 'report', {
+                    id,
+                    data: safeStringify(data),
+                    appVersion: packageJson.version
+                });
+            }
+        }
+        
+    }
+
+}
+
+// Exporta o namespace como default também
+export default AuthApi;