@censys/platform-sdk 0.8.0 → 0.9.1

package/src/models/components/collection.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";
 
@@ -16,7 +17,7 @@ export const CollectionStatus = {
   Paused: "paused",
   Archived: "archived",
 } as const;
-export type CollectionStatus = ClosedEnum<typeof CollectionStatus>;
+export type CollectionStatus = OpenEnum<typeof CollectionStatus>;
 
 export const StatusReason = {
   Unspecified: "unspecified",
@@ -27,11 +28,15 @@ export const StatusReason = {
   QueryChanged: "query_changed",
   Initial: "initial",
 } as const;
-export type StatusReason = ClosedEnum<typeof StatusReason>;
+export type StatusReason = OpenEnum<typeof StatusReason>;
 
 export type Collection = {
   addedAssets24Hours: number;
   createTime: Date;
+  /**
+   * The ID of a Censys user who created the collection.
+   */
+  createdBy?: string | undefined;
   description: string;
   id: string;
   name: string;
@@ -43,13 +48,18 @@ export type Collection = {
 };
 
 /** @internal */
-export const CollectionStatus$inboundSchema: z.ZodNativeEnum<
-  typeof CollectionStatus
-> = z.nativeEnum(CollectionStatus);
+export const CollectionStatus$inboundSchema: z.ZodType<
+  CollectionStatus,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(CollectionStatus);
 
 /** @internal */
-export const StatusReason$inboundSchema: z.ZodNativeEnum<typeof StatusReason> =
-  z.nativeEnum(StatusReason);
+export const StatusReason$inboundSchema: z.ZodType<
+  StatusReason,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(StatusReason);
 
 /** @internal */
 export const Collection$inboundSchema: z.ZodType<
@@ -61,6 +71,7 @@ export const Collection$inboundSchema: z.ZodType<
   create_time: z.string().datetime({ offset: true }).transform(v =>
     new Date(v)
   ),
+  created_by: z.string().optional(),
   description: z.string(),
   id: z.string(),
   name: z.string(),
@@ -73,6 +84,7 @@ export const Collection$inboundSchema: z.ZodType<
   return remap$(v, {
     "added_assets_24_hours": "addedAssets24Hours",
     "create_time": "createTime",
+    "created_by": "createdBy",
     "removed_assets_24_hours": "removedAssets24Hours",
     "status_reason": "statusReason",
     "total_assets": "totalAssets",

package/src/models/components/creditexpiration.ts

@@ -21,6 +21,10 @@ export type CreditExpiration = {
    * The date and time the credit expiration will expire.
    */
   expiresAt?: Date | undefined;
+  /**
+   * The initial balance of the credit expiration (i.e. how much was purchased).
+   */
+  initialBalance: number;
 };
 
 /** @internal */
@@ -34,10 +38,12 @@ export const CreditExpiration$inboundSchema: z.ZodType<
     .optional(),
   expires_at: z.string().datetime({ offset: true }).transform(v => new Date(v))
     .optional(),
+  initial_balance: z.number().int(),
 }).transform((v) => {
   return remap$(v, {
     "created_at": "createdAt",
     "expires_at": "expiresAt",
+    "initial_balance": "initialBalance",
   });
 });
 

package/src/models/components/creditusagereport.ts

@@ -5,45 +5,104 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.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 {
+  CreditUsageReportPeriod,
+  CreditUsageReportPeriod$inboundSchema,
+} from "./creditusagereportperiod.js";
 import {
   SourceUsageBreakdown,
   SourceUsageBreakdown$inboundSchema,
 } from "./sourceusagebreakdown.js";
 
+/**
+ * The granularity of the report.
+ */
+export const Granularity = {
+  Daily: "daily",
+  Monthly: "monthly",
+} as const;
+/**
+ * The granularity of the report.
+ */
+export type Granularity = OpenEnum<typeof Granularity>;
+
 export type CreditUsageReport = {
   /**
-   * The end date of the window for this report.
+   * The breakdown of credits consumed by consumer. This may not be present if the report is generated for a specific user.
+   */
+  creditsConsumedByConsumer?: string | undefined;
+  creditsConsumedBySource: SourceUsageBreakdown;
+  /**
+   * The end time of the window for this report.
+   */
+  endTime: Date;
+  /**
+   * The granularity of the report.
+   */
+  granularity: Granularity;
+  /**
+   * The periods of the report (i.e. time buckets).
    */
-  endDate: Date;
-  sourceBreakdown: SourceUsageBreakdown;
+  periods: Array<CreditUsageReportPeriod> | null;
   /**
-   * The start date of the window for this report.
+   * The start time of the window for this report.
    */
-  startDate: Date;
+  startTime: Date;
+  /**
+   * The total amount of credits added during the report period.
+   */
+  totalAdded: number;
   /**
    * The total amount of credits consumed during the report period.
    */
   totalConsumed: number;
+  /**
+   * The total amount of credits expired during the report period.
+   */
+  totalExpired: number;
+  /**
+   * The total number of transactions during the report period.
+   */
+  transactionCount: number;
 };
 
+/** @internal */
+export const Granularity$inboundSchema: z.ZodType<
+  Granularity,
+  z.ZodTypeDef,
+  unknown
+> = openEnums.inboundSchema(Granularity);
+
 /** @internal */
 export const CreditUsageReport$inboundSchema: z.ZodType<
   CreditUsageReport,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  end_date: z.string().datetime({ offset: true }).transform(v => new Date(v)),
-  source_breakdown: SourceUsageBreakdown$inboundSchema,
-  start_date: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  credits_consumed_by_consumer: z.string().optional(),
+  credits_consumed_by_source: SourceUsageBreakdown$inboundSchema,
+  end_time: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  granularity: Granularity$inboundSchema.default("daily"),
+  periods: z.nullable(z.array(CreditUsageReportPeriod$inboundSchema)),
+  start_time: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  total_added: z.number().int(),
   total_consumed: z.number().int(),
+  total_expired: z.number().int(),
+  transaction_count: z.number().int(),
 }).transform((v) => {
   return remap$(v, {
-    "end_date": "endDate",
-    "source_breakdown": "sourceBreakdown",
-    "start_date": "startDate",
+    "credits_consumed_by_consumer": "creditsConsumedByConsumer",
+    "credits_consumed_by_source": "creditsConsumedBySource",
+    "end_time": "endTime",
+    "start_time": "startTime",
+    "total_added": "totalAdded",
     "total_consumed": "totalConsumed",
+    "total_expired": "totalExpired",
+    "transaction_count": "transactionCount",
   });
 });
 

