@digital-ai/dot-components 5.4.0 → 5.5.1

package/index.esm.js

@@ -2076,6 +2076,19 @@ 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;
@@ -2260,7 +2273,7 @@ function getResponseBody$1(response) {
     return null;
   });
 }
-function catchErrors$1(options, result) {
+function catchErrors(options, result) {
   const errors = Object.assign({
     400: 'Bad Request',
     401: 'Unauthorized',
@@ -2297,7 +2310,7 @@ function request$1(options) {
       statusText: response.statusText,
       body: responseHeader || responseBody
     };
-    catchErrors$1(options, result);
+    catchErrors(options, result);
     return result;
   });
 }
@@ -9520,25 +9533,126 @@ const DotPill = ({
 };
 
 class ApiError extends Error {
-  constructor(response, message) {
+  constructor(request, 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};
+  HEADERS: undefined,
+  ENCODE_PATH: undefined
+};
 
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 var DashboardCreateBody;
 (function (DashboardCreateBody) {
   (function (lifecycle_state) {
@@ -9551,9 +9665,6 @@ var DashboardCreateBody;
   })(DashboardCreateBody.bi_type || (DashboardCreateBody.bi_type = {}));
 })(DashboardCreateBody || (DashboardCreateBody = {}));
 
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 var DashboardPatchBody;
 (function (DashboardPatchBody) {
   (function (lifecycle_state) {
@@ -9566,9 +9677,6 @@ var DashboardPatchBody;
   })(DashboardPatchBody.bi_type || (DashboardPatchBody.bi_type = {}));
 })(DashboardPatchBody || (DashboardPatchBody = {}));
 
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 var DashboardPutBody;
 (function (DashboardPutBody) {
   (function (lifecycle_state) {
@@ -9581,9 +9689,6 @@ var DashboardPutBody;
   })(DashboardPutBody.bi_type || (DashboardPutBody.bi_type = {}));
 })(DashboardPutBody || (DashboardPutBody = {}));
 
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
 var DashboardView;
 (function (DashboardView) {
   (function (lifecycle_state) {
@@ -9596,159 +9701,180 @@ var DashboardView;
   })(DashboardView.bi_type || (DashboardView.bi_type = {}));
 })(DashboardView || (DashboardView = {}));
 
-function isDefined(value) {
+const isDefined = value => {
   return value !== undefined && value !== null;
-}
-function isString(value) {
+};
+const isString = value => {
   return typeof value === 'string';
-}
-function isStringWithValue(value) {
+};
+const isStringWithValue = value => {
   return isString(value) && value !== '';
-}
-function isBlob(value) {
-  return value instanceof Blob;
-}
-function base64(str) {
+};
+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 => {
   try {
     return btoa(str);
   } catch (err) {
+    // @ts-ignore
     return Buffer.from(str).toString('base64');
   }
-}
-function getQueryString(params) {
+};
+const getQueryString = params => {
   const qs = [];
-  Object.keys(params).forEach(key => {
-    const value = params[key];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process = (key, value) => {
     if (isDefined(value)) {
       if (Array.isArray(value)) {
-        value.forEach(value => {
-          qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+        value.forEach(v => {
+          process(key, v);
+        });
+      } else if (typeof value === 'object') {
+        Object.entries(value).forEach(([k, v]) => {
+          process(`${key}[${k}]`, v);
         });
       } else {
-        qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+        append(key, value);
       }
     }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process(key, value);
   });
   if (qs.length > 0) {
     return `?${qs.join('&')}`;
   }
   return '';
-}
-function getUrl(options) {
-  const path = options.path;
-  const url = `${OpenAPI.BASE}${path}`;
+};
+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}`;
   if (options.query) {
     return `${url}${getQueryString(options.query)}`;
   }
   return url;
-}
-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');
+};
+const getFormData = options => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
       } else {
-        headers.append('Content-Type', 'application/json');
+        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));
+      } else {
+        process(key, value);
+      }
+    });
+    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 headers;
-  });
-}
-function getRequestBody(options) {
-  var _a;
-  if (options.formData) {
-    return getFormData(options.formData);
   }
-  if (options.body) {
+  return new Headers(headers);
+});
+const getRequestBody = options => {
+  var _a;
+  if (options.body !== undefined) {
     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)) {
+    } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
       return options.body;
     } else {
       return JSON.stringify(options.body);
     }
   }
   return undefined;
-}
-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) {
+};
+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) => {
   if (responseHeader) {
     const content = response.headers.get(responseHeader);
     if (isString(content)) {
       return content;
     }
   }
-  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();
-          }
+  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();
         }
-      } catch (error) {
-        console.error(error);
       }
+    } catch (error) {
+      console.error(error);
     }
-    return null;
-  });
-}
-function catchErrors(options, result) {
+  }
+  return undefined;
+});
+const catchErrorCodes = (options, result) => {
+  var _a, _b;
   const errors = Object.assign({
     400: 'Bad Request',
     401: 'Unauthorized',
@@ -9760,35 +9886,54 @@ function catchErrors(options, result) {
   }, options.errors);
   const error = errors[result.status];
   if (error) {
-    throw new ApiError(result, error);
+    throw new ApiError(options, result, error);
   }
   if (!result.ok) {
-    throw new ApiError(result, 'Generic Error');
+    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}`);
   }
-}
+};
 /**
- * Request using fetch client
- * @param options The request options from the the service
- * @returns ApiResult
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
  * @throws ApiError
  */
-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;
-  });
-}
+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);
+    }
+  }));
+};
 
 class DashboardsService {
   /**
@@ -9800,7 +9945,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, 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, featured, 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.
@@ -9819,39 +9964,36 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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`
+      }
     });
   }
   /**
@@ -9863,23 +10005,20 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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`
+      }
     });
   }
   /**
@@ -9891,21 +10030,21 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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.`
+      }
     });
   }
   /**
@@ -9919,28 +10058,28 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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`
+      }
     });
   }
   /**
@@ -9954,28 +10093,28 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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`
+      }
     });
   }
   /**
@@ -9986,16 +10125,16 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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
+      }
     });
   }
   /**
@@ -10007,21 +10146,21 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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.`
+      }
     });
   }
   /**
@@ -10034,24 +10173,24 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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`
+      }
     });
   }
   /**
@@ -10065,28 +10204,28 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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`
+      }
     });
   }
   /**
@@ -10100,28 +10239,28 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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`
+      }
     });
   }
   /**
@@ -10133,22 +10272,22 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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`
+      }
     });
   }
   /**
@@ -10161,23 +10300,23 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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`
+      }
     });
   }
   /**
@@ -10189,20 +10328,20 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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.`
+      }
     });
   }
   /**
@@ -10214,20 +10353,20 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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.`
+      }
     });
   }
   /**
@@ -10247,28 +10386,25 @@ class DashboardsService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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`
+      }
     });
   }
 }
@@ -10282,47 +10418,42 @@ class HelpContentService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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.`
+      }
     });
   }
   /**
    * Upload an HTML file to be displayed as help content.
    * Upload help content.
-   * @param requestBody
+   * @param formData
    * @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(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;
+  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`
+      }
     });
   }
   /**
@@ -10334,50 +10465,51 @@ class HelpContentService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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.`
+      }
     });
   }
   /**
    * Update a help content definition.
    * Update a single help content definition, selected by ID.
    * @param helpContentId
-   * @param requestBody
+   * @param formData
    * @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_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;
+  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`
+      }
     });
   }
   /**
@@ -10388,21 +10520,21 @@ class HelpContentService {
    * @returns Error Default error response
    * @throws ApiError
    */
-  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;
+  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.`
+      }
     });
   }
 }
@@ -10951,6 +11083,9 @@ 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);
@@ -12808,6 +12943,7 @@ function DotDashboardOptionsMenu({
   currentUser,
   isEdit = false,
   menuPlacement,
+  onFeature,
   onStartDelete,
   onStartDuplicate,
   onStartStatusChange,
@@ -12870,6 +13006,21 @@ 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, {
@@ -13067,6 +13218,9 @@ function DotDashboardOptionsMenu({
       case 'unpublish':
         onStartStatusChange(dashboard, DashboardView.lifecycle_state.DRAFT);
         break;
+      case 'feature':
+        onFeature(dashboard);
+        break;
     }
     handleMenuClose();
   }, [menuItems, handleMenuClose]);