@mx-space/api-client 1.0.3 → 1.2.0

package/dist/index.global.js

@@ -0,0 +1,907 @@
+"use strict";
+(() => {
+  // utils/index.ts
+  var isPlainObject = (obj) => isObject(obj) && Object.prototype.toString.call(obj) === "[object Object]" && Object.getPrototypeOf(obj) === Object.prototype;
+  var sortOrderToNumber = (order) => {
+    return {
+      asc: 1,
+      desc: -1
+    }[order] || 1;
+  };
+  var isObject = (obj) => obj && typeof obj === "object";
+  var destructureData = (payload) => {
+    if (typeof payload !== "object") {
+      return payload;
+    }
+    if (payload === null) {
+      return payload;
+    }
+    const data = payload.data;
+    const dataIsPlainObject = isPlainObject(data);
+    if (dataIsPlainObject && Object.keys(payload).length === 1) {
+      const d = Object.assign({}, data);
+      attachRawFromOneToAnthor(payload, d);
+      return d;
+    }
+    return payload;
+  };
+  var attachRawFromOneToAnthor = (from, to) => {
+    if (!from || !isObject(to)) {
+      return;
+    }
+    from.$raw && Object.defineProperty(to, "$raw", {
+      value: { ...from.$raw },
+      enumerable: false
+    });
+    from.$request && Object.defineProperty(to, "$request", {
+      value: { ...from.$request },
+      enumerable: false
+    });
+  };
+
+  // utils/camelcase-keys.ts
+  var camelcaseKeys = (obj) => {
+    if (Array.isArray(obj)) {
+      return obj.map((x) => camelcaseKeys(x));
+    }
+    if (isPlainObject(obj)) {
+      return Object.keys(obj).reduce((result, key) => {
+        result[camelcase(key)] = camelcaseKeys(obj[key]);
+        return result;
+      }, {});
+    }
+    return obj;
+  };
+  function camelcase(str) {
+    return str.replace(/([-_][a-z])/gi, ($1) => {
+      return $1.toUpperCase().replace("-", "").replace("_", "");
+    });
+  }
+
+  // utils/path.ts
+  var resolveFullPath = (endpoint, path) => {
+    if (!path.startsWith("/")) {
+      path = `/${path}`;
+    }
+    return `${endpoint}${path}`;
+  };
+
+  // utils/auto-bind.ts
+  var getAllProperties = (object) => {
+    const properties = /* @__PURE__ */ new Set();
+    do {
+      for (const key of Reflect.ownKeys(object)) {
+        properties.add([object, key]);
+      }
+    } while ((object = Reflect.getPrototypeOf(object)) && object !== Object.prototype);
+    return properties;
+  };
+  function autoBind(self, { include, exclude } = {}) {
+    const filter = (key) => {
+      const match = (pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key);
+      if (include) {
+        return include.some(match);
+      }
+      if (exclude) {
+        return !exclude.some(match);
+      }
+      return true;
+    };
+    for (const [object, key] of getAllProperties(self.constructor.prototype)) {
+      if (key === "constructor" || !filter(key)) {
+        continue;
+      }
+      const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
+      if (descriptor && typeof descriptor.value === "function") {
+        self[key] = self[key].bind(self);
+      }
+    }
+    return self;
+  }
+
+  // controllers/aggregate.ts
+  var AggregateController = class {
+    constructor(client) {
+      this.client = client;
+      this.base = "aggregate";
+      this.name = "aggregate";
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getAggregateData() {
+      return this.proxy.get();
+    }
+    getTop(size = 5) {
+      return this.proxy.top.get({ params: { size } });
+    }
+    getTimeline(options) {
+      const { sort, type, year } = options || {};
+      return this.proxy.timeline.get({
+        params: {
+          sort: sort && sortOrderToNumber(sort),
+          type,
+          year
+        }
+      });
+    }
+    getStat() {
+      return this.proxy.stat.get();
+    }
+  };
+
+  // core/error.ts
+  var RequestError = class extends Error {
+    constructor(message, status, path, raw) {
+      super(message);
+      this.status = status;
+      this.path = path;
+      this.raw = raw;
+    }
+  };
+
+  // models/category.ts
+  var CategoryType = /* @__PURE__ */ ((CategoryType2) => {
+    CategoryType2[CategoryType2["Category"] = 0] = "Category";
+    CategoryType2[CategoryType2["Tag"] = 1] = "Tag";
+    return CategoryType2;
+  })(CategoryType || {});
+
+  // controllers/category.ts
+  var CategoryController = class {
+    constructor(client) {
+      this.client = client;
+      this.name = "category";
+      this.base = "categories";
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getAllCategories() {
+      return this.proxy.get({
+        params: {
+          type: 0 /* Category */
+        }
+      });
+    }
+    getAllTags() {
+      return this.proxy.get({
+        params: {
+          type: 1 /* Tag */
+        }
+      });
+    }
+    async getCategoryDetail(ids) {
+      if (typeof ids === "string") {
+        const data = await this.proxy.get({
+          params: {
+            ids
+          }
+        });
+        const result = Object.values(data.entries)[0];
+        attachRawFromOneToAnthor(data, result);
+        return result;
+      } else if (Array.isArray(ids)) {
+        const data = await this.proxy.get({
+          params: {
+            ids: ids.join(",")
+          }
+        });
+        const entries = data?.entries;
+        if (!entries) {
+          throw new RequestError(
+            "data structure error",
+            500,
+            data.$request.path,
+            data
+          );
+        }
+        const map = new Map(
+          Object.entries(entries).map(([id, value]) => [id.toLowerCase(), value])
+        );
+        attachRawFromOneToAnthor(data, map);
+        return map;
+      }
+    }
+    async getCategoryByIdOrSlug(idOrSlug) {
+      const res = await this.proxy(idOrSlug).get();
+      return destructureData(res);
+    }
+    async getTagByName(name) {
+      const res = await this.proxy(name).get({
+        params: {
+          tag: 1
+        }
+      });
+      return res;
+    }
+  };
+
+  // controllers/comment.ts
+  var CommentController = class {
+    constructor(client) {
+      this.client = client;
+      this.base = "comments";
+      this.name = "comment";
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getById(id) {
+      return this.proxy(id).get();
+    }
+    getByRefId(refId, pagination = {}) {
+      const { page, size } = pagination;
+      return this.proxy.ref(refId).get({
+        params: { page: page || 1, size: size || 10 }
+      });
+    }
+    comment(refId, data) {
+      return this.proxy(refId).post({
+        data
+      });
+    }
+    reply(commentId, data) {
+      return this.proxy.reply(commentId).post({
+        data
+      });
+    }
+  };
+
+  // controllers/base.ts
+  var BaseCrudController = class {
+    constructor(client) {
+      this.client = client;
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getById(id) {
+      return this.proxy(id).get();
+    }
+    getAll() {
+      return this.proxy.all.get();
+    }
+    getAllPaginated(page, perPage, sortOption) {
+      return this.proxy.get({
+        params: { page, size: perPage, ...sortOption }
+      });
+    }
+  };
+
+  // controllers/link.ts
+  var LinkController = class extends BaseCrudController {
+    constructor(client) {
+      super(client);
+      this.client = client;
+      this.name = ["link", "friend"];
+      this.base = "links";
+      autoBind(this);
+    }
+    async canApplyLink() {
+      const { can } = await this.proxy.audit.get();
+      return can;
+    }
+    async applyLink(data) {
+      return await this.proxy.audit.post({ data });
+    }
+  };
+
+  // controllers/note.ts
+  var NoteController = class {
+    constructor(client) {
+      this.client = client;
+      this.base = "notes";
+      this.name = "note";
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getLatest() {
+      return this.proxy.latest.get();
+    }
+    getNoteById(...rest) {
+      const [id, password = void 0, singleResult = false] = rest;
+      if (typeof id === "number") {
+        return this.proxy.nid(id.toString()).get({
+          params: { password, single: singleResult ? "1" : void 0 }
+        });
+      } else {
+        return this.proxy(id).get();
+      }
+    }
+    getList(page = 1, perPage = 10, options = {}) {
+      const { select, sortBy, sortOrder, year } = options;
+      return this.proxy.get({
+        params: {
+          page,
+          size: perPage,
+          select: select?.join(" "),
+          sortBy,
+          sortOrder,
+          year
+        }
+      });
+    }
+    getMiddleList(id, size = 5) {
+      return this.proxy.list(id).get({
+        params: { size }
+      });
+    }
+    likeIt(id) {
+      return this.proxy.like(id).get();
+    }
+    getNoteByTopicId(topicId, page = 1, size = 10, sortOptions = {}) {
+      return this.proxy.topics(topicId).get({
+        params: { page, size, ...sortOptions }
+      });
+    }
+  };
+
+  // controllers/page.ts
+  var PageController = class {
+    constructor(client) {
+      this.client = client;
+      this.base = "pages";
+      this.name = "page";
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getList(page = 1, perPage = 10, options = {}) {
+      const { select, sortBy, sortOrder } = options;
+      return this.proxy.get({
+        params: {
+          page,
+          size: perPage,
+          select: select?.join(" "),
+          sortBy,
+          sortOrder
+        }
+      });
+    }
+    getById(id) {
+      return this.proxy(id).get();
+    }
+    getBySlug(slug) {
+      return this.proxy.slug(slug).get({});
+    }
+  };
+
+  // controllers/post.ts
+  var PostController = class {
+    constructor(client) {
+      this.client = client;
+      this.base = "posts";
+      this.name = "post";
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getList(page = 1, perPage = 10, options = {}) {
+      const { select, sortBy, sortOrder, year } = options;
+      return this.proxy.get({
+        params: {
+          page,
+          size: perPage,
+          select: select?.join(" "),
+          sortBy,
+          sortOrder,
+          year
+        }
+      });
+    }
+    getPost(idOrCategoryName, slug) {
+      if (arguments.length == 1) {
+        return this.proxy(idOrCategoryName).get();
+      } else {
+        return this.proxy(idOrCategoryName)(slug).get();
+      }
+    }
+    getLatest() {
+      return this.proxy.latest.get();
+    }
+    thumbsUp(id) {
+      return this.proxy("_thumbs-up").get({ params: { id } });
+    }
+  };
+
+  // controllers/project.ts
+  var ProjectController = class extends BaseCrudController {
+    constructor(client) {
+      super(client);
+      this.client = client;
+      this.base = "projects";
+      this.name = "project";
+      autoBind(this);
+    }
+  };
+
+  // controllers/recently.ts
+  var RecentlyAttitudeResultEnum = /* @__PURE__ */ ((RecentlyAttitudeResultEnum2) => {
+    RecentlyAttitudeResultEnum2[RecentlyAttitudeResultEnum2["Inc"] = 1] = "Inc";
+    RecentlyAttitudeResultEnum2[RecentlyAttitudeResultEnum2["Dec"] = -1] = "Dec";
+    return RecentlyAttitudeResultEnum2;
+  })(RecentlyAttitudeResultEnum || {});
+  var RecentlyAttitudeEnum = /* @__PURE__ */ ((RecentlyAttitudeEnum2) => {
+    RecentlyAttitudeEnum2[RecentlyAttitudeEnum2["Up"] = 0] = "Up";
+    RecentlyAttitudeEnum2[RecentlyAttitudeEnum2["Down"] = 1] = "Down";
+    return RecentlyAttitudeEnum2;
+  })(RecentlyAttitudeEnum || {});
+  var RecentlyController = class {
+    constructor(client) {
+      this.client = client;
+      this.base = "recently";
+      this.name = ["recently", "shorthand"];
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getLatestOne() {
+      return this.proxy.latest.get();
+    }
+    getAll() {
+      return this.proxy.all.get();
+    }
+    getList(before, after, size) {
+      return this.proxy.get({
+        params: {
+          before,
+          after,
+          size
+        }
+      });
+    }
+    attitude(id, attitude) {
+      return this.proxy.attitude(id).get({
+        params: {
+          attitude
+        }
+      });
+    }
+  };
+
+  // controllers/say.ts
+  var SayController = class extends BaseCrudController {
+    constructor(client) {
+      super(client);
+      this.client = client;
+      this.base = "says";
+      this.name = "say";
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getRandom() {
+      return this.proxy.random.get();
+    }
+  };
+
+  // controllers/search.ts
+  var SearchController = class {
+    constructor(client) {
+      this.client = client;
+      this.base = "search";
+      this.name = "search";
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    search(type, keyword, options = {}) {
+      return this.proxy(type).get({
+        params: { keyword, ...options }
+      });
+    }
+    searchByAlgolia(keyword, options) {
+      return this.proxy("algolia").get({ params: { keyword, ...options } });
+    }
+  };
+
+  // controllers/severless.ts
+  var ServerlessController = class {
+    constructor(client) {
+      this.client = client;
+      this.base = "serverless";
+      this.name = "serverless";
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getByReferenceAndName(reference, name) {
+      return this.proxy(reference)(name).get();
+    }
+  };
+
+  // controllers/snippet.ts
+  var SnippetController = class {
+    constructor(client) {
+      this.client = client;
+      this.base = "snippets";
+      this.name = "snippet";
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getByReferenceAndName(reference, name) {
+      return this.proxy(reference)(name).get();
+    }
+  };
+
+  // controllers/topic.ts
+  var TopicController = class extends BaseCrudController {
+    constructor(client) {
+      super(client);
+      this.client = client;
+      this.base = "topics";
+      this.name = "topic";
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getTopicBySlug(slug) {
+      return this.proxy.slug(slug).get();
+    }
+  };
+
+  // controllers/user.ts
+  var UserController = class {
+    constructor(client) {
+      this.client = client;
+      this.base = "master";
+      this.name = ["user", "master"];
+      autoBind(this);
+    }
+    get proxy() {
+      return this.client.proxy(this.base);
+    }
+    getMasterInfo() {
+      return this.proxy.get();
+    }
+    login(username, password) {
+      return this.proxy.login.post({
+        data: {
+          username,
+          password
+        }
+      });
+    }
+    loginWithToken(token) {
+      return this.proxy.login.put({
+        params: token ? {
+          token: `bearer ${token.replace(/^Bearer\s/i, "")}`
+        } : void 0
+      });
+    }
+    checkTokenValid(token) {
+      return this.proxy.check_logged.get({
+        params: {
+          token: `bearer ${token.replace(/^Bearer\s/i, "")}`
+        }
+      });
+    }
+  };
+
+  // controllers/index.ts
+  var allControllers = [
+    AggregateController,
+    CategoryController,
+    CommentController,
+    LinkController,
+    NoteController,
+    PageController,
+    PostController,
+    ProjectController,
+    RecentlyController,
+    TopicController,
+    SayController,
+    SearchController,
+    SnippetController,
+    ServerlessController,
+    UserController
+  ];
+  var allContollerNames = [
+    "aggregate",
+    "category",
+    "comment",
+    "link",
+    "note",
+    "page",
+    "post",
+    "project",
+    "topic",
+    "recently",
+    "say",
+    "search",
+    "snippet",
+    "serverless",
+    "user",
+    "friend",
+    "master",
+    "shorthand"
+  ];
+
+  // core/attach-request.ts
+  function attachRequestMethod(target) {
+    Object.defineProperty(target, "$$get", {
+      value(url, options) {
+        const { params = {}, ...rest } = options;
+        const qs = handleSearchParams(params);
+        return target.instance.get(`${url}${qs ? `${`?${qs}`}` : ""}`, rest);
+      }
+    });
+    ["put", "post", "patch", "delete"].forEach((method) => {
+      Object.defineProperty(target, `$$${method}`, {
+        value(path, options) {
+          return target.instance[method](path, options);
+        }
+      });
+    });
+  }
+  function handleSearchParams(obj) {
+    if (!obj && typeof obj !== "object") {
+      throw new TypeError("params must be object.");
+    }
+    if (obj instanceof URLSearchParams) {
+      return obj.toString();
+    }
+    const search = new URLSearchParams();
+    Object.entries(obj).forEach(([k, v]) => {
+      if (typeof v === "undefined" || Object.prototype.toString.call(v) === "[object Null]") {
+        return;
+      }
+      search.set(k, v);
+    });
+    return search.toString();
+  }
+
+  // core/client.ts
+  var methodPrefix = "_$";
+  var HTTPClient = class {
+    constructor(_endpoint, _adaptor, options = {}) {
+      this._endpoint = _endpoint;
+      this._adaptor = _adaptor;
+      this.options = options;
+      this._endpoint = _endpoint.replace(/\/*$/, "").replace("localhost", "127.0.0.1");
+      this._proxy = this.buildRoute(this)();
+      options.transformResponse = options.transformResponse || ((data) => camelcaseKeys(data));
+      this.initGetClient();
+      attachRequestMethod(this);
+    }
+    initGetClient() {
+      for (const name of allContollerNames) {
+        Object.defineProperty(this, name, {
+          get() {
+            const client = Reflect.get(this, `${methodPrefix}${name}`);
+            if (!client) {
+              throw new ReferenceError(
+                `${name.charAt(0).toUpperCase() + name.slice(1)} Client not inject yet, please inject with client.injectClients(...)`
+              );
+            }
+            return client;
+          },
+          configurable: false,
+          enumerable: false
+        });
+      }
+    }
+    injectControllers(Controller, ...rest) {
+      Controller = Array.isArray(Controller) ? Controller : [Controller, ...rest];
+      for (const Client of Controller) {
+        const cl = new Client(this);
+        if (Array.isArray(cl.name)) {
+          for (const name of cl.name) {
+            attach.call(this, name, cl);
+          }
+        } else {
+          attach.call(this, cl.name, cl);
+        }
+      }
+      function attach(name, cl) {
+        Object.defineProperty(this, `${methodPrefix}${name.toLowerCase()}`, {
+          get() {
+            return cl;
+          },
+          enumerable: false,
+          configurable: false
+        });
+      }
+    }
+    get endpoint() {
+      return this._endpoint;
+    }
+    get instance() {
+      return this._adaptor;
+    }
+    request(options) {
+      return this[`$$${String(options.method || "get").toLowerCase()}`](
+        options.url,
+        options
+      );
+    }
+    get proxy() {
+      return this._proxy;
+    }
+    buildRoute(manager) {
+      const noop = () => {
+      };
+      const methods = ["get", "post", "delete", "patch", "put"];
+      const reflectors = [
+        "toString",
+        "valueOf",
+        "inspect",
+        "constructor",
+        Symbol.toPrimitive
+      ];
+      const that = this;
+      return () => {
+        const route = [""];
+        const handler = {
+          get(target, name) {
+            if (reflectors.includes(name))
+              return (withBase) => {
+                if (withBase) {
+                  const path = resolveFullPath(that.endpoint, route.join("/"));
+                  route.length = 0;
+                  return path;
+                } else {
+                  const path = route.join("/");
+                  route.length = 0;
+                  return path.startsWith("/") ? path : `/${path}`;
+                }
+              };
+            if (methods.includes(name)) {
+              return async (options) => {
+                const url = resolveFullPath(that.endpoint, route.join("/"));
+                route.length = 0;
+                let res;
+                try {
+                  res = await manager.request({
+                    method: name,
+                    ...options,
+                    url
+                  });
+                } catch (e) {
+                  let message = e.message;
+                  let code = e.code || e.status || e.statusCode || e.response?.status || e.response?.statusCode || e.response?.code || 500;
+                  if (that.options.getCodeMessageFromException) {
+                    const errorInfo = that.options.getCodeMessageFromException(e);
+                    message = errorInfo.message || message;
+                    code = errorInfo.code || code;
+                  }
+                  throw that.options.customThrowResponseError ? that.options.customThrowResponseError(e) : new RequestError(message, code, url, e);
+                }
+                const data = res.data;
+                if (!data) {
+                  return null;
+                }
+                const transform = (Array.isArray(data) || isPlainObject(data)) && that.options.transformResponse ? that.options.transformResponse(data) : data;
+                if (transform && typeof transform === "object") {
+                  Object.defineProperty(transform, "$raw", {
+                    get() {
+                      return res;
+                    },
+                    enumerable: false,
+                    configurable: false
+                  });
+                  Object.defineProperty(transform, "$request", {
+                    get() {
+                      return {
+                        url,
+                        method: name,
+                        options
+                      };
+                    },
+                    enumerable: false
+                  });
+                }
+                return transform;
+              };
+            }
+            route.push(name);
+            return new Proxy(noop, handler);
+          },
+          apply(target, _, args) {
+            route.push(...args.filter((x) => x !== null));
+            return new Proxy(noop, handler);
+          }
+        };
+        return new Proxy(noop, handler);
+      };
+    }
+  };
+  function createClient(adapter) {
+    return (endpoint, options) => {
+      const client = new HTTPClient(
+        endpoint,
+        adapter,
+        options
+      );
+      const { controllers } = options || {};
+      if (controllers) {
+        client.injectControllers(controllers);
+      }
+      return client;
+    };
+  }
+
+  // models/aggregate.ts
+  var TimelineType = /* @__PURE__ */ ((TimelineType2) => {
+    TimelineType2[TimelineType2["Post"] = 0] = "Post";
+    TimelineType2[TimelineType2["Note"] = 1] = "Note";
+    return TimelineType2;
+  })(TimelineType || {});
+
+  // models/comment.ts
+  var RefType = /* @__PURE__ */ ((RefType2) => {
+    RefType2["Page"] = "Page";
+    RefType2["Post"] = "Post";
+    RefType2["Note"] = "Note";
+    return RefType2;
+  })(RefType || {});
+  var CommentState = /* @__PURE__ */ ((CommentState2) => {
+    CommentState2[CommentState2["Unread"] = 0] = "Unread";
+    CommentState2[CommentState2["Read"] = 1] = "Read";
+    CommentState2[CommentState2["Junk"] = 2] = "Junk";
+    return CommentState2;
+  })(CommentState || {});
+
+  // models/link.ts
+  var LinkType = /* @__PURE__ */ ((LinkType2) => {
+    LinkType2[LinkType2["Friend"] = 0] = "Friend";
+    LinkType2[LinkType2["Collection"] = 1] = "Collection";
+    return LinkType2;
+  })(LinkType || {});
+  var LinkState = /* @__PURE__ */ ((LinkState2) => {
+    LinkState2[LinkState2["Pass"] = 0] = "Pass";
+    LinkState2[LinkState2["Audit"] = 1] = "Audit";
+    LinkState2[LinkState2["Outdate"] = 2] = "Outdate";
+    LinkState2[LinkState2["Banned"] = 3] = "Banned";
+    LinkState2[LinkState2["Reject"] = 4] = "Reject";
+    return LinkState2;
+  })(LinkState || {});
+
+  // models/page.ts
+  var EnumPageType = /* @__PURE__ */ ((EnumPageType2) => {
+    EnumPageType2["md"] = "md";
+    EnumPageType2["html"] = "html";
+    EnumPageType2["frame"] = "frame";
+    return EnumPageType2;
+  })(EnumPageType || {});
+
+  // models/recently.ts
+  var RecentlyRefTypes = /* @__PURE__ */ ((RecentlyRefTypes2) => {
+    RecentlyRefTypes2["Post"] = "Post";
+    RecentlyRefTypes2["Note"] = "Note";
+    RecentlyRefTypes2["Page"] = "Page";
+    return RecentlyRefTypes2;
+  })(RecentlyRefTypes || {});
+
+  // models/snippet.ts
+  var SnippetType = /* @__PURE__ */ ((SnippetType2) => {
+    SnippetType2["JSON"] = "json";
+    SnippetType2["Function"] = "function";
+    SnippetType2["Text"] = "text";
+    SnippetType2["YAML"] = "yaml";
+    return SnippetType2;
+  })(SnippetType || {});
+
+  // dtos/comment.ts
+  var CommentDto = class {
+  };
+
+  // index.ts
+  var api_client_default = createClient;
+})();