@authenty/authapi-types 1.0.13 → 1.0.15

package/dist/index.d.ts

@@ -338,159 +338,159 @@ export declare namespace AuthApi {
         };
         namespace auth {
             namespace login {
-                type POST = ApiResponse<{
+                type POST = {
                     user: objects.LocalUser;
                     msg?: string;
-                }>;
+                };
             }
             namespace logout {
-                type GET = ApiResponse<{}>;
+                type GET = {};
             }
             namespace checkSession {
-                type GET = ApiResponse<{
+                type GET = {
                     user?: objects.LocalUser;
                     msg?: string;
-                }>;
+                };
             }
         }
         namespace users {
-            type GET = ApiResponse<objects.LocalUser[]>;
+            type GET = objects.LocalUser[];
         }
         namespace user {
-            type GET = ApiResponse<objects.LocalUser & {
+            type GET = objects.LocalUser & {
                 Wallets?: objects.Wallet[];
                 PurchasesShares?: objects.PurchaseShare[];
-            }>;
-            type PUT = ApiResponse<objects.LocalUser>;
+            };
+            type PUT = objects.LocalUser;
             namespace updateConfig {
-                type PUT = ApiResponse<{
+                type PUT = {
                     msg?: string;
-                }>;
+                };
             }
             namespace updateAdmin {
-                type PUT = ApiResponse<objects.LocalUser>;
+                type PUT = objects.LocalUser;
             }
             namespace license {
-                type PUT = ApiResponse<{
+                type PUT = {
                     availableLicenses: number;
                     heldLicenses: number;
                     usedLicenses: number;
                     msg?: string;
-                }>;
+                };
             }
         }
         namespace purchase {
             namespace create {
-                type POST = ApiResponse<{
+                type POST = {
                     msg?: string;
                     purchase: objects.Purchase;
                     url?: string;
-                }>;
+                };
             }
             namespace id {
                 namespace sync {
-                    type POST = ApiResponse<objects.Purchase & {
+                    type POST = objects.Purchase & {
                         msg?: string;
-                    }>;
+                    };
                 }
             }
-            type PUT = ApiResponse<objects.Purchase | {
+            type PUT = objects.Purchase | {
                 msg?: string;
-            }>;
+            };
             namespace cancel {
-                type PUT = ApiResponse<objects.Purchase>;
+                type PUT = objects.Purchase;
             }
-            type DELETE = ApiResponse<{
+            type DELETE = {
                 msg?: string;
-            }>;
+            };
             namespace getFromGateway {
-                type GET = ApiResponse<objects.PaymentSystem.PG_Purchase>;
+                type GET = objects.PaymentSystem.PG_Purchase;
             }
         }
         namespace purchases {
-            type post_list = ApiResponse<{
+            type post_list = {
                 purchases: objects.Purchase[];
                 pagination: {
                     page: number;
                     pageSize: number;
                     count: number;
                 };
-            }>;
+            };
         }
         namespace product {
-            type GET = ApiResponse<objects.Product>;
-            type PUT = ApiResponse<objects.Product>;
+            type GET = objects.Product;
+            type PUT = objects.Product;
         }
         namespace products {
-            type GET = ApiResponse<objects.Product[]>;
+            type GET = objects.Product[];
         }
         namespace paymentMethod {
-            type POST = ApiResponse<objects.PaymentMethod>;
-            type PUT = ApiResponse<objects.PaymentMethod>;
-            type DELETE = ApiResponse<{
+            type POST = objects.PaymentMethod;
+            type PUT = objects.PaymentMethod;
+            type DELETE = {
                 msg?: string;
-            }>;
+            };
         }
         namespace logs {
-            type POST_SEARCH = ApiResponse<{
+            type POST_SEARCH = {
                 data: {
                     logs: objects.LogEntry[];
                     pagination: auxiliarTypes.PaginationInfo;
                     available: boolean;
                 };
-            }>;
+            };
             namespace status {
-                type GET = ApiResponse<{
+                type GET = {
                     saveToFile: boolean;
                     logPretty: boolean;
                     fileExists: boolean;
                     filePath: string;
                     logLevel: string;
                     canListLogs: boolean;
-                }>;
+                };
             }
         }
         namespace cronJobs {
             namespace status {
-                type GET = ApiResponse<auxiliarTypes.CronjobsStatuses>;
+                type GET = auxiliarTypes.CronjobsStatuses;
             }
             namespace run {
-                type POST = ApiResponse<{
+                type POST = {
                     msg: string;
-                }>;
+                };
             }
         }
         namespace aux {
             namespace countries {
-                type GET = ApiResponse<Array<{
+                type GET = Array<{
                     id: number;
                     nome: string;
                     nome_pt: string;
-                }>>;
+                }>;
             }
             namespace states {
-                type GET = ApiResponse<Array<{
+                type GET = Array<{
                     id: number;
                     nome: string;
                     uf: string;
                     ibge: number;
                     pais?: number;
                     ddd?: string;
-                }>>;
+                }>;
             }
             namespace cities {
-                type GET = ApiResponse<Array<{
+                type GET = Array<{
                     id: number;
                     nome: string;
                     uf: number;
                     ibge: number;
-                }>>;
+                }>;
             }
         }
         namespace report {
-            type POST = ApiResponse<{
+            type POST = {
                 msg?: string;
-            }>;
+            };
         }
     }
     /**
@@ -555,45 +555,45 @@ export declare namespace AuthApi {
             /**
              * Faz login na API
              */
