@digital-ai/dot-components 5.5.1 → 5.6.0

package/index.esm.js

@@ -2076,19 +2076,6 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
 typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
@@ -2273,7 +2260,7 @@ function getResponseBody$1(response) {
     return null;
   });
 }
-function catchErrors(options, result) {
+function catchErrors$1(options, result) {
   const errors = Object.assign({
     400: 'Bad Request',
     401: 'Unauthorized',
@@ -2310,7 +2297,7 @@ function request$1(options) {
       statusText: response.statusText,
       body: responseHeader || responseBody
     };
-    catchErrors(options, result);
+    catchErrors$1(options, result);
     return result;
   });
 }
@@ -9533,126 +9520,25 @@ const DotPill = ({
 };
 
 class ApiError extends Error {
-  constructor(request, response, message) {
+  constructor(response, message) {
     super(message);
-    this.name = 'ApiError';
     this.url = response.url;
     this.status = response.status;
     this.statusText = response.statusText;
     this.body = response.body;
-    this.request = request;
-  }
-}
-
-var _CancelablePromise_isResolved, _CancelablePromise_isRejected, _CancelablePromise_isCancelled, _CancelablePromise_cancelHandlers, _CancelablePromise_promise, _CancelablePromise_resolve, _CancelablePromise_reject;
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-class CancelError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'CancelError';
-  }
-  get isCancelled() {
-    return true;
-  }
-}
-class CancelablePromise {
-  constructor(executor) {
-    _CancelablePromise_isResolved.set(this, void 0);
-    _CancelablePromise_isRejected.set(this, void 0);
-    _CancelablePromise_isCancelled.set(this, void 0);
-    _CancelablePromise_cancelHandlers.set(this, void 0);
-    _CancelablePromise_promise.set(this, void 0);
-    _CancelablePromise_resolve.set(this, void 0);
-    _CancelablePromise_reject.set(this, void 0);
-    __classPrivateFieldSet(this, _CancelablePromise_isResolved, false, "f");
-    __classPrivateFieldSet(this, _CancelablePromise_isRejected, false, "f");
-    __classPrivateFieldSet(this, _CancelablePromise_isCancelled, false, "f");
-    __classPrivateFieldSet(this, _CancelablePromise_cancelHandlers, [], "f");
-    __classPrivateFieldSet(this, _CancelablePromise_promise, new Promise((resolve, reject) => {
-      __classPrivateFieldSet(this, _CancelablePromise_resolve, resolve, "f");
-      __classPrivateFieldSet(this, _CancelablePromise_reject, reject, "f");
-      const onResolve = value => {
-        if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
-          return;
-        }
-        __classPrivateFieldSet(this, _CancelablePromise_isResolved, true, "f");
-        if (__classPrivateFieldGet(this, _CancelablePromise_resolve, "f")) __classPrivateFieldGet(this, _CancelablePromise_resolve, "f").call(this, value);
-      };
-      const onReject = reason => {
-        if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
-          return;
-        }
-        __classPrivateFieldSet(this, _CancelablePromise_isRejected, true, "f");
-        if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f")) __classPrivateFieldGet(this, _CancelablePromise_reject, "f").call(this, reason);
-      };
-      const onCancel = cancelHandler => {
-        if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
-          return;
-        }
-        __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").push(cancelHandler);
-      };
-      Object.defineProperty(onCancel, 'isResolved', {
-        get: () => __classPrivateFieldGet(this, _CancelablePromise_isResolved, "f")
-      });
-      Object.defineProperty(onCancel, 'isRejected', {
-        get: () => __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f")
-      });
-      Object.defineProperty(onCancel, 'isCancelled', {
-        get: () => __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")
-      });
-      return executor(onResolve, onReject, onCancel);
-    }), "f");
-  }
-  get [(_CancelablePromise_isResolved = new WeakMap(), _CancelablePromise_isRejected = new WeakMap(), _CancelablePromise_isCancelled = new WeakMap(), _CancelablePromise_cancelHandlers = new WeakMap(), _CancelablePromise_promise = new WeakMap(), _CancelablePromise_resolve = new WeakMap(), _CancelablePromise_reject = new WeakMap(), Symbol.toStringTag)]() {
-    return 'Cancellable Promise';
-  }
-  then(onFulfilled, onRejected) {
-    return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").then(onFulfilled, onRejected);
-  }
-  catch(onRejected) {
-    return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").catch(onRejected);
-  }
-  finally(onFinally) {
-    return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").finally(onFinally);
-  }
-  cancel() {
-    if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
-      return;
-    }
-    __classPrivateFieldSet(this, _CancelablePromise_isCancelled, true, "f");
-    if (__classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length) {
-      try {
-        for (const cancelHandler of __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f")) {
-          cancelHandler();
-        }
-      } catch (error) {
-        console.warn('Cancellation threw an error', error);
-        return;
-      }
-    }
-    __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length = 0;
-    if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f")) __classPrivateFieldGet(this, _CancelablePromise_reject, "f").call(this, new CancelError('Request aborted'));
-  }
-  get isCancelled() {
-    return __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f");
   }
 }
 
 const OpenAPI = {
   BASE: '',
-  VERSION: '0.1',
-  WITH_CREDENTIALS: false,
-  CREDENTIALS: 'include',
   TOKEN: undefined,
   USERNAME: undefined,
   PASSWORD: undefined,
-  HEADERS: undefined,
-  ENCODE_PATH: undefined
-};
+  HEADERS: undefined};
 
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
 var DashboardCreateBody;
 (function (DashboardCreateBody) {
   (function (lifecycle_state) {
@@ -9665,6 +9551,9 @@ var DashboardCreateBody;
   })(DashboardCreateBody.bi_type || (DashboardCreateBody.bi_type = {}));
 })(DashboardCreateBody || (DashboardCreateBody = {}));
 
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
 var DashboardPatchBody;
 (function (DashboardPatchBody) {
   (function (lifecycle_state) {
@@ -9677,6 +9566,9 @@ var DashboardPatchBody;
   })(DashboardPatchBody.bi_type || (DashboardPatchBody.bi_type = {}));
 })(DashboardPatchBody || (DashboardPatchBody = {}));
 
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
 var DashboardPutBody;
 (function (DashboardPutBody) {
   (function (lifecycle_state) {
@@ -9689,6 +9581,9 @@ var DashboardPutBody;
   })(DashboardPutBody.bi_type || (DashboardPutBody.bi_type = {}));
 })(DashboardPutBody || (DashboardPutBody = {}));
 
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
 var DashboardView;
 (function (DashboardView) {
   (function (lifecycle_state) {
@@ -9701,180 +9596,159 @@ var DashboardView;
   })(DashboardView.bi_type || (DashboardView.bi_type = {}));
 })(DashboardView || (DashboardView = {}));
 
