protected findMatchingChoicesForScalar(choices: Dictionary<Ro.Value> | null, titleMatch: string): Ro.Value[] {
        if (choices == null) {
            return [];
        }

        const labels = keys(choices);
        const matchingLabels = filter(labels, l => l.toString().toLowerCase().indexOf(titleMatch.toLowerCase()) >= 0);
        const result = new Array<Ro.Value>();
        switch (matchingLabels.length) {
            case 0:
                break; // leave result empty
            case 1:
                // Push the VALUE for the key
                // For simple scalars they are the same, but not for Enums
                result.push(choices[matchingLabels[0]]);
                break;
            default:
                // Push the matching KEYs, wrapped as (pseudo) Values for display in message to user
                // For simple scalars the values would also be OK, but not for Enums
                forEach(matchingLabels, label => result.push(new Ro.Value(label)));
                break;
        }
        return result;
    }

export function tooltip(onWhat: { clientValid: () => boolean }, fields: FieldViewModel[]): string {
    if (onWhat.clientValid()) {
        return '';
    }

    const missingMandatoryFields = filter(fields, p => !p.clientValid && !p.getMessage());

    if (missingMandatoryFields.length > 0) {
        return reduce(missingMandatoryFields, (s, t) => s + t.title + '; ', Msg.mandatoryFieldsPrefix);
    }

    const invalidFields = filter(fields, p => !p.clientValid);

    if (invalidFields.length > 0) {
        return reduce(invalidFields, (s, t) => s + t.title + '; ', Msg.invalidFieldsPrefix);
    }

    return '';
}

 protected matchFriendlyNameAndOrMenuPath<T extends Ro.IHasExtensions>(
     reps: T[],
     match: string | undefined): T[] {
     const clauses = match ? match.split(' ') : [];
     // An exact match has preference over any partial match
     const exactMatches = filter(reps,
         (rep) => {
             const path = rep.extensions().menuPath();
             const name = rep.extensions().friendlyName().toLowerCase();
             return match === name ||
                 (!!path && match === path.toLowerCase() + ' ' + name) ||
                 every(clauses, clause => name === clause || (!!path && path.toLowerCase() === clause));
         });
     if (exactMatches.length > 0) { return exactMatches; }
     return filter(reps,
         rep => {
             const path = rep.extensions().menuPath();
             const name = rep.extensions().friendlyName().toLowerCase();
             return every(clauses, clause => name.indexOf(clause) >= 0 || (!!path && path.toLowerCase().indexOf(clause) >= 0));
         });
 }

export function createSubmenuItems(avms: ActionViewModel[], menuSlot: { name: string, action: ActionViewModel }, level: number): MenuItemViewModel {
    // if not root menu aggregate all actions with same name
    let menuActions: ActionViewModel[];
    let menuItems: MenuItemViewModel[] | null;

    if (menuSlot.name) {
        const actions = filter(avms, a => getMenuNameForLevel(a.menuPath, level) === menuSlot.name && !getMenuNameForLevel(a.menuPath, level + 1));
        menuActions = actions;

        // then collate submenus
        const submenuActions = filter(avms, a => getMenuNameForLevel(a.menuPath, level) === menuSlot.name && !!getMenuNameForLevel(a.menuPath, level + 1));
        let menuSubSlots = map(submenuActions, a => ({ name: getMenuNameForLevel(a.menuPath, level + 1), action: a }));
        menuSubSlots = removeDuplicateMenuNames(menuSubSlots);

        menuItems = map(menuSubSlots, slot => createSubmenuItems(submenuActions, slot, level + 1));
    } else {
        menuActions = [menuSlot.action];
        menuItems = null;
    }

    return new MenuItemViewModel(menuSlot.name, menuActions, menuItems);
}

 protected findMatchingChoicesForRef(choices: Dictionary<Ro.Value> | null, titleMatch: string): Ro.Value[] {
     return choices ? filter(choices, v => v.toString().toLowerCase().indexOf(titleMatch.toLowerCase()) >= 0) : [];
 }