@pnp/cli-microsoft365 7.1.0-beta.d53f0d9 → 7.2.0-beta.194fd07

package/.eslintrc.cjs

@@ -5,6 +5,7 @@ const dictionary = [
   'activation',
   'activations',
   'adaptive',
+  'administrative',
   'ai',
   'app',
   'application',
@@ -90,6 +91,7 @@ const dictionary = [
   'threat',
   'token',
   'type',
+  'unit',
   'user',
   'web',
   'webhook'

package/dist/Auth.js

@@ -289,7 +289,7 @@ export class Auth {
             // but also stub it for testing
             /* c8 ignore next 3 */
             if (!this._authServer) {
-                this._authServer = (await import('./AuthServer')).default;
+                this._authServer = (await import('./AuthServer.js')).default;
             }
             this._authServer.initializeServer(this.service, resource, resolve, reject, logger, debug);
         });

package/dist/Command.js

@@ -12,6 +12,7 @@ import { settingsNames } from './settingsNames.js';
 import { telemetry } from './telemetry.js';
 import { accessToken } from './utils/accessToken.js';
 import { md } from './utils/md.js';
+import { prompt } from './utils/prompt.js';
 export class CommandError {
     constructor(message, code) {
         this.message = message;
@@ -75,7 +76,6 @@ class Command {
     }
     async validateRequiredOptions(args, command) {
         const shouldPrompt = Cli.getInstance().getSettingWithDefaultValue(settingsNames.prompt, true);
-        let inquirer;
         let prompted = false;
         for (let i = 0; i < command.options.length; i++) {
             if (!command.options[i].required ||
@@ -87,19 +87,17 @@ class Command {
             }
             if (!prompted) {
                 prompted = true;
-                Cli.log('Provide values for the following parameters:');
+                Cli.error('🌶️  Provide values for the following parameters:');
             }
-            if (!inquirer) {
-                inquirer = await import('inquirer');
-            }
-            const missingRequireOptionValue = await inquirer.default
-                .prompt({
+            const missingRequireOptionValue = await prompt.forInput({
                 name: 'missingRequireOptionValue',
                 message: `${command.options[i].name}: `
-            })
-                .then(result => result.missingRequireOptionValue);
+            }).then(result => result.missingRequireOptionValue);
             args.options[command.options[i].name] = missingRequireOptionValue;
         }
+        if (prompted) {
+            Cli.error('');
+        }
         this.processOptions(args.options);
         return true;
     }
@@ -108,7 +106,6 @@ class Command {
         if (!optionsSets || optionsSets.length === 0) {
             return true;
         }
-        let inquirer;
         const shouldPrompt = Cli.getInstance().getSettingWithDefaultValue(settingsNames.prompt, true);
         const argsOptions = Object.keys(args.options);
         for (const optionSet of optionsSets.sort(opt => opt.runsWhen ? 0 : 1)) {
@@ -120,50 +117,43 @@ class Command {
                 if (!shouldPrompt) {
                     return `Specify one of the following options: ${optionSet.options.join(', ')}.`;
                 }
-                await this.promptForOptionSetNameAndValue(args, optionSet, inquirer);
+                await this.promptForOptionSetNameAndValue(args, optionSet);
             }
             if (commonOptions.length > 1) {
                 if (!shouldPrompt) {
                     return `Specify one of the following options: ${optionSet.options.join(', ')}, but not multiple.`;
                 }
-                await this.promptForSpecificOption(args, commonOptions, inquirer);
+                await this.promptForSpecificOption(args, commonOptions);
             }
         }
         return true;
     }
-    async promptForOptionSetNameAndValue(args, optionSet, inquirer) {
-        if (!inquirer) {
-            inquirer = await import('inquirer');
-        }
-        Cli.log(`Please specify one of the following options:`);
-        const resultOptionName = await inquirer.default.prompt({
+    async promptForOptionSetNameAndValue(args, optionSet) {
+        Cli.error(`🌶️  Please specify one of the following options:`);
+        const resultOptionName = await prompt.forInput({
             type: 'list',
             name: 'missingRequiredOptionName',
             message: `Option to use:`,
             choices: optionSet.options
         });
         const missingRequiredOptionName = resultOptionName.missingRequiredOptionName;
-        const resultOptionValue = await inquirer.default
-            .prompt({
+        const resultOptionValue = await prompt.forInput({
             name: 'missingRequiredOptionValue',
             message: `${missingRequiredOptionName}:`
         });
         args.options[missingRequiredOptionName] = resultOptionValue.missingRequiredOptionValue;
-        Cli.log();
+        Cli.error('');
     }
-    async promptForSpecificOption(args, commonOptions, inquirer) {
-        if (!inquirer) {
-            inquirer = await import('inquirer');
-        }
-        Cli.log(`Multiple options for an option set specified. Please specify the correct option that you wish to use.`);
-        const requiredOptionNameResult = await inquirer.default.prompt({
+    async promptForSpecificOption(args, commonOptions) {
+        Cli.error(`🌶️  Multiple options for an option set specified. Please specify the correct option that you wish to use.`);
+        const requiredOptionNameResult = await prompt.forInput({
             type: 'list',
             name: 'missingRequiredOptionName',
             message: `Option to use:`,
             choices: commonOptions
         });
         commonOptions.filter(y => y !== requiredOptionNameResult.missingRequiredOptionName).map(optionName => args.options[optionName] = undefined);
-        Cli.log();
+        Cli.error('');
     }
     async validateOutput(args) {
         if (args.options.output &&

package/dist/cli/Cli.js

@@ -15,6 +15,7 @@ import { formatting } from '../utils/formatting.js';
 import { fsUtil } from '../utils/fsUtil.js';
 import { md } from '../utils/md.js';
 import { validation } from '../utils/validation.js';
+import { prompt } from '../utils/prompt.js';
 export class Cli {
     get config() {
         if (!this._config) {
@@ -706,9 +707,10 @@ export class Cli {
             const maxLength = Math.max(...namesOfCommandsToPrint.map(s => s.length)) + 10;
             Cli.log(`Commands:`);
             Cli.log();
-            for (const commandName in commandsToPrint) {
+            const sortedCommandNamesToPrint = Object.getOwnPropertyNames(commandsToPrint).sort();
+            sortedCommandNamesToPrint.forEach(commandName => {
                 Cli.log(`  ${`${commandName} [options]`.padEnd(maxLength, ' ')}  ${commandsToPrint[commandName].command.description}`);
-            }
+            });
         }
         const namesOfCommandGroupsToPrint = Object.keys(commandGroupsToPrint);
         if (namesOfCommandGroupsToPrint.length > 0) {
@@ -803,14 +805,13 @@ export class Cli {
         }
     }
     static async prompt(options, answers) {
-        const inquirer = await import('inquirer');
         const cli = Cli.getInstance();
         const spinnerSpinning = cli.spinner.isSpinning;
         /* c8 ignore next 3 */
         if (spinnerSpinning) {
             cli.spinner.stop();
         }
-        const response = await inquirer.default.prompt(options, answers);
+        const response = await prompt.forInput(options, answers);
         // Restart the spinner if it was running before the prompt
         /* c8 ignore next 3 */
         if (spinnerSpinning) {
@@ -827,6 +828,7 @@ export class Cli {
             type: 'list',
             name: 'select',
             default: 0,
+            prefix: '🌶️  ',
             message: `${message} Please choose one:`,
             choices: Object.keys(values)
         });

package/dist/m365/aad/commands/administrativeunit/administrativeunit-add.js

@@ -0,0 +1,61 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AadAdministrativeUnitAddCommand_instances, _AadAdministrativeUnitAddCommand_initTelemetry, _AadAdministrativeUnitAddCommand_initOptions;
+import request from "../../../../request.js";
+import GraphCommand from "../../../base/GraphCommand.js";
+import commands from "../../commands.js";
+class AadAdministrativeUnitAddCommand extends GraphCommand {
+    get name() {
+        return commands.ADMINISTRATIVEUNIT_ADD;
+    }
+    get description() {
+        return 'Creates an administrative unit';
+    }
+    constructor() {
+        super();
+        _AadAdministrativeUnitAddCommand_instances.add(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitAddCommand_instances, "m", _AadAdministrativeUnitAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitAddCommand_instances, "m", _AadAdministrativeUnitAddCommand_initOptions).call(this);
+    }
+    async commandAction(logger, args) {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/directory/administrativeUnits`,
+            headers: {
+                'accept': 'application/json;odata.metadata=none'
+            },
+            responseType: 'json',
+            data: {
+                description: args.options.description,
+                displayName: args.options.displayName,
+                visibility: args.options.hiddenMembership ? 'HiddenMembership' : null
+            }
+        };
+        try {
+            const administrativeUnit = await request.post(requestOptions);
+            await logger.log(administrativeUnit);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_AadAdministrativeUnitAddCommand_instances = new WeakSet(), _AadAdministrativeUnitAddCommand_initTelemetry = function _AadAdministrativeUnitAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            hiddenMembership: args.options.hiddenMembership
+        });
+    });
+}, _AadAdministrativeUnitAddCommand_initOptions = function _AadAdministrativeUnitAddCommand_initOptions() {
+    this.options.unshift({
+        option: '-n, --displayName <displayName>'
+    }, {
+        option: '-d, --description [description]'
+    }, {
+        option: '--hiddenMembership [hiddenMembership]'
+    });
+};
+export default new AadAdministrativeUnitAddCommand();
+//# sourceMappingURL=administrativeunit-add.js.map

package/dist/m365/aad/commands/administrativeunit/administrativeunit-get.js

@@ -0,0 +1,93 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AadAdministrativeUnitGetCommand_instances, _AadAdministrativeUnitGetCommand_initTelemetry, _AadAdministrativeUnitGetCommand_initOptions, _AadAdministrativeUnitGetCommand_initValidators, _AadAdministrativeUnitGetCommand_initOptionSets, _AadAdministrativeUnitGetCommand_initTypes;
+import { validation } from "../../../../utils/validation.js";
+import request from "../../../../request.js";
+import GraphCommand from "../../../base/GraphCommand.js";
+import commands from "../../commands.js";
+import { odata } from "../../../../utils/odata.js";
+import { formatting } from "../../../../utils/formatting.js";
+import { Cli } from "../../../../cli/Cli.js";
+class AadAdministrativeUnitGetCommand extends GraphCommand {
+    get name() {
+        return commands.ADMINISTRATIVEUNIT_GET;
+    }
+    get description() {
+        return 'Gets information about a specific administrative unit';
+    }
+    constructor() {
+        super();
+        _AadAdministrativeUnitGetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitGetCommand_instances, "m", _AadAdministrativeUnitGetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitGetCommand_instances, "m", _AadAdministrativeUnitGetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitGetCommand_instances, "m", _AadAdministrativeUnitGetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitGetCommand_instances, "m", _AadAdministrativeUnitGetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitGetCommand_instances, "m", _AadAdministrativeUnitGetCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        let administrativeUnit;
+        try {
+            if (args.options.id) {
+                administrativeUnit = await this.getAdministrativeUnitById(args.options.id);
+            }
+            else {
+                administrativeUnit = await this.getAdministrativeUnitByDisplayName(args.options.displayName);
+            }
+            await logger.log(administrativeUnit);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getAdministrativeUnitById(id) {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/directory/administrativeUnits/${id}`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        return await request.get(requestOptions);
+    }
+    async getAdministrativeUnitByDisplayName(displayName) {
+        const administrativeUnits = await odata.getAllItems(`${this.resource}/v1.0/directory/administrativeUnits?$filter=displayName eq '${formatting.encodeQueryParameter(displayName)}'`);
+        if (administrativeUnits.length === 0) {
+            throw `The specified administrative unit '${displayName}' does not exist.`;
+        }
+        if (administrativeUnits.length > 1) {
+            const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', administrativeUnits);
+            return await Cli.handleMultipleResultsFound(`Multiple administrative units with name '${displayName}' found.`, resultAsKeyValuePair);
+        }
+        return administrativeUnits[0];
+    }
+}
+_AadAdministrativeUnitGetCommand_instances = new WeakSet(), _AadAdministrativeUnitGetCommand_initTelemetry = function _AadAdministrativeUnitGetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            id: typeof args.options.id !== 'undefined',
+            displayName: typeof args.options.displayName !== 'undefined'
+        });
+    });
+}, _AadAdministrativeUnitGetCommand_initOptions = function _AadAdministrativeUnitGetCommand_initOptions() {
+    this.options.unshift({
+        option: '-i, --id [id]'
+    }, {
+        option: '-n, --displayName [displayName]'
+    });
+}, _AadAdministrativeUnitGetCommand_initValidators = function _AadAdministrativeUnitGetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.id && !validation.isValidGuid(args.options.id)) {
+            return `${args.options.id} is not a valid GUID`;
+        }
+        return true;
+    });
+}, _AadAdministrativeUnitGetCommand_initOptionSets = function _AadAdministrativeUnitGetCommand_initOptionSets() {
+    this.optionSets.push({ options: ['id', 'displayName'] });
+}, _AadAdministrativeUnitGetCommand_initTypes = function _AadAdministrativeUnitGetCommand_initTypes() {
+    this.types.string.push('displayName');
+};
+export default new AadAdministrativeUnitGetCommand();
+//# sourceMappingURL=administrativeunit-get.js.map

package/dist/m365/aad/commands/administrativeunit/administrativeunit-list.js

@@ -0,0 +1,25 @@
+import { odata } from '../../../../utils/odata.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class AadAdministrativeUnitListCommand extends GraphCommand {
+    get name() {
+        return commands.ADMINISTRATIVEUNIT_LIST;
+    }
+    get description() {
+        return 'Retrieves a list of administrative units';
+    }
+    defaultProperties() {
+        return ['id', 'displayName', 'visibility'];
+    }
+    async commandAction(logger) {
+        try {
+            const results = await odata.getAllItems(`${this.resource}/v1.0/directory/administrativeUnits`);
+            await logger.log(results);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+export default new AadAdministrativeUnitListCommand();
+//# sourceMappingURL=administrativeunit-list.js.map

package/dist/m365/aad/commands/administrativeunit/administrativeunit-remove.js

@@ -0,0 +1,108 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AadAdministrativeUnitRemoveCommand_instances, _AadAdministrativeUnitRemoveCommand_initTelemetry, _AadAdministrativeUnitRemoveCommand_initOptions, _AadAdministrativeUnitRemoveCommand_initOptionSets, _AadAdministrativeUnitRemoveCommand_initValidators, _AadAdministrativeUnitRemoveCommand_initTypes;
+import { validation } from "../../../../utils/validation.js";
+import request from "../../../../request.js";
+import GraphCommand from "../../../base/GraphCommand.js";
+import commands from "../../commands.js";
+import { odata } from "../../../../utils/odata.js";
+import { formatting } from "../../../../utils/formatting.js";
+import { Cli } from "../../../../cli/Cli.js";
+class AadAdministrativeUnitRemoveCommand extends GraphCommand {
+    get name() {
+        return commands.ADMINISTRATIVEUNIT_REMOVE;
+    }
+    get description() {
+        return 'Removes an administrative unit';
+    }
+    constructor() {
+        super();
+        _AadAdministrativeUnitRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitRemoveCommand_instances, "m", _AadAdministrativeUnitRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitRemoveCommand_instances, "m", _AadAdministrativeUnitRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitRemoveCommand_instances, "m", _AadAdministrativeUnitRemoveCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitRemoveCommand_instances, "m", _AadAdministrativeUnitRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _AadAdministrativeUnitRemoveCommand_instances, "m", _AadAdministrativeUnitRemoveCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        const removeAdministrativeUnit = async () => {
+            try {
+                let administrativeUnitId = args.options.id;
+                if (args.options.displayName) {
+                    administrativeUnitId = await this.getAdministrativeUnitIdByDisplayName(args.options.displayName);
+                }
+                const requestOptions = {
+                    url: `${this.resource}/v1.0/directory/administrativeUnits/${administrativeUnitId}`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    }
+                };
+                await request.delete(requestOptions);
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await removeAdministrativeUnit();
+        }
+        else {
+            const result = await Cli.prompt({
+                type: 'confirm',
+                name: 'continue',
+                default: false,
+                message: `Are you sure you want to remove administrative unit '${args.options.id || args.options.displayName}'?`
+            });
+            if (result.continue) {
+                await removeAdministrativeUnit();
+            }
+        }
+    }
+    async getAdministrativeUnitIdByDisplayName(displayName) {
+        const administrativeUnits = await odata.getAllItems(`${this.resource}/v1.0/directory/administrativeUnits?$filter=displayName eq '${formatting.encodeQueryParameter(displayName)}'&$select=id`);
+        if (administrativeUnits.length === 0) {
+            throw `The specified administrative unit '${displayName}' does not exist.`;
+        }
+        if (administrativeUnits.length > 1) {
+            const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', administrativeUnits);
+            const selectedAdministrativeUnit = await Cli.handleMultipleResultsFound(`Multiple administrative units with name '${displayName}' found.`, resultAsKeyValuePair);
+            return selectedAdministrativeUnit.id;
+        }
+        return administrativeUnits[0].id;
+    }
+}
+_AadAdministrativeUnitRemoveCommand_instances = new WeakSet(), _AadAdministrativeUnitRemoveCommand_initTelemetry = function _AadAdministrativeUnitRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            id: args.options.id !== 'undefined',
+            displayName: args.options.displayName !== 'undefined',
+            force: !!args.options.force
+        });
+    });
+}, _AadAdministrativeUnitRemoveCommand_initOptions = function _AadAdministrativeUnitRemoveCommand_initOptions() {
+    this.options.unshift({
+        option: '-i, --id [id]'
+    }, {
+        option: '-n, --displayName [displayName]'
+    }, {
+        option: '-f, --force'
+    });
+}, _AadAdministrativeUnitRemoveCommand_initOptionSets = function _AadAdministrativeUnitRemoveCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['id', 'displayName']
+    });
+}, _AadAdministrativeUnitRemoveCommand_initValidators = function _AadAdministrativeUnitRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.id && !validation.isValidGuid(args.options.id)) {
+            return `${args.options.id} is not a valid GUID for option id.`;
+        }
+        return true;
+    });
+}, _AadAdministrativeUnitRemoveCommand_initTypes = function _AadAdministrativeUnitRemoveCommand_initTypes() {
+    this.types.string.push('id', 'displayName');
+};
+export default new AadAdministrativeUnitRemoveCommand();
+//# sourceMappingURL=administrativeunit-remove.js.map

