vanta-auditor-api-sdk 0.4.1 → 0.4.2

package/src/models/components/addauditorinput.ts

@@ -3,9 +3,6 @@
  */
 
 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 AddAuditorInput = {
   /**
@@ -22,16 +19,6 @@ export type AddAuditorInput = {
   familyName: string;
 };
 
-/** @internal */
-export const AddAuditorInput$inboundSchema: z.ZodType<
-  AddAuditorInput,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  email: z.string(),
-  givenName: z.string(),
-  familyName: z.string(),
-});
 /** @internal */
 export type AddAuditorInput$Outbound = {
   email: string;
@@ -55,12 +42,3 @@ export function addAuditorInputToJSON(
 ): string {
   return JSON.stringify(AddAuditorInput$outboundSchema.parse(addAuditorInput));
 }
-export function addAuditorInputFromJSON(
-  jsonString: string,
-): SafeParseResult<AddAuditorInput, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AddAuditorInput$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AddAuditorInput' from JSON`,
-  );
-}

package/src/models/components/addcommentinput.ts

@@ -3,9 +3,6 @@
  */
 
 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 AddCommentInput = {
   /**
@@ -22,18 +19,6 @@ export type AddCommentInput = {
   creationDate: Date;
 };
 
-/** @internal */
-export const AddCommentInput$inboundSchema: z.ZodType<
-  AddCommentInput,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  text: z.string(),
-  email: z.string(),
-  creationDate: z.string().datetime({ offset: true }).transform(v =>
-    new Date(v)
-  ),
-});
 /** @internal */
 export type AddCommentInput$Outbound = {
   text: string;
@@ -57,12 +42,3 @@ export function addCommentInputToJSON(
 ): string {
   return JSON.stringify(AddCommentInput$outboundSchema.parse(addCommentInput));
 }
-export function addCommentInputFromJSON(
-  jsonString: string,
-): SafeParseResult<AddCommentInput, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AddCommentInput$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AddCommentInput' from JSON`,
-  );
-}

package/src/models/components/audit.ts

