@agrotools1/at-components 0.3.5 → 0.3.6

package/dist/PBFDecoderWorker-f2ab98a5.js

@@ -0,0 +1,213 @@
+import { cu as c, bR as d, c6 as p, cv as f, gZ as m } from "./index-4ead5b97.js";
+import { p as y, r as _ } from "./featureConversionUtils-90914512.js";
+import { t as g } from "./pbfQueryUtils-0b522562.js";
+import "vue";
+import "./OptimizedGeometry-3b808152.js";
+import "./OptimizedFeatureSet-54e095c4.js";
+import "./pbf-e5c31775.js";
+let b = class {
+  constructor(t, e, s) {
+    this.uid = t, this.geometry = e, this.attributes = s, this.visible = !0, this.objectId = null, this.centroid = null;
+  }
+};
+class P {
+  constructor() {
+    this.exceededTransferLimit = !1, this.features = [], this.fields = [], this.hasM = !1, this.hasZ = !1, this.geometryType = null, this.objectIdFieldName = null, this.globalIdFieldName = null, this.geometryProperties = null, this.geohashFieldName = null, this.spatialReference = null, this.transform = null;
+  }
+}
+function C(i, t, e, s) {
+  if (t != null && t.size && e != null && i)
+    for (const r in i) {
+      if (!t.has(r))
+        continue;
+      const o = i[r];
+      typeof o == "string" && o.length > e && (s(r), i[r] = "");
+    }
+}
+function G(i, t) {
+  return t;
+}
+function l(i, t, e, s) {
+  switch (e) {
+    case 0:
+      return h(i, t + s, 0);
+    case 1:
+      return i.originPosition === "lowerLeft" ? h(i, t + s, 1) : M(i, t + s, 1);
+  }
+}
+function u(i, t, e, s) {
+  return e === 2 ? h(i, t, 2) : l(i, t, e, s);
+}
+function A(i, t, e, s) {
+  return e === 2 ? h(i, t, 3) : l(i, t, e, s);
+}
+function v(i, t, e, s) {
+  return e === 3 ? h(i, t, 3) : u(i, t, e, s);
+}
+function h({ translate: i, scale: t }, e, s) {
+  return i[s] + e * t[s];
+}
+function M({ translate: i, scale: t }, e, s) {
+  return i[s] - e * t[s];
+}
+class R {
+  constructor(t) {
+    this._options = t, this.geometryTypes = ["point", "multipoint", "polyline", "polygon"], this._previousCoordinate = [0, 0], this._transform = null, this._applyTransform = G, this._lengths = [], this._currentLengthIndex = 0, this._toAddInCurrentPath = 0, this._vertexDimension = 0, this._coordinateBuffer = null, this._coordinateBufferPtr = 0, this._attributesConstructor = class {
+    }, this._missingAttributes = [];
+  }
+  get missingAttributes() {
+    return this._missingAttributes;
+  }
+  createFeatureResult() {
+    return new P();
+  }
+  finishFeatureResult(t) {
+    if (this._options.applyTransform && (t.transform = null), this._attributesConstructor = class {
+    }, this._coordinateBuffer = null, this._lengths.length = 0, !t.hasZ)
+      return;
+    const e = c(t.geometryType, this._options.sourceSpatialReference, t.spatialReference);
+    if (e != null)
+      for (const s of t.features)
+        e(s.geometry);
+  }
+  createSpatialReference() {
+    return new d();
+  }
+  addField(t, e) {
+    t.fields.push(p.fromJSON(e));
+    const s = t.fields.map((r) => r.name);
+    this._attributesConstructor = function() {
+      for (const r of s)
+        this[r] = null;
+    };
+  }
+  addFeature(t, e) {
+    const s = this._options.maxStringAttributeLength, r = this._options.maxStringAttributeFields;
+    C(e.attributes, r, s, (o) => {
+      const n = e.attributes[t.objectIdFieldName];
+      n != null && this._missingAttributes.push({ objectId: n, attribute: o });
+    }), t.features.push(e);
+  }
+  addQueryGeometry(t, e) {
+    const { queryGeometry: s, queryGeometryType: r } = e, o = y(s.clone(), s, !1, !1, this._transform), n = _(o, r, !1, !1);
+    let a = null;
+    switch (r) {
+      case "esriGeometryPoint":
+        a = "point";
+        break;
+      case "esriGeometryPolygon":
+        a = "polygon";
+        break;
+      case "esriGeometryPolyline":
+        a = "polyline";
+        break;
+      case "esriGeometryMultipoint":
+        a = "multipoint";
+    }
+    n.type = a, t.queryGeometryType = r, t.queryGeometry = n;
+  }
+  prepareFeatures(t) {
+    switch (this._transform = t.transform ?? null, this._options.applyTransform && t.transform && (this._applyTransform = this._deriveApplyTransform(t)), this._vertexDimension = 2, t.hasZ && this._vertexDimension++, t.hasM && this._vertexDimension++, t.geometryType) {
+      case "point":
+        this.addCoordinate = (e, s, r) => this.addCoordinatePoint(e, s, r), this.createGeometry = (e) => this.createPointGeometry(e);
+        break;
+      case "polygon":
+        this.addCoordinate = (e, s, r) => this._addCoordinatePolygon(e, s, r), this.createGeometry = (e) => this._createPolygonGeometry(e);
+        break;
+      case "polyline":
+        this.addCoordinate = (e, s, r) => this._addCoordinatePolyline(e, s, r), this.createGeometry = (e) => this._createPolylineGeometry(e);
+        break;
+      case "multipoint":
+        this.addCoordinate = (e, s, r) => this._addCoordinateMultipoint(e, s, r), this.createGeometry = (e) => this._createMultipointGeometry(e);
+        break;
+      case "mesh":
+      case "extent":
+        break;
+      default:
+        f(t.geometryType);
+    }
+  }
+  createFeature() {
+    return this._lengths.length = 0, this._currentLengthIndex = 0, this._previousCoordinate[0] = 0, this._previousCoordinate[1] = 0, new b(m(), null, new this._attributesConstructor());
+  }
+  allocateCoordinates() {
+    const t = this._lengths.reduce((e, s) => e + s, 0);
+    this._coordinateBuffer = new Float64Array(t * this._vertexDimension), this._coordinateBufferPtr = 0;
+  }
+  addLength(t, e) {
+    this._lengths.length === 0 && (this._toAddInCurrentPath = e), this._lengths.push(e);
+  }
+  createPointGeometry(t) {
+    const e = { type: "point", x: 0, y: 0, spatialReference: t.spatialReference, hasZ: !!t.hasZ, hasM: !!t.hasM };
+    return e.hasZ && (e.z = 0), e.hasM && (e.m = 0), e;
+  }
+  addCoordinatePoint(t, e, s) {
+    const r = this._transform ? this._applyTransform(this._transform, e, s, 0) : e;
+    if (r != null)
+      switch (s) {
+        case 0:
+          t.x = r;
+          break;
+        case 1:
+          t.y = r;
+          break;
+        case 2:
+          t.hasZ ? t.z = r : t.m = r;
+          break;
+        case 3:
+          t.m = r;
+      }
+  }
+  _transformPathLikeValue(t, e) {
+    let s = 0;
+    return e <= 1 && (s = this._previousCoordinate[e], this._previousCoordinate[e] += t), this._transform ? this._applyTransform(this._transform, t, e, s) : t;
+  }
+  _addCoordinatePolyline(t, e, s) {
+    this._dehydratedAddPointsCoordinate(t.paths, e, s);
+  }
+  _addCoordinatePolygon(t, e, s) {
+    this._dehydratedAddPointsCoordinate(t.rings, e, s);
+  }
+  _addCoordinateMultipoint(t, e, s) {
+    s === 0 && t.points.push([]);
+    const r = this._transformPathLikeValue(e, s);
+    t.points[t.points.length - 1].push(r);
+  }
+  _createPolygonGeometry(t) {
+    return { type: "polygon", rings: [[]], spatialReference: t.spatialReference, hasZ: !!t.hasZ, hasM: !!t.hasM };
+  }
+  _createPolylineGeometry(t) {
+    return { type: "polyline", paths: [[]], spatialReference: t.spatialReference, hasZ: !!t.hasZ, hasM: !!t.hasM };
+  }
+  _createMultipointGeometry(t) {
+    return { type: "multipoint", points: [], spatialReference: t.spatialReference, hasZ: !!t.hasZ, hasM: !!t.hasM };
+  }
+  _dehydratedAddPointsCoordinate(t, e, s) {
+    s === 0 && this._toAddInCurrentPath-- == 0 && (t.push([]), this._toAddInCurrentPath = this._lengths[++this._currentLengthIndex] - 1, this._previousCoordinate[0] = 0, this._previousCoordinate[1] = 0);
+    const r = this._transformPathLikeValue(e, s), o = t[t.length - 1], n = this._coordinateBuffer;
+    if (n) {
+      if (s === 0) {
+        const a = this._coordinateBufferPtr * Float64Array.BYTES_PER_ELEMENT;
+        o.push(new Float64Array(n.buffer, a, this._vertexDimension));
+      }
+      n[this._coordinateBufferPtr++] = r;
+    }
+  }
+  _deriveApplyTransform(t) {
+    const { hasZ: e, hasM: s } = t;
+    return e && s ? v : e ? u : s ? A : l;
+  }
+}
+class T {
+  _parseFeatureQuery(t) {
+    var o;
+    const e = new R(t.options), s = g(t.buffer, e), r = { ...s, spatialReference: (o = s.spatialReference) == null ? void 0 : o.toJSON(), fields: s.fields ? s.fields.map((n) => n.toJSON()) : void 0, missingAttributes: e.missingAttributes };
+    return Promise.resolve(r);
+  }
+}
+function N() {
+  return new T();
+}
+export {
+  N as default
+};

