DeviceHealthAttestationState.php — Booking for Appointments and Events Calendar – Amelia 1.2.20

ameliabooking / vendor / microsoft / microsoft-graph / src / Model / DeviceHealthAttestationState.php

ameliabooking / vendor / microsoft / microsoft-graph / src / Model Last commit date

DeviceHealthAttestationState.php

928 lines

1	<?php
2	/**
3	* Copyright (c) Microsoft Corporation. All Rights Reserved. Licensed under the MIT License. See License in the project root for license information.
4	*
5	* DeviceHealthAttestationState File
6	* PHP version 7
7	*
8	* @category Library
9	* @package Microsoft.Graph
10	* @copyright (c) Microsoft Corporation. All rights reserved.
11	* @license https://opensource.org/licenses/MIT MIT License
12	* @link https://graph.microsoft.com
13	*/
14	namespace Microsoft\Graph\Model;
15	/**
16	* DeviceHealthAttestationState class
17	*
18	* @category Model
19	* @package Microsoft.Graph
20	* @copyright (c) Microsoft Corporation. All rights reserved.
21	* @license https://opensource.org/licenses/MIT MIT License
22	* @link https://graph.microsoft.com
23	*/
24	class DeviceHealthAttestationState extends Entity
25	{
26	/**
27	* Gets the attestationIdentityKey
28	* TWhen an Attestation Identity Key (AIK) is present on a device, it indicates that the device has an endorsement key (EK) certificate.
29	*
30	* @return string\|null The attestationIdentityKey
31	*/
32	public function getAttestationIdentityKey()
33	{
34	if (array_key_exists("attestationIdentityKey", $this->_propDict)) {
35	return $this->_propDict["attestationIdentityKey"];
36	} else {
37	return null;
38	}
39	}
40
41	/**
42	* Sets the attestationIdentityKey
43	* TWhen an Attestation Identity Key (AIK) is present on a device, it indicates that the device has an endorsement key (EK) certificate.
44	*
45	* @param string $val The value of the attestationIdentityKey
46	*
47	* @return DeviceHealthAttestationState
48	*/
49	public function setAttestationIdentityKey($val)
50	{
51	$this->_propDict["attestationIdentityKey"] = $val;
52	return $this;
53	}
54	/**
55	* Gets the bitLockerStatus
56	* On or Off of BitLocker Drive Encryption
57	*
58	* @return string\|null The bitLockerStatus
59	*/
60	public function getBitLockerStatus()
61	{
62	if (array_key_exists("bitLockerStatus", $this->_propDict)) {
63	return $this->_propDict["bitLockerStatus"];
64	} else {
65	return null;
66	}
67	}
68
69	/**
70	* Sets the bitLockerStatus
71	* On or Off of BitLocker Drive Encryption
72	*
73	* @param string $val The value of the bitLockerStatus
74	*
75	* @return DeviceHealthAttestationState
76	*/
77	public function setBitLockerStatus($val)
78	{
79	$this->_propDict["bitLockerStatus"] = $val;
80	return $this;
81	}
82	/**
83	* Gets the bootAppSecurityVersion
84	* The security version number of the Boot Application
85	*
86	* @return string\|null The bootAppSecurityVersion
87	*/
88	public function getBootAppSecurityVersion()
89	{
90	if (array_key_exists("bootAppSecurityVersion", $this->_propDict)) {
91	return $this->_propDict["bootAppSecurityVersion"];
92	} else {
93	return null;
94	}
95	}
96
97	/**
98	* Sets the bootAppSecurityVersion
99	* The security version number of the Boot Application
100	*
101	* @param string $val The value of the bootAppSecurityVersion
102	*
103	* @return DeviceHealthAttestationState
104	*/
105	public function setBootAppSecurityVersion($val)
106	{
107	$this->_propDict["bootAppSecurityVersion"] = $val;
108	return $this;
109	}
110	/**
111	* Gets the bootDebugging
112	* When bootDebugging is enabled, the device is used in development and testing
113	*
114	* @return string\|null The bootDebugging
115	*/
116	public function getBootDebugging()
117	{
118	if (array_key_exists("bootDebugging", $this->_propDict)) {
119	return $this->_propDict["bootDebugging"];
120	} else {
121	return null;
122	}
123	}
124
125	/**
126	* Sets the bootDebugging
127	* When bootDebugging is enabled, the device is used in development and testing
128	*
129	* @param string $val The value of the bootDebugging
130	*
131	* @return DeviceHealthAttestationState
132	*/
133	public function setBootDebugging($val)
134	{
135	$this->_propDict["bootDebugging"] = $val;
136	return $this;
137	}
138	/**
139	* Gets the bootManagerSecurityVersion
140	* The security version number of the Boot Application
141	*
142	* @return string\|null The bootManagerSecurityVersion
143	*/
144	public function getBootManagerSecurityVersion()
145	{
146	if (array_key_exists("bootManagerSecurityVersion", $this->_propDict)) {
147	return $this->_propDict["bootManagerSecurityVersion"];
148	} else {
149	return null;
150	}
151	}
152
153	/**
154	* Sets the bootManagerSecurityVersion
155	* The security version number of the Boot Application
156	*
157	* @param string $val The value of the bootManagerSecurityVersion
158	*
159	* @return DeviceHealthAttestationState
160	*/
161	public function setBootManagerSecurityVersion($val)
162	{
163	$this->_propDict["bootManagerSecurityVersion"] = $val;
164	return $this;
165	}
166	/**
167	* Gets the bootManagerVersion
168	* The version of the Boot Manager
169	*
170	* @return string\|null The bootManagerVersion
171	*/
172	public function getBootManagerVersion()
173	{
174	if (array_key_exists("bootManagerVersion", $this->_propDict)) {
175	return $this->_propDict["bootManagerVersion"];
176	} else {
177	return null;
178	}
179	}
180
181	/**
182	* Sets the bootManagerVersion
183	* The version of the Boot Manager
184	*
185	* @param string $val The value of the bootManagerVersion
186	*
187	* @return DeviceHealthAttestationState
188	*/
189	public function setBootManagerVersion($val)
190	{
191	$this->_propDict["bootManagerVersion"] = $val;
192	return $this;
193	}
194	/**
195	* Gets the bootRevisionListInfo
196	* The Boot Revision List that was loaded during initial boot on the attested device
197	*
198	* @return string\|null The bootRevisionListInfo
199	*/
200	public function getBootRevisionListInfo()
201	{
202	if (array_key_exists("bootRevisionListInfo", $this->_propDict)) {
203	return $this->_propDict["bootRevisionListInfo"];
204	} else {
205	return null;
206	}
207	}
208
209	/**
210	* Sets the bootRevisionListInfo
211	* The Boot Revision List that was loaded during initial boot on the attested device
212	*
213	* @param string $val The value of the bootRevisionListInfo
214	*
215	* @return DeviceHealthAttestationState
216	*/
217	public function setBootRevisionListInfo($val)
218	{
219	$this->_propDict["bootRevisionListInfo"] = $val;
220	return $this;
221	}
222	/**
223	* Gets the codeIntegrity
224	* When code integrity is enabled, code execution is restricted to integrity verified code
225	*
226	* @return string\|null The codeIntegrity
227	*/
228	public function getCodeIntegrity()
229	{
230	if (array_key_exists("codeIntegrity", $this->_propDict)) {
231	return $this->_propDict["codeIntegrity"];
232	} else {
233	return null;
234	}
235	}
236
237	/**
238	* Sets the codeIntegrity
239	* When code integrity is enabled, code execution is restricted to integrity verified code
240	*
241	* @param string $val The value of the codeIntegrity
242	*
243	* @return DeviceHealthAttestationState
244	*/
245	public function setCodeIntegrity($val)
246	{
247	$this->_propDict["codeIntegrity"] = $val;
248	return $this;
249	}
250	/**
251	* Gets the codeIntegrityCheckVersion
252	* The version of the Boot Manager
253	*
254	* @return string\|null The codeIntegrityCheckVersion
255	*/
256	public function getCodeIntegrityCheckVersion()
257	{
258	if (array_key_exists("codeIntegrityCheckVersion", $this->_propDict)) {
259	return $this->_propDict["codeIntegrityCheckVersion"];
260	} else {
261	return null;
262	}
263	}
264
265	/**
266	* Sets the codeIntegrityCheckVersion
267	* The version of the Boot Manager
268	*
269	* @param string $val The value of the codeIntegrityCheckVersion
270	*
271	* @return DeviceHealthAttestationState
272	*/
273	public function setCodeIntegrityCheckVersion($val)
274	{
275	$this->_propDict["codeIntegrityCheckVersion"] = $val;
276	return $this;
277	}
278	/**
279	* Gets the codeIntegrityPolicy
280	* The Code Integrity policy that is controlling the security of the boot environment
281	*
282	* @return string\|null The codeIntegrityPolicy
283	*/
284	public function getCodeIntegrityPolicy()
285	{
286	if (array_key_exists("codeIntegrityPolicy", $this->_propDict)) {
287	return $this->_propDict["codeIntegrityPolicy"];
288	} else {
289	return null;
290	}
291	}
292
293	/**
294	* Sets the codeIntegrityPolicy
295	* The Code Integrity policy that is controlling the security of the boot environment
296	*
297	* @param string $val The value of the codeIntegrityPolicy
298	*
299	* @return DeviceHealthAttestationState
300	*/
301	public function setCodeIntegrityPolicy($val)
302	{
303	$this->_propDict["codeIntegrityPolicy"] = $val;
304	return $this;
305	}
306	/**
307	* Gets the contentNamespaceUrl
308	* The DHA report version. (Namespace version)
309	*
310	* @return string\|null The contentNamespaceUrl
311	*/
312	public function getContentNamespaceUrl()
313	{
314	if (array_key_exists("contentNamespaceUrl", $this->_propDict)) {
315	return $this->_propDict["contentNamespaceUrl"];
316	} else {
317	return null;
318	}
319	}
320
321	/**
322	* Sets the contentNamespaceUrl
323	* The DHA report version. (Namespace version)
324	*
325	* @param string $val The value of the contentNamespaceUrl
326	*
327	* @return DeviceHealthAttestationState
328	*/
329	public function setContentNamespaceUrl($val)
330	{
331	$this->_propDict["contentNamespaceUrl"] = $val;
332	return $this;
333	}
334	/**
335	* Gets the contentVersion
336	* The HealthAttestation state schema version
337	*
338	* @return string\|null The contentVersion
339	*/
340	public function getContentVersion()
341	{
342	if (array_key_exists("contentVersion", $this->_propDict)) {
343	return $this->_propDict["contentVersion"];
344	} else {
345	return null;
346	}
347	}
348
349	/**
350	* Sets the contentVersion
351	* The HealthAttestation state schema version
352	*
353	* @param string $val The value of the contentVersion
354	*
355	* @return DeviceHealthAttestationState
356	*/
357	public function setContentVersion($val)
358	{
359	$this->_propDict["contentVersion"] = $val;
360	return $this;
361	}
362	/**
363	* Gets the dataExcutionPolicy
364	* DEP Policy defines a set of hardware and software technologies that perform additional checks on memory
365	*
366	* @return string\|null The dataExcutionPolicy
367	*/
368	public function getDataExcutionPolicy()
369	{
370	if (array_key_exists("dataExcutionPolicy", $this->_propDict)) {
371	return $this->_propDict["dataExcutionPolicy"];
372	} else {
373	return null;
374	}
375	}
376
377	/**
378	* Sets the dataExcutionPolicy
379	* DEP Policy defines a set of hardware and software technologies that perform additional checks on memory
380	*
381	* @param string $val The value of the dataExcutionPolicy
382	*
383	* @return DeviceHealthAttestationState
384	*/
385	public function setDataExcutionPolicy($val)
386	{
387	$this->_propDict["dataExcutionPolicy"] = $val;
388	return $this;
389	}
390	/**
391	* Gets the deviceHealthAttestationStatus
392	* The DHA report version. (Namespace version)
393	*
394	* @return string\|null The deviceHealthAttestationStatus
395	*/
396	public function getDeviceHealthAttestationStatus()
397	{
398	if (array_key_exists("deviceHealthAttestationStatus", $this->_propDict)) {
399	return $this->_propDict["deviceHealthAttestationStatus"];
400	} else {
401	return null;
402	}
403	}
404
405	/**
406	* Sets the deviceHealthAttestationStatus
407	* The DHA report version. (Namespace version)
408	*
409	* @param string $val The value of the deviceHealthAttestationStatus
410	*
411	* @return DeviceHealthAttestationState
412	*/
413	public function setDeviceHealthAttestationStatus($val)
414	{
415	$this->_propDict["deviceHealthAttestationStatus"] = $val;
416	return $this;
417	}
418	/**
419	* Gets the earlyLaunchAntiMalwareDriverProtection
420	* ELAM provides protection for the computers in your network when they start up
421	*
422	* @return string\|null The earlyLaunchAntiMalwareDriverProtection
423	*/
424	public function getEarlyLaunchAntiMalwareDriverProtection()
425	{
426	if (array_key_exists("earlyLaunchAntiMalwareDriverProtection", $this->_propDict)) {
427	return $this->_propDict["earlyLaunchAntiMalwareDriverProtection"];
428	} else {
429	return null;
430	}
431	}
432
433	/**
434	* Sets the earlyLaunchAntiMalwareDriverProtection
435	* ELAM provides protection for the computers in your network when they start up
436	*
437	* @param string $val The value of the earlyLaunchAntiMalwareDriverProtection
438	*
439	* @return DeviceHealthAttestationState
440	*/
441	public function setEarlyLaunchAntiMalwareDriverProtection($val)
442	{
443	$this->_propDict["earlyLaunchAntiMalwareDriverProtection"] = $val;
444	return $this;
445	}
446	/**
447	* Gets the healthAttestationSupportedStatus
448	* This attribute indicates if DHA is supported for the device
449	*
450	* @return string\|null The healthAttestationSupportedStatus
451	*/
452	public function getHealthAttestationSupportedStatus()
453	{
454	if (array_key_exists("healthAttestationSupportedStatus", $this->_propDict)) {
455	return $this->_propDict["healthAttestationSupportedStatus"];
456	} else {
457	return null;
458	}
459	}
460
461	/**
462	* Sets the healthAttestationSupportedStatus
463	* This attribute indicates if DHA is supported for the device
464	*
465	* @param string $val The value of the healthAttestationSupportedStatus
466	*
467	* @return DeviceHealthAttestationState
468	*/
469	public function setHealthAttestationSupportedStatus($val)
470	{
471	$this->_propDict["healthAttestationSupportedStatus"] = $val;
472	return $this;
473	}
474	/**
475	* Gets the healthStatusMismatchInfo
476	* This attribute appears if DHA-Service detects an integrity issue
477	*
478	* @return string\|null The healthStatusMismatchInfo
479	*/
480	public function getHealthStatusMismatchInfo()
481	{
482	if (array_key_exists("healthStatusMismatchInfo", $this->_propDict)) {
483	return $this->_propDict["healthStatusMismatchInfo"];
484	} else {
485	return null;
486	}
487	}
488
489	/**
490	* Sets the healthStatusMismatchInfo
491	* This attribute appears if DHA-Service detects an integrity issue
492	*
493	* @param string $val The value of the healthStatusMismatchInfo
494	*
495	* @return DeviceHealthAttestationState
496	*/
497	public function setHealthStatusMismatchInfo($val)
498	{
499	$this->_propDict["healthStatusMismatchInfo"] = $val;
500	return $this;
501	}
502
503	/**
504	* Gets the issuedDateTime
505	* The DateTime when device was evaluated or issued to MDM
506	*
507	* @return \DateTime\|null The issuedDateTime
508	*/
509	public function getIssuedDateTime()
510	{
511	if (array_key_exists("issuedDateTime", $this->_propDict)) {
512	if (is_a($this->_propDict["issuedDateTime"], "\DateTime") \|\| is_null($this->_propDict["issuedDateTime"])) {
513	return $this->_propDict["issuedDateTime"];
514	} else {
515	$this->_propDict["issuedDateTime"] = new \DateTime($this->_propDict["issuedDateTime"]);
516	return $this->_propDict["issuedDateTime"];
517	}
518	}
519	return null;
520	}
521
522	/**
523	* Sets the issuedDateTime
524	* The DateTime when device was evaluated or issued to MDM
525	*
526	* @param \DateTime $val The value to assign to the issuedDateTime
527	*
528	* @return DeviceHealthAttestationState The DeviceHealthAttestationState
529	*/
530	public function setIssuedDateTime($val)
531	{
532	$this->_propDict["issuedDateTime"] = $val;
533	return $this;
534	}
535	/**
536	* Gets the lastUpdateDateTime
537	* The Timestamp of the last update.
538	*
539	* @return string\|null The lastUpdateDateTime
540	*/
541	public function getLastUpdateDateTime()
542	{
543	if (array_key_exists("lastUpdateDateTime", $this->_propDict)) {
544	return $this->_propDict["lastUpdateDateTime"];
545	} else {
546	return null;
547	}
548	}
549
550	/**
551	* Sets the lastUpdateDateTime
552	* The Timestamp of the last update.
553	*
554	* @param string $val The value of the lastUpdateDateTime
555	*
556	* @return DeviceHealthAttestationState
557	*/
558	public function setLastUpdateDateTime($val)
559	{
560	$this->_propDict["lastUpdateDateTime"] = $val;
561	return $this;
562	}
563	/**
564	* Gets the operatingSystemKernelDebugging
565	* When operatingSystemKernelDebugging is enabled, the device is used in development and testing
566	*
567	* @return string\|null The operatingSystemKernelDebugging
568	*/
569	public function getOperatingSystemKernelDebugging()
570	{
571	if (array_key_exists("operatingSystemKernelDebugging", $this->_propDict)) {
572	return $this->_propDict["operatingSystemKernelDebugging"];
573	} else {
574	return null;
575	}
576	}
577
578	/**
579	* Sets the operatingSystemKernelDebugging
580	* When operatingSystemKernelDebugging is enabled, the device is used in development and testing
581	*
582	* @param string $val The value of the operatingSystemKernelDebugging
583	*
584	* @return DeviceHealthAttestationState
585	*/
586	public function setOperatingSystemKernelDebugging($val)
587	{
588	$this->_propDict["operatingSystemKernelDebugging"] = $val;
589	return $this;
590	}
591	/**
592	* Gets the operatingSystemRevListInfo
593	* The Operating System Revision List that was loaded during initial boot on the attested device
594	*
595	* @return string\|null The operatingSystemRevListInfo
596	*/
597	public function getOperatingSystemRevListInfo()
598	{
599	if (array_key_exists("operatingSystemRevListInfo", $this->_propDict)) {
600	return $this->_propDict["operatingSystemRevListInfo"];
601	} else {
602	return null;
603	}
604	}
605
606	/**
607	* Sets the operatingSystemRevListInfo
608	* The Operating System Revision List that was loaded during initial boot on the attested device
609	*
610	* @param string $val The value of the operatingSystemRevListInfo
611	*
612	* @return DeviceHealthAttestationState
613	*/
614	public function setOperatingSystemRevListInfo($val)
615	{
616	$this->_propDict["operatingSystemRevListInfo"] = $val;
617	return $this;
618	}
619	/**
620	* Gets the pcr0
621	* The measurement that is captured in PCR[0]
622	*
623	* @return string\|null The pcr0
624	*/
625	public function getPcr0()
626	{
627	if (array_key_exists("pcr0", $this->_propDict)) {
628	return $this->_propDict["pcr0"];
629	} else {
630	return null;
631	}
632	}
633
634	/**
635	* Sets the pcr0
636	* The measurement that is captured in PCR[0]
637	*
638	* @param string $val The value of the pcr0
639	*
640	* @return DeviceHealthAttestationState
641	*/
642	public function setPcr0($val)
643	{
644	$this->_propDict["pcr0"] = $val;
645	return $this;
646	}
647	/**
648	* Gets the pcrHashAlgorithm
649	* Informational attribute that identifies the HASH algorithm that was used by TPM
650	*
651	* @return string\|null The pcrHashAlgorithm
652	*/
653	public function getPcrHashAlgorithm()
654	{
655	if (array_key_exists("pcrHashAlgorithm", $this->_propDict)) {
656	return $this->_propDict["pcrHashAlgorithm"];
657	} else {
658	return null;
659	}
660	}
661
662	/**
663	* Sets the pcrHashAlgorithm
664	* Informational attribute that identifies the HASH algorithm that was used by TPM
665	*
666	* @param string $val The value of the pcrHashAlgorithm
667	*
668	* @return DeviceHealthAttestationState
669	*/
670	public function setPcrHashAlgorithm($val)
671	{
672	$this->_propDict["pcrHashAlgorithm"] = $val;
673	return $this;
674	}
675	/**
676	* Gets the resetCount
677	* The number of times a PC device has hibernated or resumed
678	*
679	* @return int\|null The resetCount
680	*/
681	public function getResetCount()
682	{
683	if (array_key_exists("resetCount", $this->_propDict)) {
684	return $this->_propDict["resetCount"];
685	} else {
686	return null;
687	}
688	}
689
690	/**
691	* Sets the resetCount
692	* The number of times a PC device has hibernated or resumed
693	*
694	* @param int $val The value of the resetCount
695	*
696	* @return DeviceHealthAttestationState
697	*/
698	public function setResetCount($val)
699	{
700	$this->_propDict["resetCount"] = $val;
701	return $this;
702	}
703	/**
704	* Gets the restartCount
705	* The number of times a PC device has rebooted
706	*
707	* @return int\|null The restartCount
708	*/
709	public function getRestartCount()
710	{
711	if (array_key_exists("restartCount", $this->_propDict)) {
712	return $this->_propDict["restartCount"];
713	} else {
714	return null;
715	}
716	}
717
718	/**
719	* Sets the restartCount
720	* The number of times a PC device has rebooted
721	*
722	* @param int $val The value of the restartCount
723	*
724	* @return DeviceHealthAttestationState
725	*/
726	public function setRestartCount($val)
727	{
728	$this->_propDict["restartCount"] = $val;
729	return $this;
730	}
731	/**
732	* Gets the safeMode
733	* Safe mode is a troubleshooting option for Windows that starts your computer in a limited state
734	*
735	* @return string\|null The safeMode
736	*/
737	public function getSafeMode()
738	{
739	if (array_key_exists("safeMode", $this->_propDict)) {
740	return $this->_propDict["safeMode"];
741	} else {
742	return null;
743	}
744	}
745
746	/**
747	* Sets the safeMode
748	* Safe mode is a troubleshooting option for Windows that starts your computer in a limited state
749	*
750	* @param string $val The value of the safeMode
751	*
752	* @return DeviceHealthAttestationState
753	*/
754	public function setSafeMode($val)
755	{
756	$this->_propDict["safeMode"] = $val;
757	return $this;
758	}
759	/**
760	* Gets the secureBoot
761	* When Secure Boot is enabled, the core components must have the correct cryptographic signatures
762	*
763	* @return string\|null The secureBoot
764	*/
765	public function getSecureBoot()
766	{
767	if (array_key_exists("secureBoot", $this->_propDict)) {
768	return $this->_propDict["secureBoot"];
769	} else {
770	return null;
771	}
772	}
773
774	/**
775	* Sets the secureBoot
776	* When Secure Boot is enabled, the core components must have the correct cryptographic signatures
777	*
778	* @param string $val The value of the secureBoot
779	*
780	* @return DeviceHealthAttestationState
781	*/
782	public function setSecureBoot($val)
783	{
784	$this->_propDict["secureBoot"] = $val;
785	return $this;
786	}
787	/**
788	* Gets the secureBootConfigurationPolicyFingerPrint
789	* Fingerprint of the Custom Secure Boot Configuration Policy
790	*
791	* @return string\|null The secureBootConfigurationPolicyFingerPrint
792	*/
793	public function getSecureBootConfigurationPolicyFingerPrint()
794	{
795	if (array_key_exists("secureBootConfigurationPolicyFingerPrint", $this->_propDict)) {
796	return $this->_propDict["secureBootConfigurationPolicyFingerPrint"];
797	} else {
798	return null;
799	}
800	}
801
802	/**
803	* Sets the secureBootConfigurationPolicyFingerPrint
804	* Fingerprint of the Custom Secure Boot Configuration Policy
805	*
806	* @param string $val The value of the secureBootConfigurationPolicyFingerPrint
807	*
808	* @return DeviceHealthAttestationState
809	*/
810	public function setSecureBootConfigurationPolicyFingerPrint($val)
811	{
812	$this->_propDict["secureBootConfigurationPolicyFingerPrint"] = $val;
813	return $this;
814	}
815	/**
816	* Gets the testSigning
817	* When test signing is allowed, the device does not enforce signature validation during boot
818	*
819	* @return string\|null The testSigning
820	*/
821	public function getTestSigning()
822	{
823	if (array_key_exists("testSigning", $this->_propDict)) {
824	return $this->_propDict["testSigning"];
825	} else {
826	return null;
827	}
828	}
829
830	/**
831	* Sets the testSigning
832	* When test signing is allowed, the device does not enforce signature validation during boot
833	*
834	* @param string $val The value of the testSigning
835	*
836	* @return DeviceHealthAttestationState
837	*/
838	public function setTestSigning($val)
839	{
840	$this->_propDict["testSigning"] = $val;
841	return $this;
842	}
843	/**
844	* Gets the tpmVersion
845	* The security version number of the Boot Application
846	*
847	* @return string\|null The tpmVersion
848	*/
849	public function getTpmVersion()
850	{
851	if (array_key_exists("tpmVersion", $this->_propDict)) {
852	return $this->_propDict["tpmVersion"];
853	} else {
854	return null;
855	}
856	}
857
858	/**
859	* Sets the tpmVersion
860	* The security version number of the Boot Application
861	*
862	* @param string $val The value of the tpmVersion
863	*
864	* @return DeviceHealthAttestationState
865	*/
866	public function setTpmVersion($val)
867	{
868	$this->_propDict["tpmVersion"] = $val;
869	return $this;
870	}
871	/**
872	* Gets the virtualSecureMode
873	* VSM is a container that protects high value assets from a compromised kernel
874	*
875	* @return string\|null The virtualSecureMode
876	*/
877	public function getVirtualSecureMode()
878	{
879	if (array_key_exists("virtualSecureMode", $this->_propDict)) {
880	return $this->_propDict["virtualSecureMode"];
881	} else {
882	return null;
883	}
884	}
885
886	/**
887	* Sets the virtualSecureMode
888	* VSM is a container that protects high value assets from a compromised kernel
889	*
890	* @param string $val The value of the virtualSecureMode
891	*
892	* @return DeviceHealthAttestationState
893	*/
894	public function setVirtualSecureMode($val)
895	{
896	$this->_propDict["virtualSecureMode"] = $val;
897	return $this;
898	}
899	/**
900	* Gets the windowsPE
901	* Operating system running with limited services that is used to prepare a computer for Windows
902	*
903	* @return string\|null The windowsPE
904	*/
905	public function getWindowsPE()
906	{
907	if (array_key_exists("windowsPE", $this->_propDict)) {
908	return $this->_propDict["windowsPE"];
909	} else {
910	return null;
911	}
912	}
913
914	/**
915	* Sets the windowsPE
916	* Operating system running with limited services that is used to prepare a computer for Windows
917	*
918	* @param string $val The value of the windowsPE
919	*
920	* @return DeviceHealthAttestationState
921	*/
922	public function setWindowsPE($val)
923	{
924	$this->_propDict["windowsPE"] = $val;
925	return $this;
926	}
927	}
928