@pnp/cli-microsoft365 8.0.0-beta.e6f9331 → 8.1.0-beta.3bc5759

package/dist/m365/teams/commands/meeting/meeting-attendancereport-get.js

@@ -0,0 +1,119 @@
+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 _TeamsMeetingAttendancereportGetCommand_instances, _TeamsMeetingAttendancereportGetCommand_initTelemetry, _TeamsMeetingAttendancereportGetCommand_initOptions, _TeamsMeetingAttendancereportGetCommand_initTypes, _TeamsMeetingAttendancereportGetCommand_initValidators, _TeamsMeetingAttendancereportGetCommand_initOptionSets;
+import auth from '../../../../Auth.js';
+import { accessToken } from '../../../../utils/accessToken.js';
+import { validation } from '../../../../utils/validation.js';
+import GraphCommand from "../../../base/GraphCommand.js";
+import commands from '../../commands.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import request from '../../../../request.js';
+class TeamsMeetingAttendancereportGetCommand extends GraphCommand {
+    get name() {
+        return commands.MEETING_ATTENDANCEREPORT_GET;
+    }
+    get description() {
+        return 'Gets attendance report for a given meeting';
+    }
+    constructor() {
+        super();
+        _TeamsMeetingAttendancereportGetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAttendancereportGetCommand_instances, "m", _TeamsMeetingAttendancereportGetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAttendancereportGetCommand_instances, "m", _TeamsMeetingAttendancereportGetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAttendancereportGetCommand_instances, "m", _TeamsMeetingAttendancereportGetCommand_initTypes).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAttendancereportGetCommand_instances, "m", _TeamsMeetingAttendancereportGetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _TeamsMeetingAttendancereportGetCommand_instances, "m", _TeamsMeetingAttendancereportGetCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[auth.defaultResource].accessToken);
+            if (isAppOnlyAccessToken && !args.options.userId && !args.options.userName && !args.options.email) {
+                throw `The option 'userId', 'userName' or 'email' is required when retrieving meeting attendance report using app only permissions.`;
+            }
+            else if (!isAppOnlyAccessToken && (args.options.userId || args.options.userName || args.options.email)) {
+                throw `The options 'userId', 'userName' and 'email' cannot be used when retrieving meeting attendance report using delegated permissions.`;
+            }
+            if (this.verbose) {
+                await logger.logToStderr(`Retrieving attendance report for ${isAppOnlyAccessToken ? `specific user ${args.options.userId || args.options.userName || args.options.email}.` : 'currently logged in user'}.`);
+            }
+            let userUrl = '';
+            if (isAppOnlyAccessToken) {
+                const userId = await this.getUserId(args.options);
+                userUrl += `users/${userId}`;
+            }
+            else {
+                userUrl += 'me';
+            }
+            const requestOptions = {
+                url: `${this.resource}/v1.0/${userUrl}/onlineMeetings/${args.options.meetingId}/attendanceReports/${args.options.id}?$expand=attendanceRecords`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            const attendanceReport = await request.get(requestOptions);
+            await logger.log(attendanceReport);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getUserId(options) {
+        if (options.userId) {
+            return options.userId;
+        }
+        if (options.userName) {
+            return entraUser.getUserIdByUpn(options.userName);
+        }
+        return entraUser.getUserIdByEmail(options.email);
+    }
+}
+_TeamsMeetingAttendancereportGetCommand_instances = new WeakSet(), _TeamsMeetingAttendancereportGetCommand_initTelemetry = function _TeamsMeetingAttendancereportGetCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            userId: typeof args.options.userId !== 'undefined',
+            userName: typeof args.options.userName !== 'undefined',
+            email: typeof args.options.email !== 'undefined'
+        });
+    });
+}, _TeamsMeetingAttendancereportGetCommand_initOptions = function _TeamsMeetingAttendancereportGetCommand_initOptions() {
+    this.options.unshift({
+        option: '-u, --userId [userId]'
+    }, {
+        option: '-n, --userName [userName]'
+    }, {
+        option: '--email [email]'
+    }, {
+        option: '-m, --meetingId <meetingId>'
+    }, {
+        option: '-i, --id <id>'
+    });
+}, _TeamsMeetingAttendancereportGetCommand_initTypes = function _TeamsMeetingAttendancereportGetCommand_initTypes() {
+    this.types.string.push('userId', 'userName', 'email', 'meetingId', 'id');
+}, _TeamsMeetingAttendancereportGetCommand_initValidators = function _TeamsMeetingAttendancereportGetCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (!validation.isValidGuid(args.options.id)) {
+            return `${args.options.id} is not a valid GUID for option 'id'.`;
+        }
+        if (args.options.userId && !validation.isValidGuid(args.options.userId)) {
+            return `${args.options.userId} is not a valid GUID for option 'userId'.`;
+        }
+        if (args.options.userName && !validation.isValidUserPrincipalName(args.options.userName)) {
+            return `${args.options.userName} is not a valid UPN.`;
+        }
+        if (args.options.email && !validation.isValidUserPrincipalName(args.options.email)) {
+            return `${args.options.email} is not a valid email.`;
+        }
+        return true;
+    });
+}, _TeamsMeetingAttendancereportGetCommand_initOptionSets = function _TeamsMeetingAttendancereportGetCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['userId', 'userName', 'email'],
+        runsWhen: (args) => args.options.userId || args.options.userName || args.options.email
+    });
+};
+export default new TeamsMeetingAttendancereportGetCommand();
+//# sourceMappingURL=meeting-attendancereport-get.js.map