package/dist/PointCloudLayer-fed28318.js

@@ -0,0 +1,197 @@
+import { e as r, y as o, c as y, bx as B, ea as x, db as v, bz as u, c6 as b, ba as _, bO as V, iq as C, W as l, d1 as L, U as N, s as P, w as O, c5 as E, c2 as A, a_ as D } from "./index-4ead5b97.js";
+import { m as K } from "./MultiOriginJSONSupport-66a73b5d.js";
+import { i as k } from "./APIKeyMixin-ee07543b.js";
+import { l as G } from "./ArcGISService-16ef592c.js";
+import { e as M } from "./CustomParametersMixin-949de3be.js";
+import { u as U } from "./OperationalLayer-2e935984.js";
+import { j as z } from "./PortalLayer-15420854.js";
+import { t as W } from "./ScaleRangeLayer-6b36cfd2.js";
+import { L as Z, P as T } from "./SceneService-3215551f.js";
+import { y as H, f as J, c as Q } from "./commonProperties-c36fc1b2.js";
+import { s as X } from "./fieldProperties-917b162f.js";
+import { c as q, d as Y, b as ee, a as te } from "./PointCloudUniqueValueRenderer-8fd8d64d.js";
+import { I as F, x as re, Z as oe } from "./elevationInfoUtils-f7fb37da.js";
+import { p as ie } from "./popupUtils-3e3652c3.js";
+import "vue";
+import "./portalItemUtils-9fe0753b.js";
+import "./originUtils-87edf087.js";
+import "./multiOriginJSONSupportUtils-207ba4d4.js";
+import "./jsonContext-4c9c02ed.js";
+import "./resourceUtils-318f1fd0.js";
+import "./resourceUtils-bf624bf9.js";
+import "./saveAPIKeyUtils-c407e113.js";
+import "./saveUtils-9d95f409.js";
+import "./ElevationInfo-c194d5f5.js";
+import "./unitConversionUtils-c6c847c9.js";
+import "./lengthUtils-21f99608.js";
+import "./FieldsIndex-cddb2b35.js";
+import "./UnknownTimeZone-6d259a58.js";
+import "./ColorStop-6fd09765.js";
+let f = class extends B {
+  constructor(e) {
+    super(e), this.field = null, this.type = null;
+  }
+  clone() {
+    return console.warn(".clone() is not implemented for " + this.declaredClass), null;
+  }
+};
+r([o({ type: String, json: { write: { enabled: !0, isRequired: !0 } } })], f.prototype, "field", void 0), r([o({ readOnly: !0, nonNullable: !0, json: { read: !1 } })], f.prototype, "type", void 0), f = r([y("esri.layers.pointCloudFilters.PointCloudFilter")], f);
+const g = f;
+var w;
+let d = w = class extends g {
+  constructor(e) {
+    super(e), this.requiredClearBits = null, this.requiredSetBits = null, this.type = "bitfield";
+  }
+  clone() {
+    return new w({ field: this.field, requiredClearBits: u(this.requiredClearBits), requiredSetBits: u(this.requiredSetBits) });
+  }
+};
+r([o({ type: [x], json: { write: { enabled: !0, overridePolicy() {
+  return { enabled: !0, isRequired: !this.requiredSetBits };
+} } } })], d.prototype, "requiredClearBits", void 0), r([o({ type: [x], json: { write: { enabled: !0, overridePolicy() {
+  return { enabled: !0, isRequired: !this.requiredClearBits };
+} } } })], d.prototype, "requiredSetBits", void 0), r([v({ pointCloudBitfieldFilter: "bitfield" })], d.prototype, "type", void 0), d = w = r([y("esri.layers.pointCloudFilters.PointCloudBitfieldFilter")], d);
+const se = d;
+var I;
+let m = I = class extends g {
+  constructor(e) {
+    super(e), this.includedReturns = [], this.type = "return";
+  }
+  clone() {
+    return new I({ field: this.field, includedReturns: u(this.includedReturns) });
+  }
+};
+r([o({ type: [["firstOfMany", "last", "lastOfMany", "single"]], json: { write: { enabled: !0, isRequired: !0 } } })], m.prototype, "includedReturns", void 0), r([v({ pointCloudReturnFilter: "return" })], m.prototype, "type", void 0), m = I = r([y("esri.layers.pointCloudFilters.PointCloudReturnFilter")], m);
+const ne = m;
+var $;
+let p = $ = class extends g {
+  constructor(e) {
+    super(e), this.mode = "exclude", this.type = "value", this.values = [];
+  }
+  clone() {
+    return new $({ field: this.field, mode: this.mode, values: u(this.values) });
+  }
+};
+r([o({ type: ["exclude", "include"], json: { write: { enabled: !0, isRequired: !0 } } })], p.prototype, "mode", void 0), r([v({ pointCloudValueFilter: "value" })], p.prototype, "type", void 0), r([o({ type: [Number], json: { write: { enabled: !0, isRequired: !0 } } })], p.prototype, "values", void 0), p = $ = r([y("esri.layers.pointCloudFilters.PointCloudValueFilter")], p);
+const ae = p, le = { key: "type", base: g, typeMap: { value: ae, bitfield: se, return: ne } };
+var S;
+let h = S = class extends q {
+  constructor(e) {
+    super(e), this.type = "point-cloud-rgb", this.field = null;
+  }
+  clone() {
+    return new S({ ...this.cloneProperties(), field: u(this.field) });
+  }
+};
+r([v({ pointCloudRGBRenderer: "point-cloud-rgb" })], h.prototype, "type", void 0), r([o({ type: String, json: { write: !0 } })], h.prototype, "field", void 0), h = S = r([y("esri.renderers.PointCloudRGBRenderer")], h);
+const de = h, R = { key: "type", base: q, typeMap: { "point-cloud-class-breaks": Y, "point-cloud-rgb": de, "point-cloud-stretch": ee, "point-cloud-unique-value": te }, errorContext: "renderer" }, j = X();
+let i = class extends Z(G(U(z(W(K(M(k(D)))))))) {
+  constructor(...e) {
+    super(...e), this.operationalLayerType = "PointCloudLayer", this.popupEnabled = !0, this.popupTemplate = null, this.opacity = 1, this.filters = [], this.fields = null, this.fieldsIndex = null, this.outFields = null, this.path = null, this.legendEnabled = !0, this.renderer = null, this.type = "point-cloud";
+  }
+  normalizeCtorArgs(e, t) {
+    return typeof e == "string" ? { url: e, ...t } : e;
+  }
+  get defaultPopupTemplate() {
+    return this.attributeStorageInfo ? this.createPopupTemplate() : null;
+  }
+  getFieldDomain(e) {
+    const t = this.fieldsIndex.get(e);
+    return t != null && t.domain ? t.domain : null;
+  }
+  readServiceFields(e, t, n) {
+    return Array.isArray(e) ? e.map((s) => {
+      const a = new b();
+      return s.type === "FieldTypeInteger" && ((s = u(s)).type = "esriFieldTypeInteger"), a.read(s, n), a;
+    }) : Array.isArray(t.attributeStorageInfo) ? t.attributeStorageInfo.map((s) => new b({ name: s.name, type: s.name === "ELEVATION" ? "double" : "integer" })) : null;
+  }
+  set elevationInfo(e) {
+    this._set("elevationInfo", e), this._validateElevationInfo();
+  }
+  writeRenderer(e, t, n, s) {
+    _("layerDefinition.drawingInfo.renderer", e.write({}, s), t);
+  }
+  load(e) {
+    const t = e != null ? e.signal : null, n = this.loadFromPortal({ supportedTypes: ["Scene Service"] }, e).catch(V).then(() => this._fetchService(t));
+    return this.addResolvingPromise(n), Promise.resolve(this);
+  }
+  createPopupTemplate(e) {
+    const t = ie(this, e);
+    return t && (this._formatPopupTemplateReturnsField(t), this._formatPopupTemplateRGBField(t)), t;
+  }
+  _formatPopupTemplateReturnsField(e) {
+    var a;
+    const t = this.fieldsIndex.get("RETURNS");
+    if (!t)
+      return;
+    const n = (a = e.fieldInfos) == null ? void 0 : a.find((c) => c.fieldName === t.name);
+    if (!n)
+      return;
+    const s = new C({ name: "pcl-returns-decoded", title: t.alias || t.name, expression: `
+        var returnValue = $feature.${t.name};
+        return (returnValue % 16) + " / " + Floor(returnValue / 16);
+      ` });
+    e.expressionInfos = [...e.expressionInfos || [], s], n.fieldName = "expression/pcl-returns-decoded";
+  }
+  _formatPopupTemplateRGBField(e) {
+    var a;
+    const t = this.fieldsIndex.get("RGB");
+    if (!t)
+      return;
+    const n = (a = e.fieldInfos) == null ? void 0 : a.find((c) => c.fieldName === t.name);
+    if (!n)
+      return;
+    const s = new C({ name: "pcl-rgb-decoded", title: t.alias || t.name, expression: `
+        var rgb = $feature.${t.name};
+        var red = Floor(rgb / 65536, 0);
+        var green = Floor((rgb - (red * 65536)) / 256,0);
+        var blue = rgb - (red * 65536) - (green * 256);
+
+        return "rgb(" + red + "," + green + "," + blue + ")";
+      ` });
+    e.expressionInfos = [...e.expressionInfos || [], s], n.fieldName = "expression/pcl-rgb-decoded";
+  }
+  async queryCachedStatistics(e, t) {
+    if (await this.load(t), !this.attributeStorageInfo)
+      throw new l("scenelayer:no-cached-statistics", "Cached statistics are not available for this layer");
+    const n = this.fieldsIndex.get(e);
+    if (!n)
+      throw new l("pointcloudlayer:field-unexisting", `Field '${e}' does not exist on the layer`);
+    for (const s of this.attributeStorageInfo)
+      if (s.name === n.name) {
+        const a = L(this.parsedUrl.path, `./statistics/${s.key}`);
+        return N(a, { query: { f: "json", ...this.customParameters, token: this.apiKey }, responseType: "json", signal: t ? t.signal : null }).then((c) => c.data);
+      }
+    throw new l("pointcloudlayer:no-cached-statistics", "Cached statistics for this attribute are not available");
+  }
+  async saveAs(e, t) {
+    return this._debouncedSaveOperations(T.SAVE_AS, { ...t, getTypeKeywords: () => this._getTypeKeywords(), portalItemLayerType: "point-cloud" }, e);
+  }
+  async save() {
+    const e = { getTypeKeywords: () => this._getTypeKeywords(), portalItemLayerType: "point-cloud" };
+    return this._debouncedSaveOperations(T.SAVE, e);
+  }
+  validateLayer(e) {
+    if (e.layerType && e.layerType !== "PointCloud")
+      throw new l("pointcloudlayer:layer-type-not-supported", "PointCloudLayer does not support this layer type", { layerType: e.layerType });
+    if (isNaN(this.version.major) || isNaN(this.version.minor))
+      throw new l("layer:service-version-not-supported", "Service version is not supported.", { serviceVersion: this.version.versionString, supportedVersions: "1.x-2.x" });
+    if (this.version.major > 2)
+      throw new l("layer:service-version-too-new", "Service version is too new.", { serviceVersion: this.version.versionString, supportedVersions: "1.x-2.x" });
+  }
+  hasCachedStatistics(e) {
+    return this.attributeStorageInfo != null && this.attributeStorageInfo.some((t) => t.name === e);
+  }
+  _getTypeKeywords() {
+    return ["PointCloud"];
+  }
+  _validateElevationInfo() {
+    const e = this.elevationInfo;
+    F(P.getLogger(this), re("Point cloud layers", "absolute-height", e)), F(P.getLogger(this), oe("Point cloud layers", e));
+  }
+};
+r([o({ type: ["PointCloudLayer"] })], i.prototype, "operationalLayerType", void 0), r([o(H)], i.prototype, "popupEnabled", void 0), r([o({ type: O, json: { name: "popupInfo", write: !0 } })], i.prototype, "popupTemplate", void 0), r([o({ readOnly: !0, json: { read: !1 } })], i.prototype, "defaultPopupTemplate", null), r([o({ readOnly: !0, json: { write: !1, read: !1, origins: { "web-document": { write: !1, read: !1 } } } })], i.prototype, "opacity", void 0), r([o({ type: ["show", "hide"] })], i.prototype, "listMode", void 0), r([o({ types: [le], json: { origins: { service: { read: { source: "filters" } } }, name: "layerDefinition.filters", write: !0 } })], i.prototype, "filters", void 0), r([o({ type: [b] })], i.prototype, "fields", void 0), r([o(j.fieldsIndex)], i.prototype, "fieldsIndex", void 0), r([E("service", "fields", ["fields", "attributeStorageInfo"])], i.prototype, "readServiceFields", null), r([o(j.outFields)], i.prototype, "outFields", void 0), r([o({ readOnly: !0 })], i.prototype, "attributeStorageInfo", void 0), r([o(J)], i.prototype, "elevationInfo", null), r([o({ type: String, json: { origins: { "web-scene": { read: !0, write: !0 }, "portal-item": { read: !0, write: !0 } }, read: !1 } })], i.prototype, "path", void 0), r([o(Q)], i.prototype, "legendEnabled", void 0), r([o({ types: R, json: { origins: { service: { read: { source: "drawingInfo.renderer" } } }, name: "layerDefinition.drawingInfo.renderer", write: { target: { "layerDefinition.drawingInfo.renderer": { types: R }, "layerDefinition.drawingInfo.transparency": { type: Number } } } } })], i.prototype, "renderer", void 0), r([A("renderer")], i.prototype, "writeRenderer", null), r([o({ json: { read: !1 }, readOnly: !0 })], i.prototype, "type", void 0), i = r([y("esri.layers.PointCloudLayer")], i);
+const Ae = i;
+export {
+  Ae as default
+};

