@authenty/authapi-types 1.0.9 → 1.0.11

package/dist/src/index.d.ts

@@ -0,0 +1,623 @@
+/**
+ * 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;