@arcgis/coding-components 4.31.0-next.2 → 4.31.0-next.21

package/dist/types/components.d.ts

@@ -8,30 +8,30 @@ import { HTMLStencilElement, JSXBase } from "./stencil-public-runtime";
 import { IEditorProfileDefinition, IPredefinedProfile } from "./utils/profile/types";
 import { ArcadeResult, IEditorTestContext } from "./utils/arcade-executor";
 import { IEditorCodeSuggestion, IEditorCodeSuggestionGroup } from "./utils/editor-suggestions";
-import { ApiSnippet, Diagnostic } from "@arcgis/arcade-languageservice";
+import { ApiCategory, ApiSnippet, Diagnostic } from "@arcgis/arcade-languageservice";
 import { SidePanelName } from "./components/arcade-editor/arcade-editor";
 import { editor, Selection } from "monaco-editor";
 import { IColorRules } from "./utils/arcade-monaco/arcade-theme";
 import { ResultPanelName } from "./components/arcade-results/arcade-results";
-import { LanguageDefaultsBase } from "./utils/language-defaults-base";
+import { IPredefinedProfile as IPredefinedProfile1 } from "./components";
 export { IEditorProfileDefinition, IPredefinedProfile } from "./utils/profile/types";
 export { ArcadeResult, IEditorTestContext } from "./utils/arcade-executor";
 export { IEditorCodeSuggestion, IEditorCodeSuggestionGroup } from "./utils/editor-suggestions";
-export { ApiSnippet, Diagnostic } from "@arcgis/arcade-languageservice";
+export { ApiCategory, ApiSnippet, Diagnostic } from "@arcgis/arcade-languageservice";
 export { SidePanelName } from "./components/arcade-editor/arcade-editor";
 export { editor, Selection } from "monaco-editor";
 export { IColorRules } from "./utils/arcade-monaco/arcade-theme";
 export { ResultPanelName } from "./components/arcade-results/arcade-results";
