@arcgis/coding-components 4.31.0-next.6 → 4.31.0-next.60

package/dist/types/components/sql-expression-editor/sql-expression-editor.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentInterface, VNode } from "../../stencil-public-runtime";
+import type { ComponentInterface, EventEmitter, VNode } from "../../stencil-public-runtime";
 import type { ControllerManager } from "@arcgis/components-controllers";
 import type { EditorProfile } from "../../utils/profile/editor-profile";
 import type { IPredefinedProfile } from "../../components";
@@ -12,13 +12,41 @@ export declare class SqlExpressionEditor implements ComponentInterface {
     _editorProfile: EditorProfile | undefined;
     _activeAction: "fields" | "functions" | undefined;
     _apiLibrary: ApiCategory[] | undefined;
+    messages: {
+        _lang: string;
+        _t9nLocale: "id" | "en" | "el" | "ar" | "bg" | "bs" | "ca" | "cs" | "da" | "de" | "es" | "et" | "fi" | "fr" | "he" | "hr" | "hu" | "it" | "ja" | "ko" | "lt" | "lv" | "nl" | "nb" | "pl" | "pt-BR" | "pt-PT" | "ro" | "ru" | "sk" | "sl" | "sr" | "sv" | "th" | "tr" | "uk" | "vi" | "zh-CN" | "zh-HK" | "zh-TW";
+        _loading: boolean;
+        _overrides: {
+            fields?: string | undefined;
+            functions?: string | undefined;
+        };
+        _original?: {
+            fields: string;
+            functions: string;
+        } | undefined;
+    } & Partial<{
+        fields: string;
+        functions: string;
+    }>;
+    _messagesChanged(): Promise<void>;
     profile: IPredefinedProfile | undefined;
-    _profileChanged(): void;
-    private _updateSqlExprDefaults;
+    _profileChanged(): Promise<void>;
+    /**
+     * The sql expression script. Use this property to define or update the script.
+     */
+    script: string;
+    private _updateEditorProfile;
     private _setActiveAction;
     private _handleActionClick;
     private _insertAsSnippet;
+    private _updateApiLibrary;
+    private _onCodeEditorValueChange;
     componentWillLoad(): Promise<void>;
+    componentDidLoad(): Promise<void>;
     disconnectedCallback(): void;
+    /**
+     * Emitted when the script string has changed.
+     */
+    arcgisScriptChange: EventEmitter<string>;
     render(): VNode;
 }

package/dist/types/components/sql-expression-fields/sql-expression-fields.d.ts

