@arcgis/portal-components 4.34.0-next.144

package/dist/types/classification.d.ts

@@ -0,0 +1,214 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+type ClassificationType = Readonly<{
+    [index: string]: string | undefined;
+    value: string;
+    acronym?: string;
+    backgroundColor?: string;
+    textColor?: string;
+}>;
+type ClassificationMetadata = Readonly<{
+    primaryAttribute: string;
+    defaultValue: string;
+    classificationValueProperties: ClassificationType[];
+}>;
+export type ValueOption = Readonly<{
+    label: string;
+    value: string;
+}>;
+export type BaseAttributesValues = Readonly<{
+    label: string;
+    description?: string;
+    type: string;
+    uiElement: string;
+    isRequired?: boolean;
+    defaultValue?: string;
+    defaultDateTimeline?: number;
+    defaultDateTimelineUnits?: string;
+    validValues?: ValueOption[];
+    validValuesMap?: Record<string, ValueOption[]>;
+    isAttributeEnabled?: string;
+    valueExpression?: string;
+    attributeValidation?: string;
+    arcadeResultLookup?: Record<string, ValueOption[]>;
+    attributeCategory?: string;
+    selectionDisplayOrder?: number;
+    selectionDisplayLabel?: string;
+    bannerOrder?: number;
+    bannerLabel?: string;
+    labelDelimiter?: string;
+    labelTooltip?: string;
+    valueDelimiter?: string;
+    attributeDelimiter?: string;
+}>;
+/**
+ * Create narrowed types for each of the possible UI elements.
+ * Never is used to inform users that the property will never be defined
+ * when uiElement is a specific value.
+ */
+type SingleSelectAttributesValues = BaseAttributesValues & Readonly<{
+    uiElement: "single-select";
+    validValues?: ValueOption[];
+    validValuesMap?: never;
+}>;
+type MultiSelectAttributesValues = BaseAttributesValues & Readonly<{
+    uiElement: "multi-select";
+    validValues?: ValueOption[];
+    validValuesMap?: never;
+}>;
+type MultiGroupedSelectNestedAttributesValues = BaseAttributesValues & Readonly<{
+    uiElement: "multi-grouped-select-nested";
+    validValuesMap: Record<string, ValueOption[]>;
+    validValues?: never;
+}>;
+type CheckboxAttributesValues = BaseAttributesValues & Readonly<{
+    uiElement: "checkbox";
+    type: "boolean";
+    validValues?: never;
+    validValuesMap?: never;
+    defaultDateTimeline?: never;
+    defaultDateTimelineUnits?: never;
+}>;
+type DateAttributesValues = BaseAttributesValues & Readonly<{
+    uiElement: "date";
+    type: "date";
+    defaultDateTimeline: number;
+    defaultDateTimelineUnits: string;
+    validValues?: never;
+    validValuesMap?: never;
+}>;
+type TextAttributesValues = BaseAttributesValues & Readonly<{
+    uiElement: "text";
+    type: "string";
+    validValues?: never;
+    validValuesMap?: never;
+    defaultDateTimeline?: never;
+    defaultDateTimelineUnits?: never;
+}>;
+export type ClassificationAttributesValues = CheckboxAttributesValues | DateAttributesValues | MultiGroupedSelectNestedAttributesValues | MultiSelectAttributesValues | SingleSelectAttributesValues | TextAttributesValues;
+export declare function isAttributesValuesOfUIElement<T extends BaseAttributesValues>(attributes: BaseAttributesValues, uiElement: T["uiElement"]): attributes is T;
+type ClassificationLayoutElements = Readonly<{
+    formDisplayOrder: number;
+}>;
+type DefaultLayout = Readonly<{
+    layoutElements: Record<string, ClassificationLayoutElements>;
+}>;
+/**
+ * The classification schema defined on the portal.
+ */
+export type ClassificationSchema = Readonly<{
+    attributeCategories?: string[];
+    attributes: Record<string, ClassificationAttributesValues>;
+    bannerExpression?: string;
+    classificationMetadata: ClassificationMetadata;
+    grammarVersion: string;
+    layouts: Record<string, DefaultLayout>;
+    name: string;
+    selectionTextExpression?: string;
+    version: string;
+    helpUrl?: string;
+    helpTooltip?: string;
+}>;
+/**
+ * The result of a request for a classification schema from
+ * the portal /portals/self/classification/classificationSchema endpoint
+ */
+export type SchemaResult = {
+    result?: ClassificationSchema;
+    error?: {
+        name: string;
+        message: string;
+        details: Record<string, unknown>;
+    };
+};
+export interface ValidationResult {
+    result?: {
+        success: string;
+    };
+    error?: {
+        code: string;
+        details: {
+            raw: {
+                messages: string[];
+            };
+            name: string;
+        };
+        message: string;
+        name: string;
+    };
+}
+declare const portalErrorList: readonly ["unhandledError"];
+export type PortalErrorType = (typeof portalErrorList)[number];
+export interface Result<ResultT = any, ErrorT extends PortalErrorType = PortalErrorType> {
+    result?: ResultT;
+    error?: PortalError<ErrorT>;
+}
+export interface PortalError<Error extends PortalErrorType = PortalErrorType> {
+    code: Error;
+    translatedMessage?: string;
+    message?: string;
+    details?: any;
+}
+export type EditInfo = Readonly<{
+    createdUser: string;
+    createdDate: number;
+    lastEditedUser: string;
+    lastEditedDate: number;
+}>;
+export type SelectionText = Readonly<{
+    elementType: string;
+    selectionDisplayLabel: string;
+    labelDelimiter: string;
+    classificationProp: string;
+    valueDelimiter: string;
+}>;
+export interface FavoriteClassification {
+    name: string;
+    classification: __esri.PortalItem["classification"];
+}
+export interface FavoriteClassificationResult {
+    result?: {
+        favorites: FavoriteClassification[];
+    };
+    error?: {
+        details: {
+            raw: {
+                code: string;
+                messages: string[];
+                messageCode: string;
+            };
+        };
+        message: string;
+        name: string;
+    };
+}
+export interface ClassificationAlertIndicator {
+    alertIndicatorType?: HTMLCalciteAlertElement["kind"];
+    alertIndicatorIcon?: string;
+    alertIndicatorInfo: string;
+}
+export interface AddFavoriteClassificationResult {
+    result?: {
+        success: boolean;
+    };
+    error?: {
+        name: string;
+        message: string;
+        details?: {
+            raw: {
+                messages: string[];
+            };
+            name: string;
+        };
+        url?: string;
+    };
+}
+/**
+ * State object that is used to store arcade expression results from expressions
+ * that are evaluated for each attribute in the classification schema.
+ **/
+export type AttributeExpressionResults = Map<string, {
+    enabled: boolean;
+    valueExpressionResult: Record<string, ValueOption[]> | ValueOption[] | null;
+    attributeValidationResult: string | null;
+}>;
+export {};