-            login: (email: string, password: string) => Promise<responses.auth.login.POST>;
+            login: (email: string, password: string) => Promise<responses.ApiResponse<responses.auth.login.POST>>;
             /**
              * Faz logout da API
              */
-            logout: () => Promise<responses.auth.logout.GET>;
+            logout: () => Promise<responses.ApiResponse<responses.auth.logout.GET>>;
             /**
              * Verifica a sessão atual
              */
-            checkSession: () => Promise<responses.auth.checkSession.GET>;
+            checkSession: () => Promise<responses.ApiResponse<responses.auth.checkSession.GET>>;
         };
         checkHealth(): Promise<boolean>;
-        user: {
+        users: {
             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>>;
+            update: (userId: number, userData: Partial<objects.LocalUser>) => Promise<responses.ApiResponse<objects.LocalUser>>;
             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>>;
+            updateAdmin: (userId: number, isAdmin: boolean) => Promise<responses.ApiResponse<objects.LocalUser>>;
             license: (userId: number) => Promise<responses.ApiResponse<responses.user.license.PUT>>;
         };
-        purchase: {
+        purchases: {
             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>>;
+            cancel: (purchaseId: number, userId: number) => Promise<responses.ApiResponse<objects.Purchase>>;
             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>>;
+            getFromGateway: (purchaseId: number, userId: number, async?: boolean) => Promise<responses.ApiResponse<objects.PaymentSystem.PG_Purchase>>;
         };
         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>>;
+            get: (productId: number) => Promise<responses.ApiResponse<objects.Product>>;
+            update: (productId: number, productData: any) => Promise<responses.ApiResponse<objects.Product>>;
         };
         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>>;
+            create: (id: number, paymentMethodData: objects.PaymentMethod) => Promise<responses.ApiResponse<objects.PaymentMethod>>;
+            update: (id: number, paymentMethodId: number, paymentMethodData: objects.PaymentMethod) => Promise<responses.ApiResponse<objects.PaymentMethod>>;
             delete: (id: number, paymentMethodId: number) => Promise<responses.ApiResponse<responses.paymentMethod.DELETE>>;
         };
         aux: {
@@ -611,7 +611,7 @@ export declare namespace AuthApi {
                 status: () => Promise<responses.ApiResponse<responses.logs.status.GET>>;
             };
             cronJobs: {
-                status: () => Promise<responses.ApiResponse<responses.cronJobs.status.GET>>;
+                status: () => Promise<responses.ApiResponse<auxiliarTypes.CronjobsStatuses>>;
                 run: (name: string) => Promise<responses.ApiResponse<responses.cronJobs.run.POST>>;
             };
         };

package/dist/index.js

@@ -117,7 +117,7 @@ var AuthApi;
                     return this.request('GET', 'auth', {}, { retryAttempts: 2, retryDelay: 1000 });
                 }
             };
-            this.user = {
+            this.users = {
                 list: async () => {
                     return await this.request('GET', 'users', {});
                 },
@@ -137,7 +137,7 @@ var AuthApi;
                     return await this.request('GET', `user/${userId}/license`, {});
                 }
             };
