@censys/platform-sdk 0.9.0 → 0.10.0

package/src/models/components/cvsscomponents.ts

@@ -5,7 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -20,7 +21,7 @@ export const AttackComplexity = {
 /**
  * Indicates conditions beyond the attacker’s control that must exist in order to exploit the vulnerability. The Attack Complexity metric is scored as either Low or High. There are two possible values: Low (L) – There are no specific pre-conditions required for exploitation, High (H) – The attacker must complete some number of preparatory steps in order to get access.
  */
-export type AttackComplexity = ClosedEnum<typeof AttackComplexity>;
+export type AttackComplexity = OpenEnum<typeof AttackComplexity>;
 
 /**
  * Indicates the level of access required for an attacker to exploit the vulnerability. The Attack Vector metric is scored in one of four levels: Network (N) – Vulnerabilities with this rating are remotely exploitable, from one or more hops away, up to, and including, remote exploitation over the Internet, Adjacent (A) – A vulnerability with this rating requires network adjacency for exploitation. The attack must be launched from the same physical or logical network, Local (L) – Vulnerabilities with this rating are not exploitable over a network, Physical (P) – An attacker must physically interact with the target system.
@@ -35,7 +36,7 @@ export const AttackVector = {
 /**
  * Indicates the level of access required for an attacker to exploit the vulnerability. The Attack Vector metric is scored in one of four levels: Network (N) – Vulnerabilities with this rating are remotely exploitable, from one or more hops away, up to, and including, remote exploitation over the Internet, Adjacent (A) – A vulnerability with this rating requires network adjacency for exploitation. The attack must be launched from the same physical or logical network, Local (L) – Vulnerabilities with this rating are not exploitable over a network, Physical (P) – An attacker must physically interact with the target system.
  */
-export type AttackVector = ClosedEnum<typeof AttackVector>;
+export type AttackVector = OpenEnum<typeof AttackVector>;
 
 /**
  * If an attack renders information unavailable, such as when a system crashes or through a DDoS attack, availability is negatively impacted. Availability has three possible values: None (N) – There is no loss of availability, Low (L) – Availability might be intermittently limited, or performance might be negatively impacted, as a result of a successful attack, High (H) – There is a complete loss of availability of the impacted system or information.
@@ -49,7 +50,7 @@ export const Availability = {
 /**
  * If an attack renders information unavailable, such as when a system crashes or through a DDoS attack, availability is negatively impacted. Availability has three possible values: None (N) – There is no loss of availability, Low (L) – Availability might be intermittently limited, or performance might be negatively impacted, as a result of a successful attack, High (H) – There is a complete loss of availability of the impacted system or information.
  */
-export type Availability = ClosedEnum<typeof Availability>;
+export type Availability = OpenEnum<typeof Availability>;
 
 /**
  * Refers to the disclosure of sensitive information to authorized and unauthorized users, with the goal being that only authorized users are able to access the target data. Confidentiality has three potential values: High (H) – The attacker has full access to all resources in the impacted system, including highly sensitive information such as encryption keys, Low (L) – The attacker has partial access to information, with no control over what, specifically, they are able to access, None (N) – No data is accessible to unauthorized users as a result of the exploit.
@@ -63,7 +64,7 @@ export const Confidentiality = {
 /**
  * Refers to the disclosure of sensitive information to authorized and unauthorized users, with the goal being that only authorized users are able to access the target data. Confidentiality has three potential values: High (H) – The attacker has full access to all resources in the impacted system, including highly sensitive information such as encryption keys, Low (L) – The attacker has partial access to information, with no control over what, specifically, they are able to access, None (N) – No data is accessible to unauthorized users as a result of the exploit.
  */
-export type Confidentiality = ClosedEnum<typeof Confidentiality>;
+export type Confidentiality = OpenEnum<typeof Confidentiality>;
 
 /**
  * Refers to whether the protected information has been tampered with or changed in any way. If there is no way for an attacker to alter the accuracy or completeness of the information, integrity has been maintained. Integrity has three values: None (N) – There is no loss of the integrity of any information, Low (L) – A limited amount of information might be tampered with or modified, but there is no serious impact on the protected system, High (H) – The attacker can modify any/all information on the target system, resulting in a complete loss of integrity.
@@ -77,7 +78,7 @@ export const Integrity = {
 /**
  * Refers to whether the protected information has been tampered with or changed in any way. If there is no way for an attacker to alter the accuracy or completeness of the information, integrity has been maintained. Integrity has three values: None (N) – There is no loss of the integrity of any information, Low (L) – A limited amount of information might be tampered with or modified, but there is no serious impact on the protected system, High (H) – The attacker can modify any/all information on the target system, resulting in a complete loss of integrity.
  */
-export type Integrity = ClosedEnum<typeof Integrity>;
+export type Integrity = OpenEnum<typeof Integrity>;
 
 /**
  * Describes the level of privileges or access an attacker must have before successful exploitation. There are three possible values: None (N) – There is no privilege or special access required to conduct the attack, Low (L) – The attacker requires basic, “user” level privileges to leverage the exploit, High (H) – Administrative or similar access privileges are required for successful attack.
@@ -91,7 +92,7 @@ export const PrivilegesRequired = {
 /**
  * Describes the level of privileges or access an attacker must have before successful exploitation. There are three possible values: None (N) – There is no privilege or special access required to conduct the attack, Low (L) – The attacker requires basic, “user” level privileges to leverage the exploit, High (H) – Administrative or similar access privileges are required for successful attack.
  */
-export type PrivilegesRequired = ClosedEnum<typeof PrivilegesRequired>;
+export type PrivilegesRequired = OpenEnum<typeof PrivilegesRequired>;
 
 /**
  * Determines whether a vulnerability in one system or component can impact another system or component. If a vulnerability in a vulnerable component can affect a component which is in a different security scope than the vulnerable component, a scope change occurs. Scope has two possible ratings: Changed (C) – An exploited vulnerability can have a carry over impact on another system, Unchanged (U) – The exploited vulnerability is limited in damage to only the local security authority.
@@ -104,7 +105,7 @@ export const Scope = {
 /**
  * Determines whether a vulnerability in one system or component can impact another system or component. If a vulnerability in a vulnerable component can affect a component which is in a different security scope than the vulnerable component, a scope change occurs. Scope has two possible ratings: Changed (C) – An exploited vulnerability can have a carry over impact on another system, Unchanged (U) – The exploited vulnerability is limited in damage to only the local security authority.
  */
-export type Scope = ClosedEnum<typeof Scope>;
+export type Scope = OpenEnum<typeof Scope>;
 
 /**
  * Describes whether a user, other than the attacker, is required to do anything or participate in exploitation of the vulnerability. User interaction has two possible values: None (N) – No user interaction is required, Required (R) – A user must complete some steps for the exploit to succeed. For example, a user might be required to install some software.
@@ -117,7 +118,7 @@ export const UserInteraction = {
 /**
  * Describes whether a user, other than the attacker, is required to do anything or participate in exploitation of the vulnerability. User interaction has two possible values: None (N) – No user interaction is required, Required (R) – A user must complete some steps for the exploit to succeed. For example, a user might be required to install some software.
  */
-export type UserInteraction = ClosedEnum<typeof UserInteraction>;
+export type UserInteraction = OpenEnum<typeof UserInteraction>;
 
 export type CVSSComponents = {
   /**
@@ -155,41 +156,57 @@ export type CVSSComponents = {
 };
 
 /** @internal */
-export const AttackComplexity$inboundSchema: z.ZodNativeEnum<
-  typeof AttackComplexity
-> = z.nativeEnum(AttackComplexity);
+export const AttackComplexity$inboundSchema: z.ZodType<
+  AttackComplexity,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(AttackComplexity);
 
 /** @internal */
-export const AttackVector$inboundSchema: z.ZodNativeEnum<typeof AttackVector> =
-  z.nativeEnum(AttackVector);
+export const AttackVector$inboundSchema: z.ZodType<
+  AttackVector,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(AttackVector);
 
 /** @internal */
-export const Availability$inboundSchema: z.ZodNativeEnum<typeof Availability> =
-  z.nativeEnum(Availability);
+export const Availability$inboundSchema: z.ZodType<
+  Availability,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(Availability);
 
 /** @internal */
-export const Confidentiality$inboundSchema: z.ZodNativeEnum<
-  typeof Confidentiality
-> = z.nativeEnum(Confidentiality);
+export const Confidentiality$inboundSchema: z.ZodType<
+  Confidentiality,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(Confidentiality);
 
 /** @internal */
-export const Integrity$inboundSchema: z.ZodNativeEnum<typeof Integrity> = z
-  .nativeEnum(Integrity);
+export const Integrity$inboundSchema: z.ZodType<
+  Integrity,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(Integrity);
 
 /** @internal */
-export const PrivilegesRequired$inboundSchema: z.ZodNativeEnum<
-  typeof PrivilegesRequired
-> = z.nativeEnum(PrivilegesRequired);
+export const PrivilegesRequired$inboundSchema: z.ZodType<
+  PrivilegesRequired,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(PrivilegesRequired);
 
 /** @internal */
-export const Scope$inboundSchema: z.ZodNativeEnum<typeof Scope> = z.nativeEnum(
-  Scope,
-);
+export const Scope$inboundSchema: z.ZodType<Scope, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Scope);
 
 /** @internal */
-export const UserInteraction$inboundSchema: z.ZodNativeEnum<
-  typeof UserInteraction
-> = z.nativeEnum(UserInteraction);
+export const UserInteraction$inboundSchema: z.ZodType<
+  UserInteraction,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(UserInteraction);
 
 /** @internal */
 export const CVSSComponents$inboundSchema: z.ZodType<

package/src/models/components/cvssv4components.ts

@@ -5,7 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -20,7 +21,7 @@ export const CVSSv4ComponentsAttackComplexity = {
 /**
  * Indicates conditions beyond the attacker’s control that must exist in order to exploit the vulnerability. The Attack Complexity metric is scored as either Low or High. There are two possible values: Low (L) – There are no specific pre-conditions required for exploitation, High (H) – The attacker must complete some number of preparatory steps in order to get access.
  */
-export type CVSSv4ComponentsAttackComplexity = ClosedEnum<
+export type CVSSv4ComponentsAttackComplexity = OpenEnum<
   typeof CVSSv4ComponentsAttackComplexity
 >;
 
@@ -29,7 +30,7 @@ export const AttackRequirements = {
   None: "none",
   Present: "present",
 } as const;
-export type AttackRequirements = ClosedEnum<typeof AttackRequirements>;
+export type AttackRequirements = OpenEnum<typeof AttackRequirements>;
 
 /**
  * Indicates the level of access required for an attacker to exploit the vulnerability. The Attack Vector metric is scored in one of four levels: Network (N) – Vulnerabilities with this rating are remotely exploitable, from one or more hops away, up to, and including, remote exploitation over the Internet, Adjacent (A) – A vulnerability with this rating requires network adjacency for exploitation. The attack must be launched from the same physical or logical network, Local (L) – Vulnerabilities with this rating are not exploitable over a network, Physical (P) – An attacker must physically interact with the target system.
@@ -44,7 +45,7 @@ export const CVSSv4ComponentsAttackVector = {
 /**
  * Indicates the level of access required for an attacker to exploit the vulnerability. The Attack Vector metric is scored in one of four levels: Network (N) – Vulnerabilities with this rating are remotely exploitable, from one or more hops away, up to, and including, remote exploitation over the Internet, Adjacent (A) – A vulnerability with this rating requires network adjacency for exploitation. The attack must be launched from the same physical or logical network, Local (L) – Vulnerabilities with this rating are not exploitable over a network, Physical (P) – An attacker must physically interact with the target system.
  */
-export type CVSSv4ComponentsAttackVector = ClosedEnum<
+export type CVSSv4ComponentsAttackVector = OpenEnum<
   typeof CVSSv4ComponentsAttackVector
 >;
 
@@ -53,7 +54,7 @@ export const Automatable = {
   No: "no",
   Yes: "yes",
 } as const;
-export type Automatable = ClosedEnum<typeof Automatable>;
+export type Automatable = OpenEnum<typeof Automatable>;
 
 /**
  * If an attack renders information unavailable, such as when a system crashes or through a DDoS attack, availability is negatively impacted. Availability has three possible values: None (N) – There is no loss of availability, Low (L) – Availability might be intermittently limited, or performance might be negatively impacted, as a result of a successful attack, High (H) – There is a complete loss of availability of the impacted system or information.
@@ -67,7 +68,7 @@ export const CVSSv4ComponentsAvailability = {
 /**
  * If an attack renders information unavailable, such as when a system crashes or through a DDoS attack, availability is negatively impacted. Availability has three possible values: None (N) – There is no loss of availability, Low (L) – Availability might be intermittently limited, or performance might be negatively impacted, as a result of a successful attack, High (H) – There is a complete loss of availability of the impacted system or information.
  */
-export type CVSSv4ComponentsAvailability = ClosedEnum<
+export type CVSSv4ComponentsAvailability = OpenEnum<
   typeof CVSSv4ComponentsAvailability
 >;
 
@@ -83,7 +84,7 @@ export const CVSSv4ComponentsConfidentiality = {
 /**
  * Refers to the disclosure of sensitive information to authorized and unauthorized users, with the goal being that only authorized users are able to access the target data. Confidentiality has three potential values: High (H) – The attacker has full access to all resources in the impacted system, including highly sensitive information such as encryption keys, Low (L) – The attacker has partial access to information, with no control over what, specifically, they are able to access, None (N) – No data is accessible to unauthorized users as a result of the exploit.
  */
-export type CVSSv4ComponentsConfidentiality = ClosedEnum<
+export type CVSSv4ComponentsConfidentiality = OpenEnum<
   typeof CVSSv4ComponentsConfidentiality
 >;
 
@@ -99,7 +100,7 @@ export const CVSSv4ComponentsIntegrity = {
 /**
  * Refers to whether the protected information has been tampered with or changed in any way. If there is no way for an attacker to alter the accuracy or completeness of the information, integrity has been maintained. Integrity has three values: None (N) – There is no loss of the integrity of any information, Low (L) – A limited amount of information might be tampered with or modified, but there is no serious impact on the protected system, High (H) – The attacker can modify any/all information on the target system, resulting in a complete loss of integrity.
  */
-export type CVSSv4ComponentsIntegrity = ClosedEnum<
+export type CVSSv4ComponentsIntegrity = OpenEnum<
   typeof CVSSv4ComponentsIntegrity
 >;
 
@@ -115,7 +116,7 @@ export const CVSSv4ComponentsPrivilegesRequired = {
 /**
  * Describes the level of privileges or access an attacker must have before successful exploitation. There are three possible values: None (N) – There is no privilege or special access required to conduct the attack, Low (L) – The attacker requires basic, “user” level privileges to leverage the exploit, High (H) – Administrative or similar access privileges are required for successful attack.
  */
-export type CVSSv4ComponentsPrivilegesRequired = ClosedEnum<
+export type CVSSv4ComponentsPrivilegesRequired = OpenEnum<
   typeof CVSSv4ComponentsPrivilegesRequired
 >;
 
@@ -126,7 +127,7 @@ export const ProviderUrgency = {
   Amber: "amber",
   Red: "red",
 } as const;
-export type ProviderUrgency = ClosedEnum<typeof ProviderUrgency>;
+export type ProviderUrgency = OpenEnum<typeof ProviderUrgency>;
 
 export const Recovery = {
   Unknown: "",
@@ -134,14 +135,14 @@ export const Recovery = {
   User: "user",
   Irrecoverable: "irrecoverable",
 } as const;
-export type Recovery = ClosedEnum<typeof Recovery>;
+export type Recovery = OpenEnum<typeof Recovery>;
 
 export const Safety = {
   Unknown: "",
   Negligible: "negligible",
   Present: "present",
 } as const;
-export type Safety = ClosedEnum<typeof Safety>;
+export type Safety = OpenEnum<typeof Safety>;
 
 /**
  * Describes whether a user, other than the attacker, is required to do anything or participate in exploitation of the vulnerability. User interaction has two possible values: None (N) – No user interaction is required, Required (R) – A user must complete some steps for the exploit to succeed. For example, a user might be required to install some software.
@@ -154,7 +155,7 @@ export const CVSSv4ComponentsUserInteraction = {
 /**
  * Describes whether a user, other than the attacker, is required to do anything or participate in exploitation of the vulnerability. User interaction has two possible values: None (N) – No user interaction is required, Required (R) – A user must complete some steps for the exploit to succeed. For example, a user might be required to install some software.
  */
-export type CVSSv4ComponentsUserInteraction = ClosedEnum<
+export type CVSSv4ComponentsUserInteraction = OpenEnum<
   typeof CVSSv4ComponentsUserInteraction
 >;
 
@@ -163,7 +164,7 @@ export const ValueDensity = {
   Diffuse: "diffuse",
   Concentrated: "concentrated",
 } as const;
-export type ValueDensity = ClosedEnum<typeof ValueDensity>;
+export type ValueDensity = OpenEnum<typeof ValueDensity>;
 
 export const VulnerabilityResponseEffort = {
   Unknown: "",
@@ -171,7 +172,7 @@ export const VulnerabilityResponseEffort = {
   Moderate: "moderate",
   High: "high",
 } as const;
-export type VulnerabilityResponseEffort = ClosedEnum<
+export type VulnerabilityResponseEffort = OpenEnum<
   typeof VulnerabilityResponseEffort
 >;
 
@@ -214,70 +215,99 @@ export type CVSSv4Components = {
 };
 
 /** @internal */
-export const CVSSv4ComponentsAttackComplexity$inboundSchema: z.ZodNativeEnum<
-  typeof CVSSv4ComponentsAttackComplexity
-> = z.nativeEnum(CVSSv4ComponentsAttackComplexity);
+export const CVSSv4ComponentsAttackComplexity$inboundSchema: z.ZodType<
+  CVSSv4ComponentsAttackComplexity,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CVSSv4ComponentsAttackComplexity);
 
 /** @internal */
-export const AttackRequirements$inboundSchema: z.ZodNativeEnum<
-  typeof AttackRequirements
-> = z.nativeEnum(AttackRequirements);
+export const AttackRequirements$inboundSchema: z.ZodType<
+  AttackRequirements,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(AttackRequirements);
 
 /** @internal */
-export const CVSSv4ComponentsAttackVector$inboundSchema: z.ZodNativeEnum<
-  typeof CVSSv4ComponentsAttackVector
-> = z.nativeEnum(CVSSv4ComponentsAttackVector);
+export const CVSSv4ComponentsAttackVector$inboundSchema: z.ZodType<
+  CVSSv4ComponentsAttackVector,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CVSSv4ComponentsAttackVector);
 
 /** @internal */
-export const Automatable$inboundSchema: z.ZodNativeEnum<typeof Automatable> = z
-  .nativeEnum(Automatable);
+export const Automatable$inboundSchema: z.ZodType<
+  Automatable,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(Automatable);
 
 /** @internal */
-export const CVSSv4ComponentsAvailability$inboundSchema: z.ZodNativeEnum<
-  typeof CVSSv4ComponentsAvailability
-> = z.nativeEnum(CVSSv4ComponentsAvailability);
+export const CVSSv4ComponentsAvailability$inboundSchema: z.ZodType<
+  CVSSv4ComponentsAvailability,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CVSSv4ComponentsAvailability);
 
 /** @internal */
-export const CVSSv4ComponentsConfidentiality$inboundSchema: z.ZodNativeEnum<
-  typeof CVSSv4ComponentsConfidentiality
-> = z.nativeEnum(CVSSv4ComponentsConfidentiality);
+export const CVSSv4ComponentsConfidentiality$inboundSchema: z.ZodType<
+  CVSSv4ComponentsConfidentiality,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CVSSv4ComponentsConfidentiality);
 
 /** @internal */
-export const CVSSv4ComponentsIntegrity$inboundSchema: z.ZodNativeEnum<
-  typeof CVSSv4ComponentsIntegrity
-> = z.nativeEnum(CVSSv4ComponentsIntegrity);
+export const CVSSv4ComponentsIntegrity$inboundSchema: z.ZodType<
+  CVSSv4ComponentsIntegrity,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CVSSv4ComponentsIntegrity);
 
 /** @internal */
-export const CVSSv4ComponentsPrivilegesRequired$inboundSchema: z.ZodNativeEnum<
-  typeof CVSSv4ComponentsPrivilegesRequired
-> = z.nativeEnum(CVSSv4ComponentsPrivilegesRequired);
+export const CVSSv4ComponentsPrivilegesRequired$inboundSchema: z.ZodType<
+  CVSSv4ComponentsPrivilegesRequired,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CVSSv4ComponentsPrivilegesRequired);
 
 /** @internal */
-export const ProviderUrgency$inboundSchema: z.ZodNativeEnum<
-  typeof ProviderUrgency
-> = z.nativeEnum(ProviderUrgency);
+export const ProviderUrgency$inboundSchema: z.ZodType<
+  ProviderUrgency,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ProviderUrgency);
 
 /** @internal */
