@pnp/cli-microsoft365 7.5.0-beta.cae14d0 → 7.5.0

package/dist/m365/entra/commands/{sp/sp-list.js → enterpriseapp/enterpriseapp-list.js}

@@ -3,33 +3,33 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _EntraSpListCommand_instances, _EntraSpListCommand_initTelemetry, _EntraSpListCommand_initOptions;
+var _EntraEnterpriseAppListCommand_instances, _EntraEnterpriseAppListCommand_initTelemetry, _EntraEnterpriseAppListCommand_initOptions;
 import { odata } from '../../../../utils/odata.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import aadCommands from '../../aadCommands.js';
 import commands from '../../commands.js';
-class EntraSpListCommand extends GraphCommand {
+class EntraEnterpriseAppListCommand extends GraphCommand {
     get name() {
-        return commands.SP_LIST;
+        return commands.ENTERPRISEAPP_LIST;
     }
     defaultProperties() {
         return ['appId', 'displayName', 'tag'];
     }
     get description() {
-        return 'Lists the service principals in the directory';
+        return 'Lists the enterprise applications (or service principals) in Entra ID';
     }
     alias() {
-        return [aadCommands.SP_LIST];
+        return [aadCommands.SP_LIST, commands.SP_LIST];
     }
     constructor() {
         super();
-        _EntraSpListCommand_instances.add(this);
-        __classPrivateFieldGet(this, _EntraSpListCommand_instances, "m", _EntraSpListCommand_initTelemetry).call(this);
-        __classPrivateFieldGet(this, _EntraSpListCommand_instances, "m", _EntraSpListCommand_initOptions).call(this);
+        _EntraEnterpriseAppListCommand_instances.add(this);
+        __classPrivateFieldGet(this, _EntraEnterpriseAppListCommand_instances, "m", _EntraEnterpriseAppListCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _EntraEnterpriseAppListCommand_instances, "m", _EntraEnterpriseAppListCommand_initOptions).call(this);
     }
     async commandAction(logger, args) {
         if (this.verbose) {
-            await logger.logToStderr(`Retrieving service principal information...`);
+            await logger.logToStderr(`Retrieving enterprise application information...`);
         }
         try {
             let requestUrl = `${this.resource}/v1.0/servicePrincipals`;
@@ -51,19 +51,19 @@ class EntraSpListCommand extends GraphCommand {
         }
     }
 }
-_EntraSpListCommand_instances = new WeakSet(), _EntraSpListCommand_initTelemetry = function _EntraSpListCommand_initTelemetry() {
+_EntraEnterpriseAppListCommand_instances = new WeakSet(), _EntraEnterpriseAppListCommand_initTelemetry = function _EntraEnterpriseAppListCommand_initTelemetry() {
     this.telemetry.push((args) => {
         Object.assign(this.telemetryProperties, {
             displayName: typeof args.options.displayName !== 'undefined',
             tag: typeof args.options.tag !== 'undefined'
         });
     });
-}, _EntraSpListCommand_initOptions = function _EntraSpListCommand_initOptions() {
+}, _EntraEnterpriseAppListCommand_initOptions = function _EntraEnterpriseAppListCommand_initOptions() {
     this.options.unshift({
         option: '--displayName [displayName]'
     }, {
         option: '--tag [tag]'
     });
 };
-export default new EntraSpListCommand();
-//# sourceMappingURL=sp-list.js.map
+export default new EntraEnterpriseAppListCommand();
+//# sourceMappingURL=enterpriseapp-list.js.map

package/dist/m365/entra/commands/group/group-add.js

@@ -0,0 +1,224 @@
+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 _EntraGroupAddCommand_instances, _EntraGroupAddCommand_initOptions, _EntraGroupAddCommand_initValidators, _EntraGroupAddCommand_initTelemetry;
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import aadCommands from '../../aadCommands.js';
+import { validation } from '../../../../utils/validation.js';
+import request from '../../../../request.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+class EntraGroupAddCommand extends GraphCommand {
+    get name() {
+        return commands.GROUP_ADD;
+    }
+    get description() {
+        return 'Creates a Microsoft Entra group';
+    }
+    alias() {
+        return [aadCommands.GROUP_ADD];
+    }
+    allowUnknownOptions() {
+        return true;
+    }
+    constructor() {
+        super();
+        _EntraGroupAddCommand_instances.add(this);
+        __classPrivateFieldGet(this, _EntraGroupAddCommand_instances, "m", _EntraGroupAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _EntraGroupAddCommand_instances, "m", _EntraGroupAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _EntraGroupAddCommand_instances, "m", _EntraGroupAddCommand_initValidators).call(this);
+    }
+    async commandAction(logger, args) {
+        let group;
+        let ownerIds = [];
+        let memberIds = [];
+        try {
+            const manifest = this.createRequestBody(args.options);
+            const requestOptions = {
+                url: `${this.resource}/v1.0/groups`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json',
+                data: manifest
+            };
+            ownerIds = await this.getUserIds(logger, args.options.ownerIds, args.options.ownerUserNames);
+            memberIds = await this.getUserIds(logger, args.options.memberIds, args.options.memberUserNames);
+            group = await request.post(requestOptions);
+            if (ownerIds.length !== 0) {
+                await this.addUsers(group.id, 'owners', ownerIds);
+            }
+            if (memberIds.length !== 0) {
+                await this.addUsers(group.id, 'members', memberIds);
+            }
+            await logger.log(group);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    ;
+    createRequestBody(options) {
+        const requestBody = {
+            displayName: options.displayName,
+            description: options.description,
+            mailNickName: options.mailNickname ?? this.generateMailNickname(),
+            visibility: options.visibility ?? 'Public',
+            groupTypes: options.type === 'microsoft365' ? ['Unified'] : [],
+            mailEnabled: options.type === 'security' ? false : true,
+            securityEnabled: true
+        };
+        this.addUnknownOptionsToPayload(requestBody, options);
+        return requestBody;
+    }
+    generateMailNickname() {
+        return `Group${Math.floor(Math.random() * 1000000)}`;
+    }
+    async getUserIds(logger, userIds, userNames) {
+        if (userIds) {
+            return userIds.split(',').map(o => o.trim());
+        }
+        if (!userNames) {
+            if (this.verbose) {
+                await logger.logToStderr('No users to validate, skipping.');
+            }
+            return [];
+        }
+        if (this.verbose) {
+            await logger.logToStderr('Retrieving user information.');
+        }
+        const userArr = userNames.split(',').map(o => o.trim());
+        if (this.verbose) {
+            await logger.logToStderr('Retrieving ID(s) of user(s)...');
+        }
+        return entraUser.getUserIdsByUpns(userArr);
+    }
+    async addUsers(groupId, role, userIds) {
+        for (let i = 0; i < userIds.length; i += 400) {
+            const userIdsBatch = userIds.slice(i, i + 400);
+            const requestOptions = {
+                url: `${this.resource}/v1.0/$batch`,
+                headers: {
+                    'content-type': 'application/json;odata.metadata=none'
+                },
+                responseType: 'json',
+                data: {
+                    requests: []
+                }
+            };
+            // only 20 requests per one batch are allowed
+            for (let j = 0; j < userIdsBatch.length; j += 20) {
+                // only 20 users can be added in one request
+                const userIdsChunk = userIdsBatch.slice(j, j + 20);
+                requestOptions.data.requests.push({
+                    id: j + 1,
+                    method: 'PATCH',
+                    url: `/groups/${groupId}`,
+                    headers: {
+                        'content-type': 'application/json;odata.metadata=none'
+                    },
+                    body: {
+                        [`${role}@odata.bind`]: userIdsChunk.map(u => `${this.resource}/v1.0/directoryObjects/${u}`)
+                    }
+                });
+            }
+            const res = await request.post(requestOptions);
+            for (const response of res.responses) {
+                if (response.status !== 204) {
+                    throw response.body;
+                }
+            }
+        }
+    }
+}
+_EntraGroupAddCommand_instances = new WeakSet(), _EntraGroupAddCommand_initOptions = function _EntraGroupAddCommand_initOptions() {
+    this.options.unshift({
+        option: '-n, --displayName <displayName>'
+    }, {
+        option: '-d, --description [description]'
+    }, {
+        option: '-t, --type <type>',
+        autocomplete: ['microsoft365', 'security']
+    }, {
+        option: '-m, --mailNickname [mailNickname]'
+    }, {
+        option: '--ownerIds [ownerIds]'
+    }, {
+        option: '--ownerUserNames [ownerUserNames]'
+    }, {
+        option: '--memberIds [memberIds]'
+    }, {
+        option: '--memberUserNames [memberUserNames]'
+    }, {
+        option: '--visibility [visibility]',
+        autocomplete: ['Public', 'Private', 'HiddenMembership']
+    });
+}, _EntraGroupAddCommand_initValidators = function _EntraGroupAddCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.displayName.length > 256) {
+            return `The maximum amount of characters for 'displayName' is 256.`;
+        }
+        if (args.options.mailNickname) {
+            if (!validation.isValidMailNickname(args.options.mailNickname)) {
+                return `Value for option 'mailNickname' must contain only characters in the ASCII character set 0-127 except the following: @ () \ [] " ; : <> , SPACE.`;
+            }
+            if (args.options.mailNickname.length > 64) {
+                return `The maximum amount of characters for 'mailNickname' is 64.`;
+            }
+        }
+        if (args.options.ownerIds) {
+            const ids = args.options.ownerIds.split(',').map(i => i.trim());
+            if (!validation.isValidGuidArray(ids)) {
+                const invalidGuid = ids.find(id => !validation.isValidGuid(id));
+                return `'${invalidGuid}' is not a valid GUID for option 'ownerIds'.`;
+            }
+        }
+        if (args.options.ownerUserNames) {
+            const isValidUserPrincipalNameArray = validation.isValidUserPrincipalNameArray(args.options.ownerUserNames.split(',').map(u => u.trim()));
+            if (isValidUserPrincipalNameArray !== true) {
+                return `User principal name '${isValidUserPrincipalNameArray}' is invalid for option 'ownerUserNames'.`;
+            }
+        }
+        if (args.options.memberIds) {
+            const ids = args.options.memberIds.split(',').map(i => i.trim());
+            if (!validation.isValidGuidArray(ids)) {
+                const invalidGuid = ids.find(id => !validation.isValidGuid(id));
+                return `'${invalidGuid}' is not a valid GUID for option 'memberIds'.`;
+            }
+        }
+        if (args.options.memberUserNames) {
+            const isValidUserPrincipalNameArray = validation.isValidUserPrincipalNameArray(args.options.memberUserNames.split(',').map(u => u.trim()));
+            if (isValidUserPrincipalNameArray !== true) {
+                return `User principal name '${isValidUserPrincipalNameArray}' is invalid for option 'memberUserNames'.`;
+            }
+        }
+        if (['microsoft365', 'security'].indexOf(args.options.type) === -1) {
+            return `Option 'type' must be one of the following values: microsoft365, security.`;
+        }
+        if (args.options.type === 'microsoft365' && !args.options.visibility) {
+            return `Option 'visibility' must be specified if the option 'type' is set to microsoft365`;
+        }
+        if (args.options.visibility && ['Public', 'Private', 'HiddenMembership'].indexOf(args.options.visibility) === -1) {
+            return `Option 'visibility' must be one of the following values: Public, Private, HiddenMembership.`;
+        }
+        return true;
+    });
+}, _EntraGroupAddCommand_initTelemetry = function _EntraGroupAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            displayName: typeof args.options.displayName !== 'undefined',
+            description: typeof args.options.description !== 'undefined',
+            type: typeof args.options.type !== 'undefined',
+            mailNickname: typeof args.options.mailNickname !== 'undefined',
+            ownerIds: typeof args.options.ownerIds !== 'undefined',
+            ownerUserNames: typeof args.options.ownerUserNames !== 'undefined',
+            memberIds: typeof args.options.memberIds !== 'undefined',
+            memberUserNames: typeof args.options.memberUserNames !== 'undefined',
+            visibility: typeof args.options.visibility !== 'undefined'
+        });
+    });
+};
+export default new EntraGroupAddCommand();
+//# sourceMappingURL=group-add.js.map