-            this.purchase = {
+            this.purchases = {
                 new: async (paymentMethodId, userId) => {
                     return await this.request('POST', `user/${userId}/purchase/new/${paymentMethodId}`, {});
                 },

package/package.json

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

package/src/index.ts

@@ -388,122 +388,122 @@ export namespace AuthApi {
 
         export namespace auth {
             export namespace login {
-                export type POST = ApiResponse<{ user: objects.LocalUser; msg?: string }>;
+                export type POST = { user: objects.LocalUser; msg?: string };
             }
             export namespace logout {
-                export type GET = ApiResponse<{}>;
+                export type GET = {};
             }
             export namespace checkSession {
-                export type GET = ApiResponse<{ user?: objects.LocalUser; msg?: string }>;
+                export type GET = { user?: objects.LocalUser; msg?: string };
             }
         }
 
         export namespace users {
-            export type GET = ApiResponse<objects.LocalUser[]>;
+            export type GET = objects.LocalUser[];
         }
 
         export namespace user {
-            export type GET = ApiResponse<objects.LocalUser & { Wallets?: objects.Wallet[]; PurchasesShares?: objects.PurchaseShare[] }>;
-            export type PUT = ApiResponse<objects.LocalUser>;
+            export type GET = objects.LocalUser & { Wallets?: objects.Wallet[]; PurchasesShares?: objects.PurchaseShare[] };
+            export type PUT = objects.LocalUser;
             
             export namespace updateConfig {
-                export type PUT = ApiResponse<{ msg?: string }>;
+                export type PUT = { msg?: string };
             }
             export namespace updateAdmin {
-                export type PUT = ApiResponse<objects.LocalUser>;
+                export type PUT = objects.LocalUser;
             }
             export namespace license {
-                export type PUT = ApiResponse<{ availableLicenses: number; heldLicenses: number; usedLicenses: number; msg?: string }>;
+                export type PUT = { 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 type POST = { msg?: string; purchase: objects.Purchase; url?: string };
             }
             export namespace id {
                 export namespace sync {
-                    export type POST = ApiResponse<objects.Purchase & { msg?: string }>;
+                    export type POST = objects.Purchase & { msg?: string };
                 }
             }
-            export type PUT = ApiResponse<objects.Purchase | { msg?: string }>;
+            export type PUT = objects.Purchase | { msg?: string };
             export namespace cancel {
-                export type PUT = ApiResponse<objects.Purchase>;
+                export type PUT = objects.Purchase;
             }
-            export type DELETE = ApiResponse<{ msg?: string }>;
+            export type DELETE = { msg?: string };
             export namespace getFromGateway {
-                export type GET = ApiResponse<objects.PaymentSystem.PG_Purchase>;
+                export type GET = objects.PaymentSystem.PG_Purchase;
             }
         }
 
         export namespace purchases {
-            export type post_list = ApiResponse<{
+            export type post_list = {
                 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 type GET = objects.Product;
+            export type PUT = objects.Product;
         }
         export namespace products {
             
-            export type GET = ApiResponse<objects.Product[]>;
+            export type GET = objects.Product[];
         }
 
         export namespace paymentMethod {
-            export type POST = ApiResponse<objects.PaymentMethod>;
-            export type PUT = ApiResponse<objects.PaymentMethod>;
-            export type DELETE = ApiResponse<{ msg?: string }>;
+            export type POST = objects.PaymentMethod;
+            export type PUT = objects.PaymentMethod;
+            export type DELETE = { msg?: string };
         }
 
         export namespace logs {
 
-            export type POST_SEARCH = ApiResponse<{ data: {
+            export type POST_SEARCH = { data: {
                 logs: objects.LogEntry[];
                 pagination: auxiliarTypes.PaginationInfo;
                 available: boolean;
-            } }>;
+            } };
             export namespace status {
-                export type GET = ApiResponse<{
+                export type GET = {
                     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 type GET = auxiliarTypes.CronjobsStatuses;
             }
             export namespace run {
-                export type POST = ApiResponse<{ msg: string }>;
+                export type POST = { msg: string };
             }
         }
 
         export namespace aux {
             export namespace countries {
-                export type GET = ApiResponse<Array<{ id: number; nome: string; nome_pt: string }>>;
+                export type GET = 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 type GET = 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 type GET = Array<{ id: number; nome: string; uf: number; ibge: number }>;
             }
         }
         
         export namespace report {
-            export type POST = ApiResponse<{ msg?: string }>;
+            export type POST = { msg?: string };
         }
     }
 
@@ -621,7 +621,8 @@ export namespace AuthApi {
                 retryAttempts?: number;
                 retryDelay?: number;
             }
-        ): Promise<responses.ApiResponse<T>> {
+        ) {
+
             const result: responses.ApiResponse<T> = {
                 conex: true,
                 reqStat: 0,
@@ -739,15 +740,15 @@ export namespace AuthApi {
             /**
              * 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 });
+            login: async (email: string, password: string) => {
+                return this.request<responses.auth.login.POST>('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', {});
+            logout: async () => {
+                const result = await this.request<responses.auth.logout.GET>('GET', 'auth/logout', {});
                 this.setToken('');
                 this.setPin1('');
                 return result;
@@ -756,7 +757,7 @@ export namespace AuthApi {
             /**
              * Verifica a sessão atual
              */
-            checkSession: async (): Promise<responses.auth.checkSession.GET> => {
+            checkSession: async () => {
                 if (!this.bearer) {
                     return {
                         conex: true,
@@ -766,7 +767,7 @@ export namespace AuthApi {
                         msg: 'Token not found'
                     };
                 }
-                return this.request<responses.auth.checkSession.GET['data']>('GET', 'auth', {}, { retryAttempts: 2, retryDelay: 1000 });
+                return this.request<responses.auth.checkSession.GET>('GET', 'auth', {}, { retryAttempts: 2, retryDelay: 1000 });
             }
         }
 
@@ -785,7 +786,7 @@ export namespace AuthApi {
             return true;
         }
 
-        public user = {
+        public users = {
             list: async () => {
                 return await this.request<responses.users.GET>('GET', 'users', {});
             },
@@ -806,7 +807,7 @@ export namespace AuthApi {
             }
         }
 
-        public purchase = {
+        public purchases = {
             new: async (paymentMethodId: number, userId: number) => {
                 return await this.request<responses.purchase.create.POST>('POST', `user/${userId}/purchase/new/${paymentMethodId}`, {});
             },