-export { LanguageDefaultsBase } from "./utils/language-defaults-base";
+export { IPredefinedProfile as IPredefinedProfile1 } from "./components";
 export namespace Components {
     interface ArcgisArcadeEditor {
         /**
-          * The instance of the Monaco Editor.
+          * The instance of the Monaco Editor after the component has been rendered. To determine when a component is rendered, you can use componentOnReady() method. The method returns a Promise that resolves after the component rendered for the first time.
           * @readonly
          */
         "editorInstance": editor.IStandaloneCodeEditor | undefined;
         /**
-          * The options for the editor (see Monaco Editor options documentation for more details).
+          * Options to update on the editor. For example: ```json {   "fontSize": 18 } ```  To get the full list of available options, see the Monaco Editor options documentation for more details.
          */
         "editorOptions": (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
         /**
@@ -127,10 +127,14 @@ export namespace Components {
     }
     interface ArcgisCodeEditor {
         /**
-          * The instance of the Monaco Editor.
+          * The instance of the Monaco Editor after the component has been rendered. To determine when a component is rendered, you can use componentOnReady() method. The method returns a Promise that resolves after the component rendered for the first time.
           * @readonly
          */
         "editorInstance": editor.IStandaloneCodeEditor | undefined;
+        /**
+          * Options to update on the editor. For example: ```json {   "fontSize": 18 } ```  To get the full list of options set on the editor, use the editorInstance property and see Monaco Editor options documentation for more details.
+         */
+        "editorOptions": (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
         /**
           * @deprecated Use `editorInstance` property instead.
          */
@@ -152,17 +156,13 @@ export namespace Components {
          */
         "insertText": (text: string | null | undefined) => Promise<void>;
         /**
-          * The language for the editor. Currently supported language: arcade, json, css, html, javascript, typescript, and text.
+          * The language for the editor. Currently supported language: arcade, arcgis-sql-expression, json, css, html, javascript, typescript, and text.
          */
         "language": string | undefined;
         /**
           * A unique identifier for the model. The unique identifier is sometimes used by language defaults to store model metadata. For example, with arcade, the model id is used to store the arcade profile and other metadata. The unique identifier is especially useful when there are multiple editors on the same page.
          */
         "modelId": string;
-        /**
-          * The options for the editor (see Monaco Editor options documentation for more details).
-         */
-        "options": (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
         /**
           * Sets the focus on the editor.
           * @returns
@@ -178,13 +178,29 @@ export namespace Components {
         "value": string;
     }
     interface ArcgisLanguageApiPanel {
+        /**
+          * The api library to display
+         */
+        "apiLibrary": ApiCategory[] | undefined;
         /**
           * Should the documentation action be hidden
          */
         "hideDocumentationActions": boolean;
-        "languageDefaults": LanguageDefaultsBase;
         /**
-          * The model id used by the component to retrieve the api library
+          * When true, a busy indicator is displayed
+         */
+        "loading": boolean;
+    }
+    interface ArcgisSqlExpressionEditor {
+        "profile": IPredefinedProfile1 | undefined;
+    }
+    interface ArcgisSqlExpressionFields {
+        /**
+          * Loading state
+         */
+        "loading": boolean;
+        /**
+          * The model id
          */
         "modelId": string | undefined;
     }
@@ -213,6 +229,10 @@ export interface ArcgisLanguageApiPanelCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLArcgisLanguageApiPanelElement;
 }
+export interface ArcgisSqlExpressionFieldsCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLArcgisSqlExpressionFieldsElement;
+}
 declare global {
     interface HTMLArcgisArcadeEditorElementEventMap {
         "arcgisScriptChange": string;
@@ -325,6 +345,30 @@ declare global {
         prototype: HTMLArcgisLanguageApiPanelElement;
         new (): HTMLArcgisLanguageApiPanelElement;
     };
+    interface HTMLArcgisSqlExpressionEditorElement extends Components.ArcgisSqlExpressionEditor, HTMLStencilElement {
+    }
+    var HTMLArcgisSqlExpressionEditorElement: {
+        prototype: HTMLArcgisSqlExpressionEditorElement;
+        new (): HTMLArcgisSqlExpressionEditorElement;
+    };
+    interface HTMLArcgisSqlExpressionFieldsElementEventMap {
+        "arcgisClose": void;
+        "arcgisFieldSelected": string;
+    }
+    interface HTMLArcgisSqlExpressionFieldsElement extends Components.ArcgisSqlExpressionFields, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLArcgisSqlExpressionFieldsElementEventMap>(type: K, listener: (this: HTMLArcgisSqlExpressionFieldsElement, ev: ArcgisSqlExpressionFieldsCustomEvent<HTMLArcgisSqlExpressionFieldsElementEventMap[K]>) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLArcgisSqlExpressionFieldsElementEventMap>(type: K, listener: (this: HTMLArcgisSqlExpressionFieldsElement, ev: ArcgisSqlExpressionFieldsCustomEvent<HTMLArcgisSqlExpressionFieldsElementEventMap[K]>) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof DocumentEventMap>(type: K, listener: (this: Document, ev: DocumentEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    }
+    var HTMLArcgisSqlExpressionFieldsElement: {
+        prototype: HTMLArcgisSqlExpressionFieldsElement;
+        new (): HTMLArcgisSqlExpressionFieldsElement;
+    };
     interface HTMLElementTagNameMap {
         "arcgis-arcade-editor": HTMLArcgisArcadeEditorElement;
         "arcgis-arcade-results": HTMLArcgisArcadeResultsElement;
@@ -332,12 +376,14 @@ declare global {
         "arcgis-arcade-variables": HTMLArcgisArcadeVariablesElement;
         "arcgis-code-editor": HTMLArcgisCodeEditorElement;
         "arcgis-language-api-panel": HTMLArcgisLanguageApiPanelElement;
+        "arcgis-sql-expression-editor": HTMLArcgisSqlExpressionEditorElement;
+        "arcgis-sql-expression-fields": HTMLArcgisSqlExpressionFieldsElement;
     }
 }
 declare namespace LocalJSX {
     interface ArcgisArcadeEditor {
         /**
-          * The options for the editor (see Monaco Editor options documentation for more details).
+          * Options to update on the editor. For example: ```json {   "fontSize": 18 } ```  To get the full list of available options, see the Monaco Editor options documentation for more details.
          */
         "editorOptions"?: (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
         /**
@@ -445,12 +491,16 @@ declare namespace LocalJSX {
     }
     interface ArcgisCodeEditor {
         /**
-          * The instance of the Monaco Editor.
+          * The instance of the Monaco Editor after the component has been rendered. To determine when a component is rendered, you can use componentOnReady() method. The method returns a Promise that resolves after the component rendered for the first time.
           * @readonly
          */
         "editorInstance"?: editor.IStandaloneCodeEditor | undefined;
         /**
-          * The language for the editor. Currently supported language: arcade, json, css, html, javascript, typescript, and text.
+          * Options to update on the editor. For example: ```json {   "fontSize": 18 } ```  To get the full list of options set on the editor, use the editorInstance property and see Monaco Editor options documentation for more details.
+         */
+        "editorOptions"?: (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
+        /**
+          * The language for the editor. Currently supported language: arcade, arcgis-sql-expression, json, css, html, javascript, typescript, and text.
          */
         "language"?: string | undefined;
         /**
@@ -468,25 +518,24 @@ declare namespace LocalJSX {
           * Emitted when the value has changed (script, code, css, json, etc.)
          */
         "onArcgisValueChange"?: (event: ArcgisCodeEditorCustomEvent<string>) => void;
-        /**
-          * The options for the editor (see Monaco Editor options documentation for more details).
-         */
-        "options"?: (editor.IEditorOptions & editor.IGlobalEditorOptions) | undefined;
         /**
           * The initial value for the editor. The value is the script, code, css, json, etc.
          */
         "value"?: string;
     }
     interface ArcgisLanguageApiPanel {
+        /**
+          * The api library to display
+         */
+        "apiLibrary"?: ApiCategory[] | undefined;
         /**
           * Should the documentation action be hidden
          */
         "hideDocumentationActions"?: boolean;
-        "languageDefaults": LanguageDefaultsBase;
         /**
-          * The model id used by the component to retrieve the api library
+          * When true, a busy indicator is displayed
          */
-        "modelId"?: string | undefined;
+        "loading"?: boolean;
         /**
           * Raised when the close action has been requested
          */
@@ -496,6 +545,27 @@ declare namespace LocalJSX {
          */
         "onArcgisItemSelected"?: (event: ArcgisLanguageApiPanelCustomEvent<string>) => void;
     }
+    interface ArcgisSqlExpressionEditor {
+        "profile"?: IPredefinedProfile1 | undefined;
+    }
+    interface ArcgisSqlExpressionFields {
+        /**
+          * Loading state
+         */
+        "loading"?: boolean;
+        /**
+          * The model id
+         */
+        "modelId"?: string | undefined;
+        /**
+          * Emitted when close action has been activated
+         */
+        "onArcgisClose"?: (event: ArcgisSqlExpressionFieldsCustomEvent<void>) => void;
+        /**
+          * Emitted when a field has been selected
+         */
+        "onArcgisFieldSelected"?: (event: ArcgisSqlExpressionFieldsCustomEvent<string>) => void;
+    }
     interface IntrinsicElements {
         "arcgis-arcade-editor": ArcgisArcadeEditor;
         "arcgis-arcade-results": ArcgisArcadeResults;
@@ -503,6 +573,8 @@ declare namespace LocalJSX {
         "arcgis-arcade-variables": ArcgisArcadeVariables;
         "arcgis-code-editor": ArcgisCodeEditor;
         "arcgis-language-api-panel": ArcgisLanguageApiPanel;
+        "arcgis-sql-expression-editor": ArcgisSqlExpressionEditor;
+        "arcgis-sql-expression-fields": ArcgisSqlExpressionFields;
     }
 }
 export { LocalJSX as JSX };
@@ -515,6 +587,8 @@ declare module "@stencil/core" {
             "arcgis-arcade-variables": LocalJSX.ArcgisArcadeVariables & JSXBase.HTMLAttributes<HTMLArcgisArcadeVariablesElement>;
             "arcgis-code-editor": LocalJSX.ArcgisCodeEditor & JSXBase.HTMLAttributes<HTMLArcgisCodeEditorElement>;
             "arcgis-language-api-panel": LocalJSX.ArcgisLanguageApiPanel & JSXBase.HTMLAttributes<HTMLArcgisLanguageApiPanelElement>;
+            "arcgis-sql-expression-editor": LocalJSX.ArcgisSqlExpressionEditor & JSXBase.HTMLAttributes<HTMLArcgisSqlExpressionEditorElement>;
+            "arcgis-sql-expression-fields": LocalJSX.ArcgisSqlExpressionFields & JSXBase.HTMLAttributes<HTMLArcgisSqlExpressionFieldsElement>;
         }
     }
 }

package/dist/types/data/actions-runner-1/_work/arcgis-web-components/arcgis-web-components/packages/coding-packages/coding-components/.stencil/stories/internal/arcade-editor/arcade-editor.stories.d.ts

@@ -1,6 +1,8 @@
 import type { Meta, StoryObj } from "@storybook/web-components";
 import type { Components } from "../../../src/components";
+import type { LayerItemPopupProfileConfiguration } from "./editorContext";
 import { type PopupProfileConfiguration } from "./editorContext";
+import type { BundleType } from "@arcgis/arcade-languageservice";
 declare const meta: Meta<Components.ArcgisArcadeEditor>;
 export default meta;
 interface PopupProfileAdditionalArgs {
@@ -8,8 +10,13 @@ interface PopupProfileAdditionalArgs {
 }
 type PopupProfileStoryType = Components.ArcgisArcadeEditor & PopupProfileAdditionalArgs;
 export declare const PopupProfileStory: StoryObj<PopupProfileStoryType>;
+interface SLPopupProfileAdditionalArgs {
+    configuration: LayerItemPopupProfileConfiguration;
+}
+type SLPopupProfileStoryType = Components.ArcgisArcadeEditor & SLPopupProfileAdditionalArgs;
+export declare const SLPopupProfileStory: StoryObj<SLPopupProfileStoryType>;
 export declare const HideItemsCustomProfileStory: StoryObj<Components.ArcgisArcadeEditor & {
-    bundles?: string[];
+    bundles?: BundleType[];
     hiddenApiItems: string[];
 }>;
 export declare const HideItemsPredefinedProfileStory: StoryObj<Components.ArcgisArcadeEditor & {

package/dist/types/data/actions-runner-1/_work/arcgis-web-components/arcgis-web-components/packages/coding-packages/coding-components/.stencil/stories/internal/arcade-editor/editorContext.d.ts

@@ -1,6 +1,7 @@
 import type { Components } from "../../../src/components";
+type PortalKeyType = "devext" | "qaext" | "www";
 export interface PopupProfileConfiguration {
-    portalKey: "devext" | "qaext" | "www";
+    portalKey: PortalKeyType;
     itemId: string;
     layerId: string;
     subtypeCode?: number;
@@ -9,3 +10,6 @@ export interface PopupProfileConfiguration {
 }
 export type PopupProfileEditorContext = Partial<Pick<Components.ArcgisArcadeEditor, "profile" | "testData">>;
 export declare function getPopupProfileEditorContext({ portalKey, itemId, layerId, timeZone, subtypeCode, sublayerId, }: PopupProfileConfiguration): Promise<PopupProfileEditorContext>;
+export type LayerItemPopupProfileConfiguration = Pick<PopupProfileConfiguration, "layerId" | "portalKey">;
+export declare function getPopupProfileEditorContextForLayerItem({ portalKey, layerId }: LayerItemPopupProfileConfiguration, createTestData?: boolean): Promise<PopupProfileEditorContext>;
+export {};

package/dist/types/data/actions-runner-1/_work/arcgis-web-components/arcgis-web-components/packages/coding-packages/coding-components/.stencil/stories/internal/sql-expression-editor/sql-expression-editor.stories.d.ts

@@ -0,0 +1,13 @@
+import type { Meta, StoryObj } from "@storybook/web-components";
+import { type Components } from "../../../src/components";
+declare const meta: Meta<Components.ArcgisSqlExpressionEditor>;
+export default meta;
+interface Configuration {
+    portalKey: "devext" | "qaext" | "www";
+    itemId: string;
+    sublayerId?: number;
+}
+type StoryType = Components.ArcgisArcadeEditor & {
+    configuration: Configuration;
+};
+export declare const SimpleStory: StoryObj<StoryType>;

package/dist/types/dependencies.d.ts

@@ -2,24 +2,20 @@
  * This is a workaround for missing JSX typing for components authored in Stencil.
  * @see https://github.com/maxpatiiuk/web-component-framework-benchmarks/tree/stencil-calcite-no-typing/stencil
  */
-
 import type { JSX as CalciteJsx } from "@esri/calcite-components/dist/types/components";
 import type { JSXBase } from "./stencil-public-runtime";
-
 /**
  * The "JSX" type exported from @esri/calcite-components includes only component
  * props, without HTMLElement props. This type re-maps the Calcite JSX type to
  * add HTMLElement props
  */
 type ReMappedCalciteJsx = {
-  [Key in keyof CalciteJsx.IntrinsicElements]: Partial<
-    CalciteJsx.IntrinsicElements[Key] & JSXBase.HTMLAttributes<HTMLElementTagNameMap[Key]>
-  >;
+    [Key in keyof CalciteJsx.IntrinsicElements]: JSXBase.HTMLAttributes<HTMLElementTagNameMap[Key]>;
 };
-
 declare module "@stencil/core" {
-  export namespace JSX {
-    // eslint-disable-next-line @typescript-eslint/no-empty-interface
-    interface IntrinsicElements extends ReMappedCalciteJsx {}
-  }
+    namespace JSX {
+        interface IntrinsicElements extends ReMappedCalciteJsx {
+        }
+    }
 }
+export {};

package/dist/types/utils/arcade-monaco/arcade-language-features.d.ts

@@ -19,6 +19,7 @@ export declare class DiagnosticsAdapter {
     dispose(): void;
     private _doValidate;
 }
+export declare function toCompletionItemKind(kind: number | undefined): languages.CompletionItemKind;
 export declare class CompletionProvider implements languages.CompletionItemProvider {
     private _worker;
     private _defaults;

package/dist/types/utils/arcade-monaco/arcade-profile-strategy.d.ts

@@ -0,0 +1,9 @@
+import type { ApiProfile } from "@arcgis/arcade-languageservice";
+import type { EditorProfile } from "../profile/editor-profile";
+import type { IPredefinedProfile, IEditorProfileDefinition } from "../profile/types";
+/**
+ * Converts an editor profile to an api profile.
+ * The api profile is an optimized version of the editor profile designed for minimal data transfer between the main thread and the worker.
+ */
+export declare function arcadeEditorToApiProfile(editorProfile: EditorProfile): Promise<ApiProfile>;
+export declare function convertToEditorProfileDefinition(predefinedProfile: IPredefinedProfile, locale?: string): Promise<IEditorProfileDefinition | undefined>;

package/dist/types/utils/fields.d.ts

@@ -4,8 +4,8 @@ import type { ApiValueVariableType } from "@arcgis/arcade-languageservice";
  */
 export declare function fieldTypeToIconName(field: __esri.Field): string;
 /**
- * Returns the Arcade type for the given field.
+ * Returns the ApiValueVariable type for the given field.
  */
-export declare function fieldTypeToArcadeType(field: __esri.Field): ApiValueVariableType;
+export declare function fieldTypeToApiValueVarType(field: __esri.Field): ApiValueVariableType;
 export declare function supportedFields(fields: __esri.Field[] | null | undefined): __esri.Field[];
 export declare function fieldAlias(field: __esri.Field): string;

package/dist/types/utils/language-defaults-base.d.ts

@@ -16,16 +16,9 @@ export declare abstract class LanguageDefaultsBase<TApiContext extends ApiContex
     get onDidChange(): IEvent<this>;
     get languageOptions(): typeof this._languageOptions | null;
     /**
-     * Dispose the editor profile for the given model id.
-     * It is the responsibility of the caller that created the editor profile to dispose it.
-     * @param modelId The model id for which to dispose the editor profile.
+     * Dispose any cached resources for the model
      */
-    disposeEditorProfileForModel(modelId: Uri | string): void;
-    /**
-     * Dispose the api context for the given model id.
-     * @param modelId The model id for which to dispose the api context.
-     */
-    disposeApiContextForModel(modelId: Uri | string): void;
+    disposeForModel(modelId: Uri | string): void;
     /**
      * Returns the editor profile for the given model id.
      * @param modelId The model id for which to get the editor profile.

package/dist/types/utils/profile/editor-profile.d.ts

@@ -1,5 +1,6 @@
-import type { ApiVariableType, ApiProfile } from "@arcgis/arcade-languageservice";
+import type { ApiVariableType } from "@arcgis/arcade-languageservice";
 import type * as types from "./types";
+import type { ApiValueVariable } from "@arcgis/languages-api-utils";
 /**
  * FeatureSetCollection interface. Used in Arcade expressions to represent Web Maps
  * or Feature Services.
@@ -21,6 +22,10 @@ interface IFeatureSetCollections {
      */
     source: __esri.Map | __esri.WebMap | __esri.WebScene | string;
 }
+/**
+ * converts fields to profile values and calculates the feature completion description all in one iteration
+ */
+export declare function fieldsToProfileValues(fields: __esri.Field[], initialFeatureCompletionDescription: string, includeAliases?: boolean): [ApiValueVariable[], string];
 type ProfileItemType = ApiVariableType | "group";
 export type EditorVariable = ArrayVariable | DictionaryVariable | FeatureSetCollectionVariable | FeatureSetVariable | FeatureVariable | ValueVariable;
 interface ConstructorProperties<T> {
@@ -200,7 +205,7 @@ export declare class FeatureSetVariable extends SourceBasedVariable {
     constructor(owner: CollectionBasedVariable | undefined, props: ConstructorProperties<types.IProfileFeatureSet>, featureSetSnippets?: ValueVariable[], relationshipProps?: IRelationshipsProperties);
     get title(): types.IIntlString | string;
     protected _loadSource(): Promise<types.SupportedSource | null>;
-    toProfileVariableDefinition(): types.IProfileVariable;
+    toProfileVariableDefinition(): types.IProfileFeatureSet;
 }
 export declare class FeatureSetCollectionVariable extends CollectionBasedVariable {
     type: "featureSetCollection";
@@ -239,10 +244,6 @@ export declare class EditorProfile extends DictionaryVariable {
      * Returns true if the profile supports feature set functions for snippets.
      */
     get supportFeatureSetFunctions(): boolean;
-    /**
-     * Returns the language service profile. It is different than the editor profile as it is optimized for Monaco.
-     */
-    toLSProfile(): Promise<ApiProfile>;
     /**
      * Returns the EditorProfile as a json. The EditorProfile may have been updated. This function allows to
      * get the new json representing mutations.

package/dist/types/utils/profile/types.d.ts

@@ -13,7 +13,7 @@ export interface IEditorProfileDefinition {
     label?: string;
     /**
      * The collection of variables that will be passed to the expression at execution time.
-     * The variable declartions are used to help the editor provide validation and completion.
+     * The variable declarations are used to help the editor provide validation and completion.
      */
     variables: IProfileVariable[];
     /**
@@ -165,12 +165,7 @@ export interface IUrlDefinition {
 /**
  * The most basic way to define a feature or feature set is by passing a collection of fields
  */
-export interface IFieldsDefinition {
-    /**
-     * An array of fields.
-     */
-    fields: __esri.Field[];
-}
+export type IFieldsDefinition = Pick<__esri.FeatureLayer, "fields">;
 /**
  * FeatureDefinition represents various ways a Feature variable could be defined.
  * Layer instance is the most common way to define a feature,
@@ -218,29 +213,39 @@ export type SupportedSource = IFieldsDefinition;
 /**
  * Layer that supports title.
  */
-export interface ITitleCapableSource {
-    /**
-     * The title of the source.
-     */
-    title: string;
-}
+export type ITitleCapableSource = Pick<__esri.Layer, "title">;
 /**
  * Layer that supports url.
  */
-export interface IUrlCapableSource {
-    /**
-     * The url of the source.
-     */
-    url: string;
-}
+export type IUrlCapableSource = Pick<__esri.FeatureLayer, "url">;
 /**
  * Layer that supports layer id.
  */
-export interface ILayerIdCapableSource {
+export type ILayerIdCapableSource = Pick<__esri.FeatureLayer, "layerId">;
+/**
+ * Layer that supports queryFeatures
+ */
+export interface IFeatureLayerLikeInstance extends IFieldsDefinition, ITitleCapableSource {
+    /**
+     * The declared class of the layer.
+     */
+    declaredClass: string;
     /**
-     * The layer id of the source.
+     * The unique ID assigned to the layer.
+     */
+    id: string;
+    /**
+     * The layer ID, or layer index, of a Feature Service layer.
      */
     layerId: number;
+    /**
+     * Executes a Query against the feature service and returns a Promise to a FeatureSet.
+     */
+    queryFeatures: (query?: __esri.Query | __esri.QueryProperties) => Promise<__esri.FeatureSet>;
+    /**
+     * The service's metadata JSON exposed by the ArcGIS REST API.
+     */
+    sourceJSON?: any;
 }
 /**
  * Layer that supports field domains.
@@ -254,62 +259,39 @@ export interface IDomainsCapableSource {
 /**
  * Layer that implements types
  */
-export interface IFeatureTypesCapableSource extends IDomainsCapableSource {
-    /**
-     * The name of the field holding the type ID or subtypes for the features.
-     */
-    typeIdField: string;
-    /**
-     * An array of subtypes defined in the feature service exposed by ArcGIS REST API.
-     */
-    types: __esri.FeatureType[];
-}
+export type IFeatureTypesCapableSource = IDomainsCapableSource & Pick<__esri.FeatureLayer, "typeIdField" | "types">;
 /**
  * Layer that has a subtype field
  */
-export interface ISubtypeFieldCapableSource extends IDomainsCapableSource {
-    /**
-     * The name of the field which holds the id of the subtypes.
-     */
-    subtypeField: string;
-}
+export type ISubtypeFieldCapableSource = IDomainsCapableSource & Pick<__esri.FeatureLayer, "subtypeField">;
 /**
  * Layer that exposes subtypes.
  */
-export interface ISubtypesCapableSource extends ISubtypeFieldCapableSource {
-    /**
-     * An array of subtypes defined in the layer.
-     */
-    subtypes: __esri.Subtype[];
-}
+export type ISubtypesCapableSource = ISubtypeFieldCapableSource & Pick<__esri.FeatureLayer, "subtypes">;
 /**
  * Layer that supports relationships.
  */
-export interface IRelationshipsCapableSource extends ILayerIdCapableSource {
-    /**
-     * Array of relationships set up for the layer.
-     */
-    relationships: __esri.Relationship[];
-    /**
-     * The absolute URL of the REST endpoint of the layer, non-spatial table or service.
-     */
-    url: string;
-}
+export type IRelationshipsCapableSource = ILayerIdCapableSource & IUrlCapableSource & Pick<__esri.FeatureLayer, "relationships">;
 /**
  * Layer that is capable of being npn-spatial.
  */
-export interface ITableCapableSource {
-    /**
-     * Returns `true` if the layer is loaded from a non-spatial table in a service.
-     */
-    isTable: boolean;
-}
-export interface ILoadableSource {
-    /**
-     * Loads the resources referenced by the layer.
-     */
-    load: (signal?: AbortSignal) => Promise<any>;
-}
+export type ITableCapableSource = Pick<__esri.FeatureLayer, "isTable">;
+/**
+ * An instance that requires a load operation to be performed.
+ */
+export type ILoadableSource = Pick<__esri.Layer, "load">;
+/**
+ * An instance that requires a loadAll operation to be performed.
+ */
+export type ILoadAllCapable = Pick<__esri.WebMap | __esri.WebScene, "loadAll">;
+/**
+ * An instance that is based on a portal item.
+ */
+export type IPortalItemCapable = Pick<__esri.PortalItemResource, "portalItem">;
+/**
+ * An instance that exposes all layers and tables collections.
+ */
+export type IGroupLayerCapable = Pick<__esri.Map, "allLayers" | "allTables">;
 /**
  * Represents a string that will have to be manufactured from a Intl strings resource.
  */
@@ -326,8 +308,14 @@ export interface IIntlString {
      */
     formatValues?: Record<string, string>;
 }
+/**
+ * The bare minimum interface for layer information coming from the rest API.
+ */
 export interface LayerInfo {
     id: number;
     type: string;
     capabilities?: string;
 }
+export interface IExtendedPredefinedProfile extends IPredefinedProfile {
+    additionalVariables?: IProfileVariable[];
+}

package/dist/types/utils/profile/utils.d.ts

@@ -1,17 +1,17 @@
 import type * as types from "./types";
-export declare function isQueryableLayerInstance(item: unknown): item is __esri.FeatureLayer;
-export declare function isSubtypeSublayerInstance(item: unknown): item is __esri.SubtypeSublayer;
-export declare function isGroupLayerInstance(item: unknown): item is __esri.GroupLayer;
-export declare function isMapImageLayerInstance(item: unknown): item is __esri.MapImageLayer;
-export declare function isMapInstance(item: unknown): item is __esri.Map | __esri.WebMap | __esri.WebScene;
-export declare function isWebMapInstance(item: __esri.Map | __esri.WebMap | __esri.WebScene): item is __esri.WebMap;
-export declare function isWebSceneInstance(item: __esri.Map | __esri.WebMap | __esri.WebScene): item is __esri.WebScene;
-export declare function isLoadableMapInstance(item: __esri.Map | __esri.WebMap | __esri.WebScene): item is __esri.WebMap | __esri.WebScene;
+import type { FeatureDefinition, FeatureSetCollectionDefinition, FeatureSetDefinition } from "./types";
+export declare function isFeatureLayerLikeInstance(item: unknown): item is types.IFeatureLayerLikeInstance;
+export declare function isGroupLayerCapable(item: unknown): item is types.IGroupLayerCapable;
+export declare function isMapInstance(item: unknown): item is __esri.Map;
+export declare function isLoadAllCapable(item: unknown): item is types.ILoadAllCapable;
 export declare function isPortalItemDefinition(item: unknown): item is types.IPortalItemDefinition;
 export declare function isFeatureLayerItemDefinition(item: unknown): item is types.IFeatureLayerItemDefinition;
 export declare function isFieldsDefinition(item: unknown): item is types.IFieldsDefinition;
 export declare function isUrlDefinition(item: unknown): item is types.IUrlDefinition;
 export declare function isSupportedServiceUrlDefinition(item: unknown): item is types.IUrlDefinition;
+export declare function isFeatureDefinition(item: unknown): item is FeatureDefinition;
+export declare function isFeatureSetDefinition(item: unknown): item is FeatureSetDefinition;
+export declare function isFeatureSetCollectionDefinition(item: unknown): item is FeatureSetCollectionDefinition;
 export declare function isSubtypeInstance(item: unknown): item is __esri.Subtype;
 export declare function isCodedValueDomainInstance(item: unknown): item is __esri.CodedValueDomain;
 export declare function isInheritedDomainInstance(item: unknown): item is __esri.InheritedDomain;
@@ -23,6 +23,7 @@ export declare function isFeatureTypesCapableLayer(item: unknown): item is types
 export declare function isDomainsCapableLayer(item: unknown): item is types.IDomainsCapableSource;
 export declare function isSubtypeFieldCapableLayer(item: unknown): item is types.ISubtypeFieldCapableSource;
 export declare function isSubtypesCapableLayer(item: unknown): item is types.ISubtypesCapableSource;
+export declare function isPortalItemCapable(item: unknown): item is types.IPortalItemCapable;
 export declare function isRelationshipsCapableLayer(item: unknown): item is types.IRelationshipsCapableSource;
 export declare function isTableCapableLayer(item: unknown): item is types.ITableCapableSource;
 export declare function isLoadableSource(item: unknown): item is types.ILoadableSource;