@lodashventure/medusa-membership 0.0.6

package/.medusa/server/src/admin/index.mjs

@@ -0,0 +1,2038 @@
+import { jsxs, jsx, Fragment } from "react/jsx-runtime";
+import { defineWidgetConfig, defineRouteConfig } from "@medusajs/admin-sdk";
+import { toast, Container, Heading, Switch, Label, Text, Input, Button, createDataTableColumnHelper, usePrompt, useDataTable, DataTable, Drawer, Textarea } from "@medusajs/ui";
+import { useQuery, useQueryClient, useMutation } from "@tanstack/react-query";
+import Medusa from "@medusajs/js-sdk";
+import { Users } from "@medusajs/icons";
+import { useState, useEffect } from "react";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var axios$3 = { exports: {} };
+var bind$2 = function bind(fn, thisArg) {
+  return function wrap() {
+    var args = new Array(arguments.length);
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i];
+    }
+    return fn.apply(thisArg, args);
+  };
+};
+var bind$1 = bind$2;
+var toString = Object.prototype.toString;
+function isArray(val) {
+  return toString.call(val) === "[object Array]";
+}
+function isUndefined(val) {
+  return typeof val === "undefined";
+}
+function isBuffer(val) {
+  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
+}
+function isArrayBuffer(val) {
+  return toString.call(val) === "[object ArrayBuffer]";
+}
+function isFormData(val) {
+  return typeof FormData !== "undefined" && val instanceof FormData;
+}
+function isArrayBufferView(val) {
+  var result;
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+    result = ArrayBuffer.isView(val);
+  } else {
+    result = val && val.buffer && val.buffer instanceof ArrayBuffer;
+  }
+  return result;
+}
+function isString(val) {
+  return typeof val === "string";
+}
+function isNumber(val) {
+  return typeof val === "number";
+}
+function isObject(val) {
+  return val !== null && typeof val === "object";
+}
+function isPlainObject(val) {
+  if (toString.call(val) !== "[object Object]") {
+    return false;
+  }
+  var prototype = Object.getPrototypeOf(val);
+  return prototype === null || prototype === Object.prototype;
+}
+function isDate(val) {
+  return toString.call(val) === "[object Date]";
+}
+function isFile(val) {
+  return toString.call(val) === "[object File]";
+}
+function isBlob(val) {
+  return toString.call(val) === "[object Blob]";
+}
+function isFunction(val) {
+  return toString.call(val) === "[object Function]";
+}
+function isStream(val) {
+  return isObject(val) && isFunction(val.pipe);
+}
+function isURLSearchParams(val) {
+  return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
+}
+function trim(str) {
+  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
+}
+function isStandardBrowserEnv() {
+  if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
+    return false;
+  }
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function forEach(obj, fn) {
+  if (obj === null || typeof obj === "undefined") {
+    return;
+  }
+  if (typeof obj !== "object") {
+    obj = [obj];
+  }
+  if (isArray(obj)) {
+    for (var i = 0, l = obj.length; i < l; i++) {
+      fn.call(null, obj[i], i, obj);
+    }
+  } else {
+    for (var key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        fn.call(null, obj[key], key, obj);
+      }
+    }
+  }
+}
+function merge() {
+  var result = {};
+  function assignValue(val, key) {
+    if (isPlainObject(result[key]) && isPlainObject(val)) {
+      result[key] = merge(result[key], val);
+    } else if (isPlainObject(val)) {
+      result[key] = merge({}, val);
+    } else if (isArray(val)) {
+      result[key] = val.slice();
+    } else {
+      result[key] = val;
+    }
+  }
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    forEach(arguments[i], assignValue);
+  }
+  return result;
+}
+function extend(a, b, thisArg) {
+  forEach(b, function assignValue(val, key) {
+    if (thisArg && typeof val === "function") {
+      a[key] = bind$1(val, thisArg);
+    } else {
+      a[key] = val;
+    }
+  });
+  return a;
+}
+function stripBOM(content) {
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  return content;
+}
+var utils$9 = {
+  isArray,
+  isArrayBuffer,
+  isBuffer,
+  isFormData,
+  isArrayBufferView,
+  isString,
+  isNumber,
+  isObject,
+  isPlainObject,
+  isUndefined,
+  isDate,
+  isFile,
+  isBlob,
+  isFunction,
+  isStream,
+  isURLSearchParams,
+  isStandardBrowserEnv,
+  forEach,
+  merge,
+  extend,
+  trim,
+  stripBOM
+};
+var utils$8 = utils$9;
+function encode(val) {
+  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+}
+var buildURL$1 = function buildURL(url, params, paramsSerializer) {
+  if (!params) {
+    return url;
+  }
+  var serializedParams;
+  if (paramsSerializer) {
+    serializedParams = paramsSerializer(params);
+  } else if (utils$8.isURLSearchParams(params)) {
+    serializedParams = params.toString();
+  } else {
+    var parts = [];
+    utils$8.forEach(params, function serialize(val, key) {
+      if (val === null || typeof val === "undefined") {
+        return;
+      }
+      if (utils$8.isArray(val)) {
+        key = key + "[]";
+      } else {
+        val = [val];
+      }
+      utils$8.forEach(val, function parseValue(v) {
+        if (utils$8.isDate(v)) {
+          v = v.toISOString();
+        } else if (utils$8.isObject(v)) {
+          v = JSON.stringify(v);
+        }
+        parts.push(encode(key) + "=" + encode(v));
+      });
+    });
+    serializedParams = parts.join("&");
+  }
+  if (serializedParams) {
+    var hashmarkIndex = url.indexOf("#");
+    if (hashmarkIndex !== -1) {
+      url = url.slice(0, hashmarkIndex);
+    }
+    url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
+  }
+  return url;
+};
+var utils$7 = utils$9;
+function InterceptorManager$1() {
+  this.handlers = [];
+}
+InterceptorManager$1.prototype.use = function use(fulfilled, rejected, options) {
+  this.handlers.push({
+    fulfilled,
+    rejected,
+    synchronous: options ? options.synchronous : false,
+    runWhen: options ? options.runWhen : null
+  });
+  return this.handlers.length - 1;
+};
+InterceptorManager$1.prototype.eject = function eject(id) {
+  if (this.handlers[id]) {
+    this.handlers[id] = null;
+  }
+};
+InterceptorManager$1.prototype.forEach = function forEach2(fn) {
+  utils$7.forEach(this.handlers, function forEachHandler(h) {
+    if (h !== null) {
+      fn(h);
+    }
+  });
+};
+var InterceptorManager_1 = InterceptorManager$1;
+var utils$6 = utils$9;
+var normalizeHeaderName$1 = function normalizeHeaderName(headers, normalizedName) {
+  utils$6.forEach(headers, function processHeader(value, name) {
+    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
+      headers[normalizedName] = value;
+      delete headers[name];
+    }
+  });
+};
+var enhanceError$1 = function enhanceError(error, config2, code, request2, response) {
+  error.config = config2;
+  if (code) {
+    error.code = code;
+  }
+  error.request = request2;
+  error.response = response;
+  error.isAxiosError = true;
+  error.toJSON = function toJSON() {
+    return {
+      // Standard
+      message: this.message,
+      name: this.name,
+      // Microsoft
+      description: this.description,
+      number: this.number,
+      // Mozilla
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      // Axios
+      config: this.config,
+      code: this.code
+    };
+  };
+  return error;
+};
+var createError;
+var hasRequiredCreateError;
+function requireCreateError() {
+  if (hasRequiredCreateError) return createError;
+  hasRequiredCreateError = 1;
+  var enhanceError3 = enhanceError$1;
+  createError = function createError2(message, config2, code, request2, response) {
+    var error = new Error(message);
+    return enhanceError3(error, config2, code, request2, response);
+  };
+  return createError;
+}
+var settle;
+var hasRequiredSettle;
+function requireSettle() {
+  if (hasRequiredSettle) return settle;
+  hasRequiredSettle = 1;
+  var createError2 = requireCreateError();
+  settle = function settle2(resolve, reject, response) {
+    var validateStatus2 = response.config.validateStatus;
+    if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
+      resolve(response);
+    } else {
+      reject(createError2(
+        "Request failed with status code " + response.status,
+        response.config,
+        null,
+        response.request,
+        response
+      ));
+    }
+  };
+  return settle;
+}
+var cookies;
+var hasRequiredCookies;
+function requireCookies() {
+  if (hasRequiredCookies) return cookies;
+  hasRequiredCookies = 1;
+  var utils2 = utils$9;
+  cookies = utils2.isStandardBrowserEnv() ? (
+    // Standard browser envs support document.cookie
+    /* @__PURE__ */ function standardBrowserEnv() {
+      return {
+        write: function write(name, value, expires, path, domain, secure) {
+          var cookie = [];
+          cookie.push(name + "=" + encodeURIComponent(value));
+          if (utils2.isNumber(expires)) {
+            cookie.push("expires=" + new Date(expires).toGMTString());
+          }
+          if (utils2.isString(path)) {
+            cookie.push("path=" + path);
+          }
+          if (utils2.isString(domain)) {
+            cookie.push("domain=" + domain);
+          }
+          if (secure === true) {
+            cookie.push("secure");
+          }
+          document.cookie = cookie.join("; ");
+        },
+        read: function read(name) {
+          var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
+          return match ? decodeURIComponent(match[3]) : null;
+        },
+        remove: function remove(name) {
+          this.write(name, "", Date.now() - 864e5);
+        }
+      };
+    }()
+  ) : (
+    // Non standard browser env (web workers, react-native) lack needed support.
+    /* @__PURE__ */ function nonStandardBrowserEnv() {
+      return {
+        write: function write() {
+        },
+        read: function read() {
+          return null;
+        },
+        remove: function remove() {
+        }
+      };
+    }()
+  );
+  return cookies;
+}
+var isAbsoluteURL;
+var hasRequiredIsAbsoluteURL;
+function requireIsAbsoluteURL() {
+  if (hasRequiredIsAbsoluteURL) return isAbsoluteURL;
+  hasRequiredIsAbsoluteURL = 1;
+  isAbsoluteURL = function isAbsoluteURL2(url) {
+    return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+  };
+  return isAbsoluteURL;
+}
+var combineURLs;
+var hasRequiredCombineURLs;
+function requireCombineURLs() {
+  if (hasRequiredCombineURLs) return combineURLs;
+  hasRequiredCombineURLs = 1;
+  combineURLs = function combineURLs2(baseURL, relativeURL) {
+    return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+  };
+  return combineURLs;
+}
+var buildFullPath;
+var hasRequiredBuildFullPath;
+function requireBuildFullPath() {
+  if (hasRequiredBuildFullPath) return buildFullPath;
+  hasRequiredBuildFullPath = 1;
+  var isAbsoluteURL2 = requireIsAbsoluteURL();
+  var combineURLs2 = requireCombineURLs();
+  buildFullPath = function buildFullPath2(baseURL, requestedURL) {
+    if (baseURL && !isAbsoluteURL2(requestedURL)) {
+      return combineURLs2(baseURL, requestedURL);
+    }
+    return requestedURL;
+  };
+  return buildFullPath;
+}
+var parseHeaders;
+var hasRequiredParseHeaders;
+function requireParseHeaders() {
+  if (hasRequiredParseHeaders) return parseHeaders;
+  hasRequiredParseHeaders = 1;
+  var utils2 = utils$9;
+  var ignoreDuplicateOf = [
+    "age",
+    "authorization",
+    "content-length",
+    "content-type",
+    "etag",
+    "expires",
+    "from",
+    "host",
+    "if-modified-since",
+    "if-unmodified-since",
+    "last-modified",
+    "location",
+    "max-forwards",
+    "proxy-authorization",
+    "referer",
+    "retry-after",
+    "user-agent"
+  ];
+  parseHeaders = function parseHeaders2(headers) {
+    var parsed = {};
+    var key;
+    var val;
+    var i;
+    if (!headers) {
+      return parsed;
+    }
+    utils2.forEach(headers.split("\n"), function parser(line) {
+      i = line.indexOf(":");
+      key = utils2.trim(line.substr(0, i)).toLowerCase();
+      val = utils2.trim(line.substr(i + 1));
+      if (key) {
+        if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
+          return;
+        }
+        if (key === "set-cookie") {
+          parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
+        } else {
+          parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
+        }
+      }
+    });
+    return parsed;
+  };
+  return parseHeaders;
+}
+var isURLSameOrigin;
+var hasRequiredIsURLSameOrigin;
+function requireIsURLSameOrigin() {
+  if (hasRequiredIsURLSameOrigin) return isURLSameOrigin;
+  hasRequiredIsURLSameOrigin = 1;
+  var utils2 = utils$9;
+  isURLSameOrigin = utils2.isStandardBrowserEnv() ? (
+    // Standard browser envs have full support of the APIs needed to test
+    // whether the request URL is of the same origin as current location.
+    function standardBrowserEnv() {
+      var msie = /(msie|trident)/i.test(navigator.userAgent);
+      var urlParsingNode = document.createElement("a");
+      var originURL;
+      function resolveURL(url) {
+        var href = url;
+        if (msie) {
+          urlParsingNode.setAttribute("href", href);
+          href = urlParsingNode.href;
+        }
+        urlParsingNode.setAttribute("href", href);
+        return {
+          href: urlParsingNode.href,
+          protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "",
+          host: urlParsingNode.host,
+          search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "",
+          hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
+          hostname: urlParsingNode.hostname,
+          port: urlParsingNode.port,
+          pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname
+        };
+      }
+      originURL = resolveURL(window.location.href);
+      return function isURLSameOrigin2(requestURL) {
+        var parsed = utils2.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+        return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+      };
+    }()
+  ) : (
+    // Non standard browser envs (web workers, react-native) lack needed support.
+    /* @__PURE__ */ function nonStandardBrowserEnv() {
+      return function isURLSameOrigin2() {
+        return true;
+      };
+    }()
+  );
+  return isURLSameOrigin;
+}
+var xhr;
+var hasRequiredXhr;
+function requireXhr() {
+  if (hasRequiredXhr) return xhr;
+  hasRequiredXhr = 1;
+  var utils2 = utils$9;
+  var settle2 = requireSettle();
+  var cookies2 = requireCookies();
+  var buildURL3 = buildURL$1;
+  var buildFullPath2 = requireBuildFullPath();
+  var parseHeaders2 = requireParseHeaders();
+  var isURLSameOrigin2 = requireIsURLSameOrigin();
+  var createError2 = requireCreateError();
+  xhr = function xhrAdapter(config2) {
+    return new Promise(function dispatchXhrRequest(resolve, reject) {
+      var requestData = config2.data;
+      var requestHeaders = config2.headers;
+      var responseType = config2.responseType;
+      if (utils2.isFormData(requestData)) {
+        delete requestHeaders["Content-Type"];
+      }
+      var request2 = new XMLHttpRequest();
+      if (config2.auth) {
+        var username = config2.auth.username || "";
+        var password = config2.auth.password ? unescape(encodeURIComponent(config2.auth.password)) : "";
+        requestHeaders.Authorization = "Basic " + btoa(username + ":" + password);
+      }
+      var fullPath = buildFullPath2(config2.baseURL, config2.url);
+      request2.open(config2.method.toUpperCase(), buildURL3(fullPath, config2.params, config2.paramsSerializer), true);
+      request2.timeout = config2.timeout;
+      function onloadend() {
+        if (!request2) {
+          return;
+        }
+        var responseHeaders = "getAllResponseHeaders" in request2 ? parseHeaders2(request2.getAllResponseHeaders()) : null;
+        var responseData = !responseType || responseType === "text" || responseType === "json" ? request2.responseText : request2.response;
+        var response = {
+          data: responseData,
+          status: request2.status,
+          statusText: request2.statusText,
+          headers: responseHeaders,
+          config: config2,
+          request: request2
+        };
+        settle2(resolve, reject, response);
+        request2 = null;
+      }
+      if ("onloadend" in request2) {
+        request2.onloadend = onloadend;
+      } else {
+        request2.onreadystatechange = function handleLoad() {
+          if (!request2 || request2.readyState !== 4) {
+            return;
+          }
+          if (request2.status === 0 && !(request2.responseURL && request2.responseURL.indexOf("file:") === 0)) {
+            return;
+          }
+          setTimeout(onloadend);
+        };
+      }
+      request2.onabort = function handleAbort() {
+        if (!request2) {
+          return;
+        }
+        reject(createError2("Request aborted", config2, "ECONNABORTED", request2));
+        request2 = null;
+      };
+      request2.onerror = function handleError() {
+        reject(createError2("Network Error", config2, null, request2));
+        request2 = null;
+      };
+      request2.ontimeout = function handleTimeout() {
+        var timeoutErrorMessage = "timeout of " + config2.timeout + "ms exceeded";
+        if (config2.timeoutErrorMessage) {
+          timeoutErrorMessage = config2.timeoutErrorMessage;
+        }
+        reject(createError2(
+          timeoutErrorMessage,
+          config2,
+          config2.transitional && config2.transitional.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED",
+          request2
+        ));
+        request2 = null;
+      };
+      if (utils2.isStandardBrowserEnv()) {
+        var xsrfValue = (config2.withCredentials || isURLSameOrigin2(fullPath)) && config2.xsrfCookieName ? cookies2.read(config2.xsrfCookieName) : void 0;
+        if (xsrfValue) {
+          requestHeaders[config2.xsrfHeaderName] = xsrfValue;
+        }
+      }
+      if ("setRequestHeader" in request2) {
+        utils2.forEach(requestHeaders, function setRequestHeader(val, key) {
+          if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
+            delete requestHeaders[key];
+          } else {
+            request2.setRequestHeader(key, val);
+          }
+        });
+      }
+      if (!utils2.isUndefined(config2.withCredentials)) {
+        request2.withCredentials = !!config2.withCredentials;
+      }
+      if (responseType && responseType !== "json") {
+        request2.responseType = config2.responseType;
+      }
+      if (typeof config2.onDownloadProgress === "function") {
+        request2.addEventListener("progress", config2.onDownloadProgress);
+      }
+      if (typeof config2.onUploadProgress === "function" && request2.upload) {
+        request2.upload.addEventListener("progress", config2.onUploadProgress);
+      }
+      if (config2.cancelToken) {
+        config2.cancelToken.promise.then(function onCanceled(cancel) {
+          if (!request2) {
+            return;
+          }
+          request2.abort();
+          reject(cancel);
+          request2 = null;
+        });
+      }
+      if (!requestData) {
+        requestData = null;
+      }
+      request2.send(requestData);
+    });
+  };
+  return xhr;
+}
+var utils$5 = utils$9;
+var normalizeHeaderName2 = normalizeHeaderName$1;
+var enhanceError2 = enhanceError$1;
+var DEFAULT_CONTENT_TYPE = {
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+function setContentTypeIfUnset(headers, value) {
+  if (!utils$5.isUndefined(headers) && utils$5.isUndefined(headers["Content-Type"])) {
+    headers["Content-Type"] = value;
+  }
+}
+function getDefaultAdapter() {
+  var adapter;
+  if (typeof XMLHttpRequest !== "undefined") {
+    adapter = requireXhr();
+  } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
+    adapter = requireXhr();
+  }
+  return adapter;
+}
+function stringifySafely(rawValue, parser, encoder) {
+  if (utils$5.isString(rawValue)) {
+    try {
+      (parser || JSON.parse)(rawValue);
+      return utils$5.trim(rawValue);
+    } catch (e) {
+      if (e.name !== "SyntaxError") {
+        throw e;
+      }
+    }
+  }
+  return (encoder || JSON.stringify)(rawValue);
+}
+var defaults$3 = {
+  transitional: {
+    silentJSONParsing: true,
+    forcedJSONParsing: true,
+    clarifyTimeoutError: false
+  },
+  adapter: getDefaultAdapter(),
+  transformRequest: [function transformRequest(data, headers) {
+    normalizeHeaderName2(headers, "Accept");
+    normalizeHeaderName2(headers, "Content-Type");
+    if (utils$5.isFormData(data) || utils$5.isArrayBuffer(data) || utils$5.isBuffer(data) || utils$5.isStream(data) || utils$5.isFile(data) || utils$5.isBlob(data)) {
+      return data;
+    }
+    if (utils$5.isArrayBufferView(data)) {
+      return data.buffer;
+    }
+    if (utils$5.isURLSearchParams(data)) {
+      setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
+      return data.toString();
+    }
+    if (utils$5.isObject(data) || headers && headers["Content-Type"] === "application/json") {
+      setContentTypeIfUnset(headers, "application/json");
+      return stringifySafely(data);
+    }
+    return data;
+  }],
+  transformResponse: [function transformResponse(data) {
+    var transitional2 = this.transitional;
+    var silentJSONParsing = transitional2 && transitional2.silentJSONParsing;
+    var forcedJSONParsing = transitional2 && transitional2.forcedJSONParsing;
+    var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
+    if (strictJSONParsing || forcedJSONParsing && utils$5.isString(data) && data.length) {
+      try {
+        return JSON.parse(data);
+      } catch (e) {
+        if (strictJSONParsing) {
+          if (e.name === "SyntaxError") {
+            throw enhanceError2(e, this, "E_JSON_PARSE");
+          }
+          throw e;
+        }
+      }
+    }
+    return data;
+  }],
+  /**
+   * A timeout in milliseconds to abort a request. If set to 0 (default) a
+   * timeout is not created.
+   */
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  validateStatus: function validateStatus(status) {
+    return status >= 200 && status < 300;
+  }
+};
+defaults$3.headers = {
+  common: {
+    "Accept": "application/json, text/plain, */*"
+  }
+};
+utils$5.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
+  defaults$3.headers[method] = {};
+});
+utils$5.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+  defaults$3.headers[method] = utils$5.merge(DEFAULT_CONTENT_TYPE);
+});
+var defaults_1 = defaults$3;
+var utils$4 = utils$9;
+var defaults$2 = defaults_1;
+var transformData$1 = function transformData(data, headers, fns) {
+  var context = this || defaults$2;
+  utils$4.forEach(fns, function transform(fn) {
+    data = fn.call(context, data, headers);
+  });
+  return data;
+};
+var isCancel$1;
+var hasRequiredIsCancel;
+function requireIsCancel() {
+  if (hasRequiredIsCancel) return isCancel$1;
+  hasRequiredIsCancel = 1;
+  isCancel$1 = function isCancel2(value) {
+    return !!(value && value.__CANCEL__);
+  };
+  return isCancel$1;
+}
+var utils$3 = utils$9;
+var transformData2 = transformData$1;
+var isCancel = requireIsCancel();
+var defaults$1 = defaults_1;
+function throwIfCancellationRequested(config2) {
+  if (config2.cancelToken) {
+    config2.cancelToken.throwIfRequested();
+  }
+}
+var dispatchRequest$1 = function dispatchRequest(config2) {
+  throwIfCancellationRequested(config2);
+  config2.headers = config2.headers || {};
+  config2.data = transformData2.call(
+    config2,
+    config2.data,
+    config2.headers,
+    config2.transformRequest
+  );
+  config2.headers = utils$3.merge(
+    config2.headers.common || {},
+    config2.headers[config2.method] || {},
+    config2.headers
+  );
+  utils$3.forEach(
+    ["delete", "get", "head", "post", "put", "patch", "common"],
+    function cleanHeaderConfig(method) {
+      delete config2.headers[method];
+    }
+  );
+  var adapter = config2.adapter || defaults$1.adapter;
+  return adapter(config2).then(function onAdapterResolution(response) {
+    throwIfCancellationRequested(config2);
+    response.data = transformData2.call(
+      config2,
+      response.data,
+      response.headers,
+      config2.transformResponse
+    );
+    return response;
+  }, function onAdapterRejection(reason) {
+    if (!isCancel(reason)) {
+      throwIfCancellationRequested(config2);
+      if (reason && reason.response) {
+        reason.response.data = transformData2.call(
+          config2,
+          reason.response.data,
+          reason.response.headers,
+          config2.transformResponse
+        );
+      }
+    }
+    return Promise.reject(reason);
+  });
+};
+var utils$2 = utils$9;
+var mergeConfig$2 = function mergeConfig(config1, config2) {
+  config2 = config2 || {};
+  var config3 = {};
+  var valueFromConfig2Keys = ["url", "method", "data"];
+  var mergeDeepPropertiesKeys = ["headers", "auth", "proxy", "params"];
+  var defaultToConfig2Keys = [
+    "baseURL",
+    "transformRequest",
+    "transformResponse",
+    "paramsSerializer",
+    "timeout",
+    "timeoutMessage",
+    "withCredentials",
+    "adapter",
+    "responseType",
+    "xsrfCookieName",
+    "xsrfHeaderName",
+    "onUploadProgress",
+    "onDownloadProgress",
+    "decompress",
+    "maxContentLength",
+    "maxBodyLength",
+    "maxRedirects",
+    "transport",
+    "httpAgent",
+    "httpsAgent",
+    "cancelToken",
+    "socketPath",
+    "responseEncoding"
+  ];
+  var directMergeKeys = ["validateStatus"];
+  function getMergedValue(target, source) {
+    if (utils$2.isPlainObject(target) && utils$2.isPlainObject(source)) {
+      return utils$2.merge(target, source);
+    } else if (utils$2.isPlainObject(source)) {
+      return utils$2.merge({}, source);
+    } else if (utils$2.isArray(source)) {
+      return source.slice();
+    }
+    return source;
+  }
+  function mergeDeepProperties(prop) {
+    if (!utils$2.isUndefined(config2[prop])) {
+      config3[prop] = getMergedValue(config1[prop], config2[prop]);
+    } else if (!utils$2.isUndefined(config1[prop])) {
+      config3[prop] = getMergedValue(void 0, config1[prop]);
+    }
+  }
+  utils$2.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
+    if (!utils$2.isUndefined(config2[prop])) {
+      config3[prop] = getMergedValue(void 0, config2[prop]);
+    }
+  });
+  utils$2.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);
+  utils$2.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
+    if (!utils$2.isUndefined(config2[prop])) {
+      config3[prop] = getMergedValue(void 0, config2[prop]);
+    } else if (!utils$2.isUndefined(config1[prop])) {
+      config3[prop] = getMergedValue(void 0, config1[prop]);
+    }
+  });
+  utils$2.forEach(directMergeKeys, function merge2(prop) {
+    if (prop in config2) {
+      config3[prop] = getMergedValue(config1[prop], config2[prop]);
+    } else if (prop in config1) {
+      config3[prop] = getMergedValue(void 0, config1[prop]);
+    }
+  });
+  var axiosKeys = valueFromConfig2Keys.concat(mergeDeepPropertiesKeys).concat(defaultToConfig2Keys).concat(directMergeKeys);
+  var otherKeys = Object.keys(config1).concat(Object.keys(config2)).filter(function filterAxiosKeys(key) {
+    return axiosKeys.indexOf(key) === -1;
+  });
+  utils$2.forEach(otherKeys, mergeDeepProperties);
+  return config3;
+};
+const version = "0.21.4";
+const require$$0 = {
+  version
+};
+var pkg = require$$0;
+var validators$1 = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
+  validators$1[type] = function validator2(thing) {
+    return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+  };
+});
+var deprecatedWarnings = {};
+var currentVerArr = pkg.version.split(".");
+function isOlderVersion(version2, thanVersion) {
+  var pkgVersionArr = thanVersion ? thanVersion.split(".") : currentVerArr;
+  var destVer = version2.split(".");
+  for (var i = 0; i < 3; i++) {
+    if (pkgVersionArr[i] > destVer[i]) {
+      return true;
+    } else if (pkgVersionArr[i] < destVer[i]) {
+      return false;
+    }
+  }
+  return false;
+}
+validators$1.transitional = function transitional(validator2, version2, message) {
+  var isDeprecated = version2 && isOlderVersion(version2);
+  function formatMessage(opt, desc) {
+    return "[Axios v" + pkg.version + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+  }
+  return function(value, opt, opts) {
+    if (validator2 === false) {
+      throw new Error(formatMessage(opt, " has been removed in " + version2));
+    }
+    if (isDeprecated && !deprecatedWarnings[opt]) {
+      deprecatedWarnings[opt] = true;
+      console.warn(
+        formatMessage(
+          opt,
+          " has been deprecated since v" + version2 + " and will be removed in the near future"
+        )
+      );
+    }
+    return validator2 ? validator2(value, opt, opts) : true;
+  };
+};
+function assertOptions(options, schema, allowUnknown) {
+  if (typeof options !== "object") {
+    throw new TypeError("options must be an object");
+  }
+  var keys = Object.keys(options);
+  var i = keys.length;
+  while (i-- > 0) {
+    var opt = keys[i];
+    var validator2 = schema[opt];
+    if (validator2) {
+      var value = options[opt];
+      var result = value === void 0 || validator2(value, opt, options);
+      if (result !== true) {
+        throw new TypeError("option " + opt + " must be " + result);
+      }
+      continue;
+    }
+    if (allowUnknown !== true) {
+      throw Error("Unknown option " + opt);
+    }
+  }
+}
+var validator$1 = {
+  isOlderVersion,
+  assertOptions,
+  validators: validators$1
+};
+var utils$1 = utils$9;
+var buildURL2 = buildURL$1;
+var InterceptorManager = InterceptorManager_1;
+var dispatchRequest2 = dispatchRequest$1;
+var mergeConfig$1 = mergeConfig$2;
+var validator = validator$1;
+var validators = validator.validators;
+function Axios$1(instanceConfig) {
+  this.defaults = instanceConfig;
+  this.interceptors = {
+    request: new InterceptorManager(),
+    response: new InterceptorManager()
+  };
+}
+Axios$1.prototype.request = function request(config2) {
+  if (typeof config2 === "string") {
+    config2 = arguments[1] || {};
+    config2.url = arguments[0];
+  } else {
+    config2 = config2 || {};
+  }
+  config2 = mergeConfig$1(this.defaults, config2);
+  if (config2.method) {
+    config2.method = config2.method.toLowerCase();
+  } else if (this.defaults.method) {
+    config2.method = this.defaults.method.toLowerCase();
+  } else {
+    config2.method = "get";
+  }
+  var transitional2 = config2.transitional;
+  if (transitional2 !== void 0) {
+    validator.assertOptions(transitional2, {
+      silentJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
+      forcedJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
+      clarifyTimeoutError: validators.transitional(validators.boolean, "1.0.0")
+    }, false);
+  }
+  var requestInterceptorChain = [];
+  var synchronousRequestInterceptors = true;
+  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+    if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config2) === false) {
+      return;
+    }
+    synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+    requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+  });
+  var responseInterceptorChain = [];
+  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+    responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+  });
+  var promise;
+  if (!synchronousRequestInterceptors) {
+    var chain = [dispatchRequest2, void 0];
+    Array.prototype.unshift.apply(chain, requestInterceptorChain);
+    chain = chain.concat(responseInterceptorChain);
+    promise = Promise.resolve(config2);
+    while (chain.length) {
+      promise = promise.then(chain.shift(), chain.shift());
+    }
+    return promise;
+  }
+  var newConfig = config2;
+  while (requestInterceptorChain.length) {
+    var onFulfilled = requestInterceptorChain.shift();
+    var onRejected = requestInterceptorChain.shift();
+    try {
+      newConfig = onFulfilled(newConfig);
+    } catch (error) {
+      onRejected(error);
+      break;
+    }
+  }
+  try {
+    promise = dispatchRequest2(newConfig);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  while (responseInterceptorChain.length) {
+    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
+  }
+  return promise;
+};
+Axios$1.prototype.getUri = function getUri(config2) {
+  config2 = mergeConfig$1(this.defaults, config2);
+  return buildURL2(config2.url, config2.params, config2.paramsSerializer).replace(/^\?/, "");
+};
+utils$1.forEach(["delete", "get", "head", "options"], function forEachMethodNoData2(method) {
+  Axios$1.prototype[method] = function(url, config2) {
+    return this.request(mergeConfig$1(config2 || {}, {
+      method,
+      url,
+      data: (config2 || {}).data
+    }));
+  };
+});
+utils$1.forEach(["post", "put", "patch"], function forEachMethodWithData2(method) {
+  Axios$1.prototype[method] = function(url, data, config2) {
+    return this.request(mergeConfig$1(config2 || {}, {
+      method,
+      url,
+      data
+    }));
+  };
+});
+var Axios_1 = Axios$1;
+var Cancel_1;
+var hasRequiredCancel;
+function requireCancel() {
+  if (hasRequiredCancel) return Cancel_1;
+  hasRequiredCancel = 1;
+  function Cancel(message) {
+    this.message = message;
+  }
+  Cancel.prototype.toString = function toString2() {
+    return "Cancel" + (this.message ? ": " + this.message : "");
+  };
+  Cancel.prototype.__CANCEL__ = true;
+  Cancel_1 = Cancel;
+  return Cancel_1;
+}
+var CancelToken_1;
+var hasRequiredCancelToken;
+function requireCancelToken() {
+  if (hasRequiredCancelToken) return CancelToken_1;
+  hasRequiredCancelToken = 1;
+  var Cancel = requireCancel();
+  function CancelToken(executor) {
+    if (typeof executor !== "function") {
+      throw new TypeError("executor must be a function.");
+    }
+    var resolvePromise;
+    this.promise = new Promise(function promiseExecutor(resolve) {
+      resolvePromise = resolve;
+    });
+    var token = this;
+    executor(function cancel(message) {
+      if (token.reason) {
+        return;
+      }
+      token.reason = new Cancel(message);
+      resolvePromise(token.reason);
+    });
+  }
+  CancelToken.prototype.throwIfRequested = function throwIfRequested() {
+    if (this.reason) {
+      throw this.reason;
+    }
+  };
+  CancelToken.source = function source() {
+    var cancel;
+    var token = new CancelToken(function executor(c) {
+      cancel = c;
+    });
+    return {
+      token,
+      cancel
+    };
+  };
+  CancelToken_1 = CancelToken;
+  return CancelToken_1;
+}
+var spread;
+var hasRequiredSpread;
+function requireSpread() {
+  if (hasRequiredSpread) return spread;
+  hasRequiredSpread = 1;
+  spread = function spread2(callback) {
+    return function wrap(arr) {
+      return callback.apply(null, arr);
+    };
+  };
+  return spread;
+}
+var isAxiosError;
+var hasRequiredIsAxiosError;
+function requireIsAxiosError() {
+  if (hasRequiredIsAxiosError) return isAxiosError;
+  hasRequiredIsAxiosError = 1;
+  isAxiosError = function isAxiosError2(payload) {
+    return typeof payload === "object" && payload.isAxiosError === true;
+  };
+  return isAxiosError;
+}
+var utils = utils$9;
+var bind2 = bind$2;
+var Axios = Axios_1;
+var mergeConfig2 = mergeConfig$2;
+var defaults = defaults_1;
+function createInstance(defaultConfig) {
+  var context = new Axios(defaultConfig);
+  var instance = bind2(Axios.prototype.request, context);
+  utils.extend(instance, Axios.prototype, context);
+  utils.extend(instance, context);
+  return instance;
+}
+var axios$2 = createInstance(defaults);
+axios$2.Axios = Axios;
+axios$2.create = function create(instanceConfig) {
+  return createInstance(mergeConfig2(axios$2.defaults, instanceConfig));
+};
+axios$2.Cancel = requireCancel();
+axios$2.CancelToken = requireCancelToken();
+axios$2.isCancel = requireIsCancel();
+axios$2.all = function all(promises) {
+  return Promise.all(promises);
+};
+axios$2.spread = requireSpread();
+axios$2.isAxiosError = requireIsAxiosError();
+axios$3.exports = axios$2;
+axios$3.exports.default = axios$2;
+var axiosExports = axios$3.exports;
+var axios = axiosExports;
+const axios$1 = /* @__PURE__ */ getDefaultExportFromCjs(axios);
+const useMembershipConfig = (storeId, options) => {
+  return useQuery({
+    ...options,
+    queryKey: ["membership-config", storeId],
+    queryFn: async () => {
+      if (!storeId) {
+        throw new Error("No store id found");
+      }
+      const { data: config2 } = await axios$1.get(
+        `/admin/membership/config/${storeId}`
+      );
+      return config2;
+    }
+  });
+};
+const sdk = new Medusa({
+  baseUrl: "/",
+  debug: false,
+  auth: {
+    type: "session"
+  }
+});
+const useStore = () => {
+  return useQuery({
+    queryFn: async () => {
+      var _a;
+      const response = await sdk.admin.store.list();
+      const activeStore = (_a = response.stores) == null ? void 0 : _a[0];
+      if (!activeStore) {
+        throw new Error("No active store found");
+      }
+      return activeStore;
+    },
+    queryKey: ["store"]
+  });
+};
+const usePromotionCollectable = (id) => {
+  return useQuery({
+    queryKey: ["promotion-collectable", id],
+    queryFn: () => axios$1.get(`/admin/promotions/${id}/update-collectable`)
+  });
+};
+const useUpdatePromotionCollectable = (id) => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data) => axios$1.patch(`/admin/promotions/${id}/update-collectable`, data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["promotion-collectable", id]
+      });
+      toast.success("Coupon collection updated successfully", {
+        dismissable: true,
+        duration: 2500
+      });
+    },
+    onError: () => {
+      toast.error("Failed to update coupon collection", {
+        dismissable: true,
+        duration: 2500
+      });
+    }
+  });
+};
+const PromotionWidget = ({ data }) => {
+  const { id } = data;
+  const { data: collectable } = usePromotionCollectable(id);
+  const { data: store } = useStore();
+  const { data: config2 } = useMembershipConfig(store == null ? void 0 : store.id);
+  const { mutate: updateCollectable } = useUpdatePromotionCollectable(id);
+  const handleToggleCollectable = async (checked) => {
+    try {
+      updateCollectable({
+        enabled: checked
+      });
+      toast.success("Coupon collection updated successfully", {
+        dismissable: true,
+        duration: 2500
+      });
+    } catch (error) {
+      toast.error("Failed to update coupon collection", {
+        dismissable: true,
+        duration: 2500
+      });
+    }
+  };
+  if (!(config2 == null ? void 0 : config2.enable_promotion_collection)) {
+    return null;
+  }
+  if (data.is_automatic) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(Container, { className: "divide-y p-6 gap-4", children: [
+    /* @__PURE__ */ jsx("div", { className: "flex items-center justify-between", children: /* @__PURE__ */ jsx(Heading, { level: "h2", children: "Coupon Collection" }) }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 py-2", children: [
+      /* @__PURE__ */ jsx(
+        Switch,
+        {
+          checked: collectable == null ? void 0 : collectable.data.enabled,
+          onCheckedChange: handleToggleCollectable
+        }
+      ),
+      /* @__PURE__ */ jsx(Label, { children: "Can be collected by customer" })
+    ] })
+  ] });
+};
+defineWidgetConfig({
+  zone: "promotion.details.side.after"
+});
+const useUpdateMembershipConfig = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ storeId, config: config2 }) => {
+      if (!storeId) {
+        throw new Error("No store id found");
+      }
+      const response = await axios$1.patch(
+        `/admin/membership/config/${storeId}`,
+        config2
+      );
+      return response.data;
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({
+        queryKey: ["membership-config", data.membershipConfig.store_id]
+      });
+    }
+  });
+};
+const MembershipPage = () => {
+  const { data: store } = useStore();
+  const [config2, setConfig] = useState({
+    enable_membership: false,
+    membership_points_multiplier: 1,
+    enable_membership_notification: false,
+    enable_wishlist: true,
+    enable_promotion_collection: true
+  });
+  const { data: curConfig, error, refetch } = useMembershipConfig(store == null ? void 0 : store.id);
+  const { mutate: saveConfig, isPending } = useUpdateMembershipConfig();
+  const [spendingAmount, setSpendingAmount] = useState(
+    1 / config2.membership_points_multiplier
+  );
+  useEffect(() => {
+    if (curConfig) {
+      setConfig(curConfig);
+      setSpendingAmount(1 / curConfig.membership_points_multiplier);
+    }
+  }, [curConfig]);
+  const handleSave = async () => {
+    var _a, _b;
+    try {
+      await saveConfig({
+        storeId: store == null ? void 0 : store.id,
+        config: config2
+      });
+      toast.success("Settings saved successfully", {
+        dismissable: true,
+        duration: 2500
+      });
+      await refetch();
+    } catch (error2) {
+      if (axios$1.isAxiosError(error2)) {
+        toast.error("Error saving settings", {
+          description: (_b = (_a = error2.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message,
+          dismissable: true,
+          duration: 2500
+        });
+      } else {
+        toast.error("Error saving settings", {
+          dismissable: true,
+          duration: 2500
+        });
+      }
+    }
+  };
+  if (error || !config2) {
+    return /* @__PURE__ */ jsxs("div", { children: [
+      "Error: ",
+      error == null ? void 0 : error.message
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Container, { className: "p-8 rounded-lg", children: [
+    /* @__PURE__ */ jsx("h1", { className: "text-xl font-semibold mb-4", children: "Membership Settings" }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-4", children: [
+      /* @__PURE__ */ jsx(
+        Switch,
+        {
+          checked: config2.enable_membership,
+          onCheckedChange: (checked) => setConfig((prev) => ({ ...prev, enable_membership: checked }))
+        }
+      ),
+      "Enable Membership points"
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-4 mt-4", children: [
+      /* @__PURE__ */ jsx(Text, { children: "Spending" }),
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          className: "w-32",
+          type: "number",
+          value: spendingAmount,
+          onChange: (e) => {
+            const value = Number(e.target.value) || 0;
+            const ratio = 1 / value;
+            setConfig((prev) => ({
+              ...prev,
+              membership_points_multiplier: ratio
+            }));
+            setSpendingAmount(value);
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(Text, { children: "To get 1 point" })
+    ] }),
+    /* @__PURE__ */ jsx("hr", { className: "my-4" }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-4 my-2", children: [
+      /* @__PURE__ */ jsx(
+        Switch,
+        {
+          checked: config2.enable_membership_notification,
+          onCheckedChange: (checked) => setConfig((prev) => ({
+            ...prev,
+            enable_membership_notification: checked
+          }))
+        }
+      ),
+      "Enable Membership Notification"
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-4 my-2", children: [
+      /* @__PURE__ */ jsx(
+        Switch,
+        {
+          checked: config2.enable_wishlist,
+          onCheckedChange: (checked) => setConfig((prev) => ({
+            ...prev,
+            enable_wishlist: checked
+          }))
+        }
+      ),
+      "Enable Membership Wishlist"
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-4 my-2", children: [
+      /* @__PURE__ */ jsx(
+        Switch,
+        {
+          checked: config2.enable_promotion_collection,
+          onCheckedChange: (checked) => setConfig((prev) => ({
+            ...prev,
+            enable_promotion_collection: checked
+          }))
+        }
+      ),
+      "Enable Promotion Collection"
+    ] }),
+    /* @__PURE__ */ jsx(Button, { onClick: handleSave, disabled: isPending, className: "mt-5", children: isPending ? "Saving..." : "Save Settings" })
+  ] });
+};
+const BannerUpload = () => {
+  return /* @__PURE__ */ jsx(MembershipPage, {});
+};
+const config$2 = defineRouteConfig({
+  label: "Membership",
+  icon: Users
+});
+const useCreateMembershipConsent = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (data) => {
+      const response = await axios$1.post("/admin/membership-consents", data);
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["membership-consents"] });
+    }
+  });
+};
+const useDeleteMembershipConsent = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (id) => {
+      await axios$1.delete(`/admin/membership-consents/${id}`);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["membership-consents"] });
+    }
+  });
+};
+const MEMBERSHIP_TIERS_QUERY_KEY$1 = ["membership-consents"];
+const useMembershipConsents = () => {
+  return useQuery({
+    queryKey: [...MEMBERSHIP_TIERS_QUERY_KEY$1],
+    queryFn: async () => {
+      const response = await axios$1.get("/admin/membership-consents");
+      return response.data;
+    }
+  });
+};
+const useUpdateMembershipConsent = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (consentKey) => {
+      const response = await axios$1.patch(
+        `/admin/membership-consents/${consentKey.id}`,
+        {
+          name: consentKey.name,
+          description: consentKey.description
+        }
+      );
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["membership-consents"] });
+    }
+  });
+};
+const columnHelper$1 = createDataTableColumnHelper();
+const columns$1 = [
+  columnHelper$1.accessor("name", {
+    header: "Name"
+  }),
+  columnHelper$1.accessor("description", {
+    header: "Description",
+    maxSize: 250
+  })
+];
+const MembershipConsentsRenderer = () => {
+  const dialog = usePrompt();
+  const [pagination, setPagination] = useState({
+    pageSize: 1e3,
+    pageIndex: 0
+  });
+  const [isDrawerOpen, setIsDrawerOpen] = useState(false);
+  const [editingConsent, setEditingConsent] = useState(null);
+  const [formData, setFormData] = useState({
+    name: "",
+    description: ""
+  });
+  const { data, isLoading, refetch } = useMembershipConsents();
+  const createConsent = useCreateMembershipConsent();
+  const updateConsent = useUpdateMembershipConsent();
+  const deleteConsent = useDeleteMembershipConsent();
+  const table = useDataTable({
+    columns: columns$1,
+    data: (data == null ? void 0 : data.consent_keys) || [],
+    getRowId: (consent) => consent.id,
+    rowCount: (data == null ? void 0 : data.count) || 0,
+    isLoading,
+    pagination: {
+      state: pagination,
+      onPaginationChange: setPagination
+    },
+    onRowClick: (_, row) => {
+      openDrawer(row.original);
+    }
+  });
+  const handleInputChange = (e) => {
+    const { name, value } = e.target;
+    setFormData((prev) => ({
+      ...prev,
+      [name]: name === "min_points" ? Number(value) : value
+    }));
+  };
+  const handleTextAreaChange = (e) => {
+    const { name, value } = e.target;
+    setFormData((prev) => ({
+      ...prev,
+      [name]: value
+    }));
+  };
+  const handleReset = () => {
+    setFormData({
+      name: "",
+      description: ""
+    });
+  };
+  const openDrawer = (consentKey) => {
+    if (consentKey) {
+      setEditingConsent(consentKey);
+      setFormData({
+        name: consentKey.name,
+        description: consentKey.description
+      });
+    } else {
+      setEditingConsent(null);
+      handleReset();
+    }
+    setIsDrawerOpen(true);
+  };
+  const closeDrawer = () => {
+    setIsDrawerOpen(false);
+    setEditingConsent(null);
+    handleReset();
+    refetch();
+  };
+  const handleSubmit = async () => {
+    var _a, _b;
+    try {
+      if (!formData.name) {
+        toast.error("Name is required", { dismissable: true, duration: 2500 });
+        return;
+      }
+      if (editingConsent) {
+        await updateConsent.mutateAsync({ id: editingConsent.id, ...formData });
+        toast.success("Consent updated successfully", {
+          dismissable: true,
+          duration: 2500
+        });
+      } else {
+        await createConsent.mutateAsync(formData);
+        toast.success("Consent created successfully", {
+          dismissable: true,
+          duration: 2500
+        });
+      }
+      closeDrawer();
+    } catch (error) {
+      if (axios$1.isAxiosError(error)) {
+        toast.error("Error saving consent", {
+          description: (_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message,
+          dismissable: true,
+          duration: 2500
+        });
+      } else {
+        toast.error("Error saving consent", {
+          dismissable: true,
+          duration: 2500
+        });
+      }
+    }
+  };
+  const handleDelete = async (id) => {
+    var _a, _b;
+    try {
+      const confirmed = await dialog({
+        title: "Delete Membership Consent",
+        description: `Are you sure you want to delete the \`${editingConsent == null ? void 0 : editingConsent.name}\` consent?`
+      });
+      if (!confirmed) {
+        return;
+      }
+      await deleteConsent.mutateAsync(id);
+      toast.success("Consent deleted successfully", {
+        dismissable: true,
+        duration: 2500
+      });
+      closeDrawer();
+    } catch (error) {
+      if (axios$1.isAxiosError(error)) {
+        toast.error("Error deleting consent", {
+          description: (_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message,
+          dismissable: true,
+          duration: 2500
+        });
+      } else {
+        toast.error("Error deleting consent", {
+          dismissable: true,
+          duration: 2500
+        });
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Container, { className: "flex flex-col p-0 overflow-hidden", children: /* @__PURE__ */ jsxs(DataTable, { instance: table, children: [
+      /* @__PURE__ */ jsxs(DataTable.Toolbar, { className: "flex flex-col items-start justify-between gap-2 md:flex-row md:items-center", children: [
+        /* @__PURE__ */ jsx(Heading, { children: "Membership Consents" }),
+        /* @__PURE__ */ jsx(Button, { onClick: () => openDrawer(), children: "Add Consent" })
+      ] }),
+      /* @__PURE__ */ jsx(DataTable.Table, {})
+    ] }) }),
+    /* @__PURE__ */ jsx(Drawer, { open: isDrawerOpen, onOpenChange: setIsDrawerOpen, children: /* @__PURE__ */ jsxs(Drawer.Content, { children: [
+      /* @__PURE__ */ jsx(Drawer.Header, { children: /* @__PURE__ */ jsx(Drawer.Title, { children: editingConsent ? "Edit Consent" : "Add Consent" }) }),
+      /* @__PURE__ */ jsxs(Drawer.Body, { "aria-description": "Membership Consent Form", children: [
+        /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "space-y-4",
+            "aria-description": "Membership Consent Form",
+            children: [
+              /* @__PURE__ */ jsx(Text, { children: "Name" }),
+              /* @__PURE__ */ jsx(
+                Input,
+                {
+                  name: "name",
+                  value: formData.name,
+                  onChange: handleInputChange
+                }
+              ),
+              /* @__PURE__ */ jsx(Text, { children: "Description" }),
+              /* @__PURE__ */ jsx(
+                Textarea,
+                {
+                  className: "truncate",
+                  name: "description",
+                  value: formData.description,
+                  onChange: handleTextAreaChange
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "flex justify-end gap-2 mt-6", children: [
+          /* @__PURE__ */ jsx(Button, { variant: "secondary", onClick: closeDrawer, children: "Cancel" }),
+          /* @__PURE__ */ jsx(Button, { onClick: handleSubmit, children: editingConsent ? "Update" : "Create" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(Drawer.Footer, { className: "flex justify-start", children: editingConsent && /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "danger",
+          onClick: () => {
+            handleDelete(editingConsent.id);
+          },
+          children: "Delete"
+        }
+      ) })
+    ] }) })
+  ] });
+};
+const MembershipConsentPage = () => {
+  return /* @__PURE__ */ jsx(MembershipConsentsRenderer, {});
+};
+const config$1 = defineRouteConfig({
+  label: "Membership Consents"
+});
+const useCreateMembershipTier = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (data) => {
+      const response = await axios$1.post("/admin/member-tiers", data);
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["membership-tiers"] });
+    }
+  });
+};
+const useDeleteMembershipTier = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (id) => {
+      await axios$1.delete(`/admin/member-tiers/${id}`);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["member-tiers"] });
+    }
+  });
+};
+const MEMBERSHIP_TIERS_QUERY_KEY = ["membership-tiers"];
+const useMembershipTiers = (params = {
+  limit: 15,
+  offset: 0,
+  order: {
+    min_points: "ASC"
+  }
+}) => {
+  return useQuery({
+    queryKey: [...MEMBERSHIP_TIERS_QUERY_KEY, params],
+    queryFn: async () => {
+      const response = await axios$1.get("/admin/member-tiers", {
+        params
+      });
+      return response.data;
+    }
+  });
+};
+const useUpdateMembershipTier = () => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (tier) => {
+      const response = await axios$1.patch(`/admin/member-tiers/${tier.id}`, {
+        name: tier.name,
+        description: tier.description,
+        privilege_description: tier.privilege_description,
+        min_points: tier.min_points
+      });
+      return response.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["member-tiers"] });
+    }
+  });
+};
+const columnHelper = createDataTableColumnHelper();
+const columns = [
+  columnHelper.accessor("min_points", {
+    header: "Min Points"
+  }),
+  columnHelper.accessor("name", {
+    header: "Name"
+  }),
+  columnHelper.accessor("description", {
+    header: "Description",
+    maxSize: 250
+  }),
+  columnHelper.accessor("privilege_description", {
+    header: "Privilege Description",
+    maxSize: 250
+  })
+];
+const MembershipTierRenderer = () => {
+  const dialog = usePrompt();
+  const [pagination, setPagination] = useState({
+    pageSize: 1e3,
+    pageIndex: 0
+  });
+  const [isDrawerOpen, setIsDrawerOpen] = useState(false);
+  const [editingTier, setEditingTier] = useState(null);
+  const [formData, setFormData] = useState({
+    name: "",
+    description: "",
+    privilege_description: "",
+    min_points: 0
+  });
+  const { data, isLoading, refetch } = useMembershipTiers({
+    limit: pagination.pageSize,
+    offset: pagination.pageIndex * pagination.pageSize
+  });
+  const createTier = useCreateMembershipTier();
+  const updateTier = useUpdateMembershipTier();
+  const deleteTier = useDeleteMembershipTier();
+  const table = useDataTable({
+    columns,
+    data: (data == null ? void 0 : data.tiers) || [],
+    getRowId: (tier) => tier.id,
+    rowCount: (data == null ? void 0 : data.count) || 0,
+    isLoading,
+    pagination: {
+      state: pagination,
+      onPaginationChange: setPagination
+    },
+    onRowClick: (_, row) => {
+      openDrawer(row.original);
+    }
+  });
+  const handleInputChange = (e) => {
+    const { name, value } = e.target;
+    setFormData((prev) => ({
+      ...prev,
+      [name]: name === "min_points" ? Number(value) : value
+    }));
+  };
+  const handleTextAreaChange = (e) => {
+    const { name, value } = e.target;
+    setFormData((prev) => ({
+      ...prev,
+      [name]: value
+    }));
+  };
+  const handleReset = () => {
+    setFormData({
+      name: "",
+      description: "",
+      privilege_description: "",
+      min_points: 0
+    });
+  };
+  const openDrawer = (tier) => {
+    if (tier) {
+      setEditingTier(tier);
+      setFormData({
+        name: tier.name,
+        description: tier.description,
+        privilege_description: tier.privilege_description,
+        min_points: tier.min_points
+      });
+    } else {
+      setEditingTier(null);
+      handleReset();
+    }
+    setIsDrawerOpen(true);
+  };
+  const closeDrawer = () => {
+    setIsDrawerOpen(false);
+    setEditingTier(null);
+    handleReset();
+    refetch();
+  };
+  const handleSubmit = async () => {
+    var _a, _b;
+    try {
+      if (!formData.name) {
+        toast.error("Name is required", { dismissable: true, duration: 2500 });
+        return;
+      }
+      if (editingTier) {
+        await updateTier.mutateAsync({ id: editingTier.id, ...formData });
+        toast.success("Tier updated successfully", {
+          dismissable: true,
+          duration: 2500
+        });
+      } else {
+        await createTier.mutateAsync(formData);
+        toast.success("Tier created successfully", {
+          dismissable: true,
+          duration: 2500
+        });
+      }
+      closeDrawer();
+    } catch (error) {
+      if (axios$1.isAxiosError(error)) {
+        toast.error("Error saving tier", {
+          description: (_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message,
+          dismissable: true,
+          duration: 2500
+        });
+      } else {
+        toast.error("Error saving tier", {
+          dismissable: true,
+          duration: 2500
+        });
+      }
+    }
+  };
+  const handleDelete = async (id) => {
+    var _a, _b;
+    try {
+      const confirmed = await dialog({
+        title: "Delete Membership Tier",
+        description: `Are you sure you want to delete the \`${editingTier == null ? void 0 : editingTier.name}\` tier?`
+      });
+      if (!confirmed) {
+        return;
+      }
+      await deleteTier.mutateAsync(id);
+      toast.success("Tier deleted successfully", {
+        dismissable: true,
+        duration: 2500
+      });
+      closeDrawer();
+    } catch (error) {
+      if (axios$1.isAxiosError(error)) {
+        toast.error("Error deleting tier", {
+          description: (_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message,
+          dismissable: true,
+          duration: 2500
+        });
+      } else {
+        toast.error("Error deleting tier", {
+          dismissable: true,
+          duration: 2500
+        });
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Container, { className: "flex flex-col p-0 overflow-hidden", children: /* @__PURE__ */ jsxs(DataTable, { instance: table, children: [
+      /* @__PURE__ */ jsxs(DataTable.Toolbar, { className: "flex flex-col items-start justify-between gap-2 md:flex-row md:items-center", children: [
+        /* @__PURE__ */ jsx(Heading, { children: "Membership Tiers" }),
+        /* @__PURE__ */ jsx(Button, { onClick: () => openDrawer(), children: "Add Tier" })
+      ] }),
+      /* @__PURE__ */ jsx(DataTable.Table, {})
+    ] }) }),
+    /* @__PURE__ */ jsx(Drawer, { open: isDrawerOpen, onOpenChange: setIsDrawerOpen, children: /* @__PURE__ */ jsxs(Drawer.Content, { children: [
+      /* @__PURE__ */ jsx(Drawer.Header, { children: /* @__PURE__ */ jsx(Drawer.Title, { children: editingTier ? "Edit Tier" : "Add Tier" }) }),
+      /* @__PURE__ */ jsxs(Drawer.Body, { "aria-description": "Membership Tier Form", children: [
+        /* @__PURE__ */ jsxs("div", { className: "space-y-4", "aria-description": "Membership Tier Form", children: [
+          /* @__PURE__ */ jsx(Text, { children: "Name" }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              name: "name",
+              value: formData.name,
+              onChange: handleInputChange
+            }
+          ),
+          /* @__PURE__ */ jsx(Text, { children: "Description" }),
+          /* @__PURE__ */ jsx(
+            Textarea,
+            {
+              className: "truncate",
+              name: "description",
+              value: formData.description,
+              onChange: handleTextAreaChange
+            }
+          ),
+          /* @__PURE__ */ jsx(Text, { children: "Privilege Description" }),
+          /* @__PURE__ */ jsx(
+            Textarea,
+            {
+              className: "truncate",
+              name: "privilege_description",
+              value: formData.privilege_description,
+              onChange: handleTextAreaChange
+            }
+          ),
+          /* @__PURE__ */ jsx(Text, { children: "Points" }),
+          /* @__PURE__ */ jsx(
+            Input,
+            {
+              name: "min_points",
+              type: "number",
+              value: formData.min_points,
+              onChange: handleInputChange
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex justify-end gap-2 mt-6", children: [
+          /* @__PURE__ */ jsx(Button, { variant: "secondary", onClick: closeDrawer, children: "Cancel" }),
+          /* @__PURE__ */ jsx(Button, { onClick: handleSubmit, children: editingTier ? "Update" : "Create" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(Drawer.Footer, { className: "flex justify-start", children: editingTier && /* @__PURE__ */ jsx(
+        Button,
+        {
+          variant: "danger",
+          onClick: () => {
+            handleDelete(editingTier.id);
+          },
+          children: "Delete"
+        }
+      ) })
+    ] }) })
+  ] });
+};
+const MembershipTierPage = () => {
+  return /* @__PURE__ */ jsx(MembershipTierRenderer, {});
+};
+const config = defineRouteConfig({
+  label: "Membership Tiers"
+});
+const widgetModule = { widgets: [
+  {
+    Component: PromotionWidget,
+    zone: ["promotion.details.side.after"]
+  }
+] };
+const routeModule = {
+  routes: [
+    {
+      Component: BannerUpload,
+      path: "/membership"
+    },
+    {
+      Component: MembershipConsentPage,
+      path: "/membership/member-consents"
+    },
+    {
+      Component: MembershipTierPage,
+      path: "/membership/membertier"
+    }
+  ]
+};
+const menuItemModule = {
+  menuItems: [
+    {
+      label: config$2.label,
+      icon: config$2.icon,
+      path: "/membership",
+      nested: void 0
+    },
+    {
+      label: config$1.label,
+      icon: void 0,
+      path: "/membership/member-consents",
+      nested: void 0
+    },
+    {
+      label: config.label,
+      icon: void 0,
+      path: "/membership/membertier",
+      nested: void 0
+    }
+  ]
+};
+const formModule = { customFields: {} };
+const displayModule = {
+  displays: {}
+};
+const plugin = {
+  widgetModule,
+  routeModule,
+  menuItemModule,
+  formModule,
+  displayModule
+};
+export {
+  plugin as default
+};