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);
  return value;
};
import { j as jwtDecode_esm, b as optionsSchema, L as Logger, C as Cache, E as Emitter, N as Network, g as getConfigResponseSchema, d as configSchema, u as unionType, o as objectType, s as stringType, e as o, h as getUserResponseSchema, k as userSchema, l as getUserAvatarResponseSchema, m as getSpacesResponseSchema, n as getViewInputSchema, p as getViewResponseSchema, q as askInputSchema, r as askResponseSchema, t as getNotificationsInputSchema, v as getNotificationsResponseSchema, w as getNotificationInputSchema, x as getNotificationResponseSchema, y as actionNotificationInputSchema, z as actionNotificationResponseSchema, A as deleteNotificationInputSchema, B as deleteNotificationResponseSchema, D as viewNotificationInputSchema, F as viewNotificationResponseSchema } from "./index-7892b8aa.js";
import { a as getAugmentedNamespace, g as getDefaultExportFromCjs, c as commonjsGlobal } from "./_commonjsHelpers-ca272635.js";
var lib = { exports: {} };
const require$$0 = /* @__PURE__ */ getAugmentedNamespace(jwtDecode_esm);
(function(module, exports) {
  var __importDefault = commonjsGlobal && commonjsGlobal.__importDefault || function(mod) {
    return mod && mod.__esModule ? mod : { "default": mod };
  };
  Object.defineProperty(exports, "__esModule", { value: true });
  const jwt_decode_1 = __importDefault(require$$0);
  function jwtCache2({ getToken, eagerRefreshMilliseconds = 0, minimumValidityMilliseconds = 1e3 }) {
    let disposed = false;
    let statePromise;
    let nextState;
    let timeout;
    const getState = async () => {
      const token = await getToken();
      const decoded = jwt_decode_1.default(token);
      if (typeof decoded === "object" && decoded !== null && typeof decoded.exp === "number") {
        const expiry = decoded.exp * 1e3;
        return { token, expiry };
      } else {
        throw new Error(`You can only cache a JWT if it has an "exp" that is an integer number of seconds`);
      }
    };
    const handleEagerRefresh = (state, currentStatePromise) => {
      if (disposed)
        return;
      if (eagerRefreshMilliseconds) {
        timeout = setTimeout(() => {
          if (statePromise === currentStatePromise) {
            const thisNextState = nextState = getState();
            thisNextState.then((state2) => {
              if (nextState === thisNextState && statePromise === currentStatePromise) {
                statePromise = thisNextState;
                handleEagerRefresh(state2, thisNextState);
              }
            }, (_ex) => {
              if (nextState === thisNextState && statePromise === currentStatePromise) {
                nextState = void 0;
              }
            });
          }
        }, state.expiry - Date.now() - minimumValidityMilliseconds - eagerRefreshMilliseconds);
      }
    };
    const getUpdatedToken = async (currentStatePromise) => {
      if (statePromise && currentStatePromise !== statePromise) {
        return (await statePromise).token;
      }
      statePromise = nextState !== null && nextState !== void 0 ? nextState : getState();
      nextState = void 0;
      try {
        const state = await statePromise;
        handleEagerRefresh(state, statePromise);
        return state.token;
      } catch (ex) {
        statePromise = void 0;
        throw ex;
      }
    };
    if (eagerRefreshMilliseconds) {
      getUpdatedToken(void 0).catch(() => {
      });
    }
    return {
      dispose: () => {
        disposed = true;
        if (timeout) {
          clearTimeout(timeout);
        }
      },
      getToken: async () => {
        if (disposed) {
          throw new Error(`Cannot get token after disposing jwt-cache`);
        }
        const stateP = statePromise;
        if (!stateP) {
          return await getUpdatedToken(stateP);
        }
        const state = await stateP;
        if (state.expiry - Date.now() >= minimumValidityMilliseconds) {
          return state.token;
        }
        return await getUpdatedToken(stateP);
      }
    };
  }
  exports.default = jwtCache2;
  module.exports = Object.assign(jwtCache2, { default: jwtCache2 });
})(lib, lib.exports);
var libExports = lib.exports;
const jwtCache = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
const copyProperty = (to, from, property, ignoreNonConfigurable) => {
  if (property === "length" || property === "prototype") {
    return;
  }
  if (property === "arguments" || property === "caller") {
    return;
  }
  const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
  const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
  if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
    return;
  }
  Object.defineProperty(to, property, fromDescriptor);
};
const canCopyProperty = function(toDescriptor, fromDescriptor) {
  return toDescriptor === void 0 || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
};
const changePrototype = (to, from) => {
  const fromPrototype = Object.getPrototypeOf(from);
  if (fromPrototype === Object.getPrototypeOf(to)) {
    return;
  }
  Object.setPrototypeOf(to, fromPrototype);
};
const wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/
${fromBody}`;
const toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString");
const toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name");
const changeToString = (to, from, name2) => {
  const withName = name2 === "" ? "" : `with ${name2.trim()}() `;
  const newToString = wrappedToString.bind(null, withName, from.toString());
  Object.defineProperty(newToString, "name", toStringName);
  Object.defineProperty(to, "toString", { ...toStringDescriptor, value: newToString });
};
function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
  const { name: name2 } = to;
  for (const property of Reflect.ownKeys(from)) {
    copyProperty(to, from, property, ignoreNonConfigurable);
  }
  changePrototype(to, from);
  changeToString(to, from, name2);
  return to;
}
const cacheStore = /* @__PURE__ */ new WeakMap();
function pMemoize(fn, { cacheKey = ([firstArgument]) => firstArgument, cache = /* @__PURE__ */ new Map() } = {}) {
  const promiseCache = /* @__PURE__ */ new Map();
  const memoized = function(...arguments_) {
    const key = cacheKey(arguments_);
    if (promiseCache.has(key)) {
      return promiseCache.get(key);
    }
    const promise = (async () => {
      try {
        if (cache && await cache.has(key)) {
          return await cache.get(key);
        }
        const promise2 = fn.apply(this, arguments_);
        const result = await promise2;
        try {
          return result;
        } finally {
          if (cache) {
            await cache.set(key, result);
          }
        }
      } finally {
        promiseCache.delete(key);
      }
    })();
    promiseCache.set(key, promise);
    return promise;
  };
  mimicFunction(memoized, fn, {
    ignoreNonConfigurable: true
  });
  cacheStore.set(memoized, cache);
  return memoized;
}
function toS(obj) {
  return Object.prototype.toString.call(obj);
}
function isDate(obj) {
  return toS(obj) === "[object Date]";
}
function isRegExp(obj) {
  return toS(obj) === "[object RegExp]";
}
function isError(obj) {
  return toS(obj) === "[object Error]";
}
function isBoolean(obj) {
  return toS(obj) === "[object Boolean]";
}
function isNumber(obj) {
  return toS(obj) === "[object Number]";
}
function isString(obj) {
  return toS(obj) === "[object String]";
}
var isArray = Array.isArray || function isArray2(xs) {
  return Object.prototype.toString.call(xs) === "[object Array]";
};
function forEach(xs, fn) {
  if (xs.forEach) {
    return xs.forEach(fn);
  }
  for (var i = 0; i < xs.length; i++) {
    fn(xs[i], i, xs);
  }
  return void 0;
}
var objectKeys = Object.keys || function keys(obj) {
  var res = [];
  for (var key in obj) {
    res.push(key);
  }
  return res;
};
var hasOwnProperty = Object.prototype.hasOwnProperty || function(obj, key) {
  return key in obj;
};
function copy(src) {
  if (typeof src === "object" && src !== null) {
    var dst;
    if (isArray(src)) {
      dst = [];
    } else if (isDate(src)) {
      dst = new Date(src.getTime ? src.getTime() : src);
    } else if (isRegExp(src)) {
      dst = new RegExp(src);
    } else if (isError(src)) {
      dst = { message: src.message };
    } else if (isBoolean(src) || isNumber(src) || isString(src)) {
      dst = Object(src);
    } else if (Object.create && Object.getPrototypeOf) {
      dst = Object.create(Object.getPrototypeOf(src));
    } else if (src.constructor === Object) {
      dst = {};
    } else {
      var proto = src.constructor && src.constructor.prototype || src.__proto__ || {};
      var T = function T2() {
      };
      T.prototype = proto;
      dst = new T();
    }
    forEach(objectKeys(src), function(key) {
      dst[key] = src[key];
    });
    return dst;
  }
  return src;
}
function walk(root, cb, immutable) {
  var path = [];
  var parents = [];
  var alive = true;
  return function walker(node_) {
    var node = immutable ? copy(node_) : node_;
    var modifiers = {};
    var keepGoing = true;
    var state = {
      node,
      node_,
      path: [].concat(path),
      parent: parents[parents.length - 1],
      parents,
      key: path[path.length - 1],
      isRoot: path.length === 0,
      level: path.length,
      circular: null,
      update: function(x, stopHere) {
        if (!state.isRoot) {
          state.parent.node[state.key] = x;
        }
        state.node = x;
        if (stopHere) {
          keepGoing = false;
        }
      },
      delete: function(stopHere) {
        delete state.parent.node[state.key];
        if (stopHere) {
          keepGoing = false;
        }
      },
      remove: function(stopHere) {
        if (isArray(state.parent.node)) {
          state.parent.node.splice(state.key, 1);
        } else {
          delete state.parent.node[state.key];
        }
        if (stopHere) {
          keepGoing = false;
        }
      },
      keys: null,
      before: function(f) {
        modifiers.before = f;
      },
      after: function(f) {
        modifiers.after = f;
      },
      pre: function(f) {
        modifiers.pre = f;
      },
      post: function(f) {
        modifiers.post = f;
      },
      stop: function() {
        alive = false;
      },
      block: function() {
        keepGoing = false;
      }
    };
    if (!alive) {
      return state;
    }
    function updateState() {
      if (typeof state.node === "object" && state.node !== null) {
        if (!state.keys || state.node_ !== state.node) {
          state.keys = objectKeys(state.node);
        }
        state.isLeaf = state.keys.length === 0;
        for (var i = 0; i < parents.length; i++) {
          if (parents[i].node_ === node_) {
            state.circular = parents[i];
            break;
          }
        }
      } else {
        state.isLeaf = true;
        state.keys = null;
      }
      state.notLeaf = !state.isLeaf;
      state.notRoot = !state.isRoot;
    }
    updateState();
    var ret = cb.call(state, state.node);
    if (ret !== void 0 && state.update) {
      state.update(ret);
    }
    if (modifiers.before) {
      modifiers.before.call(state, state.node);
    }
    if (!keepGoing) {
      return state;
    }
    if (typeof state.node === "object" && state.node !== null && !state.circular) {
      parents.push(state);
      updateState();
      forEach(state.keys, function(key, i) {
        path.push(key);
        if (modifiers.pre) {
          modifiers.pre.call(state, state.node[key], key);
        }
        var child = walker(state.node[key]);
        if (immutable && hasOwnProperty.call(state.node, key)) {
          state.node[key] = child.node;
        }
        child.isLast = i === state.keys.length - 1;
        child.isFirst = i === 0;
        if (modifiers.post) {
          modifiers.post.call(state, child);
        }
        path.pop();
      });
      parents.pop();
    }
    if (modifiers.after) {
      modifiers.after.call(state, state.node);
    }
    return state;
  }(root).node;
}
function Traverse(obj) {
  this.value = obj;
}
Traverse.prototype.get = function(ps) {
  var node = this.value;
  for (var i = 0; i < ps.length; i++) {
    var key = ps[i];
    if (!node || !hasOwnProperty.call(node, key)) {
      return void 0;
    }
    node = node[key];
  }
  return node;
};
Traverse.prototype.has = function(ps) {
  var node = this.value;
  for (var i = 0; i < ps.length; i++) {
    var key = ps[i];
    if (!node || !hasOwnProperty.call(node, key)) {
      return false;
    }
    node = node[key];
  }
  return true;
};
Traverse.prototype.set = function(ps, value) {
  var node = this.value;
  for (var i = 0; i < ps.length - 1; i++) {
    var key = ps[i];
    if (!hasOwnProperty.call(node, key)) {
      node[key] = {};
    }
    node = node[key];
  }
  node[ps[i]] = value;
  return value;
};
Traverse.prototype.map = function(cb) {
  return walk(this.value, cb, true);
};
Traverse.prototype.forEach = function(cb) {
  this.value = walk(this.value, cb, false);
  return this.value;
};
Traverse.prototype.reduce = function(cb, init) {
  var skip = arguments.length === 1;
  var acc = skip ? this.value : init;
  this.forEach(function(x) {
    if (!this.isRoot || !skip) {
      acc = cb.call(this, acc, x);
    }
  });
  return acc;
};
Traverse.prototype.paths = function() {
  var acc = [];
  this.forEach(function() {
    acc.push(this.path);
  });
  return acc;
};
Traverse.prototype.nodes = function() {
  var acc = [];
  this.forEach(function() {
    acc.push(this.node);
  });
  return acc;
};
Traverse.prototype.clone = function() {
  var parents = [];
  var nodes = [];
  return function clone(src) {
    for (var i = 0; i < parents.length; i++) {
      if (parents[i] === src) {
        return nodes[i];
      }
    }
    if (typeof src === "object" && src !== null) {
      var dst = copy(src);
      parents.push(src);
      nodes.push(dst);
      forEach(objectKeys(src), function(key) {
        dst[key] = clone(src[key]);
      });
      parents.pop();
      nodes.pop();
      return dst;
    }
    return src;
  }(this.value);
};
function traverse(obj) {
  return new Traverse(obj);
}
forEach(objectKeys(Traverse.prototype), function(key) {
  traverse[key] = function(obj) {
    var args = [].slice.call(arguments, 1);
    var t = new Traverse(obj);
    return t[key].apply(t, args);
  };
});
var traverse_1 = traverse;
const traverse$1 = /* @__PURE__ */ getDefaultExportFromCjs(traverse_1);
function injectActionData(view, data) {
  return traverse$1(view).map((node) => {
    var _a;
    if (node.type === "Action.Execute" || node.type == "Action.Submit") {
      return { ...node, data: { ...node == null ? void 0 : node.data, __internal__: { ...(_a = node == null ? void 0 : node.data) == null ? void 0 : _a.__internal__, ...data } } };
    }
  });
}
const name = "@workgrid-widgets/core";
const version = "1.3.11";
class Core {
  constructor(options) {
    __publicField(this, "client", `${name}/${version}`);
    __publicField(this, "options");
    __publicField(this, "cache");
    __publicField(this, "emitter");
    __publicField(this, "logger");
    __publicField(this, "network");
    __publicField(this, "createLogger");
    __publicField(this, "on");
    __publicField(this, "off");
    __publicField(this, "emit");
    this.options = optionsSchema.parse(options);
    const logger = this.options.logger ?? new Logger({ core: this, ...this.options.loggerOptions });
    this.logger = logger.create({ prefix: "core" });
    this.createLogger = this.logger.create.bind(this.logger);
    this.cache = this.options.cache ?? new Cache({ core: this, ...this.options.cacheOptions });
    this.emitter = this.options.emitter ?? new Emitter({ core: this, ...this.options.emitterOptions });
    this.network = this.options.network ?? new Network({ core: this, ...this.options.networkOptions });
    this.on = this.emitter.on.bind(this.emitter);
    this.off = this.emitter.off.bind(this.emitter);
    this.emit = this.emitter.emit.bind(this.emitter);
    this.getToken = jwtCache({ getToken: this.logger.wrapFn(this.getToken.bind(this)) }).getToken;
    this.getApiHost = pMemoize(this.logger.wrapFn(this.getApiHost.bind(this)));
    this.getConfig = pMemoize(this.logger.wrapFn(this.getConfig.bind(this)));
    this.getUser = pMemoize(this.logger.wrapFn(this.getUser.bind(this)));
  }
  /**
   * Resolve a user token
   */
  async getToken() {
    let token = await this.options.getToken(this);
    if (token instanceof Response) {
      token = await token.text();
    }
    return token;
  }
  /**
   * Resolve the api host
   */
  async getApiHost() {
    return this.options.getApiHost(this);
  }
  /**
   * Fetch the client config
   */
  async getConfig() {
    const cacheKey = `config/${this.options.key ?? "DEFAULT"}`;
    const promise = (async () => {
      const token = await this.getToken();
      const response = await this.network.get("v1/admin/client-config", {
        headers: {
          Authorization: `Bearer ${token}`
        },
        searchParams: {
          key: this.options.key ?? ""
        }
      });
      const config2 = getConfigResponseSchema.parse(await response.json());
      this.cache.set(cacheKey, config2);
      return config2;
    })();
    try {
      const config2 = this.cache.get(cacheKey);
      if (config2)
        return configSchema.parse(config2);
    } catch {
    }
    const config = await promise;
    return configSchema.parse(config);
  }
  /**
   * Fetch the current user
   */
  async getUser() {
    const token = await this.getToken();
    const subject = unionType([
      objectType({ sub: stringType() }).transform((token2) => token2.sub),
      objectType({ email: stringType() }).transform((token2) => token2.email)
    ]).parse(o(token));
    const cacheKey = `user/${subject}`;
    const promise = (async () => {
      const token2 = await this.getToken();
      const response = await this.network.get("v1/admin/user", {
        headers: {
          Authorization: `Bearer ${token2}`
        }
      });
      const user2 = getUserResponseSchema.parse(await response.json());
      this.cache.set(cacheKey, user2);
      return user2;
    })();
    try {
      const user2 = this.cache.get(cacheKey);
      if (user2)
        return userSchema.parse(user2);
    } catch {
    }
    const user = await promise;
    return userSchema.parse(user);
  }
  /**
   * Fetch the current user avatar
   */
  async getUserAvatar() {
    const token = await this.getToken();
    const response = await this.network.get("v1/admin/user/avatar", {
      headers: {
        Authorization: `Bearer ${token}`
      }
    });
    return getUserAvatarResponseSchema.parse(await response.json());
  }
  /**
   * Fetch spaces
   */
  async getSpaces() {
    const token = await this.getToken();
    const response = await this.network.get(`v1/userspaces`, {
      headers: {
        Authorization: `Bearer ${token}`
      }
    });
    return getSpacesResponseSchema.parse(await response.json());
  }
  /**
   * Fetch a microapp view
   */
  async getView(options) {
    const resolvedOptions = getViewInputSchema.parse(options);
    const token = await this.getToken();
    const response = await this.network.post(`v1/appbuilder/userapps/${resolvedOptions.endpoint}`, {
      headers: {
        Authorization: `Bearer ${token}`,
        "x-workgrid-space": resolvedOptions.spaceId
      },
      json: { data: resolvedOptions.data }
    });
    let view = getViewResponseSchema.parse(await response.json());
    view = injectActionData(view, {
      spaceId: resolvedOptions.spaceId
    });
    return view;
  }
  /**
   * Prompt the ask api
   */
  async ask(options) {
    const resolvedOptions = askInputSchema.parse(options);
    const token = await this.getToken();
    const response = await this.network.post("v3/ask", {
      headers: {
        Authorization: `Bearer ${token}`,
        "x-workgrid-space": resolvedOptions.spaceId
      },
      json: {
        locale: "en_US",
        channel: "unified",
        utterance: resolvedOptions.message,
        ...resolvedOptions.id ? { id: resolvedOptions.id } : {}
      }
    });
    let data = askResponseSchema.parse(await response.json());
    if ("view" in data) {
      data = {
        ...data,
        view: injectActionData(data.view, {
          spaceId: resolvedOptions.spaceId
        })
      };
    }
    if ("notifications" in data) {
      data = {
        ...data,
        notifications: data.notifications.map((notification) => ({
          ...notification,
          view: injectActionData(notification.view, {
            spaceId: resolvedOptions.spaceId,
            notificationId: notification.metadata.id
          })
        })),
        showMoreNotifications: data.showMoreNotifications ? injectActionData(data.showMoreNotifications, {
          spaceId: resolvedOptions.spaceId
        }) : void 0
      };
    }
    return data;
  }
  /**
   * Fetch notifications
   */
  async getNotifications(options) {
    const resolvedOptions = getNotificationsInputSchema.parse(options);
    const token = await this.getToken();
    const searchParameters = {
      orderBy: "date"
    };
    if (resolvedOptions.cursor)
      searchParameters.cursor = resolvedOptions.cursor;
    if (resolvedOptions.limit)
      searchParameters.limit = String(resolvedOptions.limit);
    if (resolvedOptions.since)
      searchParameters.since = resolvedOptions.since;
    if (resolvedOptions.until)
      searchParameters.until = resolvedOptions.until;
    const response = await this.network.get(`v1/usernotifications`, {
      headers: {
        Authorization: `Bearer ${token}`,
        "x-workgrid-space": resolvedOptions.spaceId,
        Accept: 'application/vnd.microsoft.card.adaptive;features="delete"'
      },
      searchParams: searchParameters
    });
    let data = getNotificationsResponseSchema.parse(await response.json());
    data = {
      ...data,
      notifications: data.notifications.map((notification) => ({
        ...notification,
        view: injectActionData(notification.view, {
          spaceId: resolvedOptions.spaceId,
          notificationId: notification.metadata.id
        })
      })),
      showMoreNotifications: data.showMoreNotifications ? injectActionData(data.showMoreNotifications, {
        spaceId: resolvedOptions.spaceId
      }) : void 0
    };
    return data;
  }
  /**
   * Fetch single notification
   */
  async getNotification(options) {
    const resolvedOptions = getNotificationInputSchema.parse(options);
    const token = await this.getToken();
    const response = await this.network.get(`v1/usernotifications/${resolvedOptions.notificationId}`, {
      headers: {
        Authorization: `Bearer ${token}`,
        "x-workgrid-space": resolvedOptions.spaceId,
        Accept: 'application/vnd.microsoft.card.adaptive;features="delete"'
      }
    });
    const data = getNotificationResponseSchema.parse(await response.json());
    const view = injectActionData(data.view, {
      spaceId: resolvedOptions.spaceId,
      notificationId: data.metadata.id
    });
    return view;
  }
  /**
   * Action a notification
   */
  async actionNotification(options) {
    const resolvedOptions = actionNotificationInputSchema.parse(options);
    const token = await this.getToken();
    const { data, analytics, ...rest } = resolvedOptions.data;
    const response = await this.network.post(`v1/usernotifications/${resolvedOptions.notificationId}/action`, {
      headers: {
        Authorization: `Bearer ${token}`,
        "x-workgrid-space": resolvedOptions.spaceId,
        Accept: 'application/vnd.microsoft.card.adaptive;features="delete"'
      },
      json: {
        data: { ...rest, ...data },
        analytics
      }
    });
    return actionNotificationResponseSchema.parse(await response.json());
  }
  /**
   * Delete a notification
   */
  async deleteNotification(options) {
    const resolvedOptions = deleteNotificationInputSchema.parse(options);
    const token = await this.getToken();
    const response = await this.network.delete(`v1/usernotifications/${resolvedOptions.notificationId}`, {
      headers: {
        Authorization: `Bearer ${token}`,
        "x-workgrid-space": resolvedOptions.spaceId,
        Accept: 'application/vnd.microsoft.card.adaptive;features="delete"'
      }
    });
    return deleteNotificationResponseSchema.parse(await response.json());
  }
  /**
   * Track notification views
   */
  async viewNotification(options) {
    const resolvedOptions = viewNotificationInputSchema.parse(options);
    const token = await this.getToken();
    const type = { summary: "view", detail: "view-detail" }[resolvedOptions.location];
    const response = await this.network.put(`v1/usernotifications/${resolvedOptions.notificationId}/${type}`, {
      headers: {
        Authorization: `Bearer ${token}`,
        "x-workgrid-space": resolvedOptions.spaceId
      }
    });
    return viewNotificationResponseSchema.parse(await response.json());
  }
}
export {
  actionNotificationInputSchema,
  actionNotificationResponseSchema,
  askInputSchema,
  askResponseSchema,
  configSchema,
  Core as default,
  deleteNotificationInputSchema,
  deleteNotificationResponseSchema,
  getConfigResponseSchema,
  getNotificationInputSchema,
  getNotificationResponseSchema,
  getNotificationsInputSchema,
  getNotificationsResponseSchema,
  getSpacesResponseSchema,
  getUserAvatarResponseSchema,
  getUserResponseSchema,
  getViewInputSchema,
  getViewResponseSchema,
  optionsSchema,
  userSchema,
  viewNotificationInputSchema,
  viewNotificationResponseSchema
};
//# sourceMappingURL=index-0ada9754.js.map
