@pnp/cli-microsoft365 9.0.0-beta.e69e8d0 → 10.0.0-beta.48e9f7d

package/dist/Command.js

@@ -111,9 +111,7 @@ class Command {
                 prompted = true;
                 await cli.error('🌶️  Provide values for the following parameters:');
             }
-            const answer = optionInfo.autocomplete !== undefined
-                ? await prompt.forSelection({ message: `${optionInfo.name}: `, choices: optionInfo.autocomplete.map((choice) => { return { name: choice, value: choice }; }) })
-                : await prompt.forInput({ message: `${optionInfo.name}: ` });
+            const answer = await cli.promptForValue(optionInfo);
             args.options[optionInfo.name] = answer;
         }
         if (prompted) {

package/dist/cli/cli.js

@@ -36,6 +36,14 @@ const defaultHelpMode = 'options';
 const defaultHelpTarget = 'console';
 const helpModes = ['options', 'examples', 'remarks', 'response', 'full'];
 const helpTargets = ['console', 'web'];
+const yargsConfiguration = {
+    'parse-numbers': true,
+    'strip-aliased': true,
+    'strip-dashed': true,
+    'dot-notation': false,
+    'boolean-negation': true,
+    'camel-case-expansion': false
+};
 function getConfig() {
     if (!_config) {
         _config = new Configstore(config.configstoreName);
@@ -129,14 +137,38 @@ async function execute(rawArgs) {
     }
     let finalArgs = cli.optionsFromArgs.options;
     if (cli.commandToExecute?.command.schema) {
-        const startValidation = process.hrtime.bigint();
-        const result = cli.commandToExecute.command.getSchemaToParse().safeParse(cli.optionsFromArgs.options);
-        const endValidation = process.hrtime.bigint();
-        timings.validation.push(Number(endValidation - startValidation));
-        if (!result.success) {
-            return cli.closeWithError(result.error, cli.optionsFromArgs, true);
+        while (true) {
+            const startValidation = process.hrtime.bigint();
+            const result = cli.commandToExecute.command.getSchemaToParse().safeParse(cli.optionsFromArgs.options);
+            const endValidation = process.hrtime.bigint();
+            timings.validation.push(Number(endValidation - startValidation));
+            if (result.success) {
+                finalArgs = result.data;
+                break;
+            }
+            else {
+                const hasNonRequiredErrors = result.error.errors.some(e => e.code !== 'invalid_type' || e.received !== 'undefined');
+                const shouldPrompt = cli.getSettingWithDefaultValue(settingsNames.prompt, true);
+                if (hasNonRequiredErrors === false &&
+                    shouldPrompt) {
+                    await cli.error('🌶️  Provide values for the following parameters:');
+                    for (const error of result.error.errors) {
+                        const optionInfo = cli.commandToExecute.options.find(o => o.name === error.path.join('.'));
+                        const answer = await cli.promptForValue(optionInfo);
+                        cli.optionsFromArgs.options[error.path.join('.')] = answer;
+                    }
+                }
+                else {
+                    result.error.errors.forEach(e => {
+                        if (e.code === 'invalid_type' &&
+                            e.received === 'undefined') {
+                            e.message = `Required option not specified`;
+                        }
+                    });
+                    return cli.closeWithError(result.error, cli.optionsFromArgs, true);
+                }
+            }
         }
-        finalArgs = result.data;
     }
     else {
         const startValidation = process.hrtime.bigint();
@@ -404,11 +436,7 @@ function getCommandOptions(command) {
 function getCommandOptionsFromArgs(args, commandInfo) {
     const yargsOptions = {
         alias: {},
-        configuration: {
-            "parse-numbers": false,
-            "strip-aliased": true,
-            "strip-dashed": true
-        }
+        configuration: yargsConfiguration
     };
     let argsToParse = args;
     if (commandInfo) {
@@ -749,7 +777,7 @@ async function closeWithError(error, args, showHelpIfEnabled = false) {
     }
     let errorMessage = error instanceof CommandError ? error.message : error;
     if (error instanceof ZodError) {
-        errorMessage = error.errors.map(e => `${e.path}: ${e.message}`).join(os.EOL);
+        errorMessage = error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(os.EOL);
     }
     if ((!args.options.output || args.options.output === 'json') &&
         !cli.getSettingWithDefaultValue(settingsNames.printErrorsAsPlainText, true)) {
@@ -789,6 +817,16 @@ async function error(message, ...optionalParams) {
         console.error(message, ...optionalParams);
     }
 }
+async function promptForValue(optionInfo) {
+    return optionInfo.autocomplete !== undefined
+        ? await prompt.forSelection({
+            message: `${optionInfo.name}: `,
+            choices: optionInfo.autocomplete.map((choice) => {
+                return { name: choice, value: choice };
+            })
+        })
+        : await prompt.forInput({ message: `${optionInfo.name}: ` });
+}
 async function promptForSelection(config) {
     const answer = await prompt.forSelection(config);
     await cli.error('');
@@ -853,6 +891,8 @@ export const cli = {
     printAvailableCommands,
     promptForConfirmation,
     promptForSelection,
-    shouldTrimOutput
+    promptForValue,
+    shouldTrimOutput,
+    yargsConfiguration
 };
 //# sourceMappingURL=cli.js.map

package/dist/m365/cli/commands/cli-consent.js

@@ -23,12 +23,8 @@ class CliConsentCommand extends AnonymousCommand {
     }
     async commandAction(logger, args) {
         let scope = '';
-        switch (args.options.service) {
-            case 'yammer':
-                await this.warn(logger, 'The yammer service is deprecated. Please use the VivaEngage service instead.');
-            case 'VivaEngage':
-                scope = 'https://api.yammer.com/user_impersonation';
-                break;
+        if (args.options.service === 'VivaEngage') {
+            scope = 'https://api.yammer.com/user_impersonation';
         }
         await logger.log(`To consent permissions for executing ${args.options.service} commands, navigate in your web browser to https://login.microsoftonline.com/${config.tenant}/oauth2/v2.0/authorize?client_id=${config.cliEntraAppId}&response_type=code&scope=${encodeURIComponent(scope)}`);
     }
@@ -50,7 +46,7 @@ _CliConsentCommand_instances = new WeakSet(), _CliConsentCommand_initTelemetry =
     });
 }, _CliConsentCommand_initValidators = function _CliConsentCommand_initValidators() {
     this.validators.push(async (args) => {
-        if (args.options.service !== 'VivaEngage' && args.options.service !== 'yammer') {
+        if (args.options.service !== 'VivaEngage') {
             return `${args.options.service} is not a valid value for the service option. Allowed values: VivaEngage`;
         }
         return true;

package/dist/m365/commands/login.js

@@ -38,19 +38,24 @@ class LoginCommand extends Command {
     getRefinedSchema(schema) {
         return schema
             .refine(options => options.authType !== 'password' || options.userName, {
-            message: 'Username is required when using password authentication'
+            message: 'Username is required when using password authentication',
+            path: ['userName']
         })
             .refine(options => options.authType !== 'password' || options.password, {
-            message: 'Password is required when using password authentication'
+            message: 'Password is required when using password authentication',
+            path: ['password']
         })
             .refine(options => options.authType !== 'certificate' || !(options.certificateFile && options.certificateBase64Encoded), {
-            message: 'Specify either certificateFile or certificateBase64Encoded, but not both.'
+            message: 'Specify either certificateFile or certificateBase64Encoded, but not both.',
+            path: ['certificateBase64Encoded']
         })
             .refine(options => options.authType !== 'certificate' || options.certificateFile || options.certificateBase64Encoded, {
-            message: 'Specify either certificateFile or certificateBase64Encoded'
+            message: 'Specify either certificateFile or certificateBase64Encoded',
+            path: ['certificateFile']
         })
             .refine(options => options.authType !== 'secret' || options.secret, {
-            message: 'Secret is required when using secret authentication'
+            message: 'Secret is required when using secret authentication',
+            path: ['secret']
         });
     }
     async commandAction(logger, args) {

package/dist/m365/entra/commands/enterpriseapp/enterpriseapp-remove.js

@@ -0,0 +1,123 @@
+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 _EntraEnterpriseAppRemoveCommand_instances, _EntraEnterpriseAppRemoveCommand_initTelemetry, _EntraEnterpriseAppRemoveCommand_initOptions, _EntraEnterpriseAppRemoveCommand_initValidators, _EntraEnterpriseAppRemoveCommand_initOptionSets, _EntraEnterpriseAppRemoveCommand_initTypes;
+import { cli } from '../../../../cli/cli.js';
+import request from '../../../../request.js';
+import { odata } from '../../../../utils/odata.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { validation } from '../../../../utils/validation.js';
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+class EntraEnterpriseAppRemoveCommand extends GraphCommand {
+    get name() {
+        return commands.ENTERPRISEAPP_REMOVE;
+    }
+    get description() {
+        return 'Deletes an enterprise application (or service principal)';
+    }
+    alias() {
+        return [commands.SP_REMOVE];
+    }
+    constructor() {
+        super();
+        _EntraEnterpriseAppRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _EntraEnterpriseAppRemoveCommand_instances, "m", _EntraEnterpriseAppRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _EntraEnterpriseAppRemoveCommand_instances, "m", _EntraEnterpriseAppRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _EntraEnterpriseAppRemoveCommand_instances, "m", _EntraEnterpriseAppRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _EntraEnterpriseAppRemoveCommand_instances, "m", _EntraEnterpriseAppRemoveCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _EntraEnterpriseAppRemoveCommand_instances, "m", _EntraEnterpriseAppRemoveCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        const removeEnterpriseApplication = async () => {
+            if (this.verbose) {
+                await logger.logToStderr(`Removing enterprise application ${args.options.id || args.options.displayName || args.options.objectId}...`);
+            }
+            try {
+                let url = `${this.resource}/v1.0`;
+                if (args.options.id) {
+                    url += `/servicePrincipals(appId='${args.options.id}')`;
+                }
+                else {
+                    const id = await this.getSpId(args.options);
+                    url += `/servicePrincipals/${id}`;
+                }
+                const requestOptions = {
+                    url: url,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json'
+                };
+                await request.delete(requestOptions);
+            }
+            catch (err) {
+                this.handleRejectedODataJsonPromise(err);
+            }
+        };
+        if (args.options.force) {
+            await removeEnterpriseApplication();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove enterprise application '${args.options.id || args.options.displayName || args.options.objectId}'?` });
+            if (result) {
+                await removeEnterpriseApplication();
+            }
+        }
+    }
+    async getSpId(options) {
+        if (options.objectId) {
+            return options.objectId;
+        }
+        const spItemsResponse = await odata.getAllItems(`${this.resource}/v1.0/servicePrincipals?$filter=displayName eq '${formatting.encodeQueryParameter(options.displayName)}'&$select=id`);
+        if (spItemsResponse.length === 0) {
+            throw `The specified enterprise application does not exist.`;
+        }
+        if (spItemsResponse.length > 1) {
+            const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', spItemsResponse);
+            const result = await cli.handleMultipleResultsFound(`Multiple enterprise applications with name '${options.displayName}' found.`, resultAsKeyValuePair);
+            return result.id;
+        }
+        const spItem = spItemsResponse[0];
+        return spItem.id;
+    }
+}
+_EntraEnterpriseAppRemoveCommand_instances = new WeakSet(), _EntraEnterpriseAppRemoveCommand_initTelemetry = function _EntraEnterpriseAppRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            id: typeof args.options.id !== 'undefined',
+            displayName: typeof args.options.displayName !== 'undefined',
+            objectId: typeof args.options.objectId !== 'undefined',
+            force: !!args.options.force
+        });
+    });
+}, _EntraEnterpriseAppRemoveCommand_initOptions = function _EntraEnterpriseAppRemoveCommand_initOptions() {
+    this.options.unshift({
+        option: '-i, --id [id]'
+    }, {
+        option: '-n, --displayName [displayName]'
+    }, {
+        option: '--objectId [objectId]'
+    }, {
+        option: '-f, --force'
+    });
+}, _EntraEnterpriseAppRemoveCommand_initValidators = function _EntraEnterpriseAppRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.id && !validation.isValidGuid(args.options.id)) {
+            return `The option 'id' with value '${args.options.id}' is not a valid GUID.`;
+        }
+        if (args.options.objectId && !validation.isValidGuid(args.options.objectId)) {
+            return `The option 'objectId' with value '${args.options.objectId}' is not a valid GUID.`;
+        }
+        return true;
+    });
+}, _EntraEnterpriseAppRemoveCommand_initOptionSets = function _EntraEnterpriseAppRemoveCommand_initOptionSets() {
+    this.optionSets.push({ options: ['id', 'displayName', 'objectId'] });
+}, _EntraEnterpriseAppRemoveCommand_initTypes = function _EntraEnterpriseAppRemoveCommand_initTypes() {
+    this.types.string.push('id', 'displayName', 'objectId');
+    this.types.boolean.push('force');
+};
+export default new EntraEnterpriseAppRemoveCommand();
+//# sourceMappingURL=enterpriseapp-remove.js.map

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

@@ -0,0 +1,256 @@
+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 _EntraGroupSetCommand_instances, _EntraGroupSetCommand_initTelemetry, _EntraGroupSetCommand_initOptions, _EntraGroupSetCommand_initValidators, _EntraGroupSetCommand_initOptionSets, _EntraGroupSetCommand_initTypes;
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import { validation } from '../../../../utils/validation.js';
+import request from '../../../../request.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { entraGroup } from '../../../../utils/entraGroup.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { odata } from '../../../../utils/odata.js';
+class EntraGroupSetCommand extends GraphCommand {
+    get name() {
+        return commands.GROUP_SET;
+    }
+    get description() {
+        return 'Updates a Microsoft Entra group';
+    }
+    constructor() {
+        super();
+        _EntraGroupSetCommand_instances.add(this);
+        this.allowedVisibility = ['Public', 'Private'];
+        __classPrivateFieldGet(this, _EntraGroupSetCommand_instances, "m", _EntraGroupSetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _EntraGroupSetCommand_instances, "m", _EntraGroupSetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _EntraGroupSetCommand_instances, "m", _EntraGroupSetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _EntraGroupSetCommand_instances, "m", _EntraGroupSetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _EntraGroupSetCommand_instances, "m", _EntraGroupSetCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        let groupId = args.options.id;
+        try {
+            if (args.options.displayName) {
+                if (this.verbose) {
+                    await logger.logToStderr(`Retrieving group id...`);
+                }
+                groupId = await entraGroup.getGroupIdByDisplayName(args.options.displayName);
+            }
+            const requestOptions = {
+                url: `${this.resource}/v1.0/groups/${groupId}`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                data: {
+                    displayName: args.options.newDisplayName,
+                    description: args.options.description === '' ? null : args.options.description,
+                    mailNickName: args.options.mailNickname,
+                    visibility: args.options.visibility
+                }
+            };
+            await request.patch(requestOptions);
+            const ownerIds = await this.getUserIds(logger, args.options.ownerIds, args.options.ownerUserNames);
+            if (ownerIds.length !== 0) {
+                await this.updateUsers(logger, groupId, 'owners', ownerIds);
+            }
+            else if (this.verbose) {
+                await logger.logToStderr(`No owners to update.`);
+            }
+            const memberIds = await this.getUserIds(logger, args.options.memberIds, args.options.memberUserNames);
+            if (memberIds.length !== 0) {
+                await this.updateUsers(logger, groupId, 'members', memberIds);
+            }
+            else if (this.verbose) {
+                await logger.logToStderr(`No members to update.`);
+            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    ;
+    async getUserIds(logger, userIds, userNames) {
+        if (userIds) {
+            return formatting.splitAndTrim(userIds);
+        }
+        if (userNames) {
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving user IDs...`);
+            }
+            return entraUser.getUserIdsByUpns(formatting.splitAndTrim(userNames));
+        }
+        return [];
+    }
+    async updateUsers(logger, groupId, role, userIds) {
+        const groupUsers = await odata.getAllItems(`${this.resource}/v1.0/groups/${groupId}/${role}/microsoft.graph.user?$select=id`);
+        const userIdsToAdd = userIds.filter(userId => !groupUsers.some(groupUser => groupUser.id === userId));
+        const userIdsToRemove = groupUsers.filter(groupUser => !userIds.some(userId => groupUser.id === userId)).map(user => user.id);
+        if (this.verbose) {
+            await logger.logToStderr(`Adding ${userIdsToAdd.length} ${role}...`);
+        }
+        for (let i = 0; i < userIdsToAdd.length; i += 400) {
+            const userIdsBatch = userIdsToAdd.slice(i, i + 400);
+            const batchRequestOptions = this.getBatchRequestOptions();
+            // 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);
+                batchRequestOptions.data.requests.push({
+                    id: j + 1,
+                    method: 'PATCH',
+                    url: `/groups/${groupId}`,
+                    headers: {
+                        'content-type': 'application/json;odata.metadata=none',
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    body: {
+                        [`${role}@odata.bind`]: userIdsChunk.map(u => `${this.resource}/v1.0/directoryObjects/${u}`)
+                    }
+                });
+            }
+            const res = await request.post(batchRequestOptions);
+            for (const response of res.responses) {
+                if (response.status !== 204) {
+                    throw response.body;
+                }
+            }
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Removing ${userIdsToRemove.length} ${role}...`);
+        }
+        for (let i = 0; i < userIdsToRemove.length; i += 20) {
+            const userIdsBatch = userIdsToRemove.slice(i, i + 20);
+            const batchRequestOptions = this.getBatchRequestOptions();
+            userIdsBatch.map(userId => {
+                batchRequestOptions.data.requests.push({
+                    id: userId,
+                    method: 'DELETE',
+                    url: `/groups/${groupId}/${role}/${userId}/$ref`
+                });
+            });
+            const res = await request.post(batchRequestOptions);
+            for (const response of res.responses) {
+                if (response.status !== 204) {
+                    throw response.body;
+                }
+            }
+        }
+    }
+    getBatchRequestOptions() {
+        const requestOptions = {
+            url: `${this.resource}/v1.0/$batch`,
+            headers: {
+                'content-type': 'application/json;odata.metadata=none',
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json',
+            data: {
+                requests: []
+            }
+        };
+        return requestOptions;
+    }
+}
+_EntraGroupSetCommand_instances = new WeakSet(), _EntraGroupSetCommand_initTelemetry = function _EntraGroupSetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            id: typeof args.options.id !== 'undefined',
+            displayName: typeof args.options.displayName !== 'undefined',
+            newDisplayName: typeof args.options.newDisplayName !== 'undefined',
+            description: typeof args.options.description !== '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'
+        });
+    });
+}, _EntraGroupSetCommand_initOptions = function _EntraGroupSetCommand_initOptions() {
+    this.options.unshift({
+        option: '-i, --id [id]'
+    }, {
+        option: '--mailNickname [mailNickname]'
+    }, {
+        option: '-n, --displayName [displayName]'
+    }, {
+        option: '--newDisplayName [newDisplayName]'
+    }, {
+        option: '--description [description]'
+    }, {
+        option: '--ownerIds [ownerIds]'
+    }, {
+        option: '--ownerUserNames [ownerUserNames]'
+    }, {
+        option: '--memberIds [memberIds]'
+    }, {
+        option: '--memberUserNames [memberUserNames]'
+    }, {
+        option: '--visibility [visibility]',
+        autocomplete: this.allowedVisibility
+    });
+}, _EntraGroupSetCommand_initValidators = function _EntraGroupSetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.id && !validation.isValidGuid(args.options.id)) {
+            return `Value '${args.options.id}' is not a valid GUID for option 'id'.`;
+        }
+        if (args.options.newDisplayName && args.options.newDisplayName.length > 256) {
+            return `The maximum amount of characters for 'newDisplayName' is 256.`;
+        }
+        if (args.options.mailNickname) {
+            if (!validation.isValidMailNickname(args.options.mailNickname)) {
+                return `Value '${args.options.mailNickname}' 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 isValidGUIDArrayResult = validation.isValidGuidArray(args.options.ownerIds);
+            if (isValidGUIDArrayResult !== true) {
+                return `The following GUIDs are invalid for option 'ownerIds': ${isValidGUIDArrayResult}.`;
+            }
+        }
+        if (args.options.ownerUserNames) {
+            const isValidUPNArrayResult = validation.isValidUserPrincipalNameArray(args.options.ownerUserNames);
+            if (isValidUPNArrayResult !== true) {
+                return `The following user principal names are invalid for option 'ownerUserNames': ${isValidUPNArrayResult}.`;
+            }
+        }
+        if (args.options.memberIds) {
+            const isValidGUIDArrayResult = validation.isValidGuidArray(args.options.memberIds);
+            if (isValidGUIDArrayResult !== true) {
+                return `The following GUIDs are invalid for option 'memberIds': ${isValidGUIDArrayResult}.`;
+            }
+        }
+        if (args.options.memberUserNames) {
+            const isValidUPNArrayResult = validation.isValidUserPrincipalNameArray(args.options.memberUserNames);
+            if (isValidUPNArrayResult !== true) {
+                return `The following user principal names are invalid for option 'memberUserNames': ${isValidUPNArrayResult}.`;
+            }
+        }
+        if (args.options.visibility && !this.allowedVisibility.includes(args.options.visibility)) {
+            return `Option 'visibility' must be one of the following values: ${this.allowedVisibility.join(', ')}.`;
+        }
+        if (args.options.newDisplayName === undefined && args.options.description === undefined && args.options.visibility === undefined
+            && args.options.ownerIds === undefined && args.options.ownerUserNames === undefined && args.options.memberIds === undefined
+            && args.options.memberUserNames === undefined && args.options.mailNickname === undefined) {
+            return `Specify at least one of the following options: 'newDisplayName', 'description', 'visibility', 'ownerIds', 'ownerUserNames', 'memberIds', 'memberUserNames', 'mailNickname'.`;
+        }
+        return true;
+    });
+}, _EntraGroupSetCommand_initOptionSets = function _EntraGroupSetCommand_initOptionSets() {
+    this.optionSets.push({ options: ['id', 'displayName'] }, {
+        options: ['ownerIds', 'ownerUserNames'],
+        runsWhen: (args) => args.options.ownerIds || args.options.ownerUserNames
+    }, {
+        options: ['memberIds', 'memberUserNames'],
+        runsWhen: (args) => args.options.memberIds || args.options.memberUserNames
+    });
+}, _EntraGroupSetCommand_initTypes = function _EntraGroupSetCommand_initTypes() {
+    this.types.string.push('id', 'displayName', 'newDisplayName', 'description', 'mailNickname', 'ownerIds', 'ownerUserNames', 'memberIds', 'memberUserNames', 'visibility');
+};
+export default new EntraGroupSetCommand();
+//# sourceMappingURL=group-set.js.map

package/dist/m365/entra/commands.js

@@ -35,10 +35,12 @@ export default {
     ENTERPRISEAPP_ADD: `${prefix} enterpriseapp add`,
     ENTERPRISEAPP_GET: `${prefix} enterpriseapp get`,
     ENTERPRISEAPP_LIST: `${prefix} enterpriseapp list`,
+    ENTERPRISEAPP_REMOVE: `${prefix} enterpriseapp remove`,
     GROUP_ADD: `${prefix} group add`,
     GROUP_GET: `${prefix} group get`,
     GROUP_LIST: `${prefix} group list`,
     GROUP_REMOVE: `${prefix} group remove`,
+    GROUP_SET: `${prefix} group set`,
     GROUP_USER_ADD: `${prefix} group user add`,
     GROUP_USER_LIST: `${prefix} group user list`,
     GROUP_USER_SET: `${prefix} group user set`,
@@ -92,6 +94,7 @@ export default {
     SP_ADD: `${prefix} sp add`,
     SP_GET: `${prefix} sp get`,
     SP_LIST: `${prefix} sp list`,
+    SP_REMOVE: `${prefix} sp remove`,
     USER_ADD: `${prefix} user add`,
     USER_GET: `${prefix} user get`,
     USER_GUEST_ADD: `${prefix} user guest add`,