@pnp/cli-microsoft365 11.4.0-beta.0b6d893 → 11.4.0-beta.312ca0b

package/dist/m365/flow/commands/recyclebinitem/recyclebinitem-restore.js

@@ -1,20 +1,14 @@
 import PowerAutomateCommand from '../../../base/PowerAutomateCommand.js';
 import { globalOptionsZod } from '../../../../Command.js';
 import { z } from 'zod';
-import { zod } from '../../../../utils/zod.js';
 import commands from '../../commands.js';
-import { validation } from '../../../../utils/validation.js';
 import { formatting } from '../../../../utils/formatting.js';
 import request from '../../../../request.js';
-const options = globalOptionsZod
-    .extend({
-    environmentName: zod.alias('e', z.string()),
-    flowName: zod.alias('n', z.string()
-        .refine(name => validation.isValidGuid(name), name => ({
-        message: `'${name}' is not a valid GUID.`
-    })))
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    environmentName: z.string().alias('e'),
+    flowName: z.uuid().alias('n')
+});
 class FlowRecycleBinItemRestoreCommand extends PowerAutomateCommand {
     get name() {
         return commands.RECYCLEBINITEM_RESTORE;

package/dist/m365/graph/commands/directoryextension/directoryextension-add.js

@@ -1,14 +1,13 @@
 import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
 import request from '../../../../request.js';
-import { zod } from '../../../../utils/zod.js';
 import commands from '../../commands.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import { validation } from '../../../../utils/validation.js';
 import { entraApp } from '../../../../utils/entraApp.js';
-const options = globalOptionsZod
-    .extend({
-    name: zod.alias('n', z.string()),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    name: z.string().alias('n'),
     appId: z.string().optional(),
     appObjectId: z.string().optional(),
     appName: z.string().optional(),
@@ -16,8 +15,7 @@ const options = globalOptionsZod
     targetObjects: z.string().transform((value) => value.split(',').map(String))
         .pipe(z.enum(['User', 'Group', 'Application', 'AdministrativeUnit', 'Device', 'Organization']).array()),
     isMultiValued: z.boolean().optional()
-})
-    .strict();
+});
 class GraphDirectoryExtensionAddCommand extends GraphCommand {
     get name() {
         return commands.DIRECTORYEXTENSION_ADD;
@@ -31,18 +29,18 @@ class GraphDirectoryExtensionAddCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => Object.values([options.appId, options.appObjectId, options.appName]).filter(v => typeof v !== 'undefined').length === 1, {
-            message: 'Specify either appId, appObjectId or appName, but not multiple'
+            error: 'Specify either appId, appObjectId or appName, but not multiple'
         })
             .refine(options => (!options.appId && !options.appObjectId && !options.appName) || options.appObjectId || options.appName ||
-            (options.appId && validation.isValidGuid(options.appId)), options => ({
-            message: `The '${options.appId}' must be a valid GUID`,
+            (options.appId && validation.isValidGuid(options.appId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['appId']
-        }))
+        })
             .refine(options => (!options.appId && !options.appObjectId && !options.appName) || options.appId || options.appName ||
-            (options.appObjectId && validation.isValidGuid(options.appObjectId)), options => ({
-            message: `The '${options.appObjectId}' must be a valid GUID`,
+            (options.appObjectId && validation.isValidGuid(options.appObjectId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['appObjectId']
-        }));
+        });
     }
     async commandAction(logger, args) {
         try {

package/dist/m365/graph/commands/directoryextension/directoryextension-get.js

@@ -1,27 +1,18 @@
 import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
 import request from '../../../../request.js';
-import { zod } from '../../../../utils/zod.js';
 import commands from '../../commands.js';
 import GraphCommand from '../../../base/GraphCommand.js';
-import { validation } from '../../../../utils/validation.js';
 import { entraApp } from '../../../../utils/entraApp.js';
 import { directoryExtension } from '../../../../utils/directoryExtension.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()),
-    appId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
-    appObjectId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    id: z.uuid().optional().alias('i'),
+    name: z.string().optional().alias('n'),
+    appId: z.uuid().optional(),
+    appObjectId: z.uuid().optional(),
     appName: z.string().optional()
-})
-    .strict();
+});
 class GraphDirectoryExtensionGetCommand extends GraphCommand {
     get name() {
         return commands.DIRECTORYEXTENSION_GET;
@@ -35,13 +26,13 @@ class GraphDirectoryExtensionGetCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => !options.id !== !options.name, {
-            message: 'Specify either id or name, but not both'
+            error: 'Specify either id or name, but not both'
         })
             .refine(options => options.id || options.name, {
-            message: 'Specify either id or name'
+            error: 'Specify either id or name'
         })
             .refine(options => Object.values([options.appId, options.appObjectId, options.appName]).filter(v => typeof v !== 'undefined').length === 1, {
-            message: 'Specify either appId, appObjectId or appName, but not multiple'
+            error: 'Specify either appId, appObjectId or appName, but not multiple'
         });
     }
     async commandAction(logger, args) {

package/dist/m365/graph/commands/directoryextension/directoryextension-list.js

@@ -3,20 +3,14 @@ import { globalOptionsZod } from '../../../../Command.js';
 import request from '../../../../request.js';
 import commands from '../../commands.js';
 import GraphCommand from '../../../base/GraphCommand.js';
-import { validation } from '../../../../utils/validation.js';
 import { entraApp } from '../../../../utils/entraApp.js';
 import { odata } from '../../../../utils/odata.js';
-const options = globalOptionsZod
-    .extend({
-    appId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
-    appObjectId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    appId: z.uuid().optional(),
+    appObjectId: z.uuid().optional(),
     appName: z.string().optional()
-})
-    .strict();
+});
 class GraphDirectoryExtensionListCommand extends GraphCommand {
     get name() {
         return commands.DIRECTORYEXTENSION_LIST;
@@ -33,7 +27,7 @@ class GraphDirectoryExtensionListCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => ([options.appId, options.appObjectId, options.appName].filter(x => x !== undefined).length <= 1), {
-            message: 'Specify either appId, appObjectId, or appName, but not multiple.'
+            error: 'Specify either appId, appObjectId, or appName, but not multiple.'
         });
     }
     async commandAction(logger, args) {

package/dist/m365/graph/commands/directoryextension/directoryextension-remove.js

@@ -1,29 +1,20 @@
 import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
 import request from '../../../../request.js';
-import { zod } from '../../../../utils/zod.js';
 import commands from '../../commands.js';
 import GraphCommand from '../../../base/GraphCommand.js';
-import { validation } from '../../../../utils/validation.js';
 import { entraApp } from '../../../../utils/entraApp.js';
 import { cli } from '../../../../cli/cli.js';
 import { directoryExtension } from '../../../../utils/directoryExtension.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()),
-    appId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
-    appObjectId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    id: z.uuid().optional().alias('i'),
+    name: z.string().optional().alias('n'),
+    appId: z.uuid().optional(),
+    appObjectId: z.uuid().optional(),
     appName: z.string().optional(),
-    force: zod.alias('f', z.boolean().optional())
-})
-    .strict();
+    force: z.boolean().optional().alias('f')
+});
 class GraphDirectoryExtensionRemoveCommand extends GraphCommand {
     get name() {
         return commands.DIRECTORYEXTENSION_REMOVE;
@@ -37,13 +28,13 @@ class GraphDirectoryExtensionRemoveCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => !options.id !== !options.name, {
-            message: 'Specify either id or name, but not both'
+            error: 'Specify either id or name, but not both'
         })
             .refine(options => options.id || options.name, {
-            message: 'Specify either id or name'
+            error: 'Specify either id or name'
         })
             .refine(options => Object.values([options.appId, options.appObjectId, options.appName]).filter(v => typeof v !== 'undefined').length === 1, {
-            message: 'Specify either appId, appObjectId or appName, but not multiple'
+            error: 'Specify either appId, appObjectId or appName, but not multiple'
         });
     }
     async commandAction(logger, args) {

package/dist/m365/graph/commands/openextension/openextension-add.js

@@ -6,13 +6,12 @@ import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
 import request from '../../../../request.js';
 import { optionsUtils } from '../../../../utils/optionsUtils.js';
-const options = globalOptionsZod
-    .extend({
-    name: zod.alias('n', z.string()),
-    resourceId: zod.alias('i', z.string()),
-    resourceType: zod.alias('t', z.enum(['user', 'group', 'device', 'organization']))
-})
-    .passthrough();
+const options = z.looseObject({
+    ...globalOptionsZod.shape,
+    name: z.string().alias('n'),
+    resourceId: z.string().alias('i'),
+    resourceType: z.enum(['user', 'group', 'device', 'organization']).alias('t')
+});
 class GraphOpenExtensionAddCommand extends GraphCommand {
     get name() {
         return commands.OPENEXTENSION_ADD;
@@ -25,14 +24,14 @@ class GraphOpenExtensionAddCommand extends GraphCommand {
     }
     getRefinedSchema(schema) {
         return schema
-            .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' || (options.resourceId && validation.isValidGuid(options.resourceId)), options => ({
-            message: `The '${options.resourceId}' must be a valid GUID`,
+            .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' || (options.resourceId && validation.isValidGuid(options.resourceId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['resourceId']
-        }))
-            .refine(options => options.resourceType !== 'user' || (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), options => ({
-            message: `The '${options.resourceId}' must be a valid GUID or user principal name`,
+        })
+            .refine(options => options.resourceType !== 'user' || (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), {
+            error: e => `The '${e.input}' must be a valid GUID or user principal name`,
             path: ['resourceId']
-        }));
+        });
     }
     async commandAction(logger, args) {
         try {

package/dist/m365/graph/commands/openextension/openextension-get.js

@@ -1,17 +1,15 @@
 import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
-import { zod } from '../../../../utils/zod.js';
 import { validation } from '../../../../utils/validation.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
 import request from '../../../../request.js';
-const options = globalOptionsZod
-    .extend({
-    resourceId: zod.alias('i', z.string()),
-    resourceType: zod.alias('t', z.enum(['user', 'group', 'device', 'organization'])),
-    name: zod.alias('n', z.string())
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    resourceId: z.string().alias('i'),
+    resourceType: z.enum(['user', 'group', 'device', 'organization']).alias('t'),
+    name: z.string().alias('n')
+});
 class GraphOpenExtensionGetCommand extends GraphCommand {
     get name() {
         return commands.OPENEXTENSION_GET;
@@ -24,14 +22,14 @@ class GraphOpenExtensionGetCommand extends GraphCommand {
     }
     getRefinedSchema(schema) {
         return schema
-            .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' || (options.resourceId && validation.isValidGuid(options.resourceId)), options => ({
-            message: `The '${options.resourceId}' must be a valid GUID`,
+            .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' || (options.resourceId && validation.isValidGuid(options.resourceId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['resourceId']
-        }))
-            .refine(options => options.resourceType !== 'user' || (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), options => ({
-            message: `The '${options.resourceId}' must be a valid GUID or user principal name`,
+        })
+            .refine(options => options.resourceType !== 'user' || (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), {
+            error: e => `The '${e.input}' must be a valid GUID or user principal name`,
             path: ['resourceId']
-        }));
+        });
     }
     async commandAction(logger, args) {
         try {

package/dist/m365/graph/commands/openextension/openextension-list.js

@@ -1,16 +1,14 @@
 import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
-import { zod } from '../../../../utils/zod.js';
 import { validation } from '../../../../utils/validation.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
 import { odata } from '../../../../utils/odata.js';
-const options = globalOptionsZod
-    .extend({
-    resourceId: zod.alias('i', z.string()),
-    resourceType: zod.alias('t', z.enum(['user', 'group', 'device', 'organization']))
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    resourceId: z.string().alias('i'),
+    resourceType: z.enum(['user', 'group', 'device', 'organization']).alias('t')
+});
 class GraphOpenExtensionListCommand extends GraphCommand {
     get name() {
         return commands.OPENEXTENSION_LIST;
@@ -27,15 +25,15 @@ class GraphOpenExtensionListCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' ||
-            (options.resourceId && validation.isValidGuid(options.resourceId)), options => ({
-            message: `The '${options.resourceId}' must be a valid GUID`,
+            (options.resourceId && validation.isValidGuid(options.resourceId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['resourceId']
-        }))
+        })
             .refine(options => options.resourceType !== 'user' ||
-            (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), options => ({
-            message: `The '${options.resourceId}' must be a valid GUID or user principal name`,
+            (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), {
+            error: e => `The '${e.input}' must be a valid GUID or user principal name`,
             path: ['resourceId']
-        }));
+        });
     }
     async commandAction(logger, args) {
         try {

package/dist/m365/graph/commands/openextension/openextension-remove.js

@@ -1,19 +1,17 @@
 import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
-import { zod } from '../../../../utils/zod.js';
 import { validation } from '../../../../utils/validation.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
 import { cli } from '../../../../cli/cli.js';
 import request from '../../../../request.js';
-const options = globalOptionsZod
-    .extend({
-    resourceId: zod.alias('i', z.string()),
-    resourceType: zod.alias('t', z.enum(['user', 'group', 'device', 'organization'])),
-    name: zod.alias('n', z.string()),
-    force: zod.alias('f', z.boolean().optional())
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    resourceId: z.string().alias('i'),
+    resourceType: z.enum(['user', 'group', 'device', 'organization']).alias('t'),
+    name: z.string().alias('n'),
+    force: z.boolean().optional().alias('f')
+});
 class GraphOpenExtensionRemoveCommand extends GraphCommand {
     get name() {
         return commands.OPENEXTENSION_REMOVE;
@@ -26,14 +24,14 @@ class GraphOpenExtensionRemoveCommand extends GraphCommand {
     }
     getRefinedSchema(schema) {
         return schema
-            .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' || (options.resourceId && validation.isValidGuid(options.resourceId)), options => ({
-            message: `The '${options.resourceId}' must be a valid GUID`,
+            .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' || (options.resourceId && validation.isValidGuid(options.resourceId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['resourceId']
-        }))
-            .refine(options => options.resourceType !== 'user' || (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), options => ({
-            message: `The '${options.resourceId}' must be a valid GUID or user principal name`,
+        })
+            .refine(options => options.resourceType !== 'user' || (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), {
+            error: e => `The '${e.input}' must be a valid GUID or user principal name`,
             path: ['resourceId']
-        }));
+        });
     }
     async commandAction(logger, args) {
         const removeOpenExtension = async () => {

package/dist/m365/graph/commands/openextension/openextension-set.js

@@ -1,19 +1,18 @@
 import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
-import { zod } from '../../../../utils/zod.js';
+import request from '../../../../request.js';
+import { optionsUtils } from '../../../../utils/optionsUtils.js';
 import { validation } from '../../../../utils/validation.js';
+import { zod } from '../../../../utils/zod.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
-import request from '../../../../request.js';
-import { optionsUtils } from '../../../../utils/optionsUtils.js';
-const options = globalOptionsZod
-    .extend({
-    name: zod.alias('n', z.string()),
-    resourceId: zod.alias('i', z.string()),
-    resourceType: zod.alias('t', z.enum(['user', 'group', 'device', 'organization'])),
-    keepUnchangedProperties: zod.alias('k', z.boolean().optional())
-})
-    .passthrough();
+const options = z.looseObject({
+    ...globalOptionsZod.shape,
+    name: z.string().alias('n'),
+    resourceId: z.string().alias('i'),
+    resourceType: z.enum(['user', 'group', 'device', 'organization']).alias('t'),
+    keepUnchangedProperties: z.boolean().optional().alias('k')
+});
 class GraphOpenExtensionSetCommand extends GraphCommand {
     constructor() {
         super(...arguments);
@@ -30,14 +29,14 @@ class GraphOpenExtensionSetCommand extends GraphCommand {
     }
     getRefinedSchema(schema) {
         return schema
-            .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' || (options.resourceId && validation.isValidGuid(options.resourceId)), options => ({
-            message: `The '${options.resourceId}' must be a valid GUID`,
+            .refine(options => options.resourceType !== 'group' && options.resourceType !== 'device' && options.resourceType !== 'organization' || (options.resourceId && validation.isValidGuid(options.resourceId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['resourceId']
-        }))
-            .refine(options => options.resourceType !== 'user' || (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), options => ({
-            message: `The '${options.resourceId}' must be a valid GUID or user principal name`,
+        })
+            .refine(options => options.resourceType !== 'user' || (options.resourceId && (validation.isValidGuid(options.resourceId) || validation.isValidUserPrincipalName(options.resourceId))), {
+            error: e => `The '${e.input}' must be a valid GUID or user principal name`,
             path: ['resourceId']
-        }));
+        });
     }
     async commandAction(logger, args) {
         try {

package/dist/m365/onedrive/commands/onedrive-list.js

@@ -1,10 +1,11 @@
+import { z } from 'zod';
 import { globalOptionsZod } from '../../../Command.js';
 import config from "../../../config.js";
 import request from "../../../request.js";
 import { spo } from "../../../utils/spo.js";
 import SpoCommand from "../../base/SpoCommand.js";
 import commands from "../commands.js";
-const options = globalOptionsZod.strict();
+export const options = z.strictObject({ ...globalOptionsZod.shape });
 class OneDriveListCommand extends SpoCommand {
     get name() {
         return commands.LIST;

package/dist/m365/outlook/commands/mail/mail-searchfolder-add.js

@@ -3,26 +3,21 @@ import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
 import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
-import { zod } from '../../../../utils/zod.js';
 import { validation } from '../../../../utils/validation.js';
 import { accessToken } from '../../../../utils/accessToken.js';
 import auth from '../../../../Auth.js';
-const options = globalOptionsZod
-    .extend({
-    userId: zod.alias('i', z.string()
-        .refine(userId => validation.isValidGuid(userId), userId => ({
-        message: `'${userId}' is not a valid GUID.`
-    })).optional()),
-    userName: zod.alias('n', z.string()
-        .refine(userName => validation.isValidUserPrincipalName(userName), userName => ({
-        message: `'${userName}' is not a valid UPN.`
-    })).optional()),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    userId: z.uuid().optional().alias('i'),
+    userName: z.string()
+        .refine(userName => validation.isValidUserPrincipalName(userName), {
+        error: e => `'${e.input}' is not a valid UPN.`
+    }).optional().alias('n'),
     folderName: z.string(),
     messageFilter: z.string(),
     sourceFoldersIds: z.string().transform((value) => value.split(',')).pipe(z.string().array()),
     includeNestedFolders: z.boolean().optional()
-})
-    .strict();
+});
 class OutlookMailSearchFolderAddCommand extends GraphCommand {
     get name() {
         return commands.MAIL_SEARCHFOLDER_ADD;
@@ -36,7 +31,7 @@ class OutlookMailSearchFolderAddCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => !(options.userId && options.userName), {
-            message: 'Specify either userId or userName, but not both'
+            error: 'Specify either userId or userName, but not both'
         });
     }
     async commandAction(logger, args) {

package/dist/m365/outlook/commands/mailbox/mailbox-settings-get.js

@@ -1,22 +1,18 @@
 import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
-import { zod } from '../../../../utils/zod.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
 import { validation } from '../../../../utils/validation.js';
 import request from '../../../../request.js';
 import { accessToken } from '../../../../utils/accessToken.js';
 import auth from '../../../../Auth.js';
-const options = globalOptionsZod
-    .extend({
-    userId: zod.alias('i', z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional()),
-    userName: zod.alias('n', z.string().refine(name => validation.isValidUserPrincipalName(name), name => ({
-        message: `'${name}' is not a valid UPN.`
-    })).optional())
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    userId: z.uuid().optional().alias('i'),
+    userName: z.string().refine(name => validation.isValidUserPrincipalName(name), {
+        error: e => `'${e.input}' is not a valid UPN.`
+    }).optional().alias('n')
+});
 class OutlookMailboxSettingsGetCommand extends GraphCommand {
     get name() {
         return commands.MAILBOX_SETTINGS_GET;
@@ -30,7 +26,7 @@ class OutlookMailboxSettingsGetCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => !(options.userId && options.userName), {
-            message: 'Specify either userId or userName, but not both'
+            error: 'Specify either userId or userName, but not both'
         });
     }
     async commandAction(logger, args) {

package/dist/m365/outlook/commands/mailbox/mailbox-settings-set.js

@@ -1,20 +1,19 @@
 import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
-import { zod } from '../../../../utils/zod.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
 import { validation } from '../../../../utils/validation.js';
 import request from '../../../../request.js';
 import { accessToken } from '../../../../utils/accessToken.js';
 import auth from '../../../../Auth.js';
-const options = globalOptionsZod
-    .extend({
-    userId: zod.alias('i', z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional()),
-    userName: zod.alias('n', z.string().refine(name => validation.isValidUserPrincipalName(name), name => ({
-        message: `'${name}' is not a valid UPN.`
-    })).optional()),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    userId: z.string().refine(id => validation.isValidGuid(id), {
+        error: e => `'${e.input}' is not a valid GUID.`
+    }).optional().alias('i'),
+    userName: z.string().refine(name => validation.isValidUserPrincipalName(name), {
+        error: e => `'${e.input}' is not a valid UPN.`
+    }).optional().alias('n'),
     dateFormat: z.string().optional(),
     timeFormat: z.string().optional(),
     timeZone: z.string().optional(),
@@ -32,8 +31,7 @@ const options = globalOptionsZod
     autoReplyEndDateTime: z.string().optional(),
     autoReplyEndTimeZone: z.string().optional(),
     autoReplyStatus: z.enum(['disabled', 'scheduled', 'alwaysEnabled']).optional()
-})
-    .strict();
+});
 class OutlookMailboxSettingsSetCommand extends GraphCommand {
     get name() {
         return commands.MAILBOX_SETTINGS_SET;
@@ -47,13 +45,15 @@ class OutlookMailboxSettingsSetCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => !(options.userId && options.userName), {
-            message: 'Specify either userId or userName, but not both'
+            error: 'Specify either userId or userName, but not both'
         })
-            .refine(options => [options.workingDays, options.workingHoursStartTime, options.workingHoursEndTime, options.workingHoursTimeZone,
+            .refine(options => [
+            options.workingDays, options.workingHoursStartTime, options.workingHoursEndTime, options.workingHoursTimeZone,
             options.autoReplyStatus, options.autoReplyExternalAudience, options.autoReplyExternalMessage, options.autoReplyInternalMessage,
             options.autoReplyStartDateTime, options.autoReplyStartTimeZone, options.autoReplyEndDateTime, options.autoReplyEndTimeZone,
-            options.timeFormat, options.timeZone, options.dateFormat, options.delegateMeetingMessageDeliveryOptions, options.language].filter(o => o !== undefined).length > 0, {
-            message: 'Specify at least one of the following options: workingDays, workingHoursStartTime, workingHoursEndTime, workingHoursTimeZone, autoReplyStatus, autoReplyExternalAudience, autoReplyExternalMessage, autoReplyInternalMessage, autoReplyStartDateTime, autoReplyStartTimeZone, autoReplyEndDateTime, autoReplyEndTimeZone, timeFormat, timeZone, dateFormat, delegateMeetingMessageDeliveryOptions, or language'
+            options.timeFormat, options.timeZone, options.dateFormat, options.delegateMeetingMessageDeliveryOptions, options.language
+        ].filter(o => o !== undefined).length > 0, {
+            error: 'Specify at least one of the following options: workingDays, workingHoursStartTime, workingHoursEndTime, workingHoursTimeZone, autoReplyStatus, autoReplyExternalAudience, autoReplyExternalMessage, autoReplyInternalMessage, autoReplyStartDateTime, autoReplyStartTimeZone, autoReplyEndDateTime, autoReplyEndTimeZone, timeFormat, timeZone, dateFormat, delegateMeetingMessageDeliveryOptions, or language'
         });
     }
     async commandAction(logger, args) {

package/dist/m365/outlook/commands/roomlist/roomlist-list.js

@@ -1,8 +1,9 @@
+import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
 import { odata } from '../../../../utils/odata.js';
 import GraphCommand from '../../../base/GraphCommand.js';
 import commands from '../../commands.js';
-const options = globalOptionsZod.strict();
+export const options = z.strictObject({ ...globalOptionsZod.shape });
 class OutlookRoomListListCommand extends GraphCommand {
     get name() {
         return commands.ROOMLIST_LIST;