@pnp/cli-microsoft365 9.0.0-beta.e69e8d0 → 9.0.0

package/dist/m365/spo/commands/tenant/tenant-recyclebinitem-restore.js

@@ -3,7 +3,7 @@ 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 _SpoTenantRecycleBinItemRestoreCommand_instances, _SpoTenantRecycleBinItemRestoreCommand_initOptions, _SpoTenantRecycleBinItemRestoreCommand_initValidators, _SpoTenantRecycleBinItemRestoreCommand_initTypes;
+var _SpoTenantRecycleBinItemRestoreCommand_instances, _SpoTenantRecycleBinItemRestoreCommand_initTelemetry, _SpoTenantRecycleBinItemRestoreCommand_initOptions, _SpoTenantRecycleBinItemRestoreCommand_initValidators, _SpoTenantRecycleBinItemRestoreCommand_initTypes;
 import request from '../../../../request.js';
 import { formatting } from '../../../../utils/formatting.js';
 import { odata } from '../../../../utils/odata.js';
@@ -22,11 +22,15 @@ class SpoTenantRecycleBinItemRestoreCommand extends SpoCommand {
     constructor() {
         super();
         _SpoTenantRecycleBinItemRestoreCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpoTenantRecycleBinItemRestoreCommand_instances, "m", _SpoTenantRecycleBinItemRestoreCommand_initTelemetry).call(this);
         __classPrivateFieldGet(this, _SpoTenantRecycleBinItemRestoreCommand_instances, "m", _SpoTenantRecycleBinItemRestoreCommand_initOptions).call(this);
         __classPrivateFieldGet(this, _SpoTenantRecycleBinItemRestoreCommand_instances, "m", _SpoTenantRecycleBinItemRestoreCommand_initValidators).call(this);
         __classPrivateFieldGet(this, _SpoTenantRecycleBinItemRestoreCommand_instances, "m", _SpoTenantRecycleBinItemRestoreCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
+        if (args.options.wait) {
+            await this.warn(logger, `Option 'wait' is deprecated and will be removed in the next major release.`);
+        }
         try {
             if (this.verbose) {
                 await logger.logToStderr(`Restoring site collection '${args.options.siteUrl}' from recycle bin.`);
@@ -58,6 +62,13 @@ class SpoTenantRecycleBinItemRestoreCommand extends SpoCommand {
                 };
                 await request.post(restoreOptions);
             }
+            // Here, we return a fixed response because this new API endpoint doesn't return a response while the previous API did.
+            // This has to be removed in the next major release.
+            await logger.log({
+                HasTimedout: false,
+                IsComplete: !!args.options.wait,
+                PollingInterval: 15000
+            });
         }
         catch (err) {
             this.handleRejectedODataJsonPromise(err);
@@ -68,14 +79,23 @@ class SpoTenantRecycleBinItemRestoreCommand extends SpoCommand {
         return sites[0].GroupId;
     }
 }
-_SpoTenantRecycleBinItemRestoreCommand_instances = new WeakSet(), _SpoTenantRecycleBinItemRestoreCommand_initOptions = function _SpoTenantRecycleBinItemRestoreCommand_initOptions() {
+_SpoTenantRecycleBinItemRestoreCommand_instances = new WeakSet(), _SpoTenantRecycleBinItemRestoreCommand_initTelemetry = function _SpoTenantRecycleBinItemRestoreCommand_initTelemetry() {
+    this.telemetry.push((args) => {
+        Object.assign(this.telemetryProperties, {
+            wait: !!args.options.wait
+        });
+    });
+}, _SpoTenantRecycleBinItemRestoreCommand_initOptions = function _SpoTenantRecycleBinItemRestoreCommand_initOptions() {
     this.options.unshift({
         option: '-u, --siteUrl <siteUrl>'
+    }, {
+        option: '--wait'
     });
 }, _SpoTenantRecycleBinItemRestoreCommand_initValidators = function _SpoTenantRecycleBinItemRestoreCommand_initValidators() {
     this.validators.push(async (args) => validation.isValidSharePointUrl(args.options.siteUrl));
 }, _SpoTenantRecycleBinItemRestoreCommand_initTypes = function _SpoTenantRecycleBinItemRestoreCommand_initTypes() {
     this.types.string.push('siteUrl');
+    this.types.boolean.push('wait');
 };
 export default new SpoTenantRecycleBinItemRestoreCommand();
 //# sourceMappingURL=tenant-recyclebinitem-restore.js.map

package/dist/m365/spo/commands.js

@@ -92,6 +92,7 @@ export default {
     FOLDER_LIST: `${prefix} folder list`,
     FOLDER_MOVE: `${prefix} folder move`,
     FOLDER_REMOVE: `${prefix} folder remove`,
+    FOLDER_RENAME: `${prefix} folder rename`,
     FOLDER_SET: `${prefix} folder set`,
     FOLDER_RETENTIONLABEL_ENSURE: `${prefix} folder retentionlabel ensure`,
     FOLDER_RETENTIONLABEL_REMOVE: `${prefix} folder retentionlabel remove`,

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

@@ -0,0 +1,106 @@
+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 _TeamsMessageRestoreCommand_instances, _TeamsMessageRestoreCommand_initTelemetry, _TeamsMessageRestoreCommand_initOptions, _TeamsMessageRestoreCommand_initValidators, _TeamsMessageRestoreCommand_initOptionSets, _TeamsMessageRestoreCommand_initTypes;
+import request from '../../../../request.js';
+import { validation } from '../../../../utils/validation.js';
+import commands from '../../commands.js';
+import DelegatedGraphCommand from '../../../base/DelegatedGraphCommand.js';
+import { teams } from '../../../../utils/teams.js';
+class TeamsMessageRestoreCommand extends DelegatedGraphCommand {
+    get name() {
+        return commands.MESSAGE_RESTORE;
+    }
+    get description() {
+        return 'Restores a deleted message from a channel in a Microsoft Teams team';
+    }
+    constructor() {
+        super();
+        _TeamsMessageRestoreCommand_instances.add(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _TeamsMessageRestoreCommand_instances, "m", _TeamsMessageRestoreCommand_initTypes).call(this);
+    }
+    async commandAction(logger, args) {
+        try {
+            if (this.verbose) {
+                await logger.logToStderr(`Restoring deleted message '${args.options.id}' from channel '${args.options.channelId || args.options.channelName}' in the Microsoft Teams team '${args.options.teamId || args.options.teamName}'.`);
+            }
+            const teamId = await this.getTeamId(args.options, logger);
+            const channelId = await this.getChannelId(args.options, teamId, logger);
+            const requestOptions = {
+                url: `${this.resource}/v1.0/teams/${teamId}/channels/${channelId}/messages/${args.options.id}/undoSoftDelete`,
+                headers: {
+                    accept: 'application/json;odata.metadata=none'
+                },
+                responseType: 'json'
+            };
+            await request.post(requestOptions);
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getTeamId(options, logger) {
+        if (options.teamId) {
+            return options.teamId;
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Getting the Team ID.`);
+        }
+        const groupId = await teams.getTeamIdByDisplayName(options.teamName);
+        return groupId;
+    }
+    async getChannelId(options, teamId, logger) {
+        if (options.channelId) {
+            return options.channelId;
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Getting the channel ID.`);
+        }
+        const channelId = await teams.getChannelIdByDisplayName(teamId, options.channelName);
+        return channelId;
+    }
+}
+_TeamsMessageRestoreCommand_instances = new WeakSet(), _TeamsMessageRestoreCommand_initTelemetry = function _TeamsMessageRestoreCommand_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'
+        });
+    });
+}, _TeamsMessageRestoreCommand_initOptions = function _TeamsMessageRestoreCommand_initOptions() {
+    this.options.unshift({
+        option: '--teamId [teamId]'
+    }, {
+        option: '--teamName [teamName]'
+    }, {
+        option: '--channelId [channelId]'
+    }, {
+        option: '--channelName [channelName]'
+    }, {
+        option: '-i, --id <id>'
+    });
+}, _TeamsMessageRestoreCommand_initValidators = function _TeamsMessageRestoreCommand_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;
+    });
+}, _TeamsMessageRestoreCommand_initOptionSets = function _TeamsMessageRestoreCommand_initOptionSets() {
+    this.optionSets.push({ options: ['teamId', 'teamName'] }, { options: ['channelId', 'channelName'] });
+}, _TeamsMessageRestoreCommand_initTypes = function _TeamsMessageRestoreCommand_initTypes() {
+    this.types.string.push('teamId', 'teamName', 'channelId', 'channelName', 'id');
+};
+export default new TeamsMessageRestoreCommand();
+//# sourceMappingURL=message-restore.js.map

