@sassoftware/vi-api 1.42.0 → 1.46.0

package/control/control-api.d.ts

@@ -5,6 +5,8 @@ import { PageDataChange, PageModeChange, StateChange } from "./events";
 import { Control, RefreshablePageControlOptions, SlidingPanelContent, SlidingPanelProperties, TypeAttributes } from "./page";
 import { FieldTypeToRestrictions, FileRestrictions } from "./restrictions";
 import { AttachmentFormData } from "./file";
+import { MaskingControlApi, MaskingPageApi } from "./masking-api";
+import { IControlClientStates } from "../../spb/page-viewer/control-member/api/control-state-api";
 /**
  * The minimum API that should be supported on control members across solutions.
  */
@@ -47,9 +49,14 @@ export interface ControlApiBase<ControlTypeAttributes extends TypeAttributes = T
     readonly state: ControlStateApi;
     /** Control type. */
     readonly type: string;
-    /** Control Mask */
+    /**
+     * Control Mask
+     * @deprecated use `api.control.masking.isConfiguredForMasking` instead.
+     **/
     isMaskedControl(): boolean;
-    /** Control Mask Authorization */
+    /** Control Mask Authorization
+     * @deprecated use `api.control.masking.isAuthorizedToUnmask`
+     **/
     isAuthorizedToUnmask(): boolean;
     /**
      * Sets the value of the control's field.
@@ -85,6 +92,10 @@ export interface ControlApiBase<ControlTypeAttributes extends TypeAttributes = T
      * @returns Object representing the calling control.
      */
     getControl(): Control<ControlTypeAttributes>;
+    /**
+     * Access the Control Data Masking API
+     */
+    masking: MaskingControlApi;
 }
 /**
  * This API pertains to administration functionality for controls, for example registering resources.
@@ -176,16 +187,24 @@ export interface ControlStateApi {
      * True if the control is hidden, otherwise false.
      */
     readonly hidden: boolean;
+    /**
+     * Returns the disabled state of the calling control.
+     * True if the control is disabled, otherwise false.
+     */
+    readonly disabled: boolean;
     /**
      * Returns the masked state of the calling control.
      * True if the control is masked, otherwise false.
+     * @deprecated use `api.control.masking.isMasked`
      */
     readonly maskActive: boolean;
     /**
-     * Returns the disabled state of the calling control.
-     * True if the control is disabled, otherwise false.
+     * Returns the state with a specified key.
+     * @method
+     * @param state {string} The key of the state to be returned.
+     * @returns The specified state of the calling control, or undefined if no match.
      */
-    readonly disabled: boolean;
+    get<T extends keyof IControlClientStates>(state: T): boolean | undefined;
     /**
      * Registers a function to be invoked whenever a state change event occurs.
      * This function receives an object that contains information about the change event.
@@ -380,8 +399,9 @@ export interface ControlPageApi extends ControlPageApiBase {
      *      When providing a url for content: the panel properties will be available on the controller's "slidingPanel" object.
      *      When providing a selector for content: the properties will be set on the element to be created.
      * @param [onClose] {function} A callback function invoked when the panel is dismissed. There are no parameters. Returns void.
+     * @param [focusPreviousActiveElementOnClose] {boolean} Toggle for whether the app should apply focus to the last active element before the panel was opened.
      */
-    toggleSlidingPanel<T>(sectionLabel?: string, content?: SlidingPanelContent<T>, panelProperties?: SlidingPanelProperties, onClose?: () => void): void;
+    toggleSlidingPanel<T>(sectionLabel?: string, content?: SlidingPanelContent<T>, panelProperties?: SlidingPanelProperties, onClose?: () => void, focusPreviousActiveElementOnClose?: boolean): void;
     /**
      * Checks if a page is in edit mode.
      * @method
@@ -423,6 +443,16 @@ export interface ControlPageApi extends ControlPageApiBase {
      * @returns A Promise which resolves when the page has been saved.
      */
     save(stopEditing: boolean, closeObject: boolean): Promise<void>;