package/src/models/components/creditusagereportperiod.ts

@@ -0,0 +1,69 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type CreditUsageReportPeriod = {
+  /**
+   * The total amount of credits added during the report period.
+   */
+  creditsAdded: number;
+  /**
+   * The total amount of credits consumed during the report period.
+   */
+  creditsConsumed: number;
+  /**
+   * The total amount of credits expired during the report period.
+   */
+  creditsExpired: number;
+  /**
+   * The end date of the window for this report period.
+   */
+  endDate: Date;
+  /**
+   * The start date of the window for this report period.
+   */
+  startDate: Date;
+  /**
+   * The total number of transactions during the report period.
+   */
+  transactionCount: number;
+};
+
+/** @internal */
+export const CreditUsageReportPeriod$inboundSchema: z.ZodType<
+  CreditUsageReportPeriod,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  credits_added: z.number().int(),
+  credits_consumed: z.number().int(),
+  credits_expired: z.number().int(),
+  end_date: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  start_date: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  transaction_count: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "credits_added": "creditsAdded",
+    "credits_consumed": "creditsConsumed",
+    "credits_expired": "creditsExpired",
+    "end_date": "endDate",
+    "start_date": "startDate",
+    "transaction_count": "transactionCount",
+  });
+});
+
+export function creditUsageReportPeriodFromJSON(
+  jsonString: string,
+): SafeParseResult<CreditUsageReportPeriod, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreditUsageReportPeriod$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreditUsageReportPeriod' from JSON`,
+  );
+}

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<