@authenty/authapi-types 1.0.20 → 1.0.22

package/dist/index.d.ts

@@ -45,6 +45,22 @@ export declare namespace AuthApi {
                 Bundle?: Bundle;
             }[];
         };
+        type Teacher = {
+            id: number;
+            fullname: string;
+            resume: string;
+            email: string;
+            avatar_l: string;
+            date_c: string;
+            date_r: string | null;
+            active: boolean;
+            notif_newPupil: boolean;
+        };
+        enum TeacherType {
+            DEFAULT_TEACHER = 0,
+            AUXILIAR_TEACHER = 1,
+            PARTICIPATION = 2
+        }
         type Course = {
             id: number;
             type: number;
@@ -69,6 +85,14 @@ export declare namespace AuthApi {
             email_after?: string;
             date_c: string;
             date_r?: string | null;
+            scholar_courses_teacher?: {
+                id: number;
+                courseID: number;
+                teacherID: number;
+                type: TeacherType;
+                Course?: Course;
+                Teacher?: Teacher;
+            };
         };
         type Consultancy = {
             id: number;
@@ -210,6 +234,36 @@ export declare namespace AuthApi {
             deletedAt: Date | null;
             userID: number;
         };
+        type Session = {
+            id: string;
+            hash?: string;
+            pin1?: string;
+            pin2?: string;
+            trust: boolean;
+            userID: number;
+            User?: LocalUser;
+            ip: string;
+            os: string;
+            browser: string;
+            creation_ts: number;
+            update_ts: number;
+            last_ts: number;
+            active: boolean;
+            data: string;
+            Licenses?: License[];
+        };
+        type License = {
+            id: number;
+            purchaseID: number;
+            Purchase?: Purchase;
+            levelID: number | null;
+            ProductLevel?: ProductLevel;
+            sessionID: number | null;
+            Session?: MediaSession;
+            got_at: number;
+            renew_at: number;
+            released_at: number | null;
+        };
         type LogEntry = {
             appId: string;
             logCode: number;
@@ -358,79 +412,197 @@ export declare namespace AuthApi {
             type GET = objects.LocalUser[];
         }
         namespace user {
-            type GET = objects.LocalUser & {
-                Wallets?: objects.Wallet[];
-                PurchasesShares?: objects.PurchaseShare[];
-            };
-            type PUT = objects.LocalUser;
-            namespace updateConfig {
-                type PUT = {
-                    msg?: string;
+            type POST = objects.LocalUser;
+            namespace $userId {
+                type GET = objects.LocalUser & {
+                    Wallets?: objects.Wallet[];
+                    PurchasesShares?: objects.PurchaseShare[];
                 };
-            }
-            namespace updateAdmin {
                 type PUT = objects.LocalUser;
-            }
-            namespace license {
-                type PUT = {
-                    availableLicenses: number;
-                    heldLicenses: number;
-                    usedLicenses: number;
-                    msg?: string;
-                };
-            }
-        }
-        namespace purchase {
-            namespace create {
-                type POST = {
+                type DELETE = {
                     msg?: string;
-                    purchase: objects.Purchase;
-                    url?: string;
                 };
-            }
-            namespace id {
-                namespace sync {
-                    type POST = objects.Purchase & {
+                namespace updateConfig {
+                    type PUT = {
                         msg?: string;
                     };
                 }
+                namespace updateAdmin {
+                    type PUT = objects.LocalUser;
+                }
+                namespace license {
+                    type GET = {
+                        msg?: string;
+                        license: objects.License;
+                    };
+                    namespace release {
+                        type POST = {
+                            msg?: string;
+                        };
+                    }
+                }
+                namespace licenses {
+                    type GET = objects.License[];
+                    namespace revokeAll {
+                        type POST = {
+                            msg: string;
+                        };
+                    }
+                }
+                namespace availableProducts {
+                    type GET = auxiliarTypes.availableSoftware[];
+                }
+                namespace purchase {
+                    type POST = {
+                        msg?: string;
+                        code: number;
+                        purchase?: objects.Purchase;
+                        url?: string;
+                    };
+                    namespace $purchaseId {
+                        type GET = objects.Purchase;
+                        type PUT = objects.Purchase;
+                        type DELETE = {
+                            msg?: string;
+                        };
+                        namespace sync {
+                            type POST = {
+                                msg: string;
+                                purchase?: objects.Purchase;
+                            };
+                        }
+                        namespace getFromGateway {
+                            type GET = objects.PaymentSystem.PG_Purchase;
+                        }
+                        namespace cancel {
+                            type POST = {
+                                msg?: string;
+                            };
+                        }
+                    }
+                }
+                namespace purchases {
+                    type GET = objects.Purchase[];
+                    namespace getByProduct {
+                        type GET = {
+                            ownPurchases: objects.Purchase[];
+                            sharedPurchases: objects.Purchase[];
+                        };
+                    }
+                }
+                namespace sessions {
+                    type GET = (objects.Session & {
+                        Licenses: objects.License[];
+                    })[];
+                    namespace renew {
+                        type GET = {
+                            msg: string;
+                        };
+                    }
+                    namespace revokeAllLicenses {
+                        type GET = {
+                            msg: string;
+                        };
+                    }
+                }
             }
-            type PUT = objects.Purchase | {
-                msg?: string;
-            };
-            namespace cancel {
-                type PUT = objects.Purchase;
-            }
-            type DELETE = {
-                msg?: string;
+        }
+        namespace bundle {
+            type POST = {
+                msg: string;
+                Bundle?: objects.Bundle;
             };
-            namespace getFromGateway {
-                type GET = objects.PaymentSystem.PG_Purchase;
+            namespace $bundleId {
+                type GET = objects.Bundle;
+                type PUT = objects.Bundle;
+                type DELETE = {
+                    msg: string;
+                };
+                namespace paymentMethod {
+                    type POST = {
+                        msg: string;
+                        PaymentMethod: objects.PaymentMethod;
+                    };
+                    namespace $paymentMethodId {
+                        type GET = objects.PaymentMethod;
+                        type PUT = objects.PaymentMethod;
+                        type DELETE = {
+                            msg: string;
+                        };
+                    }
+                }
             }
         }
-        namespace purchases {
-            type post_list = {
-                purchases: objects.Purchase[];
-                pagination: {
-                    page: number;
-                    pageSize: number;
-                    count: number;
-                };
-            };
+        namespace bundles {
+            type GET = objects.Bundle[];
         }
         namespace product {
-            type GET = objects.Product;
-            type PUT = objects.Product;
+            type POST = {
+                msg: string;
+                product?: objects.Product;
+            };
+            namespace $productId {
+                type GET = objects.Product;
+                type PUT = objects.Product;
+                type DELETE = {
+                    msg: string;
+                };
+            }
         }
         namespace products {
             type GET = objects.Product[];
+            namespace featured {
+                type GET = objects.Product[];
+            }
         }
-        namespace paymentMethod {
-            type POST = objects.PaymentMethod;
-            type PUT = objects.PaymentMethod;
-            type DELETE = {
-                msg?: string;
+        namespace course {
+            type POST = {
+                msg: string;
+                course?: objects.Course;
             };
+            namespace $courseId {
+                type GET = objects.Course;
+                type PUT = objects.Course;
+                type DELETE = {
+                    msg: string;
+                };
+                namespace teachers {
+                    type GET = objects.Teacher[];
+                }
+                namespace enroll {
+                    type POST = {
+                        msg?: string;
+                        url?: string;
+                    };
+                }
+            }
+        }
+        namespace courses {
+            type GET = objects.Course[];
+            namespace teachers {
+                type GET = objects.Teacher[];
+            }
+            namespace teacher {
+                namespace $teacherId {
+                    type GET = objects.Teacher;
+                }
+            }
+        }
+        namespace consultancy {
+            namespace $consultancyId {
+                type GET = objects.Consultancy;
+            }
+        }
+        namespace consultancies {
+            type GET = objects.Consultancy[];
+            namespace consultors {
+                type GET = objects.Teacher[];
+            }
+            namespace consultor {
+                namespace $consultorId {
+                    type GET = objects.Teacher;
+                }
+            }
         }
         namespace logs {
             type POST_SEARCH = {
@@ -491,6 +663,16 @@ export declare namespace AuthApi {
                 msg?: string;
             };
         }
+        namespace admin {
+            namespace purchases {
+                namespace search {
+                    type POST = {
+                        purchases: objects.Purchase[];
+                        pagination: auxiliarTypes.PaginationInfo;
+                    };
+                }
+            }
+        }
     }
     /**
      * Configuração do Client
@@ -567,22 +749,27 @@ export declare namespace AuthApi {
         checkHealth(): Promise<boolean>;
         users: {
             list: () => Promise<responses.ApiResponse<responses.users.GET>>;
-            get: (userId: number, includePurchases?: boolean) => Promise<responses.ApiResponse<responses.user.GET>>;
+            get: (userId: number, includePurchases?: boolean) => Promise<responses.ApiResponse<responses.user.$userId.GET>>;
             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>>;
+            }) => Promise<responses.ApiResponse<responses.user.$userId.updateConfig.PUT>>;
             updateAdmin: (userId: number, isAdmin: boolean) => Promise<responses.ApiResponse<objects.LocalUser>>;
-            license: (userId: number) => Promise<responses.ApiResponse<responses.user.license.PUT>>;
+            license: {
+                list: (userId: number) => Promise<responses.ApiResponse<responses.user.$userId.licenses.GET>>;
+                get: (userId: number) => Promise<responses.ApiResponse<responses.user.$userId.license.GET>>;
+                release: (userId: number) => Promise<responses.ApiResponse<responses.user.$userId.license.release.POST>>;
+                revokeAll: (userId: number) => Promise<responses.ApiResponse<responses.user.$userId.licenses.revokeAll.POST>>;
+            };
         };
         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<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>>;
+            new: (paymentMethodId: number, userId: number) => Promise<responses.ApiResponse<responses.user.$userId.purchase.POST>>;
+            sync: (purchaseId: number, userId: number, async?: boolean) => Promise<responses.ApiResponse<responses.user.$userId.purchase.$purchaseId.sync.POST>>;
+            update: (userId: number, purchase: objects.Purchase) => Promise<responses.ApiResponse<objects.Purchase>>;
+            cancel: (purchaseId: number, userId: number) => Promise<responses.ApiResponse<responses.user.$userId.purchase.$purchaseId.cancel.POST>>;
+            delete: (purchaseId: number, userId: number) => Promise<responses.ApiResponse<responses.user.$userId.purchase.$purchaseId.DELETE>>;
+            list: (userId: number) => Promise<responses.ApiResponse<responses.user.$userId.purchases.GET>>;
             getFromGateway: (purchaseId: number, userId: number, async?: boolean) => Promise<responses.ApiResponse<objects.PaymentSystem.PG_Purchase>>;
         };
         products: {
@@ -591,9 +778,9 @@ export declare namespace AuthApi {
             update: (productId: number, productData: any) => Promise<responses.ApiResponse<objects.Product>>;
         };
         paymentMethods: {
-            create: (id: number, paymentMethodData: objects.PaymentMethod) => Promise<responses.ApiResponse<objects.PaymentMethod>>;
+            create: (id: number, paymentMethodData: objects.PaymentMethod) => Promise<responses.ApiResponse<responses.bundle.$bundleId.paymentMethod.POST>>;
             update: (id: number, paymentMethodId: number, paymentMethodData: objects.PaymentMethod) => Promise<responses.ApiResponse<objects.PaymentMethod>>;
-            delete: (id: number, paymentMethodId: number) => Promise<responses.ApiResponse<responses.paymentMethod.DELETE>>;
+            delete: (id: number, paymentMethodId: number) => Promise<responses.ApiResponse<responses.bundle.$bundleId.paymentMethod.$paymentMethodId.DELETE>>;
         };
         aux: {
             countries: () => Promise<responses.ApiResponse<responses.aux.countries.GET>>;

package/dist/index.js

@@ -34,6 +34,12 @@ var AuthApi;
             BundleType[BundleType["SYMBOLIC_COURSE"] = 2] = "SYMBOLIC_COURSE";
             BundleType[BundleType["SYMBOLIC_CONSULTANCY"] = 3] = "SYMBOLIC_CONSULTANCY";
         })(BundleType = objects.BundleType || (objects.BundleType = {}));
+        let TeacherType;
+        (function (TeacherType) {
+            TeacherType[TeacherType["DEFAULT_TEACHER"] = 0] = "DEFAULT_TEACHER";
+            TeacherType[TeacherType["AUXILIAR_TEACHER"] = 1] = "AUXILIAR_TEACHER";
+            TeacherType[TeacherType["PARTICIPATION"] = 2] = "PARTICIPATION";
+        })(TeacherType = objects.TeacherType || (objects.TeacherType = {}));
         let PaymentSystem;
         (function (PaymentSystem) {
             let PG_PurchaseLicenseStatus;
@@ -147,13 +153,24 @@ var AuthApi;
                 updateAdmin: async (userId, isAdmin) => {
                     return await this.request('PUT', `user/${userId}/admin`, { isAdmin });
                 },
-                license: async (userId) => {
-                    return await this.request('GET', `user/${userId}/license`, {});
+                license: {
+                    list: async (userId) => {
+                        return await this.request('GET', `user/${userId}/licenses`, {});
+                    },
+                    get: async (userId) => {
+                        return await this.request('GET', `user/${userId}/license`, {});
+                    },
+                    release: async (userId) => {
+                        return await this.request('POST', `user/${userId}/license/release`, {});
+                    },
+                    revokeAll: async (userId) => {
+                        return await this.request('GET', `user/${userId}/licenses/revokeAll`, {});
+                    }
                 }
             };
             this.purchases = {
                 new: async (paymentMethodId, userId) => {
-                    return await this.request('POST', `user/${userId}/purchase/new/${paymentMethodId}`, {});
+                    return await this.request('POST', `user/${userId}/purchase`, { paymentMethodId });
                 },
                 sync: async (purchaseId, userId, async = false) => {
                     return await this.request('POST', `user/${userId}/purchase/${purchaseId}/sync`, { async });
@@ -162,13 +179,13 @@ var AuthApi;
                     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`, {});
+                    return await this.request('POST', `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 });
+                list: async (userId) => {
+                    return await this.request('GET', `user/${userId}/purchases`, {});
                 },
                 getFromGateway: async (purchaseId, userId, async = false) => {
                     return await this.request('GET', `user/${userId}/purchase/${purchaseId}/getFromGateway`, {});
@@ -187,13 +204,13 @@ var AuthApi;
             };
             this.paymentMethods = {
                 create: async (id, paymentMethodData) => {
-                    return await this.request('POST', `bundle/${id}/payment-method`, paymentMethodData);
+                    return await this.request('POST', `bundle/${id}/paymentMethod`, paymentMethodData);
                 },
                 update: async (id, paymentMethodId, paymentMethodData) => {
-                    return await this.request('PUT', `bundle/${id}/payment-method/${paymentMethodId}`, paymentMethodData);
+                    return await this.request('PUT', `bundle/${id}/paymentMethod/${paymentMethodId}`, paymentMethodData);
                 },
                 delete: async (id, paymentMethodId) => {
-                    return await this.request('DELETE', `bundle/${id}/payment-method/${paymentMethodId}`, {});
+                    return await this.request('DELETE', `bundle/${id}/paymentMethod/${paymentMethodId}`, {});
                 }
             };
             this.aux = {

package/package.json

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

package/src/index.ts

@@ -52,6 +52,23 @@ export namespace AuthApi {
             }[];
         }
 
+        export type Teacher = {
+            id: number,
+            fullname: string,
+            resume: string, 
+            email: string, 
+            avatar_l: string,
+            date_c: string,
+            date_r: string | null,
+            active: boolean,
+            notif_newPupil: boolean
+        }
+
+        export enum TeacherType {
+            DEFAULT_TEACHER = 0,
+            AUXILIAR_TEACHER = 1,
+            PARTICIPATION = 2
+        }
         export type Course = {
             id: number;
             type: number;
@@ -76,6 +93,14 @@ export namespace AuthApi {
             email_after?: string;
             date_c: string;
             date_r?: string | null;
+            scholar_courses_teacher?: {
+                id: number,
+                courseID: number,
+                teacherID: number,
+                type: TeacherType,
+                Course?: Course,
+                Teacher?: Teacher
+            }
         }
 
         export type Consultancy = {
@@ -228,6 +253,36 @@ export namespace AuthApi {
             deletedAt: Date | null,
             userID: number
         }
+        export type Session = {
+            id: string,
+            hash?: string,
+            pin1?: string,
+            pin2?: string,
+            trust: boolean,
+            userID: number,
+            User?: LocalUser,
+            ip: string,
+            os: string,
+            browser: string,
+            creation_ts: number,
+            update_ts: number,
+            last_ts: number,
+            active: boolean,
+            data: string,
+            Licenses?: License[]
+        }
+        export type License = {
+            id: number,
+            purchaseID: number,
+            Purchase?: Purchase,
+            levelID: number | null,
+            ProductLevel?: ProductLevel,
+            sessionID: number | null,
+            Session?: MediaSession,
+            got_at: number,
+            renew_at: number,
+            released_at: number | null
+        }
 
         // Tipos para logs do sistema
         export type LogEntry = {
@@ -404,65 +459,183 @@ export namespace AuthApi {
         }
 
         export namespace user {
-            export type GET = objects.LocalUser & { Wallets?: objects.Wallet[]; PurchasesShares?: objects.PurchaseShare[] };
-            export type PUT = objects.LocalUser;
-            
-            export namespace updateConfig {
-                export type PUT = { msg?: string };
-            }
-            export namespace updateAdmin {
+
+            export type POST = objects.LocalUser;
+            export namespace $userId {
+
+                export type GET = objects.LocalUser & { Wallets?: objects.Wallet[]; PurchasesShares?: objects.PurchaseShare[] };
                 export type PUT = objects.LocalUser;
-            }
-            export namespace license {
-                export type PUT = { availableLicenses: number; heldLicenses: number; usedLicenses: number; msg?: string };
-            }
-        }
+                export type DELETE = {msg?:string};
+                
+                export namespace updateConfig {
+                    export type PUT = { msg?: string };
+                }
+                export namespace updateAdmin {
+                    export type PUT = objects.LocalUser;
+                }
+                export namespace license {
+                    // export type PUT = { availableLicenses: number; heldLicenses: number; usedLicenses: number; msg?: string };
+                    export type GET = { msg?: string, license: objects.License}
 
-        export namespace purchase {
-            export namespace create {
-                export type POST = { msg?: string; purchase: objects.Purchase; url?: string };
+                    export namespace release {
+                        export type POST = {msg?:string}
+                    }
+                }
+                export namespace licenses {
+                    export type GET = objects.License[]
+                    export namespace revokeAll {
+                        export type POST = {msg: string}
+                    }
+                }
+    
+                export namespace availableProducts {
+                    export type GET = auxiliarTypes.availableSoftware[]
+                }
+    
+                export namespace purchase {
+
+                    export type POST = { 
+                        msg?: string;
+                        code: number,
+                        purchase?: objects.Purchase;
+                        url?: string
+                    };
+
+                    export namespace $purchaseId {
+                        export type GET = objects.Purchase;
+                        export type PUT = objects.Purchase;
+                        export type DELETE = { msg?: string };
+
+                        export namespace sync {
+                            export type POST = {
+                                msg:string,
+                                purchase?: objects.Purchase
+                            };
+                        }
+                        export namespace getFromGateway {
+                            export type GET = objects.PaymentSystem.PG_Purchase;
+                        }
+                        export namespace cancel {
+                            export type POST = {msg?:string};
+                        }
+
+                    }
+
+                }
+                export namespace purchases {
+    
+                    export type GET = objects.Purchase[];
+
+                    export namespace getByProduct {
+                        export type GET = {
+                            ownPurchases: objects.Purchase[],
+                            sharedPurchases: objects.Purchase[]
+                        }
+                    }
+                }
+
+                export namespace sessions {
+                    export type GET = (objects.Session & {
+                        Licenses: objects.License[]
+                    })[]
+                    export namespace renew {
+                        export type GET = {msg:string}
+                    }
+                    export namespace revokeAllLicenses {
+                        export type GET = {msg:string}
+                    }
+                }
             }
-            export namespace id {
-                export namespace sync {
-                    export type POST = objects.Purchase & { msg?: string };
+        }
+        
+        export namespace bundle {
+            export type POST = {msg:string, Bundle?: objects.Bundle};
+            export namespace $bundleId {
+                export type GET = objects.Bundle;
+                export type PUT = objects.Bundle;
+                export type DELETE = {msg:string};
+
+                export namespace paymentMethod {
+                    export type POST = {msg:string, PaymentMethod: objects.PaymentMethod};
+                    export namespace $paymentMethodId {
+                        export type GET = objects.PaymentMethod;
+                        export type PUT = objects.PaymentMethod;
+                        export type DELETE = {msg:string};
+                    }
                 }
             }
-            export type PUT = objects.Purchase | { msg?: string };
-            export namespace cancel {
-                export type PUT = objects.Purchase;
+        }
+        export namespace bundles {
+            export type GET = objects.Bundle[]
+        }
+        export namespace product {
+            export type POST = {msg:string, product?:objects.Product};
+            export namespace $productId {
+                export type GET = objects.Product;
+                export type PUT = objects.Product;
+                export type DELETE = {msg:string};
             }
-            export type DELETE = { msg?: string };
-            export namespace getFromGateway {
-                export type GET = objects.PaymentSystem.PG_Purchase;
+        }
+        export namespace products {
+            export type GET = objects.Product[];
+            export namespace featured {
+                export type GET = objects.Product[];
             }
         }
 
-        export namespace purchases {
-            export type post_list = {
-                purchases: objects.Purchase[];
-                pagination: {
-                    page: number;
-                    pageSize: number;
-                    count: number;
-                };
-            };
+        export namespace course {
+            export type POST = {msg:string, course?:objects.Course};
+            export namespace $courseId {
+                export type GET = objects.Course;
+                export type PUT = objects.Course;
+                export type DELETE = {msg:string};
+
+                export namespace teachers {
+                    export type GET = objects.Teacher[]
+                }
+                export namespace enroll {
+                    export type POST = {msg?:string, url?: string}
+                }
+            }
         }
+        export namespace courses {
+            export type GET = objects.Course[]
 
-        export namespace product {
-            export type GET = objects.Product;
-            export type PUT = objects.Product;
+            export namespace teachers {
+                export type GET = objects.Teacher[]
+            }
+            export namespace teacher {
+                export namespace $teacherId {
+                    export type GET = objects.Teacher
+                }
+            }
         }
-        export namespace products {
-            
-            export type GET = objects.Product[];
+
+        export namespace consultancy {
+            export namespace $consultancyId {
+                export type GET = objects.Consultancy;
+            }
         }
+        export namespace consultancies {
+
+            export type GET = objects.Consultancy[];
 
-        export namespace paymentMethod {
-            export type POST = objects.PaymentMethod;
-            export type PUT = objects.PaymentMethod;
-            export type DELETE = { msg?: string };
+            export namespace consultors {
+                export type GET = objects.Teacher[];
+            }
+            export namespace consultor {
+                export namespace $consultorId {
+                    export type GET = objects.Teacher;
+                }
+            }
         }
 
+        // export namespace paymentMethod {
+        //     export type POST = objects.PaymentMethod;
+        //     export type PUT = objects.PaymentMethod;
+        //     export type DELETE = { msg?: string };
+        // }
+
         export namespace logs {
 
             export type POST_SEARCH = {
@@ -506,6 +679,14 @@ export namespace AuthApi {
         export namespace report {
             export type POST = { msg?: string };
         }
+
+        export namespace admin {
+            export namespace purchases {
+                export namespace search {
+                    export type POST = {purchases: objects.Purchase[], pagination: auxiliarTypes.PaginationInfo}
+                }
+            }
+        }
     }
 
     /**
@@ -792,43 +973,54 @@ export namespace AuthApi {
                 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}`, {});
+                return await this.request<responses.user.$userId.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);
+                return await this.request<responses.user.$userId.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);
+                return await this.request<responses.user.$userId.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 });
+                return await this.request<responses.user.$userId.updateAdmin.PUT>('PUT', `user/${userId}/admin`, { isAdmin });
             },
-            license: async (userId:number) => {
-                return await this.request<responses.user.license.PUT>('GET', `user/${userId}/license`, {});
+            license: {
+                list: async (userId:number) => {
+                    return await this.request<responses.user.$userId.licenses.GET>('GET', `user/${userId}/licenses`, {});
+                },
+                get: async (userId:number) => {
+                    return await this.request<responses.user.$userId.license.GET>('GET', `user/${userId}/license`, {});
+                },
+                release: async (userId:number) => {
+                    return await this.request<responses.user.$userId.license.release.POST>('POST', `user/${userId}/license/release`, {});
+                },
+                revokeAll: async (userId:number) => {
+                    return await this.request<responses.user.$userId.licenses.revokeAll.POST>('GET', `user/${userId}/licenses/revokeAll`, {});
+                }
             }
         }
 
         public purchases = {
             new: async (paymentMethodId: number, userId: number) => {
-                return await this.request<responses.purchase.create.POST>('POST', `user/${userId}/purchase/new/${paymentMethodId}`, {});
+                return await this.request<responses.user.$userId.purchase.POST>('POST', `user/${userId}/purchase`, {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 });
+                return await this.request<responses.user.$userId.purchase.$purchaseId.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 );
+                return await this.request<responses.user.$userId.purchase.$purchaseId.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`, {} );
+                return await this.request<responses.user.$userId.purchase.$purchaseId.cancel.POST>('POST', `user/${userId}/purchase/${purchaseId}/cancel`, {} );
             },
             delete: async (purchaseId: number, userId: number) => {
-                return await this.request<responses.purchase.DELETE>('DELETE', `user/${userId}/purchase/${purchaseId}`, { });
+                return await this.request<responses.user.$userId.purchase.$purchaseId.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 });
+            list: async (userId: number) => {
+                return await this.request<responses.user.$userId.purchases.GET>('GET', `user/${userId}/purchases`, { });
             },
             getFromGateway: async (purchaseId: number, userId: number, async: boolean = false) => {
-                return await this.request<responses.purchase.getFromGateway.GET>('GET', `user/${userId}/purchase/${purchaseId}/getFromGateway`, {});
+                return await this.request<responses.user.$userId.purchase.$purchaseId.getFromGateway.GET>('GET', `user/${userId}/purchase/${purchaseId}/getFromGateway`, {});
             },
         }
 
@@ -838,23 +1030,23 @@ export namespace AuthApi {
                 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' });
+                return await this.request<responses.product.$productId.GET>('GET', `product/${productId}`, { mode: 'admin' });
             },
             update: async (productId: number, productData: any) => {
-                return await this.request<responses.product.PUT>('PUT', `product/${productId}`, productData);
+                return await this.request<responses.product.$productId.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);
+                return await this.request<responses.bundle.$bundleId.paymentMethod.POST>('POST', `bundle/${id}/paymentMethod`, paymentMethodData);
             },
             update: async (id: number, paymentMethodId: number, paymentMethodData: objects.PaymentMethod) => {
-                return await this.request<responses.paymentMethod.PUT>('PUT', `bundle/${id}/payment-method/${paymentMethodId}`, paymentMethodData);
+                return await this.request<responses.bundle.$bundleId.paymentMethod.$paymentMethodId.PUT>('PUT', `bundle/${id}/paymentMethod/${paymentMethodId}`, paymentMethodData);
             },
             delete: async (id: number, paymentMethodId: number) => {
-                return await this.request<responses.paymentMethod.DELETE>('DELETE', `bundle/${id}/payment-method/${paymentMethodId}`, {});
+                return await this.request<responses.bundle.$bundleId.paymentMethod.$paymentMethodId.DELETE>('DELETE', `bundle/${id}/paymentMethod/${paymentMethodId}`, {});
             }
         }