vanta-auditor-api-sdk 0.1.1

package/src/lib/security.ts

@@ -0,0 +1,254 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as components from "../models/components/index.js";
+import { env } from "./env.js";
+
+type OAuth2PasswordFlow = {
+  username: string;
+  password?: string | undefined;
+  clientID: string;
+  clientSecret?: string | undefined;
+  tokenURL: string;
+};
+
+export enum SecurityErrorCode {
+  Incomplete = "incomplete",
+  UnrecognisedSecurityType = "unrecognized_security_type",
+}
+
+export class SecurityError extends Error {
+  constructor(
+    public code: SecurityErrorCode,
+    message: string,
+  ) {
+    super(message);
+    this.name = "SecurityError";
+  }
+
+  static incomplete(): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.Incomplete,
+      "Security requirements not met in order to perform the operation",
+    );
+  }
+  static unrecognizedType(type: string): SecurityError {
+    return new SecurityError(
+      SecurityErrorCode.UnrecognisedSecurityType,
+      `Unrecognised security type: ${type}`,
+    );
+  }
+}
+
+export type SecurityState = {
+  basic: { username?: string | undefined; password?: string | undefined };
+  headers: Record<string, string>;
+  queryParams: Record<string, string>;
+  cookies: Record<string, string>;
+  oauth2: ({ type: "password" } & OAuth2PasswordFlow) | { type: "none" };
+};
+
+type SecurityInputBasic = {
+  type: "http:basic";
+  value:
+    | { username?: string | undefined; password?: string | undefined }
+    | null
+    | undefined;
+};
+
+type SecurityInputBearer = {
+  type: "http:bearer";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputAPIKey = {
+  type: "apiKey:header" | "apiKey:query" | "apiKey:cookie";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOIDC = {
+  type: "openIdConnect";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2 = {
+  type: "oauth2";
+  value: string | null | undefined;
+  fieldName: string;
+};
+
+type SecurityInputOAuth2ClientCredentials = {
+  type: "oauth2:client_credentials";
+  value:
+    | { clientID?: string | undefined; clientSecret?: string | undefined }
+    | null
+    | undefined;
+};
+
+type SecurityInputOAuth2PasswordCredentials = {
+  type: "oauth2:password";
+  value:
+    | string
+    | null
+    | undefined;
+  fieldName: string;
+};
+
+type SecurityInputCustom = {
+  type: "http:custom";
+  value: any | null | undefined;
+  fieldName: string;
+};
+
+export type SecurityInput =
+  | SecurityInputBasic
+  | SecurityInputBearer
+  | SecurityInputAPIKey
+  | SecurityInputOAuth2
+  | SecurityInputOAuth2ClientCredentials
+  | SecurityInputOAuth2PasswordCredentials
+  | SecurityInputOIDC
+  | SecurityInputCustom;
+
+export function resolveSecurity(
+  ...options: SecurityInput[][]
+): SecurityState | null {
+  const state: SecurityState = {
+    basic: {},
+    headers: {},
+    queryParams: {},
+    cookies: {},
+    oauth2: { type: "none" },
+  };
+
+  const option = options.find((opts) => {
+    return opts.every((o) => {
+      if (o.value == null) {
+        return false;
+      } else if (o.type === "http:basic") {
+        return o.value.username != null || o.value.password != null;
+      } else if (o.type === "http:custom") {
+        return null;
+      } else if (o.type === "oauth2:password") {
+        return (
+          typeof o.value === "string" && !!o.value
+        );
+      } else if (o.type === "oauth2:client_credentials") {
+        return o.value.clientID != null || o.value.clientSecret != null;
+      } else if (typeof o.value === "string") {
+        return !!o.value;
+      } else {
+        throw new Error(
+          `Unrecognized security type: ${o.type} (value type: ${typeof o
+            .value})`,
+        );
+      }
+    });
+  });
+  if (option == null) {
+    return null;
+  }
+
+  option.forEach((spec) => {
+    if (spec.value == null) {
+      return;
+    }
+
+    const { type } = spec;
+
+    switch (type) {
+      case "apiKey:header":
+        state.headers[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:query":
+        state.queryParams[spec.fieldName] = spec.value;
+        break;
+      case "apiKey:cookie":
+        state.cookies[spec.fieldName] = spec.value;
+        break;
+      case "http:basic":
+        applyBasic(state, spec);
+        break;
+      case "http:custom":
+        break;
+      case "http:bearer":
+        applyBearer(state, spec);
+        break;
+      case "oauth2":
+        applyBearer(state, spec);
+        break;
+      case "oauth2:password":
+        applyBearer(state, spec);
+        break;
+      case "oauth2:client_credentials":
+        break;
+      case "openIdConnect":
+        applyBearer(state, spec);
+        break;
+      default:
+        spec satisfies never;
+        throw SecurityError.unrecognizedType(type);
+    }
+  });
+
+  return state;
+}
+
+function applyBasic(
+  state: SecurityState,
+  spec: SecurityInputBasic,
+) {
+  if (spec.value == null) {
+    return;
+  }
+
+  state.basic = spec.value;
+}
+
+function applyBearer(
+  state: SecurityState,
+  spec:
+    | SecurityInputBearer
+    | SecurityInputOAuth2
+    | SecurityInputOIDC
+    | SecurityInputOAuth2PasswordCredentials,
+) {
+  if (typeof spec.value !== "string" || !spec.value) {
+    return;
+  }
+
+  let value = spec.value;
+  if (value.slice(0, 7).toLowerCase() !== "bearer ") {
+    value = `Bearer ${value}`;
+  }
+
+  state.headers[spec.fieldName] = value;
+}
+
+export function resolveGlobalSecurity(
+  security: Partial<components.Security> | null | undefined,
+): SecurityState | null {
+  return resolveSecurity(
+    [
+      {
+        fieldName: "Authorization",
+        type: "http:bearer",
+        value: security?.bearerAuth ?? env().VANTA_BEARER_AUTH,
+      },
+    ],
+  );
+}
+
+export async function extractSecurity<
+  T extends string | Record<string, unknown>,
+>(sec: T | (() => Promise<T>) | undefined): Promise<T | undefined> {
+  if (sec == null) {
+    return;
+  }
+
+  return typeof sec === "function" ? sec() : sec;
+}

package/src/lib/url.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+const hasOwn = Object.prototype.hasOwnProperty;
+
+export type Params = Partial<Record<string, string | number>>;
+
+export function pathToFunc(
+  pathPattern: string,
+  options?: { charEncoding?: "percent" | "none" },
+): (params?: Params) => string {
+  const paramRE = /\{([a-zA-Z0-9_]+?)\}/g;
+
+  return function buildURLPath(params: Record<string, unknown> = {}): string {
+    return pathPattern.replace(paramRE, function (_, placeholder) {
+      if (!hasOwn.call(params, placeholder)) {
+        throw new Error(`Parameter '${placeholder}' is required`);
+      }
+
+      const value = params[placeholder];
+      if (typeof value !== "string" && typeof value !== "number") {
+        throw new Error(
+          `Parameter '${placeholder}' must be a string or number`,
+        );
+      }
+
+      return options?.charEncoding === "percent"
+        ? encodeURIComponent(`${value}`)
+        : `${value}`;
+    });
+  };
+}

package/src/models/components/addauditorinput.ts

@@ -0,0 +1,81 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type AddAuditorInput = {
+  /**
+   * Email of the new user.
+   */
+  email: string;
+  /**
+   * First name of the new user.
+   */
+  givenName: string;
+  /**
+   * Last name of the new user.
+   */
+  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;
+  givenName: string;
+  familyName: string;
+};
+
+/** @internal */
+export const AddAuditorInput$outboundSchema: z.ZodType<
+  AddAuditorInput$Outbound,
+  z.ZodTypeDef,
+  AddAuditorInput
+> = z.object({
+  email: z.string(),
+  givenName: z.string(),
+  familyName: z.string(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AddAuditorInput$ {
+  /** @deprecated use `AddAuditorInput$inboundSchema` instead. */
+  export const inboundSchema = AddAuditorInput$inboundSchema;
+  /** @deprecated use `AddAuditorInput$outboundSchema` instead. */
+  export const outboundSchema = AddAuditorInput$outboundSchema;
+  /** @deprecated use `AddAuditorInput$Outbound` instead. */
+  export type Outbound = AddAuditorInput$Outbound;
+}
+
+export function addAuditorInputToJSON(
+  addAuditorInput: AddAuditorInput,
+): 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

@@ -0,0 +1,83 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type AddCommentInput = {
+  /**
+   * Text value of the comment
+   */
+  text: string;
+  /**
+   * Email of author. Must match an existing Vanta user and the user must exist under the Audit Firm who is making the API request
+   */
+  email: string;
+  /**
+   * When the comment was created in the external system
+   */
+  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;
+  email: string;
+  creationDate: string;
+};
+
+/** @internal */
+export const AddCommentInput$outboundSchema: z.ZodType<
+  AddCommentInput$Outbound,
+  z.ZodTypeDef,
+  AddCommentInput
+> = z.object({
+  text: z.string(),
+  email: z.string(),
+  creationDate: z.date().transform(v => v.toISOString()),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AddCommentInput$ {
+  /** @deprecated use `AddCommentInput$inboundSchema` instead. */
+  export const inboundSchema = AddCommentInput$inboundSchema;
+  /** @deprecated use `AddCommentInput$outboundSchema` instead. */
+  export const outboundSchema = AddCommentInput$outboundSchema;
+  /** @deprecated use `AddCommentInput$Outbound` instead. */
+  export type Outbound = AddCommentInput$Outbound;
+}
+
+export function addCommentInputToJSON(
+  addCommentInput: AddCommentInput,
+): 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

@@ -0,0 +1,167 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type Audit = {
+  /**
+   * The unique identifier for the audit.
+   */
+  id: string;
+  /**
+   * The domain name of the customer organization being audited (e.g. vanta.com)
+   */
+  customerOrganizationName: string;
+  /**
+   * The human readable name of the customer organization being audited (e.g. Vanta)
+   */
+  customerDisplayName: string | null;
+  /**
+   * The uuid of the customer organization being audited
+   */
+  customerOrganizationId: string;
+  /**
+   * The start of the audit window. This is also when data collection for audit starts.
+   */
+  auditStartDate: Date;
+  /**
+   * The end of the audit window.
+   */
+  auditEndDate: Date;
+  /**
+   * Timestamp at which auditors gain access to the audit. Occurs before the audit window begins
+   */
+  earlyAccessStartsDate: Date | null;
+  /**
+   * The name of the framework for the audit
+   */
+  framework: string;
+  /**
+   * Emails of auditors with access to audit
+   */
+  allowAuditorEmails: Array<string>;
+  /**
+   * Set to true if all auditors in audit firm have access
+   */
+  allowAllAuditors: boolean;
+  /**
+   * Timestamp when the audit was deleted
+   */
+  deletionDate: Date | null;
+  /**
+   * Timestamp when the audit was created
+   */
+  creationDate: Date;
+  /**
+   * Timestamp when the audit was updated
+   */
+  modificationDate: Date | null;
+  /**
+   * Timestamp when the audit was marked completed, and report was uploaded
+   */
+  completionDate: Date | null;
+};
+
+/** @internal */
+export const Audit$inboundSchema: z.ZodType<Audit, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    customerOrganizationName: z.string(),
+    customerDisplayName: z.nullable(z.string()),
+    customerOrganizationId: z.string(),
+    auditStartDate: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ),
+    auditEndDate: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ),
+    earlyAccessStartsDate: z.nullable(
+      z.string().datetime({ offset: true }).transform(v => new Date(v)),
+    ),
+    framework: z.string(),
+    allowAuditorEmails: z.array(z.string()),
+    allowAllAuditors: z.boolean(),
+    deletionDate: z.nullable(
+      z.string().datetime({ offset: true }).transform(v => new Date(v)),
+    ),
+    creationDate: z.string().datetime({ offset: true }).transform(v =>
+      new Date(v)
+    ),
+    modificationDate: z.nullable(
+      z.string().datetime({ offset: true }).transform(v => new Date(v)),
+    ),
+    completionDate: z.nullable(
+      z.string().datetime({ offset: true }).transform(v => new Date(v)),
+    ),
+  });
+
+/** @internal */
+export type Audit$Outbound = {
+  id: string;
+  customerOrganizationName: string;
+  customerDisplayName: string | null;
+  customerOrganizationId: string;
+  auditStartDate: string;
+  auditEndDate: string;
+  earlyAccessStartsDate: string | null;
+  framework: string;
+  allowAuditorEmails: Array<string>;
+  allowAllAuditors: boolean;
+  deletionDate: string | null;
+  creationDate: string;
+  modificationDate: string | null;
+  completionDate: string | null;
+};
+
+/** @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()),
+  earlyAccessStartsDate: 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())),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Audit$ {
+  /** @deprecated use `Audit$inboundSchema` instead. */
+  export const inboundSchema = Audit$inboundSchema;
+  /** @deprecated use `Audit$outboundSchema` instead. */
+  export const outboundSchema = Audit$outboundSchema;
+  /** @deprecated use `Audit$Outbound` instead. */
+  export type Outbound = Audit$Outbound;
+}
+
+export function auditToJSON(audit: Audit): string {
+  return JSON.stringify(Audit$outboundSchema.parse(audit));
+}
+
+export function auditFromJSON(
+  jsonString: string,
+): SafeParseResult<Audit, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Audit$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Audit' from JSON`,
+  );
+}

package/src/models/components/auditevidencestate.ts

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const AuditEvidenceState = {
+  Accepted: "Accepted",
+  Flagged: "Flagged",
+  Initialized: "Initialized",
+  Na: "NA",
+  NotReadyForAudit: "Not ready for audit",
+  ReadyForAudit: "Ready for audit",
+} as const;
+export type AuditEvidenceState = ClosedEnum<typeof AuditEvidenceState>;
+
+/** @internal */
+export const AuditEvidenceState$inboundSchema: z.ZodNativeEnum<
+  typeof AuditEvidenceState
+> = z.nativeEnum(AuditEvidenceState);
+
+/** @internal */
+export const AuditEvidenceState$outboundSchema: z.ZodNativeEnum<
+  typeof AuditEvidenceState
+> = AuditEvidenceState$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AuditEvidenceState$ {
+  /** @deprecated use `AuditEvidenceState$inboundSchema` instead. */
+  export const inboundSchema = AuditEvidenceState$inboundSchema;
+  /** @deprecated use `AuditEvidenceState$outboundSchema` instead. */
+  export const outboundSchema = AuditEvidenceState$outboundSchema;
+}

package/src/models/components/auditevidencetype.ts

@@ -0,0 +1,34 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const AuditEvidenceType = {
+  EvidenceRequest: "Evidence Request",
+  Policy: "Policy",
+  Test: "Test",
+} as const;
+export type AuditEvidenceType = ClosedEnum<typeof AuditEvidenceType>;
+
+/** @internal */
+export const AuditEvidenceType$inboundSchema: z.ZodNativeEnum<
+  typeof AuditEvidenceType
+> = z.nativeEnum(AuditEvidenceType);
+
+/** @internal */
+export const AuditEvidenceType$outboundSchema: z.ZodNativeEnum<
+  typeof AuditEvidenceType
+> = AuditEvidenceType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AuditEvidenceType$ {
+  /** @deprecated use `AuditEvidenceType$inboundSchema` instead. */
+  export const inboundSchema = AuditEvidenceType$inboundSchema;
+  /** @deprecated use `AuditEvidenceType$outboundSchema` instead. */
+  export const outboundSchema = AuditEvidenceType$outboundSchema;
+}