@pnp/cli-microsoft365 7.9.0-beta.d3d4146 → 7.10.0-beta.0d80e6e

package/dist/m365/base/DelegatedGraphCommand.js

@@ -0,0 +1,17 @@
+import auth from '../../Auth.js';
+import { accessToken } from '../../utils/accessToken.js';
+import GraphCommand from './GraphCommand.js';
+/**
+ * This command class is for delegated-only Graph commands.
+ */
+export default class DelegatedGraphCommand extends GraphCommand {
+    initAction(args, logger) {
+        super.initAction(args, logger);
+        if (!auth.connection.active) {
+            // we fail no login in the base command command class
+            return;
+        }
+        accessToken.assertDelegatedAccessToken();
+    }
+}
+//# sourceMappingURL=DelegatedGraphCommand.js.map

package/dist/m365/base/PowerAppsCommand.js

@@ -1,5 +1,6 @@
 import auth, { CloudType } from '../../Auth.js';
 import Command, { CommandError } from '../../Command.js';
+import { accessToken } from '../../utils/accessToken.js';
 export default class PowerAppsCommand extends Command {
     get resource() {
         return 'https://api.powerapps.com';
@@ -13,6 +14,7 @@ export default class PowerAppsCommand extends Command {
         if (auth.connection.cloudType !== CloudType.Public) {
             throw new CommandError(`Power Apps commands only support the public cloud at the moment. We'll add support for other clouds in the future. Sorry for the inconvenience.`);
         }
+        accessToken.assertDelegatedAccessToken();
     }
 }
 //# sourceMappingURL=PowerAppsCommand.js.map

package/dist/m365/base/PowerAutomateCommand.js

@@ -1,5 +1,6 @@
 import auth, { CloudType } from '../../Auth.js';
 import Command, { CommandError } from '../../Command.js';
+import { accessToken } from '../../utils/accessToken.js';
 export default class PowerAutomateCommand extends Command {
     get resource() {
         return 'https://api.flow.microsoft.com';
@@ -13,6 +14,7 @@ export default class PowerAutomateCommand extends Command {
         if (auth.connection.cloudType !== CloudType.Public) {
             throw new CommandError(`Power Automate commands only support the public cloud at the moment. We'll add support for other clouds in the future. Sorry for the inconvenience.`);
         }
+        accessToken.assertDelegatedAccessToken();
     }
 }
 //# sourceMappingURL=PowerAutomateCommand.js.map

package/dist/m365/base/PowerBICommand.js

@@ -1,7 +1,17 @@
 import Command from '../../Command.js';
+import auth from '../../Auth.js';
+import { accessToken } from '../../utils/accessToken.js';
 export default class PowerBICommand extends Command {
     get resource() {
         return 'https://api.powerbi.com';
     }
+    initAction(args, logger) {
+        super.initAction(args, logger);
+        if (!auth.connection.active) {
+            // we fail no login in the base command command class
+            return;
+        }
+        accessToken.assertDelegatedAccessToken();
+    }
 }
 //# sourceMappingURL=PowerBICommand.js.map

package/dist/m365/base/PowerPlatformCommand.js

@@ -1,5 +1,6 @@
 import auth, { CloudType } from '../../Auth.js';
 import Command, { CommandError } from '../../Command.js';
+import { accessToken } from '../../utils/accessToken.js';
 export default class PowerPlatformCommand extends Command {
     get resource() {
         return 'https://api.bap.microsoft.com';
@@ -13,6 +14,7 @@ export default class PowerPlatformCommand extends Command {
         if (auth.connection.cloudType !== CloudType.Public) {
             throw new CommandError(`Power Platform commands only support the public cloud at the moment. We'll add support for other clouds in the future. Sorry for the inconvenience.`);
         }
+        accessToken.assertDelegatedAccessToken();
     }
 }
 //# sourceMappingURL=PowerPlatformCommand.js.map

package/dist/m365/base/VivaEngageCommand.js

@@ -1,8 +1,18 @@
 import Command, { CommandError } from "../../Command.js";
+import auth from "../../Auth.js";
+import { accessToken } from "../../utils/accessToken.js";
 export default class VivaEngageCommand extends Command {
     get resource() {
         return 'https://www.yammer.com/api';
     }
+    initAction(args, logger) {
+        super.initAction(args, logger);
+        if (!auth.connection.active) {
+            // we fail no login in the base command command class
+            return;
+        }
+        accessToken.assertDelegatedAccessToken();
+    }
     handleRejectedODataJsonPromise(response) {
         if (response.statusCode === 404) {
             throw new CommandError("Not found (404)");

package/dist/m365/commands/commands.js

@@ -3,6 +3,7 @@ export default {
     LOGIN: `login`,
     LOGOUT: `logout`,
     REQUEST: `request`,
+    SEARCH: `search`,
     SETUP: `setup`,
     STATUS: `status`,
     VERSION: 'version'

package/dist/m365/commands/search.js

@@ -0,0 +1,176 @@
+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 _SearchCommand_instances, _SearchCommand_initTelemetry, _SearchCommand_initOptions, _SearchCommand_initValidators;
+import request from '../../request.js';
+import GraphCommand from '../base/GraphCommand.js';
+import commands from './commands.js';
+class SearchCommand extends GraphCommand {
+    get name() {
+        return commands.SEARCH;
+    }
+    get description() {
+        return 'Uses the Microsoft Search to query Microsoft 365 data';
+    }
+    constructor() {
+        super();
+        _SearchCommand_instances.add(this);
+        this.allowedScopes = ['chatMessage', 'message', 'event', 'drive', 'driveItem', 'list', 'listItem', 'site', 'bookmark', 'acronym', 'person'];
+        __classPrivateFieldGet(this, _SearchCommand_instances, "m", _SearchCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SearchCommand_instances, "m", _SearchCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SearchCommand_instances, "m", _SearchCommand_initValidators).call(this);
+    }
+    async commandAction(logger, args) {
+        let result;
+        const searchHits = [];
+        try {
+            let allResults = args.options.allResults ? args.options.allResults : false;
+            let startIndex = args.options.startIndex ? args.options.startIndex : 0;
+            const pageSize = args.options.pageSize ? args.options.pageSize : 25;
+            do {
+                const requestOptions = {
+                    url: `${this.resource}/v1.0/search/query`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json',
+                    data: {
+                        requests: [
+                            {
+                                "entityTypes": args.options.scopes.split(',').map(scope => scope.trim()),
+                                "query": {
+                                    "queryString": args.options.queryText ?? '*'
+                                },
+                                "enableTopResults": args.options.enableTopResults,
+                                "from": startIndex,
+                                "size": pageSize,
+                                "fields": this.getProperties(args.options),
+                                "sortProperties": this.getSortProperties(args.options),
+                                "queryAlterationOptions": {
+                                    "enableModification": args.options.enableSpellingModification,
+                                    "enableSuggestion": args.options.enableSpellingSuggestion
+                                }
+                            }
+                        ]
+                    }
+                };
+                const response = await request.post(requestOptions);
+                result = response.value[0];
+                if (allResults && result.hitsContainers) {
+                    allResults = result.hitsContainers[0].moreResultsAvailable;
+                }
+                if (allResults) {
+                    startIndex += pageSize;
+                }
+                if (result.hitsContainers && result.hitsContainers[0].hits) {
+                    searchHits.push(...result.hitsContainers[0].hits);
+                }
+            } while (allResults);
+            if (args.options.resultsOnly) {
+                await logger.log(searchHits);
+            }
+            else {
+                if (result.hitsContainers && result.hitsContainers[0].hits) {
+                    result.hitsContainers[0].hits = searchHits;
+                }
+                await logger.log(result);
+            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    getProperties(options) {
+        if (!options.select) {
+            return undefined;
+        }
+        return options.select.split(',').map(prop => prop.trim());
+    }
+    getSortProperties(options) {
+        if (!options.sortBy) {
+            return undefined;
+        }
+        const properties = options.sortBy.split(',').map(prop => prop.trim()).map(property => {
+            const sortDefinitions = property.split(':');
+            const name = sortDefinitions[0];
+            let isDescending = false;
+            if (sortDefinitions.length === 2) {
+                const order = sortDefinitions[1].trim();
+                isDescending = order === 'desc';
+            }
+            return {
+                "name": name,
+                "isDescending": isDescending
+            };
+        });
+        return properties;
+    }
+}
+_SearchCommand_instances = new WeakSet(), _SearchCommand_initTelemetry = function _SearchCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            queryText: typeof args.options.queryText !== 'undefined',
+            startIndex: typeof args.options.startIndex !== 'undefined',
+            pageSize: typeof args.options.pageSize !== 'undefined',
+            allResults: !!args.options.allResults,
+            resultsOnly: !!args.options.resultsOnly,
+            enableTopResults: !!args.options.enableTopResults,
+            select: typeof args.options.select !== 'undefined',
+            sortBy: typeof args.options.sortBy !== 'undefined',
+            enableSpellingSuggestion: !!args.options.enableSpellingSuggestion,
+            enableSpellingModification: !!args.options.enableSpellingModification
+        });
+    });
+}, _SearchCommand_initOptions = function _SearchCommand_initOptions() {
+    this.options.unshift({
+        option: '-q, --queryText [queryText]'
+    }, {
+        option: '-s, --scopes <scopes>',
+        autocomplete: this.allowedScopes
+    }, {
+        option: '--startIndex [startIndex]'
+    }, {
+        option: '--pageSize [pageSize]'
+    }, {
+        option: '--allResults'
+    }, {
+        option: '--resultsOnly'
+    }, {
+        option: '--enableTopResults'
+    }, {
+        option: '--select [select]'
+    }, {
+        option: '--sortBy [sortBy]'
+    }, {
+        option: '--enableSpellingSuggestion'
+    }, {
+        option: '--enableSpellingModification'
+    });
+}, _SearchCommand_initValidators = function _SearchCommand_initValidators() {
+    this.validators.push(async (args) => {
+        const scopes = args.options.scopes.split(',').map(x => x.trim());
+        if (!scopes.every(scope => this.allowedScopes.indexOf(scope) > -1)) {
+            const invalidScope = scopes.find(scope => this.allowedScopes.indexOf(scope) === -1);
+            return `'${invalidScope}'' is not a valid scope. Allowed scopes are ${this.allowedScopes.join(', ')}.`;
+        }
+        if (args.options.startIndex !== undefined && args.options.startIndex < 0) {
+            return `'${args.options.startIndex}' is not a valid value for option 'startIndex'. Start index must be greater or equal to 0.`;
+        }
+        if (args.options.pageSize !== undefined && (args.options.pageSize < 1 || args.options.pageSize > 500)) {
+            return `'${args.options.pageSize}' is not a valid value for option 'pageSize'. Page size must be between 1 and 500.`;
+        }
+        if (args.options.sortBy && scopes.some(scope => scope === 'message' || scope === 'event')) {
+            return 'Sorting the results is not supported for messages and events.';
+        }
+        if (args.options.enableTopResults &&
+            ((scopes.length === 1 && scopes.indexOf('message') === -1 && scopes.indexOf('chatMessage') === -1) ||
+                (scopes.length === 2) && !(scopes.indexOf('message') > -1 && scopes.indexOf('chatMessage') > -1))) {
+            return 'Top results are only supported for messages and chat messages.';
+        }
+        return true;
+    });
+};
+export default new SearchCommand();
+//# sourceMappingURL=search.js.map

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

@@ -0,0 +1,206 @@
+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 _EntraGroupUserSetCommand_instances, _EntraGroupUserSetCommand_initTelemetry, _EntraGroupUserSetCommand_initOptions, _EntraGroupUserSetCommand_initValidators, _EntraGroupUserSetCommand_initOptionSets, _EntraGroupUserSetCommand_initTypes;
+import request from '../../../../request.js';
+import { entraGroup } from '../../../../utils/entraGroup.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { validation } from '../../../../utils/validation.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class EntraGroupUserSetCommand extends GraphCommand {
+    get name() {
+        return commands.GROUP_USER_SET;
+    }
+    get description() {
+        return 'Updates role of users in a Microsoft Entra ID group';
+    }
+    constructor() {
+        super();
+        _EntraGroupUserSetCommand_instances.add(this);
+        this.roleValues = ['Owner', 'Member'];
+        __classPrivateFieldGet(this, _EntraGroupUserSetCommand_instances, "m", _EntraGroupUserSetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _EntraGroupUserSetCommand_instances, "m", _EntraGroupUserSetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _EntraGroupUserSetCommand_instances, "m", _EntraGroupUserSetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _EntraGroupUserSetCommand_instances, "m", _EntraGroupUserSetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _EntraGroupUserSetCommand_instances, "m", _EntraGroupUserSetCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            if (this.verbose) {
+                await logger.logToStderr(`Adding user(s) ${args.options.ids || args.options.userNames} to group ${args.options.groupId || args.options.groupDisplayName}...`);
+            }
+            const groupId = await this.getGroupId(logger, args.options);
+            const userIds = await this.getUserIds(logger, args.options);
+            // we can't simply switch the role
+            // first add users to the new role
+            await this.addUsers(groupId, userIds, args.options);
+            // remove users from the old role
+            await this.removeUsersFromRole(logger, groupId, userIds, args.options);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getGroupId(logger, options) {
+        if (options.groupId) {
+            return options.groupId;
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Retrieving ID of group ${options.groupDisplayName}...`);
+        }
+        return entraGroup.getGroupIdByDisplayName(options.groupDisplayName);
+    }
+    async getUserIds(logger, options) {
+        if (options.ids) {
+            return options.ids.split(',').map(i => i.trim());
+        }
+        if (this.verbose) {
+            await logger.logToStderr('Retrieving ID(s) of user(s)...');
+        }
+        return entraUser.getUserIdsByUpns(options.userNames.split(',').map(u => u.trim()));
+    }
+    async removeUsersFromRole(logger, groupId, userIds, options) {
+        const userIdsToRemove = [];
+        const currentRole = options.role === 'Member' ? 'owners' : 'members';
+        if (this.verbose) {
+            await logger.logToStderr(`Removing users from the old role '${currentRole}'.`);
+        }
+        for (let i = 0; i < userIds.length; i += 20) {
+            const userIdsBatch = userIds.slice(i, i + 20);
+            const requestOptions = this.getRequestOptions();
+            userIdsBatch.map(userId => {
+                requestOptions.data.requests.push({
+                    id: userId,
+                    method: 'GET',
+                    url: `/groups/${groupId}/${currentRole}/$count?$filter=id eq '${userId}'`,
+                    headers: {
+                        'ConsistencyLevel': 'eventual'
+                    }
+                });
+            });
+            // send batch request
+            const res = await request.post(requestOptions);
+            for (const response of res.responses) {
+                if (response.status === 200) {
+                    if (response.body === 1) {
+                        // user can be removed from current role
+                        userIdsToRemove.push(response.id);
+                    }
+                }
+                else {
+                    throw response.body;
+                }
+            }
+        }
+        for (let i = 0; i < userIdsToRemove.length; i += 20) {
+            const userIdsBatch = userIds.slice(i, i + 20);
+            const requestOptions = this.getRequestOptions();
+            userIdsBatch.map(userId => {
+                requestOptions.data.requests.push({
+                    id: userId,
+                    method: 'DELETE',
+                    url: `/groups/${groupId}/${currentRole}/${userId}/$ref`
+                });
+            });
+            const res = await request.post(requestOptions);
+            for (const response of res.responses) {
+                if (response.status !== 204) {
+                    throw response.body;
+                }
+            }
+        }
+    }
+    async addUsers(groupId, userIds, options) {
+        for (let i = 0; i < userIds.length; i += 400) {
+            const userIdsBatch = userIds.slice(i, i + 400);
+            const requestOptions = this.getRequestOptions();
+            for (let j = 0; j < userIdsBatch.length; j += 20) {
+                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: {
+                        [`${options.role === 'Member' ? 'members' : 'owners'}@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;
+                }
+            }
+        }
+    }
+    getRequestOptions() {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/$batch`,
+            headers: {
+                'content-type': 'application/json;odata.metadata=none'
+            },
+            responseType: 'json',
+            data: {
+                requests: []
+            }
+        };
+        return requestOptions;
+    }
+}
+_EntraGroupUserSetCommand_instances = new WeakSet(), _EntraGroupUserSetCommand_initTelemetry = function _EntraGroupUserSetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            groupId: typeof args.options.groupId !== 'undefined',
+            groupDisplayName: typeof args.options.groupDisplayName !== 'undefined',
+            ids: typeof args.options.ids !== 'undefined',
+            userNames: typeof args.options.userNames !== 'undefined'
+        });
+    });
+}, _EntraGroupUserSetCommand_initOptions = function _EntraGroupUserSetCommand_initOptions() {
+    this.options.unshift({
+        option: '-i, --groupId [groupId]'
+    }, {
+        option: '-n, --groupDisplayName [groupDisplayName]'
+    }, {
+        option: '--ids [ids]'
+    }, {
+        option: '--userNames [userNames]'
+    }, {
+        option: '-r, --role <role>',
+        autocomplete: this.roleValues
+    });
+}, _EntraGroupUserSetCommand_initValidators = function _EntraGroupUserSetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.groupId && !validation.isValidGuid(args.options.groupId)) {
+            return `${args.options.groupId} is not a valid GUID for option groupId.`;
+        }
+        if (args.options.ids) {
+            const isValidGUIDArrayResult = validation.isValidGuidArray(args.options.ids);
+            if (isValidGUIDArrayResult !== true) {
+                return `'${isValidGUIDArrayResult}' is not a valid GUID for option 'ids'.`;
+            }
+        }
+        if (args.options.userNames) {
+            const isValidUserPrincipalNameArray = validation.isValidUserPrincipalNameArray(args.options.userNames);
+            if (isValidUserPrincipalNameArray !== true) {
+                return `User principal name '${isValidUserPrincipalNameArray}' is invalid for option 'userNames'.`;
+            }
+        }
+        if (this.roleValues.indexOf(args.options.role) === -1) {
+            return `Option 'role' must be one of the following values: ${this.roleValues.join(', ')}.`;
+        }
+        return true;
+    });
+}, _EntraGroupUserSetCommand_initOptionSets = function _EntraGroupUserSetCommand_initOptionSets() {
+    this.optionSets.push({ options: ['groupId', 'groupDisplayName'] }, { options: ['ids', 'userNames'] });
+}, _EntraGroupUserSetCommand_initTypes = function _EntraGroupUserSetCommand_initTypes() {
+    this.types.string.push('groupId', 'groupDisplayName', 'ids', 'userNames', 'role');
+};
+export default new EntraGroupUserSetCommand();
+//# sourceMappingURL=group-user-set.js.map

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

@@ -0,0 +1,92 @@
+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 _EntraUserGroupmembershipListCommand_instances, _EntraUserGroupmembershipListCommand_initTelemetry, _EntraUserGroupmembershipListCommand_initOptions, _EntraUserGroupmembershipListCommand_initValidators, _EntraUserGroupmembershipListCommand_initOptionSets;
+import request from '../../../../request.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { validation } from '../../../../utils/validation.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class EntraUserGroupmembershipListCommand extends GraphCommand {
+    get name() {
+        return commands.USER_GROUPMEMBERSHIP_LIST;
+    }
+    get description() {
+        return 'Retrieves all groups where the user is a member of';
+    }
+    constructor() {
+        super();
+        _EntraUserGroupmembershipListCommand_instances.add(this);
+        __classPrivateFieldGet(this, _EntraUserGroupmembershipListCommand_instances, "m", _EntraUserGroupmembershipListCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _EntraUserGroupmembershipListCommand_instances, "m", _EntraUserGroupmembershipListCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _EntraUserGroupmembershipListCommand_instances, "m", _EntraUserGroupmembershipListCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _EntraUserGroupmembershipListCommand_instances, "m", _EntraUserGroupmembershipListCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        let userId = args.options.userId;
+        try {
+            if (args.options.userName) {
+                userId = await entraUser.getUserIdByUpn(args.options.userName);
+            }
+            else if (args.options.userEmail) {
+                userId = await entraUser.getUserIdByEmail(args.options.userEmail);
+            }
+            const requestOptions = {
+                url: `${this.resource}/v1.0/users/${userId}/getMemberGroups`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json',
+                data: {
+                    securityEnabledOnly: !!args.options.securityEnabledOnly
+                }
+            };
+            const groups = [];
+            const results = await request.post(requestOptions);
+            results.value.forEach(x => groups.push({ groupId: x }));
+            await logger.log(groups);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+}
+_EntraUserGroupmembershipListCommand_instances = new WeakSet(), _EntraUserGroupmembershipListCommand_initTelemetry = function _EntraUserGroupmembershipListCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            userId: typeof args.options.userId !== 'undefined',
+            userName: typeof args.options.userName !== 'undefined',
+            userEmail: typeof args.options.userEmail !== 'undefined',
+            securityEnabledOnly: !!args.options.securityEnabledOnly
+        });
+    });
+}, _EntraUserGroupmembershipListCommand_initOptions = function _EntraUserGroupmembershipListCommand_initOptions() {
+    this.options.unshift({
+        option: '-i, --userId [userId]'
+    }, {
+        option: '-n, --userName [userName]'
+    }, {
+        option: '-e, --userEmail [userEmail]'
+    }, {
+        option: '--securityEnabledOnly [securityEnabledOnly]'
+    });
+}, _EntraUserGroupmembershipListCommand_initValidators = function _EntraUserGroupmembershipListCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.userId && !validation.isValidGuid(args.options.userId)) {
+            return `${args.options.userId} is not a valid GUID`;
+        }
+        if (args.options.userName && !validation.isValidUserPrincipalName(args.options.userName)) {
+            return `${args.options.userName} is not a valid user principal name`;
+        }
+        if (args.options.userEmail && !validation.isValidUserPrincipalName(args.options.userEmail)) {
+            return `${args.options.userEmail} is not a valid user email`;
+        }
+        return true;
+    });
+}, _EntraUserGroupmembershipListCommand_initOptionSets = function _EntraUserGroupmembershipListCommand_initOptionSets() {
+    this.optionSets.push({ options: ['userId', 'userName', 'userEmail'] });
+};
+export default new EntraUserGroupmembershipListCommand();
+//# sourceMappingURL=user-groupmembership-list.js.map