@@ -6,11 +6,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 {
-  AuditFocus,
-  AuditFocus$inboundSchema,
-  AuditFocus$outboundSchema,
-} from "./auditfocus.js";
+import { AuditFocus, AuditFocus$inboundSchema } from "./auditfocus.js";
 
 export type Audit = {
   /**
@@ -105,51 +101,7 @@ export const Audit$inboundSchema: z.ZodType<Audit, z.ZodTypeDef, unknown> = z
     ),
     auditFocus: AuditFocus$inboundSchema,
   });
-/** @internal */
-export type Audit$Outbound = {
-  id: string;
-  customerOrganizationName: string;
-  customerDisplayName: string | null;
-  customerOrganizationId: string;
-  auditStartDate: string;
-  auditEndDate: string;
-  earlyAccessStartsAt: string | null;
-  framework: string;
-  allowAuditorEmails: Array<string>;
-  allowAllAuditors: boolean;
-  deletionDate: string | null;
-  creationDate: string;
-  modificationDate: string | null;
-  completionDate: string | null;
-  auditFocus: string;
-};
 
-/** @internal */
-export const Audit$outboundSchema: z.ZodType<
-  Audit$Outbound,
-  z.ZodTypeDef,
-  Audit
-> = z.object({
-  id: z.string(),
-  customerOrganizationName: z.string(),
-  customerDisplayName: z.nullable(z.string()),
-  customerOrganizationId: z.string(),
-  auditStartDate: z.date().transform(v => v.toISOString()),
-  auditEndDate: z.date().transform(v => v.toISOString()),
-  earlyAccessStartsAt: z.nullable(z.date().transform(v => v.toISOString())),
-  framework: z.string(),
-  allowAuditorEmails: z.array(z.string()),
-  allowAllAuditors: z.boolean(),
-  deletionDate: z.nullable(z.date().transform(v => v.toISOString())),
-  creationDate: z.date().transform(v => v.toISOString()),
-  modificationDate: z.nullable(z.date().transform(v => v.toISOString())),
-  completionDate: z.nullable(z.date().transform(v => v.toISOString())),
-  auditFocus: AuditFocus$outboundSchema,
-});
-
-export function auditToJSON(audit: Audit): string {
-  return JSON.stringify(Audit$outboundSchema.parse(audit));
-}
 export function auditFromJSON(
   jsonString: string,
 ): SafeParseResult<Audit, SDKValidationError> {

package/src/models/components/auditevidencestate.ts

@@ -19,7 +19,3 @@ export type AuditEvidenceState = ClosedEnum<typeof AuditEvidenceState>;
 export const AuditEvidenceState$inboundSchema: z.ZodNativeEnum<
   typeof AuditEvidenceState
 > = z.nativeEnum(AuditEvidenceState);
-/** @internal */
-export const AuditEvidenceState$outboundSchema: z.ZodNativeEnum<
-  typeof AuditEvidenceState
-> = AuditEvidenceState$inboundSchema;

package/src/models/components/auditevidencetype.ts

@@ -16,7 +16,3 @@ export type AuditEvidenceType = ClosedEnum<typeof AuditEvidenceType>;
 export const AuditEvidenceType$inboundSchema: z.ZodNativeEnum<
   typeof AuditEvidenceType
 > = z.nativeEnum(AuditEvidenceType);
-/** @internal */
-export const AuditEvidenceType$outboundSchema: z.ZodNativeEnum<
-  typeof AuditEvidenceType
-> = AuditEvidenceType$inboundSchema;

package/src/models/components/auditevidenceupdateinput.ts

@@ -3,12 +3,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 {
   AuditorEnabledStateTransition,
-  AuditorEnabledStateTransition$inboundSchema,
   AuditorEnabledStateTransition$outboundSchema,
 } from "./auditorenabledstatetransition.js";
 
@@ -24,15 +20,6 @@ export type AuditEvidenceUpdateInput = {
   statusUpdate?: StatusUpdate | undefined;
 };
 
-/** @internal */
-export const StatusUpdate$inboundSchema: z.ZodType<
-  StatusUpdate,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  auditorEmail: z.string(),
-  stateTransition: AuditorEnabledStateTransition$inboundSchema,
-});
 /** @internal */
 export type StatusUpdate$Outbound = {
   auditorEmail: string;
@@ -52,24 +39,7 @@ export const StatusUpdate$outboundSchema: z.ZodType<
 export function statusUpdateToJSON(statusUpdate: StatusUpdate): string {
   return JSON.stringify(StatusUpdate$outboundSchema.parse(statusUpdate));
 }
-export function statusUpdateFromJSON(
-  jsonString: string,
-): SafeParseResult<StatusUpdate, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => StatusUpdate$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'StatusUpdate' from JSON`,
-  );
-}
 
-/** @internal */
-export const AuditEvidenceUpdateInput$inboundSchema: z.ZodType<
-  AuditEvidenceUpdateInput,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  statusUpdate: z.lazy(() => StatusUpdate$inboundSchema).optional(),
-});
 /** @internal */
 export type AuditEvidenceUpdateInput$Outbound = {
   statusUpdate?: StatusUpdate$Outbound | undefined;
@@ -91,12 +61,3 @@ export function auditEvidenceUpdateInputToJSON(
     AuditEvidenceUpdateInput$outboundSchema.parse(auditEvidenceUpdateInput),
   );
 }
-export function auditEvidenceUpdateInputFromJSON(
-  jsonString: string,
-): SafeParseResult<AuditEvidenceUpdateInput, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => AuditEvidenceUpdateInput$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'AuditEvidenceUpdateInput' from JSON`,
-  );
-}

package/src/models/components/auditfocus.ts

