@genesislcap/pbc-auth-ui 1.0.3

package/README.md

@@ -0,0 +1,47 @@
+# Web Client
+
+## Frontend stack
+
+Genesis components are standards-based Web Components, making them compatible with almost any modern web framework.
+Our state-of-the-art design system and component set is built on top of
+[Microsoft FAST](https://www.fast.design/docs/introduction/).
+
+# Development
+
+1. Install dependencies:
+
+```shell
+npm run bootstrap
+```
+
+2. Start Web development server in watch mode:
+
+```shell
+npm run dev
+```
+
+3. Build for production:
+
+```shell
+npm run build
+```
+
+Preview production build:
+
+```shell
+npm run serve
+```
+
+## Clean
+
+Remove distribution and node_modules directories:
+
+```shell
+npm run clean
+```
+
+Baseline task combines `clean` and `bootstrap` tasks into a single command:
+
+```shell
+npm run baseline
+```

package/dist/dts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './user-admin/users';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/dts/index.federated.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.federated.d.ts.map

package/dist/dts/index.federated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.federated.d.ts","sourceRoot":"","sources":["../../src/index.federated.ts"],"names":[],"mappings":""}

package/dist/dts/types.d.ts

@@ -0,0 +1,3 @@
+export declare const HostENV: import("@microsoft/fast-foundation").InterfaceSymbol<string>;
+export declare const HostURL: import("@microsoft/fast-foundation").InterfaceSymbol<string>;
+//# sourceMappingURL=types.d.ts.map

package/dist/dts/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,8DAA+B,CAAC;AAEpD,eAAO,MAAM,OAAO,8DAA+B,CAAC"}

package/dist/dts/user-admin/users.d.ts

@@ -0,0 +1,568 @@
+import { GridProRendererTypes } from '@genesislcap/foundation-zero-grid-pro';
+import { FASTElement } from '@microsoft/fast-element';
+import { DatasourceConfiguration } from '@genesislcap/foundation-entity-management';
+/**
+ * Defines the default columns which are present on the user management component
+ *
+ * @remarks
+ *
+ * This is exported so you can override and mix-in custom columns along with the default
+ * @public
+ */
+export declare const UsersColumnConfig: ({
+    field: string;
+    headerName: string;
+    enableCellChangeFlash: boolean;
+    enableRowGroup: boolean;
+    enablePivot: boolean;
+    enableValue: boolean;
+} | {
+    field: string;
+    headerName: string;
+    valueFormatter: ({ value }: {
+        value: any;
+    }) => string;
+    enableCellChangeFlash: boolean;
+    enableRowGroup: boolean;
+    enablePivot: boolean;
+    enableValue: boolean;
+})[];
+declare const Users_base: (new (...args: any[]) => {
+    "__#1@#_container": import("@genesislcap/foundation-utils").FoundationLayoutContainer | import("@genesislcap/foundation-utils").LayoutCacheContainer | import("@genesislcap/foundation-utils").DOMContainer;
+    "__#1@#_latestTokenCode": string;
+    "__#1@#_hasFirstLoaded": boolean;
+    "__#1@#_cleanupTimeout": NodeJS.Timeout;
+    "__#1@#_shouldForceLifecycle": boolean;
+    cloneNode(deep?: boolean): Node;
+    deepClone(): Node;
+    readonly shouldRunDisconnect: boolean;
+    readonly shouldRunConnect: boolean;
+    "__#1@#_blockLifecycleDueToTokenChange"(lifecycleType: "connect" | "disconnect" | "reconnect"): boolean;
+    "__#1@#_tryFindContainingLayout"(e: Element): import("@genesislcap/foundation-utils").FoundationLayoutContainer | import("@genesislcap/foundation-utils").LayoutCacheContainer | import("@genesislcap/foundation-utils").DOMContainer;
+    connectedCallback(): void;
+    readonly $fastController: import("@microsoft/fast-element").Controller;
+    $emit(type: string, detail?: any, options?: Omit<CustomEventInit<any>, "detail">): boolean | void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string, newValue: string): void;
+    accessKey: string;
+    readonly accessKeyLabel: string;
+    autocapitalize: string;
+    dir: string;
+    draggable: boolean;
+    hidden: boolean;
+    inert: boolean;
+    innerText: string;
+    lang: string;
+    readonly offsetHeight: number;
+    readonly offsetLeft: number;
+    readonly offsetParent: Element;
+    readonly offsetTop: number;
+    readonly offsetWidth: number;
+    outerText: string;
+    spellcheck: boolean;
+    title: string;
+    translate: boolean;
+    attachInternals(): ElementInternals;
+    click(): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K_1 extends keyof HTMLElementEventMap>(type: K_1, listener: (this: HTMLElement, ev: HTMLElementEventMap[K_1]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    readonly attributes: NamedNodeMap;
+    readonly classList: DOMTokenList;
+    className: string;
+    readonly clientHeight: number;
+    readonly clientLeft: number;
+    readonly clientTop: number;
+    readonly clientWidth: number;
+    /**
+     * entityID used to control the definition of an optional entity column which is created with the {@link Users.entityColumn} function.
+     * @internal
+     */
+    id: string;
+    readonly localName: string;
+    readonly namespaceURI: string;
+    onfullscreenchange: (this: Element, ev: Event) => any;
+    onfullscreenerror: (this: Element, ev: Event) => any;
+    outerHTML: string;
+    readonly ownerDocument: Document;
+    readonly part: DOMTokenList;
+    readonly prefix: string;
+    readonly scrollHeight: number;
+    scrollLeft: number;
+    scrollTop: number;
+    readonly scrollWidth: number;
+    readonly shadowRoot: ShadowRoot;
+    slot: string;
+    readonly tagName: string;
+    attachShadow(init: ShadowRootInit): ShadowRoot;
+    closest<K_2 extends keyof HTMLElementTagNameMap>(selector: K_2): HTMLElementTagNameMap[K_2];
+    closest<K_3 extends keyof SVGElementTagNameMap>(selector: K_3): SVGElementTagNameMap[K_3];
+    closest<E extends Element = Element>(selectors: string): E;
+    getAttribute(qualifiedName: string): string;
+    getAttributeNS(namespace: string, localName: string): string;
+    getAttributeNames(): string[];
+    getAttributeNode(qualifiedName: string): Attr;
+    getAttributeNodeNS(namespace: string, localName: string): Attr;
+    getBoundingClientRect(): DOMRect;
+    getClientRects(): DOMRectList;
+    getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
+    getElementsByTagName<K_4 extends keyof HTMLElementTagNameMap>(qualifiedName: K_4): HTMLCollectionOf<HTMLElementTagNameMap[K_4]>;
+    getElementsByTagName<K_5 extends keyof SVGElementTagNameMap>(qualifiedName: K_5): HTMLCollectionOf<SVGElementTagNameMap[K_5]>;
+    getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
+    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
+    getElementsByTagNameNS(namespace: string, localName: string): HTMLCollectionOf<Element>;
+    hasAttribute(qualifiedName: string): boolean;
+    hasAttributeNS(namespace: string, localName: string): boolean;
+    hasAttributes(): boolean;
+    hasPointerCapture(pointerId: number): boolean;
+    insertAdjacentElement(where: InsertPosition, element: Element): Element;
+    insertAdjacentHTML(position: InsertPosition, text: string): void;
+    insertAdjacentText(where: InsertPosition, data: string): void;
+    matches(selectors: string): boolean;
+    releasePointerCapture(pointerId: number): void;
+    removeAttribute(qualifiedName: string): void;
+    removeAttributeNS(namespace: string, localName: string): void;
+    removeAttributeNode(attr: Attr): Attr;
+    requestFullscreen(options?: FullscreenOptions): Promise<void>;
+    requestPointerLock(): void;
+    scroll(options?: ScrollToOptions): void;
+    scroll(x: number, y: number): void;
+    scrollBy(options?: ScrollToOptions): void;
+    scrollBy(x: number, y: number): void;
+    scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollTo(x: number, y: number): void;
+    setAttribute(qualifiedName: string, value: string): void;
+    setAttributeNS(namespace: string, qualifiedName: string, value: string): void;
+    setAttributeNode(attr: Attr): Attr;
+    setAttributeNodeNS(attr: Attr): Attr;
+    setPointerCapture(pointerId: number): void;
+    toggleAttribute(qualifiedName: string, force?: boolean): boolean;
+    webkitMatchesSelector(selectors: string): boolean;
+    readonly baseURI: string;
+    readonly childNodes: NodeListOf<ChildNode>;
+    readonly firstChild: ChildNode;
+    readonly isConnected: boolean;
+    readonly lastChild: ChildNode;
+    readonly nextSibling: ChildNode;
+    readonly nodeName: string;
+    readonly nodeType: number;
+    nodeValue: string;
+    readonly parentElement: HTMLElement;
+    readonly parentNode: ParentNode;
+    readonly previousSibling: ChildNode;
+    textContent: string;
+    appendChild<T_1 extends Node>(node: T_1): T_1;
+    compareDocumentPosition(other: Node): number;
+    contains(other: Node): boolean;
+    getRootNode(options?: GetRootNodeOptions): Node;
+    hasChildNodes(): boolean;
+    insertBefore<T_2 extends Node>(node: T_2, child: Node): T_2;
+    isDefaultNamespace(namespace: string): boolean;
+    isEqualNode(otherNode: Node): boolean;
+    isSameNode(otherNode: Node): boolean;
+    lookupNamespaceURI(prefix: string): string;
+    lookupPrefix(namespace: string): string;
+    normalize(): void;
+    removeChild<T_3 extends Node>(child: T_3): T_3;
+    replaceChild<T_4 extends Node>(node: Node, child: T_4): T_4;
+    readonly ATTRIBUTE_NODE: number;
+    readonly CDATA_SECTION_NODE: number;
+    readonly COMMENT_NODE: number;
+    readonly DOCUMENT_FRAGMENT_NODE: number;
+    readonly DOCUMENT_NODE: number;
+    readonly DOCUMENT_POSITION_CONTAINED_BY: number;
+    readonly DOCUMENT_POSITION_CONTAINS: number;
+    readonly DOCUMENT_POSITION_DISCONNECTED: number;
+    readonly DOCUMENT_POSITION_FOLLOWING: number;
+    readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
+    readonly DOCUMENT_POSITION_PRECEDING: number;
+    readonly DOCUMENT_TYPE_NODE: number;
+    readonly ELEMENT_NODE: number;
+    readonly ENTITY_NODE: number;
+    readonly ENTITY_REFERENCE_NODE: number;
+    readonly NOTATION_NODE: number;
+    readonly PROCESSING_INSTRUCTION_NODE: number;
+    readonly TEXT_NODE: number;
+    dispatchEvent(event: Event): boolean;
+    ariaAtomic: string;
+    ariaAutoComplete: string;
+    ariaBusy: string;
+    ariaChecked: string;
+    ariaColCount: string;
+    ariaColIndex: string;
+    ariaColIndexText: string;
+    ariaColSpan: string;
+    ariaCurrent: string;
+    ariaDisabled: string;
+    ariaExpanded: string;
+    ariaHasPopup: string;
+    ariaHidden: string;
+    ariaInvalid: string;
+    ariaKeyShortcuts: string;
+    ariaLabel: string;
+    ariaLevel: string;
+    ariaLive: string;
+    ariaModal: string;
+    ariaMultiLine: string;
+    ariaMultiSelectable: string;
+    ariaOrientation: string;
+    ariaPlaceholder: string;
+    ariaPosInSet: string;
+    ariaPressed: string;
+    ariaReadOnly: string;
+    ariaRequired: string;
+    ariaRoleDescription: string;
+    ariaRowCount: string;
+    ariaRowIndex: string;
+    ariaRowIndexText: string;
+    ariaRowSpan: string;
+    ariaSelected: string;
+    ariaSetSize: string;
+    ariaSort: string;
+    ariaValueMax: string;
+    ariaValueMin: string;
+    ariaValueNow: string;
+    ariaValueText: string;
+    role: string;
+    animate(keyframes: PropertyIndexedKeyframes | Keyframe[], options?: number | KeyframeAnimationOptions): Animation;
+    getAnimations(options?: GetAnimationsOptions): Animation[];
+    after(...nodes: (string | Node)[]): void;
+    before(...nodes: (string | Node)[]): void;
+    remove(): void;
+    replaceWith(...nodes: (string | Node)[]): void;
+    innerHTML: string;
+    readonly nextElementSibling: Element;
+    readonly previousElementSibling: Element;
+    readonly childElementCount: number;
+    readonly children: HTMLCollection;
+    readonly firstElementChild: Element;
+    readonly lastElementChild: Element;
+    append(...nodes: (string | Node)[]): void;
+    prepend(...nodes: (string | Node)[]): void;
+    querySelector<K_6 extends keyof HTMLElementTagNameMap>(selectors: K_6): HTMLElementTagNameMap[K_6];
+    querySelector<K_7 extends keyof SVGElementTagNameMap>(selectors: K_7): SVGElementTagNameMap[K_7];
+    querySelector<E_1 extends Element = Element>(selectors: string): E_1;
+    querySelectorAll<K_8 extends keyof HTMLElementTagNameMap>(selectors: K_8): NodeListOf<HTMLElementTagNameMap[K_8]>;
+    querySelectorAll<K_9 extends keyof SVGElementTagNameMap>(selectors: K_9): NodeListOf<SVGElementTagNameMap[K_9]>;
+    querySelectorAll<E_2 extends Element = Element>(selectors: string): NodeListOf<E_2>;
+    replaceChildren(...nodes: (string | Node)[]): void;
+    readonly assignedSlot: HTMLSlotElement;
+    oncopy: (this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any;
+    oncut: (this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any;
+    onpaste: (this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any;
+    readonly style: CSSStyleDeclaration;
+    contentEditable: string;
+    enterKeyHint: string;
+    inputMode: string;
+    readonly isContentEditable: boolean;
+    onabort: (this: GlobalEventHandlers, ev: UIEvent) => any;
+    onanimationcancel: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onanimationend: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onanimationiteration: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onanimationstart: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onauxclick: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onbeforeinput: (this: GlobalEventHandlers, ev: InputEvent) => any;
+    onblur: (this: GlobalEventHandlers, ev: FocusEvent) => any;
+    oncancel: (this: GlobalEventHandlers, ev: Event) => any;
+    oncanplay: (this: GlobalEventHandlers, ev: Event) => any;
+    oncanplaythrough: (this: GlobalEventHandlers, ev: Event) => any;
+    onchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onclick: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onclose: (this: GlobalEventHandlers, ev: Event) => any;
+    oncontextmenu: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    oncuechange: (this: GlobalEventHandlers, ev: Event) => any;
+    ondblclick: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    ondrag: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragend: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragenter: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragleave: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragover: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragstart: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondrop: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondurationchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onemptied: (this: GlobalEventHandlers, ev: Event) => any;
+    onended: (this: GlobalEventHandlers, ev: Event) => any;
+    onerror: OnErrorEventHandlerNonNull;
+    onfocus: (this: GlobalEventHandlers, ev: FocusEvent) => any;
+    onformdata: (this: GlobalEventHandlers, ev: FormDataEvent) => any;
+    ongotpointercapture: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    oninput: (this: GlobalEventHandlers, ev: Event) => any;
+    oninvalid: (this: GlobalEventHandlers, ev: Event) => any;
+    onkeydown: (this: GlobalEventHandlers, ev: KeyboardEvent) => any;
+    onkeypress: (this: GlobalEventHandlers, ev: KeyboardEvent) => any;
+    onkeyup: (this: GlobalEventHandlers, ev: KeyboardEvent) => any;
+    onload: (this: GlobalEventHandlers, ev: Event) => any;
+    onloadeddata: (this: GlobalEventHandlers, ev: Event) => any;
+    onloadedmetadata: (this: GlobalEventHandlers, ev: Event) => any;
+    onloadstart: (this: GlobalEventHandlers, ev: Event) => any;
+    onlostpointercapture: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onmousedown: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseenter: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseleave: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmousemove: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseout: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseover: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseup: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onpause: (this: GlobalEventHandlers, ev: Event) => any;
+    onplay: (this: GlobalEventHandlers, ev: Event) => any;
+    onplaying: (this: GlobalEventHandlers, ev: Event) => any;
+    onpointercancel: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerdown: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerenter: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerleave: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointermove: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerout: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerover: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerup: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onprogress: (this: GlobalEventHandlers, ev: ProgressEvent<EventTarget>) => any;
+    onratechange: (this: GlobalEventHandlers, ev: Event) => any;
+    onreset: (this: GlobalEventHandlers, ev: Event) => any;
+    onresize: (this: GlobalEventHandlers, ev: UIEvent) => any;
+    onscroll: (this: GlobalEventHandlers, ev: Event) => any;
+    onsecuritypolicyviolation: (this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any;
+    onseeked: (this: GlobalEventHandlers, ev: Event) => any;
+    onseeking: (this: GlobalEventHandlers, ev: Event) => any;
+    onselect: (this: GlobalEventHandlers, ev: Event) => any;
+    onselectionchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onselectstart: (this: GlobalEventHandlers, ev: Event) => any;
+    onslotchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onstalled: (this: GlobalEventHandlers, ev: Event) => any;
+    onsubmit: (this: GlobalEventHandlers, ev: SubmitEvent) => any;
+    onsuspend: (this: GlobalEventHandlers, ev: Event) => any;
+    ontimeupdate: (this: GlobalEventHandlers, ev: Event) => any;
+    ontoggle: (this: GlobalEventHandlers, ev: Event) => any;
+    ontouchcancel?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontouchend?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontouchmove?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontouchstart?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontransitioncancel: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    ontransitionend: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    ontransitionrun: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    ontransitionstart: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    onvolumechange: (this: GlobalEventHandlers, ev: Event) => any;
+    onwaiting: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkitanimationend: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkitanimationiteration: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkitanimationstart: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkittransitionend: (this: GlobalEventHandlers, ev: Event) => any;
+    onwheel: (this: GlobalEventHandlers, ev: WheelEvent) => any;
+    autofocus: boolean;
+    readonly dataset: DOMStringMap;
+    nonce?: string;
+    tabIndex: number;
+    blur(): void;
+    focus(options?: FocusOptions): void;
+}) & (new () => HTMLElement & FASTElement) & {
+    from<TBase extends {
+        new (): HTMLElement;
+        prototype: HTMLElement;
+    }>(BaseType: TBase): new () => InstanceType<TBase> & FASTElement;
+    define<TType extends Function>(type: TType, nameOrDef?: string | import("@microsoft/fast-element").PartialFASTElementDefinition): TType;
+};
+/**
+ * Main class which defines the user management functionality
+ *
+ * @remarks
+ *
+ * Under the hood the user-management is the entity-management micro-frontend configured for use
+ * with the `ALL_USERS` resource.
+ *
+ * @public
+ *
+ * @example
+ *
+ * With no customisation required the user management micro-frontend can simply be dropped into the
+ * template as shown. However, it is advised to wrap it in an error boundary component.
+ * ```javascript
+ * <user-management></user-management>
+ * ```
+ * With this default example above the columns will be the {@link UsersColumnConfig} as well as the
+ * entity and status columns. The entity and status
+ * columns are always added regardless of the other columns which are configured.
+ *
+ * You can add in additional customisation options. For example you can define a custom column and
+ * then mix-in with the standard columns
+ * ```javascript
+ * import { Users, UsersColumnConfig, } from '@genesislcap/foundation-entity-management';
+ *
+ * const userColumns = [
+ *   {
+ *     field: 'ACCESS_TYPE',
+ *     headerName: 'Access Type',
+ *   },
+ * ];
+ *
+ * // Definition inside of the html template
+ * <user-management :columns=${() => [...UsersColumnConfig, ...userColumns]}></user-management>
+ * ```
+ */
+export declare class Users extends Users_base {
+    /**
+     * DI connect object which is used to interact with the backend.
+     *
+     * @remarks
+     *
+     * Requires {@link @genesislcap/foundation-comms#Connect | the connect class} to be registered with the
+     * DI container
+     * @internal
+     */
+    private connect;
+    /**
+     * Auth provider which is used to confirm authorisation of the user for their user management permissions
+     *
+     * @remarks
+     *
+     * Requires {@link @genesislcap/foundation-comms#Auth | the auth class} to be registered with the
+     * DI container
+     * @internal
+     */
+    private auth;
+    /**
+     * The configuration which is used when interacting with the resource on the backend
+     *
+     * @remarks
+     *
+     * Handles the configuration such as how many rows of entities to fetch at a time
+     * @internal
+     */
+    datasourceConfig: DatasourceConfiguration;
+    /**
+     * Configuring the resourceName from the entity-management, set to manage the users resource specifically
+     * @internal
+     */
+    resourceName: string;
+    /**
+     * This attribute controls whether and how the user manager stores the state of the columns when the user edits them. Defaulted to `entity_users_management`.
+     *
+     * @remarks
+     *
+     * Setting this value will set the entity manager to persist the column states through page refreshes etc. An example of what is stored is when the user resizes or reorders columns.
+     * This value must be unique for each table in your app otherwise the persisted data will be corrupted.
+     * There is an option on the grid for the user to reset the table to the default layout if they wish.
+     * @public
+     */
+    persistColumnStateKey: string;
+    /**
+     * Returns a configuration for an optional status column
+     *
+     * @returns Column configuration for an optional status column
+     * @internal
+     */
+    statusColumn(): {
+        headerName: string;
+        field: string;
+        minWidth: number;
+        width: number;
+        suppressSizeToFit: boolean;
+        cellRendererSelector: any;
+        enableCellChangeFlash: boolean;
+        enableRowGroup: boolean;
+        enablePivot: boolean;
+        enableValue: boolean;
+    };
+    /**
+     * Returns the config for an entity column if the entityID attribute is defined
+     *
+     * @returns Config for an entity column if the entityID is defined, else an empty array
+     * @internal
+     */
+    entityColumn(): {
+        headerName: string;
+        field: string;
+        enableCellChangeFlash: boolean;
+        enableRowGroup: boolean;
+        enablePivot: boolean;
+        enableValue: boolean;
+    }[];
+    /**
+     * Column definition, default to the UsersColumnConfig
+     */
+    columns: any;
+    additionalCreateFields: any;
+    additionalUpdateFields: any;
+    allAccessType: boolean;
+    private entityIdValue;
+    /**
+     * String which contains event if we have permission to insert user of empty string if not
+     */
+    createEvent: string;
+    /**
+     * String which contains event if we have permission to delete user of empty string if not
+     */
+    deleteEvent: string;
+    /**
+     * String which contains event if we have permission to update user of empty string if not
+     */
+    updateEvent: string;
+    /**
+     * entityID used to control the definition of an optional entity column which is created with the {@link Users.entityColumn} function.
+     * @internal
+     */
+    entityID: string;
+    /**
+     * entityID used to display label from the selector of entityID {@link Users.entityColumn} function.
+     * @internal
+     */
+    entityLabelKey: string;
+    /**
+     * entityID used to control the definition of an optional entity column which is created with the {@link Users.entityColumn} function.
+     * @internal
+     */
+    entityLabel: string;
+    /**
+     * Definition of the `DATASERVER` query which is used when managing Counterpartys
+     * @internal
+     */
+    availableEntitiesEndpoint: string;
+    /**
+     * Constructor will set the {@link Users.createEvent} {@link Users.deleteEvent} {@link Users.updateEvent} to match the permissions set from the server
+     */
+    constructor();
+    connectedCallback(): Promise<void>;
+    deepClone(): Node;
+    /**
+     * Used as the callback function in {@link Users.statusColumn}
+     * @internal
+     */
+    statusRendererSelector(params: any): {
+        component: GridProRendererTypes;
+        params: {
+            actionClick: () => Promise<void>;
+            actionName: string;
+            appearance: string;
+        };
+    };
+    /**
+     * Changes the status of an entity
+     *
+     * @remarks
+     *
+     * The action which is run on the status button from {@link Users.statusRendererSelector}
+     *
+     * @internal
+     */
+    changeStatus(params: any): Promise<void>;
+    /**
+     * @internal
+     */
+    readUserData(user: any): Promise<{
+        USER_PROFILES: any[];
+        ADDRESS_LINE_1: any;
+        ADDRESS_LINE_2: any;
+        ADDRESS_LINE_3: any;
+        ADDRESS_LINE_4: any;
+        ACCESS_TYPE: string;
+    } | {
+        USER_PROFILES: any[];
+        ADDRESS_LINE_1: any;
+        ADDRESS_LINE_2: any;
+        ADDRESS_LINE_3: any;
+        ADDRESS_LINE_4: any;
+        ACCESS_TYPE?: undefined;
+    }>;
+}
+export {};
+//# sourceMappingURL=users.d.ts.map

package/dist/dts/user-admin/users.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../../src/user-admin/users.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAA4B,WAAW,EAAc,MAAM,yBAAyB,CAAC;AAC5F,OAAO,EAAE,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AAWpF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;IAoC7B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkKA;;;OAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAnKL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBASa,KAAM,SAAQ,UAA2B;IACpD;;;;;;;;OAQG;IACM,OAAO,CAAC,OAAO,CAAU;IAElC;;;;;;;;OAQG;IACG,OAAO,CAAC,IAAI,CAAO;IAEzB;;;;;;;OAOG;IACS,gBAAgB,EAAE,uBAAuB,CAAC;IAEtD;;;OAGG;IACG,YAAY,SAAe;IAEjC;;;;;;;;;OASG;IAC8C,qBAAqB,EAAE,MAAM,CAClD;IAE5B;;;;;OAKG;IACI,YAAY;;;;;;;;;;;;IAYnB;;;;;OAKG;IACI,YAAY;;;;;;;;IAYnB;;OAEG;IACS,OAAO,EAAE,GAAG,CAAqB;IAEjC,sBAAsB,EAAE,GAAG,CAAM;IACjC,sBAAsB,EAAE,GAAG,CAAM;IAEjC,aAAa,EAAE,OAAO,CAAC;IACnC,OAAO,CAAC,aAAa,CAAS;IAE9B;;OAEG;IACS,WAAW,EAAE,MAAM,CAAC;IAEhC;;OAEG;IACS,WAAW,EAAE,MAAM,CAAC;IAEhC;;OAEG;IACS,WAAW,EAAE,MAAM,CAAC;IAEhC;;;OAGG;IACG,QAAQ,EAAE,MAAM,CAAqB;IAE3C;;;OAGG;IACG,cAAc,EAAE,MAAM,CAAU;IAEtC;;;OAGG;IACG,WAAW,EAAE,MAAM,CAAkB;IAE3C;;;OAGG;IACG,yBAAyB,EAAE,MAAM,CAAuB;IAE9D;;OAEG;;IAaG,iBAAiB;IAcd,SAAS,IAAI,IAAI;IAc1B;;;OAGG;IACH,sBAAsB,CAAC,MAAM,KAAA;;;;;;;;IAW7B;;;;;;;;OAQG;IACG,YAAY,CAAC,MAAM,KAAA;IAoCzB;;OAEG;IACG,YAAY,CAAC,IAAI,KAAA;;;;;;;;;;;;;;;CAwBxB"}

package/dist/dts/user-admin/users.template.d.ts

@@ -0,0 +1,3 @@
+import type { ViewTemplate } from '@microsoft/fast-element';
+export declare const UsersTemplate: ViewTemplate;
+//# sourceMappingURL=users.template.d.ts.map

package/dist/dts/user-admin/users.template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.template.d.ts","sourceRoot":"","sources":["../../../src/user-admin/users.template.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAqF5D,eAAO,MAAM,aAAa,EAAE,YAmC3B,CAAC"}

package/dist/dts/utils/formatting.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Format the error as a string with a different format depending on whether
+ * `err` has a `FIELD` property or not
+ * @public
+ */
+export declare const getErrorFormat: (err: any) => string;
+//# sourceMappingURL=formatting.d.ts.map

package/dist/dts/utils/formatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatting.d.ts","sourceRoot":"","sources":["../../../src/utils/formatting.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,cAAc,sBAAsE,CAAC"}

package/dist/dts/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './formatting';
+export * from './logger';
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC"}

package/dist/dts/utils/logger.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @public
+ */
+export declare const logger: import("@genesislcap/foundation-logger").Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/dts/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/utils/logger.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,MAAM,iDAA6B,CAAC"}

package/dist/esm/index.federated.js

@@ -0,0 +1 @@
+import('./index');

package/dist/esm/index.js

@@ -0,0 +1 @@
+export * from './user-admin/users';

package/dist/esm/types.js

@@ -0,0 +1,3 @@
+import { DI } from '@microsoft/fast-foundation';
+export const HostENV = DI.createInterface();
+export const HostURL = DI.createInterface();

package/dist/esm/user-admin/users.js

@@ -0,0 +1,313 @@
+import { __awaiter, __decorate } from "tslib";
+import { Auth, Connect } from '@genesislcap/foundation-comms';
+import { showNotification } from '@genesislcap/foundation-notifications';
+import { LifecycleMixin } from '@genesislcap/foundation-utils';
+import { GridProRendererTypes } from '@genesislcap/foundation-zero-grid-pro';
+import { attr, css, customElement, FASTElement, observable } from '@microsoft/fast-element';
+import { getErrorFormat, logger } from '../utils';
+import { UsersTemplate } from './users.template';
+const defaultColumnConfig = {
+    enableCellChangeFlash: true,
+    enableRowGroup: false,
+    enablePivot: true,
+    enableValue: true,
+};
+/**
+ * Defines the default columns which are present on the user management component
+ *
+ * @remarks
+ *
+ * This is exported so you can override and mix-in custom columns along with the default
+ * @public
+ */
+export const UsersColumnConfig = [
+    Object.assign(Object.assign({}, defaultColumnConfig), { field: 'USER_NAME', headerName: 'Username' }),
+    Object.assign(Object.assign({}, defaultColumnConfig), { field: 'FIRST_NAME', headerName: 'First Name' }),
+    Object.assign(Object.assign({}, defaultColumnConfig), { field: 'LAST_NAME', headerName: 'Last Name' }),
+    Object.assign(Object.assign({}, defaultColumnConfig), { field: 'EMAIL_ADDRESS', headerName: 'Email' }),
+    Object.assign(Object.assign({}, defaultColumnConfig), { field: 'LAST_LOGIN', headerName: 'Last Login', valueFormatter: ({ value }) => value
+            ? new Intl.DateTimeFormat('default', {
+                year: 'numeric',
+                month: 'numeric',
+                day: 'numeric',
+                hour: 'numeric',
+                minute: 'numeric',
+            }).format(value)
+            : '' }),
+];
+/**
+ * Main class which defines the user management functionality
+ *
+ * @remarks
+ *
+ * Under the hood the user-management is the entity-management micro-frontend configured for use
+ * with the `ALL_USERS` resource.
+ *
+ * @public
+ *
+ * @example
+ *
+ * With no customisation required the user management micro-frontend can simply be dropped into the
+ * template as shown. However, it is advised to wrap it in an error boundary component.
+ * ```javascript
+ * <user-management></user-management>
+ * ```
+ * With this default example above the columns will be the {@link UsersColumnConfig} as well as the
+ * entity and status columns. The entity and status
+ * columns are always added regardless of the other columns which are configured.
+ *
+ * You can add in additional customisation options. For example you can define a custom column and
+ * then mix-in with the standard columns
+ * ```javascript
+ * import { Users, UsersColumnConfig, } from '@genesislcap/foundation-entity-management';
+ *
+ * const userColumns = [
+ *   {
+ *     field: 'ACCESS_TYPE',
+ *     headerName: 'Access Type',
+ *   },
+ * ];
+ *
+ * // Definition inside of the html template
+ * <user-management :columns=${() => [...UsersColumnConfig, ...userColumns]}></user-management>
+ * ```
+ */
+let Users = class Users extends LifecycleMixin(FASTElement) {
+    /**
+     * Returns a configuration for an optional status column
+     *
+     * @returns Column configuration for an optional status column
+     * @internal
+     */
+    statusColumn() {
+        return Object.assign(Object.assign({}, defaultColumnConfig), { headerName: 'Status', field: 'STATUS', minWidth: 135, width: 135, suppressSizeToFit: true, cellRendererSelector: this.statusRendererSelector.bind(this) });
+    }
+    /**
+     * Returns the config for an entity column if the entityID attribute is defined
+     *
+     * @returns Config for an entity column if the entityID is defined, else an empty array
+     * @internal
+     */
+    entityColumn() {
+        return this.entityID
+            ? [
+                Object.assign(Object.assign({}, defaultColumnConfig), { headerName: this.entityLabel, field: this.entityID }),
+            ]
+            : [];
+    }
+    /**
+     * Constructor will set the {@link Users.createEvent} {@link Users.deleteEvent} {@link Users.updateEvent} to match the permissions set from the server
+     */
+    constructor() {
+        super();
+        /**
+         * Configuring the resourceName from the entity-management, set to manage the users resource specifically
+         * @internal
+         */
+        this.resourceName = 'ALL_USERS';
+        /**
+         * This attribute controls whether and how the user manager stores the state of the columns when the user edits them. Defaulted to `entity_users_management`.
+         *
+         * @remarks
+         *
+         * Setting this value will set the entity manager to persist the column states through page refreshes etc. An example of what is stored is when the user resizes or reorders columns.
+         * This value must be unique for each table in your app otherwise the persisted data will be corrupted.
+         * There is an option on the grid for the user to reset the table to the default layout if they wish.
+         * @public
+         */
+        this.persistColumnStateKey = 'entity_users_management';
+        /**
+         * Column definition, default to the UsersColumnConfig
+         */
+        this.columns = UsersColumnConfig;
+        this.additionalCreateFields = [];
+        this.additionalUpdateFields = [];
+        /**
+         * entityID used to control the definition of an optional entity column which is created with the {@link Users.entityColumn} function.
+         * @internal
+         */
+        this.entityID = 'COUNTERPARTY_ID';
+        /**
+         * entityID used to display label from the selector of entityID {@link Users.entityColumn} function.
+         * @internal
+         */
+        this.entityLabelKey = 'NAME';
+        /**
+         * entityID used to control the definition of an optional entity column which is created with the {@link Users.entityColumn} function.
+         * @internal
+         */
+        this.entityLabel = 'Counterparty';
+        /**
+         * Definition of the `DATASERVER` query which is used when managing Counterpartys
+         * @internal
+         */
+        this.availableEntitiesEndpoint = 'ALL_COUNTERPARTYS';
+        this.createEvent = this.auth.currentUser.hasPermission('INSERT_USER')
+            ? 'EVENT_INSERT_USER'
+            : '';
+        this.deleteEvent = this.auth.currentUser.hasPermission('DELETE_USER')
+            ? 'EVENT_DELETE_USER'
+            : '';
+        this.updateEvent = this.auth.currentUser.hasPermission('AMEND_USER') ? 'EVENT_AMEND_USER' : '';
+    }
+    connectedCallback() {
+        const _super = Object.create(null, {
+            connectedCallback: { get: () => super.connectedCallback }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.connectedCallback.call(this);
+            // retrieving access type of currently logged-in user
+            const userReq = yield this.connect.snapshot('ALL_USERS', {
+                CRITERIA_MATCH: `USER_NAME == '${this.auth.currentUser.username}'`,
+            });
+            if (userReq.ROW[0]) {
+                this.allAccessType = userReq.ROW[0].ACCESS_TYPE === 'ALL';
+                this.entityIdValue = userReq.ROW[0][this.entityID];
+            }
+        });
+    }
+    deepClone() {
+        const copy = super.deepClone();
+        copy.additionalCreateFields = structuredClone(this.additionalCreateFields);
+        copy.additionalUpdateFields = structuredClone(this.additionalUpdateFields);
+        copy.allAccessType = structuredClone(this.allAccessType);
+        copy.createEvent = structuredClone(this.createEvent);
+        copy.datasourceConfig = structuredClone(this.datasourceConfig);
+        copy.deleteEvent = structuredClone(this.deleteEvent);
+        copy.updateEvent = structuredClone(this.updateEvent);
+        // this.columns[number] might contain a function, so can't use structuredClone
+        copy.columns = this.columns ? [...this.columns].map((x) => (Object.assign({}, x))) : this.columns;
+        return copy;
+    }
+    /**
+     * Used as the callback function in {@link Users.statusColumn}
+     * @internal
+     */
+    statusRendererSelector(params) {
+        return {
+            component: GridProRendererTypes.action,
+            params: {
+                actionClick: () => this.changeStatus(params),
+                actionName: params.value === 'ENABLED' ? 'Deactivate' : 'Activate',
+                appearance: 'secondary-orange',
+            },
+        };
+    }
+    /**
+     * Changes the status of an entity
+     *
+     * @remarks
+     *
+     * The action which is run on the status button from {@link Users.statusRendererSelector}
+     *
+     * @internal
+     */
+    changeStatus(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isEnabled = params.data.STATUS === 'ENABLED';
+            // optimistically set value and store previous value
+            const previousValue = params.data.STATUS;
+            params.setValue(isEnabled ? 'DISABLED' : 'ENABLED');
+            const changeStatusRequest = yield this.connect.commitEvent(isEnabled ? 'EVENT_DISABLE_USER' : 'EVENT_ENABLE_USER', {
+                DETAILS: {
+                    USER_NAME: params.data.USER_NAME,
+                },
+            });
+            if (changeStatusRequest.ERROR) {
+                logger.error(changeStatusRequest.ERROR);
+                const notificationCloseTimeout = 5000;
+                changeStatusRequest.ERROR.forEach((err) => {
+                    showNotification({
+                        title: err.CODE,
+                        body: getErrorFormat(err),
+                        config: {
+                            toast: { type: 'warning', autoClose: true, closeTimeout: notificationCloseTimeout },
+                        },
+                    }, 'zero');
+                });
+                // bring back original value
+                params.setValue(previousValue);
+            }
+        });
+    }
+    /**
+     * @internal
+     */
+    readUserData(user) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const userProfiles = yield this.connect.request('PROFILE_USER', {
+                REQUEST: {
+                    USER_NAME: user.USER_NAME,
+                },
+            });
+            const defaultValues = !this.allAccessType && ((_a = this.entityIdValue) === null || _a === void 0 ? void 0 : _a.length)
+                ? {
+                    ACCESS_TYPE: 'ENTITY',
+                    [this.entityID]: this.entityIdValue,
+                }
+                : {};
+            return Object.assign(Object.assign({}, defaultValues), { USER_PROFILES: (userProfiles.REPLY || []).map((profile) => profile.PROFILE_NAME), ADDRESS_LINE_1: user.ADDRESS_LINE1, ADDRESS_LINE_2: user.ADDRESS_LINE2, ADDRESS_LINE_3: user.ADDRESS_LINE3, ADDRESS_LINE_4: user.ADDRESS_LINE4 });
+        });
+    }
+};
+__decorate([
+    Connect
+], Users.prototype, "connect", void 0);
+__decorate([
+    Auth
+], Users.prototype, "auth", void 0);
+__decorate([
+    observable
+], Users.prototype, "datasourceConfig", void 0);
+__decorate([
+    attr
+], Users.prototype, "resourceName", void 0);
+__decorate([
+    attr({ attribute: 'persist-column-state-key' })
+], Users.prototype, "persistColumnStateKey", void 0);
+__decorate([
+    observable
+], Users.prototype, "columns", void 0);
+__decorate([
+    observable
+], Users.prototype, "additionalCreateFields", void 0);
+__decorate([
+    observable
+], Users.prototype, "additionalUpdateFields", void 0);
+__decorate([
+    observable
+], Users.prototype, "allAccessType", void 0);
+__decorate([
+    observable
+], Users.prototype, "createEvent", void 0);
+__decorate([
+    observable
+], Users.prototype, "deleteEvent", void 0);
+__decorate([
+    observable
+], Users.prototype, "updateEvent", void 0);
+__decorate([
+    attr
+], Users.prototype, "entityID", void 0);
+__decorate([
+    attr
+], Users.prototype, "entityLabelKey", void 0);
+__decorate([
+    attr
+], Users.prototype, "entityLabel", void 0);
+__decorate([
+    attr
+], Users.prototype, "availableEntitiesEndpoint", void 0);
+Users = __decorate([
+    customElement({
+        name: 'user-management',
+        template: UsersTemplate,
+        styles: css `
+    :host {
+      height: 100%;
+    }
+  `,
+    })
+], Users);
+export { Users };

package/dist/esm/user-admin/users.template.js

@@ -0,0 +1,90 @@
+import { html } from '@microsoft/fast-element';
+const conditionalSchemaEntry = (predicate, entry) => {
+    return predicate ? [entry] : [];
+};
+const editUserSchema = (edit, allAccessType, entityID, entityLabel, entityLabelKey, availableEntitiesEndpoint, additionalEntries = []) => ({
+    type: 'VerticalLayout',
+    elements: [
+        {
+            type: 'Control',
+            label: 'Username',
+            scope: '#/properties/USER_NAME',
+            options: {
+                readonly: edit,
+            },
+        },
+        {
+            type: 'Control',
+            label: 'Email',
+            scope: '#/properties/EMAIL_ADDRESS',
+        },
+        {
+            type: 'Control',
+            label: 'First Name',
+            scope: '#/properties/FIRST_NAME',
+        },
+        {
+            type: 'Control',
+            label: 'Last Name',
+            scope: '#/properties/LAST_NAME',
+        },
+        ...conditionalSchemaEntry(!edit, {
+            type: 'Control',
+            label: 'One Time Password',
+            scope: '#/properties/ONE_TIME_PASSWORD',
+        }),
+        {
+            type: 'Control',
+            label: 'User Profiles',
+            scope: '#/properties/USER_PROFILES',
+            options: {
+                allOptionsResourceName: 'ALL_PROFILES',
+                valueField: 'PROFILE_NAME',
+                labelField: 'PROFILE_NAME',
+            },
+        },
+        ...conditionalSchemaEntry(!!entityID, {
+            type: 'Control',
+            label: 'Access Type',
+            scope: '#/properties/ACCESS_TYPE',
+            options: {
+                hidden: !allAccessType,
+            },
+        }),
+        ...conditionalSchemaEntry(!!entityID, {
+            type: 'Control',
+            scope: `#/properties/${entityID}`,
+            options: {
+                allOptionsResourceName: availableEntitiesEndpoint,
+                valueField: entityID,
+                labelField: entityLabelKey || entityID,
+                hidden: !allAccessType,
+            },
+            label: entityLabel,
+        }),
+        ...additionalEntries.map((entry) => typeof entry === 'string'
+            ? {
+                type: 'Control',
+                scope: `#/properties/${entry}`,
+            }
+            : entry),
+    ],
+});
+export const UsersTemplate = html `
+  <entity-management
+    resourceName=${(x) => x.resourceName}
+    title="User Management"
+    entityLabel="User"
+    createEvent="${(x) => x.createEvent}"
+    :readEventFn=${(x) => (user) => x.readUserData(user)}
+    updateEvent="${(x) => x.updateEvent}"
+    deleteEvent="${(x) => x.deleteEvent}"
+    entityLabel="User Details"
+    :updateFormUiSchema=${(x) => editUserSchema(true, x.allAccessType, x.entityID, x.entityLabel, x.entityLabelKey, x.availableEntitiesEndpoint, x.additionalUpdateFields)}
+    :createFormUiSchema=${(x) => editUserSchema(false, x.allAccessType, x.entityID, x.entityLabel, x.entityLabelKey, x.availableEntitiesEndpoint, x.additionalCreateFields)}
+    persist-column-state-key=${(x) => x.persistColumnStateKey}
+    size-columns-to-fit
+    :columns=${(x) => [...x.columns, ...x.entityColumn(), x.statusColumn()]}
+    :datasourceConfig=${(x) => x.datasourceConfig}
+  ></entity-management>
+`;

package/dist/esm/utils/formatting.js

@@ -0,0 +1,6 @@
+/**
+ * Format the error as a string with a different format depending on whether
+ * `err` has a `FIELD` property or not
+ * @public
+ */
+export const getErrorFormat = (err) => (err.FIELD ? `${err.FIELD} - ${err.TEXT}` : `${err.TEXT}`);

package/dist/esm/utils/index.js

@@ -0,0 +1,2 @@
+export * from './formatting';
+export * from './logger';

package/dist/esm/utils/logger.js

@@ -0,0 +1,5 @@
+import { createLogger } from '@genesislcap/foundation-logger';
+/**
+ * @public
+ */
+export const logger = createLogger('user-admin');

package/index.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8"/>
+    <title>{{htmlWebpackPlugin.options.title}}</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+</head>
+<style>
+    html,
+    body {
+        width: 100%;
+        height: 100%;
+        padding: 0;
+        margin: 0;
+    }
+    :not(:defined) {
+        visibility: hidden;
+    }
+</style>
+<body>
+<user-management></user-management>
+{{#if insertEntryPoint}}
+<script type="module" src="/src/index.ts"></script>
+{{/if}}
+</body>
+</html>

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@genesislcap/pbc-auth-ui",
+  "description": "Genesis PBC auth UI",
+  "version": "1.0.3",
+  "license": "SEE LICENSE IN license.txt",
+  "main": "dist/esm/index.js",
+  "types": "dist/foundation-auth.d.ts",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "config": {
+    "PORT": 5070
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/foundation-auth.d.ts",
+      "default": "./dist/esm/index.js"
+    },
+    "./e2e": {
+      "default": "./test/e2e/index.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "e2e": [
+        "./test/e2e/index.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "bootstrap": "npm install --no-fund --no-audit",
+    "bootstrap:ci": "npm ci --no-fund --no-audit",
+    "build": "genx build -b ts",
+    "build:webpack": "genx build",
+    "build:webpack:stats": "genx analyze",
+    "clean": "rimraf dist tsconfig.tsbuildinfo",
+    "dev": "genx dev -e API_HOST,ENABLE_SSO",
+    "dev:docker": "npm run dev -- --host 0.0.0.0",
+    "dev:intellij": "genx dev -e ENABLE_SSO",
+    "dev:no-open": "npm run dev -- --no-open",
+    "dev:https": "npm run dev -- --https",
+    "dev:webpack": "npm run dev -- -b webpack",
+    "serve": "genx serve",
+    "test": "genx test",
+    "test:coverage": "genx test --coverage",
+    "test:coverage:browser": "genx test --coverage --browser",
+    "test:e2e": "genx test --e2e",
+    "test:e2e:debug": "genx test --e2e --debug",
+    "test:e2e:ui": "genx test --e2e --interactive",
+    "test:unit:browser": "genx test --browser",
+    "test:unit:browser:watch": "genx test --browser --watch",
+    "test:unit:watch": "genx test --watch",
+    "test:debug": "genx test --debug"
+  },
+  "devDependencies": {
+    "@genesislcap/foundation-testing": "~14",
+    "@genesislcap/genx": "~14",
+    "playwright-lighthouse": "^3.1.0",
+    "rimraf": "^3.0.2",
+    "tslib": "^2.3.1"
+  },
+  "peerDependencies": {
+    "@ag-grid-community/core": "29.2.0",
+    "@genesislcap/foundation-comms": "~14",
+    "@genesislcap/foundation-entity-management": "~14",
+    "@genesislcap/foundation-logger": "~14",
+    "@genesislcap/foundation-notifications": "~14",
+    "@genesislcap/foundation-utils": "~14",
+    "@microsoft/fast-components": "^2.21.3",
+    "@microsoft/fast-element": "^1.7.0",
+    "@microsoft/fast-foundation": "^2.33.2",
+    "@microsoft/fast-router": "^0.4.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "customElements": "dist/custom-elements.json"
+}

package/sonar-project.properties

@@ -0,0 +1,5 @@
+sonar.projectKey=genesislcap_auth-server_client
+sonar.projectName=pbc-auth-ui
+sonar.organization=genesislcap
+sonar.host.url=https://sonarcloud.io
+sonar.sourceEncoding=UTF-8