vanta-auditor-api-sdk 0.4.1 → 0.5.0

package/src/models/components/paginatedresponseinformationrequestevidence.ts

@@ -0,0 +1,80 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  InformationRequestEvidence,
+  InformationRequestEvidence$inboundSchema,
+} from "./informationrequestevidence.js";
+import { PageInfo, PageInfo$inboundSchema } from "./pageinfo.js";
+
+export type PaginatedResponseInformationRequestEvidenceResults = {
+  data: Array<InformationRequestEvidence>;
+  /**
+   * Provides information about the pagination of a dataset.
+   */
+  pageInfo: PageInfo;
+};
+
+export type PaginatedResponseInformationRequestEvidence = {
+  results: PaginatedResponseInformationRequestEvidenceResults;
+};
+
+/** @internal */
+export const PaginatedResponseInformationRequestEvidenceResults$inboundSchema:
+  z.ZodType<
+    PaginatedResponseInformationRequestEvidenceResults,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    data: z.array(InformationRequestEvidence$inboundSchema),
+    pageInfo: PageInfo$inboundSchema,
+  });
+
+export function paginatedResponseInformationRequestEvidenceResultsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PaginatedResponseInformationRequestEvidenceResults,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PaginatedResponseInformationRequestEvidenceResults$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PaginatedResponseInformationRequestEvidenceResults' from JSON`,
+  );
+}
+
+/** @internal */
+export const PaginatedResponseInformationRequestEvidence$inboundSchema:
+  z.ZodType<
+    PaginatedResponseInformationRequestEvidence,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    results: z.lazy(() =>
+      PaginatedResponseInformationRequestEvidenceResults$inboundSchema
+    ),
+  });
+
+export function paginatedResponseInformationRequestEvidenceFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PaginatedResponseInformationRequestEvidence,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PaginatedResponseInformationRequestEvidence$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PaginatedResponseInformationRequestEvidence' from JSON`,
+  );
+}

package/src/models/components/partialupdateinformationrequest.ts

@@ -0,0 +1,103 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  InformationRequestCadence,
+  InformationRequestCadence$outboundSchema,
+} from "./informationrequestcadence.js";
+import {
+  InformationRequestType,
+  InformationRequestType$outboundSchema,
+} from "./informationrequesttype.js";
+
+/**
+ * Input for partially updating an information request. Only provided fields
+ *
+ * @remarks
+ * will be updated; omitted fields remain unchanged. At least one field must
+ * be provided.
+ */
+export type PartialUpdateInformationRequest = {
+  /**
+   * The framework codes this request addresses.
+   *
+   * @remarks
+   * An empty array if no framework codes are associated.
+   */
+  frameworkCodes?: Array<string> | undefined;
+  /**
+   * Detailed description of what evidence is needed.
+   */
+  description?: string | null | undefined;
+  /**
+   * Deadline for fulfilling this request. Null if no deadline.
+   *
+   * @remarks
+   * Format: ISO 8601 UTC timestamp.
+   */
+  dueDate?: Date | null | undefined;
+  /**
+   * Start date of the audit period. Evidence before this date may not be accepted.
+   *
+   * @remarks
+   * Null if not restricted. Format: ISO 8601 UTC timestamp.
+   */
+  evidenceCaptureDate?: Date | null | undefined;
+  /**
+   * Type of information request, defining what scope of evidence is needed.
+   *
+   * @remarks
+   *
+   * - POINT_IN_TIME: Evidence for a specific moment (e.g., current state of a policy)
+   * - POPULATION: Evidence covering all items in a category (e.g., all employees)
+   * - SAMPLE: Evidence for a representative sample (e.g., 10 random customer records)
+   */
+  requestType?: InformationRequestType | undefined;
+  /**
+   * Short, descriptive title.
+   */
+  title?: string | undefined;
+  /**
+   * Frequency cadence for the information request, indicating how often it recurs.
+   */
+  cadence?: InformationRequestCadence | undefined;
+};
+
+/** @internal */
+export type PartialUpdateInformationRequest$Outbound = {
+  frameworkCodes?: Array<string> | undefined;
+  description?: string | null | undefined;
+  dueDate?: string | null | undefined;
+  evidenceCaptureDate?: string | null | undefined;
+  requestType?: string | undefined;
+  title?: string | undefined;
+  cadence?: string | undefined;
+};
+
+/** @internal */
+export const PartialUpdateInformationRequest$outboundSchema: z.ZodType<
+  PartialUpdateInformationRequest$Outbound,
+  z.ZodTypeDef,
+  PartialUpdateInformationRequest
+> = z.object({
+  frameworkCodes: z.array(z.string()).optional(),
+  description: z.nullable(z.string()).optional(),
+  dueDate: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+  evidenceCaptureDate: z.nullable(z.date().transform(v => v.toISOString()))
+    .optional(),
+  requestType: InformationRequestType$outboundSchema.optional(),
+  title: z.string().optional(),
+  cadence: InformationRequestCadence$outboundSchema.optional(),
+});
+
+export function partialUpdateInformationRequestToJSON(
+  partialUpdateInformationRequest: PartialUpdateInformationRequest,
+): string {
+  return JSON.stringify(
+    PartialUpdateInformationRequest$outboundSchema.parse(
+      partialUpdateInformationRequest,
+    ),
+  );
+}

