import {
  i as i3
} from "./chunk-JOYXMSKE.js";
import {
  a
} from "./chunk-JLYTER4T.js";
import {
  y as y3
} from "./chunk-JGBXYDGB.js";
import {
  T as T2
} from "./chunk-VRLXUHP2.js";
import {
  r as r3
} from "./chunk-5N7JLUJJ.js";
import {
  i as i2
} from "./chunk-ETGAZ7LF.js";
import {
  i
} from "./chunk-75U5LM2V.js";
import {
  v as v2
} from "./chunk-RMDDCMKS.js";
import {
  o,
  s as s2
} from "./chunk-HZRKBTHJ.js";
import {
  o as o2,
  w
} from "./chunk-6T6G6LCQ.js";
import {
  s as s3
} from "./chunk-YEJL5NEF.js";
import {
  k2 as k,
  r as r2
} from "./chunk-PQFTYGF5.js";
import {
  e,
  l3 as l,
  n5 as n,
  s5 as s,
  y3 as y2
} from "./chunk-2Z2TG5CU.js";
import {
  S,
  T,
  b,
  v
} from "./chunk-SQOPWYIT.js";
import {
  y
} from "./chunk-SPWQ3AWG.js";
import {
  r
} from "./chunk-YXWMMD76.js";

// node_modules/@arcgis/core/layers/support/source/MapLayerSource.js
var a2;
var c = a2 = class extends l {
  constructor(r4) {
    super(r4), this.type = "map-layer";
  }
  clone() {
    const { mapLayerId: r4, gdbVersion: o3 } = this;
    return new a2({ mapLayerId: r4, gdbVersion: o3 });
  }
};
e([r3({ mapLayer: "map-layer" })], c.prototype, "type", void 0), e([y2({ type: T, json: { write: true } })], c.prototype, "mapLayerId", void 0), e([y2({ type: String, json: { write: true } })], c.prototype, "gdbVersion", void 0), c = a2 = e([n("esri.layers.support.source.MapLayerSource")], c);

// node_modules/@arcgis/core/layers/support/source/QueryTableDataSource.js
var c2;
var y4 = c2 = class extends l {
  constructor(e2) {
    super(e2), this.type = "query-table";
  }
  clone() {
    var _a;
    const { workspaceId: e2, query: r4, oidFields: o3, spatialReference: t, geometryType: p4 } = this, s4 = { workspaceId: e2, query: r4, oidFields: o3, spatialReference: (_a = t == null ? void 0 : t.clone()) != null ? _a : void 0, geometryType: p4 };
    return new c2(s4);
  }
};
e([r3({ queryTable: "query-table" })], y4.prototype, "type", void 0), e([y2({ type: String, json: { write: true } })], y4.prototype, "workspaceId", void 0), e([y2({ type: String, json: { write: true } })], y4.prototype, "query", void 0), e([y2({ type: String, json: { write: true } })], y4.prototype, "oidFields", void 0), e([y2({ type: k, json: { write: true } })], y4.prototype, "spatialReference", void 0), e([r3(i)], y4.prototype, "geometryType", void 0), y4 = c2 = e([n("esri.layers.support.source.QueryTableDataSource")], y4);

// node_modules/@arcgis/core/layers/support/source/RasterDataSource.js
var p;
var a3 = p = class extends l {
  constructor(r4) {
    super(r4), this.type = "raster";
  }
  clone() {
    const { workspaceId: r4, dataSourceName: o3 } = this;
    return new p({ workspaceId: r4, dataSourceName: o3 });
  }
};
e([r3({ raster: "raster" })], a3.prototype, "type", void 0), e([y2({ type: String, json: { write: true } })], a3.prototype, "dataSourceName", void 0), e([y2({ type: String, json: { write: true } })], a3.prototype, "workspaceId", void 0), a3 = p = e([n("esri.layers.support.source.RasterDataSource")], a3);

// node_modules/@arcgis/core/layers/support/source/TableDataSource.js
var p2;
var a4 = p2 = class extends l {
  constructor(r4) {
    super(r4), this.type = "table";
  }
  clone() {
    const { workspaceId: r4, gdbVersion: o3, dataSourceName: e2 } = this;
    return new p2({ workspaceId: r4, gdbVersion: o3, dataSourceName: e2 });
  }
};
e([r3({ table: "table" })], a4.prototype, "type", void 0), e([y2({ type: String, json: { write: true } })], a4.prototype, "workspaceId", void 0), e([y2({ type: String, json: { write: true } })], a4.prototype, "gdbVersion", void 0), e([y2({ type: String, json: { write: true } })], a4.prototype, "dataSourceName", void 0), a4 = p2 = e([n("esri.layers.support.source.TableDataSource")], a4);