package/dist/types/components.d.ts

@@ -0,0 +1 @@
+export * from "./stencil";

package/dist/types/lumina.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="../index.d.ts" />
+import type { ArcgisPortalClassificationBanner } from "../components/arcgis-portal-classification-banner";
+import type { ArcgisPortalClassificationConfig } from "../components/arcgis-portal-classification-config";
+import type { ArcgisPortalClassificationFavorite } from "../components/arcgis-portal-classification-favorite";
+import type { ArcgisPortalClassificationFormElement } from "../components/arcgis-portal-classification-form-element";
+import type { ArcgisPortalFieldDelete } from "../components/arcgis-portal-field-delete";
+import type { h, EventHandler } from "@arcgis/lumina";
+
+interface LuminaArcgisPortalClassificationBanner extends Partial<Pick<ArcgisPortalClassificationBanner, 'missingExistingClassification' | 'portalItem' | 'validationErrors' | 'variant'>>, h.JSX.HTMLAttributes<HTMLArcgisPortalClassificationBannerElement> {
+}
+
+interface LuminaArcgisPortalClassificationConfig extends Required<Pick<ArcgisPortalClassificationConfig, 'portalItem'>>, Partial<Pick<ArcgisPortalClassificationConfig, 'valid' | 'values'>>, h.JSX.HTMLAttributes<HTMLArcgisPortalClassificationConfigElement> {
+  onarcgisPropertyChange?: EventHandler<HTMLArcgisPortalClassificationConfigElement["arcgisPropertyChange"]>;
+}
+
+interface LuminaArcgisPortalClassificationFavorite extends Partial<Pick<ArcgisPortalClassificationFavorite, 'attributeExpressionResults' | 'classificationValue' | 'favoriteClassifications' | 'portalItem' | 'resetFavoriteClassification' | 'selectedFavoriteClassificationName' | 'updateClassificationData'>>, h.JSX.HTMLAttributes<HTMLArcgisPortalClassificationFavoriteElement> {
+}
+
+interface LuminaArcgisPortalClassificationFormElement extends Partial<Pick<ArcgisPortalClassificationFormElement, 'attribute' | 'attributeKey' | 'renderingInfo' | 'value'>>, h.JSX.HTMLAttributes<HTMLArcgisPortalClassificationFormElementElement> {
+  onarcgisAttributeValueChange?: EventHandler<HTMLArcgisPortalClassificationFormElementElement["arcgisAttributeValueChange"]>;
+}
+
+interface LuminaArcgisPortalFieldDelete extends Partial<Pick<ArcgisPortalFieldDelete, 'config' | 'fieldNames' | 'layer' | 'mapView' | 'options'>>, h.JSX.HTMLAttributes<HTMLArcgisPortalFieldDeleteElement> {
+  onarcgisBeforeModalClose?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisBeforeModalClose"]>;
+  onarcgisClose?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisClose"]>;
+  onarcgisFieldsDeleted?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisFieldsDeleted"]>;
+}
+
+declare module "@arcgis/lumina" {
+  export namespace h.JSX {
+    interface IntrinsicElements {
+      "arcgis-portal-classification-banner": LuminaArcgisPortalClassificationBanner;
+      "arcgis-portal-classification-config": LuminaArcgisPortalClassificationConfig;
+      "arcgis-portal-classification-favorite": LuminaArcgisPortalClassificationFavorite;
+      "arcgis-portal-classification-form-element": LuminaArcgisPortalClassificationFormElement;
+      "arcgis-portal-field-delete": LuminaArcgisPortalFieldDelete;
+    }
+  }
+}

