@pnp/cli-microsoft365 11.4.0-beta.13d597c → 11.4.0-beta.312ca0b

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

@@ -1,33 +1,29 @@
 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 { odata } from '../../../../utils/odata.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()),
-    displayName: zod.alias('d', z.string().optional()),
-    marketingNotificationEmails: z.string().refine(emails => validation.isValidUserPrincipalNameArray(emails) === true, invalidEmails => ({
-        message: `The following marketing notification emails are invalid: ${invalidEmails}.`
-    })).transform((value) => value.split(',')).optional(),
-    securityComplianceNotificationMails: z.string().refine(emails => validation.isValidUserPrincipalNameArray(emails) === true, invalidEmails => ({
-        message: `The following security compliance notification emails are invalid: ${invalidEmails}.`
-    })).transform((value) => value.split(',')).optional(),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    id: z.uuid().optional().alias('i'),
+    displayName: z.string().optional().alias('d'),
+    marketingNotificationEmails: z.string().refine(emails => validation.isValidUserPrincipalNameArray(emails) === true, {
+        error: e => `The following marketing notification emails are invalid: ${e.input}.`
+    }).transform((value) => value.split(',')).optional(),
+    securityComplianceNotificationMails: z.string().refine(emails => validation.isValidUserPrincipalNameArray(emails) === true, {
+        error: e => `The following security compliance notification emails are invalid: ${e.input}.`
+    }).transform((value) => value.split(',')).optional(),
     securityComplianceNotificationPhones: z.string().transform((value) => value.split(',')).optional(),
-    technicalNotificationMails: z.string().refine(emails => validation.isValidUserPrincipalNameArray(emails) === true, invalidEmails => ({
-        message: `The following technical notification emails are invalid: ${invalidEmails}.`
-    })).transform((value) => value.split(',')).optional(),
-    contactEmail: z.string().refine(id => validation.isValidUserPrincipalName(id), id => ({
-        message: `'${id}' is not a valid email.`
-    })).optional(),
+    technicalNotificationMails: z.string().refine(emails => validation.isValidUserPrincipalNameArray(emails) === true, {
+        error: e => `The following technical notification emails are invalid: ${e.input}.`
+    }).transform((value) => value.split(',')).optional(),
+    contactEmail: z.string().refine(id => validation.isValidUserPrincipalName(id), {
+        error: e => `'${e.input}' is not a valid email.`
+    }).optional(),
     statementUrl: z.string().optional()
