vanta-auditor-api-sdk 0.4.2 → 0.5.0

package/src/models/components/paginatedissuesnapshotmetadataresponse.ts

@@ -0,0 +1,74 @@
+/*
+ * 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 {
+  IssueSnapshotMetadata,
+  IssueSnapshotMetadata$inboundSchema,
+} from "./issuesnapshotmetadata.js";
+import { PageInfo, PageInfo$inboundSchema } from "./pageinfo.js";
+
+export type PaginatedIssueSnapshotMetadataResponseResults = {
+  data: Array<IssueSnapshotMetadata>;
+  /**
+   * Provides information about the pagination of a dataset.
+   */
+  pageInfo: PageInfo;
+};
+
+export type PaginatedIssueSnapshotMetadataResponse = {
+  results: PaginatedIssueSnapshotMetadataResponseResults;
+};
+
+/** @internal */
+export const PaginatedIssueSnapshotMetadataResponseResults$inboundSchema:
+  z.ZodType<
+    PaginatedIssueSnapshotMetadataResponseResults,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    data: z.array(IssueSnapshotMetadata$inboundSchema),
+    pageInfo: PageInfo$inboundSchema,
+  });
+
+export function paginatedIssueSnapshotMetadataResponseResultsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PaginatedIssueSnapshotMetadataResponseResults,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PaginatedIssueSnapshotMetadataResponseResults$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PaginatedIssueSnapshotMetadataResponseResults' from JSON`,
+  );
+}
+
+/** @internal */
+export const PaginatedIssueSnapshotMetadataResponse$inboundSchema: z.ZodType<
+  PaginatedIssueSnapshotMetadataResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  results: z.lazy(() =>
+    PaginatedIssueSnapshotMetadataResponseResults$inboundSchema
+  ),
+});
+
+export function paginatedIssueSnapshotMetadataResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<PaginatedIssueSnapshotMetadataResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PaginatedIssueSnapshotMetadataResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PaginatedIssueSnapshotMetadataResponse' from JSON`,
+  );
+}

package/src/models/components/paginatedresponseinformationrequest.ts

@@ -0,0 +1,71 @@
+/*
+ * 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 {
+  InformationRequest,
+  InformationRequest$inboundSchema,
+} from "./informationrequest.js";
+import { PageInfo, PageInfo$inboundSchema } from "./pageinfo.js";
+
+export type PaginatedResponseInformationRequestResults = {
+  data: Array<InformationRequest>;
+  /**
+   * Provides information about the pagination of a dataset.
+   */
+  pageInfo: PageInfo;
+};
+
+export type PaginatedResponseInformationRequest = {
+  results: PaginatedResponseInformationRequestResults;
+};
+
+/** @internal */
+export const PaginatedResponseInformationRequestResults$inboundSchema:
+  z.ZodType<PaginatedResponseInformationRequestResults, z.ZodTypeDef, unknown> =
+    z.object({
+      data: z.array(InformationRequest$inboundSchema),
+      pageInfo: PageInfo$inboundSchema,
+    });
+
+export function paginatedResponseInformationRequestResultsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PaginatedResponseInformationRequestResults,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PaginatedResponseInformationRequestResults$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PaginatedResponseInformationRequestResults' from JSON`,
+  );
+}
+
+/** @internal */
+export const PaginatedResponseInformationRequest$inboundSchema: z.ZodType<
+  PaginatedResponseInformationRequest,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  results: z.lazy(() =>
+    PaginatedResponseInformationRequestResults$inboundSchema
+  ),
+});
+
+export function paginatedResponseInformationRequestFromJSON(
+  jsonString: string,
+): SafeParseResult<PaginatedResponseInformationRequest, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PaginatedResponseInformationRequest$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PaginatedResponseInformationRequest' from JSON`,
+  );
+}

