@softeria/ms-365-mcp-server
Version:
Microsoft 365 MCP Server
1,298 lines • 702 kB
JavaScript
import { makeApi, Zodios } from './hack.js';
import { z } from 'zod';
const microsoft_graph_ODataErrors_ErrorDetails = z
.object({ code: z.string(), message: z.string(), target: z.string().nullish() })
.strict();
const microsoft_graph_ODataErrors_InnerError = z
.object({
'request-id': z.string().describe('Request Id as tracked internally by the service').nullable(),
'client-request-id': z
.string()
.describe('Client request Id as sent by the client application.')
.nullable(),
date: z
.string()
.regex(/^[0-9]{4,}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]([.][0-9]{1,12})?(Z|[+-][0-9][0-9]:[0-9][0-9])$/)
.datetime({ offset: true })
.describe('Date when the error occured.')
.nullable(),
})
.partial()
.strict();
const microsoft_graph_ODataErrors_MainError = z
.object({
code: z.string(),
message: z.string(),
target: z.string().nullish(),
details: z.array(microsoft_graph_ODataErrors_ErrorDetails).optional(),
innerError: microsoft_graph_ODataErrors_InnerError.optional(),
})
.strict();
const microsoft_graph_ODataErrors_ODataError = z
.object({ error: microsoft_graph_ODataErrors_MainError })
.strict();
const microsoft_graph_identity = z
.object({
displayName: z
.string()
.describe("The display name of the identity.For drive items, the display name might not always be available or up to date. For example, if a user changes their display name the API might show the new value in a future response, but the items associated with the user don't show up as changed when using delta.")
.nullable(),
id: z
.string()
.describe("Unique identifier for the identity or actor. For example, in the access reviews decisions API, this property might record the id of the principal, that is, the group, user, or application that's subject to review.")
.nullable(),
})
.partial()
.strict();
const microsoft_graph_identitySet = z
.object({
application: z
.union([microsoft_graph_identity, z.object({}).partial().strict()])
.describe('Optional. The application associated with this action.'),
device: z
.union([microsoft_graph_identity, z.object({}).partial().strict()])
.describe('Optional. The device associated with this action.'),
user: z
.union([microsoft_graph_identity, z.object({}).partial().strict()])
.describe('Optional. The user associated with this action.'),
})
.partial()
.strict();
const microsoft_graph_sharepointIds = z
.object({
listId: z
.string()
.describe("The unique identifier (guid) for the item's list in SharePoint.")
.nullable(),
listItemId: z
.string()
.describe('An integer identifier for the item within the containing list.')
.nullable(),
listItemUniqueId: z
.string()
.describe('The unique identifier (guid) for the item within OneDrive for Business or a SharePoint site.')
.nullable(),
siteId: z
.string()
.describe("The unique identifier (guid) for the item's site collection (SPSite).")
.nullable(),
siteUrl: z
.string()
.describe('The SharePoint URL for the site that contains the item.')
.nullable(),
tenantId: z.string().describe('The unique identifier (guid) for the tenancy.').nullable(),
webId: z
.string()
.describe("The unique identifier (guid) for the item's site (SPWeb).")
.nullable(),
})
.partial()
.strict();
const microsoft_graph_itemReference = z
.object({
driveId: z
.string()
.describe('Unique identifier of the drive instance that contains the driveItem. Only returned if the item is located in a drive. Read-only.')
.nullable(),
driveType: z
.string()
.describe('Identifies the type of drive. Only returned if the item is located in a drive. See drive resource for values.')
.nullable(),
id: z
.string()
.describe('Unique identifier of the driveItem in the drive or a listItem in a list. Read-only.')
.nullable(),
name: z.string().describe('The name of the item being referenced. Read-only.').nullable(),
path: z
.string()
.describe('Percent-encoded path that can be used to navigate to the item. Read-only.')
.nullable(),
shareId: z
.string()
.describe('A unique identifier for a shared resource that can be accessed via the Shares API.')
.nullable(),
sharepointIds: z
.union([microsoft_graph_sharepointIds, z.object({}).partial().strict()])
.describe('Returns identifiers useful for SharePoint REST compatibility. Read-only.'),
siteId: z
.string()
.describe('For OneDrive for Business and SharePoint, this property represents the ID of the site that contains the parent document library of the driveItem resource or the parent list of the listItem resource. The value is the same as the id property of that site resource. It is an opaque string that consists of three identifiers of the site. For OneDrive, this property is not populated.')
.nullable(),
})
.partial()
.strict();
const microsoft_graph_assignedLicense = z
.object({
disabledPlans: z
.array(z
.string()
.regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/)
.uuid())
.describe("A collection of the unique identifiers for plans that have been disabled. IDs are available in servicePlans > servicePlanId in the tenant's subscribedSkus or serviceStatus > servicePlanId in the tenant's companySubscription."),
skuId: z
.string()
.regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/)
.uuid()
.describe('The unique identifier for the SKU. Corresponds to the skuId from subscribedSkus or companySubscription.')
.nullable(),
})
.partial()
.strict();
const microsoft_graph_assignedPlan = z
.object({
assignedDateTime: z
.string()
.regex(/^[0-9]{4,}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]([.][0-9]{1,12})?(Z|[+-][0-9][0-9]:[0-9][0-9])$/)
.datetime({ offset: true })
.describe('The date and time at which the plan was assigned. The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z.')
.nullable(),
capabilityStatus: z
.string()
.describe('Condition of the capability assignment. The possible values are Enabled, Warning, Suspended, Deleted, LockedOut. See a detailed description of each value.')
.nullable(),
service: z.string().describe('The name of the service; for example, exchange.').nullable(),
servicePlanId: z
.string()
.regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/)
.uuid()
.describe('A GUID that identifies the service plan. For a complete list of GUIDs and their equivalent friendly service names, see Product names and service plan identifiers for licensing.')
.nullable(),
})
.partial()
.strict();
const microsoft_graph_authorizationInfo = z
.object({ certificateUserIds: z.array(z.string().nullable()) })
.partial()
.strict();
const microsoft_graph_customSecurityAttributeValue = z.object({}).partial().strict();
const microsoft_graph_employeeOrgData = z
.object({
costCenter: z
.string()
.describe('The cost center associated with the user. Returned only on $select. Supports $filter.')
.nullable(),
division: z
.string()
.describe('The name of the division in which the user works. Returned only on $select. Supports $filter.')
.nullable(),
})
.partial()
.strict();
const microsoft_graph_objectIdentity = z
.object({
issuer: z
.string()
.describe("Specifies the issuer of the identity, for example facebook.com. 512 character limit. For local accounts (where signInType isn't federated), this property is the local default domain name for the tenant, for example contoso.com. For guests from other Microsoft Entra organizations, this is the domain of the federated organization, for example contoso.com. For more information about filtering behavior for this property, see Filtering on the identities property of a user.")
.nullable(),
issuerAssignedId: z
.string()
.describe('Specifies the unique identifier assigned to the user by the issuer. 64 character limit. The combination of issuer and issuerAssignedId must be unique within the organization. Represents the sign-in name for the user, when signInType is set to emailAddress or userName (also known as local accounts).When signInType is set to: emailAddress (or a custom string that starts with emailAddress like emailAddress1), issuerAssignedId must be a valid email addressuserName, issuerAssignedId must begin with an alphabetical character or number, and can only contain alphanumeric characters and the following symbols: - or _ For more information about filtering behavior for this property, see Filtering on the identities property of a user.')
.nullable(),
signInType: z
.string()
.describe('Specifies the user sign-in types in your directory, such as emailAddress, userName, federated, or userPrincipalName. federated represents a unique identifier for a user from an issuer that can be in any format chosen by the issuer. Setting or updating a userPrincipalName identity updates the value of the userPrincipalName property on the user object. The validations performed on the userPrincipalName property on the user object, for example, verified domains and acceptable characters, are performed when setting or updating a userPrincipalName identity. Extra validation is enforced on issuerAssignedId when the sign-in type is set to emailAddress or userName. This property can also be set to any custom string. For more information about filtering behavior for this property, see Filtering on the identities property of a user.')
.nullable(),
})
.partial()
.strict();
const microsoft_graph_licenseAssignmentState = z
.object({
assignedByGroup: z.string().nullable(),
disabledPlans: z.array(z
.string()
.regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/)
.uuid()
.nullable()),
error: z.string().nullable(),
lastUpdatedDateTime: z
.string()
.regex(/^[0-9]{4,}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]([.][0-9]{1,12})?(Z|[+-][0-9][0-9]:[0-9][0-9])$/)
.datetime({ offset: true })
.nullable(),
skuId: z
.string()
.regex(/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/)
.uuid()
.nullable(),
state: z.string().nullable(),
})
.partial()
.strict();
const microsoft_graph_externalAudienceScope = z.enum(['none', 'contactsOnly', 'all']);
const microsoft_graph_dateTimeTimeZone = z
.object({
dateTime: z
.string()
.describe('A single point of time in a combined date and time representation ({date}T{time}; for example, 2017-08-29T04:00:00.0000000).'),
timeZone: z
.string()
.describe("Represents a time zone, for example, 'Pacific Standard Time'. See below for more possible values.")
.nullable(),
})
.partial()
.strict();
const microsoft_graph_automaticRepliesStatus = z.enum(['disabled', 'alwaysEnabled', 'scheduled']);
const microsoft_graph_automaticRepliesSetting = z
.object({
externalAudience: z
.union([microsoft_graph_externalAudienceScope, z.object({}).partial().strict()])
.describe("The set of audience external to the signed-in user's organization who will receive the ExternalReplyMessage, if Status is AlwaysEnabled or Scheduled. The possible values are: none, contactsOnly, all."),
externalReplyMessage: z
.string()
.describe('The automatic reply to send to the specified external audience, if Status is AlwaysEnabled or Scheduled.')
.nullable(),
internalReplyMessage: z
.string()
.describe("The automatic reply to send to the audience internal to the signed-in user's organization, if Status is AlwaysEnabled or Scheduled.")
.nullable(),
scheduledEndDateTime: z
.union([microsoft_graph_dateTimeTimeZone, z.object({}).partial().strict()])
.describe('The date and time that automatic replies are set to end, if Status is set to Scheduled.'),
scheduledStartDateTime: z
.union([microsoft_graph_dateTimeTimeZone, z.object({}).partial().strict()])
.describe('The date and time that automatic replies are set to begin, if Status is set to Scheduled.'),
status: z
.union([microsoft_graph_automaticRepliesStatus, z.object({}).partial().strict()])
.describe('Configurations status for automatic replies. The possible values are: disabled, alwaysEnabled, scheduled.'),
})
.partial()
.strict();
const microsoft_graph_delegateMeetingMessageDeliveryOptions = z.enum([
'sendToDelegateAndInformationToPrincipal',
'sendToDelegateAndPrincipal',
'sendToDelegateOnly',
]);
const microsoft_graph_localeInfo = z
.object({
displayName: z
.string()
.describe("A name representing the user's locale in natural language, for example, 'English (United States)'.")
.nullable(),
locale: z
.string()
.describe("A locale representation for the user, which includes the user's preferred language and country/region. For example, 'en-us'. The language component follows 2-letter codes as defined in ISO 639-1, and the country component follows 2-letter codes as defined in ISO 3166-1 alpha-2.")
.nullable(),
})
.partial()
.strict();
const microsoft_graph_userPurpose = z.enum([
'user',
'linked',
'shared',
'room',
'equipment',
'others',
'unknownFutureValue',
]);
const microsoft_graph_dayOfWeek = z.enum([
'sunday',
'monday',
'tuesday',
'wednesday',
'thursday',
'friday',
'saturday',
]);
const microsoft_graph_timeZoneBase = z
.object({
name: z
.string()
.describe("The name of a time zone. It can be a standard time zone name such as 'Hawaii-Aleutian Standard Time', or 'Customized Time Zone' for a custom time zone.")
.nullable(),
})
.partial()
.strict();
const microsoft_graph_workingHours = z
.object({
daysOfWeek: z
.array(z.union([microsoft_graph_dayOfWeek, z.object({}).partial().strict()]))
.describe('The days of the week on which the user works.'),
endTime: z
.string()
.regex(/^([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]([.][0-9]{1,12})?$/)
.describe('The time of the day that the user stops working.')
.nullable(),
startTime: z
.string()
.regex(/^([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]([.][0-9]{1,12})?$/)
.describe('The time of the day that the user starts working.')
.nullable(),
timeZone: z
.union([microsoft_graph_timeZoneBase, z.object({}).partial().strict()])
.describe('The time zone to which the working hours apply.'),
})
.partial()
.strict();
const microsoft_graph_mailboxSettings = z
.object({
archiveFolder: z.string().describe('Folder ID of an archive folder for the user.').nullable(),
automaticRepliesSetting: z
.union([microsoft_graph_automaticRepliesSetting, z.object({}).partial().strict()])
.describe('Configuration settings to automatically notify the sender of an incoming email with a message from the signed-in user.'),
dateFormat: z.string().describe("The date format for the user's mailbox.").nullable(),
delegateMeetingMessageDeliveryOptions: z
.union([
microsoft_graph_delegateMeetingMessageDeliveryOptions,
z.object({}).partial().strict(),
])
.describe('If the user has a calendar delegate, this specifies whether the delegate, mailbox owner, or both receive meeting messages and meeting responses. Possible values are: sendToDelegateAndInformationToPrincipal, sendToDelegateAndPrincipal, sendToDelegateOnly.'),
language: z
.union([microsoft_graph_localeInfo, z.object({}).partial().strict()])
.describe('The locale information for the user, including the preferred language and country/region.'),
timeFormat: z.string().describe("The time format for the user's mailbox.").nullable(),
timeZone: z.string().describe("The default time zone for the user's mailbox.").nullable(),
userPurpose: z
.union([microsoft_graph_userPurpose, z.object({}).partial().strict()])
.describe('The purpose of the mailbox. Differentiates a mailbox for a single user from a shared mailbox and equipment mailbox in Exchange Online. Possible values are: user, linked, shared, room, equipment, others, unknownFutureValue. Read-only.'),
workingHours: z
.union([microsoft_graph_workingHours, z.object({}).partial().strict()])
.describe('The days of the week and hours in a specific time zone that the user works.'),
})
.partial()
.strict();
const microsoft_graph_onPremisesExtensionAttributes = z
.object({
extensionAttribute1: z.string().describe('First customizable extension attribute.').nullable(),
extensionAttribute10: z.string().describe('Tenth customizable extension attribute.').nullable(),
extensionAttribute11: z
.string()
.describe('Eleventh customizable extension attribute.')
.nullable(),
extensionAttribute12: z
.string()
.describe('Twelfth customizable extension attribute.')
.nullable(),
extensionAttribute13: z
.string()
.describe('Thirteenth customizable extension attribute.')
.nullable(),
extensionAttribute14: z
.string()
.describe('Fourteenth customizable extension attribute.')
.nullable(),
extensionAttribute15: z
.string()
.describe('Fifteenth customizable extension attribute.')
.nullable(),
extensionAttribute2: z.string().describe('Second customizable extension attribute.').nullable(),
extensionAttribute3: z.string().describe('Third customizable extension attribute.').nullable(),
extensionAttribute4: z.string().describe('Fourth customizable extension attribute.').nullable(),
extensionAttribute5: z.string().describe('Fifth customizable extension attribute.').nullable(),
extensionAttribute6: z.string().describe('Sixth customizable extension attribute.').nullable(),
extensionAttribute7: z
.string()
.describe('Seventh customizable extension attribute.')
.nullable(),
extensionAttribute8: z.string().describe('Eighth customizable extension attribute.').nullable(),
extensionAttribute9: z.string().describe('Ninth customizable extension attribute.').nullable(),
})
.partial()
.strict();
const microsoft_graph_onPremisesProvisioningError = z
.object({
category: z
.string()
.describe('Category of the provisioning error. Note: Currently, there is only one possible value. Possible value: PropertyConflict - indicates a property value is not unique. Other objects contain the same value for the property.')
.nullable(),
occurredDateTime: z
.string()
.regex(/^[0-9]{4,}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]([.][0-9]{1,12})?(Z|[+-][0-9][0-9]:[0-9][0-9])$/)
.datetime({ offset: true })
.describe('The date and time at which the error occurred.')
.nullable(),
propertyCausingError: z
.string()
.describe('Name of the directory property causing the error. Current possible values: UserPrincipalName or ProxyAddress')
.nullable(),
value: z.string().describe('Value of the property causing the error.').nullable(),
})
.partial()
.strict();
const microsoft_graph_passwordProfile = z
.object({
forceChangePasswordNextSignIn: z
.boolean()
.describe('true if the user must change their password on the next sign-in; otherwise false.')
.nullable(),
forceChangePasswordNextSignInWithMfa: z
.boolean()
.describe('If true, at next sign-in, the user must perform a multifactor authentication (MFA) before being forced to change their password. The behavior is identical to forceChangePasswordNextSignIn except that the user is required to first perform a multifactor authentication before password change. After a password change, this property will be automatically reset to false. If not set, default is false.')
.nullable(),
password: z
.string()
.describe("The password for the user. This property is required when a user is created. It can be updated, but the user will be required to change the password on the next sign-in. The password must satisfy minimum requirements as specified by the user's passwordPolicies property. By default, a strong password is required.")
.nullable(),
})
.partial()
.strict();
const microsoft_graph_printColorMode = z.enum([
'blackAndWhite',
'grayscale',
'color',
'auto',
'unknownFutureValue',
]);
const microsoft_graph_integerRange = z
.object({
end: z.number().describe('The inclusive upper bound of the integer range.').nullable(),
start: z.number().describe('The inclusive lower bound of the integer range.').nullable(),
})
.partial()
.strict();
const microsoft_graph_printDuplexMode = z.enum([
'flipOnLongEdge',
'flipOnShortEdge',
'oneSided',
'unknownFutureValue',
]);
const microsoft_graph_printerFeedOrientation = z.enum([
'longEdgeFirst',
'shortEdgeFirst',
'unknownFutureValue',
]);
const microsoft_graph_printFinishing = z.enum([
'none',
'staple',
'punch',
'cover',
'bind',
'saddleStitch',
'stitchEdge',
'stapleTopLeft',
'stapleBottomLeft',
'stapleTopRight',
'stapleBottomRight',
'stitchLeftEdge',
'stitchTopEdge',
'stitchRightEdge',
'stitchBottomEdge',
'stapleDualLeft',
'stapleDualTop',
'stapleDualRight',
'stapleDualBottom',
'unknownFutureValue',
'stapleTripleLeft',
'stapleTripleTop',
'stapleTripleRight',
'stapleTripleBottom',
'bindLeft',
'bindTop',
'bindRight',
'bindBottom',
'foldAccordion',
'foldDoubleGate',
'foldGate',
'foldHalf',
'foldHalfZ',
'foldLeftGate',
'foldLetter',
'foldParallel',
'foldPoster',
'foldRightGate',
'foldZ',
'foldEngineeringZ',
'punchTopLeft',
'punchBottomLeft',
'punchTopRight',
'punchBottomRight',
'punchDualLeft',
'punchDualTop',
'punchDualRight',
'punchDualBottom',
'punchTripleLeft',
'punchTripleTop',
'punchTripleRight',
'punchTripleBottom',
'punchQuadLeft',
'punchQuadTop',
'punchQuadRight',
'punchQuadBottom',
'fold',
'trim',
'bale',
'bookletMaker',
'coat',
'laminate',
'trimAfterPages',
'trimAfterDocuments',
'trimAfterCopies',
'trimAfterJob',
]);
const microsoft_graph_printMultipageLayout = z.enum([
'clockwiseFromTopLeft',
'counterclockwiseFromTopLeft',
'counterclockwiseFromTopRight',
'clockwiseFromTopRight',
'counterclockwiseFromBottomLeft',
'clockwiseFromBottomLeft',
'counterclockwiseFromBottomRight',
'clockwiseFromBottomRight',
'unknownFutureValue',
]);
const microsoft_graph_printOrientation = z.enum([
'portrait',
'landscape',
'reverseLandscape',
'reversePortrait',
'unknownFutureValue',
]);
const microsoft_graph_printQuality = z.enum(['low', 'medium', 'high', 'unknownFutureValue']);
const microsoft_graph_printScaling = z.enum([
'auto',
'shrinkToFit',
'fill',
'fit',
'none',
'unknownFutureValue',
]);
const microsoft_graph_printerCapabilities = z
.object({
bottomMargins: z
.array(z.number().gte(-2147483648).lte(2147483647).nullable())
.describe('A list of supported bottom margins(in microns) for the printer.'),
collation: z
.boolean()
.describe('True if the printer supports collating when printing muliple copies of a multi-page document; false otherwise.')
.nullable(),
colorModes: z
.array(z.union([microsoft_graph_printColorMode, z.object({}).partial().strict()]))
.describe('The color modes supported by the printer. Valid values are described in the following table.'),
contentTypes: z
.array(z.string().nullable())
.describe('A list of supported content (MIME) types that the printer supports. It is not guaranteed that the Universal Print service supports printing all of these MIME types.'),
copiesPerJob: z
.union([microsoft_graph_integerRange, z.object({}).partial().strict()])
.describe('The range of copies per job supported by the printer.'),
dpis: z
.array(z.number().gte(-2147483648).lte(2147483647).nullable())
.describe('The list of print resolutions in DPI that are supported by the printer.'),
duplexModes: z
.array(z.union([microsoft_graph_printDuplexMode, z.object({}).partial().strict()]))
.describe('The list of duplex modes that are supported by the printer. Valid values are described in the following table.'),
feedOrientations: z
.array(z.union([microsoft_graph_printerFeedOrientation, z.object({}).partial().strict()]))
.describe('The list of feed orientations that are supported by the printer.'),
finishings: z
.array(z.union([microsoft_graph_printFinishing, z.object({}).partial().strict()]))
.describe('Finishing processes the printer supports for a printed document.'),
inputBins: z.array(z.string().nullable()).describe('Supported input bins for the printer.'),
isColorPrintingSupported: z
.boolean()
.describe('True if color printing is supported by the printer; false otherwise. Read-only.')
.nullable(),
isPageRangeSupported: z
.boolean()
.describe('True if the printer supports printing by page ranges; false otherwise.')
.nullable(),
leftMargins: z
.array(z.number().gte(-2147483648).lte(2147483647).nullable())
.describe('A list of supported left margins(in microns) for the printer.'),
mediaColors: z
.array(z.string().nullable())
.describe('The media (i.e., paper) colors supported by the printer.'),
mediaSizes: z
.array(z.string().nullable())
.describe('The media sizes supported by the printer. Supports standard size names for ISO and ANSI media sizes. Valid values are in the following table.'),
mediaTypes: z
.array(z.string().nullable())
.describe('The media types supported by the printer.'),
multipageLayouts: z
.array(z.union([microsoft_graph_printMultipageLayout, z.object({}).partial().strict()]))
.describe('The presentation directions supported by the printer. Supported values are described in the following table.'),
orientations: z
.array(z.union([microsoft_graph_printOrientation, z.object({}).partial().strict()]))
.describe('The print orientations supported by the printer. Valid values are described in the following table.'),
outputBins: z
.array(z.string().nullable())
.describe("The printer's supported output bins (trays)."),
pagesPerSheet: z
.array(z.number().gte(-2147483648).lte(2147483647).nullable())
.describe('Supported number of Input Pages to impose upon a single Impression.'),
qualities: z
.array(z.union([microsoft_graph_printQuality, z.object({}).partial().strict()]))
.describe('The print qualities supported by the printer.'),
rightMargins: z
.array(z.number().gte(-2147483648).lte(2147483647).nullable())
.describe('A list of supported right margins(in microns) for the printer.'),
scalings: z
.array(z.union([microsoft_graph_printScaling, z.object({}).partial().strict()]))
.describe('Supported print scalings.'),
supportsFitPdfToPage: z
.boolean()
.describe('True if the printer supports scaling PDF pages to match the print media size; false otherwise.')
.nullable(),
topMargins: z
.array(z.number().gte(-2147483648).lte(2147483647).nullable())
.describe('A list of supported top margins(in microns) for the printer.'),
})
.partial()
.strict();
const microsoft_graph_printerDefaults = z
.object({
colorMode: z
.union([microsoft_graph_printColorMode, z.object({}).partial().strict()])
.describe('The default color mode to use when printing the document. Valid values are described in the following table.'),
contentType: z
.string()
.describe('The default content (MIME) type to use when processing documents.')
.nullable(),
copiesPerJob: z
.number()
.gte(-2147483648)
.lte(2147483647)
.describe('The default number of copies printed per job.')
.nullable(),
dpi: z
.number()
.gte(-2147483648)
.lte(2147483647)
.describe('The default resolution in DPI to use when printing the job.')
.nullable(),
duplexMode: z
.union([microsoft_graph_printDuplexMode, z.object({}).partial().strict()])
.describe('The default duplex (double-sided) configuration to use when printing a document. Valid values are described in the following table.'),
finishings: z
.array(z.union([microsoft_graph_printFinishing, z.object({}).partial().strict()]))
.describe('The default set of finishings to apply to print jobs. Valid values are described in the following table.'),
fitPdfToPage: z
.boolean()
.describe('The default fitPdfToPage setting. True to fit each page of a PDF document to a physical sheet of media; false to let the printer decide how to lay out impressions.')
.nullable(),
inputBin: z
.string()
.describe('The default input bin that serves as the paper source.')
.nullable(),
mediaColor: z
.string()
.describe('The default media (such as paper) color to print the document on.')
.nullable(),
mediaSize: z
.string()
.describe('The default media size to use. Supports standard size names for ISO and ANSI media sizes. Valid values are listed in the printerCapabilities topic.')
.nullable(),
mediaType: z
.string()
.describe('The default media (such as paper) type to print the document on.')
.nullable(),
multipageLayout: z
.union([microsoft_graph_printMultipageLayout, z.object({}).partial().strict()])
.describe('The default direction to lay out pages when multiple pages are being printed per sheet. Valid values are described in the following table.'),
orientation: z
.union([microsoft_graph_printOrientation, z.object({}).partial().strict()])
.describe('The default orientation to use when printing the document. Valid values are described in the following table.'),
outputBin: z
.string()
.describe("The default output bin to place completed prints into. See the printer's capabilities for a list of supported output bins.")
.nullable(),
pagesPerSheet: z
.number()
.gte(-2147483648)
.lte(2147483647)
.describe('The default number of document pages to print on each sheet.')
.nullable(),
quality: z
.union([microsoft_graph_printQuality, z.object({}).partial().strict()])
.describe('The default quality to use when printing the document. Valid values are described in the following table.'),
scaling: z
.union([microsoft_graph_printScaling, z.object({}).partial().strict()])
.describe('Specifies how the printer scales the document data to fit the requested media. Valid values are described in the following table.'),
})
.partial()
.strict();
const microsoft_graph_printerLocation = z
.object({
altitudeInMeters: z
.number()
.gte(-2147483648)
.lte(2147483647)
.describe('The altitude, in meters, that the printer is located at.')
.nullable(),
building: z.string().describe('The building that the printer is located in.').nullable(),
city: z.string().describe('The city that the printer is located in.').nullable(),
countryOrRegion: z
.string()
.describe('The country or region that the printer is located in.')
.nullable(),
floor: z
.string()
.describe('The floor that the printer is located on. Only numerical values are supported right now.')
.nullable(),
floorDescription: z
.string()
.describe('The description of the floor that the printer is located on.')
.nullable(),
latitude: z
.number()
.describe('The latitude that the printer is located at. [Simplified from 3 options]')
.nullable(),
longitude: z
.number()
.describe('The longitude that the printer is located at. [Simplified from 3 options]')
.nullable(),
organization: z
.array(z.string().nullable())
.describe('The organizational hierarchy that the printer belongs to. The elements should be in hierarchical order.'),
postalCode: z.string().describe('The postal code that the printer is located in.').nullable(),
roomDescription: z
.string()
.describe('The description of the room that the printer is located in.')
.nullable(),
roomName: z
.string()
.describe('The room that the printer is located in. Only numerical values are supported right now.')
.nullable(),
site: z.string().describe('The site that the printer is located in.').nullable(),
stateOrProvince: z
.string()
.describe('The state or province that the printer is located in.')
.nullable(),
streetAddress: z
.string()
.describe('The street address where the printer is located.')
.nullable(),
subdivision: z
.array(z.string().nullable())
.describe('The subdivision that the printer is located in. The elements should be in hierarchical order.'),
subunit: z.array(z.string().nullable()),
})
.partial()
.strict();
const microsoft_graph_printerProcessingStateDetail = z.enum([
'paused',
'mediaJam',
'mediaNeeded',
'mediaLow',
'mediaEmpty',
'coverOpen',
'interlockOpen',
'outputTrayMissing',
'outputAreaFull',
'markerSupplyLow',
'markerSupplyEmpty',
'inputTrayMissing',
'outputAreaAlmostFull',
'markerWasteAlmostFull',
'markerWasteFull',
'fuserOverTemp',
'fuserUnderTemp',
'other',
'none',
'movingToPaused',
'shutdown',
'connectingToDevice',
'timedOut',
'stopping',
'stoppedPartially',
'tonerLow',
'tonerEmpty',
'spoolAreaFull',
'doorOpen',
'opticalPhotoConductorNearEndOfLife',
'opticalPhotoConductorLifeOver',
'developerLow',
'developerEmpty',
'interpreterResourceUnavailable',
'unknownFutureValue',
'alertRemovalOfBinaryChangeEntry',
'banderAdded',
'banderAlmostEmpty',
'banderAlmostFull',
'banderAtLimit',
'banderClosed',
'banderConfigurationChange',
'banderCoverClosed',
'banderCoverOpen',
'banderEmpty',
'banderFull',
'banderInterlockClosed',
'banderInterlockOpen',
'banderJam',
'banderLifeAlmostOver',
'banderLifeOver',
'banderMemoryExhausted',
'banderMissing',
'banderMotorFailure',
'banderNearLimit',
'banderOffline',
'banderOpened',
'banderOverTemperature',
'banderPowerSaver',
'banderRecoverableFailure',
'banderRecoverableStorage',
'banderRemoved',
'banderResourceAdded',
'banderResourceRemoved',
'banderThermistorFailure',
'banderTimingFailure',
'banderTurnedOff',
'banderTurnedOn',
'banderUnderTemperature',
'banderUnrecoverableFailure',
'banderUnrecoverableStorageError',
'banderWarmingUp',
'binderAdded',
'binderAlmostEmpty',
'binderAlmostFull',
'binderAtLimit',
'binderClosed',
'binderConfigurationChange',
'binderCoverClosed',
'binderCoverOpen',
'binderEmpty',
'binderFull',
'binderInterlockClosed',
'binderInterlockOpen',
'binderJam',
'binderLifeAlmostOver',
'binderLifeOver',
'binderMemoryExhausted',
'binderMissing',
'binderMotorFailure',
'binderNearLimit',
'binderOffline',
'binderOpened',
'binderOverTemperature',
'binderPowerSaver',
'binderRecoverableFailure',
'binderRecoverableStorage',
'binderRemoved',
'binderResourceAdded',
'binderResourceRemoved',
'binderThermistorFailure',
'binderTimingFailure',
'binderTurnedOff',
'binderTurnedOn',
'binderUnderTemperature',
'binderUnrecoverableFailure',
'binderUnrecoverableStorageError',
'binderWarmingUp',
'cameraFailure',
'chamberCooling',
'chamberFailure',
'chamberHeating',
'chamberTemperatureHigh',
'chamberTemperatureLow',
'cleanerLifeAlmostOver',
'cleanerLifeOver',
'configurationChange',
'deactivated',
'deleted',
'dieCutterAdded',
'dieCutterAlmostEmpty',
'dieCutterAlmostFull',
'dieCutterAtLimit',
'dieCutterClosed',
'dieCutterConfigurationChange',
'dieCutterCoverClosed',
'dieCutterCoverOpen',
'dieCutterEmpty',
'dieCutterFull',
'dieCutterInterlockClosed',
'dieCutterInterlockOpen',
'dieCutterJam',
'dieCutterLifeAlmostOver',
'dieCutterLifeOver',
'dieCutterMemoryExhausted',
'dieCutterMissing',
'dieCutterMotorFailure',
'dieCutterNearLimit',
'dieCutterOffline',
'dieCutterOpened',
'dieCutterOverTemperature',
'dieCutterPowerSaver',
'dieCutterRecoverableFailure',
'dieCutterRecoverableStorage',
'dieCutterRemoved',
'dieCutterResourceAdded',
'dieCutterResourceRemoved',
'dieCutterThermistorFailure',
'dieCutterTimingFailure',
'dieCutterTurnedOff',
'dieCutterTurnedOn',
'dieCutterUnderTemperature',
'dieCutterUnrecoverableFailure',
'dieCutterUnrecoverableStorageError',
'dieCutterWarmingUp',
'extruderCooling',
'extruderFailure',
'extruderHeating',
'extruderJam',
'extruderTemperatureHigh',
'extruderTemperatureLow',
'fanFailure',
'faxModemLifeAlmostOver',
'faxModemLifeOver',
'faxModemMissing',
'faxModemTurnedOff',
'faxModemTurnedOn',
'folderAdded',
'folderAlmostEmpty',
'folderAlmostFull',
'folderAtLimit',
'folderClosed',
'folderConfigurationChange',
'folderCoverClosed',
'folderCoverOpen',
'folderEmpty',
'folderFull',
'folderInterlockClosed',
'folderInterlockOpen',
'folderJam',
'folderLifeAlmostOver',
'folderLifeOver',
'folderMemoryExhausted',
'folderMissing',
'folderMotorFailure',
'folderNearLimit',
'folderOffline',
'folderOpened',
'folderOverTemperature',
'folderPowerSaver',
'folderRecoverableFailure',
'folderRecoverableStorage',
'folderRemoved',
'folderResourceAdded',
'folderResourceRemoved',
'folderThermistorFailure',
'folderTimingFailure',
'folderTurnedOff',
'folderTurnedOn',
'folderUnderTemperature',
'folderUnrecoverableFailure',
'folderUnrecoverableStorageError',
'folderWarmingUp',
'hibernate',
'holdNewJobs',
'identifyPrinterRequested',
'imprinterAdded',
'imprinterAlmostEmpty',
'imprinterAlmostFull',
'imprinterAtLimit',
'imprinterClosed',
'imprinterConfigurationChange',
'imprinterCoverClosed',
'imprinterCoverOpen',
'imprinterEmpty',
'imprinterFull',
'imprinterInterlockClosed',
'imprinterInterlockOpen',
'imprinterJam',
'imprinterLifeAlmostOver',
'imprinterLifeOver',
'imprinterMemoryExhausted',
'imprinterMissing',
'imprinterMotorFailure',
'imprinterNearLimit',
'imprinterOffline',
'imprinterOpened',
'imprinterOverTemperature',
'imprinterPowerSaver',
'imprinterRecoverableFailure',
'imprinterRecoverableStorage',
'imprinterRemoved',
'imprinterResourceAdded',
'imprinterResourceRemoved',
'imprinterThermistorFailure',
'imprinterTimingFailure',
'imprinterTurnedOff',
'imprinterTurnedOn',
'imprinterUnderTemperature',
'imprinterUnrecoverableFailure',
'imprinterUnrecoverableStorageError',
'imprinterWarmingUp',
'inputCannotFeedSizeSelected',
'inputManualInputRequest',
'inputMediaColorChange',
'inputMediaFormPartsChange',
'inputMediaSizeChange',
'inputMediaTrayFailure',
'inputMediaTrayFeedError',
'inputMediaTrayJam',
'inputMediaTypeChange',
'inputMediaWeightChange',
'inputPickRollerFailure',
'inputPickRollerLifeOver',
'inputPickRollerLifeWarn',
'inputPickRollerMissing',
'inputTrayElevationFailure',
'inputTrayPositionFailure',
'inserterAdded',
'inserterAlmostEmpty',
'inserterAlmostFull',
'inserterAtLimit',
'inserterClosed',
'inserterConfigurationChange',
'inserterCoverClosed',
'inserterCoverOpen',
'inserterEmpty',
'inserterFull',
'inserterInterlockClosed',
'inserterInterlockOpen',
'inserterJam',
'inserterLifeAlmostOver',
'inserterLifeOver',
'inserterMemoryExhausted',
'inserterMissing',
'inserterMotorFailure',
'inserterNearLimit',
'inserterOffline',
'inserterOpened',
'inserterOverTemperature',
'inserterPowerSaver',
'inserterRecoverableFailure',
'inserterRecoverableStorage',
'inserterRemoved',
'inserterResourceAdded',
'inserterResourceRemoved',
'inserterThermistorFailure',
'inserterTimingFailure',
'inserterTurnedOff',
'inserterTurnedOn',
'inserterUnderTemperature',
'inserterUnrecoverableFailure',
'inserterUnrecoverableStorageError',
'inserterWarmingUp',
'interlockClosed',
'interpreterCartridgeAdded',
'interpreterCartridgeDeleted',
'interpreterComplexPageEncountered',
'interpreterMemoryDecrease',
'interpreterMemoryIncrease',
'interpreterResourceAdded',
'interpreterResourceDeleted',
'lampAtEol',
'lampFailure',
'lampNearEol',
'laserAtEol',
'laserFailure',
'laserNearEol',
'makeEnvelopeAdded',
'makeEnvelopeAlmostEmpty',
'makeEnvelopeAlmostFull',
'makeEnvelopeAtLimit',
'makeEnvelopeClosed',
'makeEnvelopeConfigurationChange',
'makeEnvelopeCoverClosed',
'makeEnvelopeCoverOpen',
'makeEnvelopeEmpty',
'makeEnvelopeFull',
'makeEnvelopeInterlockClosed',
'makeEnvelopeInterlockOpen',
'makeEnvelopeJam',
'makeEnvelopeLifeAlmostOver',
'makeEnvelopeLifeOver',
'makeEnvelopeMemoryExhausted',
'makeEnvelopeMissing',
'makeEnvelopeMotorFailure',
'makeEnvelopeNearLimit',
'makeEnvelopeOffline',
'makeEnvelopeOpened',
'makeEnvelopeOverTemperature',
'makeEnvelopePowerSaver',
'makeEnvelopeRecoverableFailure',
'makeEnvelopeRecoverableStorage',
'makeEnvelopeRemoved',
'makeEnvelopeResourceAdded',
'makeEnvelopeResourceRemoved',
'makeEnvelopeThermistorFailure',
'makeEnvelopeTimingFailure',
'makeEnvelopeTurnedOff',
'makeEnvelopeTurnedOn',
'makeEnvelopeUnderTemperature',
'makeEnvelopeUnrecoverableFailure',
'makeEnvelopeUnrecoverableStorageError',
'makeEnvelopeWarmingUp',
'markerAdjustingPrintQuality',
'markerCleanerMissing',
'markerDeveloperAlmostEmpty',
'markerDeveloperEmpty',
'markerDeveloperMissing',
'markerFuserMissing',
'markerFuserThermistorFailure',
'markerFuserTimingFailure',
'markerInkAlmostEmpty',
'markerInkEmpty',
'markerInkMissing',
'markerOpcMissing',
'markerPrintRibbonAlmostEmpty',
'markerPrintRibbonEmpty',
'markerPrintRibbonMissing',
'markerSupplyAlmostEmpty',
'markerSupplyMissing',
'markerTonerCartridgeMissing',
'markerTonerMissing',
'markerWasteInkReceptacleAlmostFull',
'markerWasteInkReceptacleFull',
'markerWasteInkReceptacleMissing',
'markerWasteMissing',
'markerWasteTonerReceptacleAlmostFull',
'markerWasteTonerReceptacleFull',
'markerWasteTonerReceptacleMissing',
'materialEmpty',
'materialLow',
'materialNeeded',
'mediaDrying',
'mediaPathCannotDuplexMediaSelected',
'mediaPathFailure',
'mediaPathInputEmpty',
'mediaPathInputFeedError',
'mediaPathInputJam',
'mediaPathInputRequest',
'mediaPathJam',
'mediaPathMediaTrayAlmostFull',
'mediaPathMediaTrayFull',
'mediaPathMediaTrayMissing',
'mediaPathOutputFeedError',
'mediaPathOutputFull',
'mediaPathOutputJam',
'mediaPathPickRollerFailure',
'mediaPathPickRollerLifeOver',
'mediaPathPickRollerLifeWarn',
'mediaPathPickRollerMissing',
'motorFailure',
'outputMailboxSelectFailure',
'outputMediaTrayFailure',
'outputMediaTrayFeedError',
'outputMediaTrayJam',
'perforaterAdded',
'perforaterAlmostEmpty',
'perforaterAlmostFull',
'perforaterAtLimit',
'perforaterClosed',
'perforaterConfigurationChange',
'perforaterCoverClosed',
'perforaterCoverOpen',
'perforaterEmpty',
'perforaterFull',
'perforaterInterlockClosed',
'perforaterInterlockOpen',
'perforaterJam',
'perforaterLifeAlmostOver',
'perforaterLifeOver',
'perforaterMemoryExhausted',
'perforaterMissing',
'perforaterMotorFailure',
'perforaterNearLimit',
'perforaterOffline',
'perforaterOpened',
'perforaterOverTemperature',
'perforaterPowerSaver',
'perforaterRecoverableFailure',
'perforaterRecoverableStorage',
'perforaterRemoved',
'perforaterResourceAdded',
'perforaterResourceRemoved',
'perforaterThermistorFailure',
'perforaterTimingFailure',
'perforaterTurnedOff',
'perforaterTurnedOn',
'perforaterUnderTemperature',
'perforaterUnrecoverableFailure',
'perforaterUnrecoverableStorageError',
'perforaterWarmingUp',
'platformCooling',
'platformFailure',
'platformHeating',
'platformTemperatureHigh',
'platformTemperatureLow',
'powerDown',
'powerUp',
'printerManualReset',
'printerNmsReset',
'printerReadyToPrint',
'puncherAdded',
'puncherAlmostEmpty',
'puncherAlmostFull',
'puncherAtLimit',
'puncherClosed',
'puncherConfigurationChange',
'puncherCoverClosed',
'puncherCoverOpen',
'puncherEmpty',
'puncherFull',
'puncherInterlockClosed',
'puncherInterlockOpen',
'puncherJam',
'puncherLifeAlmostOver',
'puncherLifeOver',
'puncherMemoryExhausted',
'puncherMissing',
'puncherMotorFailure',
'puncherNearLimit',
'puncherOffline',
'puncherOpened',
'puncherOverTemperature',
'puncherPowerSaver',
'puncherRecoverableFailure',
'puncherRecoverableStorage',
'puncherRemoved',
'puncherResourceAdded',
'puncherResourceRemoved',
'puncherThermistorFailure',
'puncherTimingFailure',
'puncherTurnedOff',
'puncherTurnedOn',
'puncherUnderTemperature',
'puncherUnrecoverableFailure',
'puncherUnrecoverableStorageError',
'puncherWarmingUp',
'resuming',
'scanMediaPathFailure',
'scanMediaPathInputEmpty',
'scanMediaPathInputFeedError',
'scanMediaPathInputJam',
'scanMediaPathInputRequest',
'scanMediaPathJam',
'scanMediaPathOutputFeedError',
'scanMediaPathOutputFull',
'scanMediaPathOutputJam',
'scanMediaPathPickRollerFailure',
'scanMediaPathPickRollerLifeOver',
'scanMediaPathPickRollerLifeWarn',
'scanMediaPathPickRollerMissing',
'scanMediaPathTrayAlmostFull',
'scanMediaPathTrayFull',
'scanMediaPathTrayMissing',
'scannerLightFailure',
'scannerLightLifeAlmostOver',
'scannerLightLifeOver',
'scannerLightMissing',
'scannerSensorFailure',
'scannerSensorLifeAlmostOver',
'scannerSensorLifeOver',
'scannerSensorMissing',
'separationCutterAdded',
'separationCutterAlmostEmpty',
'separationCutterAlmostFull',
'separationCutterAtLimit',
'separationCutterClosed',
'separationCutterConfigurationChange',
'separationCutterCoverClosed',
'separationCutterCoverOpen',
'separationCutterEmpty',
'separationCutterFull',
'separationCutterInterlockClosed',
'separationCutterInterlockOpen',
'separationCutterJam',
'separationCutterLifeAlmostOver',
'separationCutterLifeOver',
'separationCutterMemoryExhausted',
'separationCutterMissing',
'separationCutterMotorFailure',
'separationCutterNearLimit',
'separationCutterOffline',
'separationCutterOpened',
'separationCutterOverTemperature',
'separationCutterPowerSaver',
'separationCutterRecoverableFailure',
'separationCutterRecoverableStorage',
'separationCutterRemoved',
'separationCutterResourceAdded',
'separationCutterResourceRemoved',
'separationCutterThermistorFailure',
'separationCutterTimingFailure',
'separationCutterTurnedOff',
'separationCutterTurnedOn',
'separationCutterUnderTemperature',
'separationCutterUnrecoverableFailure',
'separationCutterU