-})
-    .strict();
+});
 class EntraOrganizationSetCommand extends GraphCommand {
     get name() {
         return commands.ORGANIZATION_SET;
@@ -41,14 +37,16 @@ class EntraOrganizationSetCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => !(options.id && options.displayName), {
-            message: 'Specify either id or displayName, but not both'
+            error: 'Specify either id or displayName, but not both'
         })
             .refine(options => options.id || options.displayName, {
-            message: 'Specify either id or displayName'
+            error: 'Specify either id or displayName'
         })
-            .refine(options => [options.contactEmail, options.marketingNotificationEmails, options.securityComplianceNotificationMails, options.securityComplianceNotificationPhones,
-            options.statementUrl, options.technicalNotificationMails].filter(o => o !== undefined).length > 0, {
-            message: 'Specify at least one of the following options: contactEmail, marketingNotificationEmails, securityComplianceNotificationMails, securityComplianceNotificationPhones, statementUrl, or technicalNotificationMails'
+            .refine(options => [
+            options.contactEmail, options.marketingNotificationEmails, options.securityComplianceNotificationMails, options.securityComplianceNotificationPhones,
+            options.statementUrl, options.technicalNotificationMails
+        ].filter(o => o !== undefined).length > 0, {
+            error: 'Specify at least one of the following options: contactEmail, marketingNotificationEmails, securityComplianceNotificationMails, securityComplianceNotificationPhones, statementUrl, or technicalNotificationMails'
         });
     }
     async commandAction(logger, args) {

package/dist/m365/entra/commands/roleassignment/roleassignment-add.js

@@ -10,42 +10,27 @@ import { entraServicePrincipal } from '../../../../utils/entraServicePrincipal.j
 import { entraGroup } from '../../../../utils/entraGroup.js';
 import { roleDefinition } from '../../../../utils/roleDefinition.js';
 import { entraUser } from '../../../../utils/entraUser.js';
-const options = globalOptionsZod
-    .extend({
-    roleDefinitionId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    roleDefinitionId: z.uuid().optional(),
     roleDefinitionName: z.string().optional(),
-    principal: z.string().refine(principal => validation.isValidGuid(principal) || validation.isValidUserPrincipalName(principal) || validation.isValidMailNickname(principal), principal => ({
-        message: `'${principal}' is not a valid GUID, UPN or group mail nickname.`
-    })),
-    userId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
-    userName: z.string().refine(upn => validation.isValidUserPrincipalName(upn), upn => ({
-        message: `'${upn}' is not a valid UPN.`
-    })).optional(),
-    administrativeUnitId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
+    principal: z.string().refine(principal => validation.isValidGuid(principal) || validation.isValidUserPrincipalName(principal) || validation.isValidMailNickname(principal), {
+        error: e => `'${e.input}' is not a valid GUID, UPN or group mail nickname.`
+    }),
+    userId: z.uuid().optional(),
+    userName: z.string().refine(upn => validation.isValidUserPrincipalName(upn), {
+        error: e => `'${e.input}' is not a valid UPN.`
+    }).optional(),
+    administrativeUnitId: z.uuid().optional(),
     administrativeUnitName: z.string().optional(),
-    applicationId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
-    applicationObjectId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
+    applicationId: z.uuid().optional(),
+    applicationObjectId: z.uuid().optional(),
     applicationName: z.string().optional(),
-    servicePrincipalId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
+    servicePrincipalId: z.uuid().optional(),
     servicePrincipalName: z.string().optional(),
-    groupId: z.string().refine(id => validation.isValidGuid(id), id => ({
-        message: `'${id}' is not a valid GUID.`
-    })).optional(),
+    groupId: z.uuid().optional(),
     groupName: z.string().optional()
-})
-    .strict();
+});
 class EntraRoleAssignmentAddCommand extends GraphCommand {
     get name() {
         return commands.ROLEASSIGNMENT_ADD;
@@ -59,10 +44,12 @@ class EntraRoleAssignmentAddCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => [options.roleDefinitionId, options.roleDefinitionName].filter(o => o !== undefined).length === 1, {
-            message: 'Specify either roleDefinitionId or roleDefinitionName'
+            error: 'Specify either roleDefinitionId or roleDefinitionName'
         })
-            .refine(options => Object.values([options.userId, options.userName, options.administrativeUnitId, options.administrativeUnitName, options.applicationId, options.applicationObjectId, options.applicationName,
-            options.servicePrincipalId, options.servicePrincipalName, options.groupId, options.groupName]).filter(v => typeof v !== 'undefined').length < 2, {
+            .refine(options => Object.values([
+            options.userId, options.userName, options.administrativeUnitId, options.administrativeUnitName, options.applicationId, options.applicationObjectId, options.applicationName,
+            options.servicePrincipalId, options.servicePrincipalName, options.groupId, options.groupName
+        ]).filter(v => typeof v !== 'undefined').length < 2, {
             message: 'Provide value for only one of the following parameters: userId, userName, administrativeUnitId, administrativeUnitName, applicationId, applicationObjectId, applicationName, servicePrincipalId, servicePrincipalName, groupId or groupName'
         });
     }

package/dist/m365/entra/commands/roledefinition/roledefinition-add.js

@@ -1,18 +1,16 @@
 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 request from '../../../../request.js';
-const options = globalOptionsZod
-    .extend({
-    displayName: zod.alias('n', z.string()),
-    allowedResourceActions: zod.alias('a', z.string().transform((value) => value.split(',').map(String))),
-    description: zod.alias('d', z.string().optional()),
-    enabled: zod.alias('e', z.boolean().optional()),
-    version: zod.alias('v', z.string().optional())
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    displayName: z.string().alias('n'),
+    allowedResourceActions: z.string().transform((value) => value.split(',').map(String)).alias('a'),
+    description: z.string().optional().alias('d'),
+    enabled: z.boolean().optional().alias('e'),
+    version: z.string().optional().alias('v')
+});
 class EntraRoleDefinitionAddCommand extends GraphCommand {
     get name() {
         return commands.ROLEDEFINITION_ADD;

package/dist/m365/entra/commands/roledefinition/roledefinition-get.js

@@ -2,16 +2,14 @@ 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 { roleDefinition } from '../../../../utils/roleDefinition.js';
 import { validation } from '../../../../utils/validation.js';
-const options = globalOptionsZod
-    .extend({
-    id: zod.alias('i', z.string().optional()),
-    displayName: zod.alias('n', z.string().optional()),
-    properties: zod.alias('p', z.string().optional())
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    id: z.uuid().optional().alias('i'),
+    displayName: z.string().optional().alias('n'),
+    properties: z.string().optional().alias('p')
+});
 class EntraRoleDefinitionGetCommand extends GraphCommand {
     get name() {
         return commands.ROLEDEFINITION_GET;
@@ -25,15 +23,15 @@ class EntraRoleDefinitionGetCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => !options.id !== !options.displayName, {
-            message: 'Specify either id or displayName, but not both'
+            error: 'Specify either id or displayName, but not both'
         })
             .refine(options => options.id || options.displayName, {
-            message: 'Specify either id or displayName'
+            error: 'Specify either id or displayName'
         })
-            .refine(options => (!options.id && !options.displayName) || options.displayName || (options.id && validation.isValidGuid(options.id)), options => ({
-            message: `The '${options.id}' must be a valid GUID`,
+            .refine(options => (!options.id && !options.displayName) || options.displayName || (options.id && validation.isValidGuid(options.id)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['id']
-        }));
+        });
     }
     async commandAction(logger, args) {
         if (this.verbose) {

package/dist/m365/entra/commands/roledefinition/roledefinition-list.js

@@ -3,13 +3,11 @@ 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';
-const options = globalOptionsZod
-    .extend({
-    properties: zod.alias('p', z.string().optional()),
-    filter: zod.alias('f', z.string().optional())
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    properties: z.string().optional().alias('p'),
+    filter: z.string().optional().alias('f')
+});
 class EntraRoleDefinitionListCommand extends GraphCommand {
     get name() {
         return commands.ROLEDEFINITION_LIST;

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

@@ -2,18 +2,16 @@ 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 { roleDefinition } from '../../../../utils/roleDefinition.js';
 import { validation } from '../../../../utils/validation.js';
 import request from '../../../../request.js';
 import { cli } from '../../../../cli/cli.js';
-const options = globalOptionsZod
-    .extend({
-    id: zod.alias('i', z.string().optional()),
-    displayName: zod.alias('n', z.string().optional()),
-    force: zod.alias('f', z.boolean().optional())
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    id: z.uuid().optional().alias('i'),
+    displayName: z.string().optional().alias('n'),
+    force: z.boolean().optional().alias('f')
+});
 class EntraRoleDefinitionRemoveCommand extends GraphCommand {
     get name() {
         return commands.ROLEDEFINITION_REMOVE;
@@ -27,15 +25,15 @@ class EntraRoleDefinitionRemoveCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => !options.id !== !options.displayName, {
-            message: 'Specify either id or displayName, but not both'
+            error: 'Specify either id or displayName, but not both'
         })
             .refine(options => options.id || options.displayName, {
-            message: 'Specify either id or displayName'
+            error: 'Specify either id or displayName'
         })
-            .refine(options => (!options.id && !options.displayName) || options.displayName || (options.id && validation.isValidGuid(options.id)), options => ({
-            message: `The '${options.id}' must be a valid GUID`,
+            .refine(options => (!options.id && !options.displayName) || options.displayName || (options.id && validation.isValidGuid(options.id)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['id']
-        }));
+        });
     }
     async commandAction(logger, args) {
         const removeRoleDefinition = async () => {

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

@@ -1,22 +1,20 @@
 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 request from '../../../../request.js';
 import { roleDefinition } from '../../../../utils/roleDefinition.js';
 import { validation } from '../../../../utils/validation.js';
-const options = globalOptionsZod
-    .extend({
-    id: zod.alias('i', z.string().optional()),
-    displayName: zod.alias('n', z.string().optional()),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    id: z.uuid().optional().alias('i'),
+    displayName: z.string().optional().alias('n'),
     newDisplayName: z.string().optional(),
-    allowedResourceActions: zod.alias('a', z.string().optional()),
-    description: zod.alias('d', z.string().optional()),
-    enabled: zod.alias('e', z.boolean().optional()),
-    version: zod.alias('v', z.string().optional())
-})
-    .strict();
+    allowedResourceActions: z.string().optional().alias('a'),
+    description: z.string().optional().alias('d'),
+    enabled: z.boolean().optional().alias('e'),
+    version: z.string().optional().alias('v')
+});
 class EntraRoleDefinitionSetCommand extends GraphCommand {
     get name() {
         return commands.ROLEDEFINITION_SET;
@@ -30,17 +28,17 @@ class EntraRoleDefinitionSetCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => !options.id !== !options.displayName, {
-            message: 'Specify either id or displayName, but not both'
+            error: 'Specify either id or displayName, but not both'
         })
             .refine(options => options.id || options.displayName, {
-            message: 'Specify either id or displayName'
+            error: 'Specify either id or displayName'
         })
-            .refine(options => (!options.id && !options.displayName) || options.displayName || (options.id && validation.isValidGuid(options.id)), options => ({
-            message: `The '${options.id}' must be a valid GUID`,
+            .refine(options => (!options.id && !options.displayName) || options.displayName || (options.id && validation.isValidGuid(options.id)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['id']
-        }))
+        })
             .refine(options => Object.values([options.newDisplayName, options.description, options.allowedResourceActions, options.enabled, options.version]).filter(v => typeof v !== 'undefined').length > 0, {
-            message: 'Provide value for at least one of the following parameters: newDisplayName, description, allowedResourceActions, enabled or version'
+            error: 'Provide value for at least one of the following parameters: newDisplayName, description, allowedResourceActions, enabled or version'
         });
     }
     async commandAction(logger, args) {

package/dist/m365/entra/commands/rolepermission/rolepermission-list.js

@@ -3,13 +3,11 @@ 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';
-const options = globalOptionsZod
-    .extend({
-    resourceNamespace: zod.alias('n', z.string()),
-    privileged: zod.alias('p', z.boolean().optional())
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    resourceNamespace: z.string().alias('n'),
+    privileged: z.boolean().optional().alias('p')
+});
 class EntraRolePermissionListCommand extends GraphCommand {
     get name() {
         return commands.ROLEPERMISSION_LIST;

package/dist/m365/entra/commands/user/user-session-revoke.js

@@ -1,23 +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 { cli } from '../../../../cli/cli.js';
 import { formatting } from '../../../../utils/formatting.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()),
-    force: zod.alias('f', z.boolean().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'),
+    force: z.boolean().optional().alias('f')
+});
 class EntraUserSessionRevokeCommand extends GraphCommand {
     get name() {
         return commands.USER_SESSION_REVOKE;
@@ -31,7 +27,7 @@ class EntraUserSessionRevokeCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => [options.userId, options.userName].filter(o => o !== undefined).length === 1, {
-            message: `Specify either 'userId' or 'userName'.`
+            error: `Specify either 'userId' or 'userName'.`
         });
     }
     async commandAction(logger, args) {

package/dist/m365/exo/commands/approleassignment/approleassignment-add.js

@@ -9,15 +9,14 @@ import { entraUser } from '../../../../utils/entraUser.js';
 import { entraGroup } from '../../../../utils/entraGroup.js';
 import { entraAdministrativeUnit } from '../../../../utils/entraAdministrativeUnit.js';
 import { entraServicePrincipal } from '../../../../utils/entraServicePrincipal.js';
-import { zod } from '../../../../utils/zod.js';
 import { customAppScope } from '../../../../utils/customAppScope.js';
-const options = globalOptionsZod
-    .extend({
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
     roleDefinitionId: z.string().optional(),
     roleDefinitionName: z.string().optional(),
     principalId: z.string().optional(),
     principalName: z.string().optional(),
-    scope: zod.alias('s', z.enum(['tenant', 'user', 'group', 'administrativeUnit', 'custom'])),
+    scope: z.enum(['tenant', 'user', 'group', 'administrativeUnit', 'custom']).alias('s'),
     userId: z.string().optional(),
     userName: z.string().optional(),
     groupId: z.string().optional(),
@@ -26,8 +25,7 @@ const options = globalOptionsZod
     administrativeUnitName: z.string().optional(),
     customAppScopeId: z.string().optional(),
     customAppScopeName: z.string().optional()
-})
-    .strict();
+});
 class ExoAppRoleAssignmentAddCommand extends GraphCommand {
     get name() {
         return commands.APPROLEASSIGNMENT_ADD;
@@ -41,25 +39,25 @@ class ExoAppRoleAssignmentAddCommand extends GraphCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => !options.roleDefinitionId !== !options.roleDefinitionName, {
-            message: 'Specify either roleDefinitionId or roleDefinitionName, but not both'
+            error: 'Specify either roleDefinitionId or roleDefinitionName, but not both'
         })
             .refine(options => options.roleDefinitionId || options.roleDefinitionName, {
-            message: 'Specify either roleDefinitionId or roleDefinitionName'
+            error: 'Specify either roleDefinitionId or roleDefinitionName'
         })
-            .refine(options => (!options.roleDefinitionId && !options.roleDefinitionName) || options.roleDefinitionName || (options.roleDefinitionId && validation.isValidGuid(options.roleDefinitionId)), options => ({
-            message: `The '${options.roleDefinitionId}' must be a valid GUID`,
+            .refine(options => (!options.roleDefinitionId && !options.roleDefinitionName) || options.roleDefinitionName || (options.roleDefinitionId && validation.isValidGuid(options.roleDefinitionId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['roleDefinitionId']
-        }))
+        })
             .refine(options => !options.principalId !== !options.principalName, {
-            message: 'Specify either principalId or principalName, but not both'
+            error: 'Specify either principalId or principalName, but not both'
         })
             .refine(options => options.principalId || options.principalName, {
-            message: 'Specify either principalId or principalName'
+            error: 'Specify either principalId or principalName'
         })
-            .refine(options => (!options.principalId && !options.principalName) || options.principalName || (options.principalId && validation.isValidGuid(options.principalId)), options => ({
-            message: `The '${options.principalId}' must be a valid GUID`,
+            .refine(options => (!options.principalId && !options.principalName) || options.principalName || (options.principalId && validation.isValidGuid(options.principalId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['principalId']
-        }))
+        })
             .refine(options => options.scope !== 'tenant' || Object.values([options.userId, options.userName, options.groupId, options.groupName, options.administrativeUnitId, options.administrativeUnitName, options.customAppScopeId, options.customAppScopeName]).filter(v => typeof v !== 'undefined').length === 0, {
             message: "When the scope is set to 'tenant' then do not specify neither userId, userName, groupId, groupName, administrativeUnitId, administrativeUnitName, customAppScopeId nor customAppScopeName",
             path: ['scope']
@@ -76,14 +74,14 @@ class ExoAppRoleAssignmentAddCommand extends GraphCommand {
             message: "When the scope is set to 'user' specify either userId or userName",
             path: ['scope']
         })
-            .refine(options => options.scope !== 'user' || (!options.userId && !options.userName) || options.userName || (options.userId && validation.isValidGuid(options.userId)), options => ({
-            message: `The '${options.userId}' must be a valid GUID`,
+            .refine(options => options.scope !== 'user' || (!options.userId && !options.userName) || options.userName || (options.userId && validation.isValidGuid(options.userId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['userId']
-        }))
-            .refine(options => options.scope !== 'user' || (!options.userId && !options.userName) || options.userId || (options.userName && validation.isValidUserPrincipalName(options.userName)), options => ({
-            message: `The '${options.userId}' must be a valid GUID`,
+        })
+            .refine(options => options.scope !== 'user' || (!options.userId && !options.userName) || options.userId || (options.userName && validation.isValidUserPrincipalName(options.userName)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['userName']
-        }))
+        })
             .refine(options => options.scope !== 'group' || Object.values([options.userId, options.userName, options.administrativeUnitId, options.administrativeUnitName, options.customAppScopeId, options.customAppScopeName]).filter(v => typeof v !== 'undefined').length === 0, {
             message: "When the scope is set to 'group' then do not specify userId, userName, administrativeUnitId, administrativeUnitName, customAppScopeId nor customAppScopeName",
             path: ['scope']
@@ -96,10 +94,10 @@ class ExoAppRoleAssignmentAddCommand extends GraphCommand {
             message: "When the scope is set to 'group' specify either groupId or groupName",
             path: ['scope']
         })
-            .refine(options => options.scope !== 'group' || (!options.groupId && !options.groupName) || options.groupName || (options.groupId && validation.isValidGuid(options.groupId)), options => ({
-            message: `The '${options.groupId}' must be a valid GUID`,
+            .refine(options => options.scope !== 'group' || (!options.groupId && !options.groupName) || options.groupName || (options.groupId && validation.isValidGuid(options.groupId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['groupId']
-        }))
+        })
             .refine(options => options.scope !== 'administrativeUnit' || Object.values([options.userId, options.userName, options.groupId, options.groupName, options.customAppScopeId, options.customAppScopeName]).filter(v => typeof v !== 'undefined').length === 0, {
             message: "When the scope is set to 'administrativeUnit' then do not specify userId, userName, groupId, groupName, customAppScopeId nor customAppScopeName",
             path: ['scope']
@@ -112,10 +110,10 @@ class ExoAppRoleAssignmentAddCommand extends GraphCommand {
             message: "When the scope is set to 'administrativeUnit' specify either administrativeUnitId or administrativeUnitName",
             path: ['scope']
         })
-            .refine(options => options.scope !== 'administrativeUnit' || (!options.administrativeUnitId && !options.administrativeUnitName) || options.administrativeUnitName || (options.administrativeUnitId && validation.isValidGuid(options.administrativeUnitId)), options => ({
-            message: `The '${options.administrativeUnitId}' must be a valid GUID`,
+            .refine(options => options.scope !== 'administrativeUnit' || (!options.administrativeUnitId && !options.administrativeUnitName) || options.administrativeUnitName || (options.administrativeUnitId && validation.isValidGuid(options.administrativeUnitId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['administrativeUnitId']
-        }))
+        })
             .refine(options => options.scope !== 'custom' || Object.values([options.userId, options.userName, options.groupId, options.groupName, options.administrativeUnitId, options.administrativeUnitName]).filter(v => typeof v !== 'undefined').length === 0, {
             message: "When the scope is set to 'custom' then do not specify userId, userName, groupId, groupName, administrativeUnitId nor administrativeUnitName",
             path: ['scope']
@@ -128,10 +126,10 @@ class ExoAppRoleAssignmentAddCommand extends GraphCommand {
             message: "When the scope is set to 'custom' specify either customAppScopeId or customAppScopeName",
             path: ['scope']
         })
-            .refine(options => options.scope !== 'custom' || (!options.customAppScopeId && !options.customAppScopeName) || options.customAppScopeName || (options.customAppScopeId && validation.isValidGuid(options.customAppScopeId)), options => ({
-            message: `The '${options.customAppScopeId}' must be a valid GUID`,
+            .refine(options => options.scope !== 'custom' || (!options.customAppScopeId && !options.customAppScopeName) || options.customAppScopeName || (options.customAppScopeId && validation.isValidGuid(options.customAppScopeId)), {
+            error: e => `The '${e.input}' must be a valid GUID`,
             path: ['customAppScopeId']
-        }));
+        });
     }
     async commandAction(logger, args) {
         try {

package/dist/m365/flow/commands/environment/environment-get.js

@@ -2,15 +2,13 @@ import { z } from 'zod';
 import { globalOptionsZod } from '../../../../Command.js';
 import request from '../../../../request.js';
 import { formatting } from '../../../../utils/formatting.js';
-import { zod } from '../../../../utils/zod.js';
 import PowerAutomateCommand from '../../../base/PowerAutomateCommand.js';
 import commands from '../../commands.js';
-const options = globalOptionsZod
-    .extend({
-    name: zod.alias('n', z.string().optional()),
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    name: z.string().optional().alias('n'),
     default: z.boolean().optional()
-})
-    .strict();
+});
 class FlowEnvironmentGetCommand extends PowerAutomateCommand {
     get name() {
         return commands.ENVIRONMENT_GET;
@@ -24,7 +22,7 @@ class FlowEnvironmentGetCommand extends PowerAutomateCommand {
     getRefinedSchema(schema) {
         return schema
             .refine(options => !!options.name !== !!options.default, {
-            message: `Specify either name or default, but not both.`
+            error: `Specify either name or default, but not both.`
         });
     }
     async commandAction(logger, args) {

package/dist/m365/flow/commands/environment/environment-list.js

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

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

@@ -1,16 +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 { formatting } from '../../../../utils/formatting.js';
 import { odata } from '../../../../utils/odata.js';
 import { cli } from '../../../../cli/cli.js';
-const options = globalOptionsZod
-    .extend({
-    environmentName: zod.alias('e', z.string())
-})
-    .strict();
+export const options = z.strictObject({
+    ...globalOptionsZod.shape,
+    environmentName: z.string().alias('e')
+});
 class FlowRecycleBinItemListCommand extends PowerAutomateCommand {
     get name() {
         return commands.RECYCLEBINITEM_LIST;