+    /**
+     * Access the Page Data Masking API
+     */
+    masking: MaskingPageApi;
+    onNavigationStart(callback: () => void): void;
+    /**
+     * Checks if the sliding panel is pinned
+     * @returns A boolean value that checks whether the sliding panel is pinned.
+     */
+    isSlidingPanelPinned(): boolean | undefined;
 }
 /**
  * Methods related to files.
@@ -506,3 +536,8 @@ export interface ControlFileApi extends ControlFileApiBase {
  */
 export interface ControlPageEventsApi extends PageEventsApiBase {
 }
+export interface FieldNotOnPageError {
+    name: "FieldNotOnPageError";
+    message: string;
+    fields: string[];
+}

package/control/events.d.ts

@@ -72,5 +72,5 @@ export interface StateChange {
     allowInput?: boolean;
     couldBeReadOnly?: boolean;
     couldBeRequired?: boolean;
-    maskActive?: boolean;
+    masked?: boolean;
 }

package/control/masking-api.d.ts

@@ -0,0 +1,187 @@
+import { FieldValue } from "./data-types";
+export interface UnmaskEventData {
+    data: {
+        [fieldName: string]: FieldValue;
+    };
+    fieldNames: string[];
+    documentId: string;
+    documentType: string;
+    scopeId: string;
+    nodeId?: string;
+}
+export interface MaskEventData {
+    fieldNames: string[];
+    documentId: string;
+    documentType: string;
+    scopeId: string;
+    nodeId?: string;
+}
+export interface MaskResetEventData {
+    scopeId: string;
+    documentId: string;
+    fieldNames: string[];
+}
+export declare const MASKED_FIELD_CHAR = "\u2022";
+export declare const MASKED_FIELD_PLACEHOLDER: string;
+export declare const MASKED_FIELD_ISO_CODE_PLACEHOLDER: string;
+export interface MaskingPageApi {
+    /**
+     * Determines whether a field is masked.
+     * @throws {FieldNotOnPageError}
+     * @param fieldName The field name.
+     * @returns A boolean.
+     */
+    isMasked(fieldName: string): boolean;
+    /**
+     * Masks a field.
+     * @throws {NotConfiguredForMaskingError}
+     * @throws {FieldNotOnPageError}
+     * @param fieldName The field name.
+     */
+    mask(fieldName: string): void;
+    /**
+     * Masks the fields.
+     * If no fields array is passed in then all fields that are configured for masking on the page will be masked.
+     * @throws {NotConfiguredForMaskingError} If one or more of the fields are not configured for masking.
+     * @throws {FieldNotOnPageError} If one or more of the fields are not available on the page.
+     * @param fieldNames The field names.
+     */
+    maskAll(fieldNames?: string[]): void;
+    /**
+     * Unmasks the field via a fetch.
+     * Subsequent get field value calls return the unmasked value.
+     * If the field is unmasked or has been unmasked in the current page mode, no fetch is made.
+     * If the field is not on the page the promise will reject with a {@link FieldNotOnPageError}.
+     * If the field is not configured for masking the promise will reject with a {@link NotConfiguredForMaskingError}.
+     * If the user is not authorized to reveal the field, the returned promise will reject with an {@link UnmaskAuthError}.
+     * @param fieldName The field name.
+     * @returns A promise that resolves when the unmask is successful.
+     */
+    unmask(fieldName: string): Promise<void>;
+    /**
+     * Unmasks the fields via a fetch.
+     * Subsequent get field value calls return the unmasked value.
+     * If no fields array is passed in then all fields on the page configured for masking will be unmasked.
+     * For each field, if the field is unmasked or has been unmasked in the current page mode, no fetch for it is made.
+     * If one or more of the fields are not on the page the promise will reject with a {@link FieldNotOnPageError}.
+     * If one or more of the fields are not configured for masking the promise will reject with a {@link NotConfiguredForMaskingError}.
+     * If the user is not authorized to reveal one or more of the fields, the returned promise will reject with an {@link UnmaskAuthError}.
+     * @param fieldNames The field names.
+     * @returns A promise that resolves when the unmasks are successful.
+     */
+    unmaskAll(fieldNames?: string[]): Promise<void>;
+    /**
+     * Invokes the callback whenever any field value is masked.
+     * When an individual field is masked via a mask call, the callback will be invoked once.
+     * When multiple fields are masked via a single mask/mask all call, the callback will be invoked once.
+     * @param callback The callback function.
+     * @returns A function that removes the callback.
+     */
+    onEveryMask(callback: (mask: {
+        fieldNames: string[];
+    }) => void): () => void;
+    /**
+     * Invokes the callback whenever the specified field is masked.
+     * @throws {FieldNotOnPageError}
+     * @param fieldName The field name.
+     * @param callback The callback function.
+     * @returns A function that removes the callback.
+     */
+    onMask(fieldName: string, callback: () => void): () => void;
+    /**
+     * Invokes the callback whenever any field value is unmasked.
+     * When an individual field is unmasked via an unmask call, the callback will be invoked once.
+     * When multiple fields are unmasked via a single unmask/unmask all call, the callback will be invoked once.
+     * @param callback The callback function.
+     * @returns A function that removes the callback.
+     */
+    onEveryUnmask(callback: (unmask: {
+        fieldNames: string[];
+    }) => void): () => void;
+    /**
+     * Invokes the callback whenever the specified field is unmasked.
+     * @throws {FieldNotOnPageError}
+     * @param fieldName The field name.
+     * @param callback The callback function.
+     * @returns A function that removes the callback.
+     */
+    onUnmask(fieldName: string, callback: () => void): () => void;
+    /**
+     * Determines whether the field is configured for masking via the field's restrictions.
+     * @throws {FieldNotOnPageError}
+     * @param fieldName The field name.
+     * @returns Whether the field is configured for masking.
+     */
+    isConfiguredForMasking(fieldName: string): boolean;
+    /**
+     * Determines whether the current user can unmask the field.
+     * @throws {FieldNotOnPageError}
+     * @throws {NotConfiguredForMaskingError}
+     * @param fieldName The field name.
+     * @returns Whether the current can unmask the field.
+     */
+    isAuthorizedToUnmask(fieldName: string): boolean;
+}
+export interface MaskingControlApi {
+    /**
+     * In the case of a single field control, determines whether the control's field is masked.
+     * In the case of a multiple field control, determines whether one or more of the control's fields are masked.
+     * @returns A boolean.
+     */
+    isMasked(): boolean;
+    /**
+     * Masks the control's field(s) that are configured for masking.
+     * @throws {NotConfiguredForMaskingError} If a single field control's field is not configured for masking or if
+     * all of a multiple field control's fields are not configured for masking.
+     */
+    mask(): void;
+    /**
+     * Unmasks the controls field(s) via a fetch.
+     * Subsequent get field value calls return the unmasked value.
+     * For each field, if the field is unmasked or has been unmasked in the current page mode, no fetch for it is made.
+     * If a single field control's field is not configured for masking or if all of a multiple field control's fields are not configured for masking the returned
+     * promise will reject with a {@link NotConfiguredForMaskingError}.
+     * If the user is not authorized to reveal one or more of the control's fields, the returned promise will reject with an {@link UnmaskAuthError}.
+     * @returns A promise that resolves when the unmask is successful.
+     */
+    unmask(): Promise<void>;
+    /**
+     * Invokes the callback whenever the control's field is (or, in the case of a multiple field control, fields are) masked.
+     * @param callback The callback function.
+     * @returns A function that removes the callback.
+     */
+    onMask(callback: (mask: {
+        fieldNames: string[];
+    }) => void): () => void;
+    /**
+     * Invokes the callback whenever the control's field is (or, in the case of a multiple field control, fields are) unmasked.
+     * @param callback The callback function.
+     * @returns A function that removes the callback.
+     */
+    onUnmask(callback: (unmask: {
+        fieldNames: string[];
+    }) => void): () => void;
+    /**
+     * In the case of a single field control, determines (via the field restrictions) whether the control's field is configured for masking.
+     * In the case of a multiple field control, determines (via the field restrictions) whether one or more of the control's fields are configured for masking.
+     * @returns Whether the control is configured for masking.
+     */
+    isConfiguredForMasking(): boolean;
+    /**
+     * In the case of a single field control, determines whether the current user is able to unmask the control's field.
+     * In the case of a multiple field control, determines whether the current user is able to unmask all of the control's fields.
+     * @throws {NotConfiguredForMaskingError}
+     * @returns Whether the current user is able to unmask the control.
+     */
+    isAuthorizedToUnmask(): boolean;
+}
+export interface UnmaskAuthError {
+    name: "UnmaskAuthError";
+    message: string;
+    fields: string[];
+}
+export interface NotConfiguredForMaskingError {
+    name: "NotConfiguredForMaskingError";
+    message: string;
+    fields: string[];
+}