@@ -14,6 +14,3 @@ export type AuditFocus = ClosedEnum<typeof AuditFocus>;
 /** @internal */
 export const AuditFocus$inboundSchema: z.ZodNativeEnum<typeof AuditFocus> = z
   .nativeEnum(AuditFocus);
-/** @internal */
-export const AuditFocus$outboundSchema: z.ZodNativeEnum<typeof AuditFocus> =
-  AuditFocus$inboundSchema;

package/src/models/components/auditor.ts

@@ -36,31 +36,7 @@ export const Auditor$inboundSchema: z.ZodType<Auditor, z.ZodTypeDef, unknown> =
     givenName: z.string(),
     familyName: z.string(),
   });
-/** @internal */
-export type Auditor$Outbound = {
-  id: string;
-  organizationId: string;
-  email: string;
-  givenName: string;
-  familyName: string;
-};
 
-/** @internal */
-export const Auditor$outboundSchema: z.ZodType<
-  Auditor$Outbound,
-  z.ZodTypeDef,
-  Auditor
-> = z.object({
-  id: z.string(),
-  organizationId: z.string(),
-  email: z.string(),
-  givenName: z.string(),
-  familyName: z.string(),
-});
-
-export function auditorToJSON(auditor: Auditor): string {
-  return JSON.stringify(Auditor$outboundSchema.parse(auditor));
-}
 export function auditorFromJSON(
   jsonString: string,
 ): SafeParseResult<Auditor, SDKValidationError> {

package/src/models/components/auditorcontrol.ts

@@ -6,23 +6,9 @@ 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 {
-  ControlSource,
-  ControlSource$inboundSchema,
-  ControlSource$outboundSchema,
-} from "./controlsource.js";
-import {
-  CustomField,
-  CustomField$inboundSchema,
-  CustomField$Outbound,
-  CustomField$outboundSchema,
-} from "./customfield.js";
-import {
-  Section,
-  Section$inboundSchema,
-  Section$Outbound,
-  Section$outboundSchema,
-} from "./section.js";
+import { ControlSource, ControlSource$inboundSchema } from "./controlsource.js";
+import { CustomField, CustomField$inboundSchema } from "./customfield.js";
+import { Section, Section$inboundSchema } from "./section.js";
 
 /**
  * The control's owner.
@@ -93,27 +79,7 @@ export const Owner$inboundSchema: z.ZodType<Owner, z.ZodTypeDef, unknown> = z
     displayName: z.string(),
     emailAddress: z.string(),
   });
-/** @internal */
-export type Owner$Outbound = {
-  id: string;
-  displayName: string;
-  emailAddress: string;
-};
 
-/** @internal */
-export const Owner$outboundSchema: z.ZodType<
-  Owner$Outbound,
-  z.ZodTypeDef,
-  Owner
-> = z.object({
-  id: z.string(),
-  displayName: z.string(),
-  emailAddress: z.string(),
-});
-
-export function ownerToJSON(owner: Owner): string {
-  return JSON.stringify(Owner$outboundSchema.parse(owner));
-}
 export function ownerFromJSON(
   jsonString: string,
 ): SafeParseResult<Owner, SDKValidationError> {
@@ -142,43 +108,7 @@ export const AuditorControl$inboundSchema: z.ZodType<
   framework: z.string(),
   sections: z.array(Section$inboundSchema),
 });
-/** @internal */
-export type AuditorControl$Outbound = {
-  id: string;
-  externalId: string | null;
-  name: string;
-  description: string;
-  source: string;
-  domains: Array<string>;
-  owner: Owner$Outbound | null;
-  role?: string | null | undefined;
-  customFields: Array<CustomField$Outbound>;
-  framework: string;
-  sections: Array<Section$Outbound>;
-};
-
-/** @internal */
-export const AuditorControl$outboundSchema: z.ZodType<
-  AuditorControl$Outbound,
-  z.ZodTypeDef,
-  AuditorControl
-> = z.object({
-  id: z.string(),
-  externalId: z.nullable(z.string()),
-  name: z.string(),
-  description: z.string(),
-  source: ControlSource$outboundSchema,
-  domains: z.array(z.string()),
-  owner: z.nullable(z.lazy(() => Owner$outboundSchema)),
-  role: z.nullable(z.string()).optional(),
-  customFields: z.array(CustomField$outboundSchema),
-  framework: z.string(),
-  sections: z.array(Section$outboundSchema),
-});
 
