vanta-auditor-api-sdk 0.4.1 → 0.4.2

package/src/models/components/customfield.ts

@@ -17,19 +17,7 @@ export type CustomField = {
 /** @internal */
 export const Value$inboundSchema: z.ZodType<Value, z.ZodTypeDef, unknown> = z
   .union([z.string(), z.array(z.string())]);
-/** @internal */
-export type Value$Outbound = string | Array<string>;
 
-/** @internal */
-export const Value$outboundSchema: z.ZodType<
-  Value$Outbound,
-  z.ZodTypeDef,
-  Value
-> = z.union([z.string(), z.array(z.string())]);
-
-export function valueToJSON(value: Value): string {
-  return JSON.stringify(Value$outboundSchema.parse(value));
-}
 export function valueFromJSON(
   jsonString: string,
 ): SafeParseResult<Value, SDKValidationError> {
@@ -49,25 +37,7 @@ export const CustomField$inboundSchema: z.ZodType<
   label: z.string(),
   value: z.union([z.string(), z.array(z.string())]),
 });
-/** @internal */
-export type CustomField$Outbound = {
-  label: string;
-  value: string | Array<string>;
-};
 
-/** @internal */
-export const CustomField$outboundSchema: z.ZodType<
-  CustomField$Outbound,
-  z.ZodTypeDef,
-  CustomField
-> = z.object({
-  label: z.string(),
-  value: z.union([z.string(), z.array(z.string())]),
-});
-
-export function customFieldToJSON(customField: CustomField): string {
-  return JSON.stringify(CustomField$outboundSchema.parse(customField));
-}
 export function customFieldFromJSON(
   jsonString: string,
 ): SafeParseResult<CustomField, SDKValidationError> {

package/src/models/components/evidence.ts

@@ -9,18 +9,14 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   AuditEvidenceState,
   AuditEvidenceState$inboundSchema,
-  AuditEvidenceState$outboundSchema,
 } from "./auditevidencestate.js";
 import {
   AuditEvidenceType,
   AuditEvidenceType$inboundSchema,
-  AuditEvidenceType$outboundSchema,
 } from "./auditevidencetype.js";
 import {
   EvidenceControl,
   EvidenceControl$inboundSchema,
-  EvidenceControl$Outbound,
-  EvidenceControl$outboundSchema,
 } from "./evidencecontrol.js";
 
 export type Evidence = {
@@ -93,45 +89,7 @@ export const Evidence$inboundSchema: z.ZodType<
   relatedControls: z.array(EvidenceControl$inboundSchema),
   description: z.nullable(z.string()),
 });
-/** @internal */
-export type Evidence$Outbound = {
-  id: string;
-  externalId: string;
-  status: string;
-  name: string;
-  deletionDate: string | null;
-  creationDate: string;
-  statusUpdatedDate: string;
-  testStatus: string | null;
-  evidenceType: string;
-  evidenceId: string;
-  relatedControls: Array<EvidenceControl$Outbound>;
-  description: string | null;
-};
-
-/** @internal */
-export const Evidence$outboundSchema: z.ZodType<
-  Evidence$Outbound,
-  z.ZodTypeDef,
-  Evidence
-> = z.object({
-  id: z.string(),
-  externalId: z.string(),
-  status: AuditEvidenceState$outboundSchema,
-  name: z.string(),
-  deletionDate: z.nullable(z.date().transform(v => v.toISOString())),
-  creationDate: z.date().transform(v => v.toISOString()),
-  statusUpdatedDate: z.date().transform(v => v.toISOString()),
-  testStatus: z.nullable(z.string()),
-  evidenceType: AuditEvidenceType$outboundSchema,
-  evidenceId: z.string(),
-  relatedControls: z.array(EvidenceControl$outboundSchema),
-  description: z.nullable(z.string()),
-});
 
-export function evidenceToJSON(evidence: Evidence): string {
-  return JSON.stringify(Evidence$outboundSchema.parse(evidence));
-}
 export function evidenceFromJSON(
   jsonString: string,
 ): SafeParseResult<Evidence, SDKValidationError> {

package/src/models/components/evidencecontrol.ts

@@ -27,27 +27,7 @@ export const EvidenceControl$inboundSchema: z.ZodType<
   name: z.string(),
   sectionNames: z.array(z.string()),
 });
-/** @internal */
-export type EvidenceControl$Outbound = {
-  name: string;
-  sectionNames: Array<string>;
-};
-
-/** @internal */
-export const EvidenceControl$outboundSchema: z.ZodType<
-  EvidenceControl$Outbound,
-  z.ZodTypeDef,
-  EvidenceControl
-> = z.object({
-  name: z.string(),
-  sectionNames: z.array(z.string()),
-});
 
