@doegis/core/interfaces.d.ts

DOE GIS API

type HashMap<T> = Record<string, T>;

type IPromise<T> = Promise<T>;
type GroupKey<T> = Exclude<T, IHandle>;

interface IHandle {
  remove(): void;
}

interface __esriImplementsIteration<T> {
  [Symbol.iterator](): IterableIterator<T>;
}

declare namespace __esri {
  export class Accessor {
    destroyed: boolean;
    initialized: boolean;
    declaredClass: string;
    constructor(obj?: any);
    destroy(): void;
    get<T>(propertyName: string): T;
    get(propertyName: string): any;
    set<T>(propertyName: string, value: T): this;
    set(props: HashMap<any>): this;
    watch(path: string | string[], callback: WatchCallback, sync?: boolean): WatchHandle;
    own(handles: IHandle | IHandle[]): void;
    addHandles<T>(handles: IHandle | IHandle[], groupKey?: GroupKey<T>): void;
    removeHandles<T>(groupKey?: GroupKey<T>): void;
    hasHandles<T>(groupKey?: GroupKey<T>): boolean;
    protected notifyChange(propertyName: string): void;
    protected _get(propertyName: string): any;
    protected _get<T>(propertyName: string): T;
    protected _set<T>(propertyName: string, value: T): this;
  }
  export interface AnonymousAccessor {
    get?<T>(propertyName: string): T;
    get?(propertyName: string): any;
    set?<T>(propertyName: string, value: T): this;
    set?(props: HashMap<any>): this;
    watch?(path: string | string[], callback: WatchCallback, sync?: boolean): WatchHandle;
  }
  export type ItemCallback<T> = (item: T, index: number) => void;
  export type ItemCompareCallback<T> = (firstItem: T, secondItem: T) => number;
  export type ItemMapCallback<T, R> = (item: T, index: number) => R;
  export type ItemReduceCallback<T, R> = (previousValue: R, currentValue: T, index: number) => R;
  export type ItemTestCallback<T> = (item: T, index: number) => boolean;
  export type CollectionAfterAddEventHandler<T> = (event: CollectionAfterEvent<T>) => void;
  export type CollectionAfterChangesEventHandler<T> = (event: CollectionAfterChangesEvent<T>) => void;
  export type CollectionAfterRemoveEventHandler<T> = (event: CollectionAfterEvent<T>) => void;
  export type CollectionChangeEventHandler<T> = (event: CollectionChangeEvent<T>) => void;
  export type CollectionBeforeAddEventHandler<T> = (event: CollectionBeforeEvent<T>) => void;
  export type CollectionBeforeChangesEventHandler<T> = (event: CollectionBeforeEvent<T>) => void;
  export type CollectionBeforeRemoveEventHandler<T> = (event: CollectionBeforeEvent<T>) => void;
  export interface CollectionAfterEvent<T = any> {
    item: T;
  }
  export interface CollectionAfterChangesEvent<T = any> {
  }
  export interface CollectionBeforeEvent<T = any> {
    item: T;
    preventDefault(): void;
  }
  export interface CollectionChangeEvent<T = any> {
    added: T[];
    removed: T[];
    moved: T[];
  }
  interface Collection<T = any> extends Evented, __esriImplementsIteration<T> {
    on(type: "after-add", listener: CollectionAfterAddEventHandler<T>): IHandle;
    on(type: "after-changes", listener: CollectionAfterChangesEventHandler<T>): IHandle;
    on(type: "after-remove", listener: CollectionAfterRemoveEventHandler<T>): IHandle;
    on(type: "before-add", listener: CollectionBeforeAddEventHandler<T>): IHandle;
    on(type: "before-changes", listener: CollectionBeforeChangesEventHandler<T>): IHandle;
    on(type: "before-remove", listener: CollectionBeforeRemoveEventHandler<T>): IHandle;
    on(type: "change", listener: CollectionChangeEventHandler<T>): IHandle;
    on(type: string, listener: (event: any) => void): IHandle;
  }
  type Constructor<T> = new (...params: any[]) => T;
  interface Types<T extends Base, Base = T> {
    key: string | ((obj: any) => string);
    base: Constructor<Base> | Function;
    typeMap: HashMap<Constructor<T>>;
  }
  export class Collection<T = any> extends Accessor {
    readonly length: number;
    constructor(values?: any[] | Collection<any> | CollectionPropertiesBase<any>);
    at(index: number): T;
    add(item: T, index?: number): this;
    addMany(items: T[] | Collection<T>, index?: number): this;
    clone(): Collection<T>;
    concat(value: T[] | Collection<T>): Collection<T>;
    every(callback: ItemTestCallback<T>): boolean;
    filter(callback: ItemTestCallback<T>): Collection<T>;
    filter<S extends T>(callback: (item: T, index: number) => item is S): Collection<S>;
    find(callback: ItemTestCallback<T>): T;
    findIndex(callback: ItemTestCallback<T>): number;
    flatten(callback: (item: T, index: number) => T[] | Collection<T>): Collection<T>;
    flatten<U>(callback: (item: U, index: number) => U[] | Collection<U>): Collection<U>;
    forEach(callback: ItemCallback<T>): void;
    getItemAt(index: number): T;
    includes(searchElement: T): boolean;
    indexOf(searchElement: T, fromIndex?: number): number;
    join(separator?: string): string;
    lastIndexOf(searchElement: T, fromIndex?: number): number;
    map<R = T>(callback: ItemMapCallback<T, R>): Collection<R>;
    pop(): T;
    push(item: T): number;
    reduce<R = T>(callback: ItemReduceCallback<T, R>, initialValue?: R): R;
    reduceRight<R = T>(callback: ItemReduceCallback<T, R>, initialValue?: R): R;
    remove(item: T): void;
    removeAll(): void;
    removeAt(index: number): any;
    removeMany(items: T[] | Collection<T>): T[];
    reorder(item: T, index: number): T;
    reverse(): this;
    shift(): T;
    slice(begin?: number, end?: number): Collection<T>;
    some(callback: ItemCallback<T>): boolean;
    sort(compareFunction?: ItemCompareCallback<T>): this;
    splice(start: number, deleteCount: number, ...items: T[]): T[];
    toArray(): T[];
    unshift(...items: T[]): number;
    static isCollection<T = any>(value: any | Collection<T>): value is Collection<T>;
    static ofType<T extends Base, Base = T>(type: Constructor<T> | Types<T, Base>): new (items?: (T[] | Collection<T>) | { items?: T[] | Collection<T> }) => Collection<T>;
  }
  type CollectionProperties<T = any> = T[] | Collection<T>;
  interface CollectionPropertiesBase<T = any> {
    items?: T[];
  }
  type DateProperties = number | string | Date;
  interface ReactiveWatchOptions {
    readonly initial?: boolean;
    readonly sync?: boolean;
    readonly once?: boolean;
    readonly equals?: (newValue: any, oldValue: any) => boolean;
  }
  interface ReactiveListenerOptions<Target> {
    sync?: boolean;
    once?: boolean;
    onListenerAdd?: (target: Target) => void;
    onListenerRemove?: (target: Target) => void;
  }
  interface reactiveUtils {
    watch<T>(getValue: () => T, callback: (newValue: T, oldValue: T) => void, options?: ReactiveWatchOptions): IHandle;
    when<T>(getValue: () => T | null | undefined, callback: (newValue: T, oldValue: T | null) => void, options?: ReactiveWatchOptions): IHandle;
    on<T extends Evented | EventTarget>(getTarget: () => T | null | undefined, eventName: string, callback: (value: any) => void, options?: ReactiveListenerOptions<T>): IHandle;
    once<T>(getValue: () => T, signal?: AbortSignal | { signal?: AbortSignal } | null): Promise<T>;
    whenOnce<T>(getValue: () => T | null | undefined, signal?: AbortSignal | { signal?: AbortSignal } | null): Promise<T>;
  }
  export const reactiveUtils: reactiveUtils;
  export type BaseDynamicLayerLayerviewCreateErrorEventHandler = (
    event: BaseDynamicLayerLayerviewCreateErrorEvent
  ) => void;
  export type BaseDynamicLayerLayerviewCreateEventHandler = (event: BaseDynamicLayerLayerviewCreateEvent) => void;
  export type BaseDynamicLayerLayerviewDestroyEventHandler = (event: BaseDynamicLayerLayerviewDestroyEvent) => void;
  export type BaseDynamicLayerRefreshEventHandler = (event: BaseDynamicLayerRefreshEvent) => void;
  export type BasemapLayerListTriggerActionEventHandler = (event: BasemapLayerListTriggerActionEvent) => void;
  export type BaseTileLayerLayerviewCreateErrorEventHandler = (event: BaseTileLayerLayerviewCreateErrorEvent) => void;
  export type BaseTileLayerLayerviewCreateEventHandler = (event: BaseTileLayerLayerviewCreateEvent) => void;
  export type BaseTileLayerLayerviewDestroyEventHandler = (event: BaseTileLayerLayerviewDestroyEvent) => void;
  export type BaseTileLayerRefreshEventHandler = (event: BaseTileLayerRefreshEvent) => void;
  export type BingMapsLayerLayerviewCreateErrorEventHandler = (event: BingMapsLayerLayerviewCreateErrorEvent) => void;
  export type BingMapsLayerLayerviewCreateEventHandler = (event: BingMapsLayerLayerviewCreateEvent) => void;
  export type BingMapsLayerLayerviewDestroyEventHandler = (event: BingMapsLayerLayerviewDestroyEvent) => void;
  export type BingMapsLayerRefreshEventHandler = (event: BingMapsLayerRefreshEvent) => void;
  export type BookmarksBookmarkEditEventHandler = (event: BookmarksBookmarkEditEvent) => void;
  export type BookmarksBookmarkSelectEventHandler = (event: BookmarksBookmarkSelectEvent) => void;
  export type CredentialDestroyEventHandler = (event: CredentialDestroyEvent) => void;
  export type CredentialTokenChangeEventHandler = (event: CredentialTokenChangeEvent) => void;
  export type CSVLayerLayerviewCreateErrorEventHandler = (event: CSVLayerLayerviewCreateErrorEvent) => void;
  export type CSVLayerLayerviewCreateEventHandler = (event: CSVLayerLayerviewCreateEvent) => void;
  export type CSVLayerLayerviewDestroyEventHandler = (event: CSVLayerLayerviewDestroyEvent) => void;
  export type CSVLayerRefreshEventHandler = (event: CSVLayerRefreshEvent) => void;
  export type ElevationSamplerChangedEventHandler = (event: ElevationSamplerChangedEvent) => void;
  export type FeatureFormSubmitEventHandler = (event: FeatureFormSubmitEvent) => void;
  export type FeatureFormValueChangeEventHandler = (event: FeatureFormValueChangeEvent) => void;
  export type FeatureFormViewModelSubmitEventHandler = (event: FeatureFormViewModelSubmitEvent) => void;
  export type FeatureFormViewModelValueChangeEventHandler = (event: FeatureFormViewModelValueChangeEvent) => void;
  export type FeatureLayerEditsEventHandler = (event: FeatureLayerEditsEvent) => void;
  export type FeatureLayerLayerviewCreateErrorEventHandler = (event: FeatureLayerLayerviewCreateErrorEvent) => void;
  export type FeatureLayerLayerviewCreateEventHandler = (event: FeatureLayerLayerviewCreateEvent) => void;
  export type FeatureLayerLayerviewDestroyEventHandler = (event: FeatureLayerLayerviewDestroyEvent) => void;
  export type FeatureLayerRefreshEventHandler = (event: FeatureLayerRefreshEvent) => void;
  export type FeatureTableSelectionChangeEventHandler = (event: FeatureTableSelectionChangeEvent) => void;
  export type FeatureTemplatesSelectEventHandler = (event: FeatureTemplatesSelectEvent) => void;
  export type FeatureTemplatesViewModelSelectEventHandler = (event: FeatureTemplatesViewModelSelectEvent) => void;
  export type GeoJSONLayerEditsEventHandler = (event: GeoJSONLayerEditsEvent) => void;
  export type GeoJSONLayerLayerviewCreateErrorEventHandler = (event: GeoJSONLayerLayerviewCreateErrorEvent) => void;
  export type GeoJSONLayerLayerviewCreateEventHandler = (event: GeoJSONLayerLayerviewCreateEvent) => void;
  export type GeoJSONLayerLayerviewDestroyEventHandler = (event: GeoJSONLayerLayerviewDestroyEvent) => void;
  export type GeoJSONLayerRefreshEventHandler = (event: GeoJSONLayerRefreshEvent) => void;
  export type GeoRSSLayerLayerviewCreateErrorEventHandler = (event: GeoRSSLayerLayerviewCreateErrorEvent) => void;
  export type GeoRSSLayerLayerviewCreateEventHandler = (event: GeoRSSLayerLayerviewCreateEvent) => void;
  export type GeoRSSLayerLayerviewDestroyEventHandler = (event: GeoRSSLayerLayerviewDestroyEvent) => void;
  export type GeoRSSLayerRefreshEventHandler = (event: GeoRSSLayerRefreshEvent) => void;
  export type HeatmapSliderThumbChangeEventHandler = (event: HeatmapSliderThumbChangeEvent) => void;
  export type HeatmapSliderThumbDragEventHandler = (event: HeatmapSliderThumbDragEvent) => void;
  export type HistogramRangeSliderMaxChangeEventHandler = (event: HistogramRangeSliderMaxChangeEvent) => void;
  export type HistogramRangeSliderMinChangeEventHandler = (event: HistogramRangeSliderMinChangeEvent) => void;
  export type HistogramRangeSliderSegmentDragEventHandler = (event: HistogramRangeSliderSegmentDragEvent) => void;
  export type HistogramRangeSliderThumbChangeEventHandler = (event: HistogramRangeSliderThumbChangeEvent) => void;
  export type HistogramRangeSliderThumbDragEventHandler = (event: HistogramRangeSliderThumbDragEvent) => void;
  export type HomeGoEventHandler = (event: HomeGoEvent) => void;
  export type HomeViewModelGoEventHandler = (event: HomeViewModelGoEvent) => void;
  export type IdentityManagerCredentialCreateEventHandler = (event: IdentityManagerCredentialCreateEvent) => void;
  export type IdentityManagerDialogCreateEventHandler = (event: IdentityManagerDialogCreateEvent) => void;
  export type ImageryLayerLayerviewCreateErrorEventHandler = (event: ImageryLayerLayerviewCreateErrorEvent) => void;
  export type ImageryLayerLayerviewCreateEventHandler = (event: ImageryLayerLayerviewCreateEvent) => void;
  export type ImageryLayerLayerviewDestroyEventHandler = (event: ImageryLayerLayerviewDestroyEvent) => void;
  export type ImageryLayerRefreshEventHandler = (event: ImageryLayerRefreshEvent) => void;
  export type LayerLayerviewCreateErrorEventHandler = (event: LayerLayerviewCreateErrorEvent) => void;
  export type LayerLayerviewCreateEventHandler = (event: LayerLayerviewCreateEvent) => void;
  export type LayerLayerviewDestroyEventHandler = (event: LayerLayerviewDestroyEvent) => void;
  export type LayerListTriggerActionEventHandler = (event: LayerListTriggerActionEvent) => void;
  export type LayerListViewModelTriggerActionEventHandler = (event: LayerListViewModelTriggerActionEvent) => void;
  export type LocateLocateErrorEventHandler = (event: LocateLocateErrorEvent) => void;
  export type LocateLocateEventHandler = (event: LocateLocateEvent) => void;
  export type LocateViewModelLocateErrorEventHandler = (event: LocateViewModelLocateErrorEvent) => void;
  export type MapImageLayerLayerviewCreateErrorEventHandler = (event: MapImageLayerLayerviewCreateErrorEvent) => void;
  export type MapImageLayerLayerviewCreateEventHandler = (event: MapImageLayerLayerviewCreateEvent) => void;
  export type MapImageLayerLayerviewDestroyEventHandler = (event: MapImageLayerLayerviewDestroyEvent) => void;
  export type MapImageLayerRefreshEventHandler = (event: MapImageLayerRefreshEvent) => void;
  export class AreaMeasurementAnalysis extends Accessor {
    geometry: DOEPolygon;
    unit: SystemOrAreaUnit;
    constructor(properties?: AreaMeasurementAnalysisProperties);
    clone(): this;
  }
  export type AreaMeasurementAnalysisConstructor = typeof AreaMeasurementAnalysis;
  interface AreaMeasurementAnalysisProperties {
    geometry?: PolygonProperties;
    unit?: | "imperial"
    | "metric"
    | "square-millimeters"
    | "square-centimeters"
    | "square-decimeters"
    | "square-meters"
    | "square-kilometers"
    | "square-inches"
    | "square-feet"
    | "square-yards"
    | "square-miles"
    | "square-us-feet"
    | "acres"
    | "ares"
    | "hectares";
  }
  export class DimensionAnalysis extends Accessor {
    dimensions: Collection<LengthDimension>;
    style: DimensionSimpleStyle;
    constructor(properties?: DimensionAnalysisProperties);
    clone(): this;
  }
  export type DimensionAnalysisConstructor = typeof DimensionAnalysis;
  interface DimensionAnalysisProperties {
    dimensions?: CollectionProperties<LengthDimensionProperties>;
    style?: DimensionSimpleStyleProperties;
  }
  export class DimensionSimpleStyle extends Accessor {
    color: Color;
    fontSize: number;
    lineSize: number;
    textBackgroundColor: Color;
    textColor: Color;
    readonly type: "simple";
    constructor(properties?: DimensionSimpleStyleProperties);
    clone(): this;
  }
  export type DimensionSimpleStyleConstructor = typeof DimensionSimpleStyle;
  interface DimensionSimpleStyleProperties {
    color?: Color | number[] | string;
    fontSize?: number | string;
    lineSize?: number | string;
    textBackgroundColor?: Color | number[] | string;
    textColor?: Color | number[] | string;
  }
  export class DirectLineMeasurementAnalysis extends Accessor {
    endPoint: DOEPoint;
    startPoint: DOEPoint;
    unit: SystemOrLengthUnit;
    constructor(properties?: DirectLineMeasurementAnalysisProperties);
    clone(): this;
  }
  export type DirectLineMeasurementAnalysisConstructor = typeof DirectLineMeasurementAnalysis;
  interface DirectLineMeasurementAnalysisProperties {
    endPoint?: PointProperties;
    startPoint?: PointProperties;
    unit?: | "imperial"
    | "metric"
    | "millimeters"
    | "centimeters"
    | "decimeters"
    | "meters"
    | "kilometers"
    | "inches"
    | "feet"
    | "yards"
    | "miles"
    | "nautical-miles"
    | "us-feet";
  }
  export class LengthDimension extends Accessor {
    endPoint: DOEPoint;
    measureType: "direct" | "horizontal" | "vertical";
    offset: number;
    orientation: number;
    startPoint: DOEPoint;
    constructor(properties?: LengthDimensionProperties);
    clone(): this;
  }
  export type LengthDimensionConstructor = typeof LengthDimension;
  interface LengthDimensionProperties {
    endPoint?: PointProperties;
    measureType?: "direct" | "horizontal" | "vertical";
    offset?: number;
    orientation?: number;
    startPoint?: PointProperties;
  }
  export class LineOfSightAnalysis extends Accessor {
    observer: LineOfSightAnalysisObserver;
    targets: Collection<LineOfSightAnalysisTarget>;
    constructor(properties?: LineOfSightAnalysisProperties);
    clone(): this;
  }
  export type LineOfSightAnalysisConstructor = typeof LineOfSightAnalysis;
  interface LineOfSightAnalysisProperties {
    observer?: LineOfSightAnalysisObserverProperties;
    targets?: CollectionProperties<LineOfSightAnalysisTargetProperties>;
  }
  export class LineOfSightAnalysisObserver extends Accessor {
    elevationInfo: LineOfSightAnalysisObserverElevationInfo;
    feature: Graphic;
    position: DOEPoint;
    constructor(properties?: LineOfSightAnalysisObserverProperties);
    clone(): this;
  }
  export type LineOfSightAnalysisObserverConstructor = typeof LineOfSightAnalysisObserver;
  interface LineOfSightAnalysisObserverProperties {
    elevationInfo?: LineOfSightAnalysisObserverElevationInfo;
    feature?: GraphicProperties;
    position?: PointProperties;
  }
  export interface LineOfSightAnalysisObserverElevationInfo {
    mode: "on-the-ground" | "relative-to-ground" | "absolute-height" | "relative-to-scene";
    offset?: number;
  }
  export class LineOfSightAnalysisTarget extends Accessor {
    elevationInfo: LineOfSightAnalysisTargetElevationInfo;
    feature: Graphic;
    position: DOEPoint;
    constructor(properties?: LineOfSightAnalysisTargetProperties);
    clone(): this;
  }
  export type LineOfSightAnalysisTargetConstructor = typeof LineOfSightAnalysisTarget;
  interface LineOfSightAnalysisTargetProperties {
    elevationInfo?: LineOfSightAnalysisTargetElevationInfo;
    feature?: GraphicProperties;
    position?: PointProperties;
  }
  export interface LineOfSightAnalysisTargetElevationInfo {
    mode: "on-the-ground" | "relative-to-ground" | "absolute-height" | "relative-to-scene";
    offset?: number;
  }
  export class SliceAnalysis extends Accessor {
    shape: SlicePlane;
    readonly type: "slice";
    constructor(properties?: SliceAnalysisProperties);
    clone(): this;
  }
  export type SliceAnalysisConstructor = typeof SliceAnalysis;
  interface SliceAnalysisProperties {
    shape?: SlicePlaneProperties;
  }
  export interface SlicePlane extends Accessor, JSONSupport {
  }
  export class SlicePlane {
    heading: number;
    height: number;
    position: DOEPoint;
    tilt: number;
    readonly type: "plane";
    width: number;
    constructor(properties?: SlicePlaneProperties);
    clone(): this;
    static fromJSON(json: any): SlicePlane;
  }
  export type SlicePlaneConstructor = typeof SlicePlane;
  interface SlicePlaneProperties {
    heading?: number;
    height?: number;
    position?: PointProperties;
    tilt?: number;
    width?: number;
  }
  interface mediaUtils {
  }
  export const mediaUtils: mediaUtils;
  interface SceneViewerColorUtils {
    isBright(color: Color): boolean;
  }
  export const SceneViewerColorUtils: SceneViewerColorUtils;
  interface sceneViewerUtils {
    canSaveAs(webscene: WebScene): boolean;
    createTilingScheme(tileInfo: TileInfo): any;
    editorHasPendingEdits(viewModel: EditorViewModel): boolean;
    editorNavigateBack(viewModel: EditorViewModel): Promise<void>;
    getOrCreateCompatibleTileInfo(tileInfo: TileInfo, expectedTileSize: number, resolutionModifier: number): any;
    initializeSchemaValidators(): void;
    isHostedAgolServiceUrl(url: string): boolean;
    isSchemaValidationError(saveError: void): boolean;
    isSpatialReferenceSupported(spatialReference: SpatialReference, viewingMode: "global" | "local"): boolean;
    isSupportedTileInfo(tileInfo: TileInfo): boolean;
    renderSVG(swatch: any[][], width: number, height: number, options?: any): any;
    saveStateWarning(warningMessage: string, error: any): void;
    zoomDragBeginPoint(view: DOESceneView): number[] | null;
  }
  export const sceneViewerUtils: sceneViewerUtils;
  interface arcade {
    createArcadeExecutor(script: string, profile: Profile): Promise<ArcadeExecutor>;
    createArcadeProfile(profileName: | "form-constraint"
      | "feature-z"
      | "field-calculation"
      | "form-calculation"
      | "labeling"
      | "popup"
      | "popup-element"
      | "feature-reduction-popup"
      | "feature-reduction-popup-element"
      | "visualization"): Profile;
  }
  export const arcade: arcade;
  export interface ArcadeExecutor {
    execute: ExecuteFunction;
    executeAsync: ExecuteFunctionAsync;
    fieldsUsed: string[];
    geometryUsed: boolean;
    isAsync: boolean;
  }
  export interface ArrayElementType {
    type: | "array"
    | "dictionary"
    | "feature"
    | "featureSet"
    | "featureSetCollection"
    | "geometry"
    | "number"
    | "text"
    | "date"
    | "boolean";
    properties?: ProfileVariable[];
    elementType?: ArrayElementType;
  }
  export interface ArrayVariable {
    name: string;
    type: "array";
    elementType?: ArrayElementType;
  }
  export interface DictionaryVariable {
    name: string;
    type: "dictionary";
    properties?: ProfileVariable[];
  }
  export interface ExecuteContext {
    spatialReference?: SpatialReference;
  }
  export type ExecuteFunction = (profileVariableInstances: any, context?: ExecuteContext) => ResultType;
  export type ExecuteFunctionAsync = (profileVariableInstances: any, context?: ExecuteContext) => Promise<ResultType>;
  export interface Profile {
    variables: ProfileVariable[];
  }
  export type ProfileVariable = SimpleVariable | DictionaryVariable | ArrayVariable;
  export type ProfileVariableInstanceType = | Graphic
    | DOEGeometry
    | FeatureSet
    | DOEFeatureLayer
    | Map
    | DOEGeometry
    | string
    | number
    | boolean
    | Date
    | any
    | any[];
  export type ResultType = number | string | Date | boolean | Graphic | DOEGeometry | any | ResultType[];
  export interface SimpleVariable {
    name: string;
    type: "feature" | "featureSet" | "featureSetCollection" | "geometry" | "number" | "text" | "date" | "boolean";
  }
  export interface Basemap extends Accessor, Loadable, JSONSupport {
  }
  export class Basemap {
    baseLayers: Collection<Layer>;
    id: string;
    readonly loaded: boolean;
    portalItem: PortalItem;
    referenceLayers: Collection<Layer>;
    spatialReference: SpatialReference;
    thumbnailUrl: string;
    title: string;
    constructor(properties?: BasemapProperties);
    clone(): Basemap;
    destroy(): void;
    loadAll(): Promise<Basemap>;
    static fromId(id: string): Basemap;
    static fromJSON(json: any): Basemap;
  }
  export type BasemapConstructor = typeof Basemap;
  interface BasemapProperties extends LoadableProperties {
    baseLayers?: CollectionProperties<LayerProperties>;
    id?: string;
    portalItem?: PortalItemProperties;
    referenceLayers?: CollectionProperties<LayerProperties>;
    spatialReference?: SpatialReferenceProperties;
    thumbnailUrl?: string;
    title?: string;
  }
  export interface Camera extends Accessor, JSONSupport {
  }
  export class Camera {
    fov: number;
    heading: number;
    position: DOEPoint;
    tilt: number;
    constructor(properties?: CameraProperties);
    clone(): this;
    static fromJSON(json: any): Camera;
  }
  export type CameraConstructor = typeof Camera;
  interface CameraProperties {
    fov?: number;
    heading?: number;
    position?: PointProperties;
    tilt?: number;
  }
  export class Color {
    a: number;
    b: number;
    g: number;
    r: number;
    constructor(color: string | number[] | any);
    clone(): Color;
    setColor(color: string | number[] | any): Color;
    toCss(includeAlpha?: boolean): string;
    toHex(): string;
    toJSON(): any;
    toRgb(): number[];
    toRgba(): number[];
    static blendColors(start: Color, end: Color, weight: number, out?: Color): Color;
    static fromArray(a: number[], t?: Color): Color;
    static fromHex(colorStr: string, t?: Color): Color;
    static fromJSON(json: any): Color;
    static fromRgb(color: string, out?: Color): Color;
    static fromString(str: string, obj?: Color): Color;
  }
  export type ColorConstructor = typeof Color;
  interface config {
    apiKey: string;
    assetsPath: string;
    fontsUrl: string;
    geometryServiceUrl: string;
    geoRSSServiceUrl: string;
    kmlServiceUrl: string;
    log: configLog;
    portalUrl: string;
    request: configRequest;
    routeServiceUrl: string;
    workers: configWorkers;
  }
  export const config: config;
  export type AfterInterceptorCallback = (response: RequestResponse) => void;
  export type BeforeInterceptorCallback = (params: any) => any;
  export interface configLog {
    interceptors: LogInterceptor[];
    level: "none" | "error" | "warn" | "info";
  }
  export interface configRequest {
    httpsDomains?: string[];
    interceptors?: RequestInterceptor[];
    maxUrlLength?: number;
    priority?: "auto" | "high" | "low";
    proxyRules?: configRequestProxyRules[];
    proxyUrl?: string;
    timeout?: number;
    trustedServers?: string[];
    useIdentity?: boolean;
  }
  export interface configRequestProxyRules {
    proxyUrl?: string;
    urlPrefix?: string;
  }
  export interface configWorkers {
    loaderUrl?: any;
    workerPath?: string;
    loaderConfig?: configWorkersLoaderConfig;
  }
  export interface configWorkersLoaderConfig {
    baseUrl?: string;
    has?: any;
    paths?: any;
    map?: any;
    packages?: any[];
  }
  export type ErrorCallback = (error: Error) => void;
  export type LogInterceptor = (level: "error" | "warn" | "info", module: string, ...args: any[]) => boolean;
  export interface RequestInterceptor {
    after?: AfterInterceptorCallback;
    before?: BeforeInterceptorCallback;
    error?: ErrorCallback;
    headers?: any;
    query?: any;
    responseData?: any;
    urls?: string | RegExp | (string | RegExp)[];
  }
  export type WatchCallback = (newValue: any, oldValue: any, propertyName: string, target: Accessor) => void;
  export interface WatchHandle {
    remove(): void;
  }
  interface decorators {
    aliasOf(propertyName: string): Function;
    cast(propertyName: string): Function;
    cast(functionOrClass: Function): Function;
    property(propertyMetadata?: decoratorsPropertyPropertyMetadata): Function;
    subclass(declaredClass?: string): Function;
  }
  export const decorators: decorators;
  export interface decoratorsPropertyPropertyMetadata {
    dependsOn?: string[];
    type?: Function;
    cast?: Function;
    readOnly?: boolean;
    constructOnly?: boolean;
    aliasOf?: string;
    value?: any;
  }
  export interface CollectionAfterAddEvent {
    item: any;
  }
  export interface CollectionAfterChangesEvent {
  }
  export interface CollectionAfterRemoveEvent {
    item: any;
  }
  export interface CollectionBeforeAddEvent {
    cancellable: boolean;
    defaultPrevented: boolean;
    item: any;
    preventDefault: Function;
  }
  export interface CollectionBeforeChangesEvent {
    cancellable: boolean;
    defaultPrevented: boolean;
    item: any;
    preventDefault: Function;
  }
  export interface CollectionBeforeRemoveEvent {
    cancellable: boolean;
    defaultPrevented: boolean;
    item: any;
    preventDefault: Function;
  }
  export class Error {
    details: any;
    message: string;
    name: string;
    constructor(name: string, message?: string, details?: any);
  }
  export type ErrorConstructor = typeof Error;
  export class Evented {
    emit(type: string, event?: any): boolean;
    hasEventListener(type: string): boolean;
    on(type: string | string[], listener: EventHandler): IHandle;
  }
  export type EventHandler = (event: any) => void;
  export class HandleOwner extends Accessor {
    handles: Handles;
    constructor(properties?: HandleOwnerProperties);
  }
  export type HandleOwnerConstructor = typeof HandleOwner;
  interface HandleOwnerProperties {
    handles?: Handles;
  }
  export class Handles {
    constructor();
    add(handles: WatchHandle | WatchHandle[] | Collection<WatchHandle>, groupKey?: any): void;
    destroy(): void;
    has(groupKey: any): boolean;
    remove(groupKey?: any): void;
    removeAll(): void;
  }
  export type HandlesConstructor = typeof Handles;
  export interface Handle {
    remove(): void;
  }
  export class Identifiable {
  }
  export class JSONSupport {
    toJSON(): any;
    static fromJSON(json: any): any;
  }
  interface lang {
    clone(elem: any): any;
  }
  export const lang: lang;
  export class Loadable {
    readonly loadError: Error;
    readonly loadStatus: "not-loaded" | "loading" | "failed" | "loaded";
    readonly loadWarnings: any[];
    cancelLoad(): void;
    isFulfilled(): boolean;
    isRejected(): boolean;
    isResolved(): boolean;
    load(signal?: AbortSignal): Promise<any>;
    when(callback?: Function, errback?: Function): Promise<any>;
  }
  interface LoadableProperties {
  }
  export class corePromise {
    isFulfilled(): boolean;
    isRejected(): boolean;
    isResolved(): boolean;
    when(callback?: Function, errback?: Function): Promise<any>;
  }
  interface promiseUtils {
    create(executor: Executor): Promise<any>;
    createAbortError(): Error;
    debounce<T>(callback: T): T;
    eachAlways(promises: Promise<any>[] | any): Promise<EachAlwaysResult[]> | any;
    filter<T>(input: T[], predicate: FilterPredicateCallback): Promise<T[]>;
    isAbortError(error: Error): boolean;
  }
  export const promiseUtils: promiseUtils;
  export interface EachAlwaysResult {
    promise: Promise<any>;
    value?: any;
    error?: any;
  }
  export type Executor = (resolve: ResolveCallback, reject: RejectCallback) => void;
  export type FilterPredicateCallback = (value: any, index: number) => Promise<any>;
  export type RejectCallback = (error?: any) => void;
  export type ResolveCallback = (value?: any | Promise<any>) => void;
  interface quantity {
  }
  export const quantity: quantity;
  export interface Angle {
    value: number;
    unit: AngleUnit;
    type: "angle";
  }
  export interface Area {
    value: number;
    unit: AreaUnit;
    type: "area";
  }
  export interface Length {
    value: number;
    unit: LengthUnit;
    type: "length";
  }
  interface scheduling {
    addFrameTask(phases: PhaseCallbacks): FrameTaskHandle;
    schedule(callback: Function): any;
  }
  export const scheduling: scheduling;
  export interface FrameTaskHandle {
    pause(): void;
    resume(): void;
    remove(): void;
  }
  export type PhaseCallback = (event?: PhaseEvent) => void;
  export interface PhaseCallbacks {
    prepare?: PhaseCallback;
    render?: PhaseCallback;
    update?: PhaseCallback;
  }
  export interface PhaseEvent {
    time: number;
    deltaTime: number;
    elapsedFrameTime: number;
  }
  interface sql {
    parseWhereClause(clause: string, fieldsIndex: FieldsIndex): Promise<WhereClause>;
  }
  export const sql: sql;
  interface WhereClause {
    fieldNames: string[];
    readonly isStandardized: boolean;
    parseTree: SQLNode;
    calculateValue(feature: any): any;
    testFeature(feature: any): boolean;
  }
  export const WhereClause: WhereClause;
  export interface BinaryNode {
    type: "binary-expression";
    operator: | "AND"
    | "OR"
    | "IS"
    | "ISNOT"
    | "IN"
    | "NOT IN"
    | "BETWEEN"
    | "NOTBETWEEN"
    | "LIKE"
    | "NOT LIKE"
    | "<>"
    | "<"
    | ">"
    | ">="
    | "<="
    | "="
    | "*"
    | "-"
    | "+"
    | "/";
    left: SQLNode;
    right: SQLNode;
    escape?: string;
  }
  export interface BoolNode {
    type: "boolean";
    value: boolean;
  }
  export interface ColumnNode {
    type: "column-reference";
    column: "string";
  }
  export interface CurrentTimeNode {
    type: "current-time";
    mode: "timestamp" | "date";
  }
  export interface DateNode {
    type: "date";
    value: string;
  }
  export interface FunctionNode {
    type: "function";
    name: string;
    args: ListNode;
  }
  export interface IntervalNode {
    type: "interval";
    value: StringNode;
    op: "+" | "-" | "";
    qualifier: IntervalQualifierNode | IntervalPeriodNode;
  }
  export interface IntervalPeriodNode {
    type: "interval-period";
    period: "day" | "month" | "hour" | "second" | "year" | "minute";
    precision: number;
    secondary: "number";
  }
  export interface IntervalQualifierNode {
    type: "interval-qualifier";
    period: "day" | "month" | "hour" | "second" | "year" | "minute";
    precision: number;
    secondary: "number";
  }
  export interface ListNode {
    type: "expression-list";
    expr: SQLNode;
  }
  export interface NullNode {
    type: "null";
    value: null;
  }
  export interface NumberNode {
    type: "number";
    value: number;
  }
  export interface SearchedCaseNode {
    type: "case-expression";
    format: "searched";
    clauses: WhenNode[];
    else: SQLNode;
  }
  export interface SimpleCaseNode {
    type: "case_expression";
    format: "simple";
    clauses: WhenNode[];
    operand: SQLNode;
    else: SQLNode;
  }
  export type SQLNode = | BinaryNode
    | BoolNode
    | ColumnNode
    | CurrentTimeNode
    | DateNode
    | FunctionNode
    | IntervalNode
    | IntervalPeriodNode
    | IntervalQualifierNode
    | NullNode
    | StringNode
    | ListNode
    | NumberNode
    | SimpleCaseNode
    | SearchedCaseNode
    | TimeStampNode
    | UnaryNode
    | WhenNode;
  export interface StringNode {
    type: "string";
    value: string;
  }
  export interface TimeStampNode {
    type: "timestamp";
    value: string;
  }
  export interface UnaryNode {
    type: "unary-expression";
    expr: SQLNode;
  }
  export interface WhenNode {
    type: "when-clause";
    operand: SQLNode;
    value: SQLNode;
  }
  namespace units {
    export type LengthUnit = | "millimeters"
      | "centimeters"
      | "decimeters"
      | "meters"
      | "kilometers"
      | "inches"
      | "feet"
      | "yards"
      | "miles"
      | "nautical-miles"
      | "us-feet";
    export type AreaUnit = | "square-millimeters"
      | "square-centimeters"
      | "square-decimeters"
      | "square-meters"
      | "square-kilometers"
      | "square-inches"
      | "square-feet"
      | "square-yards"
      | "square-miles"
      | "square-us-feet"
      | "acres"
      | "ares"
      | "hectares";
    export type VolumeUnit = | "liters"
      | "cubic-millimeters"
      | "cubic-centimeters"
      | "cubic-decimeters"
      | "cubic-meters"
      | "cubic-kilometers"
      | "cubic-inches"
      | "cubic-feet"
      | "cubic-yards"
      | "cubic-miles";
    export type AngleUnit = "degrees" | "radians";
    export type Unit = __esri.LengthUnit | __esri.AreaUnit | __esri.VolumeUnit | __esri.AngleUnit;
    export type MeasurementSystem = "imperial" | "metric";
    export type SystemOrAreaUnit = __esri.MeasurementSystem | __esri.AreaUnit;
    export type SystemOrLengthUnit = __esri.MeasurementSystem | __esri.LengthUnit;
  }
  export type AngleUnit = "degrees" | "radians";
  export type AreaUnit = | "square-millimeters"
    | "square-centimeters"
    | "square-decimeters"
    | "square-meters"
    | "square-kilometers"
    | "square-inches"
    | "square-feet"
    | "square-yards"
    | "square-miles"
    | "square-us-feet"
    | "acres"
    | "ares"
    | "hectares";
  export type LengthUnit = | "millimeters"
    | "centimeters"
    | "decimeters"
    | "meters"
    | "kilometers"
    | "inches"
    | "feet"
    | "yards"
    | "miles"
    | "nautical-miles"
    | "us-feet";
  export type MeasurementSystem = "imperial" | "metric";
  export type SystemOrAreaUnit = MeasurementSystem | AreaUnit;
  export type SystemOrLengthUnit = MeasurementSystem | LengthUnit;
  export type Unit = LengthUnit | AreaUnit | VolumeUnit | AngleUnit;
  export type VolumeUnit = | "liters"
    | "cubic-millimeters"
    | "cubic-centimeters"
    | "cubic-decimeters"
    | "cubic-meters"
    | "cubic-kilometers"
    | "cubic-inches"
    | "cubic-feet"
    | "cubic-yards"
    | "cubic-miles";
  interface urlUtils {
    addProxyRule(rule: urlUtilsAddProxyRuleRule): number;
    getProxyRule(url: string): any;
    urlToObject(url: string): any;
  }
  export const urlUtils: urlUtils;
  export interface urlUtilsAddProxyRuleRule {
    proxyUrl: string;
    urlPrefix: string;
  }
  interface watchUtils {
    init(obj: Accessor, propertyName: string | string[], callback: WatchCallback): WatchHandle;
    on(obj: Accessor, propertyName: string | string[], eventName: string, eventHandler: Function, attachedHandler?: EventAttachedCallback, detachedHandler?: EventAttachedCallback): WatchHandle;
    once(obj: Accessor, propertyName: string | string[], callback?: WatchCallback): PromisedWatchHandle;
    pausable(obj: Accessor, propertyName: string | string[], callback?: WatchCallback): PausableWatchHandle;
    watch(obj: Accessor, propertyName: string | string[], callback: WatchCallback): WatchHandle;
    when(obj: Accessor, propertyName: string | string[], callback: WatchCallback): WatchHandle;
    whenDefined(obj: Accessor, propertyName: string | string[], callback: WatchCallback): WatchHandle;
    whenDefinedOnce(obj: Accessor, propertyName: string | string[], callback?: WatchCallback): PromisedWatchHandle;
    whenEqual(obj: Accessor, propertyName: string, value: any, callback: WatchCallback): WatchHandle;
    whenEqualOnce(obj: Accessor, propertyName: string, value: any, callback?: WatchCallback): PromisedWatchHandle;
    whenFalse(obj: Accessor, propertyName: string | string[], callback: WatchCallback): WatchHandle;
    whenFalseOnce(obj: Accessor, propertyName: string | string[], callback?: WatchCallback): PromisedWatchHandle;
    whenNot(obj: Accessor, propertyName: string | string[], callback: WatchCallback): WatchHandle;
    whenNotOnce(obj: Accessor, propertyName: string | string[], callback?: WatchCallback): PromisedWatchHandle;
    whenOnce(obj: Accessor, propertyName: string | string[], callback?: WatchCallback): PromisedWatchHandle;
    whenTrue(obj: Accessor, propertyName: string | string[], callback: WatchCallback): WatchHandle;
    whenTrueOnce(obj: Accessor, propertyName: string | string[], callback?: WatchCallback): PromisedWatchHandle;
    whenUndefined(obj: Accessor, propertyName: string | string[], callback: WatchCallback): WatchHandle;
    whenUndefinedOnce(obj: Accessor, propertyName: string | string[], callback?: WatchCallback): PromisedWatchHandle;
  }
  export const watchUtils: watchUtils;
  export type EventAttachedCallback = (target?: any, propName?: string, obj?: Accessor, eventName?: string) => void;
  export interface PausableWatchHandle {
    remove(): void;
    pause(): void;
    resume(): void;
  }
  export interface PromisedWatchHandle extends Promise<any> {
    remove(): void;
  }
  interface workers {
    open(modulePath: string, options?: workersOpenOptions): Promise<Connection>;
  }
  export const workers: workers;
  export class Connection {
    constructor();
    broadcast(methodName: string, data?: any, options?: ConnectionBroadcastOptions): Promise<any>[];
    close(): void;
    invoke(methodName: string, data?: any, options?: ConnectionInvokeOptions): Promise<any>;
  }
  export type ConnectionConstructor = typeof Connection;
  export interface ConnectionBroadcastOptions {
    signal?: AbortSignal;
  }
  export interface ConnectionInvokeOptions {
    transferList?: any[];
    signal?: AbortSignal;
  }
  export interface workersOpenOptions {
    client?: any;
    strategy?: "distributed" | "dedicated" | "local";
    signal?: AbortSignal;
  }
  export interface Element extends Accessor, JSONSupport {
  }
  export class Element {
    description: string;
    label: string;
    readonly type: "field" | "group";
    visibilityExpression: string;
    constructor(properties?: ElementProperties);
    static fromJSON(json: any): Element;
  }
  export type ElementConstructor = typeof Element;
  interface ElementProperties {
    description?: string;
    label?: string;
    visibilityExpression?: string;
  }
  export class FieldElement extends Element {
    domain: CodedValueDomain | RangeDomain;
    editable: boolean;
    editableExpression: string;
    fieldName: string;
    hint: string;
    input: | TextBoxInput
      | TextAreaInput
      | DateTimePickerInput
      | BarcodeScannerInput
      | ComboBoxInput
      | RadioButtonsInput
      | SwitchInput;
    requiredExpression: string;
    readonly type: "field";
    valueExpression: string;
    constructor(properties?: FieldElementProperties);
    clone(): FieldElement;
    static fromJSON(json: any): FieldElement;
  }
  export type FieldElementConstructor = typeof FieldElement;
  interface FieldElementProperties extends ElementProperties {
    domain?: (CodedValueDomainProperties & { type: "coded-value" }) | (RangeDomainProperties & { type: "range" });
    editable?: boolean;
    editableExpression?: string;
    fieldName?: string;
    hint?: string;
    input?: | (TextBoxInputProperties & { type: "text-box" })
    | (TextAreaInputProperties & { type: "text-area" })
    | (DateTimePickerInputProperties & { type: "datetime-picker" })
    | (BarcodeScannerInputProperties & { type: "barcode-scanner" })
    | (ComboBoxInputProperties & { type: "combo-box" })
    | (RadioButtonsInputProperties & { type: "radio-buttons" })
    | (SwitchInputProperties & { type: "switch" });
    requiredExpression?: string;
    valueExpression?: string;
  }
  export class GroupElement extends Element {
    elements: FieldElement[];
    initialState: "collapsed" | "expanded";
    type: "group";
    constructor(properties?: GroupElementProperties);
    clone(): GroupElement;
    static fromJSON(json: any): GroupElement;
  }
  export type GroupElementConstructor = typeof GroupElement;
  interface GroupElementProperties extends ElementProperties {
    elements?: FieldElementProperties[];
    initialState?: "collapsed" | "expanded";
    type?: "group";
  }
  export interface BarcodeScannerInput extends Accessor, TextInput, JSONSupport {
  }
  export class BarcodeScannerInput {
    readonly type: "barcode-scanner";
    constructor(properties?: BarcodeScannerInputProperties);
    static fromJSON(json: any): BarcodeScannerInput;
  }
  export type BarcodeScannerInputConstructor = typeof BarcodeScannerInput;
  interface BarcodeScannerInputProperties extends TextInputProperties {
  }
  export interface ComboBoxInput extends Accessor, JSONSupport {
  }
  export class ComboBoxInput {
    noValueOptionLabel: string;
    showNoValueOption: boolean;
    readonly type: "combo-box";
    constructor(properties?: ComboBoxInputProperties);
    static fromJSON(json: any): ComboBoxInput;
  }
  export type ComboBoxInputConstructor = typeof ComboBoxInput;
  interface ComboBoxInputProperties {
    noValueOptionLabel?: string;
    showNoValueOption?: boolean;
  }
  export interface DateTimePickerInput extends Accessor, JSONSupport {
  }
  export class DateTimePickerInput {
    includeTime: boolean;
    max: number;
    min: number;
    readonly type: "datetime-picker";
    constructor(properties?: DateTimePickerInputProperties);
    clone(): DateTimePickerInput;
    static fromJSON(json: any): DateTimePickerInput;
  }
  export type DateTimePickerInputConstructor = typeof DateTimePickerInput;
  interface DateTimePickerInputProperties {
    includeTime?: boolean;
    max?: number;
    min?: number;
  }
  export interface RadioButtonsInput extends Accessor, JSONSupport {
  }
  export class RadioButtonsInput {
    noValueOptionLabel: string;
    showNoValueOption: boolean;
    readonly type: "radio-buttons";
    constructor(properties?: RadioButtonsInputProperties);
    static fromJSON(json: any): RadioButtonsInput;
  }
  export type RadioButtonsInputConstructor = typeof RadioButtonsInput;
  interface RadioButtonsInputProperties {
    noValueOptionLabel?: string;
    showNoValueOption?: boolean;
  }
  export interface SwitchInput extends Accessor, JSONSupport {
  }
  export class SwitchInput {
    offValue: string | number;
    onValue: string | number;
    readonly type: "switch";
    constructor(properties?: SwitchInputProperties);
    static fromJSON(json: any): SwitchInput;
  }
  export type SwitchInputConstructor = typeof SwitchInput;
  interface SwitchInputProperties {
    offValue?: string | number;
    onValue?: string | number;
  }
  export interface TextAreaInput extends TextInput, JSONSupport {
  }
  export class TextAreaInput {
    readonly type: "text-area";
    constructor(properties?: TextAreaInputProperties);
    clone(): TextAreaInput;
    static fromJSON(json: any): TextAreaInput;
  }
  export type TextAreaInputConstructor = typeof TextAreaInput;
  interface TextAreaInputProperties extends TextInputProperties {
  }
  export interface TextBoxInput extends Accessor, TextInput, JSONSupport {
  }
  export class TextBoxInput {
    readonly type: "text-box";
    constructor(properties?: TextBoxInputProperties);
    clone(): TextBoxInput;
    static fromJSON(json: any): TextBoxInput;
  }
  export type TextBoxInputConstructor = typeof TextBoxInput;
  interface TextBoxInputProperties extends TextInputProperties {
  }
  export class TextInput {
    maxLength: number;
    minLength: number;
  }
  interface TextInputProperties {
    maxLength?: number;
    minLength?: number;
  }
  export type inputsBarcodeScannerInput = BarcodeScannerInput;
  export type inputsDateTimePickerInput = DateTimePickerInput;
  export type inputsInput = | DateTimePickerInput
    | TextAreaInput
    | TextBoxInput
    | BarcodeScannerInput
    | ComboBoxInput
    | RadioButtonsInput;
  export type inputsTextAreaInput = TextAreaInput;
  export type inputsTextBoxInput = TextBoxInput;
  interface inputs {
  }
  export const inputs: inputs;
  export interface ExpressionInfo extends Accessor, JSONSupport {
  }
  export class ExpressionInfo {
    expression: string;
    name: string;
    returnType: "boolean" | "date" | "number" | "string";
    title: string;
    constructor(properties?: ExpressionInfoProperties);
    clone(): ExpressionInfo;
    static fromJSON(json: any): ExpressionInfo;
  }
  export type ExpressionInfoConstructor = typeof ExpressionInfo;
  interface ExpressionInfoProperties {
    expression?: string;
    name?: string;
    returnType?: "boolean" | "date" | "number" | "string";
    title?: string;
  }
  export interface FormTemplate extends Accessor, JSONSupport {
  }
  export class FormTemplate {
    description: string;
    elements: Element[];
    expressionInfos: ExpressionInfo[];
    preserveFieldValuesWhenHidden: boolean;
    title: string;
    constructor(properties?: FormTemplateProperties);
    clone(): FormTemplate;
    static fromJSON(json: any): FormTemplate;
  }
  export type FormTemplateConstructor = typeof FormTemplate;
  interface FormTemplateProperties {
    description?: string;
    elements?: ElementProperties[];
    expressionInfos?: ExpressionInfoProperties[];
    preserveFieldValuesWhenHidden?: boolean;
    title?: string;
  }
  interface elements {
  }
  export const elements: elements;
  namespace geometry {
    export type SpatialReference = __esri.SpatialReference;
    export const SpatialReference: typeof __esri.SpatialReference;
    export type DOEGeometry = | __esri.DOEExtent
      | __esri.Multipoint
      | __esri.DOEPoint
      | __esri.DOEPolygon
      | __esri.DOEPolyline
      | __esri.Mesh;
    export type DOEExtent = __esri.DOEExtent;
    export const DOEExtent: typeof __esri.DOEExtent;
    export type Multipoint = __esri.Multipoint;
    export const Multipoint: typeof __esri.Multipoint;
    export type DOEPoint = __esri.DOEPoint;
    export const DOEPoint: typeof __esri.DOEPoint;
    export type DOEPolygon = __esri.DOEPolygon;
    export const DOEPolygon: typeof __esri.DOEPolygon;
    export type DOEPolyline = __esri.DOEPolyline;
    export const DOEPolyline: typeof __esri.DOEPolyline;
    export type Mesh = __esri.Mesh;
    export const Mesh: typeof __esri.Mesh;
  }
  export class Circle extends DOEPolygon {
    center: DOEPoint;
    geodesic: boolean;
    numberOfPoints: number;
    radius: number;
    radiusUnit: "feet" | "kilometers" | "meters" | "miles" | "nautical-miles" | "yards";
    constructor(properties?: CircleProperties);
    clone(): Circle;
    static fromJSON(json: any): Circle;
  }
  export type CircleConstructor = typeof Circle;
  interface CircleProperties extends PolygonProperties {
    center?: PointProperties;
    geodesic?: boolean;
    numberOfPoints?: number;
    radius?: number;
    radiusUnit?: "feet" | "kilometers" | "meters" | "miles" | "nautical-miles" | "yards";
  }
  interface coordinateFormatter