@seekora-ai/admin-api 1.1.56 → 1.1.58

package/api.ts

@@ -757,40 +757,140 @@ export interface AdminAnalyticsStoreXStoreIDQueriesQueryInsightsGet200Response {
 /**
  * 
  * @export
- * @interface AdminFeatureLimitsViolationsGet200Response
+ * @interface AdminPaymentGatewayVerifyInvoicePostRequest
  */
-export interface AdminFeatureLimitsViolationsGet200Response {
+export interface AdminPaymentGatewayVerifyInvoicePostRequest {
     /**
      * 
-     * @type {Array<DataTypesFeatureLimitViolation>}
-     * @memberof AdminFeatureLimitsViolationsGet200Response
+     * @type {string}
+     * @memberof AdminPaymentGatewayVerifyInvoicePostRequest
      */
-    'data'?: Array<DataTypesFeatureLimitViolation>;
+    'gateway_order_id'?: string;
+}
+/**
+ * 
+ * @export
+ * @interface AdminV1FeatureLimitsCheckGet200Response
+ */
+export interface AdminV1FeatureLimitsCheckGet200Response {
+    /**
+     * 
+     * @type {DataTypesFeatureCheckResult}
+     * @memberof AdminV1FeatureLimitsCheckGet200Response
+     */
+    'data'?: DataTypesFeatureCheckResult;
     /**
      * 
      * @type {string}
-     * @memberof AdminFeatureLimitsViolationsGet200Response
+     * @memberof AdminV1FeatureLimitsCheckGet200Response
      */
     'message'?: string;
     /**
      * 
      * @type {number}
-     * @memberof AdminFeatureLimitsViolationsGet200Response
+     * @memberof AdminV1FeatureLimitsCheckGet200Response
      */
     'status'?: number;
 }
 /**
  * 
  * @export
- * @interface AdminPaymentGatewayVerifyInvoicePostRequest
+ * @interface AdminV1FeatureLimitsHistoryGet200Response
  */
-export interface AdminPaymentGatewayVerifyInvoicePostRequest {
+export interface AdminV1FeatureLimitsHistoryGet200Response {
+    /**
+     * 
+     * @type {Array<DataTypesFeatureUsageHistory>}
+     * @memberof AdminV1FeatureLimitsHistoryGet200Response
+     */
+    'data'?: Array<DataTypesFeatureUsageHistory>;
     /**
      * 
      * @type {string}
-     * @memberof AdminPaymentGatewayVerifyInvoicePostRequest
+     * @memberof AdminV1FeatureLimitsHistoryGet200Response
      */
-    'gateway_order_id'?: string;
+    'message'?: string;
+    /**
+     * 
+     * @type {number}
+     * @memberof AdminV1FeatureLimitsHistoryGet200Response
+     */
+    'status'?: number;
+}
+/**
+ * 
+ * @export
+ * @interface AdminV1FeatureLimitsPlanGet200Response
+ */
+export interface AdminV1FeatureLimitsPlanGet200Response {
+    /**
+     * 
+     * @type {DataTypesPlanFeatures}
+     * @memberof AdminV1FeatureLimitsPlanGet200Response
+     */
+    'data'?: DataTypesPlanFeatures;
+    /**
+     * 
+     * @type {string}
+     * @memberof AdminV1FeatureLimitsPlanGet200Response
+     */
+    'message'?: string;
+    /**
+     * 
+     * @type {number}
+     * @memberof AdminV1FeatureLimitsPlanGet200Response
+     */
+    'status'?: number;
+}
+/**
+ * 
+ * @export
+ * @interface AdminV1FeatureLimitsUsageGet200Response
+ */
+export interface AdminV1FeatureLimitsUsageGet200Response {
+    /**
+     * 
+     * @type {Array<DataTypesFeatureUsageStats>}
+     * @memberof AdminV1FeatureLimitsUsageGet200Response
+     */
+    'data'?: Array<DataTypesFeatureUsageStats>;
+    /**
+     * 
+     * @type {string}
+     * @memberof AdminV1FeatureLimitsUsageGet200Response
+     */
+    'message'?: string;
+    /**
+     * 
+     * @type {number}
+     * @memberof AdminV1FeatureLimitsUsageGet200Response
+     */
+    'status'?: number;
+}
+/**
+ * 
+ * @export
+ * @interface AdminV1FeatureLimitsViolationsGet200Response
+ */
+export interface AdminV1FeatureLimitsViolationsGet200Response {
+    /**
+     * 
+     * @type {Array<DataTypesFeatureLimitViolation>}
+     * @memberof AdminV1FeatureLimitsViolationsGet200Response
+     */
+    'data'?: Array<DataTypesFeatureLimitViolation>;
+    /**
+     * 
+     * @type {string}
+     * @memberof AdminV1FeatureLimitsViolationsGet200Response
+     */
+    'message'?: string;
+    /**
+     * 
+     * @type {number}
+     * @memberof AdminV1FeatureLimitsViolationsGet200Response
+     */
+    'status'?: number;
 }
 /**
  * 
@@ -24392,106 +24492,6 @@ export interface FeatureLimitServiceLimitStatus {
      */
     'plan_name'?: string;
 }
-/**
- * 
- * @export
- * @interface FeatureLimitsCheckGet200Response
- */
-export interface FeatureLimitsCheckGet200Response {
-    /**
-     * 
-     * @type {DataTypesFeatureCheckResult}
-     * @memberof FeatureLimitsCheckGet200Response
-     */
-    'data'?: DataTypesFeatureCheckResult;
-    /**
-     * 
-     * @type {string}
-     * @memberof FeatureLimitsCheckGet200Response
-     */
-    'message'?: string;
-    /**
-     * 
-     * @type {number}
-     * @memberof FeatureLimitsCheckGet200Response
-     */
-    'status'?: number;
-}
-/**
- * 
- * @export
- * @interface FeatureLimitsHistoryGet200Response
- */
-export interface FeatureLimitsHistoryGet200Response {
-    /**
-     * 
-     * @type {Array<DataTypesFeatureUsageHistory>}
-     * @memberof FeatureLimitsHistoryGet200Response
-     */
-    'data'?: Array<DataTypesFeatureUsageHistory>;
-    /**
-     * 
-     * @type {string}
-     * @memberof FeatureLimitsHistoryGet200Response
-     */
-    'message'?: string;
-    /**
-     * 
-     * @type {number}
-     * @memberof FeatureLimitsHistoryGet200Response
-     */
-    'status'?: number;
-}
-/**
- * 
- * @export
- * @interface FeatureLimitsPlanGet200Response
- */
-export interface FeatureLimitsPlanGet200Response {
-    /**
-     * 
-     * @type {DataTypesPlanFeatures}
-     * @memberof FeatureLimitsPlanGet200Response
-     */
-    'data'?: DataTypesPlanFeatures;
-    /**
-     * 
-     * @type {string}
-     * @memberof FeatureLimitsPlanGet200Response
-     */
-    'message'?: string;
-    /**
-     * 
-     * @type {number}
-     * @memberof FeatureLimitsPlanGet200Response
-     */
-    'status'?: number;
-}
-/**
- * 
- * @export
- * @interface FeatureLimitsUsageGet200Response
- */
-export interface FeatureLimitsUsageGet200Response {
-    /**
-     * 
-     * @type {Array<DataTypesFeatureUsageStats>}
-     * @memberof FeatureLimitsUsageGet200Response
-     */
-    'data'?: Array<DataTypesFeatureUsageStats>;
-    /**
-     * 
-     * @type {string}
-     * @memberof FeatureLimitsUsageGet200Response
-     */
-    'message'?: string;
-    /**
-     * 
-     * @type {number}
-     * @memberof FeatureLimitsUsageGet200Response
-     */
-    'status'?: number;
-}
 /**
  * 
  * @export
@@ -43666,15 +43666,17 @@ export class ExternalAPINotificationsApi extends BaseAPI {
 export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Configuration) {
     return {
         /**
-         * Retrieves log of feature limit violations for monitoring
-         * @summary Get feature limit violations
-         * @param {string} [featureName] Filter by feature name
-         * @param {number} [limit] Number of records to return (default: 50)
+         * Checks if a specific feature is within limits without incrementing usage
+         * @summary Check if a feature can be used
+         * @param {string} featureName Feature name to check
+         * @param {number} [amount] Amount to check (default: 1)
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        adminFeatureLimitsViolationsGet: async (featureName?: string, limit?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/admin/feature-limits/violations`;
+        adminV1FeatureLimitsCheckGet: async (featureName: string, amount?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'featureName' is not null or undefined
+            assertParamExists('adminV1FeatureLimitsCheckGet', 'featureName', featureName)
+            const localVarPath = `/admin/v1/feature-limits/check`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -43693,8 +43695,8 @@ export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Confi
                 localVarQueryParameter['feature_name'] = featureName;
             }
 
-            if (limit !== undefined) {
-                localVarQueryParameter['limit'] = limit;
+            if (amount !== undefined) {
+                localVarQueryParameter['amount'] = amount;
             }
 
 
@@ -43709,17 +43711,15 @@ export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Confi
             };
         },
         /**
-         * Checks if a specific feature is within limits without incrementing usage
-         * @summary Check if a feature can be used
-         * @param {string} featureName Feature name to check
-         * @param {number} [amount] Amount to check (default: 1)
+         * Retrieves historical feature usage events for the organization
+         * @summary Get feature usage history
+         * @param {string} [featureName] Filter by feature name
+         * @param {number} [limit] Number of records to return (default: 100)
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsCheckGet: async (featureName: string, amount?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            // verify required parameter 'featureName' is not null or undefined
-            assertParamExists('featureLimitsCheckGet', 'featureName', featureName)
-            const localVarPath = `/feature-limits/check`;
+        adminV1FeatureLimitsHistoryGet: async (featureName?: string, limit?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/admin/v1/feature-limits/history`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -43738,8 +43738,8 @@ export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Confi
                 localVarQueryParameter['feature_name'] = featureName;
             }
 
-            if (amount !== undefined) {
-                localVarQueryParameter['amount'] = amount;
+            if (limit !== undefined) {
+                localVarQueryParameter['limit'] = limit;
             }
 
 
@@ -43754,15 +43754,13 @@ export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Confi
             };
         },
         /**
-         * Retrieves historical feature usage events for the organization
-         * @summary Get feature usage history
-         * @param {string} [featureName] Filter by feature name
-         * @param {number} [limit] Number of records to return (default: 100)
+         * Retrieves the organization\'s current plan with all feature limits
+         * @summary Get organization plan features
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsHistoryGet: async (featureName?: string, limit?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/feature-limits/history`;
+        adminV1FeatureLimitsPlanGet: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/admin/v1/feature-limits/plan`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -43777,14 +43775,6 @@ export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Confi
             // authentication BearerAuth required
             await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
 
-            if (featureName !== undefined) {
-                localVarQueryParameter['feature_name'] = featureName;
-            }
-
-            if (limit !== undefined) {
-                localVarQueryParameter['limit'] = limit;
-            }
-
 
     
             setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -43797,13 +43787,13 @@ export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Confi
             };
         },
         /**
-         * Retrieves the organization\'s current plan with all feature limits
-         * @summary Get organization plan features
+         * Returns plan details and feature availability map for UI rendering
+         * @summary Get plan information for frontend
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsPlanGet: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/feature-limits/plan`;
+        adminV1FeatureLimitsPlanInfoGet: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/admin/v1/feature-limits/plan/info`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -43830,13 +43820,13 @@ export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Confi
             };
         },
         /**
-         * Returns plan details and feature availability map for UI rendering
-         * @summary Get plan information for frontend
+         * Returns plan information and feature availability map for the current user
+         * @summary Get user plan information
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsPlanInfoGet: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/feature-limits/plan/info`;
+        adminV1FeatureLimitsPlanUserInfoGet: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/admin/v1/feature-limits/plan/user-info`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -43868,8 +43858,8 @@ export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Confi
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsStatusGet: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/feature-limits/status`;
+        adminV1FeatureLimitsStatusGet: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/admin/v1/feature-limits/status`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -43901,8 +43891,43 @@ export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Confi
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsUsageGet: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/feature-limits/usage`;
+        adminV1FeatureLimitsUsageGet: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/admin/v1/feature-limits/usage`;
+            // 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 BearerAuth 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,
+            };
+        },
+        /**
+         * Retrieves log of feature limit violations for monitoring
+         * @summary Get feature limit violations
+         * @param {string} [featureName] Filter by feature name
+         * @param {number} [limit] Number of records to return (default: 50)
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        adminV1FeatureLimitsViolationsGet: async (featureName?: string, limit?: number, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/admin/v1/feature-limits/violations`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -43917,6 +43942,14 @@ export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Confi
             // authentication BearerAuth required
             await setApiKeyToObject(localVarHeaderParameter, "Authorization", configuration)
 
+            if (featureName !== undefined) {
+                localVarQueryParameter['feature_name'] = featureName;
+            }
+
+            if (limit !== undefined) {
+                localVarQueryParameter['limit'] = limit;
+            }
+
 
     
             setSearchParams(localVarUrlObj, localVarQueryParameter);
@@ -43938,20 +43971,6 @@ export const FeatureLimitsApiAxiosParamCreator = function (configuration?: Confi
 export const FeatureLimitsApiFp = function(configuration?: Configuration) {
     const localVarAxiosParamCreator = FeatureLimitsApiAxiosParamCreator(configuration)
     return {
-        /**
-         * Retrieves log of feature limit violations for monitoring
-         * @summary Get feature limit violations
-         * @param {string} [featureName] Filter by feature name
-         * @param {number} [limit] Number of records to return (default: 50)
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        async adminFeatureLimitsViolationsGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AdminFeatureLimitsViolationsGet200Response>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.adminFeatureLimitsViolationsGet(featureName, limit, options);
-            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.adminFeatureLimitsViolationsGet']?.[localVarOperationServerIndex]?.url;
-            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
-        },
         /**
          * Checks if a specific feature is within limits without incrementing usage
          * @summary Check if a feature can be used
@@ -43960,10 +43979,10 @@ export const FeatureLimitsApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async featureLimitsCheckGet(featureName: string, amount?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FeatureLimitsCheckGet200Response>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.featureLimitsCheckGet(featureName, amount, options);
+        async adminV1FeatureLimitsCheckGet(featureName: string, amount?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AdminV1FeatureLimitsCheckGet200Response>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.adminV1FeatureLimitsCheckGet(featureName, amount, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.featureLimitsCheckGet']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.adminV1FeatureLimitsCheckGet']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -43974,10 +43993,10 @@ export const FeatureLimitsApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async featureLimitsHistoryGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FeatureLimitsHistoryGet200Response>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.featureLimitsHistoryGet(featureName, limit, options);
+        async adminV1FeatureLimitsHistoryGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AdminV1FeatureLimitsHistoryGet200Response>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.adminV1FeatureLimitsHistoryGet(featureName, limit, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.featureLimitsHistoryGet']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.adminV1FeatureLimitsHistoryGet']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -43986,10 +44005,10 @@ export const FeatureLimitsApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async featureLimitsPlanGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FeatureLimitsPlanGet200Response>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.featureLimitsPlanGet(options);
+        async adminV1FeatureLimitsPlanGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AdminV1FeatureLimitsPlanGet200Response>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.adminV1FeatureLimitsPlanGet(options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.featureLimitsPlanGet']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.adminV1FeatureLimitsPlanGet']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -43998,10 +44017,22 @@ export const FeatureLimitsApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async featureLimitsPlanInfoGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: any; }>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.featureLimitsPlanInfoGet(options);
+        async adminV1FeatureLimitsPlanInfoGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: any; }>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.adminV1FeatureLimitsPlanInfoGet(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.adminV1FeatureLimitsPlanInfoGet']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Returns plan information and feature availability map for the current user
+         * @summary Get user plan information
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async adminV1FeatureLimitsPlanUserInfoGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<{ [key: string]: any; }>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.adminV1FeatureLimitsPlanUserInfoGet(options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.featureLimitsPlanInfoGet']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.adminV1FeatureLimitsPlanUserInfoGet']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -44010,10 +44041,10 @@ export const FeatureLimitsApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async featureLimitsStatusGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DataTypesGenericResponseFeatureLimitServiceLimitStatus>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.featureLimitsStatusGet(options);
+        async adminV1FeatureLimitsStatusGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DataTypesGenericResponseFeatureLimitServiceLimitStatus>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.adminV1FeatureLimitsStatusGet(options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.featureLimitsStatusGet']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.adminV1FeatureLimitsStatusGet']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -44022,10 +44053,24 @@ export const FeatureLimitsApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async featureLimitsUsageGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FeatureLimitsUsageGet200Response>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.featureLimitsUsageGet(options);
+        async adminV1FeatureLimitsUsageGet(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AdminV1FeatureLimitsUsageGet200Response>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.adminV1FeatureLimitsUsageGet(options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.featureLimitsUsageGet']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.adminV1FeatureLimitsUsageGet']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+        /**
+         * Retrieves log of feature limit violations for monitoring
+         * @summary Get feature limit violations
+         * @param {string} [featureName] Filter by feature name
+         * @param {number} [limit] Number of records to return (default: 50)
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async adminV1FeatureLimitsViolationsGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AdminV1FeatureLimitsViolationsGet200Response>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.adminV1FeatureLimitsViolationsGet(featureName, limit, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsApi.adminV1FeatureLimitsViolationsGet']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     }
@@ -44038,17 +44083,6 @@ export const FeatureLimitsApiFp = function(configuration?: Configuration) {
 export const FeatureLimitsApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
     const localVarFp = FeatureLimitsApiFp(configuration)
     return {
-        /**
-         * Retrieves log of feature limit violations for monitoring
-         * @summary Get feature limit violations
-         * @param {string} [featureName] Filter by feature name
-         * @param {number} [limit] Number of records to return (default: 50)
-         * @param {*} [options] Override http request option.
-         * @throws {RequiredError}
-         */
-        adminFeatureLimitsViolationsGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig): AxiosPromise<AdminFeatureLimitsViolationsGet200Response> {
-            return localVarFp.adminFeatureLimitsViolationsGet(featureName, limit, options).then((request) => request(axios, basePath));
-        },
         /**
          * Checks if a specific feature is within limits without incrementing usage
          * @summary Check if a feature can be used
@@ -44057,8 +44091,8 @@ export const FeatureLimitsApiFactory = function (configuration?: Configuration,
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsCheckGet(featureName: string, amount?: number, options?: RawAxiosRequestConfig): AxiosPromise<FeatureLimitsCheckGet200Response> {
-            return localVarFp.featureLimitsCheckGet(featureName, amount, options).then((request) => request(axios, basePath));
+        adminV1FeatureLimitsCheckGet(featureName: string, amount?: number, options?: RawAxiosRequestConfig): AxiosPromise<AdminV1FeatureLimitsCheckGet200Response> {
+            return localVarFp.adminV1FeatureLimitsCheckGet(featureName, amount, options).then((request) => request(axios, basePath));
         },
         /**
          * Retrieves historical feature usage events for the organization
@@ -44068,8 +44102,8 @@ export const FeatureLimitsApiFactory = function (configuration?: Configuration,
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsHistoryGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig): AxiosPromise<FeatureLimitsHistoryGet200Response> {
-            return localVarFp.featureLimitsHistoryGet(featureName, limit, options).then((request) => request(axios, basePath));
+        adminV1FeatureLimitsHistoryGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig): AxiosPromise<AdminV1FeatureLimitsHistoryGet200Response> {
+            return localVarFp.adminV1FeatureLimitsHistoryGet(featureName, limit, options).then((request) => request(axios, basePath));
         },
         /**
          * Retrieves the organization\'s current plan with all feature limits
@@ -44077,8 +44111,8 @@ export const FeatureLimitsApiFactory = function (configuration?: Configuration,
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsPlanGet(options?: RawAxiosRequestConfig): AxiosPromise<FeatureLimitsPlanGet200Response> {
-            return localVarFp.featureLimitsPlanGet(options).then((request) => request(axios, basePath));
+        adminV1FeatureLimitsPlanGet(options?: RawAxiosRequestConfig): AxiosPromise<AdminV1FeatureLimitsPlanGet200Response> {
+            return localVarFp.adminV1FeatureLimitsPlanGet(options).then((request) => request(axios, basePath));
         },
         /**
          * Returns plan details and feature availability map for UI rendering
@@ -44086,8 +44120,17 @@ export const FeatureLimitsApiFactory = function (configuration?: Configuration,
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsPlanInfoGet(options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: any; }> {
-            return localVarFp.featureLimitsPlanInfoGet(options).then((request) => request(axios, basePath));
+        adminV1FeatureLimitsPlanInfoGet(options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: any; }> {
+            return localVarFp.adminV1FeatureLimitsPlanInfoGet(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Returns plan information and feature availability map for the current user
+         * @summary Get user plan information
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        adminV1FeatureLimitsPlanUserInfoGet(options?: RawAxiosRequestConfig): AxiosPromise<{ [key: string]: any; }> {
+            return localVarFp.adminV1FeatureLimitsPlanUserInfoGet(options).then((request) => request(axios, basePath));
         },
         /**
          * Retrieves comprehensive real-time limit status for the organization including all features, credits, and API calls
@@ -44095,8 +44138,8 @@ export const FeatureLimitsApiFactory = function (configuration?: Configuration,
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsStatusGet(options?: RawAxiosRequestConfig): AxiosPromise<DataTypesGenericResponseFeatureLimitServiceLimitStatus> {
-            return localVarFp.featureLimitsStatusGet(options).then((request) => request(axios, basePath));
+        adminV1FeatureLimitsStatusGet(options?: RawAxiosRequestConfig): AxiosPromise<DataTypesGenericResponseFeatureLimitServiceLimitStatus> {
+            return localVarFp.adminV1FeatureLimitsStatusGet(options).then((request) => request(axios, basePath));
         },
         /**
          * Retrieves current feature usage statistics for the organization
@@ -44104,8 +44147,19 @@ export const FeatureLimitsApiFactory = function (configuration?: Configuration,
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        featureLimitsUsageGet(options?: RawAxiosRequestConfig): AxiosPromise<FeatureLimitsUsageGet200Response> {
-            return localVarFp.featureLimitsUsageGet(options).then((request) => request(axios, basePath));
+        adminV1FeatureLimitsUsageGet(options?: RawAxiosRequestConfig): AxiosPromise<AdminV1FeatureLimitsUsageGet200Response> {
+            return localVarFp.adminV1FeatureLimitsUsageGet(options).then((request) => request(axios, basePath));
+        },
+        /**
+         * Retrieves log of feature limit violations for monitoring
+         * @summary Get feature limit violations
+         * @param {string} [featureName] Filter by feature name
+         * @param {number} [limit] Number of records to return (default: 50)
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        adminV1FeatureLimitsViolationsGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig): AxiosPromise<AdminV1FeatureLimitsViolationsGet200Response> {
+            return localVarFp.adminV1FeatureLimitsViolationsGet(featureName, limit, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -44117,19 +44171,6 @@ export const FeatureLimitsApiFactory = function (configuration?: Configuration,
  * @extends {BaseAPI}
  */
 export class FeatureLimitsApi extends BaseAPI {
-    /**
-     * Retrieves log of feature limit violations for monitoring
-     * @summary Get feature limit violations
-     * @param {string} [featureName] Filter by feature name
-     * @param {number} [limit] Number of records to return (default: 50)
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     * @memberof FeatureLimitsApi
-     */
-    public adminFeatureLimitsViolationsGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig) {
-        return FeatureLimitsApiFp(this.configuration).adminFeatureLimitsViolationsGet(featureName, limit, options).then((request) => request(this.axios, this.basePath));
-    }
-
     /**
      * Checks if a specific feature is within limits without incrementing usage
      * @summary Check if a feature can be used
@@ -44139,8 +44180,8 @@ export class FeatureLimitsApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof FeatureLimitsApi
      */
-    public featureLimitsCheckGet(featureName: string, amount?: number, options?: RawAxiosRequestConfig) {
-        return FeatureLimitsApiFp(this.configuration).featureLimitsCheckGet(featureName, amount, options).then((request) => request(this.axios, this.basePath));
+    public adminV1FeatureLimitsCheckGet(featureName: string, amount?: number, options?: RawAxiosRequestConfig) {
+        return FeatureLimitsApiFp(this.configuration).adminV1FeatureLimitsCheckGet(featureName, amount, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -44152,8 +44193,8 @@ export class FeatureLimitsApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof FeatureLimitsApi
      */
-    public featureLimitsHistoryGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig) {
-        return FeatureLimitsApiFp(this.configuration).featureLimitsHistoryGet(featureName, limit, options).then((request) => request(this.axios, this.basePath));
+    public adminV1FeatureLimitsHistoryGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig) {
+        return FeatureLimitsApiFp(this.configuration).adminV1FeatureLimitsHistoryGet(featureName, limit, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -44163,8 +44204,8 @@ export class FeatureLimitsApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof FeatureLimitsApi
      */
-    public featureLimitsPlanGet(options?: RawAxiosRequestConfig) {
-        return FeatureLimitsApiFp(this.configuration).featureLimitsPlanGet(options).then((request) => request(this.axios, this.basePath));
+    public adminV1FeatureLimitsPlanGet(options?: RawAxiosRequestConfig) {
+        return FeatureLimitsApiFp(this.configuration).adminV1FeatureLimitsPlanGet(options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -44174,8 +44215,19 @@ export class FeatureLimitsApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof FeatureLimitsApi
      */
-    public featureLimitsPlanInfoGet(options?: RawAxiosRequestConfig) {
-        return FeatureLimitsApiFp(this.configuration).featureLimitsPlanInfoGet(options).then((request) => request(this.axios, this.basePath));
+    public adminV1FeatureLimitsPlanInfoGet(options?: RawAxiosRequestConfig) {
+        return FeatureLimitsApiFp(this.configuration).adminV1FeatureLimitsPlanInfoGet(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Returns plan information and feature availability map for the current user
+     * @summary Get user plan information
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FeatureLimitsApi
+     */
+    public adminV1FeatureLimitsPlanUserInfoGet(options?: RawAxiosRequestConfig) {
+        return FeatureLimitsApiFp(this.configuration).adminV1FeatureLimitsPlanUserInfoGet(options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -44185,8 +44237,8 @@ export class FeatureLimitsApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof FeatureLimitsApi
      */
-    public featureLimitsStatusGet(options?: RawAxiosRequestConfig) {
-        return FeatureLimitsApiFp(this.configuration).featureLimitsStatusGet(options).then((request) => request(this.axios, this.basePath));
+    public adminV1FeatureLimitsStatusGet(options?: RawAxiosRequestConfig) {
+        return FeatureLimitsApiFp(this.configuration).adminV1FeatureLimitsStatusGet(options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -44196,8 +44248,21 @@ export class FeatureLimitsApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof FeatureLimitsApi
      */
-    public featureLimitsUsageGet(options?: RawAxiosRequestConfig) {
-        return FeatureLimitsApiFp(this.configuration).featureLimitsUsageGet(options).then((request) => request(this.axios, this.basePath));
+    public adminV1FeatureLimitsUsageGet(options?: RawAxiosRequestConfig) {
+        return FeatureLimitsApiFp(this.configuration).adminV1FeatureLimitsUsageGet(options).then((request) => request(this.axios, this.basePath));
+    }
+
+    /**
+     * Retrieves log of feature limit violations for monitoring
+     * @summary Get feature limit violations
+     * @param {string} [featureName] Filter by feature name
+     * @param {number} [limit] Number of records to return (default: 50)
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof FeatureLimitsApi
+     */
+    public adminV1FeatureLimitsViolationsGet(featureName?: string, limit?: number, options?: RawAxiosRequestConfig) {
+        return FeatureLimitsApiFp(this.configuration).adminV1FeatureLimitsViolationsGet(featureName, limit, options).then((request) => request(this.axios, this.basePath));
     }
 }
 
@@ -44215,8 +44280,8 @@ export const FeatureLimitsAdminApiAxiosParamCreator = function (configuration?:
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        adminFeatureLimitsCacheInvalidatePost: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/admin/feature-limits/cache/invalidate`;
+        adminV1FeatureLimitsCacheInvalidatePost: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/admin/v1/feature-limits/cache/invalidate`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -44249,8 +44314,8 @@ export const FeatureLimitsAdminApiAxiosParamCreator = function (configuration?:
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        adminFeatureLimitsMetricsSyncPost: async (force?: boolean, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/admin/feature-limits/metrics/sync`;
+        adminV1FeatureLimitsMetricsSyncPost: async (force?: boolean, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/admin/v1/feature-limits/metrics/sync`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -44287,10 +44352,10 @@ export const FeatureLimitsAdminApiAxiosParamCreator = function (configuration?:
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        adminFeatureLimitsResetPost: async (featureName: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        adminV1FeatureLimitsResetPost: async (featureName: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             // verify required parameter 'featureName' is not null or undefined
-            assertParamExists('adminFeatureLimitsResetPost', 'featureName', featureName)
-            const localVarPath = `/admin/feature-limits/reset`;
+            assertParamExists('adminV1FeatureLimitsResetPost', 'featureName', featureName)
+            const localVarPath = `/admin/v1/feature-limits/reset`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -44336,10 +44401,10 @@ export const FeatureLimitsAdminApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async adminFeatureLimitsCacheInvalidatePost(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DataTypesResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.adminFeatureLimitsCacheInvalidatePost(options);
+        async adminV1FeatureLimitsCacheInvalidatePost(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DataTypesResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.adminV1FeatureLimitsCacheInvalidatePost(options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsAdminApi.adminFeatureLimitsCacheInvalidatePost']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsAdminApi.adminV1FeatureLimitsCacheInvalidatePost']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -44349,10 +44414,10 @@ export const FeatureLimitsAdminApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async adminFeatureLimitsMetricsSyncPost(force?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DataTypesResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.adminFeatureLimitsMetricsSyncPost(force, options);
+        async adminV1FeatureLimitsMetricsSyncPost(force?: boolean, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DataTypesResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.adminV1FeatureLimitsMetricsSyncPost(force, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsAdminApi.adminFeatureLimitsMetricsSyncPost']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsAdminApi.adminV1FeatureLimitsMetricsSyncPost']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
@@ -44362,10 +44427,10 @@ export const FeatureLimitsAdminApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async adminFeatureLimitsResetPost(featureName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DataTypesResponse>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.adminFeatureLimitsResetPost(featureName, options);
+        async adminV1FeatureLimitsResetPost(featureName: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DataTypesResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.adminV1FeatureLimitsResetPost(featureName, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsAdminApi.adminFeatureLimitsResetPost']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['FeatureLimitsAdminApi.adminV1FeatureLimitsResetPost']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     }
@@ -44384,8 +44449,8 @@ export const FeatureLimitsAdminApiFactory = function (configuration?: Configurat
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        adminFeatureLimitsCacheInvalidatePost(options?: RawAxiosRequestConfig): AxiosPromise<DataTypesResponse> {
-            return localVarFp.adminFeatureLimitsCacheInvalidatePost(options).then((request) => request(axios, basePath));
+        adminV1FeatureLimitsCacheInvalidatePost(options?: RawAxiosRequestConfig): AxiosPromise<DataTypesResponse> {
+            return localVarFp.adminV1FeatureLimitsCacheInvalidatePost(options).then((request) => request(axios, basePath));
         },
         /**
          * Recalculates and syncs all metrics for the organization from source tables to database and Redis. For increment-based metrics (api_calls, analytics_events), only syncs if Redis is empty unless force=true
@@ -44394,8 +44459,8 @@ export const FeatureLimitsAdminApiFactory = function (configuration?: Configurat
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        adminFeatureLimitsMetricsSyncPost(force?: boolean, options?: RawAxiosRequestConfig): AxiosPromise<DataTypesResponse> {
-            return localVarFp.adminFeatureLimitsMetricsSyncPost(force, options).then((request) => request(axios, basePath));
+        adminV1FeatureLimitsMetricsSyncPost(force?: boolean, options?: RawAxiosRequestConfig): AxiosPromise<DataTypesResponse> {
+            return localVarFp.adminV1FeatureLimitsMetricsSyncPost(force, options).then((request) => request(axios, basePath));
         },
         /**
          * Resets usage counter for a specific feature (admin only)
@@ -44404,8 +44469,8 @@ export const FeatureLimitsAdminApiFactory = function (configuration?: Configurat
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        adminFeatureLimitsResetPost(featureName: string, options?: RawAxiosRequestConfig): AxiosPromise<DataTypesResponse> {
-            return localVarFp.adminFeatureLimitsResetPost(featureName, options).then((request) => request(axios, basePath));
+        adminV1FeatureLimitsResetPost(featureName: string, options?: RawAxiosRequestConfig): AxiosPromise<DataTypesResponse> {
+            return localVarFp.adminV1FeatureLimitsResetPost(featureName, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -44424,8 +44489,8 @@ export class FeatureLimitsAdminApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof FeatureLimitsAdminApi
      */
-    public adminFeatureLimitsCacheInvalidatePost(options?: RawAxiosRequestConfig) {
-        return FeatureLimitsAdminApiFp(this.configuration).adminFeatureLimitsCacheInvalidatePost(options).then((request) => request(this.axios, this.basePath));
+    public adminV1FeatureLimitsCacheInvalidatePost(options?: RawAxiosRequestConfig) {
+        return FeatureLimitsAdminApiFp(this.configuration).adminV1FeatureLimitsCacheInvalidatePost(options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -44436,8 +44501,8 @@ export class FeatureLimitsAdminApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof FeatureLimitsAdminApi
      */
-    public adminFeatureLimitsMetricsSyncPost(force?: boolean, options?: RawAxiosRequestConfig) {
-        return FeatureLimitsAdminApiFp(this.configuration).adminFeatureLimitsMetricsSyncPost(force, options).then((request) => request(this.axios, this.basePath));
+    public adminV1FeatureLimitsMetricsSyncPost(force?: boolean, options?: RawAxiosRequestConfig) {
+        return FeatureLimitsAdminApiFp(this.configuration).adminV1FeatureLimitsMetricsSyncPost(force, options).then((request) => request(this.axios, this.basePath));
     }
 
     /**
@@ -44448,8 +44513,8 @@ export class FeatureLimitsAdminApi extends BaseAPI {
      * @throws {RequiredError}
      * @memberof FeatureLimitsAdminApi
      */
-    public adminFeatureLimitsResetPost(featureName: string, options?: RawAxiosRequestConfig) {
-        return FeatureLimitsAdminApiFp(this.configuration).adminFeatureLimitsResetPost(featureName, options).then((request) => request(this.axios, this.basePath));
+    public adminV1FeatureLimitsResetPost(featureName: string, options?: RawAxiosRequestConfig) {
+        return FeatureLimitsAdminApiFp(this.configuration).adminV1FeatureLimitsResetPost(featureName, options).then((request) => request(this.axios, this.basePath));
     }
 }