vanta-auditor-api-sdk 0.4.1 → 0.5.0

package/src/models/components/paginatedresponseaudit.ts

@@ -6,18 +6,8 @@ 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 {
-  Audit,
-  Audit$inboundSchema,
-  Audit$Outbound,
-  Audit$outboundSchema,
-} from "./audit.js";
-import {
-  PageInfo,
-  PageInfo$inboundSchema,
-  PageInfo$Outbound,
-  PageInfo$outboundSchema,
-} from "./pageinfo.js";
+import { Audit, Audit$inboundSchema } from "./audit.js";
+import { PageInfo, PageInfo$inboundSchema } from "./pageinfo.js";
 
 export type Results = {
   data: Array<Audit>;
@@ -37,25 +27,7 @@ export const Results$inboundSchema: z.ZodType<Results, z.ZodTypeDef, unknown> =
     data: z.array(Audit$inboundSchema),
     pageInfo: PageInfo$inboundSchema,
   });
-/** @internal */
-export type Results$Outbound = {
-  data: Array<Audit$Outbound>;
-  pageInfo: PageInfo$Outbound;
-};
 
-/** @internal */
-export const Results$outboundSchema: z.ZodType<
-  Results$Outbound,
-  z.ZodTypeDef,
-  Results
-> = z.object({
-  data: z.array(Audit$outboundSchema),
-  pageInfo: PageInfo$outboundSchema,
-});
-
-export function resultsToJSON(results: Results): string {
-  return JSON.stringify(Results$outboundSchema.parse(results));
-}
 export function resultsFromJSON(
   jsonString: string,
 ): SafeParseResult<Results, SDKValidationError> {
@@ -74,27 +46,7 @@ export const PaginatedResponseAudit$inboundSchema: z.ZodType<
 > = z.object({
   results: z.lazy(() => Results$inboundSchema),
 });
-/** @internal */
-export type PaginatedResponseAudit$Outbound = {
-  results: Results$Outbound;
-};
-
-/** @internal */
-export const PaginatedResponseAudit$outboundSchema: z.ZodType<
-  PaginatedResponseAudit$Outbound,
-  z.ZodTypeDef,
-  PaginatedResponseAudit
-> = z.object({
-  results: z.lazy(() => Results$outboundSchema),
-});
 
-export function paginatedResponseAuditToJSON(
-  paginatedResponseAudit: PaginatedResponseAudit,
-): string {
-  return JSON.stringify(
-    PaginatedResponseAudit$outboundSchema.parse(paginatedResponseAudit),
-  );
-}
 export function paginatedResponseAuditFromJSON(
   jsonString: string,
 ): SafeParseResult<PaginatedResponseAudit, SDKValidationError> {

package/src/models/components/paginatedresponseauditorcontrol.ts

@@ -9,15 +9,8 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   AuditorControl,
   AuditorControl$inboundSchema,
-  AuditorControl$Outbound,
-  AuditorControl$outboundSchema,
 } from "./auditorcontrol.js";
-import {
-  PageInfo,
-  PageInfo$inboundSchema,
-  PageInfo$Outbound,
-  PageInfo$outboundSchema,
-} from "./pageinfo.js";
+import { PageInfo, PageInfo$inboundSchema } from "./pageinfo.js";
 
 export type PaginatedResponseAuditorControlResults = {
   data: Array<AuditorControl>;
@@ -40,32 +33,7 @@ export const PaginatedResponseAuditorControlResults$inboundSchema: z.ZodType<
   data: z.array(AuditorControl$inboundSchema),
   pageInfo: PageInfo$inboundSchema,
 });
-/** @internal */
-export type PaginatedResponseAuditorControlResults$Outbound = {
-  data: Array<AuditorControl$Outbound>;
-  pageInfo: PageInfo$Outbound;
-};
-
-/** @internal */
-export const PaginatedResponseAuditorControlResults$outboundSchema: z.ZodType<
-  PaginatedResponseAuditorControlResults$Outbound,
-  z.ZodTypeDef,
-  PaginatedResponseAuditorControlResults
-> = z.object({
-  data: z.array(AuditorControl$outboundSchema),
-  pageInfo: PageInfo$outboundSchema,
-});
 