package/dist/types/preact.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="../index.d.ts" />
+import type { ArcgisPortalClassificationBanner } from "../components/arcgis-portal-classification-banner";
+import type { ArcgisPortalClassificationConfig } from "../components/arcgis-portal-classification-config";
+import type { ArcgisPortalClassificationFavorite } from "../components/arcgis-portal-classification-favorite";
+import type { ArcgisPortalClassificationFormElement } from "../components/arcgis-portal-classification-form-element";
+import type { ArcgisPortalFieldDelete } from "../components/arcgis-portal-field-delete";
+import { HTMLAttributes } from "preact";
+import type { EventHandler } from "@arcgis/lumina";
+
+interface PreactArcgisPortalClassificationBanner extends Partial<Pick<ArcgisPortalClassificationBanner, 'missingExistingClassification' | 'portalItem' | 'validationErrors' | 'variant'>>, HTMLAttributes<HTMLArcgisPortalClassificationBannerElement> {
+}
+
+interface PreactArcgisPortalClassificationConfig extends Required<Pick<ArcgisPortalClassificationConfig, 'portalItem'>>, Partial<Pick<ArcgisPortalClassificationConfig, 'valid' | 'values'>>, HTMLAttributes<HTMLArcgisPortalClassificationConfigElement> {
+  onarcgisPropertyChange?: EventHandler<HTMLArcgisPortalClassificationConfigElement["arcgisPropertyChange"]>;
+}
+
+interface PreactArcgisPortalClassificationFavorite extends Partial<Pick<ArcgisPortalClassificationFavorite, 'attributeExpressionResults' | 'classificationValue' | 'favoriteClassifications' | 'portalItem' | 'resetFavoriteClassification' | 'selectedFavoriteClassificationName' | 'updateClassificationData'>>, HTMLAttributes<HTMLArcgisPortalClassificationFavoriteElement> {
+}
+
+interface PreactArcgisPortalClassificationFormElement extends Partial<Pick<ArcgisPortalClassificationFormElement, 'attribute' | 'attributeKey' | 'renderingInfo' | 'value'>>, HTMLAttributes<HTMLArcgisPortalClassificationFormElementElement> {
+  onarcgisAttributeValueChange?: EventHandler<HTMLArcgisPortalClassificationFormElementElement["arcgisAttributeValueChange"]>;
+}
+
+interface PreactArcgisPortalFieldDelete extends Partial<Pick<ArcgisPortalFieldDelete, 'config' | 'fieldNames' | 'layer' | 'mapView' | 'options'>>, HTMLAttributes<HTMLArcgisPortalFieldDeleteElement> {
+  onarcgisBeforeModalClose?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisBeforeModalClose"]>;
+  onarcgisClose?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisClose"]>;
+  onarcgisFieldsDeleted?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisFieldsDeleted"]>;
+}
+
+declare module 'preact' {
+  namespace createElement.JSX {
+    interface IntrinsicElements {
+      "arcgis-portal-classification-banner": PreactArcgisPortalClassificationBanner;
+      "arcgis-portal-classification-config": PreactArcgisPortalClassificationConfig;
+      "arcgis-portal-classification-favorite": PreactArcgisPortalClassificationFavorite;
+      "arcgis-portal-classification-form-element": PreactArcgisPortalClassificationFormElement;
+      "arcgis-portal-field-delete": PreactArcgisPortalFieldDelete;
+    }
+  }
+  namespace h.JSX {
+    interface IntrinsicElements {
+      "arcgis-portal-classification-banner": PreactArcgisPortalClassificationBanner;
+      "arcgis-portal-classification-config": PreactArcgisPortalClassificationConfig;
+      "arcgis-portal-classification-favorite": PreactArcgisPortalClassificationFavorite;
+      "arcgis-portal-classification-form-element": PreactArcgisPortalClassificationFormElement;
+      "arcgis-portal-field-delete": PreactArcgisPortalFieldDelete;
+    }
+  }
+}