package/src/models/components/recurrenceduration.ts

@@ -13,6 +13,7 @@ export const RecurrenceDuration = {
   P3M: "P3M",
   P6M: "P6M",
   P1Y: "P1Y",
+  P2Y: "P2Y",
 } as const;
 export type RecurrenceDuration = ClosedEnum<typeof RecurrenceDuration>;
 

package/src/models/components/section.ts

@@ -7,6 +7,20 @@ import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+/**
+ * The principle that groups this section, if any.
+ */
+export type Principle = {
+  /**
+   * The principle's unique ID.
+   */
+  id: string;
+  /**
+   * The principle's name.
+   */
+  name: string;
+};
+
 export type Section = {
   /**
    * The section name
@@ -16,33 +30,40 @@ export type Section = {
    * The section framework
    */
   framework: string;
+  /**
+   * The principle that groups this section, if any.
+   */
+  principle: Principle | null;
 };
 
 /** @internal */
-export const Section$inboundSchema: z.ZodType<Section, z.ZodTypeDef, unknown> =
-  z.object({
-    name: z.string(),
-    framework: z.string(),
-  });
-/** @internal */
-export type Section$Outbound = {
-  name: string;
-  framework: string;
-};
-
-/** @internal */
-export const Section$outboundSchema: z.ZodType<
-  Section$Outbound,
+export const Principle$inboundSchema: z.ZodType<
+  Principle,
   z.ZodTypeDef,
-  Section
+  unknown
 > = z.object({
+  id: z.string(),
   name: z.string(),
-  framework: z.string(),
 });
 
-export function sectionToJSON(section: Section): string {
-  return JSON.stringify(Section$outboundSchema.parse(section));
+export function principleFromJSON(
+  jsonString: string,
+): SafeParseResult<Principle, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Principle$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Principle' from JSON`,
+  );
 }
+
+/** @internal */
+export const Section$inboundSchema: z.ZodType<Section, z.ZodTypeDef, unknown> =
+  z.object({
+    name: z.string(),
+    framework: z.string(),
+    principle: z.nullable(z.lazy(() => Principle$inboundSchema)),
+  });
+
 export function sectionFromJSON(
   jsonString: string,
 ): SafeParseResult<Section, SDKValidationError> {

package/src/models/components/security.ts

@@ -3,22 +3,11 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../../lib/schemas.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type Security = {
   bearerAuth?: string | undefined;
 };
 
-/** @internal */
-export const Security$inboundSchema: z.ZodType<
-  Security,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  bearerAuth: z.string().optional(),
-});
 /** @internal */
 export type Security$Outbound = {
   bearerAuth?: string | undefined;
@@ -36,12 +25,3 @@ export const Security$outboundSchema: z.ZodType<
 export function securityToJSON(security: Security): string {
   return JSON.stringify(Security$outboundSchema.parse(security));
 }
-export function securityFromJSON(
-  jsonString: string,
-): SafeParseResult<Security, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Security$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Security' from JSON`,
-  );
-}

package/src/models/components/updateinformationrequestcommentinput.ts