package/dist/m365/teams/commands/message/message-remove.js

@@ -0,0 +1,112 @@
+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 _TeamsMessageRemoveCommand_instances, _TeamsMessageRemoveCommand_initTelemetry, _TeamsMessageRemoveCommand_initOptions, _TeamsMessageRemoveCommand_initValidators, _TeamsMessageRemoveCommand_initOptionSets, _TeamsMessageRemoveCommand_initTypes;
+import { cli } from '../../../../cli/cli.js';
+import request from '../../../../request.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { teams } from '../../../../utils/teams.js';
+import { validation } from '../../../../utils/validation.js';
+import DelegatedGraphCommand from '../../../base/DelegatedGraphCommand.js';
+import commands from '../../commands.js';
+class TeamsMessageRemoveCommand extends DelegatedGraphCommand {
+    get name() {
+        return commands.MESSAGE_REMOVE;
+    }
+    get description() {
+        return 'Removes a message from a channel in a Microsoft Teams team';
+    }
+    constructor() {
+        super();
+        _TeamsMessageRemoveCommand_instances.add(this);
+        __classPrivateFieldGet(this, _TeamsMessageRemoveCommand_instances, "m", _TeamsMessageRemoveCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRemoveCommand_instances, "m", _TeamsMessageRemoveCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRemoveCommand_instances, "m", _TeamsMessageRemoveCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRemoveCommand_instances, "m", _TeamsMessageRemoveCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRemoveCommand_instances, "m", _TeamsMessageRemoveCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        const removeTeamMessage = async () => {
+            try {
+                if (this.verbose) {
+                    await logger.logToStderr(`Removing message '${args.options.id}' from channel '${args.options.channelId || args.options.channelName}' in team '${args.options.teamId || args.options.teamName}'.`);
+                }
+                const teamId = args.options.teamId || await teams.getTeamIdByDisplayName(args.options.teamName);
+                const channelId = args.options.channelId || await teams.getChannelIdByDisplayName(teamId, args.options.channelName);
+                const requestOptions = {
+                    url: `${this.resource}/v1.0/teams/${teamId}/channels/${formatting.encodeQueryParameter(channelId)}/messages/${args.options.id}/softDelete`,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json'
+                };
+                await request.post(requestOptions);
+            }
+            catch (err) {
+                if (err.error?.error?.code === 'NotFound') {
+                    this.handleError('The message was not found in the Teams channel.');
+                }
+                else {
+                    this.handleRejectedODataJsonPromise(err);
+                }
+            }
+        };
+        if (args.options.force) {
+            await removeTeamMessage();
+        }
+        else {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove this message?` });
+            if (result) {
+                await removeTeamMessage();
+            }
+        }
+    }
+}
+_TeamsMessageRemoveCommand_instances = new WeakSet(), _TeamsMessageRemoveCommand_initTelemetry = function _TeamsMessageRemoveCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            teamId: typeof args.options.teamId !== 'undefined',
+            teamName: typeof args.options.teamName !== 'undefined',
+            channelId: typeof args.options.channelId !== 'undefined',
+            channelName: typeof args.options.channelName !== 'undefined',
+            force: !!args.options.force
+        });
+    });
+}, _TeamsMessageRemoveCommand_initOptions = function _TeamsMessageRemoveCommand_initOptions() {
+    this.options.unshift({
+        option: '--teamId [teamId]'
+    }, {
+        option: '--teamName [teamName]'
+    }, {
+        option: '--channelId [channelId]'
+    }, {
+        option: '--channelName [channelName]'
+    }, {
+        option: '-i, --id <id>'
+    }, {
+        option: '-f, --force'
+    });
+}, _TeamsMessageRemoveCommand_initValidators = function _TeamsMessageRemoveCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.teamId && !validation.isValidGuid(args.options.teamId)) {
+            return `'${args.options.teamId}' is not a valid GUID for 'teamId'.`;
+        }
+        if (args.options.channelId && !validation.isValidTeamsChannelId(args.options.channelId)) {
+            return `'${args.options.channelId}' is not a valid ID for 'channelId'.`;
+        }
+        return true;
+    });
+}, _TeamsMessageRemoveCommand_initOptionSets = function _TeamsMessageRemoveCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['teamId', 'teamName']
+    }, {
+        options: ['channelId', 'channelName']
+    });
+}, _TeamsMessageRemoveCommand_initTypes = function _TeamsMessageRemoveCommand_initTypes() {
+    this.types.string.push('teamId', 'teamName', 'channelId', 'channelName', 'id');
+    this.types.boolean.push('force');
+};
+export default new TeamsMessageRemoveCommand();
+//# sourceMappingURL=message-remove.js.map

package/dist/m365/teams/commands.js

@@ -30,12 +30,14 @@ export default {
     MEETING_ADD: `${prefix} meeting add`,
     MEETING_GET: `${prefix} meeting get`,
     MEETING_LIST: `${prefix} meeting list`,
+    MEETING_ATTENDANCEREPORT_GET: `${prefix} meeting attendancereport get`,
     MEETING_ATTENDANCEREPORT_LIST: `${prefix} meeting attendancereport list`,
     MEETING_TRANSCRIPT_LIST: `${prefix} meeting transcript list`,
     MEMBERSETTINGS_LIST: `${prefix} membersettings list`,
     MEMBERSETTINGS_SET: `${prefix} membersettings set`,
     MESSAGE_GET: `${prefix} message get`,
     MESSAGE_LIST: `${prefix} message list`,
+    MESSAGE_REMOVE: `${prefix} message remove`,
     MESSAGE_REPLY_LIST: `${prefix} message reply list`,
     MESSAGE_SEND: `${prefix} message send`,
     MESSAGINGSETTINGS_LIST: `${prefix} messagingsettings list`,

package/dist/m365/viva/commands/engage/engage-community-add.js

@@ -0,0 +1,166 @@
+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 _VivaEngageCommunityAddCommand_instances, _VivaEngageCommunityAddCommand_initTelemetry, _VivaEngageCommunityAddCommand_initOptions, _VivaEngageCommunityAddCommand_initValidators, _VivaEngageCommunityAddCommand_initTypes, _VivaEngageCommunityAddCommand_initOptionSets;
+import GraphCommand from '../../../base/GraphCommand.js';
+import commands from '../../commands.js';
+import request from '../../../../request.js';
+import { validation } from '../../../../utils/validation.js';
+import { accessToken } from '../../../../utils/accessToken.js';
+import auth from '../../../../Auth.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { entraUser } from '../../../../utils/entraUser.js';
+import { setTimeout } from 'timers/promises';
+class VivaEngageCommunityAddCommand extends GraphCommand {
+    get name() {
+        return commands.ENGAGE_COMMUNITY_ADD;
+    }
+    get description() {
+        return 'Creates a new community in Viva Engage';
+    }
+    constructor() {
+        super();
+        _VivaEngageCommunityAddCommand_instances.add(this);
+        this.pollingInterval = 5000;
+        this.privacyOptions = ['public', 'private'];
+        __classPrivateFieldGet(this, _VivaEngageCommunityAddCommand_instances, "m", _VivaEngageCommunityAddCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _VivaEngageCommunityAddCommand_instances, "m", _VivaEngageCommunityAddCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _VivaEngageCommunityAddCommand_instances, "m", _VivaEngageCommunityAddCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _VivaEngageCommunityAddCommand_instances, "m", _VivaEngageCommunityAddCommand_initTypes).call(this);
+        __classPrivateFieldGet(this, _VivaEngageCommunityAddCommand_instances, "m", _VivaEngageCommunityAddCommand_initOptionSets).call(this);
+    }
+    async commandAction(logger, args) {
+        const { displayName, description, privacy, adminEntraIds, adminEntraUserNames, wait } = args.options;
+        const isAppOnlyAccessToken = accessToken.isAppOnlyAccessToken(auth.connection.accessTokens[auth.defaultResource].accessToken);
+        if (isAppOnlyAccessToken && !adminEntraIds && !adminEntraUserNames) {
+            this.handleError(`Specify at least one admin using either adminEntraIds or adminEntraUserNames options when using application permissions.`);
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Creating a Viva Engage community with display name '${displayName}'...`);
+        }
+        try {
+            const requestOptions = {
+                url: `${this.resource}/beta/employeeExperience/communities`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none',
+                    'content-type': 'application/json'
+                },
+                responseType: 'json',
+                fullResponse: true,
+                data: {
+                    displayName: displayName,
+                    description: description,
+                    privacy: privacy
+                }
+            };
+            const entraIds = await this.getGraphUserUrls(args.options);
+            if (entraIds.length > 0) {
+                requestOptions.data['owners@odata.bind'] = entraIds;
+            }
+            const res = await request.post(requestOptions);
+            const location = res.headers.location;
+            if (!wait) {
+                await logger.log(location);
+                return;
+            }
+            let status;
+            do {
+                if (this.verbose) {
+                    await logger.logToStderr(`Community still provisioning. Retrying in ${this.pollingInterval / 1000} seconds...`);
+                }
+                await setTimeout(this.pollingInterval);
+                if (this.verbose) {
+                    await logger.logToStderr(`Checking create community operation status...`);
+                }
+                const operation = await request.get({
+                    url: location,
+                    headers: {
+                        accept: 'application/json;odata.metadata=none'
+                    },
+                    responseType: 'json'
+                });
+                status = operation.status;
+                if (this.verbose) {
+                    await logger.logToStderr(`Community creation operation status: ${status}`);
+                }
+                if (status === 'failed') {
+                    throw `Community creation failed: ${operation.statusDetail}`;
+                }
+                if (status === 'succeeded') {
+                    await logger.log(operation);
+                }
+            } while (status === 'notStarted' || status === 'running');
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getGraphUserUrls(options) {
+        let entraIds = [];
+        if (options.adminEntraIds) {
+            entraIds = formatting.splitAndTrim(options.adminEntraIds);
+        }
+        else if (options.adminEntraUserNames) {
+            entraIds = await entraUser.getUserIdsByUpns(formatting.splitAndTrim(options.adminEntraUserNames));
+        }
+        const graphUserUrls = entraIds.map(id => `${this.resource}/beta/users/${id}`);
+        return graphUserUrls;
+    }
+}
+_VivaEngageCommunityAddCommand_instances = new WeakSet(), _VivaEngageCommunityAddCommand_initTelemetry = function _VivaEngageCommunityAddCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            adminEntraIds: typeof args.options.adminEntraIds !== 'undefined',
+            adminEntraUserNames: typeof args.options.adminEntraUserNames !== 'undefined',
+            wait: !!args.options.wait
+        });
+    });
+}, _VivaEngageCommunityAddCommand_initOptions = function _VivaEngageCommunityAddCommand_initOptions() {
+    this.options.unshift({ option: '--displayName <displayName>' }, { option: '--description <description>' }, {
+        option: '--privacy <privacy>',
+        autocomplete: this.privacyOptions
+    }, { option: '--adminEntraIds [adminEntraIds]' }, { option: '--adminEntraUserNames [adminEntraUserNames]' }, { option: '--wait' });
+}, _VivaEngageCommunityAddCommand_initValidators = function _VivaEngageCommunityAddCommand_initValidators() {
+    this.validators.push(async (args) => {
+        if (args.options.displayName.length > 255) {
+            return `The maximum amount of characters for 'displayName' is 255.`;
+        }
+        if (args.options.description.length > 1024) {
+            return `The maximum amount of characters for 'description' is 1024.`;
+        }
+        if (this.privacyOptions.indexOf(args.options.privacy) === -1) {
+            return `'${args.options.privacy}' is not a valid value for privacy. Allowed values are: ${this.privacyOptions.join(', ')}.`;
+        }
+        if (args.options.adminEntraIds) {
+            const isValidGUIDArrayResult = validation.isValidGuidArray(args.options.adminEntraIds);
+            if (isValidGUIDArrayResult !== true) {
+                return `The following GUIDs are invalid for the option 'adminEntraIds': ${isValidGUIDArrayResult}.`;
+            }
+            if (formatting.splitAndTrim(args.options.adminEntraIds).length > 20) {
+                return `Maximum of 20 admins allowed. Please reduce the number of users and try again.`;
+            }
+        }
+        if (args.options.adminEntraUserNames) {
+            const isValidUPNArrayResult = validation.isValidUserPrincipalNameArray(args.options.adminEntraUserNames);
+            if (isValidUPNArrayResult !== true) {
+                return `The following user principal names are invalid for the option 'adminEntraUserNames': ${isValidUPNArrayResult}.`;
+            }
+            if (formatting.splitAndTrim(args.options.adminEntraUserNames).length > 20) {
+                return `Maximum of 20 admins allowed. Please reduce the number of users and try again.`;
+            }
+        }
+        return true;
+    });
+}, _VivaEngageCommunityAddCommand_initTypes = function _VivaEngageCommunityAddCommand_initTypes() {
+    this.types.string.push('displayName', 'description', 'privacy', 'adminEntraIds', 'adminEntraUserNames');
+    this.types.boolean.push('wait');
+}, _VivaEngageCommunityAddCommand_initOptionSets = function _VivaEngageCommunityAddCommand_initOptionSets() {
+    this.optionSets.push({
+        options: ['adminEntraIds', 'adminEntraUserNames'],
+        runsWhen: (args) => args.options.adminEntraIds || args.options.adminEntraUserNames
+    });
+};
+export default new VivaEngageCommunityAddCommand();
+//# sourceMappingURL=engage-community-add.js.map