-export const Recovery$inboundSchema: z.ZodNativeEnum<typeof Recovery> = z
-  .nativeEnum(Recovery);
+export const Recovery$inboundSchema: z.ZodType<
+  Recovery,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(Recovery);
 
 /** @internal */
-export const Safety$inboundSchema: z.ZodNativeEnum<typeof Safety> = z
-  .nativeEnum(Safety);
+export const Safety$inboundSchema: z.ZodType<Safety, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(Safety);
 
 /** @internal */
-export const CVSSv4ComponentsUserInteraction$inboundSchema: z.ZodNativeEnum<
-  typeof CVSSv4ComponentsUserInteraction
-> = z.nativeEnum(CVSSv4ComponentsUserInteraction);
+export const CVSSv4ComponentsUserInteraction$inboundSchema: z.ZodType<
+  CVSSv4ComponentsUserInteraction,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CVSSv4ComponentsUserInteraction);
 
 /** @internal */
-export const ValueDensity$inboundSchema: z.ZodNativeEnum<typeof ValueDensity> =
-  z.nativeEnum(ValueDensity);
+export const ValueDensity$inboundSchema: z.ZodType<
+  ValueDensity,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ValueDensity);
 
 /** @internal */
-export const VulnerabilityResponseEffort$inboundSchema: z.ZodNativeEnum<
-  typeof VulnerabilityResponseEffort
-> = z.nativeEnum(VulnerabilityResponseEffort);
+export const VulnerabilityResponseEffort$inboundSchema: z.ZodType<
+  VulnerabilityResponseEffort,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(VulnerabilityResponseEffort);
 
 /** @internal */
 export const CVSSv4Components$inboundSchema: z.ZodType<