package/control/masking-api.js

@@ -0,0 +1,3 @@
+export const MASKED_FIELD_CHAR = "\u2022";
+export const MASKED_FIELD_PLACEHOLDER = MASKED_FIELD_CHAR.repeat(9);
+export const MASKED_FIELD_ISO_CODE_PLACEHOLDER = MASKED_FIELD_CHAR.repeat(3);

package/control/page.d.ts

@@ -1,6 +1,6 @@
 import { Type } from "@angular/core";
 import { ActionState } from "../object/object-api";
-export declare const enum PageModeEvent {
+export declare enum PageModeEvent {
     CREATE = "create",
     EDIT = "edit",
     OPEN = "open",

package/control/page.js

@@ -1 +1,8 @@
-export {};
+export var PageModeEvent;
+(function (PageModeEvent) {
+    PageModeEvent["CREATE"] = "create";
+    PageModeEvent["EDIT"] = "edit";
+    PageModeEvent["OPEN"] = "open";
+    PageModeEvent["INSPECT"] = "inspect";
+    PageModeEvent["SUMMARY"] = "summary";
+})(PageModeEvent || (PageModeEvent = {}));

package/control/restrictions.d.ts

@@ -1,5 +1,11 @@
 import { FieldType, NumberDataType } from "./data-types";
-export interface RequirableRestriction {
+export interface MaskedFieldRestriction {
+    masked?: {
+        currentUserIsAuthorizedToReveal: boolean;
+        revealUrl?: string;
+    };
+}
+export interface RequirableRestriction extends MaskedFieldRestriction {
     required: boolean;
 }
 export interface FieldRestrictions extends RequirableRestriction {

package/current-user/currentUser-api.d.ts

@@ -17,6 +17,14 @@ export interface IdentitySummary {
     state?: IdentityState;
     type: IdentityType;
 }
+export interface IdentityFlatMembership {
+    id: string;
+    name: string;
+    providerId: string;
+    implicit: boolean;
+    parentsIds?: string[];
+    topLevel: boolean;
+}
 export interface UserSummary extends IdentitySummary {
     readonly type: IdentityType.User;
 }
@@ -50,9 +58,10 @@ export interface CurrentUserApi {
     /**
      * @method
      * @description Gets the list of groups to which the current user belongs.
+     * @param limit Maximum number of groups to be returned. Default: 1000.
      * @returns A list of group details.
      */
-    getUserMemberships(): Promise<IdentitySummary[]>;
+    getUserMemberships(limit?: number): Promise<IdentityFlatMembership[]>;
     /**
      * @method
      * @description Verifies if the current user has administration features.

package/current-user/currentUser-api.js

@@ -1,3 +1,4 @@
+import { expectType } from "../../shared/util/helper-functions";
 export var IdentityState;
 (function (IdentityState) {
     IdentityState["Active"] = "active";
@@ -9,3 +10,4 @@ export var IdentityType;
     IdentityType["User"] = "user";
     IdentityType["Group"] = "group";
 })(IdentityType || (IdentityType = {}));
+expectType(true);

package/elements/bindings.d.ts

@@ -0,0 +1,25 @@
+import { PageModel } from "../page-model";
+import { Control } from "../control";
+/**
+ * @category Properties
+ */
+export interface SASInputBindings<T = any> {
+    id?: string;
+    readOnly?: boolean;
+    placeholder?: string;
+    autocomplete?: string;
+    isDisabled?: boolean;
+    model?: T;
+    inputFocus?: (event: FocusEvent) => void;
+    inputBlur?: (event: FocusEvent) => void;
+    modelChanged?: (modelValue: T) => void;
+}
+/**
+ * Page Controls require a valid {@link Control | childNode} and {@link PageModel | pageModel}.</strong>
+ *
+ * @category Properties
+ **/
+export interface PageControlBindings {
+    childNode: Control;
+    pageModel: PageModel;
+}

package/elements/identity-select.d.ts

@@ -0,0 +1,274 @@
+import { SASInputBindings } from ".";
+import { IdentitySummary } from "../current-user";
+/**
+ * Properties for {@link SVICustomElement.IdentitySelect}.
+ *
+ * @category Properties
+ *
+ * @example HTML Example #1 - Provide a custom set of User/Group identities to display in dialog
+ * ```html
+ * <svi-identity-select
+ *   [model]="selectedIdentities"
+ *   [identities]="myIdentitiesList"
+ *   [selectionMode]="SelectionMode.UsersAndGroups"
+ *   [selfSelectBtn]="true"
+ *   [filter]="{ byGroups: ['alpha', 'bravo'] }"
+ *   (modelChanged)="onSelectionChange($event)"
+ * ></svi-identity-select>
+ * ```
+ *
+ *  @example HTML Example #2 - Retrieve a list of users from the identities service in dialog
+ * ```html
+ * <svi-identity-select
+ *   [model]="selectedIdentities"
+ *   [ariaLabel]="'Select Users'"
+ *   [selectionMode]="SelectionMode.Users"
+ *   [selfSelectBtn]="true"
+ *   (modelChanged)="onSelectionChange($event)"
+ * ></svi-identity-select>
+ * ```
+ *
+ * @example Create element via document.createElement:
+ * ```ts
+ * const identitySelect = document.createElement(SVICustomElement.IdentitySelect);
+ * identitySelect.identities = this.myIdentitiesList;
+ * identitySelect.ariaLabel = "My label";
+ * ```
+ */
+export interface IdentitySelectProperties extends SASInputBindings {
+    /** ARIA label for identifying the list. */
+    ariaLabel?: string;
+    /** The available users and groups to select from. If not provided, the identities are retrieved from the identities microservice. */
+    identities?: IIdentityOption[];
+    /** Does the input allow the selection of only a user, users, a group, groups, or both?  (default: {@link SelectionMode.UsersAndGroups}) */
+    selectionMode?: SelectionMode;
+    /** Determines whether the select current user button is displayed. (default: false) */
+    selfSelectBtn?: boolean;
+    /** Determines if the current user button is displayed above or to the left/right of the identity-select control. (default: false) */
+    inlineSelectCurrentUserBtn?: boolean;
+    /** The filtering options used when the available identities are retrieved from the identities microservice. (default: false) */
+    filter?: IIdentitySelectFilterOptions;
+    /**
+     * Only members of the given group will be valid and selectable. If inclusive if true,
+     * the group itself is treated as a valid selection.
+     *
+     * Accepts the group id as a string, or as part of configuration object.
+     */
+    limitSelectionToMembersOf?: string | ILimitSelectionToConfig;
+    /** Optional title that can be used to override the default dialog title. */
+    title?: string;
+}
+/**
+ * Properties for {@link SVICustomElement.IdentitySelectAction}.
+ *
+ * @category Properties
+ *
+ * @example HTML Example #1 - Select Users and Groups
+ * ```html
+ * <svi-identity-select-action
+ *   [model]="selectedIdentities"
+ *   [title]="'Multiple Users and Groups from Button'"
+ *   [hideLabel]="true"
+ *   (selectionDialogClose)="onDialogClose($event)"
+ *   (modelChanged)="onSelectionChange($event)"
+ * ></svi-identity-select-action>
+ * ```
+ *
+ * @example HTML Example #1 - Select Users Only
+ * ```html
+ * <svi-identity-select-action
+ *   [model]="selectedIdentities"
+ *   [title]="'Multiple Users from Button'"
+ *   [hideLabel]="true"
+ *   [selectionMode]="selectionMode.Users"
+ *   (selectionDialogClose)="onDialogClose($event)"
+ *   (modelChanged)="onSelectionChange($event)"
+ * ></svi-identity-select-action>
+ * ```
+ *
+ * @example Create element via document.createElement:
+ * ```ts
+ * const identityAvatar = document.createElement(SVICustomElement.IdentitySelectAction);
+ * identitySelect.title = this.title;
+ * identitySelect.actionMode = this.actionMode;
+ * ```
+ */
+export interface IdentitySelectActionProperties {
+    /** Determines if the action is rendered as a Button or MenuItem (default: {@link ActionMode.Button}). */
+    actionMode?: ActionMode;
+    /** The tabIndex for the button (default: {@link TabIndex.Tabbable}). */
+    tabIndex?: string;
+    /** Optional title that can be used to override the default dialog title. */
+    title?: string;
+    /** Optional label that can be used to override the default button label.  */
+    label?: string;
+    /** Defines if the label will be hidden. (default: false). */
+    hideLabel?: boolean;
+    /** Label for the identity select dialog "ok" button. (default: "ok") */
+    okButtonLabel?: string;
+    /** Optional icon class that can be used to override the default button icon. */
+    iconClass?: string;
+    /** Disables the component's controls. (default: false) */
+    disabled?: boolean;
+    /** The available users and groups to select from. If not provided, the identities are retrieved from the identities microservice. */
+    identities?: IIdentityOption[];
+    /** Does the input allow the selection of only a user, users, a group, groups, or both? (default: {@link SelectionMode.UsersAndGroups}) */
+    selectionMode?: SelectionMode;
+    /** Pre-select Identities. */
+    selectedIdentities?: IIdentityOption[];
+    /** The filtering options used when the available identities are retrieved from the identities microservice. */
+    filter?: IIdentitySelectFilterOptions;
+    /**
+     * Only members of the given group will be valid and selectable. If inclusive if true,
+     * the group itself is treated as a valid selection.
+     *
+     * Accepts the group id as a string, or as part of configuration object.
+     */
+    limitSelectionToMembersOf?: string | ILimitSelectionToConfig;
+    /** Emits the selected identities when the dialog's ok button is clicked. */
+    selectionDialogClose?: (event: CustomEvent) => void;
+}
+/**
+ * Properties for {@link SVICustomElement.Avatar}.
+ *
+ * @category Properties
+ *
+ * @example HTML Example
+ * ```html
+ * <svi-avatar
+ *   [identity]="identity"
+ *   [size]="SizeType.XLarge"
+ *   [isIcon]="true"
+ *   [isButton]="true"
+ * ></svi-avatar>
+ * ```
+ *
+ * @example Create element via document.createElement:
+ * ```ts
+ * const identityAvatar = document.createElement(SVICustomElement.IdentityAvatar);
+ * identitySelect.identity = this.identity;
+ * identitySelect.size = SizeType.XLarge;
+ * identitySelect.isButton = true;
+ * ```
+ */
+export interface AvatarProperties {
+    /** The identity of the user, including name, userID, user type, and any tooltips. (required) */
+    identity: AvatarData;
+    /** Specifies the size styling the avatar should use. */
+    size?: SizeType;
+    /** Specifies if the avatar is a clickable button. */
+    isButton?: boolean;
+    /** The user's photo, if provided. */
+    imgSrcUrl?: string;
+    /** Specifies whether the avatar displays an icon (user or group) or a non-icon (initial or image). */
+    isIcon?: boolean;
+}
+/** @category Identities Types */
+export declare enum SizeType {
+    Small = "small",
+    Medium = "medium",
+    XLarge = "x-large"
+}
+/** @category Identities Types */
+export declare enum TabIndex {
+    Tabbable = "0",
+    NotTabbable = "-1"
+}
+/** @category Identities Types */
+export declare enum IdentityType {
+    User = "user",
+    Group = "group"
+}
+/** @category Identities Types */
+export declare enum IdentityState {
+    Active = "active",
+    Inactive = "inactive",
+    Locked = "locked"
+}
+/** @category Identities Types */
+export interface GroupSummary extends IdentitySummary {
+    /** The value of "group" */
+    readonly type: IdentityType.Group;
+}
+/** @category Identities Types */
+export interface UserSummary extends IdentitySummary {
+    /** The value of "user" */
+    readonly type: IdentityType.User;
+}
+/** @category Identities Types */
+export interface AvatarData {
+    /** The name of the avatar file */
+    name?: string;
+    /** The content-type of the avatar file. */
+    type?: string;
+    /** Describes whether or not the avatar file for this identity is a default image. */
+    default?: boolean;
+    /** The uri location of the avatar file only if stored externally. */
+    uri?: string;
+    /** Timestamp of avatar data creation */
+    creationTimeStamp?: Date;
+    /** Timestamp of last avatar data modification */
+    modifiedTimeStamp?: Date;
+}
+/** @category Identities Types */
+export declare enum ActionMode {
+    Button = "button",
+    MenuItem = "menuItem"
+}
+/** @category Identities Types */
+export declare enum SelectionMode {
+    User = "user",
+    Group = "group",
+    Users = "users",
+    Groups = "groups",
+    UserOrGroup = "userOrGroup",
+    UsersAndGroups = "usersAndGroups"
+}
+/** @category Identities Types */
+export type IdentitySelection = Array<{
+    id: string;
+    type: IdentityType;
+}>;
+/** @category Identities Types */
+export interface IIdentitySelectDialogData {
+    identities?: IIdentityOption[];
+    selection?: IdentitySelection;
+    selectionMode: SelectionMode;
+    filter?: IIdentitySelectFilterOptions;
+    limitSelectionToMembersOf?: string | ILimitSelectionToConfig;
+    title?: string;
+    okButtonLabel?: string;
+    showSelectCurrentUserButton?: boolean;
+}
+/** @category Identities Types */
+export interface IIdentityOption {
+    label?: string;
+    icon?: string;
+}
+/** @category Identities Types */
+export declare const enum IdentityTypeIcon {
+    User = "userIcon",
+    Group = "userGroupIcon",
+    UserAndGroup = "userGroupLimitIcon"
+}
+/** @category Identities Types */
+export interface IIdentitySelectFilterOptions {
+    byGroups: string[];
+    includeNestedMembers?: boolean;
+    includeFilteredGroups?: boolean;
+    term?: string;
+    start?: number;
+    limit?: number;
+    cache?: number;
+}
+/** @category Identities Types */
+export interface IFilterGroup {
+    id: string;
+    name?: string;
+    members: IdentitySummary[];
+}
+/** @category Identities Types */
+export interface ILimitSelectionToConfig {
+    id: string;
+    inclusive?: boolean;
+}