package/dist/types/preact10.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="../index.d.ts" />
+import type { ArcgisPortalClassificationBanner } from "../components/arcgis-portal-classification-banner";
+import type { ArcgisPortalClassificationConfig } from "../components/arcgis-portal-classification-config";
+import type { ArcgisPortalClassificationFavorite } from "../components/arcgis-portal-classification-favorite";
+import type { ArcgisPortalClassificationFormElement } from "../components/arcgis-portal-classification-form-element";
+import type { ArcgisPortalFieldDelete } from "../components/arcgis-portal-field-delete";
+import { JSX as PreactJsx } from "preact";
+import type { EventHandler } from "@arcgis/lumina";
+
+/** @deprecated Update to Preact 10.27.2+ or 11+ and consume types/preact file over types/preact10 */
+interface PreactArcgisPortalClassificationBanner extends Partial<Pick<ArcgisPortalClassificationBanner, 'missingExistingClassification' | 'portalItem' | 'validationErrors' | 'variant'>>, PreactJsx.HTMLAttributes<HTMLArcgisPortalClassificationBannerElement> {
+}
+
+/** @deprecated Update to Preact 10.27.2+ or 11+ and consume types/preact file over types/preact10 */
+interface PreactArcgisPortalClassificationConfig extends Required<Pick<ArcgisPortalClassificationConfig, 'portalItem'>>, Partial<Pick<ArcgisPortalClassificationConfig, 'valid' | 'values'>>, PreactJsx.HTMLAttributes<HTMLArcgisPortalClassificationConfigElement> {
+  onarcgisPropertyChange?: EventHandler<HTMLArcgisPortalClassificationConfigElement["arcgisPropertyChange"]>;
+}
+
+/** @deprecated Update to Preact 10.27.2+ or 11+ and consume types/preact file over types/preact10 */
+interface PreactArcgisPortalClassificationFavorite extends Partial<Pick<ArcgisPortalClassificationFavorite, 'attributeExpressionResults' | 'classificationValue' | 'favoriteClassifications' | 'portalItem' | 'resetFavoriteClassification' | 'selectedFavoriteClassificationName' | 'updateClassificationData'>>, PreactJsx.HTMLAttributes<HTMLArcgisPortalClassificationFavoriteElement> {
+}
+
+/** @deprecated Update to Preact 10.27.2+ or 11+ and consume types/preact file over types/preact10 */
+interface PreactArcgisPortalClassificationFormElement extends Partial<Pick<ArcgisPortalClassificationFormElement, 'attribute' | 'attributeKey' | 'renderingInfo' | 'value'>>, PreactJsx.HTMLAttributes<HTMLArcgisPortalClassificationFormElementElement> {
+  onarcgisAttributeValueChange?: EventHandler<HTMLArcgisPortalClassificationFormElementElement["arcgisAttributeValueChange"]>;
+}
+
+/** @deprecated Update to Preact 10.27.2+ or 11+ and consume types/preact file over types/preact10 */
+interface PreactArcgisPortalFieldDelete extends Partial<Pick<ArcgisPortalFieldDelete, 'config' | 'fieldNames' | 'layer' | 'mapView' | 'options'>>, PreactJsx.HTMLAttributes<HTMLArcgisPortalFieldDeleteElement> {
+  onarcgisBeforeModalClose?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisBeforeModalClose"]>;
+  onarcgisClose?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisClose"]>;
+  onarcgisFieldsDeleted?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisFieldsDeleted"]>;
+}
+
+declare module 'preact' {
+  namespace createElement.JSX {
+    interface IntrinsicElements {
+      "arcgis-portal-classification-banner": PreactArcgisPortalClassificationBanner;
+      "arcgis-portal-classification-config": PreactArcgisPortalClassificationConfig;
+      "arcgis-portal-classification-favorite": PreactArcgisPortalClassificationFavorite;
+      "arcgis-portal-classification-form-element": PreactArcgisPortalClassificationFormElement;
+      "arcgis-portal-field-delete": PreactArcgisPortalFieldDelete;
+    }
+  }
+  namespace h.JSX {
+    interface IntrinsicElements {
+      "arcgis-portal-classification-banner": PreactArcgisPortalClassificationBanner;
+      "arcgis-portal-classification-config": PreactArcgisPortalClassificationConfig;
+      "arcgis-portal-classification-favorite": PreactArcgisPortalClassificationFavorite;
+      "arcgis-portal-classification-form-element": PreactArcgisPortalClassificationFormElement;
+      "arcgis-portal-field-delete": PreactArcgisPortalFieldDelete;
+    }
+  }
+}