package/dist/m365/entra/commands/m365group/m365group-report-activitygroupcounts.js

@@ -6,7 +6,7 @@ class M365GroupReportActivityGroupCountsCommand extends PeriodBasedReport {
         return commands.M365GROUP_REPORT_ACTIVITYGROUPCOUNTS;
     }
     get description() {
-        return 'Get the daily total number of groups and how many of them were active based on email conversations, Yammer posts, and SharePoint file activities';
+        return 'Get the daily total number of groups and how many of them were active based on email conversations, Viva Engage posts, and SharePoint file activities';
     }
     alias() {
         return [aadCommands.M365GROUP_REPORT_ACTIVITYGROUPCOUNTS];

package/dist/m365/entra/commands/user/user-get.js

@@ -5,12 +5,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _EntraUserGetCommand_instances, _EntraUserGetCommand_initTelemetry, _EntraUserGetCommand_initOptions, _EntraUserGetCommand_initValidators, _EntraUserGetCommand_initOptionSets;
 import request from '../../../../request.js';
-import { formatting } from '../../../../utils/formatting.js';
 import { validation } from '../../../../utils/validation.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
-import { cli } from '../../../../cli/cli.js';
 import aadCommands from '../../aadCommands.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { formatting } from '../../../../utils/formatting.js';
 class EntraUserGetCommand extends GraphCommand {
     get name() {
         return commands.USER_GET;
@@ -30,50 +30,50 @@ class EntraUserGetCommand extends GraphCommand {
         __classPrivateFieldGet(this, _EntraUserGetCommand_instances, "m", _EntraUserGetCommand_initOptionSets).call(this);
     }
     async commandAction(logger, args) {
-        const properties = args.options.properties ?
-            `&$select=${args.options.properties.split(',').map(p => formatting.encodeQueryParameter(p.trim())).join(',')}` :
-            '';
-        let requestUrl = `${this.resource}/v1.0/users`;
-        if (args.options.id) {
-            requestUrl += `?$filter=id eq '${formatting.encodeQueryParameter(args.options.id)}'${properties}`;
-        }
-        else if (args.options.userName) {
-            requestUrl += `?$filter=userPrincipalName eq '${formatting.encodeQueryParameter(args.options.userName)}'${properties}`;
-        }
-        else if (args.options.email) {
-            requestUrl += `?$filter=mail eq '${formatting.encodeQueryParameter(args.options.email)}'${properties}`;
-        }
-        if (args.options.withManager) {
-            requestUrl += '&$expand=manager($select=displayName,userPrincipalName,id,mail)';
-        }
-        const requestOptions = {
-            url: requestUrl,
-            headers: {
-                accept: 'application/json;odata.metadata=none'
-            },
-            responseType: 'json'
-        };
         try {
-            const res = await request.get(requestOptions);
-            const identifier = args.options.id ? `id ${args.options.id}`
-                : args.options.userName ? `user name ${args.options.userName}`
-                    : `email ${args.options.email}`;
-            if (res.value.length === 0) {
-                throw `The specified user with ${identifier} does not exist`;
+            let userIdOrPrincipalName = args.options.id;
+            if (args.options.userName) {
+                // single user can be retrieved also by user principal name
+                userIdOrPrincipalName = formatting.encodeQueryParameter(args.options.userName);
             }
-            if (res.value.length > 1) {
-                const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', res.value);
-                const result = await cli.handleMultipleResultsFound(`Multiple users with ${identifier} found.`, resultAsKeyValuePair);
-                await logger.log(result);
-            }
-            else {
-                await logger.log(res.value[0]);
+            else if (args.options.email) {
+                userIdOrPrincipalName = await entraUser.getUserIdByEmail(args.options.email);
             }
+            const requestUrl = this.getRequestUrl(userIdOrPrincipalName, args.options);
+            const requestOptions = {
+                url: requestUrl,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            const user = await request.get(requestOptions);
+            await logger.log(user);
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);
         }
     }
+    getRequestUrl(userIdOrPrincipalName, options) {
+        const queryParameters = [];
+        if (options.properties) {
+            const allProperties = options.properties.split(',');
+            const selectProperties = allProperties.filter(prop => !prop.includes('/'));
+            if (selectProperties.length > 0) {
+                queryParameters.push(`$select=${selectProperties}`);
+            }
+        }
+        if (options.withManager) {
+            queryParameters.push('$expand=manager($select=displayName,userPrincipalName,id,mail)');
+        }
+        const queryString = queryParameters.length > 0
+            ? `?${queryParameters.join('&')}`
+            : '';
+        // user principal name can start with $ but it violates the OData URL convention, so it must be enclosed in parenthesis and single quotes
+        return userIdOrPrincipalName.startsWith('%24')
+            ? `${this.resource}/v1.0/users('${userIdOrPrincipalName}')${queryString}`
+            : `${this.resource}/v1.0/users/${userIdOrPrincipalName}${queryString}`;
+    }
 }
 _EntraUserGetCommand_instances = new WeakSet(), _EntraUserGetCommand_initTelemetry = function _EntraUserGetCommand_initTelemetry() {
     this.telemetry.push((args) => {

package/dist/m365/entra/commands/user/user-license-list.js

@@ -33,7 +33,7 @@ class EntraUserLicenseListCommand extends GraphCommand {
         __classPrivateFieldGet(this, _EntraUserLicenseListCommand_instances, "m", _EntraUserLicenseListCommand_initOptionSets).call(this);
     }
     async commandAction(logger, args) {
-        const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.service.accessTokens[this.resource].accessToken);
+        const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[this.resource].accessToken);
         if (isAppOnlyAccessToken && !args.options.userId && !args.options.userName) {
             this.handleError(`Specify at least 'userId' or 'userName' when using application permissions.`);
         }

package/dist/m365/entra/commands/user/user-registrationdetails-list.js

@@ -0,0 +1,224 @@
+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 _EntraUserRegistrationDetailsListCommand_instances, _EntraUserRegistrationDetailsListCommand_initTelemetry, _EntraUserRegistrationDetailsListCommand_initOptions, _EntraUserRegistrationDetailsListCommand_initValidators;
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import aadCommands from '../../aadCommands.js';
+import { odata } from '../../../../utils/odata.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { validation } from '../../../../utils/validation.js';
+import { formatting } from '../../../../utils/formatting.js';
+const authenticationMethods = ['push', 'oath', 'voiceMobile', 'voiceAlternateMobile', 'voiceOffice', 'sms', 'none'];
+const methodsRegistered = ['mobilePhone', 'email', 'fido2', 'microsoftAuthenticatorPush', 'softwareOneTimePasscode'];
+class EntraUserRegistrationDetailsListCommand extends GraphCommand {
+    get name() {
+        return commands.USER_REGISTRATIONDETAILS_LIST;
+    }
+    get description() {
+        return 'Retrieves a list of the authentication methods registered for users';
+    }
+    alias() {
+        return [aadCommands.USER_REGISTRATIONDETAILS_LIST];
+    }
+    defaultProperties() {
+        return ['userPrincipalName', 'methodsRegistered', 'lastUpdatedDateTime'];
+    }
+    constructor() {
+        super();
+        _EntraUserRegistrationDetailsListCommand_instances.add(this);
+        __classPrivateFieldGet(this, _EntraUserRegistrationDetailsListCommand_instances, "m", _EntraUserRegistrationDetailsListCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _EntraUserRegistrationDetailsListCommand_instances, "m", _EntraUserRegistrationDetailsListCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _EntraUserRegistrationDetailsListCommand_instances, "m", _EntraUserRegistrationDetailsListCommand_initValidators).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            let userUpns = [];
+            if (args.options.userIds) {
+                const ids = args.options.userIds.split(',').map(m => m.trim());
+                userUpns = await Promise.all(ids.map(id => entraUser.getUpnByUserId(id)));
+            }
+            const requestUrl = this.getRequestUrl(args.options, userUpns);
+            const result = await odata.getAllItems(requestUrl);
+            await logger.log(result);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    getRequestUrl(options, userUpns) {
+        const queryParameters = [];
+        if (options.properties) {
+            queryParameters.push(`$select=${options.properties}`);
+        }
+        const filters = [];
+        if (options.isAdmin !== undefined) {
+            filters.push(`isAdmin eq ${options.isAdmin}`);
+        }
+        if (options.isMfaCapable !== undefined) {
+            filters.push(`isMfaCapable eq ${options.isMfaCapable}`);
+        }
+        if (options.isMfaRegistered !== undefined) {
+            filters.push(`isMfaRegistered eq ${options.isMfaRegistered}`);
+        }
+        if (options.isPasswordlessCapable !== undefined) {
+            filters.push(`isPasswordlessCapable eq ${options.isPasswordlessCapable}`);
+        }
+        if (options.isSelfServicePasswordResetCapable !== undefined) {
+            filters.push(`isSelfServicePasswordResetCapable eq ${options.isSelfServicePasswordResetCapable}`);
+        }
+        if (options.isSelfServicePasswordResetEnabled !== undefined) {
+            filters.push(`isSelfServicePasswordResetEnabled eq ${options.isSelfServicePasswordResetEnabled}`);
+        }
+        if (options.isSelfServicePasswordResetRegistered !== undefined) {
+            filters.push(`isSelfServicePasswordResetRegistered eq ${options.isSelfServicePasswordResetRegistered}`);
+        }
+        if (options.isSystemPreferredAuthenticationMethodEnabled !== undefined) {
+            filters.push(`isSystemPreferredAuthenticationMethodEnabled eq ${options.isSystemPreferredAuthenticationMethodEnabled}`);
+        }
+        const methodsRegistered = options.methodsRegistered?.split(',').map(method => `methodsRegistered/any(m:m eq '${method.trim()}')`);
+        const methodsRegisteredFilter = methodsRegistered?.join(' or ');
+        if (methodsRegisteredFilter) {
+            filters.push(`(${methodsRegisteredFilter})`);
+        }
+        const systemPreferredAuthenticationMethods = options.systemPreferredAuthenticationMethods?.split(',').map(method => `systemPreferredAuthenticationMethods/any(m:m eq '${method.trim()}')`);
+        const systemPreferredAuthenticationMethodsFilter = systemPreferredAuthenticationMethods?.join(' or ');
+        if (systemPreferredAuthenticationMethodsFilter) {
+            filters.push(`(${systemPreferredAuthenticationMethodsFilter})`);
+        }
+        const userUPNs = [];
+        if (userUpns.length > 0) {
+            userUpns.forEach(upn => {
+                userUPNs.push(`userPrincipalName eq '${formatting.encodeQueryParameter(upn)}'`);
+            });
+        }
+        if (options.userPrincipalNames) {
+            const upns = options.userPrincipalNames.split(',').map(m => m.trim());
+            upns.forEach(upn => {
+                userUPNs.push(`userPrincipalName eq '${formatting.encodeQueryParameter(upn)}'`);
+            });
+        }
+        if (userUPNs.length > 0) {
+            filters.push(`(${userUPNs.join(' or ')})`);
+        }
+        const userPreferredMethodForSecondaryAuthentication = options.userPreferredMethodForSecondaryAuthentication?.split(',').map(method => `userPreferredMethodForSecondaryAuthentication eq '${method.trim()}'`);
+        const userPreferredMethodForSecondaryAuthenticationFilter = userPreferredMethodForSecondaryAuthentication?.join(' or ');
+        if (userPreferredMethodForSecondaryAuthenticationFilter) {
+            filters.push(`(${userPreferredMethodForSecondaryAuthenticationFilter})`);
+        }
+        if (options.userType) {
+            filters.push(`userType eq '${options.userType}'`);
+        }
+        if (filters.length > 0) {
+            queryParameters.push(`$filter=${filters.join(' and ')}`);
+        }
+        const queryString = queryParameters.length > 0
+            ? `?${queryParameters.join('&')}`
+            : '';
+        return `${this.resource}/v1.0/reports/authenticationMethods/userRegistrationDetails${queryString}`;
+    }
+}
+_EntraUserRegistrationDetailsListCommand_instances = new WeakSet(), _EntraUserRegistrationDetailsListCommand_initTelemetry = function _EntraUserRegistrationDetailsListCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            isAdmin: !!args.options.isAdmin,
+            userType: typeof args.options.userType !== 'undefined',
+            userPreferredMethodForSecondaryAuthentication: typeof args.options.userPreferredMethodForSecondaryAuthentication !== 'undefined',
+            systemPreferredAuthenticationMethods: typeof args.options.systemPreferredAuthenticationMethods !== 'undefined',
+            isSelfServicePasswordResetRegistered: !!args.options.isSelfServicePasswordResetRegistered,
+            isSelfServicePasswordResetEnabled: !!args.options.isSelfServicePasswordResetEnabled,
+            isSelfServicePasswordResetCapable: !!args.options.isSelfServicePasswordResetCapable,
+            isMfaRegistered: !!args.options.isMfaRegistered,
+            isMfaCapable: !!args.options.isMfaCapable,
+            isPasswordlessCapable: !!args.options.isPasswordlessCapable,
+            isSystemPreferredAuthenticationMethodEnabled: !!args.options.isSystemPreferredAuthenticationMethodEnabled,
+            methodsRegistered: typeof args.options.methodsRegistered !== 'undefined',
+            userIds: typeof args.options.userIds !== 'undefined',
+            userPrincipalNames: typeof args.options.userPrincipalNames !== 'undefined',
+            properties: typeof args.options.properties !== 'undefined'
+        });
+    });
+}, _EntraUserRegistrationDetailsListCommand_initOptions = function _EntraUserRegistrationDetailsListCommand_initOptions() {
+    this.options.unshift({
+        option: '--isAdmin [isAdmin]'
+    }, {
+        option: '--userType [userType]',
+        autocomplete: ['member', 'guest']
+    }, {
+        option: '--userPreferredMethodForSecondaryAuthentication [userPreferredMethodForSecondaryAuthentication ]',
+        autocomplete: authenticationMethods
+    }, {
+        option: '--systemPreferredAuthenticationMethods [systemPreferredAuthenticationMethods ]',
+        autocomplete: authenticationMethods
+    }, {
+        option: '--isSelfServicePasswordResetRegistered [isSelfServicePasswordResetRegistered]'
+    }, {
+        option: '--isSelfServicePasswordResetEnabled [isSelfServicePasswordResetEnabled]'
+    }, {
+        option: '--isSelfServicePasswordResetCapable [isSelfServicePasswordResetCapable]'
+    }, {
+        option: '--isMfaRegistered [isMfaRegistered]'
+    }, {
+        option: '--isMfaCapable [isMfaCapable]'
+    }, {
+        option: '--isPasswordlessCapable [isPasswordlessCapable]'
+    }, {
+        option: '--isSystemPreferredAuthenticationMethodEnabled [isSystemPreferredAuthenticationMethodEnabled]'
+    }, {
+        option: '--methodsRegistered [methodsRegistered]',
+        autocomplete: methodsRegistered
+    }, {
+        option: '--userIds [userIds]'
+    }, {
+        option: '--userPrincipalNames [userPrincipalNames]'
+    }, {
+        option: '-p, --properties [properties]'
+    });
+}, _EntraUserRegistrationDetailsListCommand_initValidators = function _EntraUserRegistrationDetailsListCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.userType) {
+            if (['member', 'guest'].every(type => type !== args.options.userType)) {
+                return `'${args.options.userType}' is not a valid userType value. Allowed values member, guest`;
+            }
+        }
+        if (args.options.userPreferredMethodForSecondaryAuthentication) {
+            const methods = args.options.userPreferredMethodForSecondaryAuthentication.split(',').map(m => m.trim());
+            const invalidMethods = methods.filter(m => !authenticationMethods.includes(m));
+            if (invalidMethods.length > 0) {
+                return `'${args.options.userPreferredMethodForSecondaryAuthentication}' is not a valid userPreferredMethodForSecondaryAuthentication value. Invalid values: ${invalidMethods.join(',')}. Allowed values ${authenticationMethods.join(', ')}`;
+            }
+        }
+        if (args.options.systemPreferredAuthenticationMethods) {
+            const methods = args.options.systemPreferredAuthenticationMethods.split(',').map(m => m.trim());
+            const invalidMethods = methods.filter(m => !authenticationMethods.includes(m));
+            if (invalidMethods.length > 0) {
+                return `'${args.options.systemPreferredAuthenticationMethods}' is not a valid systemPreferredAuthenticationMethods value. Invalid values: ${invalidMethods.join(',')}. Allowed values ${authenticationMethods.join(', ')}`;
+            }
+        }
+        if (args.options.methodsRegistered) {
+            const methods = args.options.methodsRegistered.split(',').map(m => m.trim());
+            const invalidMethods = methods.filter(m => !methodsRegistered.includes(m));
+            if (invalidMethods.length > 0) {
+                return `'${args.options.methodsRegistered}' is not a valid methodsRegistered value. Invalid values: ${invalidMethods.join(',')}. Allowed values ${methodsRegistered.join(', ')}`;
+            }
+        }
+        if (args.options.userIds) {
+            const ids = args.options.userIds.split(',').map(i => i.trim());
+            if (!validation.isValidGuidArray(ids)) {
+                const invalidGuid = ids.find(id => !validation.isValidGuid(id));
+                return `'${invalidGuid}' is not a valid GUID for option 'userIds'.`;
+            }
+        }
+        if (args.options.userPrincipalNames) {
+            const isValidUserPrincipalNameArray = validation.isValidUserPrincipalNameArray(args.options.userPrincipalNames.split(',').map(u => u.trim()));
+            if (isValidUserPrincipalNameArray !== true) {
+                return `User principal name '${isValidUserPrincipalNameArray}' is invalid for option 'userPrincipalNames'.`;
+            }
+        }
+        return true;
+    });
+};
+export default new EntraUserRegistrationDetailsListCommand();
+//# sourceMappingURL=user-registrationdetails-list.js.map

package/dist/m365/entra/commands/user/user-set.js

@@ -37,10 +37,10 @@ class EntraUserSetCommand extends GraphCommand {
     async commandAction(logger, args) {
         try {
             if (args.options.currentPassword) {
-                if (args.options.id && args.options.id !== accessToken.getUserIdFromAccessToken(auth.service.accessTokens[auth.defaultResource].accessToken)) {
+                if (args.options.id && args.options.id !== accessToken.getUserIdFromAccessToken(auth.connection.accessTokens[auth.defaultResource].accessToken)) {
                     throw `You can only change your own password. Please use --id @meId to reference to your own userId`;
                 }
-                else if (args.options.userName && args.options.userName.toLowerCase() !== accessToken.getUserNameFromAccessToken(auth.service.accessTokens[auth.defaultResource].accessToken).toLowerCase()) {
+                else if (args.options.userName && args.options.userName.toLowerCase() !== accessToken.getUserNameFromAccessToken(auth.connection.accessTokens[auth.defaultResource].accessToken).toLowerCase()) {
                     throw 'You can only change your own password. Please use --userName @meUserName to reference to your own user principal name';
                 }
             }