-const isDefined = value => {
+function isDefined(value) {
   return value !== undefined && value !== null;
-};
-const isString = value => {
+}
+function isString(value) {
   return typeof value === 'string';
-};
-const isStringWithValue = value => {
+}
+function isStringWithValue(value) {
   return isString(value) && value !== '';
-};
-const isBlob = value => {
-  return typeof value === 'object' && typeof value.type === 'string' && typeof value.stream === 'function' && typeof value.arrayBuffer === 'function' && typeof value.constructor === 'function' && typeof value.constructor.name === 'string' && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
-};
-const isFormData = value => {
-  return value instanceof FormData;
-};
-const base64 = str => {
+}
+function isBlob(value) {
+  return value instanceof Blob;
+}
+function base64(str) {
   try {
     return btoa(str);
   } catch (err) {
-    // @ts-ignore
     return Buffer.from(str).toString('base64');
   }
-};
-const getQueryString = params => {
+}
+function getQueryString(params) {
   const qs = [];
-  const append = (key, value) => {
-    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
-  };
-  const process = (key, value) => {
+  Object.keys(params).forEach(key => {
+    const value = params[key];
     if (isDefined(value)) {
       if (Array.isArray(value)) {
-        value.forEach(v => {
-          process(key, v);
-        });
-      } else if (typeof value === 'object') {
-        Object.entries(value).forEach(([k, v]) => {
-          process(`${key}[${k}]`, v);
+        value.forEach(value => {
+          qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
         });
       } else {
-        append(key, value);
+        qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
       }
     }
-  };
-  Object.entries(params).forEach(([key, value]) => {
-    process(key, value);
   });
   if (qs.length > 0) {
     return `?${qs.join('&')}`;
   }
   return '';
-};
-const getUrl = (config, options) => {
-  const encoder = encodeURI;
-  const path = options.url.replace('{api-version}', config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
-    var _a;
-    if ((_a = options.path) === null || _a === void 0 ? void 0 : _a.hasOwnProperty(group)) {
-      return encoder(String(options.path[group]));
-    }
-    return substring;
-  });
-  const url = `${config.BASE}${path}`;
+}
+function getUrl(options) {
+  const path = options.path;
+  const url = `${OpenAPI.BASE}${path}`;
   if (options.query) {
     return `${url}${getQueryString(options.query)}`;
   }
   return url;
-};
-const getFormData = options => {
-  if (options.formData) {
-    const formData = new FormData();
-    const process = (key, value) => {
-      if (isString(value) || isBlob(value)) {
-        formData.append(key, value);
-      } else {
-        formData.append(key, JSON.stringify(value));
-      }
-    };
-    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
-      if (Array.isArray(value)) {
-        value.forEach(v => process(key, v));
+}
+function getFormData(params) {
+  const formData = new FormData();
+  Object.keys(params).forEach(key => {
+    const value = params[key];
+    if (isDefined(value)) {
+      formData.append(key, value);
+    }
+  });
+  return formData;
+}
+function resolve(options, resolver) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (typeof resolver === 'function') {
+      return resolver(options);
+    }
+    return resolver;
+  });
+}
+function getHeaders(options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const token = yield resolve(options, OpenAPI.TOKEN);
+    const username = yield resolve(options, OpenAPI.USERNAME);
+    const password = yield resolve(options, OpenAPI.PASSWORD);
+    const additionalHeaders = yield resolve(options, OpenAPI.HEADERS);
+    const defaultHeaders = Object.entries(Object.assign(Object.assign({
+      Accept: 'application/json'
+    }, additionalHeaders), options.headers)).filter(([key, value]) => isDefined(value)).reduce((headers, [key, value]) => Object.assign(Object.assign({}, headers), {
+      [key]: value
+    }), {});
+    const headers = new Headers(defaultHeaders);
+    if (isStringWithValue(token)) {
+      headers.append('Authorization', `Bearer ${token}`);
+    }
+    if (isStringWithValue(username) && isStringWithValue(password)) {
+      const credentials = base64(`${username}:${password}`);
+      headers.append('Authorization', `Basic ${credentials}`);
+    }
+    if (options.body) {
+      if (options.mediaType) {
+        headers.append('Content-Type', options.mediaType);
+      } else if (isBlob(options.body)) {
+        headers.append('Content-Type', options.body.type || 'application/octet-stream');
+      } else if (isString(options.body)) {
+        headers.append('Content-Type', 'text/plain');
       } else {
-        process(key, value);
+        headers.append('Content-Type', 'application/json');
       }
-    });
-    return formData;
-  }
-  return undefined;
-};
-const resolve = (options, resolver) => __awaiter(void 0, void 0, void 0, function* () {
-  if (typeof resolver === 'function') {
-    return resolver(options);
-  }
-  return resolver;
-});
-const getHeaders = (config, options) => __awaiter(void 0, void 0, void 0, function* () {
-  const [token, username, password, additionalHeaders] = yield Promise.all([resolve(options, config.TOKEN), resolve(options, config.USERNAME), resolve(options, config.PASSWORD), resolve(options, config.HEADERS)]);
-  const headers = Object.entries(Object.assign(Object.assign({
-    Accept: 'application/json'
-  }, additionalHeaders), options.headers)).filter(([_, value]) => isDefined(value)).reduce((headers, [key, value]) => Object.assign(Object.assign({}, headers), {
-    [key]: String(value)
-  }), {});
-  if (isStringWithValue(token)) {
-    headers['Authorization'] = `Bearer ${token}`;
-  }
-  if (isStringWithValue(username) && isStringWithValue(password)) {
-    const credentials = base64(`${username}:${password}`);
-    headers['Authorization'] = `Basic ${credentials}`;
-  }
-  if (options.body !== undefined) {
-    if (options.mediaType) {
-      headers['Content-Type'] = options.mediaType;
-    } else if (isBlob(options.body)) {
-      headers['Content-Type'] = options.body.type || 'application/octet-stream';
-    } else if (isString(options.body)) {
-      headers['Content-Type'] = 'text/plain';
-    } else if (!isFormData(options.body)) {
-      headers['Content-Type'] = 'application/json';
     }
-  }
-  return new Headers(headers);
-});
-const getRequestBody = options => {
+    return headers;
+  });
+}
+function getRequestBody(options) {
   var _a;
-  if (options.body !== undefined) {
+  if (options.formData) {
+    return getFormData(options.formData);
+  }
+  if (options.body) {
     if ((_a = options.mediaType) === null || _a === void 0 ? void 0 : _a.includes('/json')) {
       return JSON.stringify(options.body);
-    } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+    } else if (isString(options.body) || isBlob(options.body)) {
       return options.body;
     } else {
       return JSON.stringify(options.body);
     }
   }
   return undefined;
-};
-const sendRequest = (config, options, url, body, formData, headers, onCancel) => __awaiter(void 0, void 0, void 0, function* () {
-  const controller = new AbortController();
-  const request = {
-    headers,
-    body: body !== null && body !== void 0 ? body : formData,
-    method: options.method,
-    signal: controller.signal
-  };
-  onCancel(() => controller.abort());
-  return yield fetch(url, request);
-});
-const getResponseHeader = (response, responseHeader) => {
+}
+function sendRequest(options, url) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const request = {
+      method: options.method,
+      headers: yield getHeaders(options),
+      body: getRequestBody(options)
+    };
+    return yield fetch(url, request);
+  });
+}
+function getResponseHeader(response, responseHeader) {
   if (responseHeader) {
     const content = response.headers.get(responseHeader);
     if (isString(content)) {
       return content;
     }
   }
-  return undefined;
-};
-const getResponseBody = response => __awaiter(void 0, void 0, void 0, function* () {
-  if (response.status !== 204) {
-    try {
-      const contentType = response.headers.get('Content-Type');
-      if (contentType) {
-        const jsonTypes = ['application/json', 'application/problem+json'];
-        const isJSON = jsonTypes.some(type => contentType.toLowerCase().startsWith(type));
-        if (isJSON) {
-          return yield response.json();
-        } else {
-          return yield response.text();
+  return null;
+}
+function getResponseBody(response) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (response.status !== 204) {
+      try {
+        const contentType = response.headers.get('Content-Type');
+        if (contentType) {
+          const isJSON = contentType.toLowerCase().startsWith('application/json');
+          if (isJSON) {
+            return yield response.json();
+          } else {
+            return yield response.text();
+          }
         }
+      } catch (error) {
+        console.error(error);
       }
-    } catch (error) {
-      console.error(error);
     }
-  }
-  return undefined;
-});
-const catchErrorCodes = (options, result) => {
-  var _a, _b;
+    return null;
+  });
+}
+function catchErrors(options, result) {
   const errors = Object.assign({
     400: 'Bad Request',
     401: 'Unauthorized',
@@ -9886,54 +9760,35 @@ const catchErrorCodes = (options, result) => {
   }, options.errors);
   const error = errors[result.status];
   if (error) {
-    throw new ApiError(options, result, error);
+    throw new ApiError(result, error);
   }
   if (!result.ok) {
-    const errorStatus = (_a = result.status) !== null && _a !== void 0 ? _a : 'unknown';
-    const errorStatusText = (_b = result.statusText) !== null && _b !== void 0 ? _b : 'unknown';
-    const errorBody = (() => {
-      try {
-        return JSON.stringify(result.body, null, 2);
-      } catch (e) {
-        return undefined;
-      }
-    })();
-    throw new ApiError(options, result, `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`);
+    throw new ApiError(result, 'Generic Error');
   }
-};
+}
 /**
- * Request method
- * @param config The OpenAPI configuration object
- * @param options The request options from the service
- * @returns CancelablePromise<T>
+ * Request using fetch client
+ * @param options The request options from the the service
+ * @returns ApiResult
  * @throws ApiError
  */
