@vulog/aima-user 1.2.19 → 1.2.21

package/README.md

@@ -14,10 +14,10 @@ npm install @vulog/aima-client @vulog/aima-core @vulog/aima-user
 
 ```javascript
 import { getClient } from '@vulog/aima-client';
-import { 
-    createUser, 
-    findUser, 
-    getUserById, 
+import {
+    createUser,
+    findUser,
+    getUserById,
     updateUser,
     createBusinessProfile,
     getFleetBillingGroups
@@ -186,6 +186,17 @@ const result = await assignBillingGroup(client, {
 });
 ```
 
+#### unassignBillingGroup
+
+Unassign a user to a billing group.
+
+```javascript
+const result = await unassignBillingGroup(client, {
+    entityId: 'user-uuid-here',
+    billingGroupId: 'billing-group-id-here'
+});
+```
+
 ### Terms and Conditions
 
 #### acceptTAndC
@@ -219,7 +230,7 @@ const result = await setServicesStatus(client, {
 
 #### registerUserToService
 
-Register a user entity to a specific service it's optional if the service is public (users are subscribed by default to public services). but mandatory to be able to book on a private service. 
+Register a user entity to a specific service it's optional if the service is public (users are subscribed by default to public services). but mandatory to be able to book on a private service.
 
 ```javascript
 await registerUserToService(client, 'entity-uuid-here', 'service-uuid-here');
@@ -299,10 +310,10 @@ All functions include validation using Zod schemas and will throw appropriate er
 
 ```javascript
 import { getClient } from '@vulog/aima-client';
-import { 
-    createUser, 
-    findUser, 
-    getUserById, 
+import {
+    createUser,
+    findUser,
+    getUserById,
     updateUser,
     createBusinessProfile,
     getFleetBillingGroups
@@ -329,26 +340,26 @@ async function userManagementWorkflow() {
             marketingConsent: true,
             phoneNumber: '+1234567890'
         });
-        
+
         console.log('User created:', newUser);
-        
+
         // Find user by email
         const foundUsers = await findUser(client, {
             email: 'jane.doe@example.com'
         });
         console.log('Found users:', foundUsers);
-        
+
         // Get user by ID
         const user = await getUserById(client, newUser.id);
         console.log('User details:', user);
-        
+
         // Update user
         const updatedUser = await updateUser(client, newUser.id, {
             phoneNumber: '+0987654321',
             locale: 'fr_FR'
         });
         console.log('User updated:', updatedUser);
-        
+
         // Create business profile
         const businessProfile = await createBusinessProfile(client, {
             entityId: newUser.id,
@@ -362,11 +373,11 @@ async function userManagementWorkflow() {
             }
         });
         console.log('Business profile created:', businessProfile);
-        
+
         // Get billing groups
         const billingGroups = await getFleetBillingGroups(client);
         console.log('Billing groups:', billingGroups);
-        
+
         return { newUser, updatedUser, businessProfile, billingGroups };
     } catch (error) {
         console.error('User management error:', error);
@@ -382,19 +393,19 @@ async function searchUsers(client, searchTerm) {
     try {
         // Search by email
         const emailResults = await findUser(client, { email: searchTerm });
-        
+
         // Search by username
         const usernameResults = await findUser(client, { userName: searchTerm });
-        
+
         // Search by phone number
         const phoneResults = await findUser(client, { phoneNumber: searchTerm });
-        
+
         // Combine and deduplicate results
         const allResults = [...emailResults, ...usernameResults, ...phoneResults];
-        const uniqueResults = allResults.filter((user, index, self) => 
+        const uniqueResults = allResults.filter((user, index, self) =>
             index === self.findIndex(u => u.id === user.id)
         );
-        
+
         console.log(`Found ${uniqueResults.length} unique users for "${searchTerm}"`);
         return uniqueResults;
     } catch (error) {
@@ -412,13 +423,13 @@ async function analyzeUsers(client) {
         // This would require a function to get all users
         // For now, we'll demonstrate with individual user lookups
         const sampleUserIds = ['user1', 'user2', 'user3']; // Replace with actual IDs
-        
+
         const users = await Promise.all(
             sampleUserIds.map(id => getUserById(client, id).catch(() => null))
         );
-        
+
         const validUsers = users.filter(user => user !== null);
-        
+
         const analysis = {
             totalUsers: validUsers.length,
             activeUsers: validUsers.filter(u => u.status === 'ACTIVE').length,
@@ -434,7 +445,7 @@ async function analyzeUsers(client) {
                 return acc;
             }, {})
         };
-        
+
         console.log('User Analysis:');
         console.log(`Total Users: ${analysis.totalUsers}`);
         console.log(`Active: ${analysis.activeUsers}`);
@@ -442,11 +453,11 @@ async function analyzeUsers(client) {
         console.log(`Suspended: ${analysis.suspendedUsers}`);
         console.log('Consent Stats:', analysis.consentStats);
         console.log('Locale Distribution:', analysis.localeDistribution);
-        
+
         return analysis;
     } catch (error) {
         console.error('User analysis error:', error);
         throw error;
     }
 }
-```
+```

package/dist/index.d.mts

@@ -7,6 +7,8 @@ declare const acceptTAndC: (client: Client, userId: string, cityId: string) => P
 
 declare const assignBillingGroup: (client: Client, entityId: string, billingGroupId: string) => Promise<void>;
 
+declare const unassignBillingGroup: (client: Client, entityId: string, billingGroupId: string) => Promise<void>;
+
 type Address = {
     streetName?: string;
     city?: string;
@@ -300,4 +302,4 @@ type UserSort = z.infer<typeof sortSchema>;
 type UserFilters = z.infer<typeof userFiltersSchema>;
 declare const getUsers: (client: Client, options?: PaginableOptions<UserFilters, UserSort>) => Promise<PaginableResponse<UserStatus>>;
 
-export { type AccountStatus, type Address, type BillingGroup, type CreateBusinessProfile, type CreateUser, type CreateUserOptions, type Entity, type FiscalInformation, type IndividualBusiness, type Label, type PersonalCompany, type PersonalInformationBirth, type PersonalInformationIdentity, type PersonalInformationProfile, type PersonalInformationProfileType, type PersonalInformationUser, type PersonalInformationUserType, type Profile, type ProfilePaths, type ProfileServiceRegistration, type ProfileStatus, type ProfileType, type ResponseFind, type SearchType, type ServiceRegistrationWithReason, type ServiceStatus, type ServicesRegistrationList, type ServicesUpdate, type User, type UserAgreement, type UserFilters, type UserFull, type UserPaths, type UserProfile, type UserServiceRegistration, type UserSort, type UserStatus, type UserUpdateBody, acceptTAndC, accountStatus, addLabelForUser, assignBillingGroup, createBusinessProfile, createUser, findUser, getEntity, getFleetBillingGroups, getLabelsForUser, getProfilePersonalInfoById, getRegistrationOverview, getUserById, getUserPersonalInfoById, getUsers, getUsersByIds, getUsersPIByIds, personalInformationProfileTypeSchema, personalInformationProfileTypes, personalInformationUserPaths, personalInformationUserTypeSchema, personalInformationUserTypes, registerUserToService, removeLabelForUser, setServicesStatus, updateProfilePersonalInfo, updateUser, updateUserPersonalInfo };
+export { type AccountStatus, type Address, type BillingGroup, type CreateBusinessProfile, type CreateUser, type CreateUserOptions, type Entity, type FiscalInformation, type IndividualBusiness, type Label, type PersonalCompany, type PersonalInformationBirth, type PersonalInformationIdentity, type PersonalInformationProfile, type PersonalInformationProfileType, type PersonalInformationUser, type PersonalInformationUserType, type Profile, type ProfilePaths, type ProfileServiceRegistration, type ProfileStatus, type ProfileType, type ResponseFind, type SearchType, type ServiceRegistrationWithReason, type ServiceStatus, type ServicesRegistrationList, type ServicesUpdate, type User, type UserAgreement, type UserFilters, type UserFull, type UserPaths, type UserProfile, type UserServiceRegistration, type UserSort, type UserStatus, type UserUpdateBody, acceptTAndC, accountStatus, addLabelForUser, assignBillingGroup, createBusinessProfile, createUser, findUser, getEntity, getFleetBillingGroups, getLabelsForUser, getProfilePersonalInfoById, getRegistrationOverview, getUserById, getUserPersonalInfoById, getUsers, getUsersByIds, getUsersPIByIds, personalInformationProfileTypeSchema, personalInformationProfileTypes, personalInformationUserPaths, personalInformationUserTypeSchema, personalInformationUserTypes, registerUserToService, removeLabelForUser, setServicesStatus, unassignBillingGroup, updateProfilePersonalInfo, updateUser, updateUserPersonalInfo };

package/dist/index.d.ts

@@ -7,6 +7,8 @@ declare const acceptTAndC: (client: Client, userId: string, cityId: string) => P
 
 declare const assignBillingGroup: (client: Client, entityId: string, billingGroupId: string) => Promise<void>;
 
+declare const unassignBillingGroup: (client: Client, entityId: string, billingGroupId: string) => Promise<void>;
+
 type Address = {
     streetName?: string;
     city?: string;
@@ -300,4 +302,4 @@ type UserSort = z.infer<typeof sortSchema>;
 type UserFilters = z.infer<typeof userFiltersSchema>;
 declare const getUsers: (client: Client, options?: PaginableOptions<UserFilters, UserSort>) => Promise<PaginableResponse<UserStatus>>;
 
-export { type AccountStatus, type Address, type BillingGroup, type CreateBusinessProfile, type CreateUser, type CreateUserOptions, type Entity, type FiscalInformation, type IndividualBusiness, type Label, type PersonalCompany, type PersonalInformationBirth, type PersonalInformationIdentity, type PersonalInformationProfile, type PersonalInformationProfileType, type PersonalInformationUser, type PersonalInformationUserType, type Profile, type ProfilePaths, type ProfileServiceRegistration, type ProfileStatus, type ProfileType, type ResponseFind, type SearchType, type ServiceRegistrationWithReason, type ServiceStatus, type ServicesRegistrationList, type ServicesUpdate, type User, type UserAgreement, type UserFilters, type UserFull, type UserPaths, type UserProfile, type UserServiceRegistration, type UserSort, type UserStatus, type UserUpdateBody, acceptTAndC, accountStatus, addLabelForUser, assignBillingGroup, createBusinessProfile, createUser, findUser, getEntity, getFleetBillingGroups, getLabelsForUser, getProfilePersonalInfoById, getRegistrationOverview, getUserById, getUserPersonalInfoById, getUsers, getUsersByIds, getUsersPIByIds, personalInformationProfileTypeSchema, personalInformationProfileTypes, personalInformationUserPaths, personalInformationUserTypeSchema, personalInformationUserTypes, registerUserToService, removeLabelForUser, setServicesStatus, updateProfilePersonalInfo, updateUser, updateUserPersonalInfo };
+export { type AccountStatus, type Address, type BillingGroup, type CreateBusinessProfile, type CreateUser, type CreateUserOptions, type Entity, type FiscalInformation, type IndividualBusiness, type Label, type PersonalCompany, type PersonalInformationBirth, type PersonalInformationIdentity, type PersonalInformationProfile, type PersonalInformationProfileType, type PersonalInformationUser, type PersonalInformationUserType, type Profile, type ProfilePaths, type ProfileServiceRegistration, type ProfileStatus, type ProfileType, type ResponseFind, type SearchType, type ServiceRegistrationWithReason, type ServiceStatus, type ServicesRegistrationList, type ServicesUpdate, type User, type UserAgreement, type UserFilters, type UserFull, type UserPaths, type UserProfile, type UserServiceRegistration, type UserSort, type UserStatus, type UserUpdateBody, acceptTAndC, accountStatus, addLabelForUser, assignBillingGroup, createBusinessProfile, createUser, findUser, getEntity, getFleetBillingGroups, getLabelsForUser, getProfilePersonalInfoById, getRegistrationOverview, getUserById, getUserPersonalInfoById, getUsers, getUsersByIds, getUsersPIByIds, personalInformationProfileTypeSchema, personalInformationProfileTypes, personalInformationUserPaths, personalInformationUserTypeSchema, personalInformationUserTypes, registerUserToService, removeLabelForUser, setServicesStatus, unassignBillingGroup, updateProfilePersonalInfo, updateUser, updateUserPersonalInfo };

package/dist/index.js

@@ -45,6 +45,7 @@ __export(index_exports, {
   registerUserToService: () => registerUserToService,
   removeLabelForUser: () => removeLabelForUser,
   setServicesStatus: () => setServicesStatus,
+  unassignBillingGroup: () => unassignBillingGroup,
   updateProfilePersonalInfo: () => updateProfilePersonalInfo,
   updateUser: () => updateUser,
   updateUserPersonalInfo: () => updateUserPersonalInfo
@@ -87,16 +88,34 @@ var assignBillingGroup = async (client, entityId, billingGroupId) => {
   );
 };
 
-// src/createBusinessProfile.ts
+// src/unassignBillingGroup.ts
 var import_zod3 = require("zod");
-var createBusinessProfileSchema = import_zod3.z.object({
-  userId: import_zod3.z.string().nonempty().uuid(),
-  businessId: import_zod3.z.string().nonempty().uuid(),
-  data: import_zod3.z.object({
-    emailConsent: import_zod3.z.boolean(),
-    email: import_zod3.z.string().email(),
-    requestId: import_zod3.z.string().nonempty().uuid(),
-    costCenterId: import_zod3.z.string().uuid().nullish()
+var schema3 = import_zod3.z.object({
+  entityId: import_zod3.z.string().trim().min(1).uuid(),
+  billingGroupId: import_zod3.z.string().trim().min(1).uuid()
+});
+var unassignBillingGroup = async (client, entityId, billingGroupId) => {
+  const result = schema3.safeParse({ entityId, billingGroupId });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  await client.delete(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/billingGroup/${billingGroupId}/entities/${entityId}`
+  );
+};
+
+// src/createBusinessProfile.ts
+var import_zod4 = require("zod");
+var createBusinessProfileSchema = import_zod4.z.object({
+  userId: import_zod4.z.string().nonempty().uuid(),
+  businessId: import_zod4.z.string().nonempty().uuid(),
+  data: import_zod4.z.object({
+    emailConsent: import_zod4.z.boolean(),
+    email: import_zod4.z.string().email(),
+    requestId: import_zod4.z.string().nonempty().uuid(),
+    costCenterId: import_zod4.z.string().uuid().nullish()
   })
 });
 var createBusinessProfile = async (client, userId, businessId, data) => {
@@ -117,20 +136,20 @@ var createBusinessProfile = async (client, userId, businessId, data) => {
 };
 
 // src/createUser.ts
-var import_zod4 = require("zod");
-var createUserSchema = import_zod4.z.object({
-  userName: import_zod4.z.string().min(1),
-  password: import_zod4.z.string().min(1),
-  locale: import_zod4.z.string().length(5),
-  email: import_zod4.z.string().min(1).email(),
-  dataPrivacyConsent: import_zod4.z.boolean().optional(),
-  profilingConsent: import_zod4.z.boolean().optional(),
-  marketingConsent: import_zod4.z.boolean().optional(),
-  phoneNumber: import_zod4.z.string().optional()
+var import_zod5 = require("zod");
+var createUserSchema = import_zod5.z.object({
+  userName: import_zod5.z.string().min(1),
+  password: import_zod5.z.string().min(1),
+  locale: import_zod5.z.string().length(5),
+  email: import_zod5.z.string().min(1).email(),
+  dataPrivacyConsent: import_zod5.z.boolean().optional(),
+  profilingConsent: import_zod5.z.boolean().optional(),
+  marketingConsent: import_zod5.z.boolean().optional(),
+  phoneNumber: import_zod5.z.string().optional()
 });
-var createUserOptionsSchema = import_zod4.z.object({
-  tcApproval: import_zod4.z.boolean().default(true),
-  skipUserNotification: import_zod4.z.boolean().default(false)
+var createUserOptionsSchema = import_zod5.z.object({
+  tcApproval: import_zod5.z.boolean().default(true),
+  skipUserNotification: import_zod5.z.boolean().default(false)
 }).default({
   tcApproval: true,
   skipUserNotification: false
@@ -158,10 +177,10 @@ var createUser = async (client, user, option) => {
 };
 
 // src/findUser.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/types.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var accountStatus = ["INCOMPLETE", "PENDING", "APPROVED", "REJECTED", "SUSPENDED", "ARCHIVED"];
 var personalInformationUserTypes = [
   "IDENTITY",
@@ -210,16 +229,16 @@ var personalInformationUserPaths = [
   "/address/addressAdditionalInformation",
   "/membership"
 ];
-var personalInformationUserTypeSchema = import_zod5.z.enum(personalInformationUserTypes);
+var personalInformationUserTypeSchema = import_zod6.z.enum(personalInformationUserTypes);
 var personalInformationProfileTypes = ["ID_NUMBER", "PHONE_NUMBER", "EMAIL", "BILLING_ADDRESS"];
-var personalInformationProfileTypeSchema = import_zod5.z.enum(personalInformationProfileTypes);
+var personalInformationProfileTypeSchema = import_zod6.z.enum(personalInformationProfileTypes);
 
 // src/findUser.ts
 var searchTypes = ["email", "username", "phoneNumber"];
-var querySchema = import_zod6.z.object({
-  searchType: import_zod6.z.enum(searchTypes),
-  searchQuery: import_zod6.z.string().min(1),
-  types: import_zod6.z.array(personalInformationUserTypeSchema).min(1)
+var querySchema = import_zod7.z.object({
+  searchType: import_zod7.z.enum(searchTypes),
+  searchQuery: import_zod7.z.string().min(1),
+  types: import_zod7.z.array(personalInformationUserTypeSchema).min(1)
 });
 var findUser = async (client, searchType, searchQuery, types) => {
   const result = querySchema.safeParse({
@@ -241,11 +260,11 @@ var findUser = async (client, searchType, searchQuery, types) => {
 };
 
 // src/getProfilePersonalInfoById.ts
-var import_zod7 = require("zod");
-var argsSchema = import_zod7.z.object({
-  userId: import_zod7.z.string().trim().min(1).uuid(),
-  profileId: import_zod7.z.string().trim().min(1).uuid(),
-  types: import_zod7.z.array(personalInformationProfileTypeSchema).min(1)
+var import_zod8 = require("zod");
+var argsSchema = import_zod8.z.object({
+  userId: import_zod8.z.string().trim().min(1).uuid(),
+  profileId: import_zod8.z.string().trim().min(1).uuid(),
+  types: import_zod8.z.array(personalInformationProfileTypeSchema).min(1)
 });
 var getProfilePersonalInfoById = async (client, userId, profileId, types) => {
   const result = argsSchema.safeParse({ userId, profileId, types });
@@ -260,9 +279,9 @@ var getProfilePersonalInfoById = async (client, userId, profileId, types) => {
 };
 
 // src/getRegistrationOverview.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var getRegistrationOverview = async (client, userId) => {
-  const result = import_zod8.z.string().uuid().safeParse(userId);
+  const result = import_zod9.z.string().uuid().safeParse(userId);
   if (!result.success) {
     throw new TypeError("Invalid userId", {
       cause: result.error.issues
@@ -272,9 +291,9 @@ var getRegistrationOverview = async (client, userId) => {
 };
 
 // src/getUserById.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var getUserById = async (client, id, addAccountStatus = false) => {
-  const result = import_zod9.z.string().trim().min(1).uuid().safeParse(id);
+  const result = import_zod10.z.string().trim().min(1).uuid().safeParse(id);
   if (!result.success) {
     throw new TypeError("Invalid id", {
       cause: result.error.issues
@@ -288,10 +307,10 @@ var getUserById = async (client, id, addAccountStatus = false) => {
 };
 
 // src/getUserPersonalInfoById.ts
-var import_zod10 = require("zod");
-var argsSchema2 = import_zod10.z.object({
-  id: import_zod10.z.string().trim().min(1).uuid(),
-  types: import_zod10.z.array(personalInformationUserTypeSchema).min(1)
+var import_zod11 = require("zod");
+var argsSchema2 = import_zod11.z.object({
+  id: import_zod11.z.string().trim().min(1).uuid(),
+  types: import_zod11.z.array(personalInformationUserTypeSchema).min(1)
 });
 var getUserPersonalInfoById = async (client, id, types) => {
   const result = argsSchema2.safeParse({ id, types });
@@ -306,10 +325,10 @@ var getUserPersonalInfoById = async (client, id, types) => {
 };
 
 // src/getUsersPIByIds.ts
-var import_zod11 = require("zod");
-var argsSchema3 = import_zod11.z.object({
-  ids: import_zod11.z.array(import_zod11.z.string().trim().min(1).uuid()).min(1),
-  types: import_zod11.z.array(personalInformationUserTypeSchema).min(1)
+var import_zod12 = require("zod");
+var argsSchema3 = import_zod12.z.object({
+  ids: import_zod12.z.array(import_zod12.z.string().trim().min(1).uuid()).min(1),
+  types: import_zod12.z.array(personalInformationUserTypeSchema).min(1)
 });
 var getUsersPIByIds = async (client, ids, types) => {
   const result = argsSchema3.safeParse({ ids, types });
@@ -327,16 +346,16 @@ var getUsersPIByIds = async (client, ids, types) => {
 };
 
 // src/label.ts
-var import_zod12 = require("zod");
-var schema3 = import_zod12.z.object({
-  userId: import_zod12.z.string().uuid()
+var import_zod13 = require("zod");
+var schema4 = import_zod13.z.object({
+  userId: import_zod13.z.string().uuid()
 });
-var schemaData = import_zod12.z.object({
-  userId: import_zod12.z.string().uuid(),
-  labelId: import_zod12.z.number().positive()
+var schemaData = import_zod13.z.object({
+  userId: import_zod13.z.string().uuid(),
+  labelId: import_zod13.z.number().positive()
 });
 var getLabelsForUser = async (client, userId) => {
-  const result = schema3.safeParse({ userId });
+  const result = schema4.safeParse({ userId });
   if (!result.success) {
     throw new TypeError("Invalid args", {
       cause: result.error.issues
@@ -368,27 +387,27 @@ var removeLabelForUser = async (client, userId, labelId) => {
 };
 
 // src/setServicesStatus.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 var registrationStatus = ["APPROVED", "INCOMPLETE", "PENDING", "REJECTED", "SUSPENDED", "UNREGISTERED"];
-var schema4 = import_zod13.z.object({
-  disableEmailNotification: import_zod13.z.boolean(),
-  operatorProfileId: import_zod13.z.string().uuid(),
-  actions: import_zod13.z.array(
-    import_zod13.z.object({
-      reasonForChange: import_zod13.z.string(),
-      serviceId: import_zod13.z.string().uuid(),
-      status: import_zod13.z.enum(registrationStatus)
+var schema5 = import_zod14.z.object({
+  disableEmailNotification: import_zod14.z.boolean(),
+  operatorProfileId: import_zod14.z.string().uuid(),
+  actions: import_zod14.z.array(
+    import_zod14.z.object({
+      reasonForChange: import_zod14.z.string(),
+      serviceId: import_zod14.z.string().uuid(),
+      status: import_zod14.z.enum(registrationStatus)
     })
   ).min(1)
 });
 var setServicesStatus = async (client, profileId, servicesUpdate) => {
-  const resultProfileId = import_zod13.z.string().uuid().safeParse(profileId);
+  const resultProfileId = import_zod14.z.string().uuid().safeParse(profileId);
   if (!resultProfileId.success) {
     throw new TypeError("Invalid profileId", {
       cause: resultProfileId.error.issues
     });
   }
-  const resultServices = schema4.safeParse(servicesUpdate);
+  const resultServices = schema5.safeParse(servicesUpdate);
   if (!resultServices.success) {
     throw new TypeError("Invalid servicesUpdate", {
       cause: resultServices.error.issues
@@ -401,15 +420,15 @@ var setServicesStatus = async (client, profileId, servicesUpdate) => {
 };
 
 // src/registerUserToService.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 var registerUserToService = async (client, entityId, serviceId) => {
-  const resultEntityId = import_zod14.z.string().uuid().safeParse(entityId);
+  const resultEntityId = import_zod15.z.string().uuid().safeParse(entityId);
   if (!resultEntityId.success) {
     throw new TypeError("Invalid entityId", {
       cause: resultEntityId.error.issues
     });
   }
-  const resultServiceId = import_zod14.z.string().uuid().safeParse(serviceId);
+  const resultServiceId = import_zod15.z.string().uuid().safeParse(serviceId);
   if (!resultServiceId.success) {
     throw new TypeError("Invalid serviceId", {
       cause: resultServiceId.error.issues
@@ -421,27 +440,27 @@ var registerUserToService = async (client, entityId, serviceId) => {
 };
 
 // src/updateProfilePersonalInfo.ts
-var import_zod15 = require("zod");
+var import_zod16 = require("zod");
 var paths = ["/phoneNumber", "/email", "/idNumber"];
-var schema5 = import_zod15.z.object({
-  userId: import_zod15.z.string().trim().min(1).uuid(),
-  profileId: import_zod15.z.string().trim().min(1).uuid(),
-  actions: import_zod15.z.array(
-    import_zod15.z.union([
-      import_zod15.z.object({
-        op: import_zod15.z.enum(["add", "replace"]),
-        path: import_zod15.z.enum(paths),
-        value: import_zod15.z.string().min(1)
+var schema6 = import_zod16.z.object({
+  userId: import_zod16.z.string().trim().min(1).uuid(),
+  profileId: import_zod16.z.string().trim().min(1).uuid(),
+  actions: import_zod16.z.array(
+    import_zod16.z.union([
+      import_zod16.z.object({
+        op: import_zod16.z.enum(["add", "replace"]),
+        path: import_zod16.z.enum(paths),
+        value: import_zod16.z.string().min(1)
       }),
-      import_zod15.z.object({
-        op: import_zod15.z.literal("remove"),
-        path: import_zod15.z.enum(paths)
+      import_zod16.z.object({
+        op: import_zod16.z.literal("remove"),
+        path: import_zod16.z.enum(paths)
       })
     ])
   ).min(1)
 });
 var updateProfilePersonalInfo = async (client, userId, profileId, actions) => {
-  const result = schema5.safeParse({ userId, profileId, actions });
+  const result = schema6.safeParse({ userId, profileId, actions });
   if (!result.success) {
     throw new TypeError("Invalid args", {
       cause: result.error.issues
@@ -459,22 +478,22 @@ var updateProfilePersonalInfo = async (client, userId, profileId, actions) => {
 };
 
 // src/updateUser.ts
-var import_zod16 = require("zod");
-var schema6 = import_zod16.z.object({
-  id: import_zod16.z.string().trim().min(1).uuid(),
-  user: import_zod16.z.object({
-    locale: import_zod16.z.string(),
-    accountStatus: import_zod16.z.enum(accountStatus),
-    dataPrivacyConsent: import_zod16.z.boolean(),
-    marketingConsent: import_zod16.z.boolean(),
-    surveyConsent: import_zod16.z.boolean(),
-    shareDataConsent: import_zod16.z.boolean(),
-    profilingConsent: import_zod16.z.boolean(),
-    membershipNumber: import_zod16.z.string()
+var import_zod17 = require("zod");
+var schema7 = import_zod17.z.object({
+  id: import_zod17.z.string().trim().min(1).uuid(),
+  user: import_zod17.z.object({
+    locale: import_zod17.z.string(),
+    accountStatus: import_zod17.z.enum(accountStatus),
+    dataPrivacyConsent: import_zod17.z.boolean(),
+    marketingConsent: import_zod17.z.boolean(),
+    surveyConsent: import_zod17.z.boolean(),
+    shareDataConsent: import_zod17.z.boolean(),
+    profilingConsent: import_zod17.z.boolean(),
+    membershipNumber: import_zod17.z.string()
   }).partial()
 });
 var updateUser = async (client, id, user) => {
-  const result = schema6.safeParse({ id, user });
+  const result = schema7.safeParse({ id, user });
   if (!result.success) {
     throw new TypeError("Invalid args", {
       cause: result.error.issues
@@ -484,25 +503,25 @@ var updateUser = async (client, id, user) => {
 };
 
 // src/updateUserPersonalInfo.ts
-var import_zod17 = require("zod");
-var schema7 = import_zod17.z.object({
-  userId: import_zod17.z.string().trim().min(1).uuid(),
-  actions: import_zod17.z.array(
-    import_zod17.z.union([
-      import_zod17.z.object({
-        op: import_zod17.z.enum(["add", "replace"]),
-        path: import_zod17.z.enum(personalInformationUserPaths),
-        value: import_zod17.z.string().min(1)
+var import_zod18 = require("zod");
+var schema8 = import_zod18.z.object({
+  userId: import_zod18.z.string().trim().min(1).uuid(),
+  actions: import_zod18.z.array(
+    import_zod18.z.union([
+      import_zod18.z.object({
+        op: import_zod18.z.enum(["add", "replace"]),
+        path: import_zod18.z.enum(personalInformationUserPaths),
+        value: import_zod18.z.string().min(1)
       }),
-      import_zod17.z.object({
-        op: import_zod17.z.literal("remove"),
-        path: import_zod17.z.enum(personalInformationUserPaths)
+      import_zod18.z.object({
+        op: import_zod18.z.literal("remove"),
+        path: import_zod18.z.enum(personalInformationUserPaths)
       })
     ])
   ).min(1)
 });
 var updateUserPersonalInfo = async (client, userId, actions) => {
-  const result = schema7.safeParse({ userId, actions });
+  const result = schema8.safeParse({ userId, actions });
   if (!result.success) {
     throw new TypeError("Invalid args", {
       cause: result.error.issues
@@ -516,9 +535,9 @@ var updateUserPersonalInfo = async (client, userId, actions) => {
 };
 
 // src/getEntity.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 var getEntity = async (client, entityId) => {
-  const result = import_zod18.z.string().trim().min(1).uuid().safeParse(entityId);
+  const result = import_zod19.z.string().trim().min(1).uuid().safeParse(entityId);
   if (!result.success) {
     throw new TypeError("Invalid entity id", {
       cause: result.error.issues
@@ -558,9 +577,9 @@ var getFleetBillingGroups = async (client, options) => {
 };
 
 // src/getUsersByIds.ts
-var import_zod19 = require("zod");
-var argsSchema4 = import_zod19.z.object({
-  ids: import_zod19.z.array(import_zod19.z.string().trim().min(1).uuid()).min(1)
+var import_zod20 = require("zod");
+var argsSchema4 = import_zod20.z.object({
+  ids: import_zod20.z.array(import_zod20.z.string().trim().min(1).uuid()).min(1)
 });
 var getUsersByIds = async (client, ids) => {
   const result = argsSchema4.safeParse({ ids });
@@ -574,15 +593,15 @@ var getUsersByIds = async (client, ids) => {
 
 // src/getUsers.ts
 var import_aima_core2 = require("@vulog/aima-core");
-var import_zod20 = require("zod");
-var statusSchema = import_zod20.z.enum(["PENDING", "INCOMPLETE", "SUSPENDED", "REJECTED", "APPROVED"]);
-var profileTypeSchema = import_zod20.z.enum(["Single", "Business"]);
-var userFiltersSchema = import_zod20.z.object({
+var import_zod21 = require("zod");
+var statusSchema = import_zod21.z.enum(["PENDING", "INCOMPLETE", "SUSPENDED", "REJECTED", "APPROVED"]);
+var profileTypeSchema = import_zod21.z.enum(["Single", "Business"]);
+var userFiltersSchema = import_zod21.z.object({
   status: statusSchema.optional(),
   profileType: profileTypeSchema.optional(),
-  serviceId: import_zod20.z.string().uuid().optional()
+  serviceId: import_zod21.z.string().uuid().optional()
 });
-var sortSchema = import_zod20.z.enum(["registrationDate", "userName", "firstName", "lastName", "updateDate"]);
+var sortSchema = import_zod21.z.enum(["registrationDate", "userName", "firstName", "lastName", "updateDate"]);
 var getUsers = async (client, options) => {
   const paginableOptionsSchema = (0, import_aima_core2.createPaginableOptionsSchema)(
     userFiltersSchema.default({}),
@@ -642,6 +661,7 @@ var getUsers = async (client, options) => {
   registerUserToService,
   removeLabelForUser,
   setServicesStatus,
+  unassignBillingGroup,
   updateProfilePersonalInfo,
   updateUser,
   updateUserPersonalInfo

package/dist/index.mjs

@@ -34,16 +34,34 @@ var assignBillingGroup = async (client, entityId, billingGroupId) => {
   );
 };
 
-// src/createBusinessProfile.ts
+// src/unassignBillingGroup.ts
 import { z as z3 } from "zod";
-var createBusinessProfileSchema = z3.object({
-  userId: z3.string().nonempty().uuid(),
-  businessId: z3.string().nonempty().uuid(),
-  data: z3.object({
-    emailConsent: z3.boolean(),
-    email: z3.string().email(),
-    requestId: z3.string().nonempty().uuid(),
-    costCenterId: z3.string().uuid().nullish()
+var schema3 = z3.object({
+  entityId: z3.string().trim().min(1).uuid(),
+  billingGroupId: z3.string().trim().min(1).uuid()
+});
+var unassignBillingGroup = async (client, entityId, billingGroupId) => {
+  const result = schema3.safeParse({ entityId, billingGroupId });
+  if (!result.success) {
+    throw new TypeError("Invalid args", {
+      cause: result.error.issues
+    });
+  }
+  await client.delete(
+    `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/billingGroup/${billingGroupId}/entities/${entityId}`
+  );
+};
+
+// src/createBusinessProfile.ts
+import { z as z4 } from "zod";
+var createBusinessProfileSchema = z4.object({
+  userId: z4.string().nonempty().uuid(),
+  businessId: z4.string().nonempty().uuid(),
+  data: z4.object({
+    emailConsent: z4.boolean(),
+    email: z4.string().email(),
+    requestId: z4.string().nonempty().uuid(),
+    costCenterId: z4.string().uuid().nullish()
   })
 });
 var createBusinessProfile = async (client, userId, businessId, data) => {
@@ -64,20 +82,20 @@ var createBusinessProfile = async (client, userId, businessId, data) => {
 };
 
 // src/createUser.ts
-import { z as z4 } from "zod";
-var createUserSchema = z4.object({
-  userName: z4.string().min(1),
-  password: z4.string().min(1),
-  locale: z4.string().length(5),
-  email: z4.string().min(1).email(),
-  dataPrivacyConsent: z4.boolean().optional(),
-  profilingConsent: z4.boolean().optional(),
-  marketingConsent: z4.boolean().optional(),
-  phoneNumber: z4.string().optional()
+import { z as z5 } from "zod";
+var createUserSchema = z5.object({
+  userName: z5.string().min(1),
+  password: z5.string().min(1),
+  locale: z5.string().length(5),
+  email: z5.string().min(1).email(),
+  dataPrivacyConsent: z5.boolean().optional(),
+  profilingConsent: z5.boolean().optional(),
+  marketingConsent: z5.boolean().optional(),
+  phoneNumber: z5.string().optional()
 });
-var createUserOptionsSchema = z4.object({
-  tcApproval: z4.boolean().default(true),
-  skipUserNotification: z4.boolean().default(false)
+var createUserOptionsSchema = z5.object({
+  tcApproval: z5.boolean().default(true),
+  skipUserNotification: z5.boolean().default(false)
 }).default({
   tcApproval: true,
   skipUserNotification: false
@@ -105,10 +123,10 @@ var createUser = async (client, user, option) => {
 };
 
 // src/findUser.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/types.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var accountStatus = ["INCOMPLETE", "PENDING", "APPROVED", "REJECTED", "SUSPENDED", "ARCHIVED"];
 var personalInformationUserTypes = [
   "IDENTITY",
@@ -157,16 +175,16 @@ var personalInformationUserPaths = [
   "/address/addressAdditionalInformation",
   "/membership"
 ];
-var personalInformationUserTypeSchema = z5.enum(personalInformationUserTypes);
+var personalInformationUserTypeSchema = z6.enum(personalInformationUserTypes);
 var personalInformationProfileTypes = ["ID_NUMBER", "PHONE_NUMBER", "EMAIL", "BILLING_ADDRESS"];
-var personalInformationProfileTypeSchema = z5.enum(personalInformationProfileTypes);
+var personalInformationProfileTypeSchema = z6.enum(personalInformationProfileTypes);
 
 // src/findUser.ts
 var searchTypes = ["email", "username", "phoneNumber"];
-var querySchema = z6.object({
-  searchType: z6.enum(searchTypes),
-  searchQuery: z6.string().min(1),
-  types: z6.array(personalInformationUserTypeSchema).min(1)
+var querySchema = z7.object({
+  searchType: z7.enum(searchTypes),
+  searchQuery: z7.string().min(1),
+  types: z7.array(personalInformationUserTypeSchema).min(1)
 });
 var findUser = async (client, searchType, searchQuery, types) => {
   const result = querySchema.safeParse({
@@ -188,11 +206,11 @@ var findUser = async (client, searchType, searchQuery, types) => {
 };
 
 // src/getProfilePersonalInfoById.ts
-import { z as z7 } from "zod";
-var argsSchema = z7.object({
-  userId: z7.string().trim().min(1).uuid(),
-  profileId: z7.string().trim().min(1).uuid(),
-  types: z7.array(personalInformationProfileTypeSchema).min(1)
+import { z as z8 } from "zod";
+var argsSchema = z8.object({
+  userId: z8.string().trim().min(1).uuid(),
+  profileId: z8.string().trim().min(1).uuid(),
+  types: z8.array(personalInformationProfileTypeSchema).min(1)
 });
 var getProfilePersonalInfoById = async (client, userId, profileId, types) => {
   const result = argsSchema.safeParse({ userId, profileId, types });
@@ -207,9 +225,9 @@ var getProfilePersonalInfoById = async (client, userId, profileId, types) => {
 };
 
 // src/getRegistrationOverview.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var getRegistrationOverview = async (client, userId) => {
-  const result = z8.string().uuid().safeParse(userId);
+  const result = z9.string().uuid().safeParse(userId);
   if (!result.success) {
     throw new TypeError("Invalid userId", {
       cause: result.error.issues
@@ -219,9 +237,9 @@ var getRegistrationOverview = async (client, userId) => {
 };
 
 // src/getUserById.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var getUserById = async (client, id, addAccountStatus = false) => {
-  const result = z9.string().trim().min(1).uuid().safeParse(id);
+  const result = z10.string().trim().min(1).uuid().safeParse(id);
   if (!result.success) {
     throw new TypeError("Invalid id", {
       cause: result.error.issues
@@ -235,10 +253,10 @@ var getUserById = async (client, id, addAccountStatus = false) => {
 };
 
 // src/getUserPersonalInfoById.ts
-import { z as z10 } from "zod";
-var argsSchema2 = z10.object({
-  id: z10.string().trim().min(1).uuid(),
-  types: z10.array(personalInformationUserTypeSchema).min(1)
+import { z as z11 } from "zod";
+var argsSchema2 = z11.object({
+  id: z11.string().trim().min(1).uuid(),
+  types: z11.array(personalInformationUserTypeSchema).min(1)
 });
 var getUserPersonalInfoById = async (client, id, types) => {
   const result = argsSchema2.safeParse({ id, types });
@@ -253,10 +271,10 @@ var getUserPersonalInfoById = async (client, id, types) => {
 };
 
 // src/getUsersPIByIds.ts
-import { z as z11 } from "zod";
-var argsSchema3 = z11.object({
-  ids: z11.array(z11.string().trim().min(1).uuid()).min(1),
-  types: z11.array(personalInformationUserTypeSchema).min(1)
+import { z as z12 } from "zod";
+var argsSchema3 = z12.object({
+  ids: z12.array(z12.string().trim().min(1).uuid()).min(1),
+  types: z12.array(personalInformationUserTypeSchema).min(1)
 });
 var getUsersPIByIds = async (client, ids, types) => {
   const result = argsSchema3.safeParse({ ids, types });
@@ -274,16 +292,16 @@ var getUsersPIByIds = async (client, ids, types) => {
 };
 
 // src/label.ts
-import { z as z12 } from "zod";
-var schema3 = z12.object({
-  userId: z12.string().uuid()
+import { z as z13 } from "zod";
+var schema4 = z13.object({
+  userId: z13.string().uuid()
 });
-var schemaData = z12.object({
-  userId: z12.string().uuid(),
-  labelId: z12.number().positive()
+var schemaData = z13.object({
+  userId: z13.string().uuid(),
+  labelId: z13.number().positive()
 });
 var getLabelsForUser = async (client, userId) => {
-  const result = schema3.safeParse({ userId });
+  const result = schema4.safeParse({ userId });
   if (!result.success) {
     throw new TypeError("Invalid args", {
       cause: result.error.issues
@@ -315,27 +333,27 @@ var removeLabelForUser = async (client, userId, labelId) => {
 };
 
 // src/setServicesStatus.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var registrationStatus = ["APPROVED", "INCOMPLETE", "PENDING", "REJECTED", "SUSPENDED", "UNREGISTERED"];
-var schema4 = z13.object({
-  disableEmailNotification: z13.boolean(),
-  operatorProfileId: z13.string().uuid(),
-  actions: z13.array(
-    z13.object({
-      reasonForChange: z13.string(),
-      serviceId: z13.string().uuid(),
-      status: z13.enum(registrationStatus)
+var schema5 = z14.object({
+  disableEmailNotification: z14.boolean(),
+  operatorProfileId: z14.string().uuid(),
+  actions: z14.array(
+    z14.object({
+      reasonForChange: z14.string(),
+      serviceId: z14.string().uuid(),
+      status: z14.enum(registrationStatus)
     })
   ).min(1)
 });
 var setServicesStatus = async (client, profileId, servicesUpdate) => {
-  const resultProfileId = z13.string().uuid().safeParse(profileId);
+  const resultProfileId = z14.string().uuid().safeParse(profileId);
   if (!resultProfileId.success) {
     throw new TypeError("Invalid profileId", {
       cause: resultProfileId.error.issues
     });
   }
-  const resultServices = schema4.safeParse(servicesUpdate);
+  const resultServices = schema5.safeParse(servicesUpdate);
   if (!resultServices.success) {
     throw new TypeError("Invalid servicesUpdate", {
       cause: resultServices.error.issues
@@ -348,15 +366,15 @@ var setServicesStatus = async (client, profileId, servicesUpdate) => {
 };
 
 // src/registerUserToService.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var registerUserToService = async (client, entityId, serviceId) => {
-  const resultEntityId = z14.string().uuid().safeParse(entityId);
+  const resultEntityId = z15.string().uuid().safeParse(entityId);
   if (!resultEntityId.success) {
     throw new TypeError("Invalid entityId", {
       cause: resultEntityId.error.issues
     });
   }
-  const resultServiceId = z14.string().uuid().safeParse(serviceId);
+  const resultServiceId = z15.string().uuid().safeParse(serviceId);
   if (!resultServiceId.success) {
     throw new TypeError("Invalid serviceId", {
       cause: resultServiceId.error.issues
@@ -368,27 +386,27 @@ var registerUserToService = async (client, entityId, serviceId) => {
 };
 
 // src/updateProfilePersonalInfo.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var paths = ["/phoneNumber", "/email", "/idNumber"];
-var schema5 = z15.object({
-  userId: z15.string().trim().min(1).uuid(),
-  profileId: z15.string().trim().min(1).uuid(),
-  actions: z15.array(
-    z15.union([
-      z15.object({
-        op: z15.enum(["add", "replace"]),
-        path: z15.enum(paths),
-        value: z15.string().min(1)
+var schema6 = z16.object({
+  userId: z16.string().trim().min(1).uuid(),
+  profileId: z16.string().trim().min(1).uuid(),
+  actions: z16.array(
+    z16.union([
+      z16.object({
+        op: z16.enum(["add", "replace"]),
+        path: z16.enum(paths),
+        value: z16.string().min(1)
       }),
-      z15.object({
-        op: z15.literal("remove"),
-        path: z15.enum(paths)
+      z16.object({
+        op: z16.literal("remove"),
+        path: z16.enum(paths)
       })
     ])
   ).min(1)
 });
 var updateProfilePersonalInfo = async (client, userId, profileId, actions) => {
-  const result = schema5.safeParse({ userId, profileId, actions });
+  const result = schema6.safeParse({ userId, profileId, actions });
   if (!result.success) {
     throw new TypeError("Invalid args", {
       cause: result.error.issues
@@ -406,22 +424,22 @@ var updateProfilePersonalInfo = async (client, userId, profileId, actions) => {
 };
 
 // src/updateUser.ts
-import { z as z16 } from "zod";
-var schema6 = z16.object({
-  id: z16.string().trim().min(1).uuid(),
-  user: z16.object({
-    locale: z16.string(),
-    accountStatus: z16.enum(accountStatus),
-    dataPrivacyConsent: z16.boolean(),
-    marketingConsent: z16.boolean(),
-    surveyConsent: z16.boolean(),
-    shareDataConsent: z16.boolean(),
-    profilingConsent: z16.boolean(),
-    membershipNumber: z16.string()
+import { z as z17 } from "zod";
+var schema7 = z17.object({
+  id: z17.string().trim().min(1).uuid(),
+  user: z17.object({
+    locale: z17.string(),
+    accountStatus: z17.enum(accountStatus),
+    dataPrivacyConsent: z17.boolean(),
+    marketingConsent: z17.boolean(),
+    surveyConsent: z17.boolean(),
+    shareDataConsent: z17.boolean(),
+    profilingConsent: z17.boolean(),
+    membershipNumber: z17.string()
   }).partial()
 });
 var updateUser = async (client, id, user) => {
-  const result = schema6.safeParse({ id, user });
+  const result = schema7.safeParse({ id, user });
   if (!result.success) {
     throw new TypeError("Invalid args", {
       cause: result.error.issues
@@ -431,25 +449,25 @@ var updateUser = async (client, id, user) => {
 };
 
 // src/updateUserPersonalInfo.ts
-import { z as z17 } from "zod";
-var schema7 = z17.object({
-  userId: z17.string().trim().min(1).uuid(),
-  actions: z17.array(
-    z17.union([
-      z17.object({
-        op: z17.enum(["add", "replace"]),
-        path: z17.enum(personalInformationUserPaths),
-        value: z17.string().min(1)
+import { z as z18 } from "zod";
+var schema8 = z18.object({
+  userId: z18.string().trim().min(1).uuid(),
+  actions: z18.array(
+    z18.union([
+      z18.object({
+        op: z18.enum(["add", "replace"]),
+        path: z18.enum(personalInformationUserPaths),
+        value: z18.string().min(1)
       }),
-      z17.object({
-        op: z17.literal("remove"),
-        path: z17.enum(personalInformationUserPaths)
+      z18.object({
+        op: z18.literal("remove"),
+        path: z18.enum(personalInformationUserPaths)
       })
     ])
   ).min(1)
 });
 var updateUserPersonalInfo = async (client, userId, actions) => {
-  const result = schema7.safeParse({ userId, actions });
+  const result = schema8.safeParse({ userId, actions });
   if (!result.success) {
     throw new TypeError("Invalid args", {
       cause: result.error.issues
@@ -463,9 +481,9 @@ var updateUserPersonalInfo = async (client, userId, actions) => {
 };
 
 // src/getEntity.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var getEntity = async (client, entityId) => {
-  const result = z18.string().trim().min(1).uuid().safeParse(entityId);
+  const result = z19.string().trim().min(1).uuid().safeParse(entityId);
   if (!result.success) {
     throw new TypeError("Invalid entity id", {
       cause: result.error.issues
@@ -505,9 +523,9 @@ var getFleetBillingGroups = async (client, options) => {
 };
 
 // src/getUsersByIds.ts
-import { z as z19 } from "zod";
-var argsSchema4 = z19.object({
-  ids: z19.array(z19.string().trim().min(1).uuid()).min(1)
+import { z as z20 } from "zod";
+var argsSchema4 = z20.object({
+  ids: z20.array(z20.string().trim().min(1).uuid()).min(1)
 });
 var getUsersByIds = async (client, ids) => {
   const result = argsSchema4.safeParse({ ids });
@@ -521,15 +539,15 @@ var getUsersByIds = async (client, ids) => {
 
 // src/getUsers.ts
 import { createPaginableOptionsSchema as createPaginableOptionsSchema2 } from "@vulog/aima-core";
-import { z as z20 } from "zod";
-var statusSchema = z20.enum(["PENDING", "INCOMPLETE", "SUSPENDED", "REJECTED", "APPROVED"]);
-var profileTypeSchema = z20.enum(["Single", "Business"]);
-var userFiltersSchema = z20.object({
+import { z as z21 } from "zod";
+var statusSchema = z21.enum(["PENDING", "INCOMPLETE", "SUSPENDED", "REJECTED", "APPROVED"]);
+var profileTypeSchema = z21.enum(["Single", "Business"]);
+var userFiltersSchema = z21.object({
   status: statusSchema.optional(),
   profileType: profileTypeSchema.optional(),
-  serviceId: z20.string().uuid().optional()
+  serviceId: z21.string().uuid().optional()
 });
-var sortSchema = z20.enum(["registrationDate", "userName", "firstName", "lastName", "updateDate"]);
+var sortSchema = z21.enum(["registrationDate", "userName", "firstName", "lastName", "updateDate"]);
 var getUsers = async (client, options) => {
   const paginableOptionsSchema = createPaginableOptionsSchema2(
     userFiltersSchema.default({}),
@@ -588,6 +606,7 @@ export {
   registerUserToService,
   removeLabelForUser,
   setServicesStatus,
+  unassignBillingGroup,
   updateProfilePersonalInfo,
   updateUser,
   updateUserPersonalInfo

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vulog/aima-user",
-    "version": "1.2.19",
+    "version": "1.2.21",
     "main": "dist/index.js",
     "module": "dist/index.mjs",
     "types": "dist/index.d.ts",
@@ -19,9 +19,9 @@
     "author": "Vulog",
     "license": "MIT",
     "dependencies": {
-        "@vulog/aima-client": "1.2.19",
-        "@vulog/aima-config": "1.2.19",
-        "@vulog/aima-core": "1.2.19"
+        "@vulog/aima-client": "1.2.21",
+        "@vulog/aima-config": "1.2.21",
+        "@vulog/aima-core": "1.2.21"
     },
     "peerDependencies": {
         "zod": "^3.25.76"

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './acceptTAndC';
 export * from './assignBillingGroup';
+export * from './unassignBillingGroup';
 export * from './createBusinessProfile';
 export * from './createUser';
 export * from './findUser';

package/src/unassignBillingGroup.ts

@@ -0,0 +1,19 @@
+import { Client } from '@vulog/aima-client';
+import { z } from 'zod';
+
+const schema = z.object({
+    entityId: z.string().trim().min(1).uuid(),
+    billingGroupId: z.string().trim().min(1).uuid(),
+});
+
+export const unassignBillingGroup = async (client: Client, entityId: string, billingGroupId: string): Promise<void> => {
+    const result = schema.safeParse({ entityId, billingGroupId });
+    if (!result.success) {
+        throw new TypeError('Invalid args', {
+            cause: result.error.issues,
+        });
+    }
+    await client.delete(
+        `/boapi/proxy/user/fleets/${client.clientOptions.fleetId}/billingGroup/${billingGroupId}/entities/${entityId}`
+    );
+};