package/dist/types/react.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="../index.d.ts" />
+import type { ArcgisPortalClassificationBanner } from "../components/arcgis-portal-classification-banner";
+import type { ArcgisPortalClassificationConfig } from "../components/arcgis-portal-classification-config";
+import type { ArcgisPortalClassificationFavorite } from "../components/arcgis-portal-classification-favorite";
+import type { ArcgisPortalClassificationFormElement } from "../components/arcgis-portal-classification-form-element";
+import type { ArcgisPortalFieldDelete } from "../components/arcgis-portal-field-delete";
+import type { HTMLProps } from 'react';
+import type { EventHandler } from "@arcgis/lumina"; 
+
+interface ReactArcgisPortalClassificationBanner extends Partial<Pick<ArcgisPortalClassificationBanner, 'missingExistingClassification' | 'portalItem' | 'validationErrors' | 'variant'>>, HTMLProps<HTMLArcgisPortalClassificationBannerElement> {
+}
+
+interface ReactArcgisPortalClassificationConfig extends Required<Pick<ArcgisPortalClassificationConfig, 'portalItem'>>, Partial<Pick<ArcgisPortalClassificationConfig, 'valid' | 'values'>>, HTMLProps<HTMLArcgisPortalClassificationConfigElement> {
+  onarcgisPropertyChange?: EventHandler<HTMLArcgisPortalClassificationConfigElement["arcgisPropertyChange"]>;
+}
+
+interface ReactArcgisPortalClassificationFavorite extends Partial<Pick<ArcgisPortalClassificationFavorite, 'attributeExpressionResults' | 'classificationValue' | 'favoriteClassifications' | 'portalItem' | 'resetFavoriteClassification' | 'selectedFavoriteClassificationName' | 'updateClassificationData'>>, HTMLProps<HTMLArcgisPortalClassificationFavoriteElement> {
+}
+
+interface ReactArcgisPortalClassificationFormElement extends Partial<Pick<ArcgisPortalClassificationFormElement, 'attribute' | 'attributeKey' | 'renderingInfo' | 'value'>>, HTMLProps<HTMLArcgisPortalClassificationFormElementElement> {
+  onarcgisAttributeValueChange?: EventHandler<HTMLArcgisPortalClassificationFormElementElement["arcgisAttributeValueChange"]>;
+}
+
+interface ReactArcgisPortalFieldDelete extends Partial<Pick<ArcgisPortalFieldDelete, 'config' | 'fieldNames' | 'layer' | 'mapView' | 'options'>>, HTMLProps<HTMLArcgisPortalFieldDeleteElement> {
+  onarcgisBeforeModalClose?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisBeforeModalClose"]>;
+  onarcgisClose?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisClose"]>;
+  onarcgisFieldsDeleted?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisFieldsDeleted"]>;
+}
+
+declare module "react" {
+  namespace JSX {
+    interface IntrinsicElements {
+      "arcgis-portal-classification-banner": ReactArcgisPortalClassificationBanner;
+      "arcgis-portal-classification-config": ReactArcgisPortalClassificationConfig;
+      "arcgis-portal-classification-favorite": ReactArcgisPortalClassificationFavorite;
+      "arcgis-portal-classification-form-element": ReactArcgisPortalClassificationFormElement;
+      "arcgis-portal-field-delete": ReactArcgisPortalFieldDelete;
+    }
+  }
+}
+declare module "react/jsx-runtime" {
+  namespace JSX {
+    interface IntrinsicElements {
+      "arcgis-portal-classification-banner": ReactArcgisPortalClassificationBanner;
+      "arcgis-portal-classification-config": ReactArcgisPortalClassificationConfig;
+      "arcgis-portal-classification-favorite": ReactArcgisPortalClassificationFavorite;
+      "arcgis-portal-classification-form-element": ReactArcgisPortalClassificationFormElement;
+      "arcgis-portal-field-delete": ReactArcgisPortalFieldDelete;
+    }
+  }
+}
+declare module "react/jsx-dev-runtime" {
+  namespace JSX {
+    interface IntrinsicElements {
+      "arcgis-portal-classification-banner": ReactArcgisPortalClassificationBanner;
+      "arcgis-portal-classification-config": ReactArcgisPortalClassificationConfig;
+      "arcgis-portal-classification-favorite": ReactArcgisPortalClassificationFavorite;
+      "arcgis-portal-classification-form-element": ReactArcgisPortalClassificationFormElement;
+      "arcgis-portal-field-delete": ReactArcgisPortalFieldDelete;
+    }
+  }
+}