-const request = (config, options) => {
-  return new CancelablePromise((resolve, reject, onCancel) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-      const url = getUrl(config, options);
-      const formData = getFormData(options);
-      const body = getRequestBody(options);
-      const headers = yield getHeaders(config, options);
-      if (!onCancel.isCancelled) {
-        const response = yield sendRequest(config, options, url, body, formData, headers, onCancel);
-        const responseBody = yield getResponseBody(response);
-        const responseHeader = getResponseHeader(response, options.responseHeader);
-        const result = {
-          url,
-          ok: response.ok,
-          status: response.status,
-          statusText: response.statusText,
-          body: responseHeader !== null && responseHeader !== void 0 ? responseHeader : responseBody
-        };
-        catchErrorCodes(options, result);
-        resolve(result.body);
-      }
-    } catch (error) {
-      reject(error);
-    }
-  }));
-};
+function request(options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const url = getUrl(options);
+    const response = yield sendRequest(options, url);
+    const responseBody = yield getResponseBody(response);
+    const responseHeader = getResponseHeader(response, options.responseHeader);
+    const result = {
+      url,
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      body: responseHeader || responseBody
+    };
+    catchErrors(options, result);
+    return result;
+  });
+}
 
 class DashboardsService {
   /**
@@ -9945,7 +9800,7 @@ class DashboardsService {
    * @param sort Sort ordering to apply to the query.
    * @param filter List of filters (each filter is a separate query param, and they are OR'ed).
    *
-   * * **Filterable field names**: author_fullname, author_id, bi_type, categories, created_dt, dataset_id, description, external_embedding_id, external_id, featured, id, is_ootb_dashboard, lifecycle_state, name, target_apps, updated_by_fullname, updated_by_id, updated_dt
+   * * **Filterable field names**: author_fullname, author_id, bi_type, categories, created_dt, dataset_id, description, external_embedding_id, external_id, id, is_ootb_dashboard, lifecycle_state, name, target_apps, updated_by_fullname, updated_by_id, updated_dt
    * * **Searchable field names**: author_fullname, categories, description, name, updated_by_fullname
    *
    * @param favorite Boolean flag to only return dashboards marked as favorites.
@@ -9964,36 +9819,39 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static getDashboards(xDigitalaiAccountId = null, start, count = 20, sort = 'id', filter, favorite = null, q = null, authorFullname = null, authorId = null, biType = 'MICROSTRATEGY', description = null, id = null, isOotbDashboard = null, lifecycleState = null, name = null, targetApp = null, viewModified = false) {
-    return request(OpenAPI, {
-      method: 'GET',
-      url: '/metadata/bi/dashboards',
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      query: {
-        start: start,
-        count: count,
-        sort: sort,
-        filter: filter,
-        favorite: favorite,
-        q: q,
-        author_fullname: authorFullname,
-        author_id: authorId,
-        bi_type: biType,
-        description: description,
-        id: id,
-        is_ootb_dashboard: isOotbDashboard,
-        lifecycle_state: lifecycleState,
-        name: name,
-        target_app: targetApp,
-        view_modified: viewModified
-      },
-      errors: {
-        400: `An unknown parameter was specified.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        422: `Unprocessable Entity`
-      }
+  static getDashboards() {
+    return __awaiter(this, arguments, void 0, function* (xDigitalaiAccountId = null, start, count = 20, sort = 'id', filter, favorite = null, q = null, authorFullname = null, authorId = null, biType = 'MICROSTRATEGY', description = null, id = null, isOotbDashboard = null, lifecycleState = null, name = null, targetApp = null, viewModified = false) {
+      const result = yield request({
+        method: 'GET',
+        path: `/metadata/bi/dashboards`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        query: {
+          start: start,
+          count: count,
+          sort: sort,
+          filter: filter,
+          favorite: favorite,
+          q: q,
+          author_fullname: authorFullname,
+          author_id: authorId,
+          bi_type: biType,
+          description: description,
+          id: id,
+          is_ootb_dashboard: isOotbDashboard,
+          lifecycle_state: lifecycleState,
+          name: name,
+          target_app: targetApp,
+          view_modified: viewModified
+        },
+        errors: {
+          400: `An unknown parameter was specified.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10005,20 +9863,23 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static postDashboards(requestBody, xDigitalaiAccountId = null) {
-    return request(OpenAPI, {
-      method: 'POST',
-      url: '/metadata/bi/dashboards',
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      body: requestBody,
-      mediaType: 'application/json',
-      errors: {
-        400: `The provided data is not valid.`,
-        404: `The dashboard could not be found.`,
-        422: `Unprocessable Entity`
-      }
+  static postDashboards(requestBody_1) {
+    return __awaiter(this, arguments, void 0, function* (requestBody, xDigitalaiAccountId = null) {
+      const result = yield request({
+        method: 'POST',
+        path: `/metadata/bi/dashboards`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        body: requestBody,
+        mediaType: 'application/json',
+        errors: {
+          400: `The provided data is not valid.`,
+          404: `The dashboard could not be found.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10030,21 +9891,21 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static getDashboard(dashboardId, xDigitalaiAccountId = null) {
-    return request(OpenAPI, {
-      method: 'GET',
-      url: '/metadata/bi/dashboards/{dashboard_id}',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      errors: {
-        400: `An unknown parameter was specified.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        404: `The dashboard could not be found.`
-      }
+  static getDashboard(dashboardId_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, xDigitalaiAccountId = null) {
+      const result = yield request({
+        method: 'GET',
+        path: `/metadata/bi/dashboards/${dashboardId}`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        errors: {
+          400: `An unknown parameter was specified.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          404: `The dashboard could not be found.`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10058,28 +9919,28 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static putDashboard(dashboardId, requestBody, xDigitalaiAccountId = null, isSync = null) {
-    return request(OpenAPI, {
-      method: 'PUT',
-      url: '/metadata/bi/dashboards/{dashboard_id}',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      query: {
-        is_sync: isSync
-      },
-      body: requestBody,
-      mediaType: 'application/json',
-      errors: {
-        400: `The provided data is not valid.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        404: `The dashboard could not be found.`,
-        409: `Unable to update object because IDs are different.`,
-        422: `Unprocessable Entity`
-      }
+  static putDashboard(dashboardId_1, requestBody_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, requestBody, xDigitalaiAccountId = null, isSync = null) {
+      const result = yield request({
+        method: 'PUT',
+        path: `/metadata/bi/dashboards/${dashboardId}`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        query: {
+          is_sync: isSync
+        },
+        body: requestBody,
+        mediaType: 'application/json',
+        errors: {
+          400: `The provided data is not valid.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          404: `The dashboard could not be found.`,
+          409: `Unable to update object because IDs are different.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10093,28 +9954,28 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static patchDashboard(dashboardId, requestBody, xDigitalaiAccountId = null, isSync = null) {
-    return request(OpenAPI, {
-      method: 'PATCH',
-      url: '/metadata/bi/dashboards/{dashboard_id}',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      query: {
-        is_sync: isSync
-      },
-      body: requestBody,
-      mediaType: 'application/json',
-      errors: {
-        400: `The provided data is not valid.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        404: `The dashboard could not be found.`,
-        409: `Unable to update object because IDs are different.`,
-        422: `Unprocessable Entity`
-      }
+  static patchDashboard(dashboardId_1, requestBody_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, requestBody, xDigitalaiAccountId = null, isSync = null) {
+      const result = yield request({
+        method: 'PATCH',
+        path: `/metadata/bi/dashboards/${dashboardId}`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        query: {
+          is_sync: isSync
+        },
+        body: requestBody,
+        mediaType: 'application/json',
+        errors: {
+          400: `The provided data is not valid.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          404: `The dashboard could not be found.`,
+          409: `Unable to update object because IDs are different.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10125,16 +9986,16 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static deleteDashboard(dashboardId, xDigitalaiAccountId = null) {
-    return request(OpenAPI, {
-      method: 'DELETE',
-      url: '/metadata/bi/dashboards/{dashboard_id}',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      }
+  static deleteDashboard(dashboardId_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, xDigitalaiAccountId = null) {
+      const result = yield request({
+        method: 'DELETE',
+        path: `/metadata/bi/dashboards/${dashboardId}`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10146,21 +10007,21 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static getInProgressDashboard(dashboardId, xDigitalaiAccountId = null) {
-    return request(OpenAPI, {
-      method: 'GET',
-      url: '/metadata/bi/dashboards/{dashboard_id}/inprogress',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      errors: {
-        400: `An unknown parameter was specified.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        404: `The dashboard could not be found.`
-      }
+  static getInProgressDashboard(dashboardId_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, xDigitalaiAccountId = null) {
+      const result = yield request({
+        method: 'GET',
+        path: `/metadata/bi/dashboards/${dashboardId}/inprogress`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        errors: {
+          400: `An unknown parameter was specified.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          404: `The dashboard could not be found.`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10173,24 +10034,24 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static postInProgressDashboard(dashboardId, xDigitalaiAccountId = null, requestBody) {
-    return request(OpenAPI, {
-      method: 'POST',
-      url: '/metadata/bi/dashboards/{dashboard_id}/inprogress',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      body: requestBody,
-      mediaType: 'application/json',
-      errors: {
-        400: `The provided data is not valid.`,
-        404: `The dashboard could not be found.`,
-        409: `Unable to update object because IDs are different.`,
-        422: `Unprocessable Entity`
-      }
+  static postInProgressDashboard(dashboardId_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, xDigitalaiAccountId = null, requestBody) {
+      const result = yield request({
+        method: 'POST',
+        path: `/metadata/bi/dashboards/${dashboardId}/inprogress`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        body: requestBody,
+        mediaType: 'application/json',
+        errors: {
+          400: `The provided data is not valid.`,
+          404: `The dashboard could not be found.`,
+          409: `Unable to update object because IDs are different.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10204,28 +10065,28 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static putInProgressDashboard(dashboardId, requestBody, xDigitalaiAccountId = null, isSync = null) {
-    return request(OpenAPI, {
-      method: 'PUT',
-      url: '/metadata/bi/dashboards/{dashboard_id}/inprogress',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      query: {
-        is_sync: isSync
-      },
-      body: requestBody,
-      mediaType: 'application/json',
-      errors: {
-        400: `The provided data is not valid.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        404: `The dashboard could not be found.`,
-        409: `Unable to update object because IDs are different.`,
-        422: `Unprocessable Entity`
-      }
+  static putInProgressDashboard(dashboardId_1, requestBody_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, requestBody, xDigitalaiAccountId = null, isSync = null) {
+      const result = yield request({
+        method: 'PUT',
+        path: `/metadata/bi/dashboards/${dashboardId}/inprogress`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        query: {
+          is_sync: isSync
+        },
+        body: requestBody,
+        mediaType: 'application/json',
+        errors: {
+          400: `The provided data is not valid.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          404: `The dashboard could not be found.`,
+          409: `Unable to update object because IDs are different.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10239,28 +10100,28 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static patchInProgressDashboard(dashboardId, requestBody, xDigitalaiAccountId = null, isSync = null) {
-    return request(OpenAPI, {
-      method: 'PATCH',
-      url: '/metadata/bi/dashboards/{dashboard_id}/inprogress',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      query: {
-        is_sync: isSync
-      },
-      body: requestBody,
-      mediaType: 'application/json',
-      errors: {
-        400: `The provided data is not valid.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        404: `The dashboard could not be found.`,
-        409: `Unable to update object because IDs are different.`,
-        422: `Unprocessable Entity`
-      }
+  static patchInProgressDashboard(dashboardId_1, requestBody_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, requestBody, xDigitalaiAccountId = null, isSync = null) {
+      const result = yield request({
+        method: 'PATCH',
+        path: `/metadata/bi/dashboards/${dashboardId}/inprogress`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        query: {
+          is_sync: isSync
+        },
+        body: requestBody,
+        mediaType: 'application/json',
+        errors: {
+          400: `The provided data is not valid.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          404: `The dashboard could not be found.`,
+          409: `Unable to update object because IDs are different.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10272,22 +10133,22 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static deleteInProgressDashboard(dashboardId, xDigitalaiAccountId = null, publish = false) {
-    return request(OpenAPI, {
-      method: 'DELETE',
-      url: '/metadata/bi/dashboards/{dashboard_id}/inprogress',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      query: {
-        publish: publish
-      },
-      errors: {
-        422: `Unprocessable Entity`
-      }
+  static deleteInProgressDashboard(dashboardId_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, xDigitalaiAccountId = null, publish = false) {
+      const result = yield request({
+        method: 'DELETE',
+        path: `/metadata/bi/dashboards/${dashboardId}/inprogress`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        query: {
+          publish: publish
+        },
+        errors: {
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10300,23 +10161,23 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static copyDashboard(dashboardId, xDigitalaiAccountId = null, requestBody) {
-    return request(OpenAPI, {
-      method: 'POST',
-      url: '/metadata/bi/dashboards/{dashboard_id}/copy',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      body: requestBody,
-      mediaType: 'application/json',
-      errors: {
-        400: `The provided data is not valid.`,
-        404: `The dashboard could not be found.`,
-        422: `Unprocessable Entity`
-      }
+  static copyDashboard(dashboardId_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, xDigitalaiAccountId = null, requestBody) {
+      const result = yield request({
+        method: 'POST',
+        path: `/metadata/bi/dashboards/${dashboardId}/copy`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        body: requestBody,
+        mediaType: 'application/json',
+        errors: {
+          400: `The provided data is not valid.`,
+          404: `The dashboard could not be found.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10328,20 +10189,20 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static favoriteDashboard(dashboardId, xDigitalaiAccountId = null) {
-    return request(OpenAPI, {
-      method: 'POST',
-      url: '/metadata/bi/dashboards/{dashboard_id}/favorite',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      errors: {
-        400: `The provided data is not valid.`,
-        404: `The dashboard could not be found.`
-      }
+  static favoriteDashboard(dashboardId_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, xDigitalaiAccountId = null) {
+      const result = yield request({
+        method: 'POST',
+        path: `/metadata/bi/dashboards/${dashboardId}/favorite`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        errors: {
+          400: `The provided data is not valid.`,
+          404: `The dashboard could not be found.`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10353,20 +10214,20 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static unfavoriteDashboard(dashboardId, xDigitalaiAccountId = null) {
-    return request(OpenAPI, {
-      method: 'DELETE',
-      url: '/metadata/bi/dashboards/{dashboard_id}/favorite',
-      path: {
-        dashboard_id: dashboardId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      errors: {
-        400: `The provided data is not valid.`,
-        404: `The dashboard could not be found.`
-      }
+  static unfavoriteDashboard(dashboardId_1) {
+    return __awaiter(this, arguments, void 0, function* (dashboardId, xDigitalaiAccountId = null) {
+      const result = yield request({
+        method: 'DELETE',
+        path: `/metadata/bi/dashboards/${dashboardId}/favorite`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        errors: {
+          400: `The provided data is not valid.`,
+          404: `The dashboard could not be found.`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10386,25 +10247,28 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static getDashboardsMetadata(xDigitalaiAccountId = null, filter, targetApp = null, biType = 'MICROSTRATEGY', isOotbDashboard = null, lifecycleState = null) {
-    return request(OpenAPI, {
-      method: 'GET',
-      url: '/metadata/bi/dashboards/metadata',
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      query: {
-        filter: filter,
-        target_app: targetApp,
-        bi_type: biType,
-        is_ootb_dashboard: isOotbDashboard,
-        lifecycle_state: lifecycleState
-      },
-      errors: {
-        400: `Given query params are not valid.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        422: `Unprocessable Entity`
-      }
+  static getDashboardsMetadata() {
+    return __awaiter(this, arguments, void 0, function* (xDigitalaiAccountId = null, filter, targetApp = null, biType = 'MICROSTRATEGY', isOotbDashboard = null, lifecycleState = null) {
+      const result = yield request({
+        method: 'GET',
+        path: `/metadata/bi/dashboards/metadata`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        query: {
+          filter: filter,
+          target_app: targetApp,
+          bi_type: biType,
+          is_ootb_dashboard: isOotbDashboard,
+          lifecycle_state: lifecycleState
+        },
+        errors: {
+          400: `Given query params are not valid.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
 }
@@ -10418,42 +10282,47 @@ class HelpContentService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static getHelpContent(xDigitalaiAccountId = null) {
-    return request(OpenAPI, {
-      method: 'GET',
-      url: '/metadata/bi/helpcontent',
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      errors: {
-        400: `An unknown parameter was specified.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`
-      }
+  static getHelpContent() {
+    return __awaiter(this, arguments, void 0, function* (xDigitalaiAccountId = null) {
+      const result = yield request({
+        method: 'GET',
+        path: `/metadata/bi/helpcontent`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        errors: {
+          400: `An unknown parameter was specified.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`
+        }
+      });
+      return result.body;
     });
   }
   /**
    * Upload an HTML file to be displayed as help content.
    * Upload help content.
-   * @param formData
+   * @param requestBody
    * @param xDigitalaiAccountId Perform the requested operation in the context of the Digital.ai account represented by this GUID.  <em>Requires elevated permissions.</em>
    * @returns HelpContent Content uploaded.
    * @returns Error Default error response
    * @throws ApiError
    */
-  static createHelpContent(formData, xDigitalaiAccountId = null) {
-    return request(OpenAPI, {
-      method: 'POST',
-      url: '/metadata/bi/helpcontent',
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      formData: formData,
-      mediaType: 'multipart/form-data',
-      errors: {
-        400: `The provided data is not valid.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        422: `Unprocessable Entity`
-      }
+  static createHelpContent(requestBody_1) {
+    return __awaiter(this, arguments, void 0, function* (requestBody, xDigitalaiAccountId = null) {
+      const result = yield request({
+        method: 'POST',
+        path: `/metadata/bi/helpcontent`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        body: requestBody,
+        errors: {
+          400: `The provided data is not valid.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10465,51 +10334,50 @@ class HelpContentService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static getHelpContentById(helpContentId, xDigitalaiAccountId = null) {
-    return request(OpenAPI, {
-      method: 'GET',
-      url: '/metadata/bi/helpcontent/{help_content_id}',
-      path: {
-        help_content_id: helpContentId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      errors: {
-        400: `An unknown parameter was specified.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        404: `The help content could not be found.`
-      }
+  static getHelpContentById(helpContentId_1) {
+    return __awaiter(this, arguments, void 0, function* (helpContentId, xDigitalaiAccountId = null) {
+      const result = yield request({
+        method: 'GET',
+        path: `/metadata/bi/helpcontent/${helpContentId}`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        errors: {
+          400: `An unknown parameter was specified.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          404: `The help content could not be found.`
+        }
+      });
+      return result.body;
     });
   }
   /**
    * Update a help content definition.
    * Update a single help content definition, selected by ID.
    * @param helpContentId
-   * @param formData
+   * @param requestBody
    * @param xDigitalaiAccountId Perform the requested operation in the context of the Digital.ai account represented by this GUID.  <em>Requires elevated permissions.</em>
    * @returns HelpContent OK
    * @returns Error Default error response
    * @throws ApiError
    */
-  static putHelpContentById(helpContentId, formData, xDigitalaiAccountId = null) {
-    return request(OpenAPI, {
-      method: 'PUT',
-      url: '/metadata/bi/helpcontent/{help_content_id}',
-      path: {
-        help_content_id: helpContentId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      formData: formData,
-      mediaType: 'multipart/form-data',
-      errors: {
-        400: `An unknown parameter was specified.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        404: `The help content could not be found.`,
-        422: `Unprocessable Entity`
-      }
+  static putHelpContentById(helpContentId_1, requestBody_1) {
+    return __awaiter(this, arguments, void 0, function* (helpContentId, requestBody, xDigitalaiAccountId = null) {
+      const result = yield request({
+        method: 'PUT',
+        path: `/metadata/bi/helpcontent/${helpContentId}`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        body: requestBody,
+        errors: {
+          400: `An unknown parameter was specified.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          404: `The help content could not be found.`,
+          422: `Unprocessable Entity`
+        }
+      });
+      return result.body;
     });
   }
   /**
@@ -10520,21 +10388,21 @@ class HelpContentService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  static deleteHelpContentById(helpContentId, xDigitalaiAccountId = null) {
-    return request(OpenAPI, {
-      method: 'DELETE',
-      url: '/metadata/bi/helpcontent/{help_content_id}',
-      path: {
-        help_content_id: helpContentId
-      },
-      headers: {
-        'X-Digitalai-Account-ID': xDigitalaiAccountId
-      },
-      errors: {
-        400: `An unknown parameter was specified.`,
-        401: `Could not resolve a valid Tenant from the provided API Token.`,
-        404: `The help content could not be found.`
-      }
+  static deleteHelpContentById(helpContentId_1) {
+    return __awaiter(this, arguments, void 0, function* (helpContentId, xDigitalaiAccountId = null) {
+      const result = yield request({
+        method: 'DELETE',
+        path: `/metadata/bi/helpcontent/${helpContentId}`,
+        headers: {
+          'X-Digitalai-Account-ID': xDigitalaiAccountId
+        },
+        errors: {
+          400: `An unknown parameter was specified.`,
+          401: `Could not resolve a valid Tenant from the provided API Token.`,
+          404: `The help content could not be found.`
+        }
+      });
+      return result.body;
     });
   }
 }
@@ -11083,9 +10951,6 @@ const DotMetadataApiProvider = ({
           if (dashboard.in_progress_changes) {
             // If the dashboard is published and has in-progress changes, we need to update the in-progress dashboard
             response = yield DashboardsService.patchInProgressDashboard(dashboard.id, updatePayload, accountId, isSync);
-          } else if (Object.keys(updatePayload).length === 1 && 'featured' in updatePayload) {
-            // If the dashboard is published and only update is related to 'featured' flag, we can update the published dashboard directly
-            response = yield DashboardsService.patchDashboard(dashboard.id, updatePayload, accountId, isSync);
           } else {
             // If the dashboard is published and has no in-progress changes, we need to create an in-progress dashboard
             response = yield DashboardsService.postInProgressDashboard(dashboard.id, accountId, updatePayload);
@@ -12943,7 +12808,6 @@ function DotDashboardOptionsMenu({
   currentUser,
   isEdit = false,
   menuPlacement,
-  onFeature,
   onStartDelete,
   onStartDuplicate,
   onStartStatusChange,
@@ -13006,21 +12870,6 @@ function DotDashboardOptionsMenu({
   const isDraft = !dashboard.parent_id && dashboard.lifecycle_state === DashboardView.lifecycle_state.DRAFT;
   const isPublished = dashboard.parent_id || dashboard.lifecycle_state === DashboardView.lifecycle_state.PUBLISHED;
   const menuItems = [];
-  if (onFeature && isPublished && !dashboard.in_progress_changes) {
-    const label = dashboard.featured ? 'Remove from featured page' : 'Add to featured page';
-    menuItems.push({
-      children: jsx(DotButton, {
-        "data-testid": `feature-dashboard-action-button-${dashboard.id}`,
-        ariaLabel: label,
-        type: "text",
-        startIcon: jsx(DotIcon, {
-          iconId: "add-outlined"
-        }),
-        children: label
-      }, `feature-dashboard-action-button-${dashboard.id}`),
-      key: 'feature'
-    });
-  }
   if (!isEdit && onViewMode && !dashboard.is_ootb_dashboard && !dashboardLocked(dashboard, currentUser)) {
     menuItems.push({
       children: jsx(DotButton, {
@@ -13218,9 +13067,6 @@ function DotDashboardOptionsMenu({
       case 'unpublish':
         onStartStatusChange(dashboard, DashboardView.lifecycle_state.DRAFT);
         break;
-      case 'feature':
-        onFeature(dashboard);
-        break;
     }
     handleMenuClose();
   }, [menuItems, handleMenuClose]);