-export function paginatedResponseAuditorControlResultsToJSON(
-  paginatedResponseAuditorControlResults:
-    PaginatedResponseAuditorControlResults,
-): string {
-  return JSON.stringify(
-    PaginatedResponseAuditorControlResults$outboundSchema.parse(
-      paginatedResponseAuditorControlResults,
-    ),
-  );
-}
 export function paginatedResponseAuditorControlResultsFromJSON(
   jsonString: string,
 ): SafeParseResult<PaginatedResponseAuditorControlResults, SDKValidationError> {
@@ -85,29 +53,7 @@ export const PaginatedResponseAuditorControl$inboundSchema: z.ZodType<
 > = z.object({
   results: z.lazy(() => PaginatedResponseAuditorControlResults$inboundSchema),
 });
-/** @internal */
-export type PaginatedResponseAuditorControl$Outbound = {
-  results: PaginatedResponseAuditorControlResults$Outbound;
-};
 
-/** @internal */
-export const PaginatedResponseAuditorControl$outboundSchema: z.ZodType<
-  PaginatedResponseAuditorControl$Outbound,
-  z.ZodTypeDef,
-  PaginatedResponseAuditorControl
-> = z.object({
-  results: z.lazy(() => PaginatedResponseAuditorControlResults$outboundSchema),
-});
-
-export function paginatedResponseAuditorControlToJSON(
-  paginatedResponseAuditorControl: PaginatedResponseAuditorControl,
-): string {
-  return JSON.stringify(
-    PaginatedResponseAuditorControl$outboundSchema.parse(
-      paginatedResponseAuditorControl,
-    ),
-  );
-}
 export function paginatedResponseAuditorControlFromJSON(
   jsonString: string,
 ): SafeParseResult<PaginatedResponseAuditorControl, SDKValidationError> {

package/src/models/components/paginatedresponsecomment.ts

@@ -6,18 +6,8 @@ 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 {
-  Comment,
-  Comment$inboundSchema,
-  Comment$Outbound,
-  Comment$outboundSchema,
-} from "./comment.js";
-import {
-  PageInfo,
-  PageInfo$inboundSchema,
-  PageInfo$Outbound,
-  PageInfo$outboundSchema,
-} from "./pageinfo.js";
+import { Comment, Comment$inboundSchema } from "./comment.js";
+import { PageInfo, PageInfo$inboundSchema } from "./pageinfo.js";
 
 export type PaginatedResponseCommentResults = {
   data: Array<Comment>;
@@ -40,31 +30,7 @@ export const PaginatedResponseCommentResults$inboundSchema: z.ZodType<
   data: z.array(Comment$inboundSchema),
   pageInfo: PageInfo$inboundSchema,
 });
-/** @internal */
-export type PaginatedResponseCommentResults$Outbound = {
-  data: Array<Comment$Outbound>;
-  pageInfo: PageInfo$Outbound;
-};
 
-/** @internal */
-export const PaginatedResponseCommentResults$outboundSchema: z.ZodType<
-  PaginatedResponseCommentResults$Outbound,
-  z.ZodTypeDef,
-  PaginatedResponseCommentResults
-> = z.object({
-  data: z.array(Comment$outboundSchema),
-  pageInfo: PageInfo$outboundSchema,
-});
-
-export function paginatedResponseCommentResultsToJSON(
-  paginatedResponseCommentResults: PaginatedResponseCommentResults,
-): string {
-  return JSON.stringify(
-    PaginatedResponseCommentResults$outboundSchema.parse(
-      paginatedResponseCommentResults,
-    ),
-  );
-}
 export function paginatedResponseCommentResultsFromJSON(
   jsonString: string,
 ): SafeParseResult<PaginatedResponseCommentResults, SDKValidationError> {
@@ -83,27 +49,7 @@ export const PaginatedResponseComment$inboundSchema: z.ZodType<
 > = z.object({
   results: z.lazy(() => PaginatedResponseCommentResults$inboundSchema),
 });
-/** @internal */
-export type PaginatedResponseComment$Outbound = {
-  results: PaginatedResponseCommentResults$Outbound;
-};
 
-/** @internal */
-export const PaginatedResponseComment$outboundSchema: z.ZodType<
-  PaginatedResponseComment$Outbound,
-  z.ZodTypeDef,
-  PaginatedResponseComment
-> = z.object({
-  results: z.lazy(() => PaginatedResponseCommentResults$outboundSchema),
-});
-
-export function paginatedResponseCommentToJSON(
-  paginatedResponseComment: PaginatedResponseComment,
-): string {
-  return JSON.stringify(
-    PaginatedResponseComment$outboundSchema.parse(paginatedResponseComment),
-  );
-}
 export function paginatedResponseCommentFromJSON(
   jsonString: string,
 ): SafeParseResult<PaginatedResponseComment, SDKValidationError> {

package/src/models/components/paginatedresponseevidence.ts

@@ -6,18 +6,8 @@ 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 {
-  Evidence,
-  Evidence$inboundSchema,
-  Evidence$Outbound,
-  Evidence$outboundSchema,
-} from "./evidence.js";
-import {
-  PageInfo,
-  PageInfo$inboundSchema,
-  PageInfo$Outbound,
-  PageInfo$outboundSchema,
-} from "./pageinfo.js";
+import { Evidence, Evidence$inboundSchema } from "./evidence.js";
+import { PageInfo, PageInfo$inboundSchema } from "./pageinfo.js";
 
 export type PaginatedResponseEvidenceResults = {
   data: Array<Evidence>;
@@ -40,31 +30,7 @@ export const PaginatedResponseEvidenceResults$inboundSchema: z.ZodType<
   data: z.array(Evidence$inboundSchema),
   pageInfo: PageInfo$inboundSchema,
 });
-/** @internal */
-export type PaginatedResponseEvidenceResults$Outbound = {
-  data: Array<Evidence$Outbound>;
-  pageInfo: PageInfo$Outbound;
-};
 
-/** @internal */
-export const PaginatedResponseEvidenceResults$outboundSchema: z.ZodType<
-  PaginatedResponseEvidenceResults$Outbound,
-  z.ZodTypeDef,
-  PaginatedResponseEvidenceResults
-> = z.object({
-  data: z.array(Evidence$outboundSchema),
-  pageInfo: PageInfo$outboundSchema,
-});
-
-export function paginatedResponseEvidenceResultsToJSON(
-  paginatedResponseEvidenceResults: PaginatedResponseEvidenceResults,
-): string {
-  return JSON.stringify(
-    PaginatedResponseEvidenceResults$outboundSchema.parse(
-      paginatedResponseEvidenceResults,
-    ),
-  );
-}
 export function paginatedResponseEvidenceResultsFromJSON(
   jsonString: string,
 ): SafeParseResult<PaginatedResponseEvidenceResults, SDKValidationError> {
@@ -83,27 +49,7 @@ export const PaginatedResponseEvidence$inboundSchema: z.ZodType<
 > = z.object({
   results: z.lazy(() => PaginatedResponseEvidenceResults$inboundSchema),
 });
-/** @internal */
-export type PaginatedResponseEvidence$Outbound = {
-  results: PaginatedResponseEvidenceResults$Outbound;
-};
 
-/** @internal */
-export const PaginatedResponseEvidence$outboundSchema: z.ZodType<
-  PaginatedResponseEvidence$Outbound,
-  z.ZodTypeDef,
-  PaginatedResponseEvidence
-> = z.object({
-  results: z.lazy(() => PaginatedResponseEvidenceResults$outboundSchema),
-});
-
-export function paginatedResponseEvidenceToJSON(
-  paginatedResponseEvidence: PaginatedResponseEvidence,
-): string {
-  return JSON.stringify(
-    PaginatedResponseEvidence$outboundSchema.parse(paginatedResponseEvidence),
-  );
-}
 export function paginatedResponseEvidenceFromJSON(
   jsonString: string,
 ): SafeParseResult<PaginatedResponseEvidence, SDKValidationError> {

package/src/models/components/paginatedresponseevidenceurl.ts

@@ -6,18 +6,8 @@ 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 {
-  EvidenceUrl,
-  EvidenceUrl$inboundSchema,
-  EvidenceUrl$Outbound,
-  EvidenceUrl$outboundSchema,
-} from "./evidenceurl.js";
-import {
-  PageInfo,
-  PageInfo$inboundSchema,
-  PageInfo$Outbound,
-  PageInfo$outboundSchema,
-} from "./pageinfo.js";
+import { EvidenceUrl, EvidenceUrl$inboundSchema } from "./evidenceurl.js";
+import { PageInfo, PageInfo$inboundSchema } from "./pageinfo.js";
 
 export type PaginatedResponseEvidenceUrlResults = {
   data: Array<EvidenceUrl>;
@@ -40,31 +30,7 @@ export const PaginatedResponseEvidenceUrlResults$inboundSchema: z.ZodType<
   data: z.array(EvidenceUrl$inboundSchema),
   pageInfo: PageInfo$inboundSchema,
 });
-/** @internal */
-export type PaginatedResponseEvidenceUrlResults$Outbound = {
-  data: Array<EvidenceUrl$Outbound>;
-  pageInfo: PageInfo$Outbound;
-};
 
-/** @internal */
-export const PaginatedResponseEvidenceUrlResults$outboundSchema: z.ZodType<
-  PaginatedResponseEvidenceUrlResults$Outbound,
-  z.ZodTypeDef,
-  PaginatedResponseEvidenceUrlResults
-> = z.object({
-  data: z.array(EvidenceUrl$outboundSchema),
-  pageInfo: PageInfo$outboundSchema,
-});
-
-export function paginatedResponseEvidenceUrlResultsToJSON(
-  paginatedResponseEvidenceUrlResults: PaginatedResponseEvidenceUrlResults,
-): string {
-  return JSON.stringify(
-    PaginatedResponseEvidenceUrlResults$outboundSchema.parse(
-      paginatedResponseEvidenceUrlResults,
-    ),
-  );
-}
 export function paginatedResponseEvidenceUrlResultsFromJSON(
   jsonString: string,
 ): SafeParseResult<PaginatedResponseEvidenceUrlResults, SDKValidationError> {
@@ -84,29 +50,7 @@ export const PaginatedResponseEvidenceUrl$inboundSchema: z.ZodType<
 > = z.object({
   results: z.lazy(() => PaginatedResponseEvidenceUrlResults$inboundSchema),
 });
-/** @internal */
-export type PaginatedResponseEvidenceUrl$Outbound = {
-  results: PaginatedResponseEvidenceUrlResults$Outbound;
-};
 
-/** @internal */
-export const PaginatedResponseEvidenceUrl$outboundSchema: z.ZodType<
-  PaginatedResponseEvidenceUrl$Outbound,
-  z.ZodTypeDef,
-  PaginatedResponseEvidenceUrl
-> = z.object({
-  results: z.lazy(() => PaginatedResponseEvidenceUrlResults$outboundSchema),
-});
-
-export function paginatedResponseEvidenceUrlToJSON(
-  paginatedResponseEvidenceUrl: PaginatedResponseEvidenceUrl,
-): string {
-  return JSON.stringify(
-    PaginatedResponseEvidenceUrl$outboundSchema.parse(
-      paginatedResponseEvidenceUrl,
-    ),
-  );
-}
 export function paginatedResponseEvidenceUrlFromJSON(
   jsonString: string,
 ): SafeParseResult<PaginatedResponseEvidenceUrl, SDKValidationError> {

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