@@ -4,6 +4,22 @@ import { type ComponentInterface, type EventEmitter, type VNode } from "../../st
 export declare class SqlExpressionFields implements ComponentInterface {
     manager: ControllerManager<this>;
     private _flowObserver?;
+    messages: {
+        _lang: string;
+        _t9nLocale: "id" | "en" | "el" | "ar" | "bg" | "bs" | "ca" | "cs" | "da" | "de" | "es" | "et" | "fi" | "fr" | "he" | "hr" | "hu" | "it" | "ja" | "ko" | "lt" | "lv" | "nl" | "nb" | "pl" | "pt-BR" | "pt-PT" | "ro" | "ru" | "sk" | "sl" | "sr" | "sv" | "th" | "tr" | "uk" | "vi" | "zh-CN" | "zh-HK" | "zh-TW";
+        _loading: boolean;
+        _overrides: {
+            availablefields?: string | undefined;
+            domainvalues?: string | undefined;
+        };
+        _original?: {
+            availablefields: string;
+            domainvalues: string;
+        } | undefined;
+    } & Partial<{
+        availablefields: string;
+        domainvalues: string;
+    }>;
     el: HTMLDivElement;
     _mutationCounter: number;
     _flowItemRenderers: (() => VNode)[];
@@ -27,6 +43,7 @@ export declare class SqlExpressionFields implements ComponentInterface {
     arcgisFieldSelected: EventEmitter<string>;
     disconnectedCallback(): void;
     private _handleSelectField;
+    private _handleSelectDomain;
     private _emitClose;
     render(): VNode;
 }

package/dist/types/components.d.ts

@@ -26,12 +26,12 @@ 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.
          */
@@ -159,10 +163,6 @@ export namespace Components {
           * 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
@@ -193,6 +193,10 @@ export namespace Components {
     }
     interface ArcgisSqlExpressionEditor {
         "profile": IPredefinedProfile1 | undefined;
+        /**
+          * The sql expression script. Use this property to define or update the script.
+         */
+        "script": string;
     }
     interface ArcgisSqlExpressionFields {
         /**
@@ -229,6 +233,10 @@ export interface ArcgisLanguageApiPanelCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLArcgisLanguageApiPanelElement;
 }
+export interface ArcgisSqlExpressionEditorCustomEvent<T> extends CustomEvent<T> {
+    detail: T;
+    target: HTMLArcgisSqlExpressionEditorElement;
+}
 export interface ArcgisSqlExpressionFieldsCustomEvent<T> extends CustomEvent<T> {
     detail: T;
     target: HTMLArcgisSqlExpressionFieldsElement;
@@ -345,7 +353,18 @@ declare global {
         prototype: HTMLArcgisLanguageApiPanelElement;
         new (): HTMLArcgisLanguageApiPanelElement;
     };
+    interface HTMLArcgisSqlExpressionEditorElementEventMap {
+        "arcgisScriptChange": string;
+    }
     interface HTMLArcgisSqlExpressionEditorElement extends Components.ArcgisSqlExpressionEditor, HTMLStencilElement {
+        addEventListener<K extends keyof HTMLArcgisSqlExpressionEditorElementEventMap>(type: K, listener: (this: HTMLArcgisSqlExpressionEditorElement, ev: ArcgisSqlExpressionEditorCustomEvent<HTMLArcgisSqlExpressionEditorElementEventMap[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 HTMLArcgisSqlExpressionEditorElementEventMap>(type: K, listener: (this: HTMLArcgisSqlExpressionEditorElement, ev: ArcgisSqlExpressionEditorCustomEvent<HTMLArcgisSqlExpressionEditorElementEventMap[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 HTMLArcgisSqlExpressionEditorElement: {
         prototype: HTMLArcgisSqlExpressionEditorElement;
@@ -383,7 +402,7 @@ declare global {
 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;
         /**
@@ -491,10 +510,14 @@ 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;
+        /**
+          * 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.
          */
@@ -514,10 +537,6 @@ 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.
          */
@@ -546,7 +565,15 @@ declare namespace LocalJSX {
         "onArcgisItemSelected"?: (event: ArcgisLanguageApiPanelCustomEvent<string>) => void;
     }
     interface ArcgisSqlExpressionEditor {
+        /**
+          * Emitted when the script string has changed.
+         */
+        "onArcgisScriptChange"?: (event: ArcgisSqlExpressionEditorCustomEvent<string>) => void;
         "profile"?: IPredefinedProfile1 | undefined;
+        /**
+          * The sql expression script. Use this property to define or update the script.
+         */
+        "script"?: string;
     }
     interface ArcgisSqlExpressionFields {
         /**

package/dist/types/data/arcgis-web-compoments/actions-runner-1/_work/arcgis-web-components/arcgis-web-components/packages/coding-packages/coding-components/.stencil/stencil.config.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from "../../../../../../../../../../stencil-public-runtime";
+declare const config: Config;
+export { config };

package/dist/types/data/{actions-runner-1 → arcgis-web-compoments/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 → arcgis-web-compoments/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/stencil-public-runtime.d.ts

@@ -768,6 +768,7 @@ export declare namespace JSXBase {
         hrefLang?: string;
         hreflang?: string;
         media?: string;
+        ping?: string;
         rel?: string;
         target?: string;
         referrerPolicy?: ReferrerPolicy;
@@ -794,7 +795,6 @@ export declare namespace JSXBase {
         cite?: string;
     }
     interface ButtonHTMLAttributes<T> extends HTMLAttributes<T> {
-        autoFocus?: boolean;
         disabled?: boolean;
         form?: string;
         formAction?: string;
@@ -921,8 +921,6 @@ export declare namespace JSXBase {
         autocapitalize?: string;
         autoComplete?: string;
         autocomplete?: string;
-        autoFocus?: boolean;
-        autofocus?: boolean | string;
         capture?: string;
         checked?: boolean;
         crossOrigin?: string;
@@ -979,8 +977,6 @@ export declare namespace JSXBase {
         popoverTarget?: string;
     }
     interface KeygenHTMLAttributes<T> extends HTMLAttributes<T> {
-        autoFocus?: boolean;
-        autofocus?: boolean | string;
         challenge?: string;
         disabled?: boolean;
         form?: string;
@@ -993,7 +989,6 @@ export declare namespace JSXBase {
     interface LabelHTMLAttributes<T> extends HTMLAttributes<T> {
         form?: string;
         htmlFor?: string;
-        htmlfor?: string;
     }
     interface LiHTMLAttributes<T> extends HTMLAttributes<T> {
         value?: string | string[] | number;
@@ -1104,7 +1099,6 @@ export declare namespace JSXBase {
     interface OutputHTMLAttributes<T> extends HTMLAttributes<T> {
         form?: string;
         htmlFor?: string;
-        htmlfor?: string;
         name?: string;
     }
     interface ParamHTMLAttributes<T> extends HTMLAttributes<T> {
@@ -1129,7 +1123,6 @@ export declare namespace JSXBase {
         type?: string;
     }
     interface SelectHTMLAttributes<T> extends HTMLAttributes<T> {
-        autoFocus?: boolean;
         disabled?: boolean;
         form?: string;
         multiple?: boolean;
@@ -1164,8 +1157,6 @@ export declare namespace JSXBase {
     interface TextareaHTMLAttributes<T> extends HTMLAttributes<T> {
         autoComplete?: string;
         autocomplete?: string;
-        autoFocus?: boolean;
-        autofocus?: boolean | string;
         cols?: number;
         disabled?: boolean;
         form?: string;
@@ -1218,6 +1209,8 @@ export declare namespace JSXBase {
     interface HTMLAttributes<T = HTMLElement> extends DOMAttributes<T> {
         innerHTML?: string;
         accessKey?: string;
+        autoFocus?: boolean;
+        autofocus?: boolean | string;
         class?: string | {
             [className: string]: boolean;
         };

package/dist/types/utils/arcade-monaco/arcade-defaults.d.ts

@@ -37,5 +37,6 @@ export declare const arcade: {
         locale: string;
         snippets?: ApiSnippet[];
     }) => Promise<void>;
+    getApiLibrary: (modelId: string) => Promise<ApiCategory[]>;
 };
 export type { ArcadeLanguageServiceDefaults };

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/arcade-monaco/arcade-worker-manager.d.ts

@@ -1,4 +1,5 @@
 import type { Uri } from "monaco-editor";
+import { editor } from "monaco-editor";
 import type { IArcadeWorker } from "./types";
 import type { ArcadeLanguageServiceDefaults } from "./arcade-defaults";
 /**
@@ -12,6 +13,11 @@ export declare class WorkerManager {
     constructor(_defaults: ArcadeLanguageServiceDefaults);
     dispose(): void;
     stopWorker(): void;
+    /**
+     * Wait for the worker to be ready.
+     * @returns A promise that resolves when the worker is ready.
+     */
+    static waitForWorker(): Promise<editor.MonacoWebWorker<IArcadeWorker>>;
     private _getClientProxy;
     getLanguageServiceWorker(...resources: Uri[]): Promise<IArcadeWorker>;
 }

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/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

@@ -222,6 +222,31 @@ export type IUrlCapableSource = Pick<__esri.FeatureLayer, "url">;
  * Layer that supports layer id.
  */
 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 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.
  */
@@ -291,3 +316,6 @@ export interface LayerInfo {
     type: string;
     capabilities?: string;
 }
+export interface IExtendedPredefinedProfile extends IPredefinedProfile {
+    additionalVariables?: IProfileVariable[];
+}

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

@@ -1,5 +1,6 @@
 import type * as types from "./types";
-export declare function isQueryableLayerInstance(item: unknown): item is __esri.FeatureLayer;
+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;
@@ -8,6 +9,9 @@ export declare function isFeatureLayerItemDefinition(item: unknown): item is typ
 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;

package/dist/types/utils/sql-expr-monaco/sql-expr-completion.d.ts

@@ -1,5 +1,56 @@
-import * as monaco from "monaco-editor";
-export declare function sqlExpressionCompletion(range: monaco.IRange, model: monaco.editor.ITextModel, position: monaco.Position): monaco.languages.CompletionItem[];
-/** source  */
-export declare const sqlBinOps: string[];
-export declare function generateCompletionItems(layer: __esri.FeatureLayer, range: monaco.IRange): Record<"fieldsCompletion" | "sqlBinOpsCompletion" | "sqlDataTypeCompletion" | "sqlFunctionCompletion" | "sqlKeywordsCompletion", monaco.languages.CompletionItem[]>;
+/**
+ * @remarks This module is only intended to be loaded within the SQL expression worker.
+ */
+import type { IRange, Position, languages } from "monaco-editor";
+import type { ApiDatabase, ApiVariable } from "@arcgis/languages-api-utils";
+import type { ICompletionContext } from "./types";
+/**
+ * Class used for sql expression completion
+ */
+export declare class SqlExpressionCompletion {
+    private _sdkFunctions;
+    private _fields;
+    constructor(sdkLibrary: ApiDatabase, fields: ApiVariable[]);
+    getCompletions(range: IRange, modelContent: string, position: Position): Promise<languages.CompletionItem[]>;
+    /**
+     * traverses the tree to find the node that contains the current position
+     * @param node The current node to traverse
+     * @param position The current position
+     */
+    traverse(node: __esri.SQLNode, completionContext: ICompletionContext): void;
+    /**
+     * gets completions by finding the context of the current node and suggesting completions based on that context
+     */
+    private _getCompletions;
+    /**
+     * utilizes peggy's error handling to provide suggestions for the user.
+     */
+    private handleParserFailure;
+    /**
+     * gets completions based on the function node
+     * @param context the context root of the current node, see {@link identifyContextRoot}
+     * @param slotPosition the position of the current node in the context root, see {@link getSlotPosition}
+     * @param completionContext the completion context
+     */
+    private _getCompletionsFromFunction;
+    /**
+     * checks if the position is within the current node
+     * @param node The current node to check
+     * @param position The current position
+     * @returns boolean
+     */
+    private _isPositionWithinNode;
+    private _suggestFields;
+    private _suggestFunctions;
+    private _suggestDataTypes;
+    private _suggestDatePeriods;
+    private _suggestTrimParts;
+    private _suggestDateLiterals;
+    private _suggestExpressions;
+    private _suggestNull;
+    /**
+     * looks at the node and finds any children attached to it. If there are children, it will traverse them.
+     * @param node The current node to traverse
+     */
+    private _traverseChildren;
+}

package/dist/types/utils/sql-expr-monaco/sql-expr-constants.d.ts

@@ -0,0 +1,61 @@
+import type { MarkerSeverity, languages } from "monaco-editor";
+export declare enum ChildBearingProperties {
+    ARGS = "args",
+    CLAUSES = "clauses",
+    ELSE = "else",
+    END = "end",
+    EXPR = "expr",
+    LEFT = "left",
+    OPERAND = "operand",
+    QUALIFIER = "qualifier",
+    RIGHT = "right",
+    START = "start",
+    VALUE = "value"
+}
+export declare enum ChildBearingNodeTypes {
+    CASE_EXPRESSION = "case-expression",
+    EXPRESSION_LIST = "expression-list",
+    FUNCTION = "function",
+    INTERVAL = "interval",
+    INTERVAL_QUALIFIER = "interval-qualifier",
+    WHEN_CLAUSE = "when-clause",
+    UNARY_EXPRESSION = "unary-expression",
+    BINARY_EXPRESSION = "binary-expression"
+}
+export declare const CHILD_BEARING_PROPERTIES: {
+    readonly "case-expression": readonly [ChildBearingProperties.CLAUSES, ChildBearingProperties.OPERAND, ChildBearingProperties.ELSE];
+    readonly "when-clause": readonly [ChildBearingProperties.OPERAND, ChildBearingProperties.VALUE];
+    readonly "expression-list": readonly [ChildBearingProperties.VALUE];
+    readonly "unary-expression": readonly [ChildBearingProperties.EXPR];
+    readonly "binary-expression": readonly [ChildBearingProperties.LEFT, ChildBearingProperties.RIGHT];
+    readonly function: readonly [ChildBearingProperties.ARGS];
+    readonly interval: readonly [ChildBearingProperties.VALUE, ChildBearingProperties.QUALIFIER];
+    readonly "interval-qualifier": readonly [ChildBearingProperties.START, ChildBearingProperties.END];
+};
+export declare const MarkerType: {
+    Hint: MarkerSeverity.Hint;
+    Info: MarkerSeverity.Info;
+    Warning: MarkerSeverity.Warning;
+    Error: MarkerSeverity.Error;
+};
+export declare const InsertTextRules: {
+    InsertAsSnippet: languages.CompletionItemInsertTextRule.InsertAsSnippet;
+};
+export declare const CompletionItemKind: {
+    Function: languages.CompletionItemKind.Function;
+    Keyword: languages.CompletionItemKind.Keyword;
+    Operator: languages.CompletionItemKind.Operator;
+    Variable: languages.CompletionItemKind.Variable;
+    Field: languages.CompletionItemKind.Field;
+    Reference: languages.CompletionItemKind.Reference;
+};
+type UppercaseUnion<T extends string> = T extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${UppercaseUnion<Rest>}` : T;
+export declare const castDataTypesDict: Record<__esri.DataTypeNode["value"]["type"], UppercaseUnion<__esri.DataTypeNode["value"]["type"]>>;
+export declare const castDataTypes: UppercaseUnion<__esri.DataTypeNode["value"]["type"]>[];
+export declare const datePeriods: string[];
+export declare const dateLiterals: string[];
+export declare const trimKeywords: string[];
+export declare const sqlExprKeywords: string[];
+export declare const sqlExprOperators: string[];
+export declare const sqlExprFunctions: readonly ["CAST", "EXTRACT", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "ABS", "ACOS", "ASIN", "ATAN", "CEILING", "COS", "FLOOR", "LOG", "LOG10", "POWER", "ROUND", "SIGN", "SIN", "TAN", "CHAR_LENGTH", "COALESCE", "CONCAT", "LOWER", "POSITION", "TRIM", "UPPER"];
+export {};

package/dist/types/utils/sql-expr-monaco/sql-expr-contribution.d.ts

@@ -1,11 +1 @@
-import { type Uri } from "monaco-editor";
-import type { ISqlExprWorker } from "./types";
-/**
- * Returns the sql-expression worker for the model.
- * Example:
- * ```ts
- * const sqlExpressionWorker = await getSqlExpressionWorker(model.uri);
- * ```
- * @returns sql-expression worker
- */
-export declare function getSqlExprWorker(uri: Uri): Promise<ISqlExprWorker>;
+export {};

package/dist/types/utils/sql-expr-monaco/sql-expr-defaults.d.ts

@@ -7,7 +7,6 @@ declare class SqlExprDefaults extends LanguageDefaultsBase {
     protected _languageId: string;
     protected _languageOptions: {};
     private _layerMap;
-    private _apiService;
     updateFeatureLayerForModel(modelId: Uri | string, layer: FeatureLayer): void;
     setLanguageOptions(languageOptions: {
         assetsPath?: string | undefined;