-export function auditorControlToJSON(auditorControl: AuditorControl): string {
-  return JSON.stringify(AuditorControl$outboundSchema.parse(auditorControl));
-}
 export function auditorControlFromJSON(
   jsonString: string,
 ): SafeParseResult<AuditorControl, SDKValidationError> {

package/src/models/components/auditorenabledstatetransition.ts

@@ -16,11 +16,7 @@ export type AuditorEnabledStateTransition = ClosedEnum<
   typeof AuditorEnabledStateTransition
 >;
 
-/** @internal */
-export const AuditorEnabledStateTransition$inboundSchema: z.ZodNativeEnum<
-  typeof AuditorEnabledStateTransition
-> = z.nativeEnum(AuditorEnabledStateTransition);
 /** @internal */
 export const AuditorEnabledStateTransition$outboundSchema: z.ZodNativeEnum<
   typeof AuditorEnabledStateTransition
-> = AuditorEnabledStateTransition$inboundSchema;
+> = z.nativeEnum(AuditorEnabledStateTransition);

package/src/models/components/comment.ts

@@ -55,35 +55,7 @@ export const Comment$inboundSchema: z.ZodType<Comment, z.ZodTypeDef, unknown> =
     ),
     email: z.nullable(z.string()),
   });
-/** @internal */
-export type Comment$Outbound = {
-  id: string;
-  auditEvidenceId: string;
-  text: string;
-  creationDate: string;
-  modificationDate: string | null;
-  deletionDate: string | null;
-  email: string | null;
-};
-
-/** @internal */
-export const Comment$outboundSchema: z.ZodType<
-  Comment$Outbound,
-  z.ZodTypeDef,
-  Comment
-> = z.object({
-  id: z.string(),
-  auditEvidenceId: z.string(),
-  text: z.string(),
-  creationDate: z.date().transform(v => v.toISOString()),
-  modificationDate: z.nullable(z.date().transform(v => v.toISOString())),
-  deletionDate: z.nullable(z.date().transform(v => v.toISOString())),
-  email: z.nullable(z.string()),
-});
 
-export function commentToJSON(comment: Comment): string {
-  return JSON.stringify(Comment$outboundSchema.parse(comment));
-}
 export function commentFromJSON(
   jsonString: string,
 ): SafeParseResult<Comment, SDKValidationError> {

package/src/models/components/control.ts

@@ -6,17 +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 {
-  ControlSource,
-  ControlSource$inboundSchema,
-  ControlSource$outboundSchema,
-} from "./controlsource.js";
-import {
-  CustomField,
-  CustomField$inboundSchema,
-  CustomField$Outbound,
-  CustomField$outboundSchema,
-} from "./customfield.js";
+import { ControlSource, ControlSource$inboundSchema } from "./controlsource.js";
+import { CustomField, CustomField$inboundSchema } from "./customfield.js";
 
 /**
  * The control's owner.
@@ -82,27 +73,7 @@ export const ControlOwner$inboundSchema: z.ZodType<
   displayName: z.string(),
   emailAddress: z.string(),
 });
-/** @internal */
-export type ControlOwner$Outbound = {
-  id: string;
-  displayName: string;
-  emailAddress: string;
-};
 
-/** @internal */
-export const ControlOwner$outboundSchema: z.ZodType<
-  ControlOwner$Outbound,
-  z.ZodTypeDef,
-  ControlOwner
-> = z.object({
-  id: z.string(),
-  displayName: z.string(),
-  emailAddress: z.string(),
-});
-
-export function controlOwnerToJSON(controlOwner: ControlOwner): string {
-  return JSON.stringify(ControlOwner$outboundSchema.parse(controlOwner));
-}
 export function controlOwnerFromJSON(
   jsonString: string,
 ): SafeParseResult<ControlOwner, SDKValidationError> {
@@ -126,39 +97,7 @@ export const Control$inboundSchema: z.ZodType<Control, z.ZodTypeDef, unknown> =
     role: z.nullable(z.string()).optional(),
     customFields: z.array(CustomField$inboundSchema),
   });