package/src/models/components/paginatedresponseinformationrequestactivitylog.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 {
+  InformationRequestActivityLog,
+  InformationRequestActivityLog$inboundSchema,
+} from "./informationrequestactivitylog.js";
+import { PageInfo, PageInfo$inboundSchema } from "./pageinfo.js";
+
+export type PaginatedResponseInformationRequestActivityLogResults = {
+  data: Array<InformationRequestActivityLog>;
+  /**
+   * Provides information about the pagination of a dataset.
+   */
+  pageInfo: PageInfo;
+};
+
+export type PaginatedResponseInformationRequestActivityLog = {
+  results: PaginatedResponseInformationRequestActivityLogResults;
+};
+
+/** @internal */
+export const PaginatedResponseInformationRequestActivityLogResults$inboundSchema:
+  z.ZodType<
+    PaginatedResponseInformationRequestActivityLogResults,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    data: z.array(InformationRequestActivityLog$inboundSchema),
+    pageInfo: PageInfo$inboundSchema,
+  });
+
+export function paginatedResponseInformationRequestActivityLogResultsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PaginatedResponseInformationRequestActivityLogResults,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PaginatedResponseInformationRequestActivityLogResults$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PaginatedResponseInformationRequestActivityLogResults' from JSON`,
+  );
+}
+
+/** @internal */
+export const PaginatedResponseInformationRequestActivityLog$inboundSchema:
+  z.ZodType<
+    PaginatedResponseInformationRequestActivityLog,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    results: z.lazy(() =>
+      PaginatedResponseInformationRequestActivityLogResults$inboundSchema
+    ),
+  });
+
+export function paginatedResponseInformationRequestActivityLogFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PaginatedResponseInformationRequestActivityLog,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PaginatedResponseInformationRequestActivityLog$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PaginatedResponseInformationRequestActivityLog' from JSON`,
+  );
+}

package/src/models/components/paginatedresponseinformationrequestcomment.ts

@@ -0,0 +1,77 @@
+/*
+ * 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 {
+  InformationRequestComment,
+  InformationRequestComment$inboundSchema,
+} from "./informationrequestcomment.js";
+import { PageInfo, PageInfo$inboundSchema } from "./pageinfo.js";
+
+export type PaginatedResponseInformationRequestCommentResults = {
+  data: Array<InformationRequestComment>;
+  /**
+   * Provides information about the pagination of a dataset.
+   */
+  pageInfo: PageInfo;
+};
+
+export type PaginatedResponseInformationRequestComment = {
+  results: PaginatedResponseInformationRequestCommentResults;
+};
+
+/** @internal */
+export const PaginatedResponseInformationRequestCommentResults$inboundSchema:
+  z.ZodType<
+    PaginatedResponseInformationRequestCommentResults,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    data: z.array(InformationRequestComment$inboundSchema),
+    pageInfo: PageInfo$inboundSchema,
+  });
+
+export function paginatedResponseInformationRequestCommentResultsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PaginatedResponseInformationRequestCommentResults,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PaginatedResponseInformationRequestCommentResults$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PaginatedResponseInformationRequestCommentResults' from JSON`,
+  );
+}
+
+/** @internal */
+export const PaginatedResponseInformationRequestComment$inboundSchema:
+  z.ZodType<PaginatedResponseInformationRequestComment, z.ZodTypeDef, unknown> =
+    z.object({
+      results: z.lazy(() =>
+        PaginatedResponseInformationRequestCommentResults$inboundSchema
+      ),
+    });
+
+export function paginatedResponseInformationRequestCommentFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  PaginatedResponseInformationRequestComment,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      PaginatedResponseInformationRequestComment$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'PaginatedResponseInformationRequestComment' from JSON`,
+  );
+}

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,13 +30,38 @@ export type Section = {
    * The section framework
    */
   framework: string;
+  /**
+   * The principle that groups this section, if any.
+   */
+  principle: Principle | null;
 };
 
+/** @internal */
+export const Principle$inboundSchema: z.ZodType<
+  Principle,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  name: z.string(),
+});
+
+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(

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`,
+  );
+}