@pnp/cli-microsoft365 10.8.0-beta.a51d886 → 10.8.0

package/dist/m365/spe/commands/containertype/containertype-get.js

@@ -3,14 +3,15 @@ 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 _SpeContainertypeGetCommand_instances, _SpeContainertypeGetCommand_initTelemetry, _SpeContainertypeGetCommand_initOptions, _SpeContainertypeGetCommand_initOptionSets, _SpeContainertypeGetCommand_initValidators, _SpeContainertypeGetCommand_initTypes;
+var _SpeContainerTypeGetCommand_instances, _SpeContainerTypeGetCommand_initTelemetry, _SpeContainerTypeGetCommand_initOptions, _SpeContainerTypeGetCommand_initOptionSets, _SpeContainerTypeGetCommand_initValidators, _SpeContainerTypeGetCommand_initTypes;
 import config from '../../../../config.js';
 import request from '../../../../request.js';
+import { spe } from '../../../../utils/spe.js';
 import { spo } from '../../../../utils/spo.js';
 import { validation } from '../../../../utils/validation.js';
 import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
-class SpeContainertypeGetCommand extends SpoCommand {
+class SpeContainerTypeGetCommand extends SpoCommand {
     get name() {
         return commands.CONTAINERTYPE_GET;
     }
@@ -19,85 +20,80 @@ class SpeContainertypeGetCommand extends SpoCommand {
     }
     constructor() {
         super();
-        _SpeContainertypeGetCommand_instances.add(this);
-        __classPrivateFieldGet(this, _SpeContainertypeGetCommand_instances, "m", _SpeContainertypeGetCommand_initTelemetry).call(this);
-        __classPrivateFieldGet(this, _SpeContainertypeGetCommand_instances, "m", _SpeContainertypeGetCommand_initOptions).call(this);
-        __classPrivateFieldGet(this, _SpeContainertypeGetCommand_instances, "m", _SpeContainertypeGetCommand_initValidators).call(this);
-        __classPrivateFieldGet(this, _SpeContainertypeGetCommand_instances, "m", _SpeContainertypeGetCommand_initOptionSets).call(this);
-        __classPrivateFieldGet(this, _SpeContainertypeGetCommand_instances, "m", _SpeContainertypeGetCommand_initTypes).call(this);
+        _SpeContainerTypeGetCommand_instances.add(this);
+        __classPrivateFieldGet(this, _SpeContainerTypeGetCommand_instances, "m", _SpeContainerTypeGetCommand_initTelemetry).call(this);
+        __classPrivateFieldGet(this, _SpeContainerTypeGetCommand_instances, "m", _SpeContainerTypeGetCommand_initOptions).call(this);
+        __classPrivateFieldGet(this, _SpeContainerTypeGetCommand_instances, "m", _SpeContainerTypeGetCommand_initValidators).call(this);
+        __classPrivateFieldGet(this, _SpeContainerTypeGetCommand_instances, "m", _SpeContainerTypeGetCommand_initOptionSets).call(this);
+        __classPrivateFieldGet(this, _SpeContainerTypeGetCommand_instances, "m", _SpeContainerTypeGetCommand_initTypes).call(this);
     }
     async commandAction(logger, args) {
         try {
             const spoAdminUrl = await spo.getSpoAdminUrl(logger, this.debug);
-            if (this.verbose) {
-                await logger.logToStderr(`Getting the Container type...`);
-            }
             const containerTypeId = await this.getContainerTypeId(args.options, spoAdminUrl, logger);
-            const allContainerTypes = await this.getContainerTypeById(containerTypeId, spoAdminUrl, logger);
-            await logger.log(allContainerTypes);
+            const containerType = await this.getContainerTypeById(containerTypeId, spoAdminUrl, logger);
+            await logger.log(containerType);
         }
         catch (err) {
-            this.handleRejectedPromise(err);
+            this.handleRejectedODataJsonPromise(err);
         }
     }
     async getContainerTypeById(containerTypeId, spoAdminUrl, logger) {
-        const formDigestInfo = await spo.ensureFormDigest(spoAdminUrl, logger, undefined, this.debug);
+        if (this.verbose) {
+            await logger.logToStderr(`Getting the Container type...`);
+        }
         const requestOptions = {
             url: `${spoAdminUrl}/_vti_bin/client.svc/ProcessQuery`,
             headers: {
-                'X-RequestDigest': formDigestInfo.FormDigestValue
+                accept: 'application/json;odata=nometadata'
             },
+            responseType: 'json',
             data: `<Request AddExpandoFieldTypeSuffix="true" SchemaVersion="15.0.0.0" LibraryVersion="16.0.0.0" ApplicationName="${config.applicationName}" xmlns="http://schemas.microsoft.com/sharepoint/clientquery/2009"><Actions><ObjectPath Id="49" ObjectPathId="48" /><Method Name="GetSPOContainerTypeById" Id="50" ObjectPathId="48"><Parameters><Parameter Type="Guid">{${containerTypeId}}</Parameter><Parameter Type="Enum">1</Parameter></Parameters></Method></Actions><ObjectPaths><Constructor Id="48" TypeId="{268004ae-ef6b-4e9b-8425-127220d84719}" /></ObjectPaths></Request>`
         };
         const res = await request.post(requestOptions);
-        const json = JSON.parse(res);
-        const response = json[0];
+        const response = res[0];
         if (response.ErrorInfo) {
             throw response.ErrorInfo.ErrorMessage;
         }
-        const containerTypes = json[json.length - 1];
+        const containerTypes = res[res.length - 1];
         return containerTypes;
     }
     async getContainerTypeId(options, spoAdminUrl, logger) {
         if (options.id) {
             return options.id;
         }
-        const containerTypes = await spo.getAllContainerTypes(spoAdminUrl, logger, this.debug);
-        // Get id of the container type by name
-        const containerType = containerTypes.find(c => c.DisplayName === options.name);
-        if (!containerType) {
-            throw new Error(`Container type with name ${options.name} not found`);
+        if (this.verbose) {
+            await logger.logToStderr(`Retrieving container type id for container type '${options.containerTypeName}'...`);
         }
-        const match = containerType.ContainerTypeId.match(/\/Guid\(([^)]+)\)\//);
-        return match[1];
+        return spe.getContainerTypeIdByName(spoAdminUrl, options.name);
     }
 }
-_SpeContainertypeGetCommand_instances = new WeakSet(), _SpeContainertypeGetCommand_initTelemetry = function _SpeContainertypeGetCommand_initTelemetry() {
+_SpeContainerTypeGetCommand_instances = new WeakSet(), _SpeContainerTypeGetCommand_initTelemetry = function _SpeContainerTypeGetCommand_initTelemetry() {
     this.telemetry.push((args) => {
         Object.assign(this.telemetryProperties, {
             id: typeof args.options.id !== 'undefined',
             name: typeof args.options.name !== 'undefined'
         });
     });
-}, _SpeContainertypeGetCommand_initOptions = function _SpeContainertypeGetCommand_initOptions() {
+}, _SpeContainerTypeGetCommand_initOptions = function _SpeContainerTypeGetCommand_initOptions() {
     this.options.unshift({
         option: '-i, --id [id]'
     }, {
         option: '-n, --name [name]'
     });
-}, _SpeContainertypeGetCommand_initOptionSets = function _SpeContainertypeGetCommand_initOptionSets() {
+}, _SpeContainerTypeGetCommand_initOptionSets = function _SpeContainerTypeGetCommand_initOptionSets() {
     this.optionSets.push({
         options: ['id', 'name']
     });
-}, _SpeContainertypeGetCommand_initValidators = function _SpeContainertypeGetCommand_initValidators() {
+}, _SpeContainerTypeGetCommand_initValidators = function _SpeContainerTypeGetCommand_initValidators() {
     this.validators.push(async (args) => {
         if (args.options.id && !validation.isValidGuid(args.options.id)) {
             return `${args.options.id} is not a valid GUID`;
         }
         return true;
     });
-}, _SpeContainertypeGetCommand_initTypes = function _SpeContainertypeGetCommand_initTypes() {
+}, _SpeContainerTypeGetCommand_initTypes = function _SpeContainerTypeGetCommand_initTypes() {
     this.types.string.push('id', 'name');
 };
-export default new SpeContainertypeGetCommand();
+export default new SpeContainerTypeGetCommand();
 //# sourceMappingURL=containertype-get.js.map

package/dist/m365/spe/commands/containertype/containertype-list.js

@@ -1,7 +1,8 @@
 import SpoCommand from '../../../base/SpoCommand.js';
 import commands from '../../commands.js';
+import { spe } from '../../../../utils/spe.js';
 import { spo } from '../../../../utils/spo.js';
-class SpeContainertypeListCommand extends SpoCommand {
+class SpeContainerTypeListCommand extends SpoCommand {
     get name() {
         return commands.CONTAINERTYPE_LIST;
     }
@@ -17,13 +18,22 @@ class SpeContainertypeListCommand extends SpoCommand {
             if (this.verbose) {
                 await logger.logToStderr(`Retrieving list of Container types...`);
             }
-            const allContainerTypes = await spo.getAllContainerTypes(spoAdminUrl, logger, this.debug);
-            await logger.log(allContainerTypes);
+            const allContainerTypes = await spe.getAllContainerTypes(spoAdminUrl);
+            // The following conversion is done in order not to make breaking changes
+            const result = allContainerTypes.map(ct => ({
+                _ObjectType_: 'Microsoft.Online.SharePoint.TenantAdministration.SPContainerTypeProperties',
+                ...ct,
+                AzureSubscriptionId: `/Guid(${ct.AzureSubscriptionId})/`,
+                ContainerTypeId: `/Guid(${ct.ContainerTypeId})/`,
+                OwningAppId: `/Guid(${ct.OwningAppId})/`,
+                OwningTenantId: `/Guid(${ct.OwningTenantId})/`
+            }));
+            await logger.log(result);
         }
         catch (err) {
             this.handleRejectedPromise(err);
         }
     }
 }
-export default new SpeContainertypeListCommand();
+export default new SpeContainerTypeListCommand();
 //# sourceMappingURL=containertype-list.js.map

package/dist/m365/spe/commands/containertype/containertype-remove.js

@@ -0,0 +1,81 @@
+import { globalOptionsZod } from '../../../../Command.js';
+import { z } from 'zod';
+import { zod } from '../../../../utils/zod.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+import { spo } from '../../../../utils/spo.js';
+import { spe } from '../../../../utils/spe.js';
+import { cli } from '../../../../cli/cli.js';
+import { validation } from '../../../../utils/validation.js';
+import request from '../../../../request.js';
+import config from '../../../../config.js';
+const options = globalOptionsZod
+    .extend({
+    id: zod.alias('i', z.string()
+        .refine(id => validation.isValidGuid(id), id => ({
+        message: `'${id}' is not a valid GUID.`
+    }))
+        .optional()),
+    name: zod.alias('n', z.string().optional()),
+    force: zod.alias('f', z.boolean().optional())
+})
+    .strict();
+class SpeContainerTypeRemoveCommand extends SpoCommand {
+    get name() {
+        return commands.CONTAINERTYPE_REMOVE;
+    }
+    get description() {
+        return 'Remove a specific container type';
+    }
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => [options.id, options.name].filter(o => o !== undefined).length === 1, {
+            message: 'Use one of the following options: id, name.'
+        });
+    }
+    async commandAction(logger, args) {
+        if (!args.options.force) {
+            const result = await cli.promptForConfirmation({ message: `Are you sure you want to remove container type ${args.options.id || args.options.name}?` });
+            if (!result) {
+                return;
+            }
+        }
+        try {
+            const spoAdminUrl = await spo.getSpoAdminUrl(logger, this.verbose);
+            const containerTypeId = await this.getContainerTypeId(args.options, spoAdminUrl, logger);
+            const formDigestInfo = await spo.ensureFormDigest(spoAdminUrl, logger, undefined, this.debug);
+            if (this.verbose) {
+                await logger.logToStderr(`Removing container type ${args.options.id || args.options.name}...`);
+            }
+            const requestOptions = {
+                url: `${spoAdminUrl}/_vti_bin/client.svc/ProcessQuery`,
+                headers: {
+                    'X-RequestDigest': formDigestInfo.FormDigestValue
+                },
+                responseType: 'json',
+                data: `<Request AddExpandoFieldTypeSuffix="true" SchemaVersion="15.0.0.0" LibraryVersion="16.0.0.0" ApplicationName="${config.applicationName}" xmlns="http://schemas.microsoft.com/sharepoint/clientquery/2009"><Actions><ObjectPath Id="7" ObjectPathId="6" /><Method Name="RemoveSPOContainerType" Id="8" ObjectPathId="6"><Parameters><Parameter TypeId="{b66ab1ca-fd51-44f9-8cfc-01f5c2a21f99}"><Property Name="ContainerTypeId" Type="Guid">{${containerTypeId}}</Property></Parameter></Parameters></Method></Actions><ObjectPaths><Constructor Id="6" TypeId="{268004ae-ef6b-4e9b-8425-127220d84719}" /></ObjectPaths></Request>`
+            };
+            const result = await request.post(requestOptions);
+            if (result[0].ErrorInfo) {
+                throw result[0].ErrorInfo.ErrorMessage;
+            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    async getContainerTypeId(options, spoAdminUrl, logger) {
+        if (options.id) {
+            return options.id;
+        }
+        if (this.verbose) {
+            await logger.logToStderr(`Retrieving container type id for container type '${options.name}'...`);
+        }
+        return spe.getContainerTypeIdByName(spoAdminUrl, options.name);
+    }
+}
+export default new SpeContainerTypeRemoveCommand();
+//# sourceMappingURL=containertype-remove.js.map

package/dist/m365/spe/commands.js

@@ -1,11 +1,15 @@
 const prefix = 'spe';
 export default {
     CONTAINER_ACTIVATE: `${prefix} container activate`,
+    CONTAINER_ADD: `${prefix} container add`,
     CONTAINER_GET: `${prefix} container get`,
     CONTAINER_LIST: `${prefix} container list`,
+    CONTAINER_REMOVE: `${prefix} container remove`,
     CONTAINER_PERMISSION_LIST: `${prefix} container permission list`,
+    CONTAINER_RECYCLEBINITEM_LIST: `${prefix} container recyclebinitem list`,
     CONTAINERTYPE_ADD: `${prefix} containertype add`,
     CONTAINERTYPE_GET: `${prefix} containertype get`,
-    CONTAINERTYPE_LIST: `${prefix} containertype list`
+    CONTAINERTYPE_LIST: `${prefix} containertype list`,
+    CONTAINERTYPE_REMOVE: `${prefix} containertype remove`
 };
 //# sourceMappingURL=commands.js.map

package/dist/m365/spo/commands/list/list-get.js

@@ -43,6 +43,9 @@ class SpoListGetCommand extends SpoCommand {
             const listServerRelativeUrl = urlUtil.getServerRelativePath(args.options.webUrl, args.options.url);
             requestUrl += `GetList('${formatting.encodeQueryParameter(listServerRelativeUrl)}')`;
         }
+        else if (args.options.default) {
+            requestUrl += `DefaultDocumentLibrary`;
+        }
         const fieldsProperties = this.formatSelectProperties(args.options.properties, args.options.withPermissions);
         const queryParams = [];
         if (fieldsProperties.selectProperties.length > 0) {
@@ -113,11 +116,12 @@ class SpoListGetCommand extends SpoCommand {
 _SpoListGetCommand_instances = new WeakSet(), _SpoListGetCommand_initTelemetry = function _SpoListGetCommand_initTelemetry() {
     this.telemetry.push((args) => {
         Object.assign(this.telemetryProperties, {
-            id: (!(!args.options.id)).toString(),
-            title: (!(!args.options.title)).toString(),
-            url: (!(!args.options.url)).toString(),
-            properties: (!(!args.options.properties)).toString(),
-            withPermissions: typeof args.options.withPermissions !== 'undefined'
+            id: typeof args.options.id !== 'undefined',
+            title: typeof args.options.title !== 'undefined',
+            url: typeof args.options.url !== 'undefined',
+            properties: typeof args.options.properties !== 'undefined',
+            withPermissions: !!args.options.withPermissions,
+            default: !!args.options.default
         });
     });
 }, _SpoListGetCommand_initOptions = function _SpoListGetCommand_initOptions() {
@@ -129,6 +133,8 @@ _SpoListGetCommand_instances = new WeakSet(), _SpoListGetCommand_initTelemetry =
         option: '-t, --title [title]'
     }, {
         option: '--url [url]'
+    }, {
+        option: '--default'
     }, {
         option: '-p, --properties [properties]'
     }, {
@@ -148,7 +154,7 @@ _SpoListGetCommand_instances = new WeakSet(), _SpoListGetCommand_initTelemetry =
         return true;
     });
 }, _SpoListGetCommand_initOptionSets = function _SpoListGetCommand_initOptionSets() {
-    this.optionSets.push({ options: ['id', 'title', 'url'] });
+    this.optionSets.push({ options: ['id', 'title', 'url', 'default'] });
 };
 export default new SpoListGetCommand();
 //# sourceMappingURL=list-get.js.map

package/dist/m365/spp/commands/model/model-apply.js

@@ -0,0 +1,130 @@
+import request from '../../../../request.js';
+import { formatting } from '../../../../utils/formatting.js';
+import { spp } from '../../../../utils/spp.js';
+import { urlUtil } from '../../../../utils/urlUtil.js';
+import { validation } from '../../../../utils/validation.js';
+import SpoCommand from '../../../base/SpoCommand.js';
+import commands from '../../commands.js';
+import { z } from 'zod';
+import { globalOptionsZod } from '../../../../Command.js';
+import { zod } from '../../../../utils/zod.js';
+const options = globalOptionsZod
+    .extend({
+    contentCenterUrl: zod.alias('c', z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, url => ({
+        message: `'${url}' is not a valid SharePoint Online site URL.`
+    }))),
+    webUrl: zod.alias('u', z.string()
+        .refine(url => validation.isValidSharePointUrl(url) === true, url => ({
+        message: `'${url}' is not a valid SharePoint Online site URL.`
+    }))),
+    id: zod.alias('i', z.string()
+        .refine(id => validation.isValidGuid(id) === true, id => ({
+        message: `${id} is not a valid GUID.`
+    })).optional()),
+    title: zod.alias('t', z.string()).optional(),
+    listTitle: z.string().optional(),
+    listId: z.string()
+        .refine(listId => validation.isValidGuid(listId) === true, listId => ({
+        message: `${listId} is not a valid GUID.`
+    })).optional(),
+    listUrl: z.string().optional(),
+    viewOption: z.enum(['NewViewAsDefault', 'DoNotChangeDefault', 'TileViewAsDefault']).optional()
+})
+    .strict();
+class SppModelApplyCommand extends SpoCommand {
+    get name() {
+        return commands.MODEL_APPLY;
+    }
+    get description() {
+        return 'Applies (or syncs) a trained document understanding model to a document library';
+    }
+    get schema() {
+        return options;
+    }
+    getRefinedSchema(schema) {
+        return schema
+            .refine(options => [options.id, options.title].filter(x => x !== undefined).length === 1, {
+            message: `Specify exactly one of the following options: 'id' or 'title'.`
+        })
+            .refine(options => [options.listTitle, options.listId, options.listUrl].filter(x => x !== undefined).length === 1, {
+            message: `Specify exactly one of the following options: 'listTitle', 'listId' or 'listUrl'.`
+        });
+    }
+    async commandAction(logger, args) {
+        try {
+            const contentCenterUrl = urlUtil.removeTrailingSlashes(args.options.contentCenterUrl);
+            await spp.assertSiteIsContentCenter(contentCenterUrl, logger, this.verbose);
+            let model = null;
+            if (args.options.title) {
+                model = await spp.getModelByTitle(contentCenterUrl, args.options.title, logger, this.verbose);
+            }
+            else {
+                model = await spp.getModelById(contentCenterUrl, args.options.id, logger, this.verbose);
+            }
+            if (this.verbose) {
+                await logger.log(`Retrieving list information...`);
+            }
+            const listInstance = await this.getListInfo(args.options.webUrl, args.options.listId, args.options.listTitle, args.options.listUrl);
+            if (listInstance.BaseType !== 1) {
+                throw `The specified list is not a document library.`;
+            }
+            if (this.verbose) {
+                await logger.log(`Applying model '${model.ModelName}' to document library '${listInstance.RootFolder.ServerRelativeUrl}'...`);
+            }
+            const requestOptions = {
+                url: `${contentCenterUrl}/_api/machinelearning/publications`,
+                headers: {
+                    accept: 'application/json;odata=nometadata',
+                    'Content-Type': 'application/json;odata=verbose'
+                },
+                responseType: 'json',
+                data: {
+                    __metadata: { type: 'Microsoft.Office.Server.ContentCenter.SPMachineLearningPublicationsEntityData' },
+                    Publications: {
+                        results: [
+                            {
+                                ModelUniqueId: model.UniqueId,
+                                TargetSiteUrl: args.options.webUrl,
+                                TargetWebServerRelativeUrl: urlUtil.getServerRelativeSiteUrl(args.options.webUrl),
+                                TargetLibraryServerRelativeUrl: listInstance.RootFolder.ServerRelativeUrl,
+                                ViewOption: args.options.viewOption ?? "NewViewAsDefault"
+                            }
+                        ]
+                    }
+                }
+            };
+            const result = await request.post(requestOptions);
+            const resultDetails = result.Details;
+            if (resultDetails && resultDetails[0]?.ErrorMessage) {
+                throw resultDetails[0].ErrorMessage;
+            }
+        }
+        catch (err) {
+            this.handleRejectedODataJsonPromise(err);
+        }
+    }
+    getListInfo(webUrl, listId, listTitle, listUrl) {
+        let requestUrl = `${webUrl}/_api/web`;
+        if (listId) {
+            requestUrl += `/lists(guid'${formatting.encodeQueryParameter(listId)}')`;
+        }
+        else if (listTitle) {
+            requestUrl += `/lists/getByTitle('${formatting.encodeQueryParameter(listTitle)}')`;
+        }
+        else if (listUrl) {
+            const listServerRelativeUrl = urlUtil.getServerRelativePath(webUrl, listUrl);
+            requestUrl += `/GetList('${formatting.encodeQueryParameter(listServerRelativeUrl)}')`;
+        }
+        const requestOptions = {
+            url: `${requestUrl}?$select=BaseType,RootFolder/ServerRelativeUrl&$expand=RootFolder`,
+            headers: {
+                accept: 'application/json;odata=nometadata'
+            },
+            responseType: 'json'
+        };
+        return request.get(requestOptions);
+    }
+}
+export default new SppModelApplyCommand();
+//# sourceMappingURL=model-apply.js.map

package/dist/m365/spp/commands/model/model-get.js

@@ -4,8 +4,6 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _SppModelGetCommand_instances, _SppModelGetCommand_initTelemetry, _SppModelGetCommand_initOptions, _SppModelGetCommand_initValidators, _SppModelGetCommand_initOptionSets, _SppModelGetCommand_initTypes;
-import request from '../../../../request.js';
-import { formatting } from '../../../../utils/formatting.js';
 import { odata } from '../../../../utils/odata.js';
 import { spp } from '../../../../utils/spp.js';
 import { urlUtil } from '../../../../utils/urlUtil.js';
@@ -30,34 +28,19 @@ class SppModelGetCommand extends SpoCommand {
     }
     async commandAction(logger, args) {
         try {
-            if (this.verbose) {
-                await logger.log(`Retrieving model information from ${args.options.siteUrl}...`);
-            }
             const siteUrl = urlUtil.removeTrailingSlashes(args.options.siteUrl);
-            await spp.assertSiteIsContentCenter(siteUrl);
-            let requestUrl = `${siteUrl}/_api/machinelearning/models/`;
+            await spp.assertSiteIsContentCenter(siteUrl, logger, this.verbose);
+            let result = null;
             if (args.options.title) {
-                let requestTitle = args.options.title.toLowerCase();
-                if (!requestTitle.endsWith('.classifier')) {
-                    requestTitle += '.classifier';
-                }
-                requestUrl += `getbytitle('${formatting.encodeQueryParameter(requestTitle)}')`;
+                result = await spp.getModelByTitle(siteUrl, args.options.title, logger, this.verbose);
             }
             else {
-                requestUrl += `getbyuniqueid('${args.options.id}')`;
-            }
-            const requestOptions = {
-                url: requestUrl,
-                headers: {
-                    accept: 'application/json;odata=nometadata'
-                },
-                responseType: 'json'
-            };
-            const result = await request.get(requestOptions);
-            if (result['odata.null'] === true) {
-                throw 'Model not found.';
+                result = await spp.getModelById(siteUrl, args.options.id, logger, this.verbose);
             }
             if (args.options.withPublications) {
+                if (this.verbose) {
+                    await logger.log(`Retrieving publications for model...`);
+                }
                 result.Publications = await odata.getAllItems(`${siteUrl}/_api/machinelearning/publications/getbymodeluniqueid('${result.UniqueId}')`);
             }
             await logger.log({

package/dist/m365/spp/commands/model/model-list.js

@@ -33,7 +33,7 @@ class SppModelListCommand extends SpoCommand {
                 await logger.log(`Retrieving models from ${args.options.siteUrl}...`);
             }
             const siteUrl = urlUtil.removeTrailingSlashes(args.options.siteUrl);
-            await spp.assertSiteIsContentCenter(siteUrl);
+            await spp.assertSiteIsContentCenter(siteUrl, logger, this.verbose);
             const result = await odata.getAllItems(`${siteUrl}/_api/machinelearning/models`);
             await logger.log(result);
         }

package/dist/m365/spp/commands/model/model-remove.js

@@ -40,7 +40,7 @@ class SppModelRemoveCommand extends SpoCommand {
                 await logger.log(`Removing model from ${args.options.siteUrl}...`);
             }
             const siteUrl = urlUtil.removeTrailingSlashes(args.options.siteUrl);
-            await spp.assertSiteIsContentCenter(siteUrl);
+            await spp.assertSiteIsContentCenter(siteUrl, logger, this.verbose);
             let requestUrl = `${siteUrl}/_api/machinelearning/models/`;
             if (args.options.title) {
                 let requestTitle = args.options.title.toLowerCase();

package/dist/m365/spp/commands.js

@@ -1,6 +1,7 @@
 const prefix = 'spp';
 export default {
     CONTENTCENTER_LIST: `${prefix} contentcenter list`,
+    MODEL_APPLY: `${prefix} model apply`,
     MODEL_GET: `${prefix} model get`,
     MODEL_LIST: `${prefix} model list`,
     MODEL_REMOVE: `${prefix} model remove`

package/dist/utils/entraServicePrincipal.js

@@ -41,6 +41,17 @@ export const entraServicePrincipal = {
             return await cli.handleMultipleResultsFound(`Multiple service principals with name '${appName}' found in Microsoft Entra ID.`, resultAsKeyValuePair);
         }
         return apps[0];
+    },
+    /**
+     * Get all available service principals.
+     * @param properties Comma-separated list of properties to include in the response.
+     */
+    async getServicePrincipals(properties) {
+        let url = `https://graph.microsoft.com/v1.0/servicePrincipals`;
+        if (properties) {
+            url += `?$select=${properties}`;
+        }
+        return odata.getAllItems(url);
     }
 };
 //# sourceMappingURL=entraServicePrincipal.js.map

package/dist/utils/formatting.js

@@ -177,6 +177,18 @@ export const formatting = {
             resultAsKeyValuePair[obj[key]] = obj;
         });
         return resultAsKeyValuePair;
+    },
+    /**
+     * Extracts the GUID from a string in CSOM format.
+     * @param str The string to extract the GUID from
+     * @description The string should be in the format /Guid(XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX)/
+     * @returns The extracted GUID or the original string if no match is found
+     * @example /Guid(eae15efb-ac09-49b9-8906-e579efd622e4)/ => eae15efb-ac09-49b9-8906-e579efd622e4
+     */
+    extractCsomGuid(str) {
+        const guidPattern = /\/Guid\(([0-9a-f-]+)\)\//i;
+        const match = str.match(guidPattern);
+        return match ? match[1] : str;
     }
 };
 //# sourceMappingURL=formatting.js.map

package/dist/utils/spe.js

@@ -0,0 +1,77 @@
+import request from '../request.js';
+import { formatting } from './formatting.js';
+import { cli } from '../cli/cli.js';
+import config from '../config.js';
+import { odata } from './odata.js';
+const graphResource = 'https://graph.microsoft.com';
+export const spe = {
+    /**
+     * Get all container types.
+     * @param spoAdminUrl The URL of the SharePoint Online admin center site (e.g. https://contoso-admin.sharepoint.com)
+     * @returns Array of container types
+     */
+    async getAllContainerTypes(spoAdminUrl) {
+        const requestOptions = {
+            url: `${spoAdminUrl}/_vti_bin/client.svc/ProcessQuery`,
+            headers: {
+                accept: 'application/json;odata=nometadata'
+            },
+            responseType: 'json',
+            data: `<Request AddExpandoFieldTypeSuffix="true" SchemaVersion="15.0.0.0" LibraryVersion="16.0.0.0" ApplicationName="${config.applicationName}" xmlns="http://schemas.microsoft.com/sharepoint/clientquery/2009"><Actions><ObjectPath Id="46" ObjectPathId="45" /><Method Name="GetSPOContainerTypes" Id="47" ObjectPathId="45"><Parameters><Parameter Type="Enum">1</Parameter></Parameters></Method></Actions><ObjectPaths><Constructor Id="45" TypeId="{268004ae-ef6b-4e9b-8425-127220d84719}" /></ObjectPaths></Request>`
+        };
+        const json = await request.post(requestOptions);
+        const response = json[0];
+        if (response.ErrorInfo) {
+            throw new Error(response.ErrorInfo.ErrorMessage);
+        }
+        const containerTypes = json[json.length - 1];
+        // Format the response to remove CSOM GUIDs and convert them to real GUIDs
+        containerTypes.forEach(ct => {
+            delete ct._ObjectType_;
+            ct.AzureSubscriptionId = formatting.extractCsomGuid(ct.AzureSubscriptionId);
+            ct.ContainerTypeId = formatting.extractCsomGuid(ct.ContainerTypeId);
+            ct.OwningAppId = formatting.extractCsomGuid(ct.OwningAppId);
+            ct.OwningTenantId = formatting.extractCsomGuid(ct.OwningTenantId);
+        });
+        return containerTypes;
+    },
+    /**
+     * Get the ID of a container type by its name.
+     * @param spoAdminUrl SharePoint Online admin center URL (e.g. https://contoso-admin.sharepoint.com)
+     * @param name Name of the container type to search for
+     * @returns ID of the container type
+     */
+    async getContainerTypeIdByName(spoAdminUrl, name) {
+        const allContainerTypes = await this.getAllContainerTypes(spoAdminUrl);
+        const containerTypes = allContainerTypes.filter(ct => ct.DisplayName.toLowerCase() === name.toLowerCase());
+        if (containerTypes.length === 0) {
+            throw new Error(`The specified container type '${name}' does not exist.`);
+        }
+        if (containerTypes.length > 1) {
+            const containerTypeKeyValuePair = formatting.convertArrayToHashTable('ContainerTypeId', containerTypes);
+            const containerType = await cli.handleMultipleResultsFound(`Multiple container types with name '${name}' found.`, containerTypeKeyValuePair);
+            return containerType.ContainerTypeId;
+        }
+        return containerTypes[0].ContainerTypeId;
+    },
+    /**
+     * Get the ID of a container by its name.
+     * @param containerTypeId ID of the container type.
+     * @param name Name of the container to search for.
+     * @returns ID of the container.
+     */
+    async getContainerIdByName(containerTypeId, name) {
+        const containers = await odata.getAllItems(`${graphResource}/v1.0/storage/fileStorage/containers?$filter=containerTypeId eq ${containerTypeId}&$select=id,displayName`);
+        const matchingContainers = containers.filter(c => c.displayName.toLowerCase() === name.toLowerCase());
+        if (matchingContainers.length === 0) {
+            throw new Error(`The specified container '${name}' does not exist.`);
+        }
+        if (matchingContainers.length > 1) {
+            const containerKeyValuePair = formatting.convertArrayToHashTable('id', matchingContainers);
+            const container = await cli.handleMultipleResultsFound(`Multiple containers with name '${name}' found.`, containerKeyValuePair);
+            return container.id;
+        }
+        return matchingContainers[0].id;
+    }
+};
+//# sourceMappingURL=spe.js.map