package/dist/types/stencil.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="../index.d.ts" />
+import type { ArcgisPortalClassificationBanner } from "../components/arcgis-portal-classification-banner";
+import type { ArcgisPortalClassificationConfig } from "../components/arcgis-portal-classification-config";
+import type { ArcgisPortalClassificationFavorite } from "../components/arcgis-portal-classification-favorite";
+import type { ArcgisPortalClassificationFormElement } from "../components/arcgis-portal-classification-form-element";
+import type { ArcgisPortalFieldDelete } from "../components/arcgis-portal-field-delete";
+import { JSXBase as StencilJsx } from "@stencil/core/internal";
+import type { EventHandler } from "@arcgis/lumina";
+
+interface StencilArcgisPortalClassificationBanner extends Partial<Pick<ArcgisPortalClassificationBanner, 'missingExistingClassification' | 'portalItem' | 'validationErrors' | 'variant'>>, StencilJsx.HTMLAttributes<HTMLArcgisPortalClassificationBannerElement> {
+}
+
+interface StencilArcgisPortalClassificationConfig extends Required<Pick<ArcgisPortalClassificationConfig, 'portalItem'>>, Partial<Pick<ArcgisPortalClassificationConfig, 'valid' | 'values'>>, StencilJsx.HTMLAttributes<HTMLArcgisPortalClassificationConfigElement> {
+  onArcgisPropertyChange?: EventHandler<HTMLArcgisPortalClassificationConfigElement["arcgisPropertyChange"]>;
+}
+
+interface StencilArcgisPortalClassificationFavorite extends Partial<Pick<ArcgisPortalClassificationFavorite, 'attributeExpressionResults' | 'classificationValue' | 'favoriteClassifications' | 'portalItem' | 'resetFavoriteClassification' | 'selectedFavoriteClassificationName' | 'updateClassificationData'>>, StencilJsx.HTMLAttributes<HTMLArcgisPortalClassificationFavoriteElement> {
+}
+
+interface StencilArcgisPortalClassificationFormElement extends Partial<Pick<ArcgisPortalClassificationFormElement, 'attribute' | 'attributeKey' | 'renderingInfo' | 'value'>>, StencilJsx.HTMLAttributes<HTMLArcgisPortalClassificationFormElementElement> {
+  onArcgisAttributeValueChange?: EventHandler<HTMLArcgisPortalClassificationFormElementElement["arcgisAttributeValueChange"]>;
+}
+
+interface StencilArcgisPortalFieldDelete extends Partial<Pick<ArcgisPortalFieldDelete, 'config' | 'fieldNames' | 'layer' | 'mapView' | 'options'>>, StencilJsx.HTMLAttributes<HTMLArcgisPortalFieldDeleteElement> {
+  onArcgisBeforeModalClose?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisBeforeModalClose"]>;
+  onArcgisClose?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisClose"]>;
+  onArcgisFieldsDeleted?: EventHandler<HTMLArcgisPortalFieldDeleteElement["arcgisFieldsDeleted"]>;
+}
+
+interface ExposedElements {
+  "arcgis-portal-classification-banner": StencilArcgisPortalClassificationBanner;
+  "arcgis-portal-classification-config": StencilArcgisPortalClassificationConfig;
+  "arcgis-portal-classification-favorite": StencilArcgisPortalClassificationFavorite;
+  "arcgis-portal-classification-form-element": StencilArcgisPortalClassificationFormElement;
+  "arcgis-portal-field-delete": StencilArcgisPortalFieldDelete;
+}
+
+export namespace JSX {
+  export interface IntrinsicElements extends ExposedElements {}
+}
+
+declare module "@stencil/core/internal/stencil-public-runtime" {
+  export namespace h.JSX {
+    interface IntrinsicElements extends ExposedElements {}
+  }
+}