package/src/models/components/dns.ts

@@ -5,7 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import { DnsEDns, DnsEDns$inboundSchema } from "./dnsedns.js";
@@ -42,7 +43,7 @@ export const RCode = {
 /**
  * A enumerated field indicating the result of the request. The most common values are defined in RFC 1035.
  */
-export type RCode = ClosedEnum<typeof RCode>;
+export type RCode = OpenEnum<typeof RCode>;
 
 /**
  * An enumerated value indicating the behavior of the server. An AUTHORITATIVE server fulfills requests for domain names it controls, which are not listed by the server. FORWARDING and RECURSIVE_RESOLVER servers fulfill requests indirectly for domain names they do not control. A RECURSIVE_RESOLVER will query ip.parrotdns.com itself, resulting in its own IP address being present in the dns.answers.response field.
@@ -57,7 +58,7 @@ export const ServerType = {
 /**
  * An enumerated value indicating the behavior of the server. An AUTHORITATIVE server fulfills requests for domain names it controls, which are not listed by the server. FORWARDING and RECURSIVE_RESOLVER servers fulfill requests indirectly for domain names they do not control. A RECURSIVE_RESOLVER will query ip.parrotdns.com itself, resulting in its own IP address being present in the dns.answers.response field.
  */
-export type ServerType = ClosedEnum<typeof ServerType>;
+export type ServerType = OpenEnum<typeof ServerType>;
 
 export type Dns = {
   /**
@@ -93,13 +94,15 @@ export type Dns = {
 };
 
 /** @internal */
-export const RCode$inboundSchema: z.ZodNativeEnum<typeof RCode> = z.nativeEnum(
-  RCode,
-);
+export const RCode$inboundSchema: z.ZodType<RCode, z.ZodTypeDef, unknown> =
+  openEnums.inboundSchema(RCode);
 
 /** @internal */
-export const ServerType$inboundSchema: z.ZodNativeEnum<typeof ServerType> = z
-  .nativeEnum(ServerType);
+export const ServerType$inboundSchema: z.ZodType<
+  ServerType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ServerType);
 
 /** @internal */
 export const Dns$inboundSchema: z.ZodType<Dns, z.ZodTypeDef, unknown> = z

package/src/models/components/dnsresourcerecord.ts

@@ -4,7 +4,8 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -20,7 +21,7 @@ export const DnsResourceRecordType = {
 /**
  * An enumerated field indicating what type of data is in the "services.dns.additionals.response" field. For example, "A" signifies that the value in "services.dns.additionals.response" is an IPv4 address for the FQDN in "services.dns.additionals.name".
  */
-export type DnsResourceRecordType = ClosedEnum<typeof DnsResourceRecordType>;
+export type DnsResourceRecordType = OpenEnum<typeof DnsResourceRecordType>;
 
 export type DnsResourceRecord = {
   /**
@@ -38,9 +39,11 @@ export type DnsResourceRecord = {
 };
 
 /** @internal */
-export const DnsResourceRecordType$inboundSchema: z.ZodNativeEnum<
-  typeof DnsResourceRecordType
-> = z.nativeEnum(DnsResourceRecordType);
+export const DnsResourceRecordType$inboundSchema: z.ZodType<
+  DnsResourceRecordType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(DnsResourceRecordType);
 
 /** @internal */
 export const DnsResourceRecord$inboundSchema: z.ZodType<

package/src/models/components/endpointscan.ts

@@ -5,7 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -47,7 +48,7 @@ export const EndpointScanTransportProtocol = {
   Icmp: "icmp",
   Quic: "quic",
 } as const;
-export type EndpointScanTransportProtocol = ClosedEnum<
+export type EndpointScanTransportProtocol = OpenEnum<
   typeof EndpointScanTransportProtocol
 >;
 
@@ -84,9 +85,11 @@ export type EndpointScan = {
 };
 
 /** @internal */
-export const EndpointScanTransportProtocol$inboundSchema: z.ZodNativeEnum<
-  typeof EndpointScanTransportProtocol
-> = z.nativeEnum(EndpointScanTransportProtocol);
+export const EndpointScanTransportProtocol$inboundSchema: z.ZodType<
+  EndpointScanTransportProtocol,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(EndpointScanTransportProtocol);
 
 /** @internal */
 export const EndpointScan$inboundSchema: z.ZodType<

package/src/models/components/endpointscanstate.ts

@@ -5,7 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -14,6 +15,10 @@ import {
 } from "./chromedevtools.js";
 import { CobaltStrike, CobaltStrike$inboundSchema } from "./cobaltstrike.js";
 import { ElasticSearch, ElasticSearch$inboundSchema } from "./elasticsearch.js";
+import {
+  ExtractedEndpointData,
+  ExtractedEndpointData$inboundSchema,
+} from "./extractedendpointdata.js";
 import { Fortigate, Fortigate$inboundSchema } from "./fortigate.js";
 import { Graphql, Graphql$inboundSchema } from "./graphql.js";
 import { Http, Http$inboundSchema } from "./http.js";
@@ -46,7 +51,7 @@ export const EndpointScanStateTransportProtocol = {
   Icmp: "icmp",
   Quic: "quic",
 } as const;
-export type EndpointScanStateTransportProtocol = ClosedEnum<
+export type EndpointScanStateTransportProtocol = OpenEnum<
   typeof EndpointScanStateTransportProtocol
 >;
 
@@ -57,6 +62,7 @@ export type EndpointScanState = {
   cobaltStrike?: CobaltStrike | undefined;
   elasticsearch?: ElasticSearch | undefined;
   endpointType?: string | undefined;
+  extracted?: ExtractedEndpointData | undefined;
   fortigate?: Fortigate | undefined;
   graphql?: Graphql | undefined;
   hostname?: string | undefined;
@@ -81,9 +87,11 @@ export type EndpointScanState = {
 };
 
 /** @internal */
-export const EndpointScanStateTransportProtocol$inboundSchema: z.ZodNativeEnum<
-  typeof EndpointScanStateTransportProtocol
-> = z.nativeEnum(EndpointScanStateTransportProtocol);
+export const EndpointScanStateTransportProtocol$inboundSchema: z.ZodType<
+  EndpointScanStateTransportProtocol,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(EndpointScanStateTransportProtocol);
 
 /** @internal */
 export const EndpointScanState$inboundSchema: z.ZodType<
@@ -97,6 +105,7 @@ export const EndpointScanState$inboundSchema: z.ZodType<
   cobalt_strike: CobaltStrike$inboundSchema.optional(),
   elasticsearch: ElasticSearch$inboundSchema.optional(),
   endpoint_type: z.string().optional(),
+  extracted: ExtractedEndpointData$inboundSchema.optional(),
   fortigate: Fortigate$inboundSchema.optional(),
   graphql: Graphql$inboundSchema.optional(),
   hostname: z.string().optional(),

package/src/models/components/eventassetchange.ts

@@ -5,7 +5,8 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
@@ -13,7 +14,7 @@ export const ChangeType = {
   Added: "added",
   Removed: "removed",
 } as const;
-export type ChangeType = ClosedEnum<typeof ChangeType>;
+export type ChangeType = OpenEnum<typeof ChangeType>;
 
 export type EventAssetChange = {
   changeType: ChangeType;
@@ -22,8 +23,11 @@ export type EventAssetChange = {
 };
 
 /** @internal */
-export const ChangeType$inboundSchema: z.ZodNativeEnum<typeof ChangeType> = z
-  .nativeEnum(ChangeType);
+export const ChangeType$inboundSchema: z.ZodType<
+  ChangeType,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(ChangeType);
 
 /** @internal */
 export const EventAssetChange$inboundSchema: z.ZodType<