-export function evidenceControlToJSON(
-  evidenceControl: EvidenceControl,
-): string {
-  return JSON.stringify(EvidenceControl$outboundSchema.parse(evidenceControl));
-}
 export function evidenceControlFromJSON(
   jsonString: string,
 ): SafeParseResult<EvidenceControl, SDKValidationError> {

package/src/models/components/evidenceurl.ts

@@ -37,29 +37,7 @@ export const EvidenceUrl$inboundSchema: z.ZodType<
   filename: z.string(),
   isDownloadable: z.boolean(),
 });
-/** @internal */
-export type EvidenceUrl$Outbound = {
-  id: string;
-  url: string;
-  filename: string;
-  isDownloadable: boolean;
-};
-
-/** @internal */
-export const EvidenceUrl$outboundSchema: z.ZodType<
-  EvidenceUrl$Outbound,
-  z.ZodTypeDef,
-  EvidenceUrl
-> = z.object({
-  id: z.string(),
-  url: z.string(),
-  filename: z.string(),
-  isDownloadable: z.boolean(),
-});
 
-export function evidenceUrlToJSON(evidenceUrl: EvidenceUrl): string {
-  return JSON.stringify(EvidenceUrl$outboundSchema.parse(evidenceUrl));
-}
 export function evidenceUrlFromJSON(
   jsonString: string,
 ): SafeParseResult<EvidenceUrl, SDKValidationError> {

package/src/models/components/frameworkid.ts

@@ -45,8 +45,5 @@ export const FrameworkId = {
 export type FrameworkId = ClosedEnum<typeof FrameworkId>;
 
 /** @internal */
-export const FrameworkId$inboundSchema: z.ZodNativeEnum<typeof FrameworkId> = z
+export const FrameworkId$outboundSchema: z.ZodNativeEnum<typeof FrameworkId> = z
   .nativeEnum(FrameworkId);
-/** @internal */
-export const FrameworkId$outboundSchema: z.ZodNativeEnum<typeof FrameworkId> =
-  FrameworkId$inboundSchema;

package/src/models/components/frameworksection.ts

@@ -3,14 +3,7 @@
  */
 
 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 {
-  FrameworkId,
-  FrameworkId$inboundSchema,
-  FrameworkId$outboundSchema,
-} from "./frameworkid.js";
+import { FrameworkId, FrameworkId$outboundSchema } from "./frameworkid.js";
 
 export type FrameworkSectionFrameworkId = FrameworkId | string;
 
@@ -19,12 +12,6 @@ export type FrameworkSection = {
   sectionId: string;
 };
 
-/** @internal */
-export const FrameworkSectionFrameworkId$inboundSchema: z.ZodType<
-  FrameworkSectionFrameworkId,
-  z.ZodTypeDef,
-  unknown
-> = z.union([FrameworkId$inboundSchema, z.string()]);
 /** @internal */
 export type FrameworkSectionFrameworkId$Outbound = string | string;
 
@@ -44,25 +31,7 @@ export function frameworkSectionFrameworkIdToJSON(
     ),
   );
 }
-export function frameworkSectionFrameworkIdFromJSON(
-  jsonString: string,
-): SafeParseResult<FrameworkSectionFrameworkId, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FrameworkSectionFrameworkId$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FrameworkSectionFrameworkId' from JSON`,
-  );
-}
 
-/** @internal */
-export const FrameworkSection$inboundSchema: z.ZodType<
-  FrameworkSection,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  frameworkId: z.union([FrameworkId$inboundSchema, z.string()]),
-  sectionId: z.string(),
-});
 /** @internal */
 export type FrameworkSection$Outbound = {
   frameworkId: string | string;
@@ -86,12 +55,3 @@ export function frameworkSectionToJSON(
     FrameworkSection$outboundSchema.parse(frameworkSection),
   );
 }
-export function frameworkSectionFromJSON(
-  jsonString: string,
-): SafeParseResult<FrameworkSection, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => FrameworkSection$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'FrameworkSection' from JSON`,
-  );
-}

package/src/models/components/pageinfo.ts

@@ -40,29 +40,7 @@ export const PageInfo$inboundSchema: z.ZodType<
   hasPreviousPage: z.boolean(),
   startCursor: z.nullable(z.string()),
 });
-/** @internal */
-export type PageInfo$Outbound = {
-  endCursor: string | null;
-  hasNextPage: boolean;
-  hasPreviousPage: boolean;
-  startCursor: string | null;
-};
-
-/** @internal */
-export const PageInfo$outboundSchema: z.ZodType<
-  PageInfo$Outbound,
-  z.ZodTypeDef,
-  PageInfo
-> = z.object({
-  endCursor: z.nullable(z.string()),
-  hasNextPage: z.boolean(),
-  hasPreviousPage: z.boolean(),
-  startCursor: z.nullable(z.string()),
-});
 
-export function pageInfoToJSON(pageInfo: PageInfo): string {
-  return JSON.stringify(PageInfo$outboundSchema.parse(pageInfo));
-}
 export function pageInfoFromJSON(
   jsonString: string,
 ): SafeParseResult<PageInfo, SDKValidationError> {

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> {