-/** @internal */
-export type Control$Outbound = {
-  id: string;
-  externalId: string | null;
-  name: string;
-  description: string;
-  source: string;
-  domains: Array<string>;
-  owner: ControlOwner$Outbound | null;
-  role?: string | null | undefined;
-  customFields: Array<CustomField$Outbound>;
-};
 
-/** @internal */
-export const Control$outboundSchema: z.ZodType<
-  Control$Outbound,
-  z.ZodTypeDef,
-  Control
-> = z.object({
-  id: z.string(),
-  externalId: z.nullable(z.string()),
-  name: z.string(),
-  description: z.string(),
-  source: ControlSource$outboundSchema,
-  domains: z.array(z.string()),
-  owner: z.nullable(z.lazy(() => ControlOwner$outboundSchema)),
-  role: z.nullable(z.string()).optional(),
-  customFields: z.array(CustomField$outboundSchema),
-});
-
-export function controlToJSON(control: Control): string {
-  return JSON.stringify(Control$outboundSchema.parse(control));
-}
 export function controlFromJSON(
   jsonString: string,
 ): SafeParseResult<Control, SDKValidationError> {

package/src/models/components/controldomain.ts

@@ -48,11 +48,7 @@ export const ControlDomain = {
 } as const;
 export type ControlDomain = ClosedEnum<typeof ControlDomain>;
 
-/** @internal */
-export const ControlDomain$inboundSchema: z.ZodNativeEnum<
-  typeof ControlDomain
-> = z.nativeEnum(ControlDomain);
 /** @internal */
 export const ControlDomain$outboundSchema: z.ZodNativeEnum<
   typeof ControlDomain
-> = ControlDomain$inboundSchema;
+> = z.nativeEnum(ControlDomain);

package/src/models/components/controlsource.ts

@@ -15,7 +15,3 @@ export type ControlSource = ClosedEnum<typeof ControlSource>;
 export const ControlSource$inboundSchema: z.ZodNativeEnum<
   typeof ControlSource
 > = z.nativeEnum(ControlSource);
-/** @internal */
-export const ControlSource$outboundSchema: z.ZodNativeEnum<
-  typeof ControlSource
-> = ControlSource$inboundSchema;

package/src/models/components/createcustomcontrolinput.ts

@@ -3,18 +3,13 @@
  */
 
 import * as z from "zod/v3";
-import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   ControlDomain,
-  ControlDomain$inboundSchema,
   ControlDomain$outboundSchema,
 } from "./controldomain.js";
 import {
   FrameworkSection,
-  FrameworkSection$inboundSchema,
   FrameworkSection$Outbound,
   FrameworkSection$outboundSchema,
 } from "./frameworksection.js";
@@ -70,29 +65,10 @@ export type CreateCustomControlInput = {
 };
 
 /** @internal */
