@omniviewdev/runtime 0.0.0-nightly.20260225

package/dist/models.js

@@ -0,0 +1,1915 @@
+var $ = Object.defineProperty;
+var tt = (a, p, f) => p in a ? $(a, p, { enumerable: !0, configurable: !0, writable: !0, value: f }) : a[p] = f;
+var e = (a, p, f) => tt(a, typeof p != "symbol" ? p + "" : p, f);
+var k;
+((a) => {
+  class p {
+    constructor(s = {}) {
+      e(this, "name");
+      e(this, "email");
+      e(this, "url");
+      typeof s == "string" && (s = JSON.parse(s)), this.name = s.name, this.email = s.email, this.url = s.url;
+    }
+    static createFrom(s = {}) {
+      return new p(s);
+    }
+  }
+  a.PluginAuthor = p;
+  class f {
+    constructor(s = {}) {
+      e(this, "name");
+      e(this, "plugin");
+      e(this, "area");
+      e(this, "resources");
+      e(this, "extension");
+      typeof s == "string" && (s = JSON.parse(s)), this.name = s.name, this.plugin = s.plugin, this.area = s.area, this.resources = s.resources, this.extension = s.extension;
+    }
+    static createFrom(s = {}) {
+      return new f(s);
+    }
+  }
+  a.PluginResourceComponent = f;
+  class l {
+    constructor(s = {}) {
+      e(this, "resource");
+      typeof s == "string" && (s = JSON.parse(s)), this.resource = this.convertValues(s.resource, f);
+    }
+    static createFrom(s = {}) {
+      return new l(s);
+    }
+    convertValues(s, c, _ = !1) {
+      if (!s)
+        return s;
+      if (s.slice && s.map)
+        return s.map((w) => this.convertValues(w, c));
+      if (typeof s == "object") {
+        if (_) {
+          for (const w of Object.keys(s))
+            s[w] = new c(s[w]);
+          return s;
+        }
+        return new c(s);
+      }
+      return s;
+    }
+  }
+  a.PluginComponents = l;
+  class o {
+    constructor(s = {}) {
+      e(this, "name");
+      e(this, "email");
+      typeof s == "string" && (s = JSON.parse(s)), this.name = s.name, this.email = s.email;
+    }
+    static createFrom(s = {}) {
+      return new o(s);
+    }
+  }
+  a.PluginMaintainer = o;
+  class g {
+    constructor(s = {}) {
+      e(this, "primary");
+      e(this, "secondary");
+      e(this, "tertiary");
+      typeof s == "string" && (s = JSON.parse(s)), this.primary = s.primary, this.secondary = s.secondary, this.tertiary = s.tertiary;
+    }
+    static createFrom(s = {}) {
+      return new g(s);
+    }
+  }
+  a.PluginThemeColors = g;
+  class r {
+    constructor(s = {}) {
+      e(this, "colors");
+      typeof s == "string" && (s = JSON.parse(s)), this.colors = this.convertValues(s.colors, g);
+    }
+    static createFrom(s = {}) {
+      return new r(s);
+    }
+    convertValues(s, c, _ = !1) {
+      if (!s)
+        return s;
+      if (s.slice && s.map)
+        return s.map((w) => this.convertValues(w, c));
+      if (typeof s == "object") {
+        if (_) {
+          for (const w of Object.keys(s))
+            s[w] = new c(s[w]);
+          return s;
+        }
+        return new c(s);
+      }
+      return s;
+    }
+  }
+  a.PluginTheme = r;
+  class i {
+    constructor(s = {}) {
+      e(this, "id");
+      e(this, "version");
+      e(this, "name");
+      e(this, "icon");
+      e(this, "icon_url");
+      e(this, "description");
+      e(this, "repository");
+      e(this, "website");
+      e(this, "category");
+      e(this, "license");
+      e(this, "author");
+      e(this, "maintainers");
+      e(this, "tags");
+      e(this, "dependencies");
+      e(this, "capabilities");
+      e(this, "theme");
+      e(this, "components");
+      typeof s == "string" && (s = JSON.parse(s)), this.id = s.id, this.version = s.version, this.name = s.name, this.icon = s.icon, this.icon_url = s.icon_url, this.description = s.description, this.repository = s.repository, this.website = s.website, this.category = s.category, this.license = s.license, this.author = this.convertValues(s.author, p), this.maintainers = this.convertValues(s.maintainers, o), this.tags = s.tags, this.dependencies = s.dependencies, this.capabilities = s.capabilities, this.theme = this.convertValues(s.theme, r), this.components = this.convertValues(s.components, l);
+    }
+    static createFrom(s = {}) {
+      return new i(s);
+    }
+    convertValues(s, c, _ = !1) {
+      if (!s)
+        return s;
+      if (s.slice && s.map)
+        return s.map((w) => this.convertValues(w, c));
+      if (typeof s == "object") {
+        if (_) {
+          for (const w of Object.keys(s))
+            s[w] = new c(s[w]);
+          return s;
+        }
+        return new c(s);
+      }
+      return s;
+    }
+  }
+  a.PluginMeta = i;
+})(k || (k = {}));
+var U;
+((a) => {
+  class p {
+    constructor(r = {}) {
+      e(this, "pid");
+      e(this, "protocol");
+      e(this, "protocolVersion");
+      e(this, "addr");
+      e(this, "vitePort");
+      e(this, "pluginId");
+      e(this, "version");
+      e(this, "startedAt");
+      typeof r == "string" && (r = JSON.parse(r)), this.pid = r.pid, this.protocol = r.protocol, this.protocolVersion = r.protocolVersion, this.addr = r.addr, this.vitePort = r.vitePort, this.pluginId = r.pluginId, this.version = r.version, this.startedAt = r.startedAt;
+    }
+    static createFrom(r = {}) {
+      return new p(r);
+    }
+  }
+  a.DevInfoFile = p;
+  class f {
+    static createFrom(r = {}) {
+      return new f(r);
+    }
+    constructor(r = {}) {
+      typeof r == "string" && (r = JSON.parse(r));
+    }
+  }
+  a.DevServerManager = f;
+  class l {
+    constructor(r = {}) {
+      e(this, "pluginID");
+      e(this, "mode");
+      e(this, "devPath");
+      e(this, "vitePort");
+      e(this, "viteURL");
+      e(this, "viteStatus");
+      e(this, "goStatus");
+      e(this, "lastBuildDuration");
+      e(this, "lastBuildTime");
+      e(this, "lastError");
+      e(this, "grpcConnected");
+      typeof r == "string" && (r = JSON.parse(r)), this.pluginID = r.pluginID, this.mode = r.mode, this.devPath = r.devPath, this.vitePort = r.vitePort, this.viteURL = r.viteURL, this.viteStatus = r.viteStatus, this.goStatus = r.goStatus, this.lastBuildDuration = r.lastBuildDuration, this.lastBuildTime = this.convertValues(r.lastBuildTime, O.Time), this.lastError = r.lastError, this.grpcConnected = r.grpcConnected;
+    }
+    static createFrom(r = {}) {
+      return new l(r);
+    }
+    convertValues(r, i, m = !1) {
+      if (!r)
+        return r;
+      if (r.slice && r.map)
+        return r.map((s) => this.convertValues(s, i));
+      if (typeof r == "object") {
+        if (m) {
+          for (const s of Object.keys(r))
+            r[s] = new i(r[s]);
+          return r;
+        }
+        return new i(r);
+      }
+      return r;
+    }
+  }
+  a.DevServerState = l;
+  class o {
+    constructor(r = {}) {
+      e(this, "timestamp");
+      e(this, "source");
+      e(this, "level");
+      e(this, "message");
+      e(this, "pluginID");
+      typeof r == "string" && (r = JSON.parse(r)), this.timestamp = this.convertValues(r.timestamp, O.Time), this.source = r.source, this.level = r.level, this.message = r.message, this.pluginID = r.pluginID;
+    }
+    static createFrom(r = {}) {
+      return new o(r);
+    }
+    convertValues(r, i, m = !1) {
+      if (!r)
+        return r;
+      if (r.slice && r.map)
+        return r.map((s) => this.convertValues(s, i));
+      if (typeof r == "object") {
+        if (m) {
+          for (const s of Object.keys(r))
+            r[s] = new i(r[s]);
+          return r;
+        }
+        return new i(r);
+      }
+      return r;
+    }
+  }
+  a.LogEntry = o;
+})(U || (U = {}));
+var B;
+((a) => {
+  class p {
+    constructor(i = {}) {
+      e(this, "created_at");
+      e(this, "labels");
+      e(this, "params");
+      e(this, "id");
+      e(this, "command");
+      e(this, "attached");
+      typeof i == "string" && (i = JSON.parse(i)), this.created_at = this.convertValues(i.created_at, O.Time), this.labels = i.labels, this.params = i.params, this.id = i.id, this.command = i.command, this.attached = i.attached;
+    }
+    static createFrom(i = {}) {
+      return new p(i);
+    }
+    convertValues(i, m, s = !1) {
+      if (!i)
+        return i;
+      if (i.slice && i.map)
+        return i.map((c) => this.convertValues(c, m));
+      if (typeof i == "object") {
+        if (s) {
+          for (const c of Object.keys(i))
+            i[c] = new m(i[c]);
+          return i;
+        }
+        return new m(i);
+      }
+      return i;
+    }
+  }
+  a.Session = p;
+  class f {
+    constructor(i = {}) {
+      e(this, "session");
+      e(this, "buffer");
+      typeof i == "string" && (i = JSON.parse(i)), this.session = this.convertValues(i.session, p), this.buffer = i.buffer;
+    }
+    static createFrom(i = {}) {
+      return new f(i);
+    }
+    convertValues(i, m, s = !1) {
+      if (!i)
+        return i;
+      if (i.slice && i.map)
+        return i.map((c) => this.convertValues(c, m));
+      if (typeof i == "object") {
+        if (s) {
+          for (const c of Object.keys(i))
+            i[c] = new m(i[c]);
+          return i;
+        }
+        return new m(i);
+      }
+      return i;
+    }
+  }
+  a.AttachSessionResult = f;
+  class l {
+    constructor(i = {}) {
+      e(this, "labels");
+      e(this, "command");
+      typeof i == "string" && (i = JSON.parse(i)), this.labels = i.labels, this.command = i.command;
+    }
+    static createFrom(i = {}) {
+      return new l(i);
+    }
+  }
+  a.CreateTerminalOptions = l;
+  class o {
+    constructor(i = {}) {
+      e(this, "plugin");
+      e(this, "resource");
+      e(this, "target_builder");
+      e(this, "default_command");
+      typeof i == "string" && (i = JSON.parse(i)), this.plugin = i.plugin, this.resource = i.resource, this.target_builder = this.convertValues(i.target_builder, S.ActionTargetBuilder), this.default_command = i.default_command;
+    }
+    static createFrom(i = {}) {
+      return new o(i);
+    }
+    convertValues(i, m, s = !1) {
+      if (!i)
+        return i;
+      if (i.slice && i.map)
+        return i.map((c) => this.convertValues(c, m));
+      if (typeof i == "object") {
+        if (s) {
+          for (const c of Object.keys(i))
+            i[c] = new m(i[c]);
+          return i;
+        }
+        return new m(i);
+      }
+      return i;
+    }
+  }
+  a.Handler = o;
+  class g {
+    constructor(i = {}) {
+      e(this, "params");
+      e(this, "labels");
+      e(this, "id");
+      e(this, "resource_plugin");
+      e(this, "resource_key");
+      e(this, "resource_data");
+      e(this, "command");
+      e(this, "tty");
+      typeof i == "string" && (i = JSON.parse(i)), this.params = i.params, this.labels = i.labels, this.id = i.id, this.resource_plugin = i.resource_plugin, this.resource_key = i.resource_key, this.resource_data = i.resource_data, this.command = i.command, this.tty = i.tty;
+    }
+    static createFrom(i = {}) {
+      return new g(i);
+    }
+  }
+  a.SessionOptions = g;
+})(B || (B = {}));
+var G;
+((a) => {
+  class p {
+    constructor(i = {}) {
+      e(this, "target");
+      e(this, "follow");
+      e(this, "include_previous");
+      e(this, "include_timestamps");
+      e(this, "tail_lines");
+      e(this, "since_seconds");
+      e(this, "since_time");
+      e(this, "limit_bytes");
+      e(this, "include_source_events");
+      e(this, "params");
+      typeof i == "string" && (i = JSON.parse(i)), this.target = i.target, this.follow = i.follow, this.include_previous = i.include_previous, this.include_timestamps = i.include_timestamps, this.tail_lines = i.tail_lines, this.since_seconds = i.since_seconds, this.since_time = this.convertValues(i.since_time, O.Time), this.limit_bytes = i.limit_bytes, this.include_source_events = i.include_source_events, this.params = i.params;
+    }
+    static createFrom(i = {}) {
+      return new p(i);
+    }
+    convertValues(i, m, s = !1) {
+      if (!i)
+        return i;
+      if (i.slice && i.map)
+        return i.map((c) => this.convertValues(c, m));
+      if (typeof i == "object") {
+        if (s) {
+          for (const c of Object.keys(i))
+            i[c] = new m(i[c]);
+          return i;
+        }
+        return new m(i);
+      }
+      return i;
+    }
+  }
+  a.LogSessionOptions = p;
+  class f {
+    constructor(i = {}) {
+      e(this, "resource_key");
+      e(this, "resource_id");
+      e(this, "resource_data");
+      e(this, "options");
+      typeof i == "string" && (i = JSON.parse(i)), this.resource_key = i.resource_key, this.resource_id = i.resource_id, this.resource_data = i.resource_data, this.options = this.convertValues(i.options, p);
+    }
+    static createFrom(i = {}) {
+      return new f(i);
+    }
+    convertValues(i, m, s = !1) {
+      if (!i)
+        return i;
+      if (i.slice && i.map)
+        return i.map((c) => this.convertValues(c, m));
+      if (typeof i == "object") {
+        if (s) {
+          for (const c of Object.keys(i))
+            i[c] = new m(i[c]);
+          return i;
+        }
+        return new m(i);
+      }
+      return i;
+    }
+  }
+  a.CreateSessionOptions = f;
+  class l {
+    constructor(i = {}) {
+      e(this, "plugin");
+      e(this, "resource");
+      e(this, "target_builder");
+      typeof i == "string" && (i = JSON.parse(i)), this.plugin = i.plugin, this.resource = i.resource, this.target_builder = this.convertValues(i.target_builder, S.ActionTargetBuilder);
+    }
+    static createFrom(i = {}) {
+      return new l(i);
+    }
+    convertValues(i, m, s = !1) {
+      if (!i)
+        return i;
+      if (i.slice && i.map)
+        return i.map((c) => this.convertValues(c, m));
+      if (typeof i == "object") {
+        if (s) {
+          for (const c of Object.keys(i))
+            i[c] = new m(i[c]);
+          return i;
+        }
+        return new m(i);
+      }
+      return i;
+    }
+  }
+  a.Handler = l;
+  class o {
+    constructor(i = {}) {
+      e(this, "id");
+      e(this, "labels");
+      typeof i == "string" && (i = JSON.parse(i)), this.id = i.id, this.labels = i.labels;
+    }
+    static createFrom(i = {}) {
+      return new o(i);
+    }
+  }
+  a.LogSource = o;
+  class g {
+    constructor(i = {}) {
+      e(this, "id");
+      e(this, "plugin_id");
+      e(this, "connection_id");
+      e(this, "resource_key");
+      e(this, "resource_id");
+      e(this, "options");
+      e(this, "status");
+      e(this, "active_sources");
+      e(this, "created_at");
+      typeof i == "string" && (i = JSON.parse(i)), this.id = i.id, this.plugin_id = i.plugin_id, this.connection_id = i.connection_id, this.resource_key = i.resource_key, this.resource_id = i.resource_id, this.options = this.convertValues(i.options, p), this.status = i.status, this.active_sources = this.convertValues(i.active_sources, o), this.created_at = this.convertValues(i.created_at, O.Time);
+    }
+    static createFrom(i = {}) {
+      return new g(i);
+    }
+    convertValues(i, m, s = !1) {
+      if (!i)
+        return i;
+      if (i.slice && i.map)
+        return i.map((c) => this.convertValues(c, m));
+      if (typeof i == "object") {
+        if (s) {
+          for (const c of Object.keys(i))
+            i[c] = new m(i[c]);
+          return i;
+        }
+        return new m(i);
+      }
+      return i;
+    }
+  }
+  a.LogSession = g;
+})(G || (G = {}));
+var z;
+((a) => {
+  class p {
+    constructor(o = {}) {
+      e(this, "displayName");
+      e(this, "pattern");
+      typeof o == "string" && (o = JSON.parse(o)), this.displayName = o.displayName, this.pattern = o.pattern;
+    }
+    static createFrom(o = {}) {
+      return new p(o);
+    }
+  }
+  a.FileFilter = p;
+  class f {
+    constructor(o = {}) {
+      e(this, "defaultDirectory");
+      e(this, "defaultFilename");
+      e(this, "title");
+      e(this, "filters");
+      e(this, "showHiddenFiles");
+      e(this, "canCreateDirectories");
+      e(this, "resolvesAliases");
+      e(this, "treatPackagesAsDirectories");
+      typeof o == "string" && (o = JSON.parse(o)), this.defaultDirectory = o.defaultDirectory, this.defaultFilename = o.defaultFilename, this.title = o.title, this.filters = this.convertValues(o.filters, p), this.showHiddenFiles = o.showHiddenFiles, this.canCreateDirectories = o.canCreateDirectories, this.resolvesAliases = o.resolvesAliases, this.treatPackagesAsDirectories = o.treatPackagesAsDirectories;
+    }
+    static createFrom(o = {}) {
+      return new f(o);
+    }
+    convertValues(o, g, r = !1) {
+      if (!o)
+        return o;
+      if (o.slice && o.map)
+        return o.map((i) => this.convertValues(i, g));
+      if (typeof o == "object") {
+        if (r) {
+          for (const i of Object.keys(o))
+            o[i] = new g(o[i]);
+          return o;
+        }
+        return new g(o);
+      }
+      return o;
+    }
+  }
+  a.FileDialogOptions = f;
+})(z || (z = {}));
+var K;
+((a) => {
+  class p {
+    constructor(n = {}) {
+      e(this, "metric_id");
+      e(this, "min");
+      e(this, "max");
+      e(this, "avg");
+      e(this, "sum");
+      e(this, "p50");
+      e(this, "p90");
+      e(this, "p99");
+      e(this, "count");
+      e(this, "window");
+      e(this, "labels");
+      typeof n == "string" && (n = JSON.parse(n)), this.metric_id = n.metric_id, this.min = n.min, this.max = n.max, this.avg = n.avg, this.sum = n.sum, this.p50 = n.p50, this.p90 = n.p90, this.p99 = n.p99, this.count = n.count, this.window = n.window, this.labels = n.labels;
+    }
+    static createFrom(n = {}) {
+      return new p(n);
+    }
+  }
+  a.AggregateValue = p;
+  class f {
+    constructor(n = {}) {
+      e(this, "min");
+      e(this, "max");
+      e(this, "color");
+      typeof n == "string" && (n = JSON.parse(n)), this.min = n.min, this.max = n.max, this.color = n.color;
+    }
+    static createFrom(n = {}) {
+      return new f(n);
+    }
+  }
+  a.ColorRange = f;
+  class l {
+    constructor(n = {}) {
+      e(this, "metric_id");
+      e(this, "value");
+      e(this, "timestamp");
+      e(this, "labels");
+      typeof n == "string" && (n = JSON.parse(n)), this.metric_id = n.metric_id, this.value = n.value, this.timestamp = this.convertValues(n.timestamp, O.Time), this.labels = n.labels;
+    }
+    static createFrom(n = {}) {
+      return new l(n);
+    }
+    convertValues(n, y, b = !1) {
+      if (!n)
+        return n;
+      if (n.slice && n.map)
+        return n.map((d) => this.convertValues(d, y));
+      if (typeof n == "object") {
+        if (b) {
+          for (const d of Object.keys(n))
+            n[d] = new y(n[d]);
+          return n;
+        }
+        return new y(n);
+      }
+      return n;
+    }
+  }
+  a.CurrentValue = l;
+  class o {
+    constructor(n = {}) {
+      e(this, "timestamp");
+      e(this, "value");
+      e(this, "labels");
+      typeof n == "string" && (n = JSON.parse(n)), this.timestamp = this.convertValues(n.timestamp, O.Time), this.value = n.value, this.labels = n.labels;
+    }
+    static createFrom(n = {}) {
+      return new o(n);
+    }
+    convertValues(n, y, b = !1) {
+      if (!n)
+        return n;
+      if (n.slice && n.map)
+        return n.map((d) => this.convertValues(d, y));
+      if (typeof n == "object") {
+        if (b) {
+          for (const d of Object.keys(n))
+            n[d] = new y(n[d]);
+          return n;
+        }
+        return new y(n);
+      }
+      return n;
+    }
+  }
+  a.DataPoint = o;
+  class g {
+    constructor(n = {}) {
+      e(this, "id");
+      e(this, "name");
+      e(this, "unit");
+      e(this, "icon");
+      e(this, "color_ranges");
+      e(this, "format_string");
+      e(this, "supported_shapes");
+      e(this, "chart_group");
+      typeof n == "string" && (n = JSON.parse(n)), this.id = n.id, this.name = n.name, this.unit = n.unit, this.icon = n.icon, this.color_ranges = this.convertValues(n.color_ranges, f), this.format_string = n.format_string, this.supported_shapes = n.supported_shapes, this.chart_group = n.chart_group;
+    }
+    static createFrom(n = {}) {
+      return new g(n);
+    }
+    convertValues(n, y, b = !1) {
+      if (!n)
+        return n;
+      if (n.slice && n.map)
+        return n.map((d) => this.convertValues(d, y));
+      if (typeof n == "object") {
+        if (b) {
+          for (const d of Object.keys(n))
+            n[d] = new y(n[d]);
+          return n;
+        }
+        return new y(n);
+      }
+      return n;
+    }
+  }
+  a.MetricDescriptor = g;
+  class r {
+    constructor(n = {}) {
+      e(this, "resource");
+      e(this, "metrics");
+      typeof n == "string" && (n = JSON.parse(n)), this.resource = n.resource, this.metrics = this.convertValues(n.metrics, g);
+    }
+    static createFrom(n = {}) {
+      return new r(n);
+    }
+    convertValues(n, y, b = !1) {
+      if (!n)
+        return n;
+      if (n.slice && n.map)
+        return n.map((d) => this.convertValues(d, y));
+      if (typeof n == "object") {
+        if (b) {
+          for (const d of Object.keys(n))
+            n[d] = new y(n[d]);
+          return n;
+        }
+        return new y(n);
+      }
+      return n;
+    }
+  }
+  a.Handler = r;
+  class i {
+    constructor(n = {}) {
+      e(this, "plugin_id");
+      e(this, "provider_id");
+      e(this, "name");
+      e(this, "icon");
+      e(this, "description");
+      e(this, "handlers");
+      typeof n == "string" && (n = JSON.parse(n)), this.plugin_id = n.plugin_id, this.provider_id = n.provider_id, this.name = n.name, this.icon = n.icon, this.description = n.description, this.handlers = this.convertValues(n.handlers, r);
+    }
+    static createFrom(n = {}) {
+      return new i(n);
+    }
+    convertValues(n, y, b = !1) {
+      if (!n)
+        return n;
+      if (n.slice && n.map)
+        return n.map((d) => this.convertValues(d, y));
+      if (typeof n == "object") {
+        if (b) {
+          for (const d of Object.keys(n))
+            n[d] = new y(n[d]);
+          return n;
+        }
+        return new y(n);
+      }
+      return n;
+    }
+  }
+  a.MetricProviderSummary = i;
+  class m {
+    constructor(n = {}) {
+      e(this, "metric_id");
+      e(this, "data_points");
+      e(this, "labels");
+      typeof n == "string" && (n = JSON.parse(n)), this.metric_id = n.metric_id, this.data_points = this.convertValues(n.data_points, o), this.labels = n.labels;
+    }
+    static createFrom(n = {}) {
+      return new m(n);
+    }
+    convertValues(n, y, b = !1) {
+      if (!n)
+        return n;
+      if (n.slice && n.map)
+        return n.map((d) => this.convertValues(d, y));
+      if (typeof n == "object") {
+        if (b) {
+          for (const d of Object.keys(n))
+            n[d] = new y(n[d]);
+          return n;
+        }
+        return new y(n);
+      }
+      return n;
+    }
+  }
+  a.TimeSeries = m;
+  class s {
+    constructor(n = {}) {
+      e(this, "time_series");
+      e(this, "current_value");
+      e(this, "aggregate_value");
+      typeof n == "string" && (n = JSON.parse(n)), this.time_series = this.convertValues(n.time_series, m), this.current_value = this.convertValues(n.current_value, l), this.aggregate_value = this.convertValues(n.aggregate_value, p);
+    }
+    static createFrom(n = {}) {
+      return new s(n);
+    }
+    convertValues(n, y, b = !1) {
+      if (!n)
+        return n;
+      if (n.slice && n.map)
+        return n.map((d) => this.convertValues(d, y));
+      if (typeof n == "object") {
+        if (b) {
+          for (const d of Object.keys(n))
+            n[d] = new y(n[d]);
+          return n;
+        }
+        return new y(n);
+      }
+      return n;
+    }
+  }
+  a.MetricResult = s;
+  class c {
+    constructor(n = {}) {
+      e(this, "resource_key");
+      e(this, "resource_id");
+      e(this, "resource_namespace");
+      e(this, "resource_data");
+      e(this, "metric_ids");
+      e(this, "shape");
+      e(this, "start_time");
+      e(this, "end_time");
+      e(this, "step");
+      e(this, "params");
+      typeof n == "string" && (n = JSON.parse(n)), this.resource_key = n.resource_key, this.resource_id = n.resource_id, this.resource_namespace = n.resource_namespace, this.resource_data = n.resource_data, this.metric_ids = n.metric_ids, this.shape = n.shape, this.start_time = this.convertValues(n.start_time, O.Time), this.end_time = this.convertValues(n.end_time, O.Time), this.step = n.step, this.params = n.params;
+    }
+    static createFrom(n = {}) {
+      return new c(n);
+    }
+    convertValues(n, y, b = !1) {
+      if (!n)
+        return n;
+      if (n.slice && n.map)
+        return n.map((d) => this.convertValues(d, y));
+      if (typeof n == "object") {
+        if (b) {
+          for (const d of Object.keys(n))
+            n[d] = new y(n[d]);
+          return n;
+        }
+        return new y(n);
+      }
+      return n;
+    }
+  }
+  a.QueryRequest = c;
+  class _ {
+    constructor(n = {}) {
+      e(this, "success");
+      e(this, "results");
+      e(this, "error");
+      typeof n == "string" && (n = JSON.parse(n)), this.success = n.success, this.results = this.convertValues(n.results, s), this.error = n.error;
+    }
+    static createFrom(n = {}) {
+      return new _(n);
+    }
+    convertValues(n, y, b = !1) {
+      if (!n)
+        return n;
+      if (n.slice && n.map)
+        return n.map((d) => this.convertValues(d, y));
+      if (typeof n == "object") {
+        if (b) {
+          for (const d of Object.keys(n))
+            n[d] = new y(n[d]);
+          return n;
+        }
+        return new y(n);
+      }
+      return n;
+    }
+  }
+  a.QueryResponse = _;
+  class w {
+    constructor(n = {}) {
+      e(this, "resource_key");
+      e(this, "resource_id");
+      e(this, "resource_namespace");
+      e(this, "resource_data");
+      e(this, "metric_ids");
+      e(this, "interval");
+      typeof n == "string" && (n = JSON.parse(n)), this.resource_key = n.resource_key, this.resource_id = n.resource_id, this.resource_namespace = n.resource_namespace, this.resource_data = n.resource_data, this.metric_ids = n.metric_ids, this.interval = n.interval;
+    }
+    static createFrom(n = {}) {
+      return new w(n);
+    }
+  }
+  a.SubscribeRequest = w;
+})(K || (K = {}));
+var H;
+((a) => {
+  class p {
+    constructor(r = {}) {
+      e(this, "resource_id");
+      e(this, "connection_id");
+      typeof r == "string" && (r = JSON.parse(r)), this.resource_id = r.resource_id, this.connection_id = r.connection_id;
+    }
+    static createFrom(r = {}) {
+      return new p(r);
+    }
+  }
+  a.FindPortForwardSessionRequest = p;
+  class f {
+    constructor(r = {}) {
+      e(this, "algorithm");
+      e(this, "key");
+      e(this, "enabled");
+      typeof r == "string" && (r = JSON.parse(r)), this.algorithm = r.algorithm, this.key = r.key, this.enabled = r.enabled;
+    }
+    static createFrom(r = {}) {
+      return new f(r);
+    }
+  }
+  a.PortForwardSessionEncryption = f;
+  class l {
+    constructor(r = {}) {
+      e(this, "created_at");
+      e(this, "updated_at");
+      e(this, "connection");
+      e(this, "labels");
+      e(this, "id");
+      e(this, "protocol");
+      e(this, "state");
+      e(this, "connection_type");
+      e(this, "encryption");
+      e(this, "local_port");
+      e(this, "remote_port");
+      typeof r == "string" && (r = JSON.parse(r)), this.created_at = this.convertValues(r.created_at, O.Time), this.updated_at = this.convertValues(r.updated_at, O.Time), this.connection = r.connection, this.labels = r.labels, this.id = r.id, this.protocol = r.protocol, this.state = r.state, this.connection_type = r.connection_type, this.encryption = this.convertValues(r.encryption, f), this.local_port = r.local_port, this.remote_port = r.remote_port;
+    }
+    static createFrom(r = {}) {
+      return new l(r);
+    }
+    convertValues(r, i, m = !1) {
+      if (!r)
+        return r;
+      if (r.slice && r.map)
+        return r.map((s) => this.convertValues(s, i));
+      if (typeof r == "object") {
+        if (m) {
+          for (const s of Object.keys(r))
+            r[s] = new i(r[s]);
+          return r;
+        }
+        return new i(r);
+      }
+      return r;
+    }
+  }
+  a.PortForwardSession = l;
+  class o {
+    constructor(r = {}) {
+      e(this, "connection");
+      e(this, "labels");
+      e(this, "params");
+      e(this, "protocol");
+      e(this, "connection_type");
+      e(this, "encryption");
+      e(this, "local_port");
+      e(this, "remote_port");
+      typeof r == "string" && (r = JSON.parse(r)), this.connection = r.connection, this.labels = r.labels, this.params = r.params, this.protocol = r.protocol, this.connection_type = r.connection_type, this.encryption = this.convertValues(r.encryption, f), this.local_port = r.local_port, this.remote_port = r.remote_port;
+    }
+    static createFrom(r = {}) {
+      return new o(r);
+    }
+    convertValues(r, i, m = !1) {
+      if (!r)
+        return r;
+      if (r.slice && r.map)
+        return r.map((s) => this.convertValues(s, i));
+      if (typeof r == "object") {
+        if (m) {
+          for (const s of Object.keys(r))
+            r[s] = new i(r[s]);
+          return r;
+        }
+        return new i(r);
+      }
+      return r;
+    }
+  }
+  a.PortForwardSessionOptions = o;
+})(H || (H = {}));
+var Q;
+((a) => {
+  class p {
+    constructor(l = {}) {
+      e(this, "DevMode");
+      e(this, "DevModePath");
+      e(this, "ExistingState");
+      typeof l == "string" && (l = JSON.parse(l)), this.DevMode = l.DevMode, this.DevModePath = l.DevModePath, this.ExistingState = this.convertValues(l.ExistingState, S.PluginState);
+    }
+    static createFrom(l = {}) {
+      return new p(l);
+    }
+    convertValues(l, o, g = !1) {
+      if (!l)
+        return l;
+      if (l.slice && l.map)
+        return l.map((r) => this.convertValues(r, o));
+      if (typeof l == "object") {
+        if (g) {
+          for (const r of Object.keys(l))
+            l[r] = new o(l[r]);
+          return l;
+        }
+        return new o(l);
+      }
+      return l;
+    }
+  }
+  a.LoadPluginOptions = p;
+})(Q || (Q = {}));
+var Y;
+((a) => {
+  class p {
+    constructor(i = {}) {
+      e(this, "id");
+      e(this, "name");
+      e(this, "description");
+      e(this, "icon_url");
+      e(this, "category");
+      e(this, "tags");
+      e(this, "license");
+      e(this, "official");
+      e(this, "featured");
+      e(this, "download_count");
+      e(this, "average_rating");
+      e(this, "review_count");
+      e(this, "repository");
+      e(this, "url");
+      e(this, "installed");
+      e(this, "installed_version");
+      e(this, "latest_version");
+      e(this, "update_available");
+      typeof i == "string" && (i = JSON.parse(i)), this.id = i.id, this.name = i.name, this.description = i.description, this.icon_url = i.icon_url, this.category = i.category, this.tags = i.tags, this.license = i.license, this.official = i.official, this.featured = i.featured, this.download_count = i.download_count, this.average_rating = i.average_rating, this.review_count = i.review_count, this.repository = i.repository, this.url = i.url, this.installed = i.installed, this.installed_version = i.installed_version, this.latest_version = i.latest_version, this.update_available = i.update_available;
+    }
+    static createFrom(i = {}) {
+      return new p(i);
+    }
+  }
+  a.AvailablePlugin = p;
+  class f {
+    constructor(i = {}) {
+      e(this, "date");
+      e(this, "count");
+      typeof i == "string" && (i = JSON.parse(i)), this.date = i.date, this.count = i.count;
+    }
+    static createFrom(i = {}) {
+      return new f(i);
+    }
+  }
+  a.DailyStat = f;
+  class l {
+    constructor(i = {}) {
+      e(this, "total");
+      e(this, "last_month");
+      e(this, "last_week");
+      e(this, "daily_stats");
+      typeof i == "string" && (i = JSON.parse(i)), this.total = i.total, this.last_month = i.last_month, this.last_week = i.last_week, this.daily_stats = this.convertValues(i.daily_stats, f);
+    }
+    static createFrom(i = {}) {
+      return new l(i);
+    }
+    convertValues(i, m, s = !1) {
+      if (!i)
+        return i;
+      if (i.slice && i.map)
+        return i.map((c) => this.convertValues(c, m));
+      if (typeof i == "object") {
+        if (s) {
+          for (const c of Object.keys(i))
+            i[c] = new m(i[c]);
+          return i;
+        }
+        return new m(i);
+      }
+      return i;
+    }
+  }
+  a.DownloadStats = l;
+  class o {
+    constructor(i = {}) {
+      e(this, "id");
+      e(this, "user_id");
+      e(this, "rating");
+      e(this, "title");
+      e(this, "body");
+      e(this, "created_at");
+      typeof i == "string" && (i = JSON.parse(i)), this.id = i.id, this.user_id = i.user_id, this.rating = i.rating, this.title = i.title, this.body = i.body, this.created_at = i.created_at;
+    }
+    static createFrom(i = {}) {
+      return new o(i);
+    }
+  }
+  a.Review = o;
+  class g {
+    constructor(i = {}) {
+      e(this, "version");
+      e(this, "description");
+      e(this, "changelog");
+      e(this, "min_ide_version");
+      e(this, "max_ide_version");
+      e(this, "capabilities");
+      e(this, "created_at");
+      typeof i == "string" && (i = JSON.parse(i)), this.version = i.version, this.description = i.description, this.changelog = i.changelog, this.min_ide_version = i.min_ide_version, this.max_ide_version = i.max_ide_version, this.capabilities = i.capabilities, this.created_at = i.created_at;
+    }
+    static createFrom(i = {}) {
+      return new g(i);
+    }
+  }
+  a.VersionInfo = g;
+})(Y || (Y = {}));
+var q;
+((a) => {
+  ((g) => {
+    g.TEXT = "text", g.INTEGER = "integer", g.FLOAT = "float", g.TOGGLE = "toggle", g.COLOR = "color", g.DATETIME = "datetime", g.PASSWORD = "password";
+  })(a.SettingType || (a.SettingType = {}));
+  class p {
+    constructor(r = {}) {
+      e(this, "enabled");
+      e(this, "allowFolders");
+      e(this, "extensions");
+      e(this, "multiple");
+      e(this, "relative");
+      e(this, "defaultPath");
+      typeof r == "string" && (r = JSON.parse(r)), this.enabled = r.enabled, this.allowFolders = r.allowFolders, this.extensions = r.extensions, this.multiple = r.multiple, this.relative = r.relative, this.defaultPath = r.defaultPath;
+    }
+    static createFrom(r = {}) {
+      return new p(r);
+    }
+  }
+  a.SettingFileSelection = p;
+  class f {
+    constructor(r = {}) {
+      e(this, "label");
+      e(this, "description");
+      e(this, "value");
+      typeof r == "string" && (r = JSON.parse(r)), this.label = r.label, this.description = r.description, this.value = r.value;
+    }
+    static createFrom(r = {}) {
+      return new f(r);
+    }
+  }
+  a.SettingOption = f;
+  class l {
+    constructor(r = {}) {
+      e(this, "id");
+      e(this, "label");
+      e(this, "description");
+      e(this, "type");
+      e(this, "value");
+      e(this, "default");
+      e(this, "options");
+      e(this, "fileSelection");
+      e(this, "sensitive");
+      typeof r == "string" && (r = JSON.parse(r)), this.id = r.id, this.label = r.label, this.description = r.description, this.type = r.type, this.value = r.value, this.default = r.default, this.options = this.convertValues(r.options, f), this.fileSelection = this.convertValues(r.fileSelection, p), this.sensitive = r.sensitive;
+    }
+    static createFrom(r = {}) {
+      return new l(r);
+    }
+    convertValues(r, i, m = !1) {
+      if (!r)
+        return r;
+      if (r.slice && r.map)
+        return r.map((s) => this.convertValues(s, i));
+      if (typeof r == "object") {
+        if (m) {
+          for (const s of Object.keys(r))
+            r[s] = new i(r[s]);
+          return r;
+        }
+        return new i(r);
+      }
+      return r;
+    }
+  }
+  a.Setting = l;
+  class o {
+    constructor(r = {}) {
+      e(this, "settings");
+      e(this, "id");
+      e(this, "label");
+      e(this, "description");
+      e(this, "icon");
+      typeof r == "string" && (r = JSON.parse(r)), this.settings = this.convertValues(r.settings, l, !0), this.id = r.id, this.label = r.label, this.description = r.description, this.icon = r.icon;
+    }
+    static createFrom(r = {}) {
+      return new o(r);
+    }
+    convertValues(r, i, m = !1) {
+      if (!r)
+        return r;
+      if (r.slice && r.map)
+        return r.map((s) => this.convertValues(s, i));
+      if (typeof r == "object") {
+        if (m) {
+          for (const s of Object.keys(r))
+            r[s] = new i(r[s]);
+          return r;
+        }
+        return new i(r);
+      }
+      return r;
+    }
+  }
+  a.Category = o;
+})(q || (q = {}));
+var O;
+((a) => {
+  class p {
+    static createFrom(l = {}) {
+      return new p(l);
+    }
+    constructor(l = {}) {
+      typeof l == "string" && (l = JSON.parse(l));
+    }
+  }
+  a.Time = p;
+})(O || (O = {}));
+var W;
+((a) => {
+  ((l) => {
+    l.CONFIG = "config", l.FILESYSTEM = "fs", l.IMAGE = "image", l.KUBERNETES = "kubernetes", l.REPOSITORY = "repository", l.ROOTFS = "rootfs", l.SBOM = "sbom";
+  })(a.Command || (a.Command = {})), ((l) => {
+    l.VULN = "vuln", l.MISCONFIG = "misconfig", l.SECRET = "secret", l.LICENSE = "license";
+  })(a.Scanner || (a.Scanner = {}));
+  class p {
+    constructor(o = {}) {
+      e(this, "filePatterns");
+      e(this, "skipDirs");
+      e(this, "skipFiles");
+      e(this, "scanners");
+      typeof o == "string" && (o = JSON.parse(o)), this.filePatterns = o.filePatterns, this.skipDirs = o.skipDirs, this.skipFiles = o.skipFiles, this.scanners = o.scanners;
+    }
+    static createFrom(o = {}) {
+      return new p(o);
+    }
+  }
+  a.ScanOptions = p;
+  class f {
+    constructor(o = {}) {
+      e(this, "timestamp");
+      e(this, "result");
+      e(this, "id");
+      e(this, "command");
+      typeof o == "string" && (o = JSON.parse(o)), this.timestamp = this.convertValues(o.timestamp, O.Time), this.result = o.result, this.id = o.id, this.command = o.command;
+    }
+    static createFrom(o = {}) {
+      return new f(o);
+    }
+    convertValues(o, g, r = !1) {
+      if (!o)
+        return o;
+      if (o.slice && o.map)
+        return o.map((i) => this.convertValues(i, g));
+      if (typeof o == "object") {
+        if (r) {
+          for (const i of Object.keys(o))
+            o[i] = new g(o[i]);
+          return o;
+        }
+        return new g(o);
+      }
+      return o;
+    }
+  }
+  a.ScanResult = f;
+})(W || (W = {}));
+var S;
+((a) => {
+  ((V) => {
+    V.UNKNOWN = "UNKNOWN", V.CONNECTED = "CONNECTED", V.DISCONNECTED = "DISCONNECTED", V.PENDING = "PENDING", V.FAILED = "FAILED", V.ERROR = "ERROR", V.UNAUTHORIZED = "UNAUTHORIZED", V.FORBIDDEN = "FORBIDDEN", V.BAD_REQUEST = "BAD_REQUEST", V.NOT_FOUND = "NOT_FOUND", V.TIMEOUT = "TIMEOUT", V.UNAVAILABLE = "UNAVAILABLE", V.REQUEST_ENTITY_TOO_LARGE = "REQUEST_ENTITY_TOO_LARGE";
+  })(a.ConnectionStatusCode || (a.ConnectionStatusCode = {}));
+  class p {
+    constructor(t = {}) {
+      e(this, "id");
+      e(this, "label");
+      e(this, "description");
+      e(this, "icon");
+      e(this, "scope");
+      e(this, "streaming");
+      typeof t == "string" && (t = JSON.parse(t)), this.id = t.id, this.label = t.label, this.description = t.description, this.icon = t.icon, this.scope = t.scope, this.streaming = t.streaming;
+    }
+    static createFrom(t = {}) {
+      return new p(t);
+    }
+  }
+  a.ActionDescriptor = p;
+  class f {
+    constructor(t = {}) {
+      e(this, "id");
+      e(this, "namespace");
+      e(this, "params");
+      typeof t == "string" && (t = JSON.parse(t)), this.id = t.id, this.namespace = t.namespace, this.params = t.params;
+    }
+    static createFrom(t = {}) {
+      return new f(t);
+    }
+  }
+  a.ActionInput = f;
+  class l {
+    constructor(t = {}) {
+      e(this, "success");
+      e(this, "data");
+      e(this, "message");
+      typeof t == "string" && (t = JSON.parse(t)), this.success = t.success, this.data = t.data, this.message = t.message;
+    }
+    static createFrom(t = {}) {
+      return new l(t);
+    }
+  }
+  a.ActionResult = l;
+  class o {
+    constructor(t = {}) {
+      e(this, "selectors");
+      e(this, "label_selector");
+      e(this, "label");
+      e(this, "paths");
+      typeof t == "string" && (t = JSON.parse(t)), this.selectors = t.selectors, this.label_selector = t.label_selector, this.label = t.label, this.paths = t.paths;
+    }
+    static createFrom(t = {}) {
+      return new o(t);
+    }
+  }
+  a.ActionTargetBuilder = o;
+  class g {
+    constructor(t = {}) {
+      e(this, "idAccessor");
+      e(this, "namespaceAccessor");
+      e(this, "namespaced");
+      e(this, "resourceKey");
+      e(this, "keyAccessor");
+      e(this, "keyMap");
+      e(this, "detailExtractors");
+      e(this, "displayId");
+      typeof t == "string" && (t = JSON.parse(t)), this.idAccessor = t.idAccessor, this.namespaceAccessor = t.namespaceAccessor, this.namespaced = t.namespaced, this.resourceKey = t.resourceKey, this.keyAccessor = t.keyAccessor, this.keyMap = t.keyMap, this.detailExtractors = t.detailExtractors, this.displayId = t.displayId;
+    }
+    static createFrom(t = {}) {
+      return new g(t);
+    }
+  }
+  a.ResourceLink = g;
+  class r {
+    constructor(t = {}) {
+      e(this, "id");
+      e(this, "header");
+      e(this, "accessor");
+      e(this, "accessorPriority");
+      e(this, "colorMap");
+      e(this, "color");
+      e(this, "align");
+      e(this, "hidden");
+      e(this, "width");
+      e(this, "formatter");
+      e(this, "component");
+      e(this, "componentParams");
+      e(this, "resourceLink");
+      e(this, "valueMap");
+      typeof t == "string" && (t = JSON.parse(t)), this.id = t.id, this.header = t.header, this.accessor = t.accessor, this.accessorPriority = t.accessorPriority, this.colorMap = t.colorMap, this.color = t.color, this.align = t.align, this.hidden = t.hidden, this.width = t.width, this.formatter = t.formatter, this.component = t.component, this.componentParams = t.componentParams, this.resourceLink = this.convertValues(t.resourceLink, g), this.valueMap = t.valueMap;
+    }
+    static createFrom(t = {}) {
+      return new r(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.ColumnDef = r;
+  class i {
+    constructor(t = {}) {
+      e(this, "last_refresh");
+      e(this, "data");
+      e(this, "labels");
+      e(this, "id");
+      e(this, "uid");
+      e(this, "name");
+      e(this, "description");
+      e(this, "avatar");
+      e(this, "expiry_time");
+      e(this, "Client");
+      typeof t == "string" && (t = JSON.parse(t)), this.last_refresh = this.convertValues(t.last_refresh, O.Time), this.data = t.data, this.labels = t.labels, this.id = t.id, this.uid = t.uid, this.name = t.name, this.description = t.description, this.avatar = t.avatar, this.expiry_time = t.expiry_time, this.Client = t.Client;
+    }
+    static createFrom(t = {}) {
+      return new i(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.Connection = i;
+  class m {
+    constructor(t = {}) {
+      e(this, "connection");
+      e(this, "status");
+      e(this, "error");
+      e(this, "details");
+      typeof t == "string" && (t = JSON.parse(t)), this.connection = this.convertValues(t.connection, i), this.status = t.status, this.error = t.error, this.details = t.details;
+    }
+    static createFrom(t = {}) {
+      return new m(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.ConnectionStatus = m;
+  class s {
+    constructor(t = {}) {
+      e(this, "params");
+      e(this, "input");
+      e(this, "namespace");
+      typeof t == "string" && (t = JSON.parse(t)), this.params = t.params, this.input = t.input, this.namespace = t.namespace;
+    }
+    static createFrom(t = {}) {
+      return new s(t);
+    }
+  }
+  a.CreateInput = s;
+  class c {
+    constructor(t = {}) {
+      e(this, "result");
+      e(this, "success");
+      typeof t == "string" && (t = JSON.parse(t)), this.result = t.result, this.success = t.success;
+    }
+    static createFrom(t = {}) {
+      return new c(t);
+    }
+  }
+  a.CreateResult = c;
+  class _ {
+    constructor(t = {}) {
+      e(this, "input");
+      e(this, "params");
+      e(this, "id");
+      e(this, "namespace");
+      typeof t == "string" && (t = JSON.parse(t)), this.input = t.input, this.params = t.params, this.id = t.id, this.namespace = t.namespace;
+    }
+    static createFrom(t = {}) {
+      return new _(t);
+    }
+  }
+  a.DeleteInput = _;
+  class w {
+    constructor(t = {}) {
+      e(this, "result");
+      e(this, "success");
+      typeof t == "string" && (t = JSON.parse(t)), this.result = t.result, this.success = t.success;
+    }
+    static createFrom(t = {}) {
+      return new w(t);
+    }
+  }
+  a.DeleteResult = w;
+  class F {
+    constructor(t = {}) {
+      e(this, "resourceKey");
+      e(this, "fileMatch");
+      e(this, "uri");
+      e(this, "url");
+      e(this, "content");
+      e(this, "language");
+      typeof t == "string" && (t = JSON.parse(t)), this.resourceKey = t.resourceKey, this.fileMatch = t.fileMatch, this.uri = t.uri, this.url = t.url, this.content = t.content, this.language = t.language;
+    }
+    static createFrom(t = {}) {
+      return new F(t);
+    }
+  }
+  a.EditorSchema = F;
+  class n {
+    constructor(t = {}) {
+      e(this, "page");
+      e(this, "pageSize");
+      typeof t == "string" && (t = JSON.parse(t)), this.page = t.page, this.pageSize = t.pageSize;
+    }
+    static createFrom(t = {}) {
+      return new n(t);
+    }
+  }
+  a.PaginationParams = n;
+  class y {
+    constructor(t = {}) {
+      e(this, "by");
+      e(this, "direction");
+      typeof t == "string" && (t = JSON.parse(t)), this.by = t.by, this.direction = t.direction;
+    }
+    static createFrom(t = {}) {
+      return new y(t);
+    }
+  }
+  a.OrderParams = y;
+  class b {
+    constructor(t = {}) {
+      e(this, "params");
+      e(this, "conditions");
+      e(this, "namespaces");
+      e(this, "order");
+      e(this, "pagination");
+      typeof t == "string" && (t = JSON.parse(t)), this.params = t.params, this.conditions = t.conditions, this.namespaces = t.namespaces, this.order = this.convertValues(t.order, y), this.pagination = this.convertValues(t.pagination, n);
+    }
+    static createFrom(t = {}) {
+      return new b(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.FindInput = b;
+  class d {
+    constructor(t = {}) {
+      e(this, "page");
+      e(this, "pageSize");
+      e(this, "total");
+      e(this, "pages");
+      typeof t == "string" && (t = JSON.parse(t)), this.page = t.page, this.pageSize = t.pageSize, this.total = t.total, this.pages = t.pages;
+    }
+    static createFrom(t = {}) {
+      return new d(t);
+    }
+  }
+  a.PaginationResult = d;
+  class J {
+    constructor(t = {}) {
+      e(this, "result");
+      e(this, "success");
+      e(this, "pagination");
+      typeof t == "string" && (t = JSON.parse(t)), this.result = t.result, this.success = t.success, this.pagination = this.convertValues(t.pagination, d);
+    }
+    static createFrom(t = {}) {
+      return new J(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.FindResult = J;
+  class j {
+    constructor(t = {}) {
+      e(this, "params");
+      e(this, "id");
+      e(this, "namespace");
+      typeof t == "string" && (t = JSON.parse(t)), this.params = t.params, this.id = t.id, this.namespace = t.namespace;
+    }
+    static createFrom(t = {}) {
+      return new j(t);
+    }
+  }
+  a.GetInput = j;
+  class D {
+    constructor(t = {}) {
+      e(this, "result");
+      e(this, "success");
+      typeof t == "string" && (t = JSON.parse(t)), this.result = t.result, this.success = t.success;
+    }
+    static createFrom(t = {}) {
+      return new D(t);
+    }
+  }
+  a.GetResult = D;
+  class E {
+    constructor(t = {}) {
+      e(this, "connection");
+      e(this, "resources");
+      e(this, "resourceCounts");
+      e(this, "totalResources");
+      e(this, "syncedCount");
+      e(this, "errorCount");
+      typeof t == "string" && (t = JSON.parse(t)), this.connection = t.connection, this.resources = t.resources, this.resourceCounts = t.resourceCounts, this.totalResources = t.totalResources, this.syncedCount = t.syncedCount, this.errorCount = t.errorCount;
+    }
+    static createFrom(t = {}) {
+      return new E(t);
+    }
+  }
+  a.InformerConnectionSummary = E;
+  class N {
+    constructor(t = {}) {
+      e(this, "id");
+      e(this, "title");
+      e(this, "icon");
+      e(this, "description");
+      e(this, "items");
+      typeof t == "string" && (t = JSON.parse(t)), this.id = t.id, this.title = t.title, this.icon = t.icon, this.description = t.description, this.items = this.convertValues(t.items, N);
+    }
+    static createFrom(t = {}) {
+      return new N(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.LayoutItem = N;
+  class P {
+    constructor(t = {}) {
+      e(this, "params");
+      e(this, "namespaces");
+      e(this, "order");
+      e(this, "pagination");
+      typeof t == "string" && (t = JSON.parse(t)), this.params = t.params, this.namespaces = t.namespaces, this.order = this.convertValues(t.order, y), this.pagination = this.convertValues(t.pagination, n);
+    }
+    static createFrom(t = {}) {
+      return new P(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.ListInput = P;
+  class R {
+    constructor(t = {}) {
+      e(this, "result");
+      e(this, "success");
+      e(this, "pagination");
+      typeof t == "string" && (t = JSON.parse(t)), this.result = t.result, this.success = t.success, this.pagination = this.convertValues(t.pagination, d);
+    }
+    static createFrom(t = {}) {
+      return new R(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.ListResult = R;
+  class I {
+    constructor(t = {}) {
+      e(this, "id");
+      e(this, "metadata");
+      e(this, "enabled");
+      e(this, "running");
+      e(this, "devMode");
+      e(this, "devPath");
+      e(this, "loading");
+      e(this, "loadError");
+      e(this, "capabilities");
+      typeof t == "string" && (t = JSON.parse(t)), this.id = t.id, this.metadata = this.convertValues(t.metadata, k.PluginMeta), this.enabled = t.enabled, this.running = t.running, this.devMode = t.devMode, this.devPath = t.devPath, this.loading = t.loading, this.loadError = t.loadError, this.capabilities = t.capabilities;
+    }
+    static createFrom(t = {}) {
+      return new I(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.Plugin = I;
+  class T {
+    constructor(t = {}) {
+      e(this, "Metadata");
+      e(this, "ID");
+      e(this, "DevPath");
+      e(this, "Enabled");
+      e(this, "DevMode");
+      typeof t == "string" && (t = JSON.parse(t)), this.Metadata = this.convertValues(t.Metadata, k.PluginMeta), this.ID = t.ID, this.DevPath = t.DevPath, this.Enabled = t.Enabled, this.DevMode = t.DevMode;
+    }
+    static createFrom(t = {}) {
+      return new T(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.PluginState = T;
+  class A {
+    constructor(t = {}) {
+      e(this, "id_accessor");
+      e(this, "namespace_accessor");
+      e(this, "memoizer_accessor");
+      e(this, "columnDefs");
+      e(this, "supportedOperations");
+      typeof t == "string" && (t = JSON.parse(t)), this.id_accessor = t.id_accessor, this.namespace_accessor = t.namespace_accessor, this.memoizer_accessor = t.memoizer_accessor, this.columnDefs = this.convertValues(t.columnDefs, r), this.supportedOperations = t.supportedOperations;
+    }
+    static createFrom(t = {}) {
+      return new A(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.ResourceDefinition = A;
+  class M {
+    constructor(t = {}) {
+      e(this, "id");
+      e(this, "name");
+      e(this, "description");
+      e(this, "icon");
+      e(this, "resources");
+      typeof t == "string" && (t = JSON.parse(t)), this.id = t.id, this.name = t.name, this.description = t.description, this.icon = t.icon, this.resources = this.convertValues(t.resources, Array, !0);
+    }
+    static createFrom(t = {}) {
+      return new M(t);
+    }
+    convertValues(t, u, v = !1) {
+      if (!t)
+        return t;
+      if (t.slice && t.map)
+        return t.map((h) => this.convertValues(h, u));
+      if (typeof t == "object") {
+        if (v) {
+          for (const h of Object.keys(t))
+            t[h] = new u(t[h]);
+          return t;
+        }
+        return new u(t);
+      }
+      return t;
+    }
+  }
+  a.ResourceGroup = M;
+  class L {
+    constructor(t = {}) {
+      e(this, "group");
+      e(this, "version");
+      e(this, "kind");
+      e(this, "label");
+      e(this, "icon");
+      e(this, "description");
+      e(this, "category");
+      typeof t == "string" && (t = JSON.parse(t)), this.group = t.group, this.version = t.version, this.kind = t.kind, this.label = t.label, this.icon = t.icon, this.description = t.description, this.category = t.category;
+    }
+    static createFrom(t = {}) {
+      return new L(t);
+    }
+  }
+  a.ResourceMeta = L;
+  class x {
+    constructor(t = {}) {
+      e(this, "input");
+      e(this, "params");
+      e(this, "id");
+      e(this, "namespace");
+      typeof t == "string" && (t = JSON.parse(t)), this.input = t.input, this.params = t.params, this.id = t.id, this.namespace = t.namespace;
+    }
+    static createFrom(t = {}) {
+      return new x(t);
+    }
+  }
+  a.UpdateInput = x;
+  class C {
+    constructor(t = {}) {
+      e(this, "result");
+      e(this, "success");
+      typeof t == "string" && (t = JSON.parse(t)), this.result = t.result, this.success = t.success;
+    }
+    static createFrom(t = {}) {
+      return new C(t);
+    }
+  }
+  a.UpdateResult = C;
+})(S || (S = {}));
+var Z;
+((a) => {
+  class p {
+    constructor(r = {}) {
+      e(this, "plugin");
+      typeof r == "string" && (r = JSON.parse(r)), this.plugin = r.plugin;
+    }
+    static createFrom(r = {}) {
+      return new p(r);
+    }
+  }
+  a.GetPluginComponentsInput = p;
+  class f {
+    constructor(r = {}) {
+      e(this, "plugin");
+      e(this, "resource");
+      e(this, "area");
+      typeof r == "string" && (r = JSON.parse(r)), this.plugin = r.plugin, this.resource = r.resource, this.area = r.area;
+    }
+    static createFrom(r = {}) {
+      return new f(r);
+    }
+  }
+  a.GetResourceAreaComponentInput = f;
+  class l {
+    constructor(r = {}) {
+      e(this, "plugin");
+      e(this, "resource");
+      typeof r == "string" && (r = JSON.parse(r)), this.plugin = r.plugin, this.resource = r.resource;
+    }
+    static createFrom(r = {}) {
+      return new l(r);
+    }
+  }
+  a.GetResourceComponentsInput = l;
+  class o {
+    constructor(r = {}) {
+      e(this, "owner");
+      e(this, "name");
+      e(this, "plugin");
+      e(this, "resource");
+      e(this, "area");
+      e(this, "extension");
+      typeof r == "string" && (r = JSON.parse(r)), this.owner = r.owner, this.name = r.name, this.plugin = r.plugin, this.resource = r.resource, this.area = r.area, this.extension = r.extension;
+    }
+    static createFrom(r = {}) {
+      return new o(r);
+    }
+  }
+  a.ResourceComponent = o;
+})(Z || (Z = {}));
+var X;
+((a) => {
+  class p {
+    constructor(l = {}) {
+      e(this, "filename");
+      e(this, "contents");
+      typeof l == "string" && (l = JSON.parse(l)), this.filename = l.filename, this.contents = l.contents;
+    }
+    static createFrom(l = {}) {
+      return new p(l);
+    }
+  }
+  a.GetLanguageInput = p;
+})(X || (X = {}));
+export {
+  k as config,
+  U as devserver,
+  B as exec,
+  G as logs,
+  z as main,
+  K as metric,
+  H as networker,
+  Q as plugin,
+  Y as registry,
+  q as settings,
+  O as time,
+  W as trivy,
+  S as types,
+  Z as ui,
+  X as utils
+};