package/dist/PointCloudUniqueValueRenderer-8fd8d64d.js

@@ -0,0 +1,115 @@
+import { e, y as t, c as r, bx as f, bu as P, db as m, eJ as D, bz as o, ad as I, ea as N } from "./index-4ead5b97.js";
+import { p as z, a as K } from "./ColorStop-6fd09765.js";
+var w;
+let c = w = class extends f {
+  constructor() {
+    super(...arguments), this.field = null, this.minValue = 0, this.maxValue = 255;
+  }
+  clone() {
+    return new w({ field: this.field, minValue: this.minValue, maxValue: this.maxValue });
+  }
+};
+e([t({ type: String, json: { write: !0 } })], c.prototype, "field", void 0), e([t({ type: Number, nonNullable: !0, json: { write: !0 } })], c.prototype, "minValue", void 0), e([t({ type: Number, nonNullable: !0, json: { write: !0 } })], c.prototype, "maxValue", void 0), c = w = e([r("esri.renderers.support.pointCloud.ColorModulation")], c);
+const k = c, v = new P({ pointCloudFixedSizeAlgorithm: "fixed-size", pointCloudSplatAlgorithm: "splat" });
+let b = class extends f {
+};
+e([t({ type: v.apiValues, readOnly: !0, nonNullable: !0, json: { type: v.jsonValues, read: !1, write: v.write } })], b.prototype, "type", void 0), b = e([r("esri.renderers.support.pointCloud.PointSizeAlgorithm")], b);
+const R = b;
+var g;
+let y = g = class extends R {
+  constructor() {
+    super(...arguments), this.type = "fixed-size", this.size = 0, this.useRealWorldSymbolSizes = null;
+  }
+  clone() {
+    return new g({ size: this.size, useRealWorldSymbolSizes: this.useRealWorldSymbolSizes });
+  }
+};
+e([m({ pointCloudFixedSizeAlgorithm: "fixed-size" })], y.prototype, "type", void 0), e([t({ type: Number, nonNullable: !0, json: { write: !0 } })], y.prototype, "size", void 0), e([t({ type: Boolean, json: { write: !0 } })], y.prototype, "useRealWorldSymbolSizes", void 0), y = g = e([r("esri.renderers.support.pointCloud.PointSizeFixedSizeAlgorithm")], y);
+const B = y;
+var V;
+let h = V = class extends R {
+  constructor() {
+    super(...arguments), this.type = "splat", this.scaleFactor = 1;
+  }
+  clone() {
+    return new V({ scaleFactor: this.scaleFactor });
+  }
+};
+e([m({ pointCloudSplatAlgorithm: "splat" })], h.prototype, "type", void 0), e([t({ type: Number, value: 1, nonNullable: !0, json: { write: !0 } })], h.prototype, "scaleFactor", void 0), h = V = e([r("esri.renderers.support.pointCloud.PointSizeSplatAlgorithm")], h);
+const q = h, A = { key: "type", base: R, typeMap: { "fixed-size": B, splat: q } }, T = D()({ pointCloudClassBreaksRenderer: "point-cloud-class-breaks", pointCloudRGBRenderer: "point-cloud-rgb", pointCloudStretchRenderer: "point-cloud-stretch", pointCloudUniqueValueRenderer: "point-cloud-unique-value" });
+let l = class extends f {
+  constructor(O) {
+    super(O), this.type = void 0, this.pointSizeAlgorithm = null, this.colorModulation = null, this.pointsPerInch = 10;
+  }
+  clone() {
+    return console.warn(".clone() is not implemented for " + this.declaredClass), null;
+  }
+  cloneProperties() {
+    return { pointSizeAlgorithm: o(this.pointSizeAlgorithm), colorModulation: o(this.colorModulation), pointsPerInch: o(this.pointsPerInch) };
+  }
+};
+e([t({ type: T.apiValues, readOnly: !0, nonNullable: !0, json: { type: T.jsonValues, read: !1, write: T.write } })], l.prototype, "type", void 0), e([t({ types: A, json: { write: !0 } })], l.prototype, "pointSizeAlgorithm", void 0), e([t({ type: k, json: { write: !0 } })], l.prototype, "colorModulation", void 0), e([t({ json: { write: !0 }, nonNullable: !0, type: Number })], l.prototype, "pointsPerInch", void 0), l = e([r("esri.renderers.PointCloudRenderer")], l), function(s) {
+  s.fieldTransformTypeKebabDict = new P({ none: "none", lowFourBit: "low-four-bit", highFourBit: "high-four-bit", absoluteValue: "absolute-value", moduloTen: "modulo-ten" });
+}(l || (l = {}));
+const i = l;
+var j;
+let n = j = class extends f {
+  constructor() {
+    super(...arguments), this.description = null, this.label = null, this.minValue = 0, this.maxValue = 0, this.color = null;
+  }
+  clone() {
+    return new j({ description: this.description, label: this.label, minValue: this.minValue, maxValue: this.maxValue, color: o(this.color) });
+  }
+};
+e([t({ type: String, json: { write: !0 } })], n.prototype, "description", void 0), e([t({ type: String, json: { write: !0 } })], n.prototype, "label", void 0), e([t({ type: Number, json: { read: { source: "classMinValue" }, write: { target: "classMinValue" } } })], n.prototype, "minValue", void 0), e([t({ type: Number, json: { read: { source: "classMaxValue" }, write: { target: "classMaxValue" } } })], n.prototype, "maxValue", void 0), e([t({ type: I, json: { type: [N], write: !0 } })], n.prototype, "color", void 0), n = j = e([r("esri.renderers.support.pointCloud.ColorClassBreakInfo")], n);
+const M = n;
+var C;
+let p = C = class extends i {
+  constructor(s) {
+    super(s), this.type = "point-cloud-class-breaks", this.field = null, this.legendOptions = null, this.fieldTransformType = null, this.colorClassBreakInfos = null;
+  }
+  clone() {
+    return new C({ ...this.cloneProperties(), field: this.field, fieldTransformType: this.fieldTransformType, colorClassBreakInfos: o(this.colorClassBreakInfos), legendOptions: o(this.legendOptions) });
+  }
+};
+e([m({ pointCloudClassBreaksRenderer: "point-cloud-class-breaks" })], p.prototype, "type", void 0), e([t({ json: { write: !0 }, type: String })], p.prototype, "field", void 0), e([t({ type: z, json: { write: !0 } })], p.prototype, "legendOptions", void 0), e([t({ type: i.fieldTransformTypeKebabDict.apiValues, json: { type: i.fieldTransformTypeKebabDict.jsonValues, read: i.fieldTransformTypeKebabDict.read, write: i.fieldTransformTypeKebabDict.write } })], p.prototype, "fieldTransformType", void 0), e([t({ type: [M], json: { write: !0 } })], p.prototype, "colorClassBreakInfos", void 0), p = C = e([r("esri.renderers.PointCloudClassBreaksRenderer")], p);
+const E = p;
+var S;
+let a = S = class extends i {
+  constructor(s) {
+    super(s), this.type = "point-cloud-stretch", this.field = null, this.legendOptions = null, this.fieldTransformType = null, this.stops = null;
+  }
+  clone() {
+    return new S({ ...this.cloneProperties(), field: o(this.field), fieldTransformType: o(this.fieldTransformType), stops: o(this.stops), legendOptions: o(this.legendOptions) });
+  }
+};
+e([m({ pointCloudStretchRenderer: "point-cloud-stretch" })], a.prototype, "type", void 0), e([t({ json: { write: !0 }, type: String })], a.prototype, "field", void 0), e([t({ type: z, json: { write: !0 } })], a.prototype, "legendOptions", void 0), e([t({ type: i.fieldTransformTypeKebabDict.apiValues, json: { type: i.fieldTransformTypeKebabDict.jsonValues, read: i.fieldTransformTypeKebabDict.read, write: i.fieldTransformTypeKebabDict.write } })], a.prototype, "fieldTransformType", void 0), e([t({ type: [K], json: { write: !0 } })], a.prototype, "stops", void 0), a = S = e([r("esri.renderers.PointCloudStretchRenderer")], a);
+const H = a;
+var x;
+let u = x = class extends f {
+  constructor() {
+    super(...arguments), this.description = null, this.label = null, this.values = null, this.color = null;
+  }
+  clone() {
+    return new x({ description: this.description, label: this.label, values: o(this.values), color: o(this.color) });
+  }
+};
+e([t({ type: String, json: { write: !0 } })], u.prototype, "description", void 0), e([t({ type: String, json: { write: !0 } })], u.prototype, "label", void 0), e([t({ type: [String], json: { write: !0 } })], u.prototype, "values", void 0), e([t({ type: I, json: { type: [N], write: !0 } })], u.prototype, "color", void 0), u = x = e([r("esri.renderers.support.pointCloud.ColorUniqueValueInfo")], u);
+const F = u;
+var $;
+let d = $ = class extends i {
+  constructor(s) {
+    super(s), this.type = "point-cloud-unique-value", this.field = null, this.fieldTransformType = null, this.colorUniqueValueInfos = null, this.legendOptions = null;
+  }
+  clone() {
+    return new $({ ...this.cloneProperties(), field: o(this.field), fieldTransformType: o(this.fieldTransformType), colorUniqueValueInfos: o(this.colorUniqueValueInfos), legendOptions: o(this.legendOptions) });
+  }
+};
+e([m({ pointCloudUniqueValueRenderer: "point-cloud-unique-value" })], d.prototype, "type", void 0), e([t({ json: { write: !0 }, type: String })], d.prototype, "field", void 0), e([t({ type: i.fieldTransformTypeKebabDict.apiValues, json: { type: i.fieldTransformTypeKebabDict.jsonValues, read: i.fieldTransformTypeKebabDict.read, write: i.fieldTransformTypeKebabDict.write } })], d.prototype, "fieldTransformType", void 0), e([t({ type: [F], json: { write: !0 } })], d.prototype, "colorUniqueValueInfos", void 0), e([t({ type: z, json: { write: !0 } })], d.prototype, "legendOptions", void 0), d = $ = e([r("esri.renderers.PointCloudUniqueValueRenderer")], d);
+const L = d;
+export {
+  L as a,
+  H as b,
+  i as c,
+  E as d
+};