-export const Role$inboundSchema: z.ZodNativeEnum<typeof Role> = z.nativeEnum(
+export const Role$outboundSchema: z.ZodNativeEnum<typeof Role> = z.nativeEnum(
   Role,
 );
-/** @internal */
-export const Role$outboundSchema: z.ZodNativeEnum<typeof Role> =
-  Role$inboundSchema;
 
-/** @internal */
-export const CreateCustomControlInput$inboundSchema: z.ZodType<
-  CreateCustomControlInput,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  externalId: z.string(),
-  name: z.nullable(z.string()),
-  description: z.string(),
-  effectiveDate: z.string().datetime({ offset: true }).transform(v =>
-    new Date(v)
-  ),
-  category: ControlDomain$inboundSchema,
-  sections: z.nullable(z.array(FrameworkSection$inboundSchema)).optional(),
-  role: z.nullable(Role$inboundSchema).optional(),
-});
 /** @internal */
 export type CreateCustomControlInput$Outbound = {
   externalId: string;
@@ -126,12 +102,3 @@ export function createCustomControlInputToJSON(
     CreateCustomControlInput$outboundSchema.parse(createCustomControlInput),
   );
 }
-export function createCustomControlInputFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateCustomControlInput, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateCustomControlInput$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateCustomControlInput' from JSON`,
-  );
-}

package/src/models/components/createcustomevidencerequestinput.ts

@@ -3,12 +3,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 {
   RecurrenceDuration,
-  RecurrenceDuration$inboundSchema,
   RecurrenceDuration$outboundSchema,
 } from "./recurrenceduration.js";
 
@@ -37,20 +33,6 @@ export type CreateCustomEvidenceRequestInput = {
   auditorEmail: string;
 };
 
-/** @internal */
-export const CreateCustomEvidenceRequestInput$inboundSchema: z.ZodType<
-  CreateCustomEvidenceRequestInput,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  controlIds: z.array(z.string()),
-  title: z.string(),
-  description: z.string(),
-  cadence: RecurrenceDuration$inboundSchema,
-  reminderWindow: RecurrenceDuration$inboundSchema,
-  isRestricted: z.boolean(),
-  auditorEmail: z.string(),
-});
 /** @internal */
 export type CreateCustomEvidenceRequestInput$Outbound = {
   controlIds: Array<string>;
@@ -86,12 +68,3 @@ export function createCustomEvidenceRequestInputToJSON(
     ),
   );
 }
-export function createCustomEvidenceRequestInputFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateCustomEvidenceRequestInput, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateCustomEvidenceRequestInput$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateCustomEvidenceRequestInput' from JSON`,
-  );
-}

package/src/models/components/customevidencerequest.ts

@@ -9,7 +9,6 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
   RecurrenceDuration,
   RecurrenceDuration$inboundSchema,
-  RecurrenceDuration$outboundSchema,
 } from "./recurrenceduration.js";
 
 export type CustomEvidenceRequest = {
@@ -51,39 +50,7 @@ export const CustomEvidenceRequest$inboundSchema: z.ZodType<
   reminderWindow: RecurrenceDuration$inboundSchema,
   isRestricted: z.boolean(),
 });
-/** @internal */
-export type CustomEvidenceRequest$Outbound = {
-  id: string;
-  controlIds: Array<string>;
-  title: string;
-  description: string;
-  cadence: string;
-  reminderWindow: string;
-  isRestricted: boolean;
-};
 
-/** @internal */
-export const CustomEvidenceRequest$outboundSchema: z.ZodType<
-  CustomEvidenceRequest$Outbound,
-  z.ZodTypeDef,
-  CustomEvidenceRequest
-> = z.object({
-  id: z.string(),
-  controlIds: z.array(z.string()),
-  title: z.string(),
-  description: z.string(),
-  cadence: RecurrenceDuration$outboundSchema,
-  reminderWindow: RecurrenceDuration$outboundSchema,
-  isRestricted: z.boolean(),
-});
-
-export function customEvidenceRequestToJSON(
-  customEvidenceRequest: CustomEvidenceRequest,
-): string {
-  return JSON.stringify(
-    CustomEvidenceRequest$outboundSchema.parse(customEvidenceRequest),
-  );
-}
 export function customEvidenceRequestFromJSON(
   jsonString: string,
 ): SafeParseResult<CustomEvidenceRequest, SDKValidationError> {