package/dist/m365/aad/commands/group/group-user-list.js

@@ -0,0 +1,146 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AadGroupUserListCommand_instances, _AadGroupUserListCommand_initTelemetry, _AadGroupUserListCommand_initOptions, _AadGroupUserListCommand_initOptionSets, _AadGroupUserListCommand_initValidators;
+import { aadGroup } from '../../../../utils/aadGroup.js';
+import { odata } from '../../../../utils/odata.js';
+import { validation } from '../../../../utils/validation.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class AadGroupUserListCommand extends GraphCommand {
+    get name() {
+        return commands.GROUP_USER_LIST;
+    }
+    get description() {
+        return 'Lists users of a specific Azure AD group';
+    }
+    defaultProperties() {
+        return ['id', 'displayName', 'userPrincipalName', 'roles'];
+    }
+    constructor() {
+        super();
+        _AadGroupUserListCommand_instances.add(this);
+        __classPrivateFieldGet(this, _AadGroupUserListCommand_instances, "m", _AadGroupUserListCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _AadGroupUserListCommand_instances, "m", _AadGroupUserListCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _AadGroupUserListCommand_instances, "m", _AadGroupUserListCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _AadGroupUserListCommand_instances, "m", _AadGroupUserListCommand_initValidators).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            const groupId = await this.getGroupId(args.options, logger);
+            const users = [];
+            if (!args.options.role || args.options.role === 'Owner') {
+                const owners = await this.getUsers(args.options, 'Owners', groupId, logger);
+                owners.forEach(owner => users.push({ ...owner, roles: ['Owner'] }));
+            }
+            if (!args.options.role || args.options.role === 'Member') {
+                const members = await this.getUsers(args.options, 'Members', groupId, logger);
+                members.forEach((member) => {
+                    const user = users.find((u) => u.id === member.id);
+                    if (user !== undefined) {
+                        user.roles.push('Member');
+                    }
+                    else {
+                        users.push({ ...member, roles: ['Member'] });
+                    }
+                });
+            }
+            await logger.log(users);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getGroupId(options, logger) {
+        if (options.groupId) {
+            return options.groupId;
+        }
+        if (this.verbose) {
+            await logger.logToStderr('Retrieving Group Id...');
+        }
+        return await aadGroup.getGroupIdByDisplayName(options.groupDisplayName);
+    }
+    async getUsers(options, role, groupId, logger) {
+        const { properties, filter } = options;
+        if (this.verbose) {
+            await logger.logToStderr(`Retrieving ${role} of the group with id ${groupId}`);
+        }
+        const selectProperties = properties ?
+            `${properties.split(',').filter(f => f.toLowerCase() !== 'id').concat('id').map(p => p.trim()).join(',')}` :
+            'id,displayName,userPrincipalName,givenName,surname';
+        const allSelectProperties = selectProperties.split(',');
+        const propertiesWithSlash = allSelectProperties.filter(item => item.includes('/'));
+        let fieldExpand = '';
+        propertiesWithSlash.forEach(p => {
+            if (fieldExpand.length > 0) {
+                fieldExpand += ',';
+            }
+            fieldExpand += `${p.split('/')[0]}($select=${p.split('/')[1]})`;
+        });
+        const expandParam = fieldExpand.length > 0 ? `&$expand=${fieldExpand}` : '';
+        const selectParam = allSelectProperties.filter(item => !item.includes('/'));
+        const endpoint = `${this.resource}/v1.0/groups/${groupId}/${role}/microsoft.graph.user?$select=${selectParam}${expandParam}`;
+        let users = [];
+        if (filter) {
+            // While using the filter, we need to specify the ConsistencyLevel header.
+            // Can be refactored when the header is no longer necessary.
+            const requestOptions = {
+                url: `${endpoint}&$filter=${encodeURIComponent(filter)}&$count=true`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none',
+                    ConsistencyLevel: 'eventual'
+                },
+                responseType: 'json'
+            };
+            users = await odata.getAllItems(requestOptions);
+        }
+        else {
+            users = await odata.getAllItems(endpoint);
+        }
+        return users;
+    }
+}
+_AadGroupUserListCommand_instances = new WeakSet(), _AadGroupUserListCommand_initTelemetry = function _AadGroupUserListCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            groupId: typeof args.options.groupId !== 'undefined',
+            groupDisplayName: typeof args.options.groupDisplayName !== 'undefined',
+            role: typeof args.options.role !== 'undefined',
+            properties: typeof args.options.properties !== 'undefined',
+            filter: typeof args.options.filter !== 'undefined'
+        });
+    });
+}, _AadGroupUserListCommand_initOptions = function _AadGroupUserListCommand_initOptions() {
+    this.options.unshift({
+        option: "-i, --groupId [groupId]"
+    }, {
+        option: "-n, --groupDisplayName [groupDisplayName]"
+    }, {
+        option: "-r, --role [role]",
+        autocomplete: ["Owner", "Member"]
+    }, {
+        option: "-p, --properties [properties]"
+    }, {
+        option: "-f, --filter [filter]"
+    });
+}, _AadGroupUserListCommand_initOptionSets = function _AadGroupUserListCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['groupId', 'groupDisplayName']
+    });
+}, _AadGroupUserListCommand_initValidators = function _AadGroupUserListCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.groupId && !validation.isValidGuid(args.options.groupId)) {
+            return `${args.options.groupId} is not a valid GUID`;
+        }
+        if (args.options.role) {
+            if (['Owner', 'Member'].indexOf(args.options.role) === -1) {
+                return `${args.options.role} is not a valid role value. Allowed values Owner|Member`;
+            }
+        }
+        return true;
+    });
+};
+export default new AadGroupUserListCommand();
+//# sourceMappingURL=group-user-list.js.map