@bluecopa/core 0.1.2

package/dist/index.es.js

@@ -0,0 +1,2321 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import axios from "axios";
+import _ from "lodash";
+class ConfigSingleton {
+  constructor() {
+    this.config = {
+      apiBaseUrl: "",
+      accessToken: "",
+      workspaceId: ""
+    };
+  }
+  static getInstance() {
+    if (!ConfigSingleton.instance) {
+      ConfigSingleton.instance = new ConfigSingleton();
+    }
+    return ConfigSingleton.instance;
+  }
+  setConfig(newConfig) {
+    this.config = { ...this.config, ...newConfig };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  resetConfig() {
+    this.config = {
+      apiBaseUrl: "",
+      accessToken: "",
+      workspaceId: ""
+    };
+  }
+}
+const configInstance = ConfigSingleton.getInstance();
+function setConfig(newConfig) {
+  configInstance.setConfig(newConfig);
+}
+function getConfig() {
+  return configInstance.getConfig();
+}
+const createApiClient = () => {
+  const client = axios.create({
+    timeout: 1e4,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  client.interceptors.request.use(
+    (config) => {
+      const copaConfig = getConfig();
+      if (copaConfig.apiBaseUrl) {
+        config.baseURL = copaConfig.apiBaseUrl;
+      }
+      if (copaConfig.accessToken && config.headers) {
+        config.headers["X-COPA-TOKEN"] = `Bearer ${copaConfig.accessToken}`;
+      }
+      if (copaConfig.workspaceId && config.headers) {
+        config.headers["X-COPA-WORKSPACE-ID"] = copaConfig.workspaceId;
+      }
+      console.log("API Request Config:", {
+        baseURL: config.baseURL,
+        hasToken: !!copaConfig.accessToken,
+        hasWorkspaceId: !!copaConfig.workspaceId
+      });
+      return config;
+    },
+    (error) => {
+      return Promise.reject(error);
+    }
+  );
+  client.interceptors.response.use(
+    (response) => {
+      return response;
+    },
+    (error) => {
+      var _a;
+      if (((_a = error.response) == null ? void 0 : _a.status) === 401) {
+        setConfig({ accessToken: "", workspaceId: "" });
+      }
+      return Promise.reject(error);
+    }
+  );
+  return client;
+};
+const apiClient = createApiClient();
+async function getLoggedInUserDetails() {
+  var _a, _b, _c;
+  try {
+    const response = await apiClient.get("/user/current");
+    if (!response.data) {
+      throw { message: "Failed to fetch user details", status: 500 };
+    }
+    return response.data;
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while fetching user details";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+}
+const index$8 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getLoggedInUserDetails
+}, Symbol.toStringTag, { value: "Module" }));
+async function triggerHttpWorkflow({
+  data,
+  triggerId
+}) {
+  var _a, _b, _c;
+  try {
+    const response = await apiClient.post(`/http-trigger/${triggerId}`, data);
+    if (!response.data) {
+      throw { message: "Failed to trigger HTTP workflow", status: 500 };
+    }
+    return response.data;
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while triggering the HTTP workflow";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+}
+async function triggerWorkflow({
+  parentId,
+  triggerBy
+}) {
+  var _a, _b, _c;
+  try {
+    const response = await apiClient.post("/workflow/trigger", { parentId, triggerBy });
+    if (!response.data) {
+      throw { message: "Failed to trigger workflow", status: 500 };
+    }
+    return response.data;
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while triggering the workflow";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+}
+const index$7 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  triggerHttpWorkflow,
+  triggerWorkflow
+}, Symbol.toStringTag, { value: "Module" }));
+async function getFileUrlByFileId({
+  key,
+  contentType,
+  method
+}) {
+  var _a, _b, _c;
+  try {
+    const response = await apiClient.post("/file/url", { key, contentType, method });
+    if (!response.data) {
+      throw { message: "Failed to get file URL", status: 500 };
+    }
+    return { url: response.data };
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while getting file URL";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+}
+const index$6 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getFileUrlByFileId
+}, Symbol.toStringTag, { value: "Module" }));
+const runPublishedDefinition = async (props) => {
+  const { sheet, variable, inputs, describe, source } = props;
+  if (!sheet) {
+    throw new Error(`Definition is null`);
+  }
+  if (!variable) {
+    throw new Error(`Variable is null`);
+  }
+  return apiClient.post(
+    "/definition/run-published",
+    {
+      sheet,
+      variable,
+      inputs,
+      describe
+    },
+    { cancelToken: source == null ? void 0 : source.token }
+  );
+};
+const runSampleDefinition = async (props) => {
+  const { datasetId, dataFilter, duplicateColGroups, datasetType } = props;
+  if (!datasetId) {
+    throw new Error(`Dataset ID is null`);
+  }
+  if (!dataFilter) {
+    throw new Error(`Data filter is null`);
+  }
+  return apiClient.post(
+    "/definition/run-sample",
+    { datasetId, dataFilter, duplicateColGroups, datasetType }
+  );
+};
+const runDefinition = async (props) => {
+  const { definition, variable, inputs, limit, source } = props;
+  if (!definition) {
+    throw new Error(`Definition is null`);
+  }
+  if (!variable) {
+    throw new Error(`Variable is null`);
+  }
+  if (!inputs) {
+    throw new Error(`Inputs is null`);
+  }
+  return apiClient.post(
+    "/definition/run-sample",
+    { inputs, definition, variable, limit },
+    { cancelToken: source == null ? void 0 : source.token }
+  );
+};
+const index$5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  runDefinition,
+  runPublishedDefinition,
+  runSampleDefinition
+}, Symbol.toStringTag, { value: "Module" }));
+const getWorksheets = async (worksheetIds) => {
+  var _a, _b, _c;
+  try {
+    const response = await apiClient.post("/worksheet/get-worksheets", {
+      ids: worksheetIds
+    });
+    if (!response.data) {
+      throw { message: "Failed to fetch worksheets details", status: 500 };
+    }
+    return response.data;
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while fetching worksheets details";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+};
+function formatDate(date) {
+  return date.toISOString().split("T")[0];
+}
+var ShowAsEnum = /* @__PURE__ */ ((ShowAsEnum2) => {
+  ShowAsEnum2["DEFAULT"] = "default";
+  ShowAsEnum2["ROW"] = "row";
+  ShowAsEnum2["COLUMN"] = "column";
+  ShowAsEnum2["GRAND_TOTAL"] = "grandTotal";
+  return ShowAsEnum2;
+})(ShowAsEnum || {});
+var CustomCalculationShowAsEnum = /* @__PURE__ */ ((CustomCalculationShowAsEnum2) => {
+  CustomCalculationShowAsEnum2["NONE"] = "none";
+  CustomCalculationShowAsEnum2["FORMULA"] = "formula";
+  CustomCalculationShowAsEnum2["AGGREGATE"] = "aggregate";
+  return CustomCalculationShowAsEnum2;
+})(CustomCalculationShowAsEnum || {});
+class ClientEnvironmentVariablesHolder {
+  constructor() {
+    __publicField(this, "envVariables");
+    const envClone = _.clone(process.env);
+    this.envVariables = {
+      [
+        "MAX_PIVOT_CELL_COUNT"
+        /* MAX_PIVOT_CELL_COUNT */
+      ]: envClone.MAX_PIVOT_CELL_COUNT,
+      [
+        "ADMIN_EMAIL"
+        /* ADMIN_EMAIL */
+      ]: envClone.ADMIN_EMAIL,
+      [
+        "MAX_LINES_FOR_REPORT_CHART"
+        /* MAX_LINES_FOR_REPORT_CHART */
+      ]: envClone.MAX_LINES_FOR_REPORT_CHART,
+      [
+        "ROW_LIMIT"
+        /* ROW_LIMIT */
+      ]: envClone.ROW_LIMIT,
+      [
+        "ENABLE_STATIC_TEMPLATES"
+        /* ENABLE_STATIC_TEMPLATES */
+      ]: envClone.ENABLE_STATIC_TEMPLATES,
+      [
+        "MAX_UNIQUE_VALUES_COUNT"
+        /* MAX_UNIQUE_VALUES_COUNT */
+      ]: envClone.MAX_UNIQUE_VALUES_COUNT,
+      [
+        "ENABLE_JUNIOR"
+        /* ENABLE_JUNIOR */
+      ]: envClone.ENABLE_JUNIOR,
+      [
+        "SHOULD_SHOW_MODEL"
+        /* SHOULD_SHOW_MODEL */
+      ]: envClone.SHOULD_SHOW_MODEL,
+      [
+        "PROD"
+        /* PROD */
+      ]: envClone.PROD,
+      [
+        "DD_LOGGING_CLIENT_TOKEN"
+        /* DD_LOGGING_CLIENT_TOKEN */
+      ]: envClone.DD_LOGGING_CLIENT_TOKEN,
+      [
+        "APP_NAME"
+        /* APP_NAME */
+      ]: envClone.APP_NAME,
+      [
+        "FAVICON_URL"
+        /* FAVICON_URL */
+      ]: envClone.FAVICON_URL,
+      [
+        "EXT_BRANDING_LOGO"
+        /* EXT_BRANDING_LOGO */
+      ]: envClone.EXT_BRANDING_LOGO,
+      [
+        "AGGRID_LICENSE_KEY"
+        /* AGGRID_LICENSE_KEY */
+      ]: envClone.AGGRID_LICENSE_KEY,
+      [
+        "AMCHARTS_LICENSE"
+        /* AMCHARTS_LICENSE */
+      ]: envClone.AMCHARTS_LICENSE,
+      [
+        "ONEDRIVE_CLIENT_ID"
+        /* ONEDRIVE_CLIENT_ID */
+      ]: envClone.ONEDRIVE_CLIENT_ID,
+      [
+        "DBT_TRANSFORMATIONS_BRANCH"
+        /* DBT_TRANSFORMATIONS_BRANCH */
+      ]: envClone.DBT_TRANSFORMATIONS_BRANCH,
+      [
+        "WEBSOCKET_MECHANISM"
+        /* WEBSOCKET_MECHANISM */
+      ]: envClone.WEBSOCKET_MECHANISM,
+      [
+        "PUSHER_APP_KEY"
+        /* PUSHER_APP_KEY */
+      ]: envClone.PUSHER_APP_KEY,
+      [
+        "PUSHER_APP_CLUSTER"
+        /* PUSHER_APP_CLUSTER */
+      ]: envClone.PUSHER_APP_CLUSTER,
+      [
+        "PUSHER_APP_SECRET"
+        /* PUSHER_APP_SECRET */
+      ]: envClone.PUSHER_APP_SECRET,
+      [
+        "PUSHER_APP_ID"
+        /* PUSHER_APP_ID */
+      ]: envClone.PUSHER_APP_ID,
+      [
+        "CENTRIFUGO_WEBSOCKET_URL"
+        /* CENTRIFUGO_WEBSOCKET_URL */
+      ]: envClone.CENTRIFUGO_WEBSOCKET_URL,
+      [
+        "CENTRIFUGO_WEBSOCKET_TOKEN"
+        /* CENTRIFUGO_WEBSOCKET_TOKEN */
+      ]: envClone.CENTRIFUGO_WEBSOCKET_TOKEN,
+      [
+        "DEPLOYMENT_PLATFORM"
+        /* DEPLOYMENT_PLATFORM */
+      ]: envClone.DEPLOYMENT_PLATFORM,
+      [
+        "DISABLE_UI_LOGGING"
+        /* DISABLE_UI_LOGGING */
+      ]: envClone.DISABLE_UI_LOGGING
+    };
+  }
+  set variables(values) {
+    Object.keys(values).forEach((key) => {
+      this.envVariables[key] = values[key];
+    });
+  }
+  get(key) {
+    return this.envVariables[key];
+  }
+  get MAX_PIVOT_CELL_COUNT() {
+    return this.get(
+      "MAX_PIVOT_CELL_COUNT"
+      /* MAX_PIVOT_CELL_COUNT */
+    );
+  }
+  get ADMIN_EMAIL() {
+    return this.get(
+      "ADMIN_EMAIL"
+      /* ADMIN_EMAIL */
+    );
+  }
+  get MAX_LINES_FOR_REPORT_CHART() {
+    return this.get(
+      "MAX_LINES_FOR_REPORT_CHART"
+      /* MAX_LINES_FOR_REPORT_CHART */
+    );
+  }
+  get ROW_LIMIT() {
+    return this.get(
+      "ROW_LIMIT"
+      /* ROW_LIMIT */
+    );
+  }
+  get ENABLE_STATIC_TEMPLATES() {
+    return this.get(
+      "ENABLE_STATIC_TEMPLATES"
+      /* ENABLE_STATIC_TEMPLATES */
+    );
+  }
+  get MAX_UNIQUE_VALUES_COUNT() {
+    if (this.get(
+      "MAX_UNIQUE_VALUES_COUNT"
+      /* MAX_UNIQUE_VALUES_COUNT */
+    )) {
+      return parseInt(this.get(
+        "MAX_UNIQUE_VALUES_COUNT"
+        /* MAX_UNIQUE_VALUES_COUNT */
+      ));
+    }
+    return 400;
+  }
+  get ENABLE_JUNIOR() {
+    return this.get(
+      "ENABLE_JUNIOR"
+      /* ENABLE_JUNIOR */
+    );
+  }
+  get SHOULD_SHOW_MODEL() {
+    return this.get(
+      "SHOULD_SHOW_MODEL"
+      /* SHOULD_SHOW_MODEL */
+    );
+  }
+  get PROD() {
+    return this.get(
+      "PROD"
+      /* PROD */
+    );
+  }
+  get DD_LOGGING_CLIENT_TOKEN() {
+    return this.get(
+      "DD_LOGGING_CLIENT_TOKEN"
+      /* DD_LOGGING_CLIENT_TOKEN */
+    );
+  }
+  get APP_NAME() {
+    return this.get(
+      "APP_NAME"
+      /* APP_NAME */
+    ) ?? "Bluecopa";
+  }
+  get FAVICON_URL() {
+    return this.get(
+      "FAVICON_URL"
+      /* FAVICON_URL */
+    );
+  }
+  get EXT_BRANDING_LOGO() {
+    return this.get(
+      "EXT_BRANDING_LOGO"
+      /* EXT_BRANDING_LOGO */
+    );
+  }
+  get AGGRID_LICENSE_KEY() {
+    return this.get(
+      "AGGRID_LICENSE_KEY"
+      /* AGGRID_LICENSE_KEY */
+    );
+  }
+  get AMCHARTS_LICENSE() {
+    return this.get(
+      "AMCHARTS_LICENSE"
+      /* AMCHARTS_LICENSE */
+    );
+  }
+  get WEBSOCKET_MECHANISM() {
+    return this.get(
+      "WEBSOCKET_MECHANISM"
+      /* WEBSOCKET_MECHANISM */
+    );
+  }
+  get ONEDRIVE_CLIENT_ID() {
+    return this.get(
+      "ONEDRIVE_CLIENT_ID"
+      /* ONEDRIVE_CLIENT_ID */
+    );
+  }
+  get DBT_TRANSFORMATIONS_BRANCH() {
+    return this.get(
+      "DBT_TRANSFORMATIONS_BRANCH"
+      /* DBT_TRANSFORMATIONS_BRANCH */
+    );
+  }
+  get PUSHER_APP_KEY() {
+    return this.get(
+      "PUSHER_APP_KEY"
+      /* PUSHER_APP_KEY */
+    );
+  }
+  get PUSHER_APP_CLUSTER() {
+    return this.get(
+      "PUSHER_APP_CLUSTER"
+      /* PUSHER_APP_CLUSTER */
+    );
+  }
+  get PUSHER_APP_SECRET() {
+    return this.get(
+      "PUSHER_APP_SECRET"
+      /* PUSHER_APP_SECRET */
+    );
+  }
+  get PUSHER_APP_ID() {
+    return this.get(
+      "PUSHER_APP_ID"
+      /* PUSHER_APP_ID */
+    );
+  }
+  get CENTRIFUGO_WEBSOCKET_URL() {
+    return this.get(
+      "CENTRIFUGO_WEBSOCKET_URL"
+      /* CENTRIFUGO_WEBSOCKET_URL */
+    );
+  }
+  get CENTRIFUGO_WEBSOCKET_TOKEN() {
+    return this.get(
+      "CENTRIFUGO_WEBSOCKET_TOKEN"
+      /* CENTRIFUGO_WEBSOCKET_TOKEN */
+    );
+  }
+  get DEPLOYMENT_PLATFORM() {
+    return this.get(
+      "DEPLOYMENT_PLATFORM"
+      /* DEPLOYMENT_PLATFORM */
+    );
+  }
+  get DISABLE_UI_LOGGING() {
+    return this.get(
+      "DISABLE_UI_LOGGING"
+      /* DISABLE_UI_LOGGING */
+    );
+  }
+}
+const clientEnvironmentVariablesHolder = new ClientEnvironmentVariablesHolder();
+clientEnvironmentVariablesHolder.MAX_UNIQUE_VALUES_COUNT;
+const defaultFilterPanel = {
+  is_not: false,
+  rule_type: "and_cond",
+  rules: []
+};
+const filterToSelectOptionType = (filter, columns) => {
+  const rules = (filter == null ? void 0 : filter.rules) || [];
+  if (!rules || rules.length === 0) {
+    return {
+      defaultType: "and_cond",
+      rules: []
+    };
+  }
+  const selectOptionsForRules = rules.map(
+    (rule) => getSelectionOptionsFromFilter(rule, columns)
+  );
+  return {
+    defaultType: (filter == null ? void 0 : filter.rule_type) || "and_cond",
+    rules: selectOptionsForRules
+  };
+};
+const getSelectionOptionsFromFilter = (rule, columns) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
+  if (_.isEmpty(rule == null ? void 0 : rule.rules)) {
+    const col2 = columns.find((column) => column.label === rule.col || column.value === rule.col);
+    return {
+      label: (col2 == null ? void 0 : col2.label) || "",
+      value: (col2 == null ? void 0 : col2.value) || "",
+      option: {
+        aggFun: (_a = col2 == null ? void 0 : col2.option) == null ? void 0 : _a.aggFun,
+        uniqueValues: [
+          {
+            label: (col2 == null ? void 0 : col2.label) || "",
+            value: (col2 == null ? void 0 : col2.value) || "",
+            option: {
+              uniqueValue: rule == null ? void 0 : rule.value,
+              operator: rule == null ? void 0 : rule.operator,
+              ruleType: (rule == null ? void 0 : rule.rule_type) || "cond",
+              isNot: (rule == null ? void 0 : rule.is_not) || false,
+              caseSensitive: (rule == null ? void 0 : rule.is_case_sensitive) ?? true
+            }
+          }
+        ],
+        uniqueValueCount: (_b = col2 == null ? void 0 : col2.option) == null ? void 0 : _b.uniqueCount,
+        type: (_c = col2 == null ? void 0 : col2.option) == null ? void 0 : _c.type,
+        ruleType: (rule == null ? void 0 : rule.rule_type) || "cond"
+      }
+    };
+  }
+  const col = columns == null ? void 0 : columns.find(
+    (column) => {
+      var _a2, _b2, _c2, _d2;
+      return column.label === ((_b2 = (_a2 = rule == null ? void 0 : rule.rules) == null ? void 0 : _a2[0]) == null ? void 0 : _b2.col) || column.value === ((_d2 = (_c2 = rule == null ? void 0 : rule.rules) == null ? void 0 : _c2[0]) == null ? void 0 : _d2.col);
+    }
+  );
+  const isValueFilter = _.get(rule, "rules.0.operator", null) === "in_op" && _.get(rule, "rules.0.value", null);
+  if (isValueFilter) {
+    return {
+      label: (col == null ? void 0 : col.label) || "",
+      value: (col == null ? void 0 : col.value) || "",
+      option: {
+        aggFun: (_d = col == null ? void 0 : col.option) == null ? void 0 : _d.aggFun,
+        uniqueValues: ((_g = (_f = (_e = rule == null ? void 0 : rule.rules) == null ? void 0 : _e[0]) == null ? void 0 : _f.value) == null ? void 0 : _g.map((r) => {
+          var _a2;
+          return {
+            label: (col == null ? void 0 : col.label) || "",
+            value: (col == null ? void 0 : col.value) || "",
+            option: {
+              aggFun: (_a2 = col == null ? void 0 : col.option) == null ? void 0 : _a2.aggFun,
+              uniqueValue: r,
+              operator: "equal",
+              ruleType: "cond",
+              isNot: false,
+              caseSensitive: true
+            }
+          };
+        })) || [],
+        uniqueValueCount: (_h = col == null ? void 0 : col.option) == null ? void 0 : _h.uniqueCount,
+        type: (_i = col == null ? void 0 : col.option) == null ? void 0 : _i.type,
+        ruleType: (rule == null ? void 0 : rule.rule_type) || "cond"
+      }
+    };
+  }
+  return {
+    label: (col == null ? void 0 : col.label) || "",
+    value: (col == null ? void 0 : col.value) || "",
+    option: {
+      aggFun: (_j = col == null ? void 0 : col.option) == null ? void 0 : _j.aggFun,
+      uniqueValues: ((_k = rule == null ? void 0 : rule.rules) == null ? void 0 : _k.map((r) => {
+        var _a2;
+        const childCol = columns == null ? void 0 : columns.find((column) => column.value === r.col);
+        return {
+          label: (childCol == null ? void 0 : childCol.label) || "",
+          value: (childCol == null ? void 0 : childCol.value) || "",
+          option: {
+            aggFun: (_a2 = childCol == null ? void 0 : childCol.option) == null ? void 0 : _a2.aggFun,
+            uniqueValue: r == null ? void 0 : r.value,
+            operator: r == null ? void 0 : r.operator,
+            ruleType: (r == null ? void 0 : r.rule_type) || "cond",
+            isNot: (r == null ? void 0 : r.is_not) || false,
+            caseSensitive: (r == null ? void 0 : r.is_case_sensitive) ?? true
+          }
+        };
+      })) || [],
+      uniqueValueCount: (_l = col == null ? void 0 : col.option) == null ? void 0 : _l.uniqueCount,
+      type: (_m = col == null ? void 0 : col.option) == null ? void 0 : _m.type,
+      ruleType: (rule == null ? void 0 : rule.rule_type) || "cond"
+    }
+  };
+};
+const getSelectOptionTypeToFilter = (filter, filterColumnsBy) => {
+  const rules = filter == null ? void 0 : filter.rules;
+  const defaultRuleType = filter == null ? void 0 : filter.defaultType;
+  if (!rules || rules.length === 0) {
+    return defaultFilterPanel;
+  }
+  let filterRules = rules == null ? void 0 : rules.map(
+    (rule) => getFilterRuleFromSelectionOptions(rule)
+  );
+  if (filterRules.length === 1 && filterRules[0].rules && filterRules[0].rules.length < 1) {
+    filterRules = [];
+  }
+  return {
+    is_not: false,
+    rule_type: defaultRuleType,
+    rules: filterRules
+  };
+};
+const getFilterRuleFromSelectionOptions = (rule, filterColumnsBy) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  if (((_b = (_a = rule == null ? void 0 : rule.option) == null ? void 0 : _a.uniqueValues) == null ? void 0 : _b.length) > 2) {
+    return {
+      rule_type: "or_cond",
+      rules: [
+        {
+          col: rule.value,
+          value: _.map(((_c = rule == null ? void 0 : rule.option) == null ? void 0 : _c.uniqueValues) || [], (r) => r.option.uniqueValue),
+          operator: "in_op",
+          rule_type: "cond",
+          is_not: false,
+          is_case_sensitive: true
+        }
+      ],
+      is_not: false
+    };
+  }
+  if (((_e = (_d = rule == null ? void 0 : rule.option) == null ? void 0 : _d.uniqueValues) == null ? void 0 : _e.length) === 1) {
+    const uniqueValue = (_g = (_f = rule == null ? void 0 : rule.option) == null ? void 0 : _f.uniqueValues) == null ? void 0 : _g[0];
+    return {
+      col: rule.value,
+      value: (_h = uniqueValue == null ? void 0 : uniqueValue.option) == null ? void 0 : _h.uniqueValue,
+      operator: (_i = uniqueValue == null ? void 0 : uniqueValue.option) == null ? void 0 : _i.operator,
+      rule_type: ((_j = uniqueValue == null ? void 0 : uniqueValue.option) == null ? void 0 : _j.ruleType) ?? "cond",
+      is_not: ((_k = uniqueValue == null ? void 0 : uniqueValue.option) == null ? void 0 : _k.isNot) ?? false,
+      is_case_sensitive: ((_l = uniqueValue == null ? void 0 : uniqueValue.option) == null ? void 0 : _l.caseSensitive) ?? true
+    };
+  }
+  return {
+    rule_type: (_m = rule == null ? void 0 : rule.option) == null ? void 0 : _m.ruleType,
+    rules: (((_n = rule == null ? void 0 : rule.option) == null ? void 0 : _n.uniqueValues) || []).map((r) => {
+      var _a2, _b2, _c2, _d2, _e2;
+      return {
+        col: r.value,
+        value: (_a2 = r.option) == null ? void 0 : _a2.uniqueValue,
+        operator: (_b2 = r.option) == null ? void 0 : _b2.operator,
+        rule_type: ((_c2 = r.option) == null ? void 0 : _c2.ruleType) ?? "cond",
+        is_not: ((_d2 = r.option) == null ? void 0 : _d2.isNot) ?? false,
+        is_case_sensitive: ((_e2 = r.option) == null ? void 0 : _e2.caseSensitive) ?? true
+      };
+    }),
+    is_not: false
+  };
+};
+const getColumnFilterRuleFromCombinedFilterRule = (combinedFilterRule, valueCols) => {
+  const filterRules = (combinedFilterRule == null ? void 0 : combinedFilterRule.rules) ?? [];
+  const columnFilterRules = [];
+  _.forEach(filterRules, (rule) => {
+    const valueCol = valueCols == null ? void 0 : valueCols.find((valueCol2) => (rule == null ? void 0 : rule.col) === (valueCol2 == null ? void 0 : valueCol2.label));
+    if (!valueCol) {
+      columnFilterRules.push(rule);
+    }
+  });
+  return {
+    ...combinedFilterRule,
+    rules: columnFilterRules
+  };
+};
+var ProjectFractionEnum = /* @__PURE__ */ ((ProjectFractionEnum2) => {
+  ProjectFractionEnum2["FRACTION_OF_COL_TOTAL"] = "FRACTION_OF_COL_TOTAL";
+  ProjectFractionEnum2["FRACTION_OF_ROW_TOTAL"] = "FRACTION_OF_ROW_TOTAL";
+  ProjectFractionEnum2["FRACTION_OF_GRAND_TOTAL"] = "FRACTION_OF_GRAND_TOTAL";
+  ProjectFractionEnum2["NONE"] = "null";
+  ProjectFractionEnum2["TOTAL_OF_FORMULA"] = "TOTAL_OF_FORMULA";
+  ProjectFractionEnum2["TOTAL_OF_AGGREGATE"] = "TOTAL_OF_AGGREGATE";
+  return ProjectFractionEnum2;
+})(ProjectFractionEnum || {});
+const getValuesForSpecialOperators = (op) => {
+  switch (op) {
+    case "not_equal":
+      return { operator: "equal", isNot: true };
+    case "not_contains":
+      return { operator: "contains", isNot: true };
+    case "is_empty":
+      return { value: "", operator: "equal", isNot: false };
+    case "is_not_empty":
+      return { value: "", operator: "equal", isNot: true };
+    case "is_null":
+      return { value: null, operator: "equal", isNot: false };
+    case "is_not_null":
+      return { value: null, operator: "equal", isNot: true };
+    default:
+      return {};
+  }
+};
+const replaceFilterColumn = (props) => {
+  const { fr, column } = props;
+  const updatedFr = _.map(fr, (f) => {
+    let newFr = { ...f, label: column == null ? void 0 : column.label, value: column == null ? void 0 : column.value };
+    if (newFr.option.uniqueValues) {
+      _.map(newFr.option.uniqueValues, (u) => {
+        u.label = column == null ? void 0 : column.label;
+        u.value = column == null ? void 0 : column.value;
+      });
+    }
+    return newFr;
+  });
+  return updatedFr;
+};
+const getParentTableVariableType = (childId, variables) => {
+  const parentTableVariable = _.find(variables, (v) => v.name === childId);
+  return parentTableVariable;
+};
+const findParentIsMetricSeries = (childId, variables) => {
+  var _a, _b;
+  const parentTableVariable = getParentTableVariableType(childId, variables);
+  if (((_a = parentTableVariable == null ? void 0 : parentTableVariable.transforms[0]) == null ? void 0 : _a.type) === "MetricSeries") {
+    return true;
+  } else if (parentTableVariable == null ? void 0 : parentTableVariable.transforms[0]) {
+    return findParentIsMetricSeries((_b = parentTableVariable == null ? void 0 : parentTableVariable.transforms[0]) == null ? void 0 : _b.table, variables);
+  }
+  return false;
+};
+const ShowAsToProjectFractionMapper = {
+  [ShowAsEnum.ROW]: ProjectFractionEnum.FRACTION_OF_ROW_TOTAL,
+  [ShowAsEnum.COLUMN]: ProjectFractionEnum.FRACTION_OF_COL_TOTAL,
+  [ShowAsEnum.GRAND_TOTAL]: ProjectFractionEnum.FRACTION_OF_GRAND_TOTAL,
+  [CustomCalculationShowAsEnum.NONE]: ProjectFractionEnum.FRACTION_OF_ROW_TOTAL,
+  [CustomCalculationShowAsEnum.FORMULA]: ProjectFractionEnum.TOTAL_OF_FORMULA,
+  [CustomCalculationShowAsEnum.AGGREGATE]: ProjectFractionEnum.TOTAL_OF_AGGREGATE
+};
+const getDrilldownFiltersMap = (props) => {
+  const { filtersToBeApplied, columnSelectOptions } = props;
+  let filterMap = {};
+  const filterGroup = _.groupBy(filtersToBeApplied, "field");
+  _.forEach(filterGroup, (fg) => {
+    let uniqueValues = [];
+    const col = columnSelectOptions == null ? void 0 : columnSelectOptions.find(
+      (c) => c.value === fg[0].field || c.value === `${fg[0].field}_group` || c.label === fg[0].field
+    );
+    let ruleType = "cond";
+    _.forEach(
+      fg,
+      (ftba) => {
+        var _a, _b;
+        if (ftba.operator) {
+          let uniqueValuesForNegationOperator, uniqueValuesForOperator;
+          if (ftba.operator.includes("not")) {
+            uniqueValuesForNegationOperator = getValuesForSpecialOperators(ftba.operator);
+            uniqueValuesForOperator = [
+              {
+                label: col == null ? void 0 : col.label,
+                value: col == null ? void 0 : col.value,
+                option: {
+                  uniqueValue: ftba.key,
+                  ruleType: "cond",
+                  operator: uniqueValuesForNegationOperator.operator,
+                  isNot: uniqueValuesForNegationOperator.isNot
+                }
+              }
+            ];
+          } else {
+            uniqueValuesForOperator = [
+              {
+                label: col == null ? void 0 : col.label,
+                value: col == null ? void 0 : col.value,
+                option: {
+                  uniqueValue: ftba.key,
+                  ruleType: "cond",
+                  operator: ftba.operator
+                }
+              }
+            ];
+          }
+          uniqueValues.push(...uniqueValuesForOperator);
+          ruleType = "and_cond";
+        } else if (ftba.type === "date") {
+          const uniqueValuesForDate = [
+            {
+              label: col == null ? void 0 : col.label,
+              value: (_a = col == null ? void 0 : col.value) == null ? void 0 : _a.replace("_group", ""),
+              option: {
+                uniqueValue: ftba.startDate,
+                ruleType: "cond",
+                operator: "greater_equal"
+              }
+            },
+            {
+              label: col == null ? void 0 : col.label,
+              value: (_b = col == null ? void 0 : col.value) == null ? void 0 : _b.replace("_group", ""),
+              option: {
+                uniqueValue: ftba.endDate,
+                ruleType: "cond",
+                operator: "less_equal"
+              }
+            }
+          ];
+          uniqueValues.push(...uniqueValuesForDate);
+          ruleType = "or_cond";
+        } else {
+          const uniqueValuesForSelection = [
+            {
+              label: (col == null ? void 0 : col.label) || "",
+              value: col == null ? void 0 : col.value,
+              option: { uniqueValue: ftba.key, ruleType: "cond", operator: "equal" }
+            }
+          ];
+          uniqueValues.push(...uniqueValuesForSelection);
+        }
+      }
+    );
+    const fiterSelectOption = {
+      label: (col == null ? void 0 : col.label) || "",
+      value: col == null ? void 0 : col.value,
+      option: {
+        uniqueValues,
+        ruleType,
+        uniqueValueCount: col == null ? void 0 : col.option.uniqueCount,
+        type: col == null ? void 0 : col.option.type
+      }
+    };
+    filterMap = {
+      ...filterMap,
+      [col == null ? void 0 : col.value]: fiterSelectOption
+    };
+  });
+  return filterMap;
+};
+const getFiltersToBeAppliedOnDrilldown = (props) => {
+  const { rowGroups, groupKeys } = props;
+  const filtersToBeApplied = [];
+  groupKeys == null ? void 0 : groupKeys.forEach((key, index2) => filtersToBeApplied.push({ field: rowGroups[index2], key }));
+  return filtersToBeApplied;
+};
+const getMetricFilterRule = (inputs) => {
+  const isInputsArray = Array.isArray(inputs);
+  const input = isInputsArray ? inputs[0] : inputs;
+  return (input == null ? void 0 : input["rule_pivot"]) ?? defaultFilterRule;
+};
+const getColumnSettingsToSelectOptions = (columnSettings) => {
+  return _.chain(columnSettings).filter((c) => !c.field.includes("__bc_") && !c.aggFunc).map((c) => {
+    return {
+      label: c.headerName,
+      value: c.field,
+      option: {
+        type: c.type,
+        uniqueCount: c.unique_count,
+        fieldLabel: c.headerName,
+        currency: c == null ? void 0 : c.currency,
+        precision: c == null ? void 0 : c.precision,
+        dateFormat: c == null ? void 0 : c.dateFormat,
+        isCurrency: c == null ? void 0 : c.isCurrency
+      }
+    };
+  }).value();
+};
+const defaultFilterRule = {
+  is_not: false,
+  rule_type: "and_cond",
+  rules: []
+};
+const getUpdatedDefinitionCustomModel = (props) => {
+  var _a, _b, _c, _d, _e;
+  const {
+    metricDefinitionModel,
+    parentDefinitionModel,
+    metricCustomModel,
+    parentCustomModel,
+    removeSort
+  } = props;
+  const parentTableVariable = parentCustomModel.variable;
+  const metricNewColumns = _.filter(metricDefinitionModel.variables ?? [], (v) => {
+    if (!v.transforms || !v.transforms[0]) {
+      return false;
+    }
+    if (removeSort) {
+      return findParentIsMetricSeries(
+        v.transforms[0].table,
+        metricDefinitionModel.variables ?? []
+      ) && v.transforms[0].type !== "Sort";
+    }
+    return findParentIsMetricSeries(
+      v.transforms[0].table,
+      metricDefinitionModel.variables ?? []
+    );
+  });
+  const definitionVariables = metricDefinitionModel.variables ?? [];
+  const analysisVariable = _.find(
+    definitionVariables,
+    (v) => !!_.find(v.transforms, (t) => t.type === "MetricSeries")
+  );
+  metricDefinitionModel.imports = _.uniqBy(
+    [...parentDefinitionModel.imports ?? [], ...metricDefinitionModel.imports ?? []],
+    "to"
+  );
+  const parentDefinitionAliases = parentDefinitionModel.aliases ?? {};
+  const parentTableVariableAlias = parentTableVariable ? parentDefinitionAliases[parentTableVariable] : {};
+  const metricDefinitionAliases = {
+    ...metricDefinitionModel.aliases,
+    ...parentDefinitionAliases
+  };
+  for (const [tableId] of Object.entries(metricDefinitionAliases)) {
+    if (!parentDefinitionAliases[tableId]) {
+      const metricTableAlias = metricDefinitionAliases[tableId];
+      for (const [columnName, columnId] of Object.entries(metricTableAlias)) {
+        const pColName = _.findKey(parentTableVariableAlias, (pColId) => pColId === columnId);
+        if (pColName && pColName !== columnName) {
+          delete metricTableAlias[columnName];
+          metricTableAlias[pColName] = parentTableVariableAlias[pColName];
+        }
+      }
+    }
+  }
+  metricDefinitionModel.aliases = metricDefinitionAliases;
+  const variables = _.cloneDeep(parentDefinitionModel.variables ?? []);
+  metricDefinitionModel.variables = definitionVariables.filter(
+    (v) => v.name === (analysisVariable == null ? void 0 : analysisVariable.name)
+  );
+  const previousVariables = metricDefinitionModel.variables;
+  metricDefinitionModel.variables = [...variables];
+  const variableNames = (_a = metricDefinitionModel.variables) == null ? void 0 : _a.map((v) => v == null ? void 0 : v.name);
+  metricDefinitionModel.variables.push(
+    ..._.filter(previousVariables, (v) => variableNames == null ? void 0 : variableNames.includes(v.name))
+  );
+  const filterVariable = _.find(
+    definitionVariables,
+    (v) => {
+      var _a2;
+      return (_a2 = v.transforms) == null ? void 0 : _a2.some((t) => t.type === "RuleFilter" && t.rule === "${rule_pivot}");
+    }
+  );
+  if (filterVariable && parentTableVariable) {
+    filterVariable.transforms[0].table = parentTableVariable;
+    metricDefinitionModel.variables.push(filterVariable);
+  }
+  if (analysisVariable && parentTableVariable) {
+    analysisVariable.transforms[0].table = parentTableVariable;
+    analysisVariable.transforms[0].row_group_by = "${rowGroupByInput}";
+    analysisVariable.transforms[0].col_group_by = "${columnGroupByInput}";
+    const rowGroups = ((_b = metricCustomModel == null ? void 0 : metricCustomModel.gridColumnState) == null ? void 0 : _b.rowGroupCols) ?? [];
+    const valueCols = ((_c = metricCustomModel == null ? void 0 : metricCustomModel.gridColumnState) == null ? void 0 : _c.valueCols) ?? [];
+    const showAsList = _.chain(valueCols).filter((vc) => !!vc.showAs).map((vc) => vc == null ? void 0 : vc.showAs).value();
+    analysisVariable.transforms[0].require_totals = !_.isEmpty(rowGroups) || !_.isEmpty(showAsList) && _.some(showAsList, (showAs) => showAs !== "default");
+    if (filterVariable) {
+      analysisVariable.transforms[0].table = filterVariable.name;
+      if (metricDefinitionModel.aliases && parentTableVariable) {
+        metricDefinitionModel.aliases[parentTableVariable] = {
+          ...metricDefinitionModel.aliases[parentTableVariable]
+        };
+      }
+    }
+    metricDefinitionModel.variables.push(analysisVariable);
+    metricCustomModel.variable = analysisVariable.name;
+  }
+  metricCustomModel.inputs = { ...parentCustomModel.inputs, ...metricCustomModel.inputs };
+  if (!_.isEmpty(metricNewColumns)) {
+    metricDefinitionModel.variables.push(...metricNewColumns);
+    metricCustomModel.variable = metricNewColumns[metricNewColumns.length - 1].name;
+  }
+  if (metricCustomModel.parentTableColumnSettings && ((_d = parentCustomModel.uiSettings) == null ? void 0 : _d.columnSettings)) {
+    metricCustomModel.parentTableColumnSettings.splice(
+      0,
+      metricCustomModel.parentTableColumnSettings.length,
+      ...parentCustomModel.uiSettings.columnSettings
+    );
+  }
+  if (((_e = metricCustomModel.inputs) == null ? void 0 : _e["view_worksheet"]) && metricCustomModel.parentTableColumnSettings) {
+    _.forEach(metricCustomModel.parentTableColumnSettings, (c) => {
+      var _a2;
+      if ((_a2 = metricCustomModel.inputs) == null ? void 0 : _a2.view_worksheet) {
+        metricCustomModel.inputs.view_worksheet = _.uniq([
+          ...metricCustomModel.inputs.view_worksheet,
+          c.field
+        ]);
+      }
+    });
+  }
+  if (parentTableVariable) {
+    metricCustomModel.parentTableVariable = parentTableVariable;
+  }
+  return { definitionModel: metricDefinitionModel, customModel: metricCustomModel };
+};
+class MergeFilterService {
+  getColumnSettingsForCommonFilters(cf) {
+    return [
+      {
+        label: cf.name,
+        value: cf.column.name,
+        option: {
+          headerName: cf.name,
+          field: cf.column.name,
+          //@ts-ignore
+          type: cf.column.data_type,
+          datasetName: cf.datasetName,
+          datasetId: cf.datasetId
+        }
+      }
+    ];
+  }
+  mergeCommonFilters(props) {
+    const { commonFilters, rule, id, condition } = props;
+    let replacedFr = [];
+    if (_.isEmpty(commonFilters)) return { defaultType: condition, rules: rule };
+    _.forEach(commonFilters, (f) => {
+      const columnSettingsSelectOption = this.getColumnSettingsForCommonFilters(f);
+      const appliedOnLine = _.find(f == null ? void 0 : f.appliedOnBlocks, (l) => l.blockId === id);
+      if (appliedOnLine && appliedOnLine.applied) {
+        const commonRule = f.rule;
+        const fr = filterToSelectOptionType(commonRule, columnSettingsSelectOption);
+        const columnSetting = _.find(
+          appliedOnLine.columnSettings,
+          (c) => c.value === appliedOnLine.column
+        );
+        if (columnSetting) {
+          replacedFr.push(replaceFilterColumn({ fr: fr.rules, column: columnSetting }));
+        }
+      }
+    });
+    const mergedFr = _.unionBy(replacedFr.flat(), rule, "value");
+    return { defaultType: condition, rules: mergedFr };
+  }
+  getApplicablePromotedFilters(props) {
+    const { id, datasetIds, promotedFilters } = props;
+    return _.filter(promotedFilters, (pf) => {
+      const appliedBlock = _.find(pf.appliedOnBlocks, (aob) => aob.blockId === id);
+      const isApplied = (appliedBlock == null ? void 0 : appliedBlock.applied) ?? false;
+      return isApplied && _.includes(datasetIds, pf.datasetId);
+    });
+  }
+  getUnion(promotedFilters, metricFilters, columnSettings) {
+    const pfSelectOptions = _.map(promotedFilters, (pf) => {
+      var _a;
+      return ((_a = filterToSelectOptionType(pf.rule, getColumnSettingsToSelectOptions(pf.blockColumnSettings))) == null ? void 0 : _a.rules) ?? [];
+    }).flat();
+    const mFilterModel = filterToSelectOptionType(
+      metricFilters,
+      getColumnSettingsToSelectOptions(columnSettings)
+    );
+    if (_.isEmpty(mFilterModel)) {
+      return { defaultType: "and_cond", rules: pfSelectOptions };
+    }
+    const ruleType = (mFilterModel == null ? void 0 : mFilterModel.defaultType) ?? "and_cond";
+    const mSelectOptions = (mFilterModel == null ? void 0 : mFilterModel.rules) ?? [];
+    const union = _.unionBy(pfSelectOptions, mSelectOptions, "value");
+    return { defaultType: ruleType, rules: union };
+  }
+  /** merges promoted filter to metric filter */
+  mergePromotedFilters(props) {
+    const { metricFilters, columnSettings, promotedFilters } = props;
+    const applicablePromotedFilters = this.getApplicablePromotedFilters({
+      id: props.id,
+      datasetIds: props.datasetIds,
+      promotedFilters
+    });
+    return this.getUnion(applicablePromotedFilters, metricFilters, columnSettings);
+  }
+  mergeFilters(props) {
+    const { commonFilters } = props;
+    const filtersWithPromoted = this.mergePromotedFilters(props);
+    const filtersWithCommon = this.mergeCommonFilters({
+      commonFilters,
+      rule: filtersWithPromoted.rules,
+      id: props.id,
+      condition: (filtersWithPromoted == null ? void 0 : filtersWithPromoted.defaultType) ?? "and_cond"
+    });
+    return getSelectOptionTypeToFilter(filtersWithCommon);
+  }
+}
+const updatePromotedFiltersAndDateRangeToMetadataAndInputs = (props) => {
+  var _a;
+  const { blockId, metadata, promotedFilters, inputs, commonFilters } = props;
+  const updateDateRange = (updateProps) => {
+    var _a2;
+    const { blockId: blockId2, blockDateRange, dateRangeModel } = updateProps;
+    const { dateRange, appliedOnBlocks } = dateRangeModel;
+    const dateRangeApplicableOnBlockIds = (_a2 = appliedOnBlocks == null ? void 0 : appliedOnBlocks.filter((apb) => apb.applied)) == null ? void 0 : _a2.map((apb) => apb.blockId);
+    if (dateRangeApplicableOnBlockIds == null ? void 0 : dateRangeApplicableOnBlockIds.includes(blockId2)) {
+      return dateRange;
+    } else {
+      return blockDateRange;
+    }
+  };
+  const updateCurrencyFilter = (updateProps) => {
+    const { blockId: blockId2, blockCurrencyFilter, currencyModel } = updateProps;
+    const { currency, appliedOnBlocks } = currencyModel;
+    const currencyFilterApplicableOnBlockIds = _.chain(appliedOnBlocks).filter((apb) => apb.applied).map((apb) => apb.blockId).value();
+    if (currencyFilterApplicableOnBlockIds == null ? void 0 : currencyFilterApplicableOnBlockIds.includes(blockId2)) {
+      return currency;
+    } else {
+      return blockCurrencyFilter;
+    }
+  };
+  const metricColumnFilter = getColumnFilterRuleFromCombinedFilterRule(
+    metadata.filterModel,
+    metadata.valueCols || []
+  );
+  const updatedFilterRule = new MergeFilterService().mergeFilters({
+    id: blockId,
+    metricFilters: metricColumnFilter,
+    columnSettings: metadata.columnSettings,
+    promotedFilters,
+    commonFilters: commonFilters || [],
+    datasetIds: [metadata.datasetId || ""]
+  });
+  const updatedDateRange = updateDateRange({
+    blockId,
+    blockDateRange: metadata.dateRange || { time_period: "past_quarter" },
+    dateRangeModel: props.dateRangeModel
+  });
+  const updateCurrencyFilterValue = updateCurrencyFilter({
+    blockId,
+    blockCurrencyFilter: metadata.currency || "",
+    currencyModel: props.currencyModel
+  });
+  const updatedInputs = {
+    ...inputs,
+    ["filterOnAggregates"]: _.get(
+      inputs,
+      "filterOnAggregates",
+      defaultFilterRule
+    ),
+    ["rule_pivot"]: updatedFilterRule,
+    date_range: updatedDateRange,
+    to_currency: updateCurrencyFilterValue,
+    showDimensionMappingValues: metadata.showDimensionMappingValues ?? false,
+    showBinSortOrderValues: ((_a = metadata == null ? void 0 : metadata.inputs) == null ? void 0 : _a.showBinSortOrderValues) ?? false
+  };
+  const updatedMetadata = {
+    ...metadata,
+    filterModel: updatedFilterRule,
+    dateRange: updatedDateRange,
+    inputs: updatedInputs
+  };
+  return { updatedInputs, updatedMetadata };
+};
+const getRowsToGroupBy = (props) => {
+  const { pivotColumns, timeBin, rowGroupColumns } = props;
+  const rowsToGroupBy = [];
+  if (!_.isEmpty(pivotColumns)) {
+    if (timeBin) {
+      rowsToGroupBy.push([...rowGroupColumns]);
+      for (let i = 0; i < pivotColumns.length; i++) {
+        const pcols = pivotColumns;
+        rowsToGroupBy.push([...pcols.slice(0, i + 1), ...rowGroupColumns]);
+      }
+    } else {
+      for (let i = 0; i < pivotColumns.length; i++) {
+        const pcols = pivotColumns;
+        rowsToGroupBy.push([...pcols.slice(0, i + 1), ...rowGroupColumns]);
+      }
+    }
+  } else {
+    rowsToGroupBy.push([...pivotColumns, ...rowGroupColumns]);
+  }
+  return rowsToGroupBy;
+};
+const getInputsArray = (props) => {
+  const {
+    pivotColumns,
+    timeBin,
+    rowsToGroupBy,
+    inputs,
+    dateColumn,
+    valueCols,
+    hierarchy,
+    rowGroupCols,
+    compareTrends,
+    showDimensionMappingValues = false,
+    showBinSortOrderValues = false
+  } = props;
+  let inputsArray = [];
+  const inputsCompareTrendsIndices = [];
+  const getViewsInput = (index2) => {
+    let viewInputs = inputs == null ? void 0 : inputs.viewInputs;
+    if (!viewInputs) return void 0;
+    const valueColsLabel = _.map(valueCols, (vc) => vc.label);
+    viewInputs = _.filter(
+      viewInputs,
+      (vi) => valueColsLabel.includes(vi) || vi.includes("__bc_")
+    );
+    if (_.isEmpty(rowGroupCols)) {
+      viewInputs = _.filter(viewInputs, (vi) => !vi.includes("__bc_"));
+    }
+    if (timeBin) {
+      viewInputs = _.uniq([...viewInputs, dateColumn, `${dateColumn}_group`]);
+    }
+    if (index2 !== void 0) {
+      viewInputs = _.uniq([...viewInputs, ...rowsToGroupBy[index2]]);
+    } else {
+      if (!_.isEmpty(rowGroupCols)) {
+        let row = rowsToGroupBy[0];
+        if (!_.isEmpty(hierarchy) && hierarchy) {
+          const rowLabelName = _.get(rowsToGroupBy, "0.0.0");
+          row = [
+            rowLabelName,
+            `${rowLabelName}_level_number`,
+            `${rowLabelName}_${hierarchy.parentColId}`,
+            `${rowLabelName}_${hierarchy.nodeColName}`
+          ];
+        }
+        viewInputs = _.uniq([...viewInputs, ...row]);
+      }
+    }
+    return viewInputs;
+  };
+  const projectAsInput = _.reduce(
+    valueCols,
+    (acc, curr) => {
+      if (curr.showAs && curr.showAs !== ShowAsEnum.DEFAULT && curr.label) {
+        acc[curr.label] = ShowAsToProjectFractionMapper[curr.showAs];
+      }
+      return acc;
+    },
+    {}
+  );
+  const sortPivotInputsKey = Object.keys(inputs).find(
+    (key) => key.startsWith("sortPivotInputs")
+  );
+  const sortPivotInputsValue = sortPivotInputsKey ? { ...inputs[sortPivotInputsKey] } : void 0;
+  if (!_.isEmpty(pivotColumns)) {
+    const pc = timeBin ? [dateColumn, ...pivotColumns] : pivotColumns;
+    pc == null ? void 0 : pc.forEach((col, index2) => {
+      const groupByInput = rowsToGroupBy[index2];
+      const columnGroupByInput = _.filter(groupByInput, (r) => pc.includes(r));
+      const rowGroupByInput = _.filter(groupByInput, (r) => !pc.includes(r));
+      if (sortPivotInputsValue) {
+        sortPivotInputsValue.pivotColumns = rowsToGroupBy[index2];
+      }
+      inputsArray.push({
+        ...inputs,
+        groupByInput: rowsToGroupBy[index2],
+        dateColumnInput: dateColumn,
+        binByInput: timeBin,
+        viewInputs: getViewsInput(index2),
+        columnGroupByInput,
+        rowGroupByInput,
+        projectAsInput,
+        showDimensionMappingValues,
+        showBinSortOrderValues,
+        ...sortPivotInputsKey ? { [sortPivotInputsKey]: sortPivotInputsValue } : {}
+      });
+    });
+  } else {
+    if (compareTrends && compareTrends.length > 0) {
+      if (sortPivotInputsValue) {
+        sortPivotInputsValue.pivotColumns = rowsToGroupBy[0];
+      }
+      inputsArray = _.map(compareTrends, (ct, index2) => {
+        inputsCompareTrendsIndices.push({ id: ct.id, index: index2 });
+        return {
+          ...inputs,
+          date_range: { ...ct.dateRange },
+          groupByInput: rowsToGroupBy[0],
+          dateColumnInput: dateColumn,
+          binByInput: timeBin,
+          viewInputs: getViewsInput(),
+          rowGroupByInput: rowsToGroupBy[0],
+          columnGroupByInput: [],
+          projectAsInput,
+          showDimensionMappingValues,
+          showBinSortOrderValues,
+          ...sortPivotInputsKey ? { [sortPivotInputsKey]: sortPivotInputsValue } : {}
+        };
+      });
+    } else {
+      if (sortPivotInputsValue) {
+        sortPivotInputsValue.pivotColumns = rowsToGroupBy[0];
+      }
+      inputsArray = [
+        {
+          ...inputs,
+          groupByInput: rowsToGroupBy[0],
+          dateColumnInput: dateColumn,
+          binByInput: timeBin,
+          viewInputs: getViewsInput(),
+          rowGroupByInput: rowsToGroupBy[0],
+          columnGroupByInput: [],
+          projectAsInput,
+          showDimensionMappingValues,
+          showBinSortOrderValues,
+          ...sortPivotInputsKey ? { [sortPivotInputsKey]: sortPivotInputsValue } : {}
+        }
+      ];
+    }
+  }
+  return { inputs: inputsArray, inputsCompareTrendsIndices };
+};
+const mergeDrilldownFiltersToMetricFilters = (props) => {
+  const { metricFilterRule, filtersToBeApplied, columnSettings } = props;
+  const columnSelectOptions = getColumnSettingsToSelectOptions(columnSettings);
+  const metricFilterRuleSelectOptions = filterToSelectOptionType(
+    metricFilterRule,
+    columnSelectOptions
+  );
+  const drilldownFilterMap = getDrilldownFiltersMap({
+    filtersToBeApplied,
+    columnSelectOptions
+  });
+  const mergedRule = _.unionBy(
+    Object.values(drilldownFilterMap),
+    metricFilterRuleSelectOptions.rules,
+    "value"
+  );
+  const filterRule = getSelectOptionTypeToFilter({
+    defaultType: "and_cond",
+    rules: mergedRule
+  });
+  return filterRule;
+};
+const getMetricDefinition = (props) => {
+  var _a, _b;
+  const {
+    sheetId,
+    metadata,
+    groupKeys,
+    promotedFiltersStoreValue,
+    promotedFilters,
+    dateRangeModel,
+    currencyModel,
+    commonFilters
+  } = props;
+  const {
+    parentTableVariable,
+    valueCols,
+    rowGroupCols,
+    pivotCols,
+    timeBin,
+    dateColumn,
+    columnSettings
+  } = metadata;
+  let inputs = metadata == null ? void 0 : metadata.inputs;
+  const { updatedInputs } = updatePromotedFiltersAndDateRangeToMetadataAndInputs({
+    blockId: sheetId,
+    metadata,
+    promotedFilters,
+    inputs,
+    dateRangeModel,
+    currencyModel,
+    commonFilters
+  });
+  let rowsToGroupBy = getRowsToGroupBy({
+    pivotColumns: pivotCols || [],
+    rowGroupColumns: (rowGroupCols || []).slice(0, groupKeys.length + 1),
+    timeBin: timeBin || ""
+  });
+  let { inputs: inputsArray } = getInputsArray({
+    inputs: updatedInputs,
+    dateColumn: dateColumn || "",
+    timeBin: timeBin || "",
+    rowsToGroupBy,
+    pivotColumns: pivotCols || [],
+    valueCols: valueCols || [],
+    rowGroupCols,
+    compareTrends: metadata.compareTrends,
+    showDimensionMappingValues: ((_a = metadata == null ? void 0 : metadata.inputs) == null ? void 0 : _a.showDimensionMappingValues) ?? false,
+    showBinSortOrderValues: ((_b = metadata == null ? void 0 : metadata.inputs) == null ? void 0 : _b.showBinSortOrderValues) ?? false
+  });
+  if (!_.isEmpty(groupKeys)) {
+    const mergedFilterRule = mergeDrilldownFiltersToMetricFilters({
+      metricFilterRule: getMetricFilterRule(inputsArray),
+      filtersToBeApplied: getFiltersToBeAppliedOnDrilldown({
+        rowGroups: metadata == null ? void 0 : metadata.rowGroupCols,
+        groupKeys
+      }),
+      columnSettings
+    });
+    inputsArray = inputsArray == null ? void 0 : inputsArray.map((ia) => {
+      return { ...ia, ["rule_pivot"]: mergedFilterRule };
+    });
+  }
+  return {
+    inputs: inputsArray,
+    describe: parentTableVariable
+  };
+};
+const getSelectedMetricsParentIds = (selectedItems) => {
+  return _.chain(selectedItems).map((s) => {
+    var _a, _b;
+    return (_b = (_a = s == null ? void 0 : s.sheet) == null ? void 0 : _a.customFields) == null ? void 0 : _b.parentTableId;
+  }).uniq().value();
+};
+const defaultDashboardDateRangeModel = {
+  //@ts-ignore
+  dateRange: {},
+  appliedOnBlocks: []
+};
+const defaultCurrencyModel = {
+  currency: "USD",
+  appliedOnBlocks: []
+};
+const getGroupByDefinition = ({
+  tableId,
+  tableName,
+  groupKeys,
+  rowGroupCols,
+  columnSettings,
+  filterRules,
+  sortValue,
+  metricSeries
+}) => {
+  let filtersToBeApplied = getFiltersToBeAppliedOnDrilldown({
+    groupKeys,
+    rowGroups: rowGroupCols
+  });
+  const columnSelectOptions = getColumnSettingsToSelectOptions(columnSettings);
+  const metricFilterRuleSelectOptions = filterToSelectOptionType(filterRules, columnSelectOptions);
+  const crossFilterMap = getDrilldownFiltersMap({
+    filtersToBeApplied,
+    columnSelectOptions
+  });
+  const mergedRule = _.unionBy(
+    Object.values(crossFilterMap),
+    metricFilterRuleSelectOptions.rules,
+    "value"
+  );
+  const filterRule = getSelectOptionTypeToFilter({
+    defaultType: "and_cond",
+    rules: mergedRule
+  });
+  return generateDefinitionModel({
+    filters: filterRule,
+    sort: sortValue,
+    metricSeries,
+    tableId,
+    tableName
+  });
+};
+const generateDefinitionModel = ({
+  filters,
+  sort,
+  metricSeries,
+  tableId,
+  tableName
+}) => {
+  const { transformations, targetName } = generateTransformations(
+    tableName,
+    filters,
+    sort,
+    metricSeries
+  );
+  const importConfig = getImportConfig(tableId, tableName);
+  return {
+    targetName,
+    definition: {
+      imports: [importConfig],
+      transformations
+    }
+  };
+};
+const sortConfigFromValue = (sortBy) => {
+  const sortValueObj = !_.isNil(sortBy == null ? void 0 : sortBy.sortByField) ? { [sortBy.sortByField.value]: _.get(sortBy, "sortByOrder", "asc").toUpperCase() } : void 0;
+  return sortValueObj;
+};
+const getMetricSeries = (props) => {
+  const { pivotCols, rowGroupCols, valueCols } = props;
+  const group_by = [...pivotCols, ...rowGroupCols];
+  const aggregates = _.map(valueCols, (valueCol) => {
+    if (valueCol.type === "formula") {
+      const formula = valueCol.formula;
+      return [valueCol.label, formula];
+    } else if (valueCol.type === "column") {
+      const formula = valueCol.formula;
+      return [valueCol.label, formula];
+    }
+    return [valueCol.label, valueCol.col, valueCol.aggFun];
+  });
+  const metricSeries = {
+    aggregates,
+    group_by,
+    row_group_by: rowGroupCols,
+    col_group_by: pivotCols,
+    type: "TableAggregate",
+    formula_on_aggregates: []
+  };
+  return metricSeries;
+};
+const getFilterConfig = (filters, prevName) => ({
+  name: "table_filter",
+  table_name: prevName,
+  filter: filters,
+  type: "CollectionFilter"
+});
+const getSortConfig = (sort, prevName) => ({
+  name: "table_sort",
+  table_name: prevName,
+  sort_columns: sort,
+  type: "CollectionSort"
+});
+const generateTransformations = (tableName, filters, sort, metricSeries) => {
+  const transformations = [];
+  let prevName = tableName;
+  let targetName = tableName;
+  if (!_.isEmpty(filters)) {
+    const filterConfig = getFilterConfig(filters, prevName);
+    transformations.push(filterConfig);
+    prevName = filterConfig.name;
+    targetName = "table_filter";
+  }
+  if (metricSeries) {
+    const aggregateConfig = {
+      name: "table_aggregate",
+      table_name: prevName,
+      aggregates: metricSeries.aggregates,
+      group_by: metricSeries.group_by,
+      type: "CollectionAggregate"
+    };
+    transformations.push(aggregateConfig);
+    prevName = aggregateConfig.name;
+    targetName = "table_aggregate";
+  }
+  if (metricSeries == null ? void 0 : metricSeries.aggregates) {
+    if (sort !== void 0) {
+      const sortEntries = Object.entries(sort);
+      if (sortEntries.length > 0) {
+        const newSort = {};
+        for (const [sortKey, sortOrder] of sortEntries) {
+          const matchingAggregate = metricSeries.aggregates.find((agg) => agg[1] === sortKey);
+          if (matchingAggregate) {
+            newSort[matchingAggregate[0]] = sortOrder;
+          }
+        }
+        sort = _.isEmpty(newSort) ? {} : newSort;
+      }
+    }
+  }
+  if (!_.isEmpty(sort)) {
+    const sortConfig = getSortConfig(sort, prevName);
+    transformations.push(sortConfig);
+    prevName = sortConfig.name;
+    targetName = "table_sort";
+  }
+  return { transformations, targetName };
+};
+const getImportConfig = (id, name) => ({
+  name,
+  table_id: id,
+  type: "TableImport"
+});
+const inputTableDefinition = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  generateDefinitionModel,
+  getGroupByDefinition,
+  getMetricSeries,
+  sortConfigFromValue
+}, Symbol.toStringTag, { value: "Module" }));
+const index$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  formatDate,
+  getMetricDefinition,
+  inputTableUtils: inputTableDefinition
+}, Symbol.toStringTag, { value: "Module" }));
+async function downloadFile(loc, contentType) {
+  if (!loc) return null;
+  const requestData = {
+    key: loc,
+    contentType,
+    method: "GET"
+    // Type assertion to match the expected type
+  };
+  try {
+    const response = await getFileUrlByFileId(requestData);
+    const presignedUrl = response.url;
+    const config = {
+      method: "GET",
+      url: presignedUrl,
+      headers: {
+        "Content-Type": "application/octet-stream"
+      }
+    };
+    const axiosInstance = axios.create();
+    const result = await axiosInstance(config);
+    const fileRead = result.data;
+    return fileRead;
+  } catch (error) {
+    console.error("Error downloading file:", error);
+    throw error;
+  }
+}
+const hydrateWorksheet = async (sheet) => {
+  try {
+    if (!sheet) return sheet;
+    const isHydrated = sheet.definitionModel && sheet.customModel;
+    if (isHydrated) {
+      return sheet;
+    }
+    const definitionModelId = sheet.externalDataId;
+    const customModelId = sheet.modelId;
+    let definitionModel = {};
+    let customModel = {};
+    const sheetId = sheet.id;
+    if (definitionModelId && customModelId) {
+      definitionModel = await downloadFile(definitionModelId, "application/json");
+      customModel = await downloadFile(customModelId, "application/json");
+    }
+    if (!definitionModel || !definitionModel[sheetId]) {
+      return sheet;
+    }
+    sheet.definitionModel = definitionModel[sheetId];
+    sheet.customModel = customModel[sheetId];
+    return sheet;
+  } catch (error) {
+    console.error("Error hydrating portal page:", error);
+    throw error;
+  }
+};
+const getData$2 = async (metricSheetId, options) => {
+  var _a, _b, _c, _d, _e, _f;
+  const worksheets = await getWorksheets([metricSheetId]);
+  if (_.isEmpty(worksheets)) return {};
+  const selectedWorksheet = worksheets[0];
+  const hydratedSheet = await hydrateWorksheet(selectedWorksheet);
+  if (!hydratedSheet) return {};
+  const selectedMetricsParentIds = getSelectedMetricsParentIds([
+    { sheet: selectedWorksheet }
+  ]);
+  const parentWorksheets = await getWorksheets(selectedMetricsParentIds);
+  const parentSheet = _.find(
+    parentWorksheets,
+    (ps) => ps.id === (hydratedSheet == null ? void 0 : hydratedSheet.customFields.parentTableId)
+  );
+  let definitionModel;
+  let customModel;
+  if (parentSheet) {
+    const hydratedParentSheet = await hydrateWorksheet(parentSheet);
+    if (hydratedParentSheet == null ? void 0 : hydratedParentSheet.definitionModel) {
+      const {
+        definitionModel: parentDefinitionModel,
+        customModel: parentCustomModel
+      } = getUpdatedDefinitionCustomModel({
+        metricDefinitionModel: hydratedSheet.definitionModel,
+        parentDefinitionModel: hydratedParentSheet == null ? void 0 : hydratedParentSheet.definitionModel,
+        parentCustomModel: hydratedParentSheet == null ? void 0 : hydratedParentSheet.customModel,
+        metricCustomModel: hydratedSheet.customModel
+      });
+      definitionModel = parentDefinitionModel;
+      customModel = parentCustomModel;
+    }
+  } else {
+    definitionModel = hydratedSheet.definitionModel;
+    customModel = hydratedSheet.customModel;
+  }
+  const cModel = customModel;
+  const dModel = definitionModel;
+  const gridColumnState = cModel == null ? void 0 : cModel.gridColumnState;
+  const { variable, parentTableVariable, inputs } = cModel;
+  const aliases = (_a = dModel == null ? void 0 : dModel.aliases) == null ? void 0 : _a[parentTableVariable];
+  let timeBin = "";
+  if (options == null ? void 0 : options.isKPI) {
+    timeBin = (options == null ? void 0 : options.plotAsTrend) ? !_.isEmpty(cModel == null ? void 0 : cModel.timeBin) ? cModel == null ? void 0 : cModel.timeBin : "per_month" : "";
+  } else {
+    timeBin = (cModel == null ? void 0 : cModel.timeBin) ?? "";
+  }
+  const valueCols = _.map(gridColumnState == null ? void 0 : gridColumnState.valueCols, (vc) => ({
+    ...vc,
+    hide: false
+  }));
+  const columnSettings = _.map(cModel == null ? void 0 : cModel.parentTableColumnSettings, (cs) => ({
+    ...cs,
+    hide: false
+  }));
+  const metadata = {
+    variable,
+    parentTableVariable,
+    inputs,
+    datasetId: (cModel == null ? void 0 : cModel.datasetId) ?? "",
+    datasetName: (cModel == null ? void 0 : cModel.datasetName) ?? "",
+    columnSettings: columnSettings ?? [],
+    filterColumnsBy: (cModel == null ? void 0 : cModel.filterColumnsBy) ?? {},
+    filterModel: ((_c = (_b = hydratedSheet == null ? void 0 : hydratedSheet.customModel) == null ? void 0 : _b.gridColumnState) == null ? void 0 : _c.filterModel) ?? {},
+    valueCols: valueCols ?? [],
+    rowGroupCols: (gridColumnState == null ? void 0 : gridColumnState.rowGroupCols) ?? [],
+    pivotCols: (gridColumnState == null ? void 0 : gridColumnState.pivotCols) ?? [],
+    dateColumn: cModel == null ? void 0 : cModel.dateColumn,
+    timeBin,
+    dateRange: (_d = cModel == null ? void 0 : cModel.inputs) == null ? void 0 : _d.date_range,
+    aliases,
+    lastModifiedDate: hydratedSheet == null ? void 0 : hydratedSheet.lastModifiedDate,
+    hierarchy: cModel == null ? void 0 : cModel.hierarchy,
+    description: "",
+    isKPI: (options == null ? void 0 : options.isKPI) ?? false,
+    currency: cModel == null ? void 0 : cModel.currency,
+    sortOptions: cModel == null ? void 0 : cModel.sortOptions,
+    limitOptions: cModel == null ? void 0 : cModel.limitOptions,
+    stringValue: (options == null ? void 0 : options.stringValue) ?? false
+  };
+  const { inputs: definitionInputs, describe } = getMetricDefinition({
+    sheetId: hydratedSheet.id,
+    metadata,
+    groupKeys: (options == null ? void 0 : options.groupKeys) ?? [],
+    lastModifiedDate: hydratedSheet.lastModifiedDate,
+    promotedFiltersStoreValue: {},
+    promotedFilters: [],
+    dateRangeModel: ((_e = hydratedSheet == null ? void 0 : hydratedSheet.customModel) == null ? void 0 : _e.dateRangeModel) ?? defaultDashboardDateRangeModel,
+    currencyModel: ((_f = hydratedSheet == null ? void 0 : hydratedSheet.customModel) == null ? void 0 : _f.currencyModel) ?? defaultCurrencyModel,
+    commonFilters: []
+  });
+  let resultData = [];
+  if (!_.isEmpty(valueCols) || !_.isEmpty(metadata.rowGroupCols) || !_.isEmpty(metadata.pivotCols)) {
+    if (!_.isEmpty(definitionInputs)) {
+      let promises = [];
+      definitionInputs.forEach((input) => {
+        promises.push(
+          runPublishedDefinition({
+            inputs: { ...input },
+            sheet: {
+              id: hydratedSheet.id,
+              lastModifiedDate: hydratedSheet.lastModifiedDate
+            },
+            variable,
+            describe: parentTableVariable
+          })
+        );
+      });
+      const data = await Promise.all(promises);
+      resultData = _.map(data, (d) => d.data.data);
+    } else {
+      const result = (await runPublishedDefinition({
+        inputs: { ...inputs },
+        sheet: {
+          id: hydratedSheet.id,
+          lastModifiedDate: hydratedSheet.lastModifiedDate
+        },
+        variable,
+        describe: parentTableVariable
+      })).data;
+      resultData = result.data;
+    }
+  }
+  resultData = _.flatten(resultData);
+  return { data: resultData };
+};
+const index$3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getData: getData$2
+}, Symbol.toStringTag, { value: "Module" }));
+class DefinitionBuilder {
+  constructor(def) {
+    __publicField(this, "definition");
+    this.definition = {
+      inputs: {},
+      aliases: {},
+      imports: [],
+      loads: [],
+      variables: [],
+      permissions: [],
+      exports: [],
+      tables: [],
+      sections: []
+    };
+    if (def) {
+      this.definition = {
+        ...this.definition,
+        ...def
+      };
+    }
+  }
+  static builder(def) {
+    return new DefinitionBuilder(def);
+  }
+  // Input methods
+  withInputs(inputs) {
+    this.definition.inputs = { ...this.definition.inputs, ...inputs };
+    return this;
+  }
+  // Alias methods
+  withAlias(tableName, columnAliases) {
+    if (!this.definition.aliases) {
+      this.definition.aliases = {};
+    }
+    this.definition.aliases[tableName] = columnAliases;
+    return this;
+  }
+  // Import methods
+  addImport(imprt) {
+    var _a;
+    (_a = this.definition.imports) == null ? void 0 : _a.push(imprt);
+    return this;
+  }
+  addDatasetImport(datasetId, options) {
+    const imprt = {
+      loc: datasetId,
+      to: datasetId,
+      import_type: "dataset",
+      ...options
+    };
+    return this.addImport(imprt);
+  }
+  // Load methods
+  addLoad(load) {
+    var _a;
+    (_a = this.definition.loads) == null ? void 0 : _a.push(load);
+    return this;
+  }
+  addFileLoad(from, to, fsOptions = {}) {
+    const load = {
+      loc: from,
+      to,
+      fs_options: fsOptions
+    };
+    return this.addLoad(load);
+  }
+  // Variable methods
+  addVariable(name, transforms) {
+    var _a;
+    const variable = {
+      name,
+      transforms
+    };
+    (_a = this.definition.variables) == null ? void 0 : _a.push(variable);
+    return this;
+  }
+  // Permission methods
+  addPermission(permission) {
+    var _a;
+    (_a = this.definition.permissions) == null ? void 0 : _a.push(permission);
+    return this;
+  }
+  // Export methods
+  addExport(exprt) {
+    var _a;
+    (_a = this.definition.exports) == null ? void 0 : _a.push(exprt);
+    return this;
+  }
+  // Table methods
+  addTable(table) {
+    var _a;
+    (_a = this.definition.tables) == null ? void 0 : _a.push(table);
+    return this;
+  }
+  // Section methods
+  addSection(section) {
+    var _a;
+    (_a = this.definition.sections) == null ? void 0 : _a.push(section);
+    return this;
+  }
+  // Build method with basic validation
+  build() {
+    this.validateDefinition();
+    return this.definition;
+  }
+  validateDefinition() {
+    var _a, _b, _c;
+    const definedTables = /* @__PURE__ */ new Set([
+      ...((_a = this.definition.imports) == null ? void 0 : _a.map((i) => i.to)) || [],
+      ...((_b = this.definition.loads) == null ? void 0 : _b.map((l) => l.to)) || []
+    ]);
+    const aliasedTables = Object.keys(this.definition.aliases || {});
+    for (const table of aliasedTables) {
+      if (!definedTables.has(table)) {
+        throw new Error(
+          `Table "${table}" referenced in aliases but not defined in imports or loads`
+        );
+      }
+    }
+    (_c = this.definition.variables) == null ? void 0 : _c.forEach((variable) => {
+      if (!variable.name) {
+        throw new Error("Variable must have a name");
+      }
+      if (!Array.isArray(variable.transforms) || variable.transforms.length === 0) {
+        throw new Error(`Variable "${variable.name}" must have at least one transform`);
+      }
+    });
+  }
+}
+const getData$1 = async (datasetId, options) => {
+  var _a, _b, _c;
+  try {
+    if (!datasetId) {
+      throw new Error("Dataset ID is required");
+    }
+    const definitionModel = DefinitionBuilder.builder().addDatasetImport(datasetId).build();
+    const response = await runDefinition({
+      definition: definitionModel,
+      inputs: definitionModel.inputs,
+      variable: datasetId,
+      limit: (options == null ? void 0 : options.limit) || 1e3
+    });
+    if (!(response == null ? void 0 : response.data)) {
+      throw new Error("No data returned from API");
+    }
+    return { data: response.data };
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while fetching data for the dataset";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+};
+const getSampleData = async ({
+  datasetId,
+  dataFilter,
+  duplicateColGroups,
+  datasetType
+}) => {
+  var _a, _b, _c;
+  try {
+    if (!datasetId) {
+      throw new Error("Dataset ID is required");
+    }
+    const response = await runSampleDefinition({
+      datasetId,
+      dataFilter,
+      duplicateColGroups,
+      datasetType
+    });
+    if (!(response == null ? void 0 : response.data)) {
+      throw new Error("No data returned from API");
+    }
+    return { data: response.data };
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while fetching sample data";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+};
+const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getData: getData$1,
+  getSampleData
+}, Symbol.toStringTag, { value: "Module" }));
+const getPublishedWorkbookById = async ({
+  type,
+  id
+}) => {
+  var _a, _b, _c;
+  try {
+    const response = await apiClient.post("/workbook/published", {
+      type,
+      id
+    });
+    if (!response.data) {
+      throw { message: "Failed to fetch workbook details", status: 500 };
+    }
+    return response.data;
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while fetching workbook details";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+};
+var WorkbookTypeEnum = /* @__PURE__ */ ((WorkbookTypeEnum2) => {
+  WorkbookTypeEnum2["WORKBOOK"] = "WORKBOOK";
+  WorkbookTypeEnum2["TRANSFORMATION"] = "TRANSFORMATION";
+  WorkbookTypeEnum2["STATEMENT"] = "STATEMENT";
+  WorkbookTypeEnum2["DASHBOARD"] = "DASHBOARD";
+  WorkbookTypeEnum2["PORTAL"] = "PORTAL";
+  WorkbookTypeEnum2["PROCESS"] = "PROCESS";
+  WorkbookTypeEnum2["COLLECTION"] = "COLLECTION";
+  WorkbookTypeEnum2["COST_ALLOCATION_GROUP"] = "ALLOCATION_GROUP";
+  WorkbookTypeEnum2["ALLOCATION_BLUEPRINT"] = "ALLOCATION_BLUEPRINT";
+  WorkbookTypeEnum2["FIN_CLOSE"] = "FIN_CLOSE";
+  WorkbookTypeEnum2["PAGE_TEMPLATE"] = "PAGE_TEMPLATE";
+  return WorkbookTypeEnum2;
+})(WorkbookTypeEnum || {});
+const getTableById = async (tableId) => {
+  var _a, _b, _c;
+  try {
+    const response = await apiClient.get(
+      `/input-table/get-table/${tableId}`
+    );
+    if (!response.data) {
+      throw { message: "Failed to fetch table details", status: 500 };
+    }
+    return response.data;
+  } catch (error) {
+    const message = ((_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) || error.message || "An unexpected error occurred while fetching table details";
+    const status = ((_c = error.response) == null ? void 0 : _c.status) || 500;
+    throw { message, status };
+  }
+};
+const getData = async ({
+  inputTableId: inputTableWorkbookId,
+  inputTableViewId,
+  pageParams = {},
+  limitParams,
+  sortParams,
+  offsetParam
+}) => {
+  var _a, _b, _c, _d;
+  try {
+    if (!inputTableWorkbookId || !inputTableViewId) {
+      return [];
+    }
+    const inputTableWorkbook = await getPublishedWorkbookById({
+      id: inputTableWorkbookId,
+      type: WorkbookTypeEnum.COLLECTION
+    });
+    const inputTableId = _.get(
+      inputTableWorkbook,
+      "customFields.metadata.inputTableId"
+    );
+    const inputTable = await getTableById(inputTableId);
+    if (!inputTable) {
+      throw new Error("Input table not found");
+    }
+    const inputTableView = (_a = inputTableWorkbook == null ? void 0 : inputTableWorkbook.sheets) == null ? void 0 : _a.find(
+      (sheet) => sheet.id === inputTableViewId
+    );
+    if (!inputTableView) {
+      throw new Error("Input table view not found");
+    }
+    const hydratedView = await hydrateWorksheet(inputTableView);
+    if (!hydratedView) {
+      throw new Error("Failed to hydrate input table view");
+    }
+    const filters = _.get(hydratedView, "customModel.filters");
+    const sort = _.get(hydratedView, "customModel.sort");
+    const limit = _.get(hydratedView, "customModel.limit", {});
+    const metadata = _.get(hydratedView, "customModel.metadata");
+    let { targetName, definition } = {
+      targetName: "",
+      definition: {}
+    };
+    if (hydratedView.type === "PIVOT") {
+      const gridColumnState = {
+        valueCols: _.get(metadata, "valueCols", []),
+        rowGroupCols: _.get(metadata, "rowGroupCols", []),
+        filterModel: _.get(metadata, "filterModel", {}),
+        pivotCols: _.get(metadata, "pivotCols", [])
+      };
+      const metricSeries = getMetricSeries({
+        pivotCols: _.get(metadata, "pivotCols", []),
+        rowGroupCols: _.get(metadata, "rowGroupCols", []),
+        valueCols: _.get(metadata, "valueCols", [])
+      });
+      const columnSettings = _.get(
+        hydratedView,
+        "customModel.metadata.columnSettings"
+      );
+      const groupByDefinition = getGroupByDefinition({
+        tableId: inputTable.id,
+        tableName: inputTable.name,
+        groupKeys: [],
+        rowGroupCols: gridColumnState.rowGroupCols,
+        columnSettings,
+        filterRules: filters,
+        sortValue: sort,
+        metricSeries
+      });
+      targetName = groupByDefinition.targetName;
+      definition = groupByDefinition.definition;
+    } else {
+      const definitionModel = generateDefinitionModel({
+        tableId: inputTable.id,
+        tableName: inputTable.name,
+        filters,
+        sort: (sortParams == null ? void 0 : sortParams.sortByOrder) ? sortConfigFromValue(sortParams) : sortConfigFromValue(sort)
+      });
+      targetName = definitionModel.targetName;
+      definition = definitionModel.definition;
+    }
+    let stringifiedDefinition = JSON.stringify(definition);
+    try {
+      const matches = stringifiedDefinition == null ? void 0 : stringifiedDefinition.match(/{{\s*([\w.]+)\s*}}/g);
+      if (matches) {
+        matches.forEach((match) => {
+          const key = match.replace(/{{\s*|\s*}}/g, "");
+          const value = _.get(pageParams, key, "");
+          if (value) {
+            stringifiedDefinition = (stringifiedDefinition == null ? void 0 : stringifiedDefinition.replace(match, value)) || "";
+          }
+        });
+      }
+    } catch (error) {
+      console.warn("Error evaluating input", error);
+    }
+    const inputTableResponse = await apiClient.post(
+      "/input-table/get-table-data",
+      {
+        targetName,
+        definition: JSON.parse(stringifiedDefinition)
+      },
+      {
+        params: {
+          limit: (limitParams == null ? void 0 : limitParams.limit) || limit.limit || 1e3,
+          offset: offsetParam || 0
+        }
+      }
+    );
+    const data = _.get(inputTableResponse, "data.result");
+    return { data };
+  } catch (error) {
+    const message = ((_c = (_b = error.response) == null ? void 0 : _b.data) == null ? void 0 : _c.message) || error.message || "An unexpected error occurred while fetching table details";
+    const status = ((_d = error.response) == null ? void 0 : _d.status) || 500;
+    throw { message, status };
+  }
+};
+const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  getData,
+  getTableById
+}, Symbol.toStringTag, { value: "Module" }));
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  apiClient,
+  dataset: index$2,
+  definition: index$5,
+  files: index$6,
+  inputTable: index$1,
+  metric: index$3,
+  user: index$8,
+  workflow: index$7
+}, Symbol.toStringTag, { value: "Module" }));
+const bluecopaTailwindConfig = {
+  darkMode: "class",
+  important: true,
+  theme: {
+    fontFamily: {
+      para: ["Bogle"],
+      display: ["Bogle"],
+      table: ["Bogle"]
+    },
+    fontWeight: {
+      normal: "300",
+      semibold: "500",
+      bold: "700",
+      black: "800"
+    },
+    keyframes: {
+      "fadeIn-top-to-bottom": {
+        "0%": { transform: "translateY(-3%)", opacity: 0 },
+        "100%": { transform: "translateY(0)", opacity: 1 }
+      }
+    },
+    animation: {
+      "fadeIn-t-b": "fadeIn-top-to-bottom 0.8s ease-out forwards",
+      "fadeOut-b-t": "fadeIn-top-to-bottom 0.8s ease-out backwards"
+    },
+    extend: {
+      boxShadow: {
+        md: "2px 2px 10px 0px rgba(0,0,0,0.3)",
+        lg: "4px 4px 10px 0px rgba(0,0,0,0.3)",
+        xl: "6px 6px 10px 0px rgba(0,0,0,0.3)",
+        DEFAULT: "2px 2px 10px 0px rgba(0,0,0,0.3)"
+      },
+      colors: {
+        primary: {
+          50: "#ebf4ff",
+          100: "#dbe9ff",
+          200: "#bed7ff",
+          300: "#97bbff",
+          400: "#6e92ff",
+          500: "#0071dc",
+          600: "#3548ff",
+          700: "#202ee2",
+          800: "#1d2bb6",
+          900: "#202d8f",
+          950: "#131953",
+          DEFAULT: "#0071dc"
+        },
+        secondary: {
+          50: "#F9FAFB",
+          100: "#F3F4F6",
+          200: "#E5E7EB",
+          300: "#D1D5DB",
+          400: "#9CA3AF",
+          500: "#041e42",
+          600: "#4B5563",
+          700: "#374151",
+          800: "#1F2937",
+          900: "#111827",
+          DEFAULT: "#041e42"
+        },
+        danger: {
+          50: "#FEF2F2",
+          100: "#FEE2E2",
+          200: "#FECACA",
+          300: "#FCA5A5",
+          400: "#F87171",
+          500: "#EF4444",
+          600: "#DC2626",
+          700: "#B91C1C",
+          800: "#991B1B",
+          900: "#7F1D1D",
+          DEFAULT: "#DE1C24"
+        },
+        success: {
+          50: "#EEFFDD",
+          100: "#ddedce",
+          200: "#bcdb9d",
+          300: "#9ac96c",
+          400: "#79b73b",
+          500: "#89E32F",
+          600: "#468408",
+          700: "#346306",
+          800: "#234204",
+          900: "#112102",
+          DEFAULT: "#53a10f"
+        },
+        warning: {
+          DEFAULT: "#fff200",
+          100: "#fef3c7"
+        },
+        menuBtnBg: "#ffffff",
+        menuBtnText: "#041e42",
+        navbarBg: "#041e42",
+        navbarBlue: "#041e42",
+        navbarText: "#fff",
+        headerBg: "#fff",
+        headerText: "#041e42",
+        homeHeaderBg: "#f5f5f4",
+        homeHeaderText: "#041e42",
+        coralRed: "#ef4444",
+        dartMouthGreen: "#059669",
+        chestnut: "#c2410c",
+        softPink: "#fecaca",
+        darkPurple: "#6b21a8",
+        darkPastelGreen: "#4d7c0f",
+        sandyBrown: "#fb923c",
+        cinnabar: "#ef4444",
+        tyrianPurple: "#701a75",
+        ruddyBlue: "#0891b2",
+        viridian: "#0f766e",
+        cobaltBlue: "#1d4ed8",
+        dukeBlue: "#1e3a8a",
+        jasmine: "#fde68a"
+      },
+      spacing: {
+        none: "0rem",
+        sm: "0.3025rem",
+        md: "0.605rem",
+        lg: "0.9075rem",
+        xl: "1.21rem",
+        "2xl": "2.42rem",
+        "3xl": "4.84rem"
+      },
+      borderRadius: {
+        sm: "1.3rem",
+        md: "1.3rem",
+        lg: "1.3rem",
+        DEFAULT: "1.3rem"
+      },
+      fontSize: {
+        "preset-0": ["3.013rem", "4.513rem"],
+        "preset-1": ["2.505rem", "3.763rem"],
+        "preset-2": ["2.093rem", "3.146rem"],
+        "preset-3": ["1.742rem", "2.626rem"],
+        "preset-4": ["1.452rem", "2.190rem"],
+        "preset-5": ["1.21rem", "1.815rem"],
+        "preset-6": ["1.004rem", "1.513rem"],
+        "preset-7": ["0.835rem", "1.258rem"],
+        "preset-8": ["0.702rem", "1.053rem"]
+      },
+      zIndex: {
+        1: "1",
+        2: "2",
+        3: "3",
+        4: "4",
+        5: "5",
+        6: "6",
+        7: "7",
+        8: "8",
+        9: "9",
+        10: "10",
+        1001: "1001",
+        1002: "1002"
+      }
+    }
+  }
+};
+export {
+  index as copaApi,
+  getConfig as copaGetConfig,
+  setConfig as copaSetConfig,
+  bluecopaTailwindConfig as copaTailwindConfig,
+  index$4 as copaUtils
+};
+//# sourceMappingURL=index.es.js.map