package/dist/utils/arcade.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+import { ClassificationSchema, ValueOption } from '../types/classification';
+type AttributeEnabledResult = Record<string, {
+    enabled: boolean;
+}>;
+export declare function getAttributeEnabledForItem({ portalClassificationSchema, itemClassification, }: {
+    portalClassificationSchema: ClassificationSchema;
+    itemClassification: __esri.PortalItem["classification"];
+}): Promise<AttributeEnabledResult>;
+type ValueExpressionResult = Record<string, {
+    valueExpressionResult: Record<string, ValueOption[]> | ValueOption[] | null;
+}>;
+export declare function evaluateValueExpressionsForItem({ portalClassificationSchema, itemClassification, }: {
+    portalClassificationSchema: ClassificationSchema;
+    itemClassification: __esri.PortalItem["classification"];
+}): Promise<ValueExpressionResult>;
+export declare function evaluateValueExpression(attributeId: string, itemClassificationSchema: ClassificationSchema, itemClassificationValue: __esri.PortalItem["classification"]): Promise<Record<string, ValueOption[]> | ValueOption[] | null>;
+type AttributeValidationResult = Record<string, {
+    attributeValidationResult: string | null;
+}>;
+export declare function getAttributeValidationForItem({ portalClassificationSchema, itemClassification, }: {
+    portalClassificationSchema: ClassificationSchema;
+    itemClassification: __esri.PortalItem["classification"];
+}): Promise<AttributeValidationResult>;
+export declare const getBannerText: (itemClassificationSchema: ClassificationSchema, itemClassificationValue: __esri.PortalItem["classification"]) => Promise<string>;
+export declare function evaluateArcadeExpression<T>(arcadeExpression: string, schemaJson: ClassificationSchema | string, itemClassificationValue: __esri.PortalItem["classification"], attributeId?: string): Promise<T>;
+export {};

package/dist/utils/common.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+import { ClassificationSchema, BaseAttributesValues, Result, EditInfo, AttributeExpressionResults } from '../types/classification';
+/**
+ *This function addresses the scenario when classification is undefined.
+ *The param itemClassification is the original classification value retrieved from the server, it can be null.
+ */
+export declare const defineClassificationVal: (itemClassification: __esri.PortalItem["classification"], primaryAttribute: string, itemClassificationSchema: ClassificationSchema) => __esri.PortalItem["classification"];
+/**
+ *
+ * Delete all the fields that are not enabled based on-time selection
+ *
+ */
+export declare const deleteDisabledFieldsBasedOnTimeSelection: (itemClassification: __esri.PortalItem["classification"], attributeExpressionResults: AttributeExpressionResults) => __esri.PortalItem["classification"];
+/**
+ * Retrieves default values for item classification attributes based on the provided schema.
+ */
+export declare const retrieveDefaultValues: (itemClassificationSchema: ClassificationSchema, itemClassification: __esri.PortalItem["classification"]) => __esri.PortalItem["classification"];
+/** we populate the date picker by default date as today + DateTimeline(units) */
+export declare const populateDeclassificationDate: (attributes: BaseAttributesValues) => string;
+export declare const resetItemClassificationValue: (newPrimaryAttributeValue: string, itemClassification: __esri.PortalItem["classification"], primaryAttribute: string) => __esri.PortalItem["classification"];
+/** The configure experience is only available to the item owner,
+ * a full admin, a member with the administrative privilege to update content,
+ * or a member of a shared update group to which the item is shared.
+ * */
+export declare const canConfigureClassification: (portalItem: __esri.PortalItem | undefined) => Promise<boolean>;
+export declare const userAndItemBelongToSharedUpdateGroup: (item: __esri.PortalItem, user: __esri.PortalUser) => Promise<boolean>;
+export declare const getUserGroups: (user: __esri.PortalUser, portalUrl: string) => Promise<Result<__esri.PortalGroup[]>>;
+export declare const getItemGroups: (item: __esri.PortalItem, portalUrl: string) => Promise<Result>;
+export declare const getEditInfo: (item: __esri.PortalItem | undefined, itemClassification: __esri.PortalItem["classification"]) => EditInfo;

package/dist/utils/commonEnums.d.ts

@@ -0,0 +1,5 @@
+export declare enum fieldInfoPrefixEnum {
+    expression = "expression/",
+    raster = "Raster.",
+    relationship = "relationships/"
+}

package/dist/utils/commonFunctions.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+/**
+ * Returns true if the value is defined
+ * @param value - value to check
+ */
+export declare function isDefined<T>(value?: T | null): value is T;
+export declare function getFieldDisplayName(field: __esri.FieldInfo, arcadeMap: Map<string, __esri.ExpressionInfo>): string;
+export declare function getFieldType(fieldName: string, layerFieldsMap: Map<string, __esri.Field>, arcadeExpMap: Map<string, __esri.ExpressionInfo>): string;
+export declare function generateLayerFieldsMap(layer: any): Promise<Map<string, __esri.Field>>;
+export declare function generateArcadeExpressionMap(popupTemplate: __esri.PopupTemplate): Map<string, __esri.ExpressionInfo>;
+export declare function getFieldsFromLayer(layer: __esri.CatalogFootprintLayer | __esri.FeatureLayer | __esri.ImageryLayer | __esri.ImageryTileLayer | __esri.KnowledgeGraphSublayer | __esri.OGCFeatureLayer | __esri.OrientedImageryLayer | __esri.StreamLayer | __esri.Sublayer | __esri.SubtypeSublayer | __esri.WCSLayer | __esri.WFSLayer): Promise<any>;