@@ -0,0 +1,56 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+/**
+ * Updates an existing comment on an information request.
+ *
+ * @remarks
+ * Only the original author of the comment can update it.
+ */
+export type UpdateInformationRequestCommentInput = {
+  /**
+   * The text content of the comment.
+   *
+   * @remarks
+   * Must be at least 1 character. Can include questions, clarifications,
+   * or explanations related to the information request.
+   */
+  text: string;
+  /**
+   * Email address of the comment author.
+   *
+   * @remarks
+   * Must match an existing Vanta user who belongs to the audit firm making the API request.
+   * This email uniquely identifies the author across systems.
+   */
+  email: string;
+};
+
+/** @internal */
+export type UpdateInformationRequestCommentInput$Outbound = {
+  text: string;
+  email: string;
+};
+
+/** @internal */
+export const UpdateInformationRequestCommentInput$outboundSchema: z.ZodType<
+  UpdateInformationRequestCommentInput$Outbound,
+  z.ZodTypeDef,
+  UpdateInformationRequestCommentInput
+> = z.object({
+  text: z.string(),
+  email: z.string(),
+});
+
+export function updateInformationRequestCommentInputToJSON(
+  updateInformationRequestCommentInput: UpdateInformationRequestCommentInput,
+): string {
+  return JSON.stringify(
+    UpdateInformationRequestCommentInput$outboundSchema.parse(
+      updateInformationRequestCommentInput,
+    ),
+  );
+}

package/src/models/components/uploadeddocumentevidence.ts

@@ -0,0 +1,65 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Evidence in the form of an uploaded document file.
+ *
+ * @remarks
+ * The URL is a temporary presigned URL that expires after a certain period.
+ */
+export type UploadedDocumentEvidence = {
+  /**
+   * The unique identifier for the uploaded document in Vanta's system.
+   */
+  id: string;
+  /**
+   * The original filename of the uploaded document.
+   *
+   * @remarks
+   * Undefined if the filename was not captured during upload.
+   */
+  filename?: string | undefined;
+  /**
+   * The MIME type of the document indicating its file format.
+   *
+   * @remarks
+   * Common types: "application/pdf", "image/png", "image/jpeg", "text/plain"
+   */
+  mimeType: string;
+  /**
+   * A presigned URL for downloading the document.
+   *
+   * @remarks
+   * This URL is temporary and expires after a limited time.
+   * Request a new evidence list to get a fresh URL if expired.
+   */
+  url: string;
+};
+
+/** @internal */
+export const UploadedDocumentEvidence$inboundSchema: z.ZodType<
+  UploadedDocumentEvidence,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  filename: z.string().optional(),
+  mimeType: z.string(),
+  url: z.string(),
+});
+
+export function uploadedDocumentEvidenceFromJSON(
+  jsonString: string,
+): SafeParseResult<UploadedDocumentEvidence, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UploadedDocumentEvidence$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UploadedDocumentEvidence' from JSON`,
+  );
+}

package/src/models/components/vantadocumentevidence.ts

@@ -0,0 +1,145 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  VantaDocumentLinkEvidence,
+  VantaDocumentLinkEvidence$inboundSchema,
+} from "./vantadocumentlinkevidence.js";
+import {
+  VantaDocumentUploadedEvidence,
+  VantaDocumentUploadedEvidence$inboundSchema,
+} from "./vantadocumentuploadedevidence.js";
+
+/**
+ * Information about the user who added this file version to the document.
+ *
+ * @remarks
+ * Undefined if the user information is not available.
+ */
+export type AddedBy = {
+  email: string;
+  name: string;
+};
+
+/**
+ * The file or link associated with this document version.
+ *
+ * @remarks
+ * Use the `type` discriminator to determine whether it's an uploaded file
+ * or an external link.
+ */
+export type FileT = VantaDocumentUploadedEvidence | VantaDocumentLinkEvidence;
+
+/**
+ * Evidence in the form of a Vanta Document.
+ *
+ * @remarks
+ * Vanta Documents are managed documents with metadata like expiration dates
+ * and versioning. They can either be uploaded files stored in Vanta or
+ * links to external documentation.
+ */
+export type VantaDocumentEvidence = {
+  /**
+   * The title of the document as displayed in Vanta.
+   */
+  title: string;
+  /**
+   * Optional description providing additional context about the document.
+   */
+  description?: string | undefined;
+  /**
+   * The date when the document version expires and should be renewed.
+   *
+   * @remarks
+   * Undefined if no expiration is set.
+   * Format: ISO 8601 UTC timestamp.
+   */
+  expirationDate?: Date | undefined;
+  /**
+   * Information about the user who added this file version to the document.
+   *
+   * @remarks
+   * Undefined if the user information is not available.
+   */
+  addedBy?: AddedBy | undefined;
+  /**
+   * The unique identifier of the document version submitted as evidence.
+   */
+  documentVersionId: string;
+  /**
+   * The file or link associated with this document version.
+   *
+   * @remarks
+   * Use the `type` discriminator to determine whether it's an uploaded file
+   * or an external link.
+   */
+  file: VantaDocumentUploadedEvidence | VantaDocumentLinkEvidence;
+};
+
+/** @internal */
+export const AddedBy$inboundSchema: z.ZodType<AddedBy, z.ZodTypeDef, unknown> =
+  z.object({
+    email: z.string(),
+    name: z.string(),
+  });
+
+export function addedByFromJSON(
+  jsonString: string,
+): SafeParseResult<AddedBy, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AddedBy$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AddedBy' from JSON`,
+  );
+}
+
+/** @internal */
+export const FileT$inboundSchema: z.ZodType<FileT, z.ZodTypeDef, unknown> = z
+  .union([
+    VantaDocumentUploadedEvidence$inboundSchema,
+    VantaDocumentLinkEvidence$inboundSchema,
+  ]);
+
+export function fileFromJSON(
+  jsonString: string,
+): SafeParseResult<FileT, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FileT$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FileT' from JSON`,
+  );
+}
+
+/** @internal */
+export const VantaDocumentEvidence$inboundSchema: z.ZodType<
+  VantaDocumentEvidence,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  expirationDate: z.string().datetime({ offset: true }).transform(v =>
+    new Date(v)
+  ).optional(),
+  addedBy: z.lazy(() => AddedBy$inboundSchema).optional(),
+  documentVersionId: z.string(),
+  file: z.union([
+    VantaDocumentUploadedEvidence$inboundSchema,
+    VantaDocumentLinkEvidence$inboundSchema,
+  ]),
+});
+
+export function vantaDocumentEvidenceFromJSON(
+  jsonString: string,
+): SafeParseResult<VantaDocumentEvidence, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VantaDocumentEvidence$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VantaDocumentEvidence' from JSON`,
+  );
+}