package/dist/m365/teams/commands.js

@@ -39,6 +39,7 @@ export default {
     MESSAGE_LIST: `${prefix} message list`,
     MESSAGE_REMOVE: `${prefix} message remove`,
     MESSAGE_REPLY_LIST: `${prefix} message reply list`,
+    MESSAGE_RESTORE: `${prefix} message restore`,
     MESSAGE_SEND: `${prefix} message send`,
     MESSAGINGSETTINGS_LIST: `${prefix} messagingsettings list`,
     MESSAGINGSETTINGS_SET: `${prefix} messagingsettings set`,

package/dist/settingsNames.js

@@ -1,6 +1,11 @@
 const settingsNames = {
     authType: 'authType',
     autoOpenLinksInBrowser: 'autoOpenLinksInBrowser',
+    clientId: 'clientId',
+    clientSecret: 'clientSecret',
+    clientCertificateFile: 'clientCertificateFile',
+    clientCertificateBase64Encoded: 'clientCertificateBase64Encoded',
+    clientCertificatePassword: 'clientCertificatePassword',
     copyDeviceCodeToClipboard: 'copyDeviceCodeToClipboard',
     csvEscape: 'csvEscape',
     csvHeader: 'csvHeader',
@@ -16,7 +21,8 @@ const settingsNames = {
     prompt: 'prompt',
     promptListPageSize: 'promptListPageSize',
     showHelpOnFailure: 'showHelpOnFailure',
-    showSpinner: 'showSpinner'
+    showSpinner: 'showSpinner',
+    tenantId: 'tenantId'
 };
 export { settingsNames };
 //# sourceMappingURL=settingsNames.js.map

package/dist/utils/entraApp.js

@@ -0,0 +1,283 @@
+import fs from 'fs';
+import request from '../request.js';
+import { odata } from './odata.js';
+async function getCertificateBase64Encoded({ options, logger, debug }) {
+    if (options.certificateBase64Encoded) {
+        return options.certificateBase64Encoded;
+    }
+    if (debug) {
+        await logger.logToStderr(`Reading existing ${options.certificateFile}...`);
+    }
+    try {
+        return fs.readFileSync(options.certificateFile, { encoding: 'base64' });
+    }
+    catch (e) {
+        throw new Error(`Error reading certificate file: ${e}. Please add the certificate using base64 option '--certificateBase64Encoded'.`);
+    }
+}
+async function createServicePrincipal(appId) {
+    const requestOptions = {
+        url: `https://graph.microsoft.com/v1.0/myorganization/servicePrincipals`,
+        headers: {
+            'content-type': 'application/json'
+        },
+        data: {
+            appId: appId
+        },
+        responseType: 'json'
+    };
+    return request.post(requestOptions);
+}
+async function grantOAuth2Permission({ appId, resourceId, scopeName }) {
+    const grantAdminConsentApplicationRequestOptions = {
+        url: `https://graph.microsoft.com/v1.0/myorganization/oauth2PermissionGrants`,
+        headers: {
+            accept: 'application/json;odata.metadata=none'
+        },
+        responseType: 'json',
+        data: {
+            clientId: appId,
+            consentType: "AllPrincipals",
+            principalId: null,
+            resourceId: resourceId,
+            scope: scopeName
+        }
+    };
+    return request.post(grantAdminConsentApplicationRequestOptions);
+}
+async function addRoleToServicePrincipal({ objectId, resourceId, appRoleId }) {
+    const requestOptions = {
+        url: `https://graph.microsoft.com/v1.0/myorganization/servicePrincipals/${objectId}/appRoleAssignments`,
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        responseType: 'json',
+        data: {
+            appRoleId: appRoleId,
+            principalId: objectId,
+            resourceId: resourceId
+        }
+    };
+    return request.post(requestOptions);
+}
+async function getRequiredResourceAccessForApis({ servicePrincipals, apis, scopeType, logger, debug }) {
+    if (!apis) {
+        return [];
+    }
+    const resolvedApis = [];
+    const requestedApis = apis.split(',').map(a => a.trim());
+    for (const api of requestedApis) {
+        const pos = api.lastIndexOf('/');
+        const permissionName = api.substring(pos + 1);
+        const servicePrincipalName = api.substring(0, pos);
+        if (debug) {
+            await logger.logToStderr(`Resolving ${api}...`);
+            await logger.logToStderr(`Permission name: ${permissionName}`);
+            await logger.logToStderr(`Service principal name: ${servicePrincipalName}`);
+        }
+        const servicePrincipal = servicePrincipals.find(sp => (sp.servicePrincipalNames.indexOf(servicePrincipalName) > -1 ||
+            sp.servicePrincipalNames.indexOf(`${servicePrincipalName}/`) > -1));
+        if (!servicePrincipal) {
+            throw `Service principal ${servicePrincipalName} not found`;
+        }
+        const scopesOfType = scopeType === 'Scope' ? servicePrincipal.oauth2PermissionScopes : servicePrincipal.appRoles;
+        const permission = scopesOfType.find(scope => scope.value === permissionName);
+        if (!permission) {
+            throw `Permission ${permissionName} for service principal ${servicePrincipalName} not found`;
+        }
+        let resolvedApi = resolvedApis.find(a => a.resourceAppId === servicePrincipal.appId);
+        if (!resolvedApi) {
+            resolvedApi = {
+                resourceAppId: servicePrincipal.appId,
+                resourceAccess: []
+            };
+            resolvedApis.push(resolvedApi);
+        }
+        const resourceAccessPermission = {
+            id: permission.id,
+            type: scopeType
+        };
+        resolvedApi.resourceAccess.push(resourceAccessPermission);
+        updateAppPermissions({
+            spId: servicePrincipal.id,
+            resourceAccessPermission,
+            oAuth2PermissionValue: permission.value
+        });
+    }
+    return resolvedApis;
+}
+function updateAppPermissions({ spId, resourceAccessPermission, oAuth2PermissionValue }) {
+    // During API resolution, we store globally both app role assignments and oauth2permissions
+    // So that we'll be able to parse them during the admin consent process
+    let existingPermission = entraApp.appPermissions.find(oauth => oauth.resourceId === spId);
+    if (!existingPermission) {
+        existingPermission = {
+            resourceId: spId,
+            resourceAccess: [],
+            scope: []
+        };
+        entraApp.appPermissions.push(existingPermission);
+    }
+    if (resourceAccessPermission.type === 'Scope' && oAuth2PermissionValue && !existingPermission.scope.find(scp => scp === oAuth2PermissionValue)) {
+        existingPermission.scope.push(oAuth2PermissionValue);
+    }
+    if (!existingPermission.resourceAccess.find(res => res.id === resourceAccessPermission.id)) {
+        existingPermission.resourceAccess.push(resourceAccessPermission);
+    }
+}
+export const entraApp = {
+    appPermissions: [],
+    createAppRegistration: async ({ options, apis, logger, verbose, debug }) => {
+        const applicationInfo = {
+            displayName: options.name,
+            signInAudience: options.multitenant ? 'AzureADMultipleOrgs' : 'AzureADMyOrg'
+        };
+        if (apis.length > 0) {
+            applicationInfo.requiredResourceAccess = apis;
+        }
+        if (options.redirectUris) {
+            applicationInfo[options.platform] = {
+                redirectUris: options.redirectUris.split(',').map(u => u.trim())
+            };
+        }
+        if (options.implicitFlow) {
+            if (!applicationInfo.web) {
+                applicationInfo.web = {};
+            }
+            applicationInfo.web.implicitGrantSettings = {
+                enableAccessTokenIssuance: true,
+                enableIdTokenIssuance: true
+            };
+        }
+        if (options.certificateFile || options.certificateBase64Encoded) {
+            const certificateBase64Encoded = await getCertificateBase64Encoded({ options, logger, debug });
+            const newKeyCredential = {
+                type: 'AsymmetricX509Cert',
+                usage: 'Verify',
+                displayName: options.certificateDisplayName,
+                key: certificateBase64Encoded
+            };
+            applicationInfo.keyCredentials = [newKeyCredential];
+        }
+        if (options.allowPublicClientFlows) {
+            applicationInfo.isFallbackPublicClient = true;
+        }
+        if (verbose) {
+            await logger.logToStderr(`Creating Microsoft Entra app registration...`);
+        }
+        const createApplicationRequestOptions = {
+            url: `https://graph.microsoft.com/v1.0/myorganization/applications`,
+            headers: {
+                accept: 'application/json;odata.metadata=none'
+            },
+            responseType: 'json',
+            data: applicationInfo
+        };
+        return request.post(createApplicationRequestOptions);
+    },
+    grantAdminConsent: async ({ appInfo, appPermissions, adminConsent, logger, debug }) => {
+        if (!adminConsent || appPermissions.length === 0) {
+            return appInfo;
+        }
+        const sp = await createServicePrincipal(appInfo.appId);
+        if (debug) {
+            await logger.logToStderr("Service principal created, returned object id: " + sp.id);
+        }
+        const tasks = [];
+        appPermissions.forEach(async (permission) => {
+            if (permission.scope.length > 0) {
+                tasks.push(grantOAuth2Permission({
+                    appId: sp.id,
+                    resourceId: permission.resourceId,
+                    scopeName: permission.scope.join(' ')
+                }));
+                if (debug) {
+                    await logger.logToStderr(`Admin consent granted for following resource ${permission.resourceId}, with delegated permissions: ${permission.scope.join(',')}`);
+                }
+            }
+            permission.resourceAccess.filter(access => access.type === "Role").forEach(async (access) => {
+                tasks.push(addRoleToServicePrincipal({
+                    objectId: sp.id,
+                    resourceId: permission.resourceId,
+                    appRoleId: access.id
+                }));
+                if (debug) {
+                    await logger.logToStderr(`Admin consent granted for following resource ${permission.resourceId}, with application permission: ${access.id}`);
+                }
+            });
+        });
+        await Promise.all(tasks);
+        return appInfo;
+    },
+    resolveApis: async ({ options, manifest, logger, verbose, debug }) => {
+        if (!options.apisDelegated && !options.apisApplication
+            && (typeof manifest?.requiredResourceAccess === 'undefined' || manifest.requiredResourceAccess.length === 0)) {
+            return [];
+        }
+        if (verbose) {
+            await logger.logToStderr('Resolving requested APIs...');
+        }
+        const servicePrincipals = await odata.getAllItems(`https://graph.microsoft.com/v1.0/myorganization/servicePrincipals?$select=appId,appRoles,id,oauth2PermissionScopes,servicePrincipalNames`);
+        let resolvedApis = [];
+        if (options.apisDelegated || options.apisApplication) {
+            resolvedApis = await getRequiredResourceAccessForApis({
+                servicePrincipals,
+                apis: options.apisDelegated,
+                scopeType: 'Scope',
+                logger,
+                debug
+            });
+            if (verbose) {
+                await logger.logToStderr(`Resolved delegated permissions: ${JSON.stringify(resolvedApis, null, 2)}`);
+            }
+            const resolvedApplicationApis = await getRequiredResourceAccessForApis({
+                servicePrincipals,
+                apis: options.apisApplication,
+                scopeType: 'Role',
+                logger,
+                debug
+            });
+            if (verbose) {
+                await logger.logToStderr(`Resolved application permissions: ${JSON.stringify(resolvedApplicationApis, null, 2)}`);
+            }
+            // merge resolved application APIs onto resolved delegated APIs
+            resolvedApplicationApis.forEach(resolvedRequiredResource => {
+                const requiredResource = resolvedApis.find(api => api.resourceAppId === resolvedRequiredResource.resourceAppId);
+                if (requiredResource) {
+                    requiredResource.resourceAccess.push(...resolvedRequiredResource.resourceAccess);
+                }
+                else {
+                    resolvedApis.push(resolvedRequiredResource);
+                }
+            });
+        }
+        else {
+            const manifestApis = manifest.requiredResourceAccess;
+            manifestApis.forEach(manifestApi => {
+                resolvedApis.push(manifestApi);
+                const app = servicePrincipals.find(servicePrincipals => servicePrincipals.appId === manifestApi.resourceAppId);
+                if (app) {
+                    manifestApi.resourceAccess.forEach((res => {
+                        const resourceAccessPermission = {
+                            id: res.id,
+                            type: res.type
+                        };
+                        const oAuthValue = app.oauth2PermissionScopes.find(scp => scp.id === res.id)?.value;
+                        updateAppPermissions({
+                            spId: app.id,
+                            resourceAccessPermission,
+                            oAuth2PermissionValue: oAuthValue
+                        });
+                    }));
+                }
+            });
+        }
+        if (verbose) {
+            await logger.logToStderr(`Merged delegated and application permissions: ${JSON.stringify(resolvedApis, null, 2)}`);
+            await logger.logToStderr(`App role assignments: ${JSON.stringify(entraApp.appPermissions.flatMap(permission => permission.resourceAccess.filter(access => access.type === "Role")), null, 2)}`);
+            await logger.logToStderr(`OAuth2 permissions: ${JSON.stringify(entraApp.appPermissions.flatMap(permission => permission.scope), null, 2)}`);
+        }
+        return resolvedApis;
+    }
+};
+//# sourceMappingURL=entraApp.js.map

package/dist/utils/spo.js

@@ -12,16 +12,6 @@ import { RoleType } from '../m365/spo/commands/roledefinition/RoleType.js';
 import { entraGroup } from './entraGroup.js';
 import { SharingCapabilities } from '../m365/spo/commands/site/SharingCapabilities.js';
 import { setTimeout } from 'timers/promises';
-export var CreateCopyJobsNameConflictBehavior;
-(function (CreateCopyJobsNameConflictBehavior) {
-    CreateCopyJobsNameConflictBehavior[CreateCopyJobsNameConflictBehavior["Fail"] = 0] = "Fail";
-    CreateCopyJobsNameConflictBehavior[CreateCopyJobsNameConflictBehavior["Replace"] = 1] = "Replace";
-    CreateCopyJobsNameConflictBehavior[CreateCopyJobsNameConflictBehavior["Rename"] = 2] = "Rename";
-})(CreateCopyJobsNameConflictBehavior || (CreateCopyJobsNameConflictBehavior = {}));
-// Wrapping this into a settings object so we can alter the values in tests
-export const settings = {
-    pollingInterval: 3000
-};
 export const spo = {
     async getRequestDigest(siteUrl) {
         const requestOptions = {
@@ -1526,70 +1516,6 @@ export const spo = {
         };
         const itemsResponse = await request.get(requestOptionsItems);
         return (itemsResponse);
-    },
-    /**
-     * Create a SharePoint copy job to copy a file/folder to another location.
-     * @param webUrl Absolute web URL where the source file/folder is located.
-     * @param sourceUrl Absolute URL of the source file/folder.
-     * @param destinationUrl Absolute URL of the destination folder.
-     * @param options Options for the copy job.
-     * @returns Copy job information. Use {@link spo.getCopyJobResult} to get the result of the copy job.
-     */
-    async createCopyJob(webUrl, sourceUrl, destinationUrl, options) {
-        const requestOptions = {
-            url: `${webUrl}/_api/Site/CreateCopyJobs`,
-            headers: {
-                accept: 'application/json;odata=nometadata'
-            },
-            responseType: 'json',
-            data: {
-                destinationUri: destinationUrl,
-                exportObjectUris: [sourceUrl],
-                options: {
-                    NameConflictBehavior: options?.nameConflictBehavior ?? CreateCopyJobsNameConflictBehavior.Fail,
-                    AllowSchemaMismatch: true,
-                    BypassSharedLock: !!options?.bypassSharedLock,
-                    IgnoreVersionHistory: !!options?.ignoreVersionHistory,
-                    CustomizedItemName: options?.newName ? [options.newName] : undefined,
-                    SameWebCopyMoveOptimization: true
-                }
-            }
-        };
-        const response = await request.post(requestOptions);
-        return response.value[0];
-    },
-    /**
-     * Poll until the copy job is finished and return the result.
-     * @param webUrl Absolute web URL where the copy job was created.
-     * @param copyJobInfo Information about the copy job.
-     * @throws Error if the copy job has failed.
-     * @returns Information about the destination object.
-     */
-    async getCopyJobResult(webUrl, copyJobInfo) {
-        const requestOptions = {
-            url: `${webUrl}/_api/Site/GetCopyJobProgress`,
-            headers: {
-                accept: 'application/json;odata=nometadata'
-            },
-            responseType: 'json',
-            data: {
-                copyJobInfo: copyJobInfo
-            }
-        };
-        let progress = await request.post(requestOptions);
-        while (progress.JobState !== 0) {
-            await setTimeout(settings.pollingInterval);
-            progress = await request.post(requestOptions);
-        }
-        const logs = progress.Logs.map(l => JSON.parse(l));
-        // Check if the job has failed
-        const errorLog = logs.find(l => l.Event === 'JobError');
-        if (errorLog) {
-            throw new Error(errorLog.Message);
-        }
-        // Get the destination object information
-        const objectInfo = logs.find(l => l.Event === 'JobFinishedObjectInfo');
-        return objectInfo;
     }
 };
 //# sourceMappingURL=spo.js.map

package/docs/docs/_clisettings.mdx

@@ -2,6 +2,11 @@ Setting name|Definition|Default value
 ------------|----------|-------------
 `authType`|Default login method to use when running `m365 login` without the `--authType` option.|`deviceCode`
 `autoOpenLinksInBrowser`|Automatically open the browser for all commands which return a url and expect the user to copy paste this to the browser. For example when logging in, using `m365 login` in device code mode.|`false`
+`clientId`|ID of the default Entra ID app use by the CLI to authenticate|``
+`clientSecret`|Secret of the default Entra ID app use by the CLI to authenticate|``
+`clientCertificateFile`|Path to the file containing the client certificate to use for authentication|``
+`clientCertificateBase64Encoded`|Base64-encoded client certificate contents|``
+`clientCertificatePassword`|Password to the client certificate file|``
 `copyDeviceCodeToClipboard`|Automatically copy the device code to the clipboard when running `m365 login` command in device code mode|`false`
 `csvEscape`|Single character used for escaping; only apply to characters matching the quote and the escape options|`"`
 `csvHeader`|Display the column names on the first line|`true`
@@ -18,3 +23,4 @@ Setting name|Definition|Default value
 `promptListPageSize`|By default, lists of choices longer than 7 will be paginated. Use this option to control how many choices will appear on the screen at once.|7
 `showHelpOnFailure`|Automatically display help when executing a command failed|`true`
 `showSpinner`|Display spinner when executing commands|`true`
+`tenantId`|ID of the default tenant to use when authenticating with|``

package/docs/docs/cmd/app/permission/permission-add.mdx

@@ -16,10 +16,10 @@ m365 app permission add [options]
 `--appId [appId]`
 : Client ID of the Microsoft Entra app registered in the .m365rc.json file to retrieve API permissions for.
 
-`--applicationPermissions [applicationPermissions]`
+`--applicationPermission [applicationPermission]`
 : Space-separated list of application permissions to add.
 
-`--delegatedPermissions [delegatedPermissions]`
+`--delegatedPermission [delegatedPermission]`
 : Space-separated list of delegated permissions to add.
 
 `--grantAdminConsent`
@@ -37,19 +37,19 @@ If you have multiple apps registered in your .m365rc.json file, you can specify
 Adds the specified application permissions to the default app registered in the _.m365rc.json_ file while granting admin consent.
 
 ```sh
-m365 app permission add --applicationPermissions 'https://graph.microsoft.com/User.ReadWrite.All https://graph.microsoft.com/User.Read.All' --grantAdminConsent
+m365 app permission add --applicationPermission 'https://graph.microsoft.com/User.ReadWrite.All https://graph.microsoft.com/User.Read.All' --grantAdminConsent
 ```
 
 Adds the specified delegated permissions to the default app registered in the _.m365rc.json_ file without granting admin consent.
 
 ```sh
-m365 app permission add --delegatedPermissions 'https://graph.microsoft.com/offline_access'
+m365 app permission add --delegatedPermission 'https://graph.microsoft.com/offline_access'
 ```
 
 Adds the specified application and delegated permissions to a specific app registered in the _.m365rc.json_ file while granting admin consent.
 
 ```sh
-m365 app permission add --appId '1663767b-4172-4519-bfd1-28e6ff19055b' --applicationPermissions 'https://graph.microsoft.com/User.ReadWrite.All https://graph.microsoft.com/User.Read.All' --delegatedPermissions 'https://graph.microsoft.com/offline_access' --grantAdminConsent
+m365 app permission add --appId '1663767b-4172-4519-bfd1-28e6ff19055b' --applicationPermission 'https://graph.microsoft.com/User.ReadWrite.All https://graph.microsoft.com/User.Read.All' --delegatedPermission 'https://graph.microsoft.com/offline_access' --grantAdminConsent
 ```
 
 ## Response