package/dist/utils/fieldAddDelete.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+import { FieldDeleteOptions } from './types';
+export declare function canAddField(layer: any): Promise<boolean>;
+export declare function canDeleteField(mapView: __esri.MapView | undefined, layer: any, field: __esri.Field, options?: FieldDeleteOptions): Promise<boolean>;

package/dist/utils/functionalComponents/FieldIcons.d.ts

@@ -0,0 +1,6 @@
+import { TemplateResult } from 'lit';
+interface FieldIconsProps {
+    fieldType: string;
+}
+export declare const FieldIcons: ({ fieldType }: FieldIconsProps) => TemplateResult;
+export default FieldIcons;

package/dist/utils/item.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+/**
+ * Determine if a user is either the owner or an admin of an item
+ */
+export declare function userIsItemAdmin(item: __esri.PortalItem, user: __esri.PortalUser): boolean;
+/**
+ * Determine if a user is the owner of an item
+ */
+export declare function isOwner(item: __esri.PortalItem, user: __esri.PortalUser): boolean;
+export declare function isSpatioTemporalService(item: __esri.PortalItem): boolean;
+export declare function isViewServiceLayer(item: __esri.PortalItem): boolean;
+export declare function isHostedServiceLayer(item: __esri.PortalItem): boolean;
+export declare function layerParticipatesInJoinedView(item: __esri.PortalItem): boolean;
+export declare function isParentOfJoinedView(sourceJSON: any): boolean;
+export declare function getUserGroups(layer: __esri.FeatureLayer | __esri.OrientedImageryLayer): Promise<any>;
+export declare function getItemGroups(layer: __esri.FeatureLayer | __esri.OrientedImageryLayer): Promise<any>;
+export declare function getRelatedItems(itemId: string, portal: __esri.Portal, { relationshipType, direction }: {
+    relationshipType: string;
+    direction?: "forward" | "reverse";
+}): Promise<any>;
+export declare function userAndItemBelongToSharedUpdateGroup(userGroups: any, itemGroups: any): boolean;

package/dist/utils/portal.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+export declare function getPortalRestBaseUrl(portal: __esri.Portal): string;

package/dist/utils/requests.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+import { SchemaResult, ValidationResult, FavoriteClassificationResult, AddFavoriteClassificationResult } from '../types/classification';
+/**
+ * Requests the classification schema from the portal.
+ * @param portalUrl the url to the portal's classification schema endpoint
+ * @param signal the abort signal
+ * @returns the classification schema result
+ */
+export declare function requestClassificationSchema(portalUrl: string, signal: AbortSignal): Promise<SchemaResult>;
+export declare function validateClassificationValue(portalUrl: string, itemClassification: __esri.PortalItem["classification"], options: {
+    signal?: AbortSignal;
+}): Promise<ValidationResult>;
+export declare function requestFavoriteClassificationValues(portalItem: __esri.PortalItem | undefined): Promise<FavoriteClassificationResult | undefined>;
+/** Add favorite classification values */
+export declare function uploadFavoriteClassificationValues(portalItem: __esri.PortalItem | undefined, itemClassificationValue: __esri.PortalItem["classification"]): Promise<AddFavoriteClassificationResult | undefined>;

package/dist/utils/types.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+/**
+ * Configuration
+ */
+export interface IConfig {
+    arcadeEditor?: string;
+    jsapiUrl?: string;
+    helpMap?: Record<string, string>;
+    helpBase?: string;
+}
+export interface FieldDeleteOptions {
+    item: __esri.PortalItem;
+    portal: __esri.Portal;
+    handleCloseOnConsumer?: boolean;
+    ignorePopupTemplate?: boolean;
+    ignoreLayerRenderer?: boolean;
+    ignoreLayerFeatureReduction?: boolean;
+    ignoreLayerLabelingInfo?: boolean;
+    ignoreLayerDefinitionExpression?: boolean;
+    ignoreItemRenderer?: boolean;
+    ignoreItemFeatureReduction?: boolean;
+    userItemInfo?: UserItemInfo;
+}
+export interface UserItemInfo {
+    itemData: any;
+    userGroups: any[];
+    itemGroups: any[];
+    relatedItems: any[];
+    fieldGroups: any[];
+}

package/dist/utils/url.d.ts

@@ -0,0 +1 @@
+export declare const addTrailingSlashIfMissing: (url: string) => string;