// node_modules/@arcgis/core/layers/support/source/DataLayerSource.js
var d;
var m;
var j = o()({ esriLeftInnerJoin: "left-inner-join", esriLeftOuterJoin: "left-outer-join" });
var T3 = d = class extends l {
  constructor(e2) {
    super(e2), this.type = "join-table";
  }
  readLeftTableSource(e2, r4, o3) {
    return g()(e2, r4, o3);
  }
  castLeftTableSource(e2) {
    return S(L(), e2);
  }
  readRightTableSource(e2, r4, o3) {
    return g()(e2, r4, o3);
  }
  castRightTableSource(e2) {
    return S(L(), e2);
  }
  clone() {
    var _a, _b;
    const { leftTableKey: e2, rightTableKey: r4, leftTableSource: o3, rightTableSource: t, joinType: a5 } = this, s4 = { leftTableKey: e2, rightTableKey: r4, leftTableSource: (_a = o3 == null ? void 0 : o3.clone()) != null ? _a : void 0, rightTableSource: (_b = t == null ? void 0 : t.clone()) != null ? _b : void 0, joinType: a5 };
    return new d(s4);
  }
};
e([r3({ joinTable: "join-table" })], T3.prototype, "type", void 0), e([y2({ type: String, json: { write: true } })], T3.prototype, "leftTableKey", void 0), e([y2({ type: String, json: { write: true } })], T3.prototype, "rightTableKey", void 0), e([y2({ json: { write: true } })], T3.prototype, "leftTableSource", void 0), e([o2("leftTableSource")], T3.prototype, "readLeftTableSource", null), e([s3("leftTableSource")], T3.prototype, "castLeftTableSource", null), e([y2({ json: { write: true } })], T3.prototype, "rightTableSource", void 0), e([o2("rightTableSource")], T3.prototype, "readRightTableSource", null), e([s3("rightTableSource")], T3.prototype, "castRightTableSource", null), e([r3(j)], T3.prototype, "joinType", void 0), T3 = d = e([n("esri.layers.support.source.JoinTableDataSource")], T3);
var h = null;
function g() {
  return h || (h = s({ types: L() })), h;
}
var v3 = null;
function L() {
  return v3 || (v3 = { key: "type", base: null, typeMap: { "data-layer": K, "map-layer": c } }), v3;
}
var w2 = { key: "type", base: null, typeMap: { "join-table": T3, "query-table": y4, raster: a3, table: a4 } };
var K = m = class extends l {
  constructor(e2) {
    super(e2), this.type = "data-layer";
  }
  clone() {
    const { fields: e2, dataSource: r4 } = this;
    return new m({ fields: e2, dataSource: r4 });
  }
};
e([r3({ dataLayer: "data-layer" })], K.prototype, "type", void 0), e([y2({ type: [y3], json: { write: true } })], K.prototype, "fields", void 0), e([y2({ types: w2, json: { write: true } })], K.prototype, "dataSource", void 0), K = m = e([n("esri.layers.support.source.DataLayerSource")], K), K.from = b(K);

// node_modules/@arcgis/core/rest/support/FullTextSearch.js
var i4 = class extends i3(l) {
  constructor(r4) {
    super(r4), this.onFields = null, this.operator = null, this.searchTerm = null, this.searchType = null;
  }
};
e([y2({ type: [String], json: { write: { enabled: true, overridePolicy() {
  return { enabled: r(this.onFields) && this.onFields.length > 0 };
} } } })], i4.prototype, "onFields", void 0), e([y2({ type: String, json: { write: true } })], i4.prototype, "operator", void 0), e([y2({ type: String, json: { write: true } })], i4.prototype, "searchTerm", void 0), e([y2({ type: String, json: { write: true } })], i4.prototype, "searchType", void 0), i4 = e([n("esri.rest.support.FullTextSearch")], i4);
var c3 = i4;

// node_modules/@arcgis/core/rest/support/StatisticDefinition.js
var c4;
var n2 = new s2({ count: "count", sum: "sum", min: "min", max: "max", avg: "avg", stddev: "stddev", var: "var", exceedslimit: "exceedslimit", percentile_cont: "percentile-continuous", percentile_disc: "percentile-discrete", EnvelopeAggregate: "envelope-aggregate", CentroidAggregate: "centroid-aggregate", ConvexHullAggregate: "convex-hull-aggregate" });
var p3 = c4 = class extends l {
  constructor(t) {
    super(t), this.maxPointCount = void 0, this.maxRecordCount = void 0, this.maxVertexCount = void 0, this.onStatisticField = null, this.outStatisticFieldName = null, this.statisticType = null, this.statisticParameters = null;
  }
  writeStatisticParameters(t, e2) {
    "percentile-continuous" !== this.statisticType && "percentile-discrete" !== this.statisticType || (e2.statisticParameters = y(t));
  }
  clone() {
    return new c4({ maxPointCount: this.maxPointCount, maxRecordCount: this.maxRecordCount, maxVertexCount: this.maxVertexCount, onStatisticField: this.onStatisticField, outStatisticFieldName: this.outStatisticFieldName, statisticType: this.statisticType, statisticParameters: y(this.statisticParameters) });
  }
};
e([y2({ type: Number, json: { write: true } })], p3.prototype, "maxPointCount", void 0), e([y2({ type: Number, json: { write: true } })], p3.prototype, "maxRecordCount", void 0), e([y2({ type: Number, json: { write: true } })], p3.prototype, "maxVertexCount", void 0), e([y2({ type: String, json: { write: true } })], p3.prototype, "onStatisticField", void 0), e([y2({ type: String, json: { write: true } })], p3.prototype, "outStatisticFieldName", void 0), e([y2({ type: String, json: { read: { source: "statisticType", reader: n2.read }, write: { target: "statisticType", writer: n2.write } } })], p3.prototype, "statisticType", void 0), e([y2({ type: Object })], p3.prototype, "statisticParameters", void 0), e([r2("statisticParameters")], p3.prototype, "writeStatisticParameters", null), p3 = c4 = e([n("esri.rest.support.StatisticDefinition")], p3);
var m2 = p3;

// node_modules/@arcgis/core/rest/support/Query.js
var v4;
var g2 = new s2({ esriSpatialRelIntersects: "intersects", esriSpatialRelContains: "contains", esriSpatialRelCrosses: "crosses", esriSpatialRelDisjoint: "disjoint", esriSpatialRelEnvelopeIntersects: "envelope-intersects", esriSpatialRelIndexIntersects: "index-intersects", esriSpatialRelOverlaps: "overlaps", esriSpatialRelTouches: "touches", esriSpatialRelWithin: "within", esriSpatialRelRelation: "relation" });
var R = new s2({ esriSRUnit_Meter: "meters", esriSRUnit_Kilometer: "kilometers", esriSRUnit_Foot: "feet", esriSRUnit_StatuteMile: "miles", esriSRUnit_NauticalMile: "nautical-miles", esriSRUnit_USNauticalMile: "us-nautical-miles" });
var b2 = v4 = class extends l {
  constructor(t) {
    super(t), this.aggregateIds = null, this.cacheHint = void 0, this.compactGeometryEnabled = false, this.datumTransformation = null, this.defaultSpatialReferenceEnabled = false, this.distance = void 0, this.dynamicDataSource = void 0, this.formatOf3DObjects = null, this.fullText = null, this.gdbVersion = null, this.geometry = null, this.geometryPrecision = void 0, this.groupByFieldsForStatistics = null, this.having = null, this.historicMoment = null, this.maxAllowableOffset = void 0, this.maxRecordCountFactor = 1, this.multipatchOption = null, this.num = void 0, this.objectIds = null, this.orderByFields = null, this.outFields = null, this.outSpatialReference = null, this.outStatistics = null, this.parameterValues = null, this.pixelSize = null, this.quantizationParameters = null, this.rangeValues = null, this.relationParameter = null, this.resultType = null, this.returnCentroid = false, this.returnDistinctValues = false, this.returnExceededLimitFeatures = true, this.returnGeometry = false, this.returnQueryGeometry = false, this.returnM = void 0, this.returnZ = void 0, this.sourceSpatialReference = null, this.spatialRelationship = "intersects", this.start = void 0, this.sqlFormat = null, this.text = null, this.timeExtent = null, this.timeReferenceUnknownClient = false, this.units = null, this.where = null;
  }
  static from(t) {
    return v(v4, t);
  }
  castDatumTransformation(t) {
    return "number" == typeof t || "object" == typeof t ? t : null;
  }
  writeHistoricMoment(t, e2) {
    e2.historicMoment = t && t.getTime();
  }
  writeParameterValues(t, e2) {
    if (t) {
      const r4 = {};
      for (const e3 in t) {
        const o3 = t[e3];
        Array.isArray(o3) ? r4[e3] = o3.map((t2) => t2 instanceof Date ? t2.getTime() : t2) : o3 instanceof Date ? r4[e3] = o3.getTime() : r4[e3] = o3;
      }
      e2.parameterValues = r4;
    }
  }
  writeStart(t, e2) {
    e2.resultOffset = this.start, e2.resultRecordCount = this.num || 10, e2.where = "1=1";
  }
  writeWhere(t, e2) {
    e2.where = t || "1=1";
  }
  clone() {
    return new v4(y({ aggregateIds: this.aggregateIds, cacheHint: this.cacheHint, compactGeometryEnabled: this.compactGeometryEnabled, datumTransformation: this.datumTransformation, defaultSpatialReferenceEnabled: this.defaultSpatialReferenceEnabled, distance: this.distance, fullText: this.fullText, gdbVersion: this.gdbVersion, geometry: this.geometry, geometryPrecision: this.geometryPrecision, groupByFieldsForStatistics: this.groupByFieldsForStatistics, having: this.having, historicMoment: r(this.historicMoment) ? new Date(this.historicMoment.getTime()) : null, maxAllowableOffset: this.maxAllowableOffset, maxRecordCountFactor: this.maxRecordCountFactor, multipatchOption: this.multipatchOption, num: this.num, objectIds: this.objectIds, orderByFields: this.orderByFields, outFields: this.outFields, outSpatialReference: this.outSpatialReference, outStatistics: this.outStatistics, parameterValues: this.parameterValues, pixelSize: this.pixelSize, quantizationParameters: this.quantizationParameters, rangeValues: this.rangeValues, relationParameter: this.relationParameter, resultType: this.resultType, returnDistinctValues: this.returnDistinctValues, returnGeometry: this.returnGeometry, returnCentroid: this.returnCentroid, returnExceededLimitFeatures: this.returnExceededLimitFeatures, returnQueryGeometry: this.returnQueryGeometry, returnM: this.returnM, returnZ: this.returnZ, dynamicDataSource: this.dynamicDataSource, sourceSpatialReference: this.sourceSpatialReference, spatialRelationship: this.spatialRelationship, start: this.start, sqlFormat: this.sqlFormat, text: this.text, timeExtent: this.timeExtent, timeReferenceUnknownClient: this.timeReferenceUnknownClient, units: this.units, where: this.where }));
  }
};
b2.MAX_MAX_RECORD_COUNT_FACTOR = 5, e([y2({ json: { write: true } })], b2.prototype, "aggregateIds", void 0), e([y2({ type: Boolean, json: { write: true } })], b2.prototype, "cacheHint", void 0), e([y2({ type: Boolean, json: { default: false, write: true } })], b2.prototype, "compactGeometryEnabled", void 0), e([y2({ json: { write: true } })], b2.prototype, "datumTransformation", void 0), e([s3("datumTransformation")], b2.prototype, "castDatumTransformation", null), e([y2({ type: Boolean, json: { default: false, write: true } })], b2.prototype, "defaultSpatialReferenceEnabled", void 0), e([y2({ type: Number, json: { write: { overridePolicy: (t) => ({ enabled: t > 0 }) } } })], b2.prototype, "distance", void 0), e([y2({ type: K, json: { write: true } })], b2.prototype, "dynamicDataSource", void 0), e([y2({ type: String, json: { write: true } })], b2.prototype, "formatOf3DObjects", void 0), e([y2({ type: [c3], json: { write: { enabled: true, overridePolicy() {
  return { enabled: r(this.fullText) && this.fullText.length > 0 };
} } } })], b2.prototype, "fullText", void 0), e([y2({ type: String, json: { write: true } })], b2.prototype, "gdbVersion", void 0), e([y2({ types: i2, json: { read: v2, write: true } })], b2.prototype, "geometry", void 0), e([y2({ type: Number, json: { write: true } })], b2.prototype, "geometryPrecision", void 0), e([y2({ type: [String], json: { write: true } })], b2.prototype, "groupByFieldsForStatistics", void 0), e([y2({ type: String, json: { write: true } })], b2.prototype, "having", void 0), e([y2({ type: Date })], b2.prototype, "historicMoment", void 0), e([r2("historicMoment")], b2.prototype, "writeHistoricMoment", null), e([y2({ type: Number, json: { write: true } })], b2.prototype, "maxAllowableOffset", void 0), e([y2({ type: Number, cast: (t) => t < 1 ? 1 : t > v4.MAX_MAX_RECORD_COUNT_FACTOR ? v4.MAX_MAX_RECORD_COUNT_FACTOR : t, json: { write: { overridePolicy: (t) => ({ enabled: t > 1 }) } } })], b2.prototype, "maxRecordCountFactor", void 0), e([y2({ type: ["xyFootprint"], json: { write: true } })], b2.prototype, "multipatchOption", void 0), e([y2({ type: Number, json: { read: { source: "resultRecordCount" } } })], b2.prototype, "num", void 0), e([y2({ json: { write: true } })], b2.prototype, "objectIds", void 0), e([y2({ type: [String], json: { write: true } })], b2.prototype, "orderByFields", void 0), e([y2({ type: [String], json: { write: true } })], b2.prototype, "outFields", void 0), e([y2({ type: k, json: { name: "outSR", write: true } })], b2.prototype, "outSpatialReference", void 0), e([y2({ type: [m2], json: { write: { enabled: true, overridePolicy() {
  return { enabled: r(this.outStatistics) && this.outStatistics.length > 0 };
} } } })], b2.prototype, "outStatistics", void 0), e([y2({ json: { write: true } })], b2.prototype, "parameterValues", void 0), e([r2("parameterValues")], b2.prototype, "writeParameterValues", null), e([y2({ type: w, json: { write: true } })], b2.prototype, "pixelSize", void 0), e([y2({ type: a, json: { write: true } })], b2.prototype, "quantizationParameters", void 0), e([y2({ type: [Object], json: { write: true } })], b2.prototype, "rangeValues", void 0), e([y2({ type: String, json: { read: { source: "relationParam" }, write: { target: "relationParam", overridePolicy() {
  return { enabled: "relation" === this.spatialRelationship };
} } } })], b2.prototype, "relationParameter", void 0), e([y2({ type: String, json: { write: true } })], b2.prototype, "resultType", void 0), e([y2({ type: Boolean, json: { default: false, write: true } })], b2.prototype, "returnCentroid", void 0), e([y2({ type: Boolean, json: { default: false, write: true } })], b2.prototype, "returnDistinctValues", void 0), e([y2({ type: Boolean, json: { default: true, write: true } })], b2.prototype, "returnExceededLimitFeatures", void 0), e([y2({ type: Boolean, json: { write: true } })], b2.prototype, "returnGeometry", void 0), e([y2({ type: Boolean, json: { default: false, write: true } })], b2.prototype, "returnQueryGeometry", void 0), e([y2({ type: Boolean, json: { default: false, write: true } })], b2.prototype, "returnM", void 0), e([y2({ type: Boolean, json: { write: { overridePolicy: (t) => ({ enabled: t }) } } })], b2.prototype, "returnZ", void 0), e([y2({ type: k, json: { write: true } })], b2.prototype, "sourceSpatialReference", void 0), e([r3(g2, { ignoreUnknown: false, name: "spatialRel" })], b2.prototype, "spatialRelationship", void 0), e([y2({ type: Number, json: { read: { source: "resultOffset" } } })], b2.prototype, "start", void 0), e([r2("start"), r2("num")], b2.prototype, "writeStart", null), e([y2({ type: String, json: { write: true } })], b2.prototype, "sqlFormat", void 0), e([y2({ type: String, json: { write: true } })], b2.prototype, "text", void 0), e([y2({ type: T2, json: { write: true } })], b2.prototype, "timeExtent", void 0), e([y2({ type: Boolean, json: { default: false, write: true } })], b2.prototype, "timeReferenceUnknownClient", void 0), e([r3(R, { ignoreUnknown: false }), y2({ json: { write: { overridePolicy(t) {
  return { enabled: !!t && null != this.distance && this.distance > 0 };
} } } })], b2.prototype, "units", void 0), e([y2({ type: String, json: { write: { overridePolicy(t) {
  return { enabled: null != t || null != this.start && this.start > 0 };
} } } })], b2.prototype, "where", void 0), e([r2("where")], b2.prototype, "writeWhere", null), b2 = v4 = e([n("esri.rest.support.Query")], b2);
var x = b2;

export {
  c,
  K,
  m2 as m,
  x
};
//# sourceMappingURL=chunk-WD4J43GZ.js.map