package/src/models/components/vantadocumentlinkevidence.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Represents an external link in a Vanta Document.
+ *
+ * @remarks
+ * The link points to documentation hosted outside of Vanta's system.
+ */
+export type VantaDocumentLinkEvidence = {
+  /**
+   * Discriminator to identify this as an external link.
+   */
+  type: "link";
+  /**
+   * The unique identifier for the file version in Vanta's system.
+   */
+  id: string;
+  /**
+   * The URL pointing to the external documentation or resource.
+   */
+  url: string;
+};
+
+/** @internal */
+export const VantaDocumentLinkEvidence$inboundSchema: z.ZodType<
+  VantaDocumentLinkEvidence,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("link"),
+  id: z.string(),
+  url: z.string(),
+});
+
+export function vantaDocumentLinkEvidenceFromJSON(
+  jsonString: string,
+): SafeParseResult<VantaDocumentLinkEvidence, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VantaDocumentLinkEvidence$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VantaDocumentLinkEvidence' from JSON`,
+  );
+}

package/src/models/components/vantadocumentuploadedevidence.ts

@@ -0,0 +1,70 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+/**
+ * Represents an uploaded file in a Vanta Document.
+ *
+ * @remarks
+ * The file is stored in Vanta's system and accessed via a presigned URL.
+ */
+export type VantaDocumentUploadedEvidence = {
+  /**
+   * Discriminator to identify this as an uploaded file.
+   */
+  type: "uploaded";
+  /**
+   * The unique identifier for the file version in Vanta's system.
+   */
+  id: string;
+  /**
+   * The original filename of the uploaded document.
+   *
+   * @remarks
+   * Undefined if the filename was not captured during upload.
+   */
+  filename?: string | undefined;
+  /**
+   * The MIME type of the document indicating its file format.
+   *
+   * @remarks
+   * Common types: "application/pdf", "image/png", "image/jpeg", "text/plain"
+   */
+  mimeType: string;
+  /**
+   * A presigned URL for downloading the document.
+   *
+   * @remarks
+   * This URL is temporary and expires after a limited time.
+   * Request a new evidence list to get a fresh URL if expired.
+   */
+  url: string;
+};
+
+/** @internal */
+export const VantaDocumentUploadedEvidence$inboundSchema: z.ZodType<
+  VantaDocumentUploadedEvidence,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("uploaded"),
+  id: z.string(),
+  filename: z.string().optional(),
+  mimeType: z.string(),
+  url: z.string(),
+});
+
+export function vantaDocumentUploadedEvidenceFromJSON(
+  jsonString: string,
+): SafeParseResult<VantaDocumentUploadedEvidence, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VantaDocumentUploadedEvidence$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VantaDocumentUploadedEvidence' from JSON`,
+  );
+}