package/dist/m365/viva/commands.js

@@ -1,6 +1,7 @@
 const prefix = 'viva';
 export default {
     CONNECTIONS_APP_CREATE: `${prefix} connections app create`,
+    ENGAGE_COMMUNITY_ADD: `${prefix} engage community add`,
     ENGAGE_COMMUNITY_GET: `${prefix} engage community get`,
     ENGAGE_GROUP_LIST: `${prefix} engage group list`,
     ENGAGE_GROUP_USER_ADD: `${prefix} engage group user add`,

package/dist/utils/formatting.js

@@ -9,6 +9,8 @@ export var CheckStatus;
 (function (CheckStatus) {
     CheckStatus[CheckStatus["Success"] = 0] = "Success";
     CheckStatus[CheckStatus["Failure"] = 1] = "Failure";
+    CheckStatus[CheckStatus["Information"] = 2] = "Information";
+    CheckStatus[CheckStatus["Warning"] = 3] = "Warning";
 })(CheckStatus || (CheckStatus = {}));
 export const formatting = {
     escapeXml(s) {
@@ -37,6 +39,22 @@ export const formatting = {
     parseJsonWithBom(s) {
         return JSON.parse(s.replace(/^\uFEFF/, ''));
     },
+    /**
+     * Tries to parse a string as JSON. If it fails, returns the original string.
+     * @param value JSON string to parse.
+     * @returns JSON object or the original string if parsing fails.
+     */
+    tryParseJson(value) {
+        try {
+            if (typeof value !== 'string') {
+                return value;
+            }
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    },
     filterObject(obj, propertiesToInclude) {
         const objKeys = Object.keys(obj);
         return propertiesToInclude
@@ -152,7 +170,18 @@ export const formatting = {
             process.env.TERM === 'xterm-256color';
         const success = primarySupported ? '✔' : '√';
         const failure = primarySupported ? '✖' : '×';
-        return `${result === CheckStatus.Success ? chalk.green(success) : chalk.red(failure)} ${message}`;
+        const information = 'i';
+        const warning = '!';
+        switch (result) {
+            case CheckStatus.Success:
+                return `${chalk.green(success)} ${message}`;
+            case CheckStatus.Failure:
+                return `${chalk.red(failure)} ${message}`;
+            case CheckStatus.Information:
+                return `${chalk.blue(information)} ${message}`;
+            case CheckStatus.Warning:
+                return `${chalk.yellow(warning)} ${message}`;
+        }
     },
     convertArrayToHashTable(key, array) {
         const resultAsKeyValuePair = {};

package/dist/utils/teams.js

@@ -0,0 +1,49 @@
+import { formatting } from './formatting.js';
+import { odata } from './odata.js';
+import { cli } from '../cli/cli.js';
+const graphResource = 'https://graph.microsoft.com';
+export const teams = {
+    /**
+     * Retrieve the id of a team by its name.
+     * @param displayName Name of the team to retrieve.
+     * @throws Error if the team cannot be found.
+     * @throws Error when multiple teams with the same name and prompting is disabled.
+     * @returns The ID of the team.
+     */
+    async getTeamIdByDisplayName(displayName) {
+        const teams = await odata.getAllItems(`${graphResource}/v1.0/teams?$filter=displayName eq '${formatting.encodeQueryParameter(displayName)}'&$select=id`);
+        if (!teams.length) {
+            throw Error(`The specified team '${displayName}' does not exist.`);
+        }
+        if (teams.length > 1) {
+            const resultAsKeyValuePair = formatting.convertArrayToHashTable('id', teams);
+            const result = await cli.handleMultipleResultsFound(`Multiple teams with name '${displayName}' found.`, resultAsKeyValuePair);
+            return result.id;
+        }
+        return teams[0].id;
+    },
+    /**
+     * Retrieves the channel ID by its name in a Microsoft Teams team.
+     * @param teamId The ID of the team.
+     * @param name The name of the channel.
+     * @returns The ID of the channel.
+     * @throws Throws an error if the specified channel does not exist in the team.
+     */
+    async getChannelIdByDisplayName(teamId, name) {
+        const channelRequestOptions = {
+            url: `${graphResource}/v1.0/teams/${teamId}/channels?$filter=displayName eq '${formatting.encodeQueryParameter(name)}'&$select=id`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json'
+        };
+        const response = await odata.getAllItems(channelRequestOptions);
+        // Only one channel can have the same name in a team
+        const channelItem = response[0];
+        if (!channelItem) {
+            throw Error(`The channel '${name}' does not exist in the Microsoft Teams team with ID '${teamId}'.`);
+        }
+        return channelItem.id;
+    }
+};
+//# sourceMappingURL=teams.js.map

package/dist/utils/zod.js

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+function parseEffect(def, _options, _currentOption) {
+    return def.schema._def;
+}
+function parseIntersection(def, _options, _currentOption) {
+    if (def.left._def.typeName !== z.ZodFirstPartyTypeKind.ZodAny) {
+        return def.left._def;
+    }
+    if (def.right._def.typeName !== z.ZodFirstPartyTypeKind.ZodAny) {
+        return def.right._def;
+    }
+    return;
+}
+function parseObject(def, options, _currentOption) {
+    const properties = def.shape();
+    for (const key in properties) {
+        const property = properties[key];
+        const option = {
+            name: key,
+            long: key,
+            short: property._def.alias,
+            required: true,
+            type: 'string'
+        };
+        parseDef(property._def, options, option);
+        options.push(option);
+    }
+    return;
+}
+function parseString(_def, _options, currentOption) {
+    if (currentOption) {
+        currentOption.type = 'string';
+    }
+    return;
+}
+function parseNumber(_def, _options, currentOption) {
+    if (currentOption) {
+        currentOption.type = 'number';
+    }
+    return;
+}
+function parseBoolean(_def, _options, currentOption) {
+    if (currentOption) {
+        currentOption.type = 'boolean';
+    }
+    return;
+}
+function parseOptional(def, _options, currentOption) {
+    if (currentOption) {
+        currentOption.required = false;
+    }
+    return def.innerType._def;
+}
+function parseDefault(def, _options, currentOption) {
+    if (currentOption) {
+        currentOption.required = false;
+    }
+    return def.innerType._def;
+}
+function parseEnum(def, _options, currentOption) {
+    if (currentOption) {
+        currentOption.type = 'string';
+        currentOption.autocomplete = def.values;
+    }
+    return;
+}
+function parseNativeEnum(def, _options, currentOption) {
+    if (currentOption) {
+        currentOption.type = 'string';
+        currentOption.autocomplete = Object.getOwnPropertyNames(def.values);
+    }
+    return;
+}
+function getParseFn(typeName) {
+    switch (typeName) {
+        case z.ZodFirstPartyTypeKind.ZodEffects:
+            return parseEffect;
+        case z.ZodFirstPartyTypeKind.ZodObject:
+            return parseObject;
+        case z.ZodFirstPartyTypeKind.ZodOptional:
+            return parseOptional;
+        case z.ZodFirstPartyTypeKind.ZodString:
+            return parseString;
+        case z.ZodFirstPartyTypeKind.ZodNumber:
+            return parseNumber;
+        case z.ZodFirstPartyTypeKind.ZodBoolean:
+            return parseBoolean;
+        case z.ZodFirstPartyTypeKind.ZodEnum:
+            return parseEnum;
+        case z.ZodFirstPartyTypeKind.ZodNativeEnum:
+            return parseNativeEnum;
+        case z.ZodFirstPartyTypeKind.ZodDefault:
+            return parseDefault;
+        case z.ZodFirstPartyTypeKind.ZodIntersection:
+            return parseIntersection;
+        default:
+            return;
+    }
+}
+function parseDef(def, options, currentOption) {
+    let parsedDef = def;
+    do {
+        const parse = getParseFn(parsedDef.typeName);
+        if (!parse) {
+            break;
+        }
+        parsedDef = parse(parsedDef, options, currentOption);
+        if (!parsedDef) {
+            break;
+        }
+    } while (parsedDef);
+}
+export const zod = {
+    alias(alias, type) {
+        type._def.alias = alias;
+        return type;
+    },
+    schemaToOptions(schema) {
+        const options = [];
+        parseDef(schema._def, options);
+        return options;
+    }
+};
+//# sourceMappingURL=zod.js.map