@flipdish/authorization 0.0.5-rc.1756734017 → 0.0.5-rc.1766099001

package/api.ts

@@ -30,7 +30,7 @@ import { BASE_PATH, COLLECTION_FORMATS, BaseAPI, RequiredError, operationServerM
  */
 export interface AssignRoleRequestBody {
     /**
-     * Role to assign to the principal choose from: OrgViewer, OrgManager, OrgAdmin, BrandViewer, BrandManager, BrandAdmin, StoreViewer, StoreEditor, StoreManager, CustomerViewer, CustomerManager, VoucherViewer, VoucherEditor, VoucherManager, VoucherCampaignManager, VoucherStatisticsViewer, AnalyticsViewer, ReportsViewer, FinanceViewer, FinanceManager, TeamViewer, TeamManager, TeamAdmin, TechViewer, TechManager, AppStoreViewer, AppStoreManager, SalesChannelViewer, SalesChannelEditor, SalesChannelManager, DeliveryViewer, DeliveryManager, DriverManager, AuditViewer, AuditManager, AccountsViewer, AccountsEditor, DocumentExplorerViewer, DocumentExplorerEditor, PayrollViewer, PayrollEditor, PropertyViewer, PropertyManager, PropertyAdmin, WebsiteContentEditor, WebsiteContentViewer, WebsiteTechViewer, MenuViewer, MenuEditor, MenuManager, MenuMetaFieldManager, MenuMetaFieldEditor, MenuMetaFieldViewer, StoreDeliveryZoneManager, StoreDeliveryZoneEditor, StoreDeliveryZoneViewer, OrderFulfillmentManager, OrderManager, OrderEditor, OrderViewer, InventoryManager, InventoryEditor, InventoryViewer, PaymentManager, OnboardingManager, FeatureFlagManager, PropertyOwnerMisc, ManagedOwnerMisc, IntegratorMisc, PropertyManagerMisc, FinanceManagerMisc, SupportMisc
+     * 
      * @type {string}
      * @memberof AssignRoleRequestBody
      */
@@ -47,6 +47,12 @@ export interface AssignRoleRequestBody {
      * @memberof AssignRoleRequestBody
      */
     'principal': AuthorizationRequestPrincipal;
+    /**
+     * 
+     * @type {string}
+     * @memberof AssignRoleRequestBody
+     */
+    'brandId': string;
 }
 
 export const AssignRoleRequestBodyRoleEnum = {
@@ -147,10 +153,10 @@ export interface AssignRoleSuccessResponse {
 export interface AuthenticateAndAuthorizeRequest {
     /**
      * Incoming request headers to be used for authentication
-     * @type {{ [key: string]: any; }}
+     * @type {{ [key: string]: string; }}
      * @memberof AuthenticateAndAuthorizeRequest
      */
-    'headers': { [key: string]: any; };
+    'headers': { [key: string]: string; };
     /**
      * 
      * @type {AuthorizationRequestAction}
@@ -163,7 +169,21 @@ export interface AuthenticateAndAuthorizeRequest {
      * @memberof AuthenticateAndAuthorizeRequest
      */
     'resource'?: AuthorizationRequestResource;
+    /**
+     * How to check authorisation - any or all of the actions must be allowed
+     * @type {string}
+     * @memberof AuthenticateAndAuthorizeRequest
+     */
+    'checkMode'?: AuthenticateAndAuthorizeRequestCheckModeEnum;
 }
+
+export const AuthenticateAndAuthorizeRequestCheckModeEnum = {
+    Any: 'any',
+    All: 'all'
+} as const;
+
+export type AuthenticateAndAuthorizeRequestCheckModeEnum = typeof AuthenticateAndAuthorizeRequestCheckModeEnum[keyof typeof AuthenticateAndAuthorizeRequestCheckModeEnum];
+
 /**
  * Response containing the authentication and authorization decision
  * @export
@@ -172,10 +192,10 @@ export interface AuthenticateAndAuthorizeRequest {
 export interface AuthenticateAndAuthorizeResponse {
     /**
      * 
-     * @type {AuthenticateAndAuthorizeResponseAuthentication}
+     * @type {AuthenticateAndCheckIsInRoleResponseAuthentication}
      * @memberof AuthenticateAndAuthorizeResponse
      */
-    'authentication': AuthenticateAndAuthorizeResponseAuthentication;
+    'authentication': AuthenticateAndCheckIsInRoleResponseAuthentication;
     /**
      * 
      * @type {AuthorizationResponse}
@@ -186,30 +206,166 @@ export interface AuthenticateAndAuthorizeResponse {
 /**
  * 
  * @export
- * @interface AuthenticateAndAuthorizeResponseAuthentication
+ * @interface AuthenticateAndCheckIsInRoleRequest
+ */
+export interface AuthenticateAndCheckIsInRoleRequest {
+    /**
+     * Incoming request headers to be used for authentication
+     * @type {{ [key: string]: string; }}
+     * @memberof AuthenticateAndCheckIsInRoleRequest
+     */
+    'headers': { [key: string]: string; };
+    /**
+     * Array of roles to check if the principal is in
+     * @type {Array<RoleNames>}
+     * @memberof AuthenticateAndCheckIsInRoleRequest
+     */
+    'roles': Array<RoleNames>;
+    /**
+     * 
+     * @type {string}
+     * @memberof AuthenticateAndCheckIsInRoleRequest
+     */
+    'checkMode'?: AuthenticateAndCheckIsInRoleRequestCheckModeEnum;
+}
+
+export const AuthenticateAndCheckIsInRoleRequestCheckModeEnum = {
+    Any: 'any',
+    All: 'all'
+} as const;
+
+export type AuthenticateAndCheckIsInRoleRequestCheckModeEnum = typeof AuthenticateAndCheckIsInRoleRequestCheckModeEnum[keyof typeof AuthenticateAndCheckIsInRoleRequestCheckModeEnum];
+
+/**
+ * Response containing whether the principal is in any/all of the roles
+ * @export
+ * @interface AuthenticateAndCheckIsInRoleResponse
+ */
+export interface AuthenticateAndCheckIsInRoleResponse {
+    /**
+     * 
+     * @type {AuthenticateAndCheckIsInRoleResponseAuthentication}
+     * @memberof AuthenticateAndCheckIsInRoleResponse
+     */
+    'authentication': AuthenticateAndCheckIsInRoleResponseAuthentication;
+    /**
+     * result of the check - whether the principal is in any/all of the roles
+     * @type {boolean}
+     * @memberof AuthenticateAndCheckIsInRoleResponse
+     */
+    'authorized': boolean;
+}
+/**
+ * 
+ * @export
+ * @interface AuthenticateAndCheckIsInRoleResponseAuthentication
  */
-export interface AuthenticateAndAuthorizeResponseAuthentication {
+export interface AuthenticateAndCheckIsInRoleResponseAuthentication {
     /**
      * 
      * @type {AuthorizationRequestPrincipal}
-     * @memberof AuthenticateAndAuthorizeResponseAuthentication
+     * @memberof AuthenticateAndCheckIsInRoleResponseAuthentication
      */
     'principal': AuthorizationRequestPrincipal;
     /**
      * Whether the user is authenticated
      * @type {boolean}
-     * @memberof AuthenticateAndAuthorizeResponseAuthentication
+     * @memberof AuthenticateAndCheckIsInRoleResponseAuthentication
      */
     'authenticated': boolean;
     /**
      * The reason for the authentication failure
      * @type {string}
-     * @memberof AuthenticateAndAuthorizeResponseAuthentication
+     * @memberof AuthenticateAndCheckIsInRoleResponseAuthentication
      */
     'reason'?: string;
 }
 /**
- * Request to check if a user is authorized to perform an action(s). If you pass in an array of permissions, you will receive a single allow / deny response (based on an AND of the result for each permission). For a granular response to multiple permissions, call the /authorize/batch endpoint. 
+ * 
+ * @export
+ * @interface AuthorizationBatchRequest
+ */
+export interface AuthorizationBatchRequest {
+    /**
+     * 
+     * @type {AuthorizationRequestPrincipal}
+     * @memberof AuthorizationBatchRequest
+     */
+    'principal': AuthorizationRequestPrincipal;
+    /**
+     * 
+     * @type {Permissions}
+     * @memberof AuthorizationBatchRequest
+     */
+    'action': Permissions;
+    /**
+     * Array of resources to check authorisation for
+     * @type {Array<AuthorizationRequestResource>}
+     * @memberof AuthorizationBatchRequest
+     */
+    'resources': Array<AuthorizationRequestResource>;
+}
+
+
+/**
+ * 
+ * @export
+ * @interface AuthorizationBatchResponse
+ */
+export interface AuthorizationBatchResponse {
+    /**
+     * Array of allowed resources
+     * @type {Array<AuthorizationBatchResponseAllowedResourcesInner>}
+     * @memberof AuthorizationBatchResponse
+     */
+    'allowedResources': Array<AuthorizationBatchResponseAllowedResourcesInner>;
+    /**
+     * Array of denied resources
+     * @type {Array<AuthorizationBatchResponseAllowedResourcesInner>}
+     * @memberof AuthorizationBatchResponse
+     */
+    'deniedResources': Array<AuthorizationBatchResponseAllowedResourcesInner>;
+}
+/**
+ * 
+ * @export
+ * @interface AuthorizationBatchResponseAllowedResourcesInner
+ */
+export interface AuthorizationBatchResponseAllowedResourcesInner {
+    /**
+     * The authorization decision
+     * @type {string}
+     * @memberof AuthorizationBatchResponseAllowedResourcesInner
+     */
+    'decision': string;
+    /**
+     * Whether the action is allowed
+     * @type {boolean}
+     * @memberof AuthorizationBatchResponseAllowedResourcesInner
+     */
+    'allowed': boolean;
+    /**
+     * The policy IDs that were used to make the decision
+     * @type {Array<string>}
+     * @memberof AuthorizationBatchResponseAllowedResourcesInner
+     */
+    'policyIds': Array<string>;
+    /**
+     * 
+     * @type {AuthorizationBatchResponseAllowedResourcesInnerResource}
+     * @memberof AuthorizationBatchResponseAllowedResourcesInner
+     */
+    'resource': AuthorizationBatchResponseAllowedResourcesInnerResource;
+}
+/**
+ * @type AuthorizationBatchResponseAllowedResourcesInnerResource
+ * Resource that the action was checked for
+ * @export
+ */
+export type AuthorizationBatchResponseAllowedResourcesInnerResource = AuthorizationRequestResourceOneOf | AuthorizationRequestResourceOneOf1 | AuthorizationRequestResourceOneOf2 | AuthorizationRequestResourceOneOf3;
+
+/**
+ * Request to check if a user is authorized to perform an action(s). If you pass in an array of permissions, you will receive a single allow / deny response (based on the checkMode - any or all of the permissions must be allowed). 
  * @export
  * @interface AuthorizationRequest
  */
@@ -232,9 +388,23 @@ export interface AuthorizationRequest {
      * @memberof AuthorizationRequest
      */
     'resource'?: AuthorizationRequestResource;
+    /**
+     * How to check authorisation - any or all of the actions must be allowed
+     * @type {string}
+     * @memberof AuthorizationRequest
+     */
+    'checkMode'?: AuthorizationRequestCheckModeEnum;
 }
+
+export const AuthorizationRequestCheckModeEnum = {
+    Any: 'any',
+    All: 'all'
+} as const;
+
+export type AuthorizationRequestCheckModeEnum = typeof AuthorizationRequestCheckModeEnum[keyof typeof AuthorizationRequestCheckModeEnum];
+
 /**
- * 
+ * Permission or array of permissions - note that you still only receive a single allow / deny response (calculated based on the checkMode)
  * @export
  * @interface AuthorizationRequestAction
  */
@@ -434,17 +604,206 @@ export interface ErrorResponse {
     'message': string;
 }
 /**
- * Successful permissions retrieval response
+ * Feature based role and its permissions
+ * @export
+ * @interface FeatureBasedRole
+ */
+export interface FeatureBasedRole {
+    /**
+     * Name of the role
+     * @type {string}
+     * @memberof FeatureBasedRole
+     */
+    'name': string;
+    /**
+     * 
+     * @type {Permissions & Array<Permissions>}
+     * @memberof FeatureBasedRole
+     */
+    'permissions': Permissions & Array<Permissions>;
+}
+/**
+ * Request to get authorized brands for a principal or the authenticated user based on the headers. Either principal or headers must be provided, but not both. If both are provided, the principal will be used.
+ * @export
+ * @interface GetAuthorizedBrandsRequest
+ */
+export interface GetAuthorizedBrandsRequest {
+    /**
+     * 
+     * @type {GetAuthorizedOrgsRequestPrincipal}
+     * @memberof GetAuthorizedBrandsRequest
+     */
+    'principal'?: GetAuthorizedOrgsRequestPrincipal;
+    /**
+     * Incoming request headers to be used for authentication
+     * @type {{ [key: string]: string; }}
+     * @memberof GetAuthorizedBrandsRequest
+     */
+    'headers'?: { [key: string]: string; };
+    /**
+     * 
+     * @type {Permissions}
+     * @memberof GetAuthorizedBrandsRequest
+     */
+    'action': Permissions;
+}
+
+
+/**
+ * Response containing the authorized brands
+ * @export
+ * @interface GetAuthorizedBrandsResponse
+ */
+export interface GetAuthorizedBrandsResponse {
+    /**
+     * Array of allowed resources
+     * @type {Array<AuthorizationBatchResponseAllowedResourcesInner>}
+     * @memberof GetAuthorizedBrandsResponse
+     */
+    'allowedResources': Array<AuthorizationBatchResponseAllowedResourcesInner>;
+    /**
+     * Array of denied resources
+     * @type {Array<AuthorizationBatchResponseAllowedResourcesInner>}
+     * @memberof GetAuthorizedBrandsResponse
+     */
+    'deniedResources': Array<AuthorizationBatchResponseAllowedResourcesInner>;
+}
+/**
+ * Request to get authorized orgs for a principal or the authenticated user based on the headers. Either principal or headers must be provided, but not both. If both are provided, the principal will be used.
+ * @export
+ * @interface GetAuthorizedOrgsRequest
+ */
+export interface GetAuthorizedOrgsRequest {
+    /**
+     * 
+     * @type {GetAuthorizedOrgsRequestPrincipal}
+     * @memberof GetAuthorizedOrgsRequest
+     */
+    'principal'?: GetAuthorizedOrgsRequestPrincipal;
+    /**
+     * Incoming request headers to be used for authentication
+     * @type {{ [key: string]: string; }}
+     * @memberof GetAuthorizedOrgsRequest
+     */
+    'headers'?: { [key: string]: string; };
+    /**
+     * 
+     * @type {Permissions}
+     * @memberof GetAuthorizedOrgsRequest
+     */
+    'action': Permissions;
+}
+
+
+/**
+ * The principal to get authorized entities for
+ * @export
+ * @interface GetAuthorizedOrgsRequestPrincipal
+ */
+export interface GetAuthorizedOrgsRequestPrincipal {
+    /**
+     * 
+     * @type {string}
+     * @memberof GetAuthorizedOrgsRequestPrincipal
+     */
+    'type': GetAuthorizedOrgsRequestPrincipalTypeEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof GetAuthorizedOrgsRequestPrincipal
+     */
+    'id': string;
+    /**
+     * 
+     * @type {string}
+     * @memberof GetAuthorizedOrgsRequestPrincipal
+     */
+    'name'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof GetAuthorizedOrgsRequestPrincipal
+     */
+    'email'?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof GetAuthorizedOrgsRequestPrincipal
+     */
+    'phone'?: string;
+}
+
+export const GetAuthorizedOrgsRequestPrincipalTypeEnum = {
+    User: 'User',
+    Automation: 'Automation'
+} as const;
+
+export type GetAuthorizedOrgsRequestPrincipalTypeEnum = typeof GetAuthorizedOrgsRequestPrincipalTypeEnum[keyof typeof GetAuthorizedOrgsRequestPrincipalTypeEnum];
+
+/**
+ * Response containing the authorized orgs
+ * @export
+ * @interface GetAuthorizedOrgsResponse
+ */
+export interface GetAuthorizedOrgsResponse {
+    /**
+     * Array of allowed resources
+     * @type {Array<AuthorizationBatchResponseAllowedResourcesInner>}
+     * @memberof GetAuthorizedOrgsResponse
+     */
+    'allowedResources': Array<AuthorizationBatchResponseAllowedResourcesInner>;
+    /**
+     * Array of denied resources
+     * @type {Array<AuthorizationBatchResponseAllowedResourcesInner>}
+     * @memberof GetAuthorizedOrgsResponse
+     */
+    'deniedResources': Array<AuthorizationBatchResponseAllowedResourcesInner>;
+}
+/**
+ * Request to get authorized properties for a principal or the authenticated user based on the headers. Either principal or headers must be provided, but not both. If both are provided, the principal will be used.
  * @export
- * @interface GetPermissionsSuccessResponse
+ * @interface GetAuthorizedPropertiesRequest
  */
-export interface GetPermissionsSuccessResponse {
+export interface GetAuthorizedPropertiesRequest {
+    /**
+     * 
+     * @type {GetAuthorizedOrgsRequestPrincipal}
+     * @memberof GetAuthorizedPropertiesRequest
+     */
+    'principal'?: GetAuthorizedOrgsRequestPrincipal;
+    /**
+     * Incoming request headers to be used for authentication
+     * @type {{ [key: string]: string; }}
+     * @memberof GetAuthorizedPropertiesRequest
+     */
+    'headers'?: { [key: string]: string; };
     /**
      * 
-     * @type {Permissions & Array<string>}
-     * @memberof GetPermissionsSuccessResponse
+     * @type {Permissions}
+     * @memberof GetAuthorizedPropertiesRequest
+     */
+    'action': Permissions;
+}
+
+
+/**
+ * Response containing the authorized properties
+ * @export
+ * @interface GetAuthorizedPropertiesResponse
+ */
+export interface GetAuthorizedPropertiesResponse {
+    /**
+     * Array of allowed resources
+     * @type {Array<AuthorizationBatchResponseAllowedResourcesInner>}
+     * @memberof GetAuthorizedPropertiesResponse
+     */
+    'allowedResources': Array<AuthorizationBatchResponseAllowedResourcesInner>;
+    /**
+     * Array of denied resources
+     * @type {Array<AuthorizationBatchResponseAllowedResourcesInner>}
+     * @memberof GetAuthorizedPropertiesResponse
      */
-    'permissions': Permissions & Array<string>;
+    'deniedResources': Array<AuthorizationBatchResponseAllowedResourcesInner>;
 }
 /**
  * Details for getting roles for a principal
@@ -491,11 +850,17 @@ export interface GetPrincipalRolesSuccessResponseRolesInner {
      */
     'policyId': string;
     /**
-     * Role name
+     * 
+     * @type {GetPrincipalRolesSuccessResponseRolesInnerRoleName}
+     * @memberof GetPrincipalRolesSuccessResponseRolesInner
+     */
+    'roleName': GetPrincipalRolesSuccessResponseRolesInnerRoleName;
+    /**
+     * Policy type
      * @type {string}
      * @memberof GetPrincipalRolesSuccessResponseRolesInner
      */
-    'roleName': GetPrincipalRolesSuccessResponseRolesInnerRoleNameEnum;
+    'policyType': GetPrincipalRolesSuccessResponseRolesInnerPolicyTypeEnum;
     /**
      * Date and time the role was assigned
      * @type {string}
@@ -513,7 +878,7 @@ export interface GetPrincipalRolesSuccessResponseRolesInner {
      * @type {string}
      * @memberof GetPrincipalRolesSuccessResponseRolesInner
      */
-    'resourceType': GetPrincipalRolesSuccessResponseRolesInnerResourceTypeEnum;
+    'resourceType'?: GetPrincipalRolesSuccessResponseRolesInnerResourceTypeEnum;
     /**
      * Organization ID
      * @type {string}
@@ -538,38 +903,229 @@ export interface GetPrincipalRolesSuccessResponseRolesInner {
      * @memberof GetPrincipalRolesSuccessResponseRolesInner
      */
     'salesChannelId'?: string;
+    /**
+     * Principal ID this role is assigned to
+     * @type {string}
+     * @memberof GetPrincipalRolesSuccessResponseRolesInner
+     */
+    'principalId': string;
+    /**
+     * Type of principal this role is assigned to
+     * @type {string}
+     * @memberof GetPrincipalRolesSuccessResponseRolesInner
+     */
+    'principalType': GetPrincipalRolesSuccessResponseRolesInnerPrincipalTypeEnum;
 }
 
-export const GetPrincipalRolesSuccessResponseRolesInnerRoleNameEnum = {
-    OrgViewer: 'OrgViewer',
-    OrgManager: 'OrgManager',
-    OrgAdmin: 'OrgAdmin',
-    BrandViewer: 'BrandViewer',
-    BrandManager: 'BrandManager',
-    BrandAdmin: 'BrandAdmin',
-    StoreViewer: 'StoreViewer',
-    StoreEditor: 'StoreEditor',
-    StoreManager: 'StoreManager',
-    CustomerViewer: 'CustomerViewer',
-    CustomerManager: 'CustomerManager',
-    VoucherViewer: 'VoucherViewer',
-    VoucherEditor: 'VoucherEditor',
-    VoucherManager: 'VoucherManager',
-    VoucherCampaignManager: 'VoucherCampaignManager',
-    VoucherStatisticsViewer: 'VoucherStatisticsViewer',
-    AnalyticsViewer: 'AnalyticsViewer',
-    ReportsViewer: 'ReportsViewer',
-    FinanceViewer: 'FinanceViewer',
-    FinanceManager: 'FinanceManager',
-    TeamViewer: 'TeamViewer',
-    TeamManager: 'TeamManager',
-    TeamAdmin: 'TeamAdmin',
-    TechViewer: 'TechViewer',
-    TechManager: 'TechManager',
-    AppStoreViewer: 'AppStoreViewer',
-    AppStoreManager: 'AppStoreManager',
-    SalesChannelViewer: 'SalesChannelViewer',
-    SalesChannelEditor: 'SalesChannelEditor',
+export const GetPrincipalRolesSuccessResponseRolesInnerPolicyTypeEnum = {
+    Main: 'Main',
+    BrandOverride: 'BrandOverride',
+    OrgOverride: 'OrgOverride',
+    Forbidden: 'Forbidden',
+    NamedRole: 'NamedRole'
+} as const;
+
+export type GetPrincipalRolesSuccessResponseRolesInnerPolicyTypeEnum = typeof GetPrincipalRolesSuccessResponseRolesInnerPolicyTypeEnum[keyof typeof GetPrincipalRolesSuccessResponseRolesInnerPolicyTypeEnum];
+export const GetPrincipalRolesSuccessResponseRolesInnerResourceTypeEnum = {
+    Property: 'Property',
+    Org: 'Org',
+    Brand: 'Brand',
+    SalesChannel: 'SalesChannel'
+} as const;
+
+export type GetPrincipalRolesSuccessResponseRolesInnerResourceTypeEnum = typeof GetPrincipalRolesSuccessResponseRolesInnerResourceTypeEnum[keyof typeof GetPrincipalRolesSuccessResponseRolesInnerResourceTypeEnum];
+export const GetPrincipalRolesSuccessResponseRolesInnerPrincipalTypeEnum = {
+    User: 'User',
+    Automation: 'Automation'
+} as const;
+
+export type GetPrincipalRolesSuccessResponseRolesInnerPrincipalTypeEnum = typeof GetPrincipalRolesSuccessResponseRolesInnerPrincipalTypeEnum[keyof typeof GetPrincipalRolesSuccessResponseRolesInnerPrincipalTypeEnum];
+
+/**
+ * Role name
+ * @export
+ * @interface GetPrincipalRolesSuccessResponseRolesInnerRoleName
+ */
+export interface GetPrincipalRolesSuccessResponseRolesInnerRoleName {
+}
+/**
+ * Successful user permissions retrieval response
+ * @export
+ * @interface GetUserPermissionsSuccessResponse
+ */
+export interface GetUserPermissionsSuccessResponse {
+    /**
+     * Map of resource IDs to permissions
+     * @type {{ [key: string]: GetUserPermissionsSuccessResponseResourcesValue; }}
+     * @memberof GetUserPermissionsSuccessResponse
+     */
+    'resources': { [key: string]: GetUserPermissionsSuccessResponseResourcesValue; };
+}
+/**
+ * 
+ * @export
+ * @interface GetUserPermissionsSuccessResponseResourcesValue
+ */
+export interface GetUserPermissionsSuccessResponseResourcesValue {
+    /**
+     * Type of resource the permissions are assigned to
+     * @type {string}
+     * @memberof GetUserPermissionsSuccessResponseResourcesValue
+     */
+    'resourceType': GetUserPermissionsSuccessResponseResourcesValueResourceTypeEnum;
+    /**
+     * 
+     * @type {GetUserPermissionsSuccessResponseResourcesValueResourceId}
+     * @memberof GetUserPermissionsSuccessResponseResourcesValue
+     */
+    'resourceId': GetUserPermissionsSuccessResponseResourcesValueResourceId;
+    /**
+     * List of permissions that are assigned to the user for the resource
+     * @type {Array<Permissions>}
+     * @memberof GetUserPermissionsSuccessResponseResourcesValue
+     */
+    'permissions': Array<Permissions>;
+}
+
+export const GetUserPermissionsSuccessResponseResourcesValueResourceTypeEnum = {
+    Property: 'Property',
+    Org: 'Org',
+    Brand: 'Brand',
+    SalesChannel: 'SalesChannel'
+} as const;
+
+export type GetUserPermissionsSuccessResponseResourcesValueResourceTypeEnum = typeof GetUserPermissionsSuccessResponseResourcesValueResourceTypeEnum[keyof typeof GetUserPermissionsSuccessResponseResourcesValueResourceTypeEnum];
+
+/**
+ * ID of the resource the permissions are assigned to
+ * @export
+ * @interface GetUserPermissionsSuccessResponseResourcesValueResourceId
+ */
+export interface GetUserPermissionsSuccessResponseResourcesValueResourceId {
+}
+/**
+ * 
+ * @export
+ * @interface IsInRoleRequest
+ */
+export interface IsInRoleRequest {
+    /**
+     * 
+     * @type {AuthorizationRequestPrincipal}
+     * @memberof IsInRoleRequest
+     */
+    'principal': AuthorizationRequestPrincipal;
+    /**
+     * Array of roles to check if the principal is in
+     * @type {Array<RoleNames>}
+     * @memberof IsInRoleRequest
+     */
+    'roles': Array<RoleNames>;
+    /**
+     * How to check authorisation - any or all of the actions must be allowed
+     * @type {string}
+     * @memberof IsInRoleRequest
+     */
+    'checkMode'?: IsInRoleRequestCheckModeEnum;
+}
+
+export const IsInRoleRequestCheckModeEnum = {
+    Any: 'any',
+    All: 'all'
+} as const;
+
+export type IsInRoleRequestCheckModeEnum = typeof IsInRoleRequestCheckModeEnum[keyof typeof IsInRoleRequestCheckModeEnum];
+
+/**
+ * Response containing whether the principal is in any/all of the roles
+ * @export
+ * @interface IsInRoleResponse
+ */
+export interface IsInRoleResponse {
+    /**
+     * result of the check - whether the principal is in any/all of the roles
+     * @type {boolean}
+     * @memberof IsInRoleResponse
+     */
+    'authorized': boolean;
+}
+/**
+ * Successful feature based roles retrieval response
+ * @export
+ * @interface ListFeatureBasedRolesSuccessResponse
+ */
+export interface ListFeatureBasedRolesSuccessResponse {
+    /**
+     * 
+     * @type {Array<FeatureBasedRole>}
+     * @memberof ListFeatureBasedRolesSuccessResponse
+     */
+    'roles': Array<FeatureBasedRole>;
+}
+/**
+ * 
+ * @export
+ * @interface ListOrgRolesSuccessResponseValueValue
+ */
+export interface ListOrgRolesSuccessResponseValueValue {
+    /**
+     * Type of resource the permissions are assigned to
+     * @type {string}
+     * @memberof ListOrgRolesSuccessResponseValueValue
+     */
+    'resourceType': ListOrgRolesSuccessResponseValueValueResourceTypeEnum;
+    /**
+     * 
+     * @type {GetUserPermissionsSuccessResponseResourcesValueResourceId}
+     * @memberof ListOrgRolesSuccessResponseValueValue
+     */
+    'resourceId': GetUserPermissionsSuccessResponseResourcesValueResourceId;
+    /**
+     * List of roles that are assigned to the user for the resource
+     * @type {Array<string>}
+     * @memberof ListOrgRolesSuccessResponseValueValue
+     */
+    'roles': Array<ListOrgRolesSuccessResponseValueValueRolesEnum>;
+}
+
+export const ListOrgRolesSuccessResponseValueValueResourceTypeEnum = {
+    Property: 'Property',
+    Org: 'Org',
+    Brand: 'Brand',
+    SalesChannel: 'SalesChannel'
+} as const;
+
+export type ListOrgRolesSuccessResponseValueValueResourceTypeEnum = typeof ListOrgRolesSuccessResponseValueValueResourceTypeEnum[keyof typeof ListOrgRolesSuccessResponseValueValueResourceTypeEnum];
+export const ListOrgRolesSuccessResponseValueValueRolesEnum = {
+    OrgViewer: 'OrgViewer',
+    OrgManager: 'OrgManager',
+    OrgAdmin: 'OrgAdmin',
+    BrandViewer: 'BrandViewer',
+    BrandManager: 'BrandManager',
+    BrandAdmin: 'BrandAdmin',
+    StoreViewer: 'StoreViewer',
+    StoreEditor: 'StoreEditor',
+    StoreManager: 'StoreManager',
+    CustomerViewer: 'CustomerViewer',
+    CustomerManager: 'CustomerManager',
+    VoucherViewer: 'VoucherViewer',
+    VoucherEditor: 'VoucherEditor',
+    VoucherManager: 'VoucherManager',
+    VoucherCampaignManager: 'VoucherCampaignManager',
+    VoucherStatisticsViewer: 'VoucherStatisticsViewer',
+    AnalyticsViewer: 'AnalyticsViewer',
+    ReportsViewer: 'ReportsViewer',
+    FinanceViewer: 'FinanceViewer',
+    FinanceManager: 'FinanceManager',
+    TeamViewer: 'TeamViewer',
+    TeamManager: 'TeamManager',
+    TeamAdmin: 'TeamAdmin',
+    TechViewer: 'TechViewer',
+    TechManager: 'TechManager',
+    AppStoreViewer: 'AppStoreViewer',
+    AppStoreManager: 'AppStoreManager',
+    SalesChannelViewer: 'SalesChannelViewer',
+    SalesChannelEditor: 'SalesChannelEditor',
     SalesChannelManager: 'SalesChannelManager',
     DeliveryViewer: 'DeliveryViewer',
     DeliveryManager: 'DeliveryManager',
@@ -615,77 +1171,41 @@ export const GetPrincipalRolesSuccessResponseRolesInnerRoleNameEnum = {
     SupportMisc: 'SupportMisc'
 } as const;
 
-export type GetPrincipalRolesSuccessResponseRolesInnerRoleNameEnum = typeof GetPrincipalRolesSuccessResponseRolesInnerRoleNameEnum[keyof typeof GetPrincipalRolesSuccessResponseRolesInnerRoleNameEnum];
-export const GetPrincipalRolesSuccessResponseRolesInnerResourceTypeEnum = {
-    Property: 'Property',
-    Org: 'Org',
-    Brand: 'Brand',
-    SalesChannel: 'SalesChannel'
-} as const;
-
-export type GetPrincipalRolesSuccessResponseRolesInnerResourceTypeEnum = typeof GetPrincipalRolesSuccessResponseRolesInnerResourceTypeEnum[keyof typeof GetPrincipalRolesSuccessResponseRolesInnerResourceTypeEnum];
+export type ListOrgRolesSuccessResponseValueValueRolesEnum = typeof ListOrgRolesSuccessResponseValueValueRolesEnum[keyof typeof ListOrgRolesSuccessResponseValueValueRolesEnum];
 
 /**
- * Successful roles retrieval response
+ * Successful permissions retrieval response
  * @export
- * @interface GetRolesSuccessResponse
+ * @interface ListPermissionsSuccessResponse
  */
-export interface GetRolesSuccessResponse {
+export interface ListPermissionsSuccessResponse {
     /**
-     * List of roles available and their permissions
-     * @type {Array<RolesInner>}
-     * @memberof GetRolesSuccessResponse
+     * 
+     * @type {Permissions & Array<Permissions>}
+     * @memberof ListPermissionsSuccessResponse
      */
-    'roles': Array<RolesInner>;
+    'permissions': Permissions & Array<Permissions>;
 }
 /**
- * Successful user permissions retrieval response
+ * Successful roles retrieval response
  * @export
- * @interface GetUserPermissionsSuccessResponse
+ * @interface ListRolesSuccessResponse
  */
-export interface GetUserPermissionsSuccessResponse {
+export interface ListRolesSuccessResponse {
     /**
-     * Map of resource IDs to permissions
-     * @type {{ [key: string]: GetUserPermissionsSuccessResponseResourcesValue; }}
-     * @memberof GetUserPermissionsSuccessResponse
+     * List of named roles
+     * @type {Array<RoleNames>}
+     * @memberof ListRolesSuccessResponse
      */
-    'resources': { [key: string]: GetUserPermissionsSuccessResponseResourcesValue; };
+    'roles': Array<RoleNames>;
 }
 /**
- * 
+ * Permissions
  * @export
- * @interface GetUserPermissionsSuccessResponseResourcesValue
+ * @enum {string}
  */
-export interface GetUserPermissionsSuccessResponseResourcesValue {
-    /**
-     * Type of resource the permissions are assigned to
-     * @type {string}
-     * @memberof GetUserPermissionsSuccessResponseResourcesValue
-     */
-    'resourceType': GetUserPermissionsSuccessResponseResourcesValueResourceTypeEnum;
-    /**
-     * 
-     * @type {GetUserPermissionsSuccessResponseResourcesValueResourceId}
-     * @memberof GetUserPermissionsSuccessResponseResourcesValue
-     */
-    'resourceId': GetUserPermissionsSuccessResponseResourcesValueResourceId;
-    /**
-     * List of permissions that are assigned to the user for the resource
-     * @type {Array<string>}
-     * @memberof GetUserPermissionsSuccessResponseResourcesValue
-     */
-    'permissions': Array<GetUserPermissionsSuccessResponseResourcesValuePermissionsEnum>;
-}
-
-export const GetUserPermissionsSuccessResponseResourcesValueResourceTypeEnum = {
-    Property: 'Property',
-    Org: 'Org',
-    Brand: 'Brand',
-    SalesChannel: 'SalesChannel'
-} as const;
 
-export type GetUserPermissionsSuccessResponseResourcesValueResourceTypeEnum = typeof GetUserPermissionsSuccessResponseResourcesValueResourceTypeEnum[keyof typeof GetUserPermissionsSuccessResponseResourcesValueResourceTypeEnum];
-export const GetUserPermissionsSuccessResponseResourcesValuePermissionsEnum = {
+export const Permissions = {
     AnyAuditLogs: 'AnyAuditLogs',
     ViewApp: 'ViewApp',
     CreateApp: 'CreateApp',
@@ -909,325 +1429,74 @@ export const GetUserPermissionsSuccessResponseResourcesValuePermissionsEnum = {
     EditEntityFeatureFlags: 'EditEntityFeatureFlags',
     CreateOrg: 'CreateOrg',
     EditOrg: 'EditOrg',
-    ViewOrg: 'ViewOrg'
+    ViewOrg: 'ViewOrg',
+    ViewWebhooks: 'ViewWebhooks',
+    EditWebhooks: 'EditWebhooks',
+    RoleAdmin: 'RoleAdmin',
+    RoleFactory: 'RoleFactory'
 } as const;
 
-export type GetUserPermissionsSuccessResponseResourcesValuePermissionsEnum = typeof GetUserPermissionsSuccessResponseResourcesValuePermissionsEnum[keyof typeof GetUserPermissionsSuccessResponseResourcesValuePermissionsEnum];
+export type Permissions = typeof Permissions[keyof typeof Permissions];
+
 
 /**
- * ID of the resource the permissions are assigned to
- * @export
- * @interface GetUserPermissionsSuccessResponseResourcesValueResourceId
- */
-export interface GetUserPermissionsSuccessResponseResourcesValueResourceId {
-}
-/**
- * 
+ * Principals in org
  * @export
- * @interface OrgPathParam
+ * @interface PrincipalsInOrgResponse
  */
-export interface OrgPathParam {
+export interface PrincipalsInOrgResponse {
     /**
      * 
      * @type {string}
-     * @memberof OrgPathParam
+     * @memberof PrincipalsInOrgResponse
      */
     'orgId': string;
+    /**
+     * List of principals in org
+     * @type {Array<AuthorizationRequestPrincipal>}
+     * @memberof PrincipalsInOrgResponse
+     */
+    'principals': Array<AuthorizationRequestPrincipal>;
 }
 /**
- * 
+ * Details for revoking a forbidden role from a principal
  * @export
- * @interface PathParams
+ * @interface RevokeForbiddenRoleRequestBody
  */
-export interface PathParams {
+export interface RevokeForbiddenRoleRequestBody {
     /**
      * 
-     * @type {string}
-     * @memberof PathParams
+     * @type {AuthorizationRequestPrincipal}
+     * @memberof RevokeForbiddenRoleRequestBody
      */
-    'orgId': string;
+    'principal': AuthorizationRequestPrincipal;
     /**
-     * 
+     * Compensation role to revoke the forbidden role from
      * @type {string}
-     * @memberof PathParams
+     * @memberof RevokeForbiddenRoleRequestBody
      */
-    'userId': string;
+    'compensatingRole': RevokeForbiddenRoleRequestBodyCompensatingRoleEnum;
 }
+
+export const RevokeForbiddenRoleRequestBodyCompensatingRoleEnum = {
+    OwnerCompensating: 'OwnerCompensating',
+    PropertyOwnerCompensating: 'PropertyOwnerCompensating',
+    ManagedOwnerCompensating: 'ManagedOwnerCompensating',
+    IntegratorCompensating: 'IntegratorCompensating',
+    PropertyManagerCompensating: 'PropertyManagerCompensating',
+    FinanceManagerCompensating: 'FinanceManagerCompensating'
+} as const;
+
+export type RevokeForbiddenRoleRequestBodyCompensatingRoleEnum = typeof RevokeForbiddenRoleRequestBodyCompensatingRoleEnum[keyof typeof RevokeForbiddenRoleRequestBodyCompensatingRoleEnum];
+
 /**
- * 
+ * Details for revoking a role from a principal
  * @export
- * @enum {string}
- */
-
-export const Permissions = {
-    AnyAuditLogs: 'AnyAuditLogs',
-    ViewApp: 'ViewApp',
-    CreateApp: 'CreateApp',
-    UpdateApp: 'UpdateApp',
-    ViewAppName: 'ViewAppName',
-    EditAppAssets: 'EditAppAssets',
-    EditAppFeatures: 'EditAppFeatures',
-    ViewTeammates: 'ViewTeammates',
-    EditTeammates: 'EditTeammates',
-    CreateTeammateOwner: 'CreateTeammateOwner',
-    CreateTeammateManagedOwner: 'CreateTeammateManagedOwner',
-    CreateTeammateStoreOwner: 'CreateTeammateStoreOwner',
-    CreateTeammateStoreManager: 'CreateTeammateStoreManager',
-    CreateTeammateStoreStaff: 'CreateTeammateStoreStaff',
-    CreateTeammateStoreReadAccess: 'CreateTeammateStoreReadAccess',
-    CreateTeammateFinanceManager: 'CreateTeammateFinanceManager',
-    CreateTeammateIntegrator: 'CreateTeammateIntegrator',
-    CreateTeammateOnboarding: 'CreateTeammateOnboarding',
-    CreateTeammatePropertyManager: 'CreateTeammatePropertyManager',
-    CreateTeammatePropertyOwner: 'CreateTeammatePropertyOwner',
-    ViewApmConfigurations: 'ViewApmConfigurations',
-    EditApmConfigurations: 'EditApmConfigurations',
-    ViewCampaignsConfigurations: 'ViewCampaignsConfigurations',
-    CreateCampaignsConfigurations: 'CreateCampaignsConfigurations',
-    UpdateCampaignsConfigurations: 'UpdateCampaignsConfigurations',
-    DeleteCampaignsConfigurations: 'DeleteCampaignsConfigurations',
-    StampLoyaltyCardAgainstCampaignsConfigurations: 'StampLoyaltyCardAgainstCampaignsConfigurations',
-    ViewDevelopersSettings: 'ViewDevelopersSettings',
-    EditDevelopersSettings: 'EditDevelopersSettings',
-    ViewOrders: 'ViewOrders',
-    UpdateOrdersAccept: 'UpdateOrdersAccept',
-    UpdateOrdersReject: 'UpdateOrdersReject',
-    UpdateOrdersRefund: 'UpdateOrdersRefund',
-    UpdateOrdersDispatch: 'UpdateOrdersDispatch',
-    ViewStores: 'ViewStores',
-    CreateStores: 'CreateStores',
-    EditStores: 'EditStores',
-    ViewStoresOpeningHours: 'ViewStoresOpeningHours',
-    UpdateStoresOpenForCollectionOrDelivery: 'UpdateStoresOpenForCollectionOrDelivery',
-    UpdateStoresOpeningHours: 'UpdateStoresOpeningHours',
-    ViewStoresOpeningHoursOverride: 'ViewStoresOpeningHoursOverride',
-    EditStoresOpeningHoursOverride: 'EditStoresOpeningHoursOverride',
-    EditStoresOpeningHoursOverrideTemporary: 'EditStoresOpeningHoursOverrideTemporary',
-    UpdateStoresName: 'UpdateStoresName',
-    EditStoreKioskSettings: 'EditStoreKioskSettings',
-    EditStoreOrderCapacity: 'EditStoreOrderCapacity',
-    EditStoreNotifications: 'EditStoreNotifications',
-    ArchiveStores: 'ArchiveStores',
-    PublishStores: 'PublishStores',
-    UpdatePrinterTerminalsAssign: 'UpdatePrinterTerminalsAssign',
-    UpdatePrinterTerminalsToggle: 'UpdatePrinterTerminalsToggle',
-    ViewStoreGroups: 'ViewStoreGroups',
-    CreateStoreGroups: 'CreateStoreGroups',
-    UpdateStoreGroups: 'UpdateStoreGroups',
-    DeleteStoreGroups: 'DeleteStoreGroups',
-    ViewDeliveryZones: 'ViewDeliveryZones',
-    CreateDeliveryZones: 'CreateDeliveryZones',
-    UpdateDeliveryZones: 'UpdateDeliveryZones',
-    DeleteDeliveryZones: 'DeleteDeliveryZones',
-    ViewMenu: 'ViewMenu',
-    CreateMenu: 'CreateMenu',
-    UpdateMenu: 'UpdateMenu',
-    DeleteMenu: 'DeleteMenu',
-    UpdateMenuLock: 'UpdateMenuLock',
-    UpdateMenuItemsHideTemporarily: 'UpdateMenuItemsHideTemporarily',
-    EditMenuImage: 'EditMenuImage',
-    ViewVouchers: 'ViewVouchers',
-    EditVouchers: 'EditVouchers',
-    ViewWebsiteContent: 'ViewWebsiteContent',
-    EditWebsiteContent: 'EditWebsiteContent',
-    ViewWebsiteDnsVerified: 'ViewWebsiteDnsVerified',
-    ViewWebsiteCertificateCreated: 'ViewWebsiteCertificateCreated',
-    ViewWebsiteCertificateRenewed: 'ViewWebsiteCertificateRenewed',
-    ViewBankAccounts: 'ViewBankAccounts',
-    CreateBankAccounts: 'CreateBankAccounts',
-    UpdateBankAccounts: 'UpdateBankAccounts',
-    UpdateBankAccountsAssign: 'UpdateBankAccountsAssign',
-    ViewAssignedBankAccount: 'ViewAssignedBankAccount',
-    VerifyBankAccounts: 'VerifyBankAccounts',
-    ViewServiceChargeConfigurations: 'ViewServiceChargeConfigurations',
-    EditServiceChargeConfigurations: 'EditServiceChargeConfigurations',
-    EditStoreDeliveryZoneFees: 'EditStoreDeliveryZoneFees',
-    EditStoreDeliveryFeesLimited: 'EditStoreDeliveryFeesLimited',
-    ViewHydraConfig: 'ViewHydraConfig',
-    UpdateHydraConfigManage: 'UpdateHydraConfigManage',
-    InitiateBluetoothPairingMode: 'InitiateBluetoothPairingMode',
-    DeleteTerminal: 'DeleteTerminal',
-    ViewKioskTelemetry: 'ViewKioskTelemetry',
-    ViewCustomers: 'ViewCustomers',
-    EditCustomers: 'EditCustomers',
-    CreateCustomers: 'CreateCustomers',
-    CreateCatalogElements: 'CreateCatalogElements',
-    UpdateCatalogElements: 'UpdateCatalogElements',
-    ViewCatalogElements: 'ViewCatalogElements',
-    DeleteCatalogElements: 'DeleteCatalogElements',
-    ViewMetafieldDefinitions: 'ViewMetafieldDefinitions',
-    CreateMetafieldDefinitions: 'CreateMetafieldDefinitions',
-    UpdateMetafieldDefinitions: 'UpdateMetafieldDefinitions',
-    DeleteMetafieldDefinitions: 'DeleteMetafieldDefinitions',
-    UpdateMetafields: 'UpdateMetafields',
-    ViewCatalogMenuChanges: 'ViewCatalogMenuChanges',
-    PublishCatalogMenuChanges: 'PublishCatalogMenuChanges',
-    ViewAppStatistics: 'ViewAppStatistics',
-    ViewApmStatistics: 'ViewApmStatistics',
-    ViewCampaignsStatistics: 'ViewCampaignsStatistics',
-    ViewCustomerStatistics: 'ViewCustomerStatistics',
-    ViewLiveStatistics: 'ViewLiveStatistics',
-    ViewOrderStatistics: 'ViewOrderStatistics',
-    ViewSalesStatistics: 'ViewSalesStatistics',
-    ViewSalesEndOfDayStatistics: 'ViewSalesEndOfDayStatistics',
-    ViewVouchersStatistics: 'ViewVouchersStatistics',
-    DownloadCustomerCsvExport: 'DownloadCustomerCsvExport',
-    ViewApmAuditLogs: 'ViewApmAuditLogs',
-    ViewStoreAuditLogs: 'ViewStoreAuditLogs',
-    ViewMenuAuditLogs: 'ViewMenuAuditLogs',
-    ViewBankAccountAuditLogs: 'ViewBankAccountAuditLogs',
-    ViewFeeConfigurationsAuditLogs: 'ViewFeeConfigurationsAuditLogs',
-    ViewOrdersAuditLogs: 'ViewOrdersAuditLogs',
-    ViewVouchersAuditLogs: 'ViewVouchersAuditLogs',
-    ViewUserEventsAuditLogs: 'ViewUserEventsAuditLogs',
-    ViewCampaignsAuditLogs: 'ViewCampaignsAuditLogs',
-    ViewTeammatesAuditLogs: 'ViewTeammatesAuditLogs',
-    ViewAppAuditLogs: 'ViewAppAuditLogs',
-    ViewCustomerAuditLogs: 'ViewCustomerAuditLogs',
-    ViewPrinterAuditLogs: 'ViewPrinterAuditLogs',
-    ViewHydraAuditLogs: 'ViewHydraAuditLogs',
-    ViewPushNotificationAuditLogs: 'ViewPushNotificationAuditLogs',
-    ViewStripeCustomConnectedAccountAuditLogs: 'ViewStripeCustomConnectedAccountAuditLogs',
-    ViewKioskBluetoothDeviceAuditLogs: 'ViewKioskBluetoothDeviceAuditLogs',
-    ViewExternalAuditLogs: 'ViewExternalAuditLogs',
-    CreateExternalAuditLogEvents: 'CreateExternalAuditLogEvents',
-    ViewCatalogAuditLogs: 'ViewCatalogAuditLogs',
-    ViewOrderFulfillmentAuditLogs: 'ViewOrderFulfillmentAuditLogs',
-    ViewChannelAuditLogs: 'ViewChannelAuditLogs',
-    ViewAppStoreAuditLogs: 'ViewAppStoreAuditLogs',
-    SendPushNotificationToCustomer: 'SendPushNotificationToCustomer',
-    InviteDriverToApp: 'InviteDriverToApp',
-    GetDriverForApp: 'GetDriverForApp',
-    RemoveDriverFromApp: 'RemoveDriverFromApp',
-    AssignDriverToOrder: 'AssignDriverToOrder',
-    UnassignDriverFromOrder: 'UnassignDriverFromOrder',
-    UpdateOrdersDeliveryTrackingStatus: 'UpdateOrdersDeliveryTrackingStatus',
-    UpdateOrderFulfillmentStatus: 'UpdateOrderFulfillmentStatus',
-    ViewFulfillmentStatesConfiguration: 'ViewFulfillmentStatesConfiguration',
-    CreateFulfillmentStatesConfiguration: 'CreateFulfillmentStatesConfiguration',
-    UpdateFulfillmentStatesConfiguration: 'UpdateFulfillmentStatesConfiguration',
-    DeleteFulfillmentStatesConfiguration: 'DeleteFulfillmentStatesConfiguration',
-    ViewPayouts: 'ViewPayouts',
-    ViewChannels: 'ViewChannels',
-    ViewOnboarding: 'ViewOnboarding',
-    UpdateOnboarding: 'UpdateOnboarding',
-    ViewClientDevices: 'ViewClientDevices',
-    UpdateClientDevices: 'UpdateClientDevices',
-    EnrollClientDevices: 'EnrollClientDevices',
-    AssignClientDevices: 'AssignClientDevices',
-    ViewClientAuditLogs: 'ViewClientAuditLogs',
-    CreateAppStoreAppConfiguration: 'CreateAppStoreAppConfiguration',
-    ViewAppStoreAppConfiguration: 'ViewAppStoreAppConfiguration',
-    UpdateAppStoreAppConfiguration: 'UpdateAppStoreAppConfiguration',
-    DeleteAppStoreAppConfiguration: 'DeleteAppStoreAppConfiguration',
-    UpdateAppStoreAppConfigurationSettings: 'UpdateAppStoreAppConfigurationSettings',
-    CreateAppStoreSubscription: 'CreateAppStoreSubscription',
-    UpdateAppStoreSubscription: 'UpdateAppStoreSubscription',
-    DeleteAppStoreSubscription: 'DeleteAppStoreSubscription',
-    ViewSalesChannels: 'ViewSalesChannels',
-    EditSalesChannels: 'EditSalesChannels',
-    CreateSalesChannel: 'CreateSalesChannel',
-    ArchiveSalesChannel: 'ArchiveSalesChannel',
-    UnarchiveSalesChannel: 'UnarchiveSalesChannel',
-    PublishSalesChannel: 'PublishSalesChannel',
-    UnpublishSalesChannel: 'UnpublishSalesChannel',
-    CloneSalesChannel: 'CloneSalesChannel',
-    ViewPayGreenWhiteLabelConfiguration: 'ViewPayGreenWhiteLabelConfiguration',
-    CreatePayGreenWhiteLabelConfiguration: 'CreatePayGreenWhiteLabelConfiguration',
-    UpdatePayGreenWhiteLabelConfiguration: 'UpdatePayGreenWhiteLabelConfiguration',
-    UpdatePayGreenStoreConfiguration: 'UpdatePayGreenStoreConfiguration',
-    ViewSubscriptions: 'ViewSubscriptions',
-    ViewInvoices: 'ViewInvoices',
-    EditAccountsBills: 'EditAccountsBills',
-    ViewAccountsBills: 'ViewAccountsBills',
-    EditAccountsCategories: 'EditAccountsCategories',
-    ViewAccountsCategories: 'ViewAccountsCategories',
-    EditAccountsCreditAccounts: 'EditAccountsCreditAccounts',
-    ViewAccountsCreditAccounts: 'ViewAccountsCreditAccounts',
-    EditAccountsCreditBooks: 'EditAccountsCreditBooks',
-    ViewAccountsCreditBooks: 'ViewAccountsCreditBooks',
-    EditAccountsExpenses: 'EditAccountsExpenses',
-    ViewAccountsExpenses: 'ViewAccountsExpenses',
-    EditAccountsTransactionAccounts: 'EditAccountsTransactionAccounts',
-    ViewAccountsTransactionAccounts: 'ViewAccountsTransactionAccounts',
-    EditDocumentExplorer: 'EditDocumentExplorer',
-    ViewDocumentExplorer: 'ViewDocumentExplorer',
-    ViewInventoryReports: 'ViewInventoryReports',
-    EditInventoryPurchaseOrders: 'EditInventoryPurchaseOrders',
-    ViewInventoryPurchaseOrders: 'ViewInventoryPurchaseOrders',
-    EditInventoryStockItems: 'EditInventoryStockItems',
-    ViewInventoryStockItems: 'ViewInventoryStockItems',
-    EditInventorySupplier: 'EditInventorySupplier',
-    ViewInventorySupplier: 'ViewInventorySupplier',
-    EditInventoryTrackingProfiles: 'EditInventoryTrackingProfiles',
-    ViewInventoryTrackingProfiles: 'ViewInventoryTrackingProfiles',
-    ViewPayrollReports: 'ViewPayrollReports',
-    EditPayrollHoliday: 'EditPayrollHoliday',
-    ViewPayrollHoliday: 'ViewPayrollHoliday',
-    EditPayrollRota: 'EditPayrollRota',
-    ViewPayrollRota: 'ViewPayrollRota',
-    EditPayrollStaff: 'EditPayrollStaff',
-    ViewPayrollStaff: 'ViewPayrollStaff',
-    ViewSalesReports: 'ViewSalesReports',
-    ViewCostReports: 'ViewCostReports',
-    ViewMenuReports: 'ViewMenuReports',
-    ViewBrand: 'ViewBrand',
-    EditBrand: 'EditBrand',
-    CreateBrand: 'CreateBrand',
-    TransferBrand: 'TransferBrand',
-    ViewProperty: 'ViewProperty',
-    EditProperty: 'EditProperty',
-    CreateProperty: 'CreateProperty',
-    ArchiveProperty: 'ArchiveProperty',
-    ViewEntityFeatureFlags: 'ViewEntityFeatureFlags',
-    EditEntityFeatureFlags: 'EditEntityFeatureFlags',
-    CreateOrg: 'CreateOrg',
-    EditOrg: 'EditOrg',
-    ViewOrg: 'ViewOrg'
-} as const;
-
-export type Permissions = typeof Permissions[keyof typeof Permissions];
-
-
-/**
- * Details for revoking a forbidden role from a principal
- * @export
- * @interface RevokeForbiddenRoleRequestBody
- */
-export interface RevokeForbiddenRoleRequestBody {
-    /**
-     * 
-     * @type {AuthorizationRequestPrincipal}
-     * @memberof RevokeForbiddenRoleRequestBody
-     */
-    'principal': AuthorizationRequestPrincipal;
-    /**
-     * Compensation role to revoke the forbidden role from
-     * @type {string}
-     * @memberof RevokeForbiddenRoleRequestBody
-     */
-    'compensatingRole': RevokeForbiddenRoleRequestBodyCompensatingRoleEnum;
-}
-
-export const RevokeForbiddenRoleRequestBodyCompensatingRoleEnum = {
-    OwnerCompensating: 'OwnerCompensating',
-    PropertyOwnerCompensating: 'PropertyOwnerCompensating',
-    ManagedOwnerCompensating: 'ManagedOwnerCompensating',
-    IntegratorCompensating: 'IntegratorCompensating',
-    PropertyManagerCompensating: 'PropertyManagerCompensating',
-    FinanceManagerCompensating: 'FinanceManagerCompensating'
-} as const;
-
-export type RevokeForbiddenRoleRequestBodyCompensatingRoleEnum = typeof RevokeForbiddenRoleRequestBodyCompensatingRoleEnum[keyof typeof RevokeForbiddenRoleRequestBodyCompensatingRoleEnum];
-
-/**
- * Details for revoking a role from a principal
- * @export
- * @interface RevokeRoleRequestBody
+ * @interface RevokeRoleRequestBody
  */
 export interface RevokeRoleRequestBody {
     /**
-     * Role to assign to the principal choose from: OrgViewer, OrgManager, OrgAdmin, BrandViewer, BrandManager, BrandAdmin, StoreViewer, StoreEditor, StoreManager, CustomerViewer, CustomerManager, VoucherViewer, VoucherEditor, VoucherManager, VoucherCampaignManager, VoucherStatisticsViewer, AnalyticsViewer, ReportsViewer, FinanceViewer, FinanceManager, TeamViewer, TeamManager, TeamAdmin, TechViewer, TechManager, AppStoreViewer, AppStoreManager, SalesChannelViewer, SalesChannelEditor, SalesChannelManager, DeliveryViewer, DeliveryManager, DriverManager, AuditViewer, AuditManager, AccountsViewer, AccountsEditor, DocumentExplorerViewer, DocumentExplorerEditor, PayrollViewer, PayrollEditor, PropertyViewer, PropertyManager, PropertyAdmin, WebsiteContentEditor, WebsiteContentViewer, WebsiteTechViewer, MenuViewer, MenuEditor, MenuManager, MenuMetaFieldManager, MenuMetaFieldEditor, MenuMetaFieldViewer, StoreDeliveryZoneManager, StoreDeliveryZoneEditor, StoreDeliveryZoneViewer, OrderFulfillmentManager, OrderManager, OrderEditor, OrderViewer, InventoryManager, InventoryEditor, InventoryViewer, PaymentManager, OnboardingManager, FeatureFlagManager, PropertyOwnerMisc, ManagedOwnerMisc, IntegratorMisc, PropertyManagerMisc, FinanceManagerMisc, SupportMisc
+     * 
      * @type {string}
      * @memberof RevokeRoleRequestBody
      */
@@ -1327,82 +1596,340 @@ export const RevokeRoleRequestBodyRoleEnum = {
     SupportMisc: 'SupportMisc'
 } as const;
 
-export type RevokeRoleRequestBodyRoleEnum = typeof RevokeRoleRequestBodyRoleEnum[keyof typeof RevokeRoleRequestBodyRoleEnum];
+export type RevokeRoleRequestBodyRoleEnum = typeof RevokeRoleRequestBodyRoleEnum[keyof typeof RevokeRoleRequestBodyRoleEnum];
+
+/**
+ * Successful role revocation response
+ * @export
+ * @interface RevokeRoleSuccessResponse
+ */
+export interface RevokeRoleSuccessResponse {
+    /**
+     * Confirmation message
+     * @type {string}
+     * @memberof RevokeRoleSuccessResponse
+     */
+    'message': string;
+}
+/**
+ * Role names
+ * @export
+ * @enum {string}
+ */
+
+export const RoleNames = {
+    Admin: 'Admin',
+    Factory: 'Factory'
+} as const;
+
+export type RoleNames = typeof RoleNames[keyof typeof RoleNames];
+
+
+/**
+ * 
+ * @export
+ * @interface ValidationErrorsInner
+ */
+export interface ValidationErrorsInner {
+    /**
+     * 
+     * @type {Array<ValidationErrorsInnerPathInner>}
+     * @memberof ValidationErrorsInner
+     */
+    'path'?: Array<ValidationErrorsInnerPathInner>;
+    /**
+     * 
+     * @type {string}
+     * @memberof ValidationErrorsInner
+     */
+    'message': string;
+}
+/**
+ * 
+ * @export
+ * @interface ValidationErrorsInnerPathInner
+ */
+export interface ValidationErrorsInnerPathInner {
+}
+
+/**
+ * AuthenticationApi - axios parameter creator
+ * @export
+ */
+export const AuthenticationApiAxiosParamCreator = function (configuration?: Configuration) {
+    return {
+        /**
+         * Authenticate and authorize a user to perform an action
+         * @summary Authenticate and authorize Request
+         * @param {AuthenticateAndAuthorizeRequest} authenticateAndAuthorizeRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authenticateAndAuthorize: async (authenticateAndAuthorizeRequest: AuthenticateAndAuthorizeRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'authenticateAndAuthorizeRequest' is not null or undefined
+            assertParamExists('authenticateAndAuthorize', 'authenticateAndAuthorizeRequest', authenticateAndAuthorizeRequest)
+            const localVarPath = `/authenticateAndAuthorize`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(authenticateAndAuthorizeRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    }
+};
+
+/**
+ * AuthenticationApi - functional programming interface
+ * @export
+ */
+export const AuthenticationApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = AuthenticationApiAxiosParamCreator(configuration)
+    return {
+        /**
+         * Authenticate and authorize a user to perform an action
+         * @summary Authenticate and authorize Request
+         * @param {AuthenticateAndAuthorizeRequest} authenticateAndAuthorizeRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async authenticateAndAuthorize(authenticateAndAuthorizeRequest: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AuthenticateAndAuthorizeResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.authenticateAndAuthorize(authenticateAndAuthorizeRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['AuthenticationApi.authenticateAndAuthorize']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    }
+};
+
+/**
+ * AuthenticationApi - factory interface
+ * @export
+ */
+export const AuthenticationApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = AuthenticationApiFp(configuration)
+    return {
+        /**
+         * Authenticate and authorize a user to perform an action
+         * @summary Authenticate and authorize Request
+         * @param {AuthenticateAndAuthorizeRequest} authenticateAndAuthorizeRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authenticateAndAuthorize(authenticateAndAuthorizeRequest: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig): AxiosPromise<AuthenticateAndAuthorizeResponse> {
+            return localVarFp.authenticateAndAuthorize(authenticateAndAuthorizeRequest, options).then((request) => request(axios, basePath));
+        },
+    };
+};
+
+/**
+ * AuthenticationApi - object-oriented interface
+ * @export
+ * @class AuthenticationApi
+ * @extends {BaseAPI}
+ */
+export class AuthenticationApi extends BaseAPI {
+    /**
+     * Authenticate and authorize a user to perform an action
+     * @summary Authenticate and authorize Request
+     * @param {AuthenticateAndAuthorizeRequest} authenticateAndAuthorizeRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    public authenticateAndAuthorize(authenticateAndAuthorizeRequest: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig) {
+        return AuthenticationApiFp(this.configuration).authenticateAndAuthorize(authenticateAndAuthorizeRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+}
+
+
+
+/**
+ * AuthorizationApi - axios parameter creator
+ * @export
+ */
+export const AuthorizationApiAxiosParamCreator = function (configuration?: Configuration) {
+    return {
+        /**
+         * Authenticate and authorize a user to perform an action
+         * @summary Authenticate and authorize Request
+         * @param {AuthenticateAndAuthorizeRequest} authenticateAndAuthorizeRequest 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authenticateAndAuthorize: async (authenticateAndAuthorizeRequest: AuthenticateAndAuthorizeRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'authenticateAndAuthorizeRequest' is not null or undefined
+            assertParamExists('authenticateAndAuthorize', 'authenticateAndAuthorizeRequest', authenticateAndAuthorizeRequest)
+            const localVarPath = `/authenticateAndAuthorize`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(authenticateAndAuthorizeRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Authenticate and check if a user is in any/all of the roles
+         * @summary Authenticate and Check Is In Role
+         * @param {AuthenticateAndCheckIsInRoleRequest} [authenticateAndCheckIsInRoleRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authenticateAndCheckIsInRole: async (authenticateAndCheckIsInRoleRequest?: AuthenticateAndCheckIsInRoleRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/authenticateAndCheckIsInRole`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(authenticateAndCheckIsInRoleRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Check if a user is authorized to perform an action
+         * @summary Authorize Request
+         * @param {AuthorizationRequest} [authorizationRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authorize: async (authorizationRequest?: AuthorizationRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/authorize`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(authorizationRequest, localVarRequestOptions, configuration)
 
-/**
- * Successful role revocation response
- * @export
- * @interface RevokeRoleSuccessResponse
- */
-export interface RevokeRoleSuccessResponse {
-    /**
-     * Confirmation message
-     * @type {string}
-     * @memberof RevokeRoleSuccessResponse
-     */
-    'message': string;
-}
-/**
- * 
- * @export
- * @interface RolesInner
- */
-export interface RolesInner {
-    /**
-     * Name of the role
-     * @type {string}
-     * @memberof RolesInner
-     */
-    'name': string;
-    /**
-     * 
-     * @type {Permissions & Array<string>}
-     * @memberof RolesInner
-     */
-    'permissions': Permissions & Array<string>;
-}
-/**
- * 
- * @export
- * @interface ValidationErrorsInner
- */
-export interface ValidationErrorsInner {
-    /**
-     * 
-     * @type {Array<ValidationErrorsInnerPathInner>}
-     * @memberof ValidationErrorsInner
-     */
-    'path'?: Array<ValidationErrorsInnerPathInner>;
-    /**
-     * 
-     * @type {string}
-     * @memberof ValidationErrorsInner
-     */
-    'message': string;
-}
-/**
- * 
- * @export
- * @interface ValidationErrorsInnerPathInner
- */
-export interface ValidationErrorsInnerPathInner {
-}
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Check if a user is authorized to perform an action on multiple resources
+         * @summary Authorize Batch Request
+         * @param {AuthorizationBatchRequest} [authorizationBatchRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authorizeBatch: async (authorizationBatchRequest?: AuthorizationBatchRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/authorize/batch`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
 
-/**
- * AuthenticationApi - axios parameter creator
- * @export
- */
-export const AuthenticationApiAxiosParamCreator = function (configuration?: Configuration) {
-    return {
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(authorizationBatchRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
-         * Authenticate and authorize a user to perform an action
-         * @summary Authenticate and authorize Request
-         * @param {AuthenticateAndAuthorizeRequest} [authenticateAndAuthorizeRequest] 
+         * Check if a user is in any/all of the roles
+         * @summary Check Is In Role
+         * @param {IsInRoleRequest} [isInRoleRequest] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        authenticateAndAuthorize: async (authenticateAndAuthorizeRequest?: AuthenticateAndAuthorizeRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/authenticateAndAuthorize`;
+        checkIsInRole: async (isInRoleRequest?: IsInRoleRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/checkIsInRole`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -1424,7 +1951,7 @@ export const AuthenticationApiAxiosParamCreator = function (configuration?: Conf
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(authenticateAndAuthorizeRequest, localVarRequestOptions, configuration)
+            localVarRequestOptions.data = serializeDataIfNeeded(isInRoleRequest, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -1435,85 +1962,266 @@ export const AuthenticationApiAxiosParamCreator = function (configuration?: Conf
 };
 
 /**
- * AuthenticationApi - functional programming interface
+ * AuthorizationApi - functional programming interface
  * @export
  */
-export const AuthenticationApiFp = function(configuration?: Configuration) {
-    const localVarAxiosParamCreator = AuthenticationApiAxiosParamCreator(configuration)
+export const AuthorizationApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = AuthorizationApiAxiosParamCreator(configuration)
     return {
         /**
          * Authenticate and authorize a user to perform an action
          * @summary Authenticate and authorize Request
-         * @param {AuthenticateAndAuthorizeRequest} [authenticateAndAuthorizeRequest] 
+         * @param {AuthenticateAndAuthorizeRequest} authenticateAndAuthorizeRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async authenticateAndAuthorize(authenticateAndAuthorizeRequest?: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AuthenticateAndAuthorizeResponse>> {
+        async authenticateAndAuthorize(authenticateAndAuthorizeRequest: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AuthenticateAndAuthorizeResponse>> {
             const localVarAxiosArgs = await localVarAxiosParamCreator.authenticateAndAuthorize(authenticateAndAuthorizeRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['AuthenticationApi.authenticateAndAuthorize']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['AuthorizationApi.authenticateAndAuthorize']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Authenticate and check if a user is in any/all of the roles
+         * @summary Authenticate and Check Is In Role
+         * @param {AuthenticateAndCheckIsInRoleRequest} [authenticateAndCheckIsInRoleRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async authenticateAndCheckIsInRole(authenticateAndCheckIsInRoleRequest?: AuthenticateAndCheckIsInRoleRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AuthenticateAndCheckIsInRoleResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.authenticateAndCheckIsInRole(authenticateAndCheckIsInRoleRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['AuthorizationApi.authenticateAndCheckIsInRole']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Check if a user is authorized to perform an action
+         * @summary Authorize Request
+         * @param {AuthorizationRequest} [authorizationRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async authorize(authorizationRequest?: AuthorizationRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AuthorizationResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.authorize(authorizationRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['AuthorizationApi.authorize']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Check if a user is authorized to perform an action on multiple resources
+         * @summary Authorize Batch Request
+         * @param {AuthorizationBatchRequest} [authorizationBatchRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async authorizeBatch(authorizationBatchRequest?: AuthorizationBatchRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AuthorizationBatchResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.authorizeBatch(authorizationBatchRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['AuthorizationApi.authorizeBatch']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Check if a user is in any/all of the roles
+         * @summary Check Is In Role
+         * @param {IsInRoleRequest} [isInRoleRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async checkIsInRole(isInRoleRequest?: IsInRoleRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<IsInRoleResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.checkIsInRole(isInRoleRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['AuthorizationApi.checkIsInRole']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     }
 };
 
 /**
- * AuthenticationApi - factory interface
+ * AuthorizationApi - factory interface
  * @export
  */
-export const AuthenticationApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
-    const localVarFp = AuthenticationApiFp(configuration)
+export const AuthorizationApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = AuthorizationApiFp(configuration)
     return {
         /**
          * Authenticate and authorize a user to perform an action
          * @summary Authenticate and authorize Request
-         * @param {AuthenticateAndAuthorizeRequest} [authenticateAndAuthorizeRequest] 
+         * @param {AuthenticateAndAuthorizeRequest} authenticateAndAuthorizeRequest 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        authenticateAndAuthorize(authenticateAndAuthorizeRequest?: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig): AxiosPromise<AuthenticateAndAuthorizeResponse> {
+        authenticateAndAuthorize(authenticateAndAuthorizeRequest: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig): AxiosPromise<AuthenticateAndAuthorizeResponse> {
             return localVarFp.authenticateAndAuthorize(authenticateAndAuthorizeRequest, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Authenticate and check if a user is in any/all of the roles
+         * @summary Authenticate and Check Is In Role
+         * @param {AuthenticateAndCheckIsInRoleRequest} [authenticateAndCheckIsInRoleRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authenticateAndCheckIsInRole(authenticateAndCheckIsInRoleRequest?: AuthenticateAndCheckIsInRoleRequest, options?: RawAxiosRequestConfig): AxiosPromise<AuthenticateAndCheckIsInRoleResponse> {
+            return localVarFp.authenticateAndCheckIsInRole(authenticateAndCheckIsInRoleRequest, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Check if a user is authorized to perform an action
+         * @summary Authorize Request
+         * @param {AuthorizationRequest} [authorizationRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authorize(authorizationRequest?: AuthorizationRequest, options?: RawAxiosRequestConfig): AxiosPromise<AuthorizationResponse> {
+            return localVarFp.authorize(authorizationRequest, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Check if a user is authorized to perform an action on multiple resources
+         * @summary Authorize Batch Request
+         * @param {AuthorizationBatchRequest} [authorizationBatchRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authorizeBatch(authorizationBatchRequest?: AuthorizationBatchRequest, options?: RawAxiosRequestConfig): AxiosPromise<AuthorizationBatchResponse> {
+            return localVarFp.authorizeBatch(authorizationBatchRequest, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Check if a user is in any/all of the roles
+         * @summary Check Is In Role
+         * @param {IsInRoleRequest} [isInRoleRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        checkIsInRole(isInRoleRequest?: IsInRoleRequest, options?: RawAxiosRequestConfig): AxiosPromise<IsInRoleResponse> {
+            return localVarFp.checkIsInRole(isInRoleRequest, options).then((request) => request(axios, basePath));
+        },
     };
 };
 
 /**
- * AuthenticationApi - object-oriented interface
+ * AuthorizationApi - object-oriented interface
  * @export
- * @class AuthenticationApi
+ * @class AuthorizationApi
  * @extends {BaseAPI}
  */
-export class AuthenticationApi extends BaseAPI {
+export class AuthorizationApi extends BaseAPI {
     /**
      * Authenticate and authorize a user to perform an action
      * @summary Authenticate and authorize Request
-     * @param {AuthenticateAndAuthorizeRequest} [authenticateAndAuthorizeRequest] 
+     * @param {AuthenticateAndAuthorizeRequest} authenticateAndAuthorizeRequest 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof AuthenticationApi
+     * @memberof AuthorizationApi
      */
-    public authenticateAndAuthorize(authenticateAndAuthorizeRequest?: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig) {
-        return AuthenticationApiFp(this.configuration).authenticateAndAuthorize(authenticateAndAuthorizeRequest, options).then((request) => request(this.axios, this.basePath));
+    public authenticateAndAuthorize(authenticateAndAuthorizeRequest: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig) {
+        return AuthorizationApiFp(this.configuration).authenticateAndAuthorize(authenticateAndAuthorizeRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Authenticate and check if a user is in any/all of the roles
+     * @summary Authenticate and Check Is In Role
+     * @param {AuthenticateAndCheckIsInRoleRequest} [authenticateAndCheckIsInRoleRequest] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthorizationApi
+     */
+    public authenticateAndCheckIsInRole(authenticateAndCheckIsInRoleRequest?: AuthenticateAndCheckIsInRoleRequest, options?: RawAxiosRequestConfig) {
+        return AuthorizationApiFp(this.configuration).authenticateAndCheckIsInRole(authenticateAndCheckIsInRoleRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Check if a user is authorized to perform an action
+     * @summary Authorize Request
+     * @param {AuthorizationRequest} [authorizationRequest] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthorizationApi
+     */
+    public authorize(authorizationRequest?: AuthorizationRequest, options?: RawAxiosRequestConfig) {
+        return AuthorizationApiFp(this.configuration).authorize(authorizationRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Check if a user is authorized to perform an action on multiple resources
+     * @summary Authorize Batch Request
+     * @param {AuthorizationBatchRequest} [authorizationBatchRequest] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthorizationApi
+     */
+    public authorizeBatch(authorizationBatchRequest?: AuthorizationBatchRequest, options?: RawAxiosRequestConfig) {
+        return AuthorizationApiFp(this.configuration).authorizeBatch(authorizationBatchRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Check if a user is in any/all of the roles
+     * @summary Check Is In Role
+     * @param {IsInRoleRequest} [isInRoleRequest] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthorizationApi
+     */
+    public checkIsInRole(isInRoleRequest?: IsInRoleRequest, options?: RawAxiosRequestConfig) {
+        return AuthorizationApiFp(this.configuration).checkIsInRole(isInRoleRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }
 
 
 
 /**
- * AuthorizationApi - axios parameter creator
+ * AuthorizedEntitiesApi - axios parameter creator
  * @export
  */
-export const AuthorizationApiAxiosParamCreator = function (configuration?: Configuration) {
+export const AuthorizedEntitiesApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Authenticate and authorize a user to perform an action
-         * @summary Authenticate and authorize Request
-         * @param {AuthenticateAndAuthorizeRequest} [authenticateAndAuthorizeRequest] 
+         * Get the authorized brands for a given org
+         * @summary Get Authorized Brands
+         * @param {string} orgId 
+         * @param {GetAuthorizedBrandsRequest} [getAuthorizedBrandsRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getAuthorizedBrands: async (orgId: string, getAuthorizedBrandsRequest?: GetAuthorizedBrandsRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'orgId' is not null or undefined
+            assertParamExists('getAuthorizedBrands', 'orgId', orgId)
+            const localVarPath = `/orgs/{orgId}/getAuthorizedBrands`
+                .replace(`{${"orgId"}}`, encodeURIComponent(String(orgId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(getAuthorizedBrandsRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Get the authorized orgs for a given principal
+         * @summary Get Authorized Orgs
+         * @param {GetAuthorizedOrgsRequest} [getAuthorizedOrgsRequest] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        authenticateAndAuthorize: async (authenticateAndAuthorizeRequest?: AuthenticateAndAuthorizeRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/authenticateAndAuthorize`;
+        getAuthorizedOrgs: async (getAuthorizedOrgsRequest?: GetAuthorizedOrgsRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/getAuthorizedOrgs`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -1535,7 +2243,7 @@ export const AuthorizationApiAxiosParamCreator = function (configuration?: Confi
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(authenticateAndAuthorizeRequest, localVarRequestOptions, configuration)
+            localVarRequestOptions.data = serializeDataIfNeeded(getAuthorizedOrgsRequest, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -1543,14 +2251,18 @@ export const AuthorizationApiAxiosParamCreator = function (configuration?: Confi
             };
         },
         /**
-         * Check if a user is authorized to perform an action
-         * @summary Authorize Request
-         * @param {AuthorizationRequest} [authorizationRequest] 
+         * Get the authorized properties for a given org
+         * @summary Get Authorized Properties
+         * @param {string} orgId 
+         * @param {GetAuthorizedPropertiesRequest} [getAuthorizedPropertiesRequest] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        authorize: async (authorizationRequest?: AuthorizationRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/authorize`;
+        getAuthorizedProperties: async (orgId: string, getAuthorizedPropertiesRequest?: GetAuthorizedPropertiesRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'orgId' is not null or undefined
+            assertParamExists('getAuthorizedProperties', 'orgId', orgId)
+            const localVarPath = `/orgs/{orgId}/getAuthorizedProperties`
+                .replace(`{${"orgId"}}`, encodeURIComponent(String(orgId)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -1572,7 +2284,7 @@ export const AuthorizationApiAxiosParamCreator = function (configuration?: Confi
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
-            localVarRequestOptions.data = serializeDataIfNeeded(authorizationRequest, localVarRequestOptions, configuration)
+            localVarRequestOptions.data = serializeDataIfNeeded(getAuthorizedPropertiesRequest, localVarRequestOptions, configuration)
 
             return {
                 url: toPathString(localVarUrlObj),
@@ -1583,111 +2295,284 @@ export const AuthorizationApiAxiosParamCreator = function (configuration?: Confi
 };
 
 /**
- * AuthorizationApi - functional programming interface
+ * AuthorizedEntitiesApi - functional programming interface
  * @export
  */
-export const AuthorizationApiFp = function(configuration?: Configuration) {
-    const localVarAxiosParamCreator = AuthorizationApiAxiosParamCreator(configuration)
+export const AuthorizedEntitiesApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = AuthorizedEntitiesApiAxiosParamCreator(configuration)
     return {
         /**
-         * Authenticate and authorize a user to perform an action
-         * @summary Authenticate and authorize Request
-         * @param {AuthenticateAndAuthorizeRequest} [authenticateAndAuthorizeRequest] 
+         * Get the authorized brands for a given org
+         * @summary Get Authorized Brands
+         * @param {string} orgId 
+         * @param {GetAuthorizedBrandsRequest} [getAuthorizedBrandsRequest] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async authenticateAndAuthorize(authenticateAndAuthorizeRequest?: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AuthenticateAndAuthorizeResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.authenticateAndAuthorize(authenticateAndAuthorizeRequest, options);
+        async getAuthorizedBrands(orgId: string, getAuthorizedBrandsRequest?: GetAuthorizedBrandsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetAuthorizedBrandsResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getAuthorizedBrands(orgId, getAuthorizedBrandsRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['AuthorizationApi.authenticateAndAuthorize']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['AuthorizedEntitiesApi.getAuthorizedBrands']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Check if a user is authorized to perform an action
-         * @summary Authorize Request
-         * @param {AuthorizationRequest} [authorizationRequest] 
+         * Get the authorized orgs for a given principal
+         * @summary Get Authorized Orgs
+         * @param {GetAuthorizedOrgsRequest} [getAuthorizedOrgsRequest] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async authorize(authorizationRequest?: AuthorizationRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AuthorizationResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.authorize(authorizationRequest, options);
+        async getAuthorizedOrgs(getAuthorizedOrgsRequest?: GetAuthorizedOrgsRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetAuthorizedOrgsResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getAuthorizedOrgs(getAuthorizedOrgsRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['AuthorizationApi.authorize']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['AuthorizedEntitiesApi.getAuthorizedOrgs']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Get the authorized properties for a given org
+         * @summary Get Authorized Properties
+         * @param {string} orgId 
+         * @param {GetAuthorizedPropertiesRequest} [getAuthorizedPropertiesRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getAuthorizedProperties(orgId: string, getAuthorizedPropertiesRequest?: GetAuthorizedPropertiesRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetAuthorizedPropertiesResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getAuthorizedProperties(orgId, getAuthorizedPropertiesRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['AuthorizedEntitiesApi.getAuthorizedProperties']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     }
 };
 
 /**
- * AuthorizationApi - factory interface
+ * AuthorizedEntitiesApi - factory interface
  * @export
  */
-export const AuthorizationApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
-    const localVarFp = AuthorizationApiFp(configuration)
+export const AuthorizedEntitiesApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = AuthorizedEntitiesApiFp(configuration)
     return {
         /**
-         * Authenticate and authorize a user to perform an action
-         * @summary Authenticate and authorize Request
-         * @param {AuthenticateAndAuthorizeRequest} [authenticateAndAuthorizeRequest] 
+         * Get the authorized brands for a given org
+         * @summary Get Authorized Brands
+         * @param {string} orgId 
+         * @param {GetAuthorizedBrandsRequest} [getAuthorizedBrandsRequest] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        authenticateAndAuthorize(authenticateAndAuthorizeRequest?: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig): AxiosPromise<AuthenticateAndAuthorizeResponse> {
-            return localVarFp.authenticateAndAuthorize(authenticateAndAuthorizeRequest, options).then((request) => request(axios, basePath));
+        getAuthorizedBrands(orgId: string, getAuthorizedBrandsRequest?: GetAuthorizedBrandsRequest, options?: RawAxiosRequestConfig): AxiosPromise<GetAuthorizedBrandsResponse> {
+            return localVarFp.getAuthorizedBrands(orgId, getAuthorizedBrandsRequest, options).then((request) => request(axios, basePath));
         },
         /**
-         * Check if a user is authorized to perform an action
-         * @summary Authorize Request
-         * @param {AuthorizationRequest} [authorizationRequest] 
+         * Get the authorized orgs for a given principal
+         * @summary Get Authorized Orgs
+         * @param {GetAuthorizedOrgsRequest} [getAuthorizedOrgsRequest] 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        authorize(authorizationRequest?: AuthorizationRequest, options?: RawAxiosRequestConfig): AxiosPromise<AuthorizationResponse> {
-            return localVarFp.authorize(authorizationRequest, options).then((request) => request(axios, basePath));
+        getAuthorizedOrgs(getAuthorizedOrgsRequest?: GetAuthorizedOrgsRequest, options?: RawAxiosRequestConfig): AxiosPromise<GetAuthorizedOrgsResponse> {
+            return localVarFp.getAuthorizedOrgs(getAuthorizedOrgsRequest, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Get the authorized properties for a given org
+         * @summary Get Authorized Properties
+         * @param {string} orgId 
+         * @param {GetAuthorizedPropertiesRequest} [getAuthorizedPropertiesRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getAuthorizedProperties(orgId: string, getAuthorizedPropertiesRequest?: GetAuthorizedPropertiesRequest, options?: RawAxiosRequestConfig): AxiosPromise<GetAuthorizedPropertiesResponse> {
+            return localVarFp.getAuthorizedProperties(orgId, getAuthorizedPropertiesRequest, options).then((request) => request(axios, basePath));
         },
     };
 };
 
 /**
- * AuthorizationApi - object-oriented interface
+ * AuthorizedEntitiesApi - object-oriented interface
  * @export
- * @class AuthorizationApi
+ * @class AuthorizedEntitiesApi
  * @extends {BaseAPI}
  */
-export class AuthorizationApi extends BaseAPI {
+export class AuthorizedEntitiesApi extends BaseAPI {
     /**
-     * Authenticate and authorize a user to perform an action
-     * @summary Authenticate and authorize Request
-     * @param {AuthenticateAndAuthorizeRequest} [authenticateAndAuthorizeRequest] 
+     * Get the authorized brands for a given org
+     * @summary Get Authorized Brands
+     * @param {string} orgId 
+     * @param {GetAuthorizedBrandsRequest} [getAuthorizedBrandsRequest] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof AuthorizationApi
+     * @memberof AuthorizedEntitiesApi
      */
-    public authenticateAndAuthorize(authenticateAndAuthorizeRequest?: AuthenticateAndAuthorizeRequest, options?: RawAxiosRequestConfig) {
-        return AuthorizationApiFp(this.configuration).authenticateAndAuthorize(authenticateAndAuthorizeRequest, options).then((request) => request(this.axios, this.basePath));
+    public getAuthorizedBrands(orgId: string, getAuthorizedBrandsRequest?: GetAuthorizedBrandsRequest, options?: RawAxiosRequestConfig) {
+        return AuthorizedEntitiesApiFp(this.configuration).getAuthorizedBrands(orgId, getAuthorizedBrandsRequest, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
-     * Check if a user is authorized to perform an action
-     * @summary Authorize Request
-     * @param {AuthorizationRequest} [authorizationRequest] 
+     * Get the authorized orgs for a given principal
+     * @summary Get Authorized Orgs
+     * @param {GetAuthorizedOrgsRequest} [getAuthorizedOrgsRequest] 
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof AuthorizationApi
+     * @memberof AuthorizedEntitiesApi
      */
-    public authorize(authorizationRequest?: AuthorizationRequest, options?: RawAxiosRequestConfig) {
-        return AuthorizationApiFp(this.configuration).authorize(authorizationRequest, options).then((request) => request(this.axios, this.basePath));
+    public getAuthorizedOrgs(getAuthorizedOrgsRequest?: GetAuthorizedOrgsRequest, options?: RawAxiosRequestConfig) {
+        return AuthorizedEntitiesApiFp(this.configuration).getAuthorizedOrgs(getAuthorizedOrgsRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Get the authorized properties for a given org
+     * @summary Get Authorized Properties
+     * @param {string} orgId 
+     * @param {GetAuthorizedPropertiesRequest} [getAuthorizedPropertiesRequest] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthorizedEntitiesApi
+     */
+    public getAuthorizedProperties(orgId: string, getAuthorizedPropertiesRequest?: GetAuthorizedPropertiesRequest, options?: RawAxiosRequestConfig) {
+        return AuthorizedEntitiesApiFp(this.configuration).getAuthorizedProperties(orgId, getAuthorizedPropertiesRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }
 
 
 
 /**
- * PermissionsApi - axios parameter creator
+ * ConfigurationDataApi - axios parameter creator
  * @export
  */
-export const PermissionsApiAxiosParamCreator = function (configuration?: Configuration) {
+export const ConfigurationDataApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
+        /**
+         * List the available feature based roles
+         * @summary List Feature Based Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        configListFeatureBasedRoles: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/config/featureBasedRoles`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * List the available permissions
+         * @summary List Permissions
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        configListPermissions: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/config/permissions`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * List the available roles
+         * @summary List Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        configListRoles: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/config/roles`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * List the available feature based roles
+         * @summary List Feature Based Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listFeatureBasedRoles: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/featureBasedRoles`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * List the available permissions
          * @summary List Permissions
@@ -1712,6 +2597,39 @@ export const PermissionsApiAxiosParamCreator = function (configuration?: Configu
 
 
     
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * List the available roles
+         * @summary List Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listRoles: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/roles`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
@@ -1725,62 +2643,222 @@ export const PermissionsApiAxiosParamCreator = function (configuration?: Configu
 };
 
 /**
- * PermissionsApi - functional programming interface
+ * ConfigurationDataApi - functional programming interface
  * @export
  */
-export const PermissionsApiFp = function(configuration?: Configuration) {
-    const localVarAxiosParamCreator = PermissionsApiAxiosParamCreator(configuration)
+export const ConfigurationDataApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = ConfigurationDataApiAxiosParamCreator(configuration)
     return {
+        /**
+         * List the available feature based roles
+         * @summary List Feature Based Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async configListFeatureBasedRoles(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListFeatureBasedRolesSuccessResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.configListFeatureBasedRoles(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['ConfigurationDataApi.configListFeatureBasedRoles']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * List the available permissions
+         * @summary List Permissions
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async configListPermissions(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListPermissionsSuccessResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.configListPermissions(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['ConfigurationDataApi.configListPermissions']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * List the available roles
+         * @summary List Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async configListRoles(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListRolesSuccessResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.configListRoles(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['ConfigurationDataApi.configListRoles']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * List the available feature based roles
+         * @summary List Feature Based Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async listFeatureBasedRoles(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListFeatureBasedRolesSuccessResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listFeatureBasedRoles(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['ConfigurationDataApi.listFeatureBasedRoles']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * List the available permissions
          * @summary List Permissions
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async listPermissions(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GetPermissionsSuccessResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.listPermissions(options);
+        async listPermissions(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListPermissionsSuccessResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listPermissions(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['ConfigurationDataApi.listPermissions']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * List the available roles
+         * @summary List Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async listRoles(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ListRolesSuccessResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listRoles(options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['PermissionsApi.listPermissions']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['ConfigurationDataApi.listRoles']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     }
 };
 
 /**
- * PermissionsApi - factory interface
+ * ConfigurationDataApi - factory interface
  * @export
  */
-export const PermissionsApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
-    const localVarFp = PermissionsApiFp(configuration)
+export const ConfigurationDataApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = ConfigurationDataApiFp(configuration)
     return {
+        /**
+         * List the available feature based roles
+         * @summary List Feature Based Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        configListFeatureBasedRoles(options?: RawAxiosRequestConfig): AxiosPromise<ListFeatureBasedRolesSuccessResponse> {
+            return localVarFp.configListFeatureBasedRoles(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * List the available permissions
+         * @summary List Permissions
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        configListPermissions(options?: RawAxiosRequestConfig): AxiosPromise<ListPermissionsSuccessResponse> {
+            return localVarFp.configListPermissions(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * List the available roles
+         * @summary List Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        configListRoles(options?: RawAxiosRequestConfig): AxiosPromise<ListRolesSuccessResponse> {
+            return localVarFp.configListRoles(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * List the available feature based roles
+         * @summary List Feature Based Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listFeatureBasedRoles(options?: RawAxiosRequestConfig): AxiosPromise<ListFeatureBasedRolesSuccessResponse> {
+            return localVarFp.listFeatureBasedRoles(options).then((request) => request(axios, basePath));
+        },
         /**
          * List the available permissions
          * @summary List Permissions
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        listPermissions(options?: RawAxiosRequestConfig): AxiosPromise<GetPermissionsSuccessResponse> {
+        listPermissions(options?: RawAxiosRequestConfig): AxiosPromise<ListPermissionsSuccessResponse> {
             return localVarFp.listPermissions(options).then((request) => request(axios, basePath));
         },
+        /**
+         * List the available roles
+         * @summary List Roles
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listRoles(options?: RawAxiosRequestConfig): AxiosPromise<ListRolesSuccessResponse> {
+            return localVarFp.listRoles(options).then((request) => request(axios, basePath));
+        },
     };
 };
 
 /**
- * PermissionsApi - object-oriented interface
+ * ConfigurationDataApi - object-oriented interface
  * @export
- * @class PermissionsApi
+ * @class ConfigurationDataApi
  * @extends {BaseAPI}
  */
-export class PermissionsApi extends BaseAPI {
+export class ConfigurationDataApi extends BaseAPI {
+    /**
+     * List the available feature based roles
+     * @summary List Feature Based Roles
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ConfigurationDataApi
+     */
+    public configListFeatureBasedRoles(options?: RawAxiosRequestConfig) {
+        return ConfigurationDataApiFp(this.configuration).configListFeatureBasedRoles(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * List the available permissions
+     * @summary List Permissions
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ConfigurationDataApi
+     */
+    public configListPermissions(options?: RawAxiosRequestConfig) {
+        return ConfigurationDataApiFp(this.configuration).configListPermissions(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * List the available roles
+     * @summary List Roles
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ConfigurationDataApi
+     */
+    public configListRoles(options?: RawAxiosRequestConfig) {
+        return ConfigurationDataApiFp(this.configuration).configListRoles(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * List the available feature based roles
+     * @summary List Feature Based Roles
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ConfigurationDataApi
+     */
+    public listFeatureBasedRoles(options?: RawAxiosRequestConfig) {
+        return ConfigurationDataApiFp(this.configuration).listFeatureBasedRoles(options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * List the available permissions
      * @summary List Permissions
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
-     * @memberof PermissionsApi
+     * @memberof ConfigurationDataApi
      */
     public listPermissions(options?: RawAxiosRequestConfig) {
-        return PermissionsApiFp(this.configuration).listPermissions(options).then((request) => request(this.axios, this.basePath));
+        return ConfigurationDataApiFp(this.configuration).listPermissions(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * List the available roles
+     * @summary List Roles
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ConfigurationDataApi
+     */
+    public listRoles(options?: RawAxiosRequestConfig) {
+        return ConfigurationDataApiFp(this.configuration).listRoles(options).then((request) => request(this.axios, this.basePath));
     }
 }
 
@@ -1853,7 +2931,7 @@ export const RoleAssignmentApiAxiosParamCreator = function (configuration?: Conf
                 baseOptions = configuration.baseOptions;
             }
 
-            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
             const localVarHeaderParameter = {} as any;
             const localVarQueryParameter = {} as any;
 
@@ -2141,12 +3219,197 @@ export class RoleAssignmentApi extends BaseAPI {
 
 
 
+/**
+ * UserManagementApi - axios parameter creator
+ * @export
+ */
+export const UserManagementApiAxiosParamCreator = function (configuration?: Configuration) {
+    return {
+        /**
+         * List the users in a given org
+         * @summary List Users in Org
+         * @param {string} orgId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listUsersInOrg: async (orgId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'orgId' is not null or undefined
+            assertParamExists('listUsersInOrg', 'orgId', orgId)
+            const localVarPath = `/orgs/{orgId}/users`
+                .replace(`{${"orgId"}}`, encodeURIComponent(String(orgId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    }
+};
+
+/**
+ * UserManagementApi - functional programming interface
+ * @export
+ */
+export const UserManagementApiFp = function(configuration?: Configuration) {
+    const localVarAxiosParamCreator = UserManagementApiAxiosParamCreator(configuration)
+    return {
+        /**
+         * List the users in a given org
+         * @summary List Users in Org
+         * @param {string} orgId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async listUsersInOrg(orgId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PrincipalsInOrgResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listUsersInOrg(orgId, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['UserManagementApi.listUsersInOrg']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    }
+};
+
+/**
+ * UserManagementApi - factory interface
+ * @export
+ */
+export const UserManagementApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
+    const localVarFp = UserManagementApiFp(configuration)
+    return {
+        /**
+         * List the users in a given org
+         * @summary List Users in Org
+         * @param {string} orgId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listUsersInOrg(orgId: string, options?: RawAxiosRequestConfig): AxiosPromise<PrincipalsInOrgResponse> {
+            return localVarFp.listUsersInOrg(orgId, options).then((request) => request(axios, basePath));
+        },
+    };
+};
+
+/**
+ * UserManagementApi - object-oriented interface
+ * @export
+ * @class UserManagementApi
+ * @extends {BaseAPI}
+ */
+export class UserManagementApi extends BaseAPI {
+    /**
+     * List the users in a given org
+     * @summary List Users in Org
+     * @param {string} orgId 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof UserManagementApi
+     */
+    public listUsersInOrg(orgId: string, options?: RawAxiosRequestConfig) {
+        return UserManagementApiFp(this.configuration).listUsersInOrg(orgId, options).then((request) => request(this.axios, this.basePath));
+    }
+}
+
+
+
 /**
  * UserPermissionsApi - axios parameter creator
  * @export
  */
 export const UserPermissionsApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
+        /**
+         * List the available permissions for the current user
+         * @summary List Org Permissions
+         * @param {string} orgId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listOrgPermissions: async (orgId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'orgId' is not null or undefined
+            assertParamExists('listOrgPermissions', 'orgId', orgId)
+            const localVarPath = `/orgs/{orgId}/permissions`
+                .replace(`{${"orgId"}}`, encodeURIComponent(String(orgId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * List the available roles for the current user
+         * @summary List Org Roles
+         * @param {string} orgId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listOrgRoles: async (orgId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'orgId' is not null or undefined
+            assertParamExists('listOrgRoles', 'orgId', orgId)
+            const localVarPath = `/orgs/{orgId}/roles`
+                .replace(`{${"orgId"}}`, encodeURIComponent(String(orgId)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication ApiKeyAuth required
+            await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
+
+
+    
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * List the available permissions for the current user
          * @summary List Own Permissions
@@ -2235,6 +3498,32 @@ export const UserPermissionsApiAxiosParamCreator = function (configuration?: Con
 export const UserPermissionsApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = UserPermissionsApiAxiosParamCreator(configuration)
     return {
+        /**
+         * List the available permissions for the current user
+         * @summary List Org Permissions
+         * @param {string} orgId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async listOrgPermissions(orgId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: { [key: string]: GetUserPermissionsSuccessResponseResourcesValue; }; }>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listOrgPermissions(orgId, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['UserPermissionsApi.listOrgPermissions']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * List the available roles for the current user
+         * @summary List Org Roles
+         * @param {string} orgId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async listOrgRoles(orgId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: { [key: string]: ListOrgRolesSuccessResponseValueValue; }; }>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.listOrgRoles(orgId, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['UserPermissionsApi.listOrgRoles']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * List the available permissions for the current user
          * @summary List Own Permissions
@@ -2272,6 +3561,26 @@ export const UserPermissionsApiFp = function(configuration?: Configuration) {
 export const UserPermissionsApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
     const localVarFp = UserPermissionsApiFp(configuration)
     return {
+        /**
+         * List the available permissions for the current user
+         * @summary List Org Permissions
+         * @param {string} orgId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listOrgPermissions(orgId: string, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: { [key: string]: GetUserPermissionsSuccessResponseResourcesValue; }; }> {
+            return localVarFp.listOrgPermissions(orgId, options).then((request) => request(axios, basePath));
+        },
+        /**
+         * List the available roles for the current user
+         * @summary List Org Roles
+         * @param {string} orgId 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        listOrgRoles(orgId: string, options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: { [key: string]: ListOrgRolesSuccessResponseValueValue; }; }> {
+            return localVarFp.listOrgRoles(orgId, options).then((request) => request(axios, basePath));
+        },
         /**
          * List the available permissions for the current user
          * @summary List Own Permissions
@@ -2303,6 +3612,30 @@ export const UserPermissionsApiFactory = function (configuration?: Configuration
  * @extends {BaseAPI}
  */
 export class UserPermissionsApi extends BaseAPI {
+    /**
+     * List the available permissions for the current user
+     * @summary List Org Permissions
+     * @param {string} orgId 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof UserPermissionsApi
+     */
+    public listOrgPermissions(orgId: string, options?: RawAxiosRequestConfig) {
+        return UserPermissionsApiFp(this.configuration).listOrgPermissions(orgId, options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * List the available roles for the current user
+     * @summary List Org Roles
+     * @param {string} orgId 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof UserPermissionsApi
+     */
+    public listOrgRoles(orgId: string, options?: RawAxiosRequestConfig) {
+        return UserPermissionsApiFp(this.configuration).listOrgRoles(orgId, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * List the available permissions for the current user
      * @summary List Own Permissions