@vertigis/arcgis-extensions 48.4.0 → 48.4.1

package/AppConfig.schema.json

@@ -827,6 +827,10 @@
                 "type": {
                     "$ref": "#/definitions/FieldJsonType",
                     "description": "Type of the Field. See {@link FieldJsonType}."
+                },
+                "visible": {
+                    "description": "<not in spec>.",
+                    "type": "boolean"
                 }
             },
             "type": "object"
@@ -1234,6 +1238,10 @@
                     "description": "Primarily applies to thumbnails associated with an application. The URL\nto the thumbnail used for the application.",
                     "type": "string"
                 },
+                "lastViewed": {
+                    "description": "The date/time the item was last accessed in UNIX format (in\nmilliseconds).",
+                    "type": "number"
+                },
                 "licenseInfo": {
                     "description": "Any license information or restrictions.",
                     "type": "string"
@@ -1511,7 +1519,17 @@
                         {
                             "allOf": [
                                 {
-                                    "$ref": "#/definitions/GroupLayerJson"
+                                    "$ref": "#/definitions/RasterDataElevationLayerJson"
+                                },
+                                {
+                                    "$ref": "#/definitions/__type"
+                                }
+                            ]
+                        },
+                        {
+                            "allOf": [
+                                {
+                                    "$ref": "#/definitions/TiledElevationServiceLayerJson"
                                 },
                                 {
                                     "$ref": "#/definitions/__type"
@@ -1548,6 +1566,16 @@
                                 }
                             ]
                         },
+                        {
+                            "allOf": [
+                                {
+                                    "$ref": "#/definitions/GroupLayerJson"
+                                },
+                                {
+                                    "$ref": "#/definitions/__type"
+                                }
+                            ]
+                        },
                         {
                             "allOf": [
                                 {
@@ -1707,26 +1735,6 @@
                                     "$ref": "#/definitions/__type"
                                 }
                             ]
-                        },
-                        {
-                            "allOf": [
-                                {
-                                    "$ref": "#/definitions/TiledElevationServiceLayerJson"
-                                },
-                                {
-                                    "$ref": "#/definitions/__type"
-                                }
-                            ]
-                        },
-                        {
-                            "allOf": [
-                                {
-                                    "$ref": "#/definitions/RasterDataElevationLayerJson"
-                                },
-                                {
-                                    "$ref": "#/definitions/__type"
-                                }
-                            ]
                         }
                     ],
                     "description": "See {@link mapping /_LayerExtension!LayerExtension.layer}."

package/data/FeatureSettings.js

@@ -1 +1 @@
-import{__decorate as t}from"tslib";import e from"@arcgis/core/PopupTemplate";import{Hyperlink as i}from"../Hyperlink.js";import{isPopupContentExtension as n}from"../ItemType.js";import{ArrayWrappedCollection as o}from"../mapping/support/ArrayWrappedCollection.js";import{FormatSettings as s}from"../support/FormatSettings.js";import{InitializableCollectionProxy as r}from"../support/InitializableCollectionProxy.js";import{filterJSONProperties as p,isDefault as a,serializable as u,shouldExcludeDefaults as l}from"../support/Serializable.js";import{Settings as h}from"../support/Settings.js";import{compare as f}from"../utilities/array.js";import{checkArg as d}from"../utilities/checkArg.js";import{getAllFieldInfos as m,getAllReferencedFieldNames as c,isPopupTemplate as _}from"../utilities/esri.js";import{isArcadeExpressionField as g,isRelationshipField as S}from"../utilities/field.js";import{objectKeys as C}from"../utilities/object.js";import{isQueryBasedRelationship as y}from"../utilities/relationships.js";import{caseInsensitiveEquals as T}from"../utilities/string.js";import{onCollectionPropertyChange as x}from"../utilities/watch.js";import{PopupContentExtension as z,_popupContentExtensionMap as E}from"./PopupContentExtension.js";let v=class extends h{popupContentExtensions;_isDefaultPopupTemplate=!1;_popupContentCollection;get _popupContent(){return this._popupContentCollection}get hyperlinkTemplates(){return this._getCollectionSetting("hyperlinkTemplates")}get popupTemplate(){return this._getSetting("popupTemplate")}set popupTemplate(t){let i;i=t instanceof Object&&!_(t)?e.fromJSON(t):t;const n=this?._feature?.schema?.createPopupTemplate()??this?._featureSource?.schema?.createPopupTemplate();i&&n&&(i.content=i.content??n.content,i.fieldInfos=i.fieldInfos??n.fieldInfos),this._setSetting("popupTemplate",i),this._isDefaultPopupTemplate=!1}get showRelatedRecordsWhenUnconfigured(){return this._getSetting("showRelatedRecordsWhenUnconfigured",!0)}set showRelatedRecordsWhenUnconfigured(t){this._setSetting("showRelatedRecordsWhenUnconfigured",t)}get formatSettings(){return this._getNestedSettings("formatSettings",(()=>new s))}get returnGeometry(){return this._getSetting("returnGeometry",!0)}set returnGeometry(t){this._setSetting("returnGeometry",t)}get outFields(){return this._getSetting("outFields",this._defaultOutFields)}set outFields(t){this._setSetting("outFields",t)}get outSpatialReference(){return this._getSetting("outSpatialReference")}set outSpatialReference(t){this._setSetting("outSpatialReference",t)}get maxAllowableOffset(){return this._getSetting("maxAllowableOffset")}set maxAllowableOffset(t){this._setSetting("maxAllowableOffset",t)}get zoomScale(){return this._getSetting("zoomScale")}set zoomScale(t){this._setSetting("zoomScale",t)}get zoomFactor(){const t=this._feature?this._feature.schema:this._featureSource?.schema,e=t&&"point"===t.geometryType?void 0:1.5;return this._getSetting("zoomFactor",e)}set zoomFactor(t){this._setSetting("zoomFactor",t)}get featureSource(){return this._featureSource}get feature(){return this._feature}_featureSource;_feature;constructor(t){super(t),this._popupContentCollection=this._createPopupContentCollection(),this.popupContentExtensions=new A(this)}get _defaultOutFields(){const t=m(this.popupTemplate),e=this.featureSource?.schema?.primaryKeyField;if(t&&e){const i=new Set;i.add(e);const n=this.featureSource.schema.fields.toArray().map((t=>t.name)),o=new Set([...c(this.popupTemplate),...this.hyperlinkTemplates.toArray().flatMap((t=>t.getReferencedFields()))]),s=t.filter((t=>t.visible||t.isEditable&&this.featureSource.capabilities.supportsEditing)).map((t=>t.fieldName)).concat(...o).filter((t=>n.some((e=>T(e,t)))));return this._featureSource.relationships.forEach((t=>{y(t)&&s.push(t.keyField)})),s.filter((t=>!(g(t)||S(t)))).forEach((t=>i.add(t))),Array.from(i.values())}return["*"]}_setFeatureSource(t){this._featureSource=t,this.notifyChange("featureSource")}_setFeature(t){this._feature=t,this.notifyChange("feature")}toJSON(t="all"){const e=p(this._getSerializableProperties(),this,t)||{},i=e.popupContentExtensions?.filter((t=>{const e=this.parent;return!e?.popupContentExtensions?.some((e=>e.id===t.id))}));if(e)for(const t of C(e))this.isModified(t)||delete e[t];if(i?.length&&(e.popupContentExtensions=i),!l(t)||!a(e))return e}_createPopupContentCollection(){return new o({parent:this,targetProperty:"popupTemplate",arrayProperty:"content"})}_getSerializableProperties(){return{hyperlinkTemplates:{serializeModes:["initial"],deserialize:t=>{t.forEach((t=>{this.hyperlinkTemplates.find((e=>this._hyperlinksAreEquivalent(e,t)))||this.hyperlinkTemplates.add(t instanceof i?t:new i(t))})),this.hyperlinkTemplates.toArray().forEach((e=>{const i=this.hyperlinkTemplates.indexOf(e),n=t.findIndex((t=>this._hyperlinksAreEquivalent(t,e)));n<0?this.hyperlinkTemplates.removeAt(i):n!==i&&this.hyperlinkTemplates.reorder(e,n)}))}},popupTemplate:{serializeModes:["project"],isDefault:()=>!this._isDefaultPopupTemplate},showRelatedRecordsWhenUnconfigured:{serializeModes:["initial"],default:!0},formatSettings:"initial",outFields:{serializeModes:["initial"],serialize:()=>this.isModified("outFields")?this.outFields:void 0},returnGeometry:{serializeModes:["initial"],default:!0},outSpatialReference:"initial",maxAllowableOffset:"initial",zoomScale:"initial",zoomFactor:{serializeModes:["initial"],isDefault:t=>{const e=this._feature?this._feature.schema:this._featureSource?.schema;return t===(e&&"point"===e.geometryType?void 0:1.5)}},popupContentExtensions:{serializeModes:["initial"],serialize:t=>this.popupContentExtensions.map((e=>e.toJSON(t))).filter((t=>!(t&&2===Object.keys(t).length&&t.id&&t.content))).toArray(),deserialize:t=>{t&&f(this.popupContentExtensions,t,{onNew:(t,e)=>{this.popupContentExtensions.add(n(t)?t:new z(t),e)},onMatch:(t,e,i,o)=>{n(e)||t.assignProperties(e),i!==o&&this.popupContentExtensions.reorder(t,o)},onMissing:t=>{this.popupContentExtensions.remove(t)},equals:(t,e)=>n(e)?e===t||e.id===t.id:!(!e?.content||!z.matchesRef(this.popupContentExtensions.toArray(),this.popupContentExtensions.indexOf(t),e.content))||t.id===e.id})}}}}_hyperlinksAreEquivalent(t,e){if(t===e)return!0;const i=t=>t||"";return i(t.text)===i(e.text)&&i(t.url)===i(e.url)&&i(t.iconUrl)===i(e.iconUrl)&&i(t.target)===i(e.target)&&i(t.tooltip)===i(e.tooltip)}};v=t([u],v);export{v as FeatureSettings};class A extends r{get _collection(){return this._featureSettings._popupContent.map((t=>this._forContent(t))).concat(Array.from(this._uninitializedPopupContentExtensions))}get _popupTemplateIsInherited(){return this._featureSettings.parent&&this._featureSettings.popupTemplate===this._featureSettings.parent.popupTemplate}_featureSettings;_uninitializedPopupContentExtensions=new Set;constructor(t){super(),this._featureSettings=t,x(this._featureSettings,"_popupContent",(t=>{const e={added:(t.added||[]).map((t=>this._forContent(t))),moved:(t.moved||[]).map((t=>this._forContent(t))),removed:(t.removed||[]).map((t=>this._forContent(t))),target:this};this.emit("change",e)})),t.watch("_popupContent.length",(()=>this.notifyChange("length")))}forContent(t){if(d("content",t).isNotMissing(),this._featureSettings._popupContent.includes(t))return this._forContent(t)}add(t,i){if(d("contentX",t).isNotMissing(),this._popupTemplateIsInherited&&(this._featureSettings.popupTemplate=new e({content:this._featureSettings._popupContent.toArray()})),t.featureSettings&&t.featureSettings.popupContentExtensions.remove(t),t._setFeatureSettings(this._featureSettings),t.content){const e=E.get(t.content);if(E.set(t.content,t),e&&e!==t&&this._onRemoved(e),this._featureSettings._popupContent.includes(t.content))if(void 0===i){const i={added:[t],moved:[],removed:e?[e]:[],target:this};this.emit("change",i)}else this._featureSettings._popupContent.reorder(t.content,i);else this._featureSettings._popupContent.add(t.content,i)}else{this._uninitializedPopupContentExtensions.add(t);const e={added:[t],moved:[],removed:[],target:this};this.emit("change",e)}return this._onAdded(t),this}removeAt(t){const i=this.getItemAt(t);if(void 0!==i){if(this._popupTemplateIsInherited&&(this._featureSettings.popupTemplate=new e({content:this._featureSettings._popupContent.toArray()})),this._uninitializedPopupContentExtensions.has(i)){this._uninitializedPopupContentExtensions.delete(i);const t={added:[],moved:[],removed:[i],target:this};this.emit("change",t)}else this._featureSettings._popupContent.remove(i.content);return this._onRemoved(i),i}}reorder(t,i){if(t&&this._featureSettings._popupContent.includes(t.content))return this._popupTemplateIsInherited&&(this._featureSettings.popupTemplate=new e({content:this._featureSettings._popupContent.toArray()})),this._featureSettings._popupContent.reorder(t.content,i),t}sort(t){return this._popupTemplateIsInherited&&(this._featureSettings.popupTemplate=new e({content:this._featureSettings._popupContent.toArray()})),this._featureSettings._popupContent.sort(((e,i)=>t(this._forContent(e),this._forContent(i)))),this}_itemIsInitialized(t){return super._itemIsInitialized(t)&&!!t.content}_onAdded(t){}_onRemoved(t){t.featureSettings===this._featureSettings&&t._setFeatureSettings(void 0)}_forContent(t){if(this._uninitializedPopupContentExtensions.size)for(const t of this._uninitializedPopupContentExtensions)t._resolveContent(),t.content&&(E.set(t.content,t),this._uninitializedPopupContentExtensions.delete(t));if(!E.has(t)){const e=new z({content:t});E.set(t,e),e._setFeatureSettings(this._featureSettings),this._onAdded(e)}return E.get(t)}}
+import{__decorate as t}from"tslib";import e from"@arcgis/core/PopupTemplate";import{Hyperlink as i}from"../Hyperlink.js";import{isPopupContentExtension as n}from"../ItemType.js";import{ArrayWrappedCollection as o}from"../mapping/support/ArrayWrappedCollection.js";import{FormatSettings as s}from"../support/FormatSettings.js";import{InitializableCollectionProxy as r}from"../support/InitializableCollectionProxy.js";import{filterJSONProperties as p,isDefault as a,serializable as u,shouldExcludeDefaults as l}from"../support/Serializable.js";import{Settings as h}from"../support/Settings.js";import{compare as f}from"../utilities/array.js";import{checkArg as d}from"../utilities/checkArg.js";import{getAllFieldInfos as m,getAllReferencedFieldNames as c,isPopupTemplate as _}from"../utilities/esri.js";import{isArcadeExpressionField as g,isRelationshipField as S}from"../utilities/field.js";import{objectKeys as C}from"../utilities/object.js";import{isQueryBasedRelationship as y}from"../utilities/relationships.js";import{caseInsensitiveEquals as T}from"../utilities/string.js";import{onCollectionPropertyChange as x}from"../utilities/watch.js";import{PopupContentExtension as z,_popupContentExtensionMap as E}from"./PopupContentExtension.js";let v=class extends h{popupContentExtensions;_isDefaultPopupTemplate=!1;_popupContentCollection;get _popupContent(){return this._popupContentCollection}get hyperlinkTemplates(){return this._getCollectionSetting("hyperlinkTemplates")}get popupTemplate(){return this._getSetting("popupTemplate")}set popupTemplate(t){let i;i=t instanceof Object&&!_(t)?e.fromJSON(t):t;const n=this?._feature?.schema?.createPopupTemplate()??this?._featureSource?.schema?.createPopupTemplate();i&&n&&(i.content=i.content??n.content,i.fieldInfos=i.fieldInfos??n.fieldInfos),this._setSetting("popupTemplate",i),this._isDefaultPopupTemplate=!1}get showRelatedRecordsWhenUnconfigured(){return this._getSetting("showRelatedRecordsWhenUnconfigured",!0)}set showRelatedRecordsWhenUnconfigured(t){this._setSetting("showRelatedRecordsWhenUnconfigured",t)}get formatSettings(){return this._getNestedSettings("formatSettings",(()=>new s))}get returnGeometry(){return this._getSetting("returnGeometry",!0)}set returnGeometry(t){this._setSetting("returnGeometry",t)}get outFields(){return this._getSetting("outFields",this._defaultOutFields)}set outFields(t){this._setSetting("outFields",t)}get outSpatialReference(){return this._getSetting("outSpatialReference")}set outSpatialReference(t){this._setSetting("outSpatialReference",t)}get maxAllowableOffset(){return this._getSetting("maxAllowableOffset")}set maxAllowableOffset(t){this._setSetting("maxAllowableOffset",t)}get zoomScale(){return this._getSetting("zoomScale")}set zoomScale(t){this._setSetting("zoomScale",t)}get zoomFactor(){const t=this._feature?this._feature.schema:this._featureSource?.schema,e=t&&"point"===t.geometryType?void 0:1.5;return this._getSetting("zoomFactor",e)}set zoomFactor(t){this._setSetting("zoomFactor",t)}get featureSource(){return this._featureSource}get feature(){return this._feature}_featureSource;_feature;constructor(t){super(t),this._popupContentCollection=this._createPopupContentCollection(),this.popupContentExtensions=new A(this)}get _defaultOutFields(){if(null==this.popupTemplate)return["*"];const t=m(this.popupTemplate),e=this.featureSource?.schema?.primaryKeyField;if(t&&e){const i=new Set;i.add(e);const n=this.featureSource.schema.fields.toArray().map((t=>t.name)),o=new Set([...c(this.popupTemplate),...this.hyperlinkTemplates.toArray().flatMap((t=>t.getReferencedFields()))]),s=t.filter((t=>t.visible||t.isEditable&&this.featureSource.capabilities.supportsEditing)).map((t=>t.fieldName)).concat(...o).filter((t=>n.some((e=>T(e,t)))));return this._featureSource.relationships.forEach((t=>{y(t)&&s.push(t.keyField)})),s.filter((t=>!(g(t)||S(t)))).forEach((t=>i.add(t))),Array.from(i.values())}return["*"]}_setFeatureSource(t){this._featureSource=t,this.notifyChange("featureSource")}_setFeature(t){this._feature=t,this.notifyChange("feature")}toJSON(t="all"){const e=p(this._getSerializableProperties(),this,t)||{},i=e.popupContentExtensions?.filter((t=>{const e=this.parent;return!e?.popupContentExtensions?.some((e=>e.id===t.id))}));if(e)for(const t of C(e))this.isModified(t)||delete e[t];if(i?.length&&(e.popupContentExtensions=i),!l(t)||!a(e))return e}_createPopupContentCollection(){return new o({parent:this,targetProperty:"popupTemplate",arrayProperty:"content"})}_getSerializableProperties(){return{hyperlinkTemplates:{serializeModes:["initial"],deserialize:t=>{t.forEach((t=>{this.hyperlinkTemplates.find((e=>this._hyperlinksAreEquivalent(e,t)))||this.hyperlinkTemplates.add(t instanceof i?t:new i(t))})),this.hyperlinkTemplates.toArray().forEach((e=>{const i=this.hyperlinkTemplates.indexOf(e),n=t.findIndex((t=>this._hyperlinksAreEquivalent(t,e)));n<0?this.hyperlinkTemplates.removeAt(i):n!==i&&this.hyperlinkTemplates.reorder(e,n)}))}},popupTemplate:{serializeModes:["project"],isDefault:()=>!this._isDefaultPopupTemplate},showRelatedRecordsWhenUnconfigured:{serializeModes:["initial"],default:!0},formatSettings:"initial",outFields:{serializeModes:["initial"],serialize:()=>this.isModified("outFields")?this.outFields:void 0},returnGeometry:{serializeModes:["initial"],default:!0},outSpatialReference:"initial",maxAllowableOffset:"initial",zoomScale:"initial",zoomFactor:{serializeModes:["initial"],isDefault:t=>{const e=this._feature?this._feature.schema:this._featureSource?.schema;return t===(e&&"point"===e.geometryType?void 0:1.5)}},popupContentExtensions:{serializeModes:["initial"],serialize:t=>this.popupContentExtensions.map((e=>e.toJSON(t))).filter((t=>!(t&&2===Object.keys(t).length&&t.id&&t.content))).toArray(),deserialize:t=>{t&&f(this.popupContentExtensions,t,{onNew:(t,e)=>{this.popupContentExtensions.add(n(t)?t:new z(t),e)},onMatch:(t,e,i,o)=>{n(e)||t.assignProperties(e),i!==o&&this.popupContentExtensions.reorder(t,o)},onMissing:t=>{this.popupContentExtensions.remove(t)},equals:(t,e)=>n(e)?e===t||e.id===t.id:!(!e?.content||!z.matchesRef(this.popupContentExtensions.toArray(),this.popupContentExtensions.indexOf(t),e.content))||t.id===e.id})}}}}_hyperlinksAreEquivalent(t,e){if(t===e)return!0;const i=t=>t||"";return i(t.text)===i(e.text)&&i(t.url)===i(e.url)&&i(t.iconUrl)===i(e.iconUrl)&&i(t.target)===i(e.target)&&i(t.tooltip)===i(e.tooltip)}};v=t([u],v);export{v as FeatureSettings};class A extends r{get _collection(){return this._featureSettings._popupContent.map((t=>this._forContent(t))).concat(Array.from(this._uninitializedPopupContentExtensions))}get _popupTemplateIsInherited(){return this._featureSettings.parent&&this._featureSettings.popupTemplate===this._featureSettings.parent.popupTemplate}_featureSettings;_uninitializedPopupContentExtensions=new Set;constructor(t){super(),this._featureSettings=t,x(this._featureSettings,"_popupContent",(t=>{const e={added:(t.added||[]).map((t=>this._forContent(t))),moved:(t.moved||[]).map((t=>this._forContent(t))),removed:(t.removed||[]).map((t=>this._forContent(t))),target:this};this.emit("change",e)})),t.watch("_popupContent.length",(()=>this.notifyChange("length")))}forContent(t){if(d("content",t).isNotMissing(),this._featureSettings._popupContent.includes(t))return this._forContent(t)}add(t,i){if(d("contentX",t).isNotMissing(),this._popupTemplateIsInherited&&(this._featureSettings.popupTemplate=new e({content:this._featureSettings._popupContent.toArray()})),t.featureSettings&&t.featureSettings.popupContentExtensions.remove(t),t._setFeatureSettings(this._featureSettings),t.content){const e=E.get(t.content);if(E.set(t.content,t),e&&e!==t&&this._onRemoved(e),this._featureSettings._popupContent.includes(t.content))if(void 0===i){const i={added:[t],moved:[],removed:e?[e]:[],target:this};this.emit("change",i)}else this._featureSettings._popupContent.reorder(t.content,i);else this._featureSettings._popupContent.add(t.content,i)}else{this._uninitializedPopupContentExtensions.add(t);const e={added:[t],moved:[],removed:[],target:this};this.emit("change",e)}return this._onAdded(t),this}removeAt(t){const i=this.getItemAt(t);if(void 0!==i){if(this._popupTemplateIsInherited&&(this._featureSettings.popupTemplate=new e({content:this._featureSettings._popupContent.toArray()})),this._uninitializedPopupContentExtensions.has(i)){this._uninitializedPopupContentExtensions.delete(i);const t={added:[],moved:[],removed:[i],target:this};this.emit("change",t)}else this._featureSettings._popupContent.remove(i.content);return this._onRemoved(i),i}}reorder(t,i){if(t&&this._featureSettings._popupContent.includes(t.content))return this._popupTemplateIsInherited&&(this._featureSettings.popupTemplate=new e({content:this._featureSettings._popupContent.toArray()})),this._featureSettings._popupContent.reorder(t.content,i),t}sort(t){return this._popupTemplateIsInherited&&(this._featureSettings.popupTemplate=new e({content:this._featureSettings._popupContent.toArray()})),this._featureSettings._popupContent.sort(((e,i)=>t(this._forContent(e),this._forContent(i)))),this}_itemIsInitialized(t){return super._itemIsInitialized(t)&&!!t.content}_onAdded(t){}_onRemoved(t){t.featureSettings===this._featureSettings&&t._setFeatureSettings(void 0)}_forContent(t){if(this._uninitializedPopupContentExtensions.size)for(const t of this._uninitializedPopupContentExtensions)t._resolveContent(),t.content&&(E.set(t.content,t),this._uninitializedPopupContentExtensions.delete(t));if(!E.has(t)){const e=new z({content:t});E.set(t,e),e._setFeatureSettings(this._featureSettings),this._onAdded(e)}return E.get(t)}}

package/data/_TableExtension.d.ts

@@ -125,7 +125,7 @@ export declare class TableSchema extends Schema {
     /**
      * Maps schema properties to equivalent properties on the table.
      */
-    protected readonly _tableBindings: Map<keyof this, "listMode" | "title" | "url" | "id" | "gdbVersion" | "fields" | "hasM" | "hasZ" | "watch" | "get" | "set" | "emit" | "hasEventListener" | "on" | "destroy" | "spatialReference" | "popupTemplate" | "destroyed" | "initialized" | "declaredClass" | "addHandles" | "removeHandles" | "hasHandles" | "labelingInfo" | "renderer" | "refresh" | "mode" | "elevationInfo" | "clone" | "floorInfo" | "opacity" | "visible" | "definitionExpression" | "outFields" | "popupEnabled" | "createPopupTemplate" | "createQuery" | "getField" | "getFieldDomain" | "queryExtent" | "queryFeatureCount" | "queryFeatures" | "queryObjectIds" | "objectIdField" | "geometryType" | "cancelLoad" | "isFulfilled" | "isRejected" | "isResolved" | "load" | "when" | "labelsVisible" | "customParameters" | "maxScale" | "minScale" | "save" | "saveAs" | "fullExtent" | "parent" | "persistenceEnabled" | "visibilityTimeExtent" | "createLayerView" | "fetchAttributionData" | "portalItem" | "sourceJSON" | "legendEnabled" | "formTemplate" | "refreshInterval" | "blendMode" | "effect" | "copyright" | "addAttachment" | "deleteAttachments" | "attributeTableTemplate" | "charts" | "dynamicDataSource" | "editingEnabled" | "displayField" | "typeIdField" | "types" | "layerId" | "apiKey" | "dateFieldsTimeZone" | "screenSizePerspectiveEnabled" | "orderBy" | "timeExtent" | "timeInfo" | "timeOffset" | "useViewTime" | "featureEffect" | "featureReduction" | "source" | "historicMoment" | "returnM" | "returnZ" | "templates" | "getFeatureType" | "queryTopFeatureCount" | "queryTopFeatures" | "queryTopFeaturesExtent" | "queryTopObjectIds" | "applyEdits" | "queryAttachments" | "queryRelatedFeatures" | "queryRelatedFeaturesCount" | "updateAttachment">;
+    protected readonly _tableBindings: Map<keyof this, "listMode" | "title" | "url" | "id" | "gdbVersion" | "fields" | "hasM" | "hasZ" | "watch" | "get" | "set" | "emit" | "hasEventListener" | "on" | "destroy" | "destroyed" | "initialized" | "declaredClass" | "addHandles" | "removeHandles" | "hasHandles" | "labelingInfo" | "renderer" | "refresh" | "spatialReference" | "mode" | "elevationInfo" | "clone" | "floorInfo" | "opacity" | "visible" | "definitionExpression" | "outFields" | "popupEnabled" | "popupTemplate" | "createPopupTemplate" | "createQuery" | "getField" | "getFieldDomain" | "queryExtent" | "queryFeatureCount" | "queryFeatures" | "queryObjectIds" | "objectIdField" | "geometryType" | "cancelLoad" | "isFulfilled" | "isRejected" | "isResolved" | "load" | "when" | "labelsVisible" | "customParameters" | "maxScale" | "minScale" | "save" | "saveAs" | "fullExtent" | "parent" | "persistenceEnabled" | "visibilityTimeExtent" | "createLayerView" | "fetchAttributionData" | "portalItem" | "sourceJSON" | "legendEnabled" | "formTemplate" | "refreshInterval" | "blendMode" | "effect" | "copyright" | "addAttachment" | "deleteAttachments" | "attributeTableTemplate" | "charts" | "dynamicDataSource" | "editingEnabled" | "displayField" | "typeIdField" | "types" | "layerId" | "apiKey" | "dateFieldsTimeZone" | "screenSizePerspectiveEnabled" | "orderBy" | "timeExtent" | "timeInfo" | "timeOffset" | "useViewTime" | "featureEffect" | "featureReduction" | "source" | "historicMoment" | "returnM" | "returnZ" | "templates" | "getFeatureType" | "queryTopFeatureCount" | "queryTopFeatures" | "queryTopFeaturesExtent" | "queryTopObjectIds" | "applyEdits" | "queryAttachments" | "queryRelatedFeatures" | "queryRelatedFeaturesCount" | "updateAttachment">;
     /**
      * The collection of fields.
      */

package/docs/html/assets/navigation.js

@@ -1 +1 @@
-window.navigationData = "data:application/octet-stream;base64,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"
+window.navigationData = "data:application/octet-stream;base64,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"