@documenso/sdk-typescript 0.8.1 → 0.9.0

package/src/models/errors/envelopecancel.ts

@@ -0,0 +1,498 @@
+/*
+ * 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 { DocumensoError } from "./documensoerror.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
+
+export type EnvelopeCancelInternalServerErrorIssue = {
+  message: string;
+};
+
+/**
+ * Internal server error
+ */
+export type EnvelopeCancelInternalServerErrorData = {
+  message: string;
+  code: string;
+  issues?: Array<EnvelopeCancelInternalServerErrorIssue> | undefined;
+};
+
+/**
+ * Internal server error
+ */
+export class EnvelopeCancelInternalServerError extends DocumensoError {
+  code: string;
+  issues?: Array<EnvelopeCancelInternalServerErrorIssue> | undefined;
+
+  /** The original data that was passed to this error instance. */
+  data$: EnvelopeCancelInternalServerErrorData;
+
+  constructor(
+    err: EnvelopeCancelInternalServerErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.code = err.code;
+    if (err.issues != null) this.issues = err.issues;
+
+    this.name = "EnvelopeCancelInternalServerError";
+  }
+}
+
+export type EnvelopeCancelForbiddenIssue = {
+  message: string;
+};
+
+/**
+ * Insufficient access
+ */
+export type EnvelopeCancelForbiddenErrorData = {
+  message: string;
+  code: string;
+  issues?: Array<EnvelopeCancelForbiddenIssue> | undefined;
+};
+
+/**
+ * Insufficient access
+ */
+export class EnvelopeCancelForbiddenError extends DocumensoError {
+  code: string;
+  issues?: Array<EnvelopeCancelForbiddenIssue> | undefined;
+
+  /** The original data that was passed to this error instance. */
+  data$: EnvelopeCancelForbiddenErrorData;
+
+  constructor(
+    err: EnvelopeCancelForbiddenErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.code = err.code;
+    if (err.issues != null) this.issues = err.issues;
+
+    this.name = "EnvelopeCancelForbiddenError";
+  }
+}
+
+export type EnvelopeCancelUnauthorizedIssue = {
+  message: string;
+};
+
+/**
+ * Authorization not provided
+ */
+export type EnvelopeCancelUnauthorizedErrorData = {
+  message: string;
+  code: string;
+  issues?: Array<EnvelopeCancelUnauthorizedIssue> | undefined;
+};
+
+/**
+ * Authorization not provided
+ */
+export class EnvelopeCancelUnauthorizedError extends DocumensoError {
+  code: string;
+  issues?: Array<EnvelopeCancelUnauthorizedIssue> | undefined;
+
+  /** The original data that was passed to this error instance. */
+  data$: EnvelopeCancelUnauthorizedErrorData;
+
+  constructor(
+    err: EnvelopeCancelUnauthorizedErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.code = err.code;
+    if (err.issues != null) this.issues = err.issues;
+
+    this.name = "EnvelopeCancelUnauthorizedError";
+  }
+}
+
+export type EnvelopeCancelBadRequestIssue = {
+  message: string;
+};
+
+/**
+ * Invalid input data
+ */
+export type EnvelopeCancelBadRequestErrorData = {
+  message: string;
+  code: string;
+  issues?: Array<EnvelopeCancelBadRequestIssue> | undefined;
+};
+
+/**
+ * Invalid input data
+ */
+export class EnvelopeCancelBadRequestError extends DocumensoError {
+  code: string;
+  issues?: Array<EnvelopeCancelBadRequestIssue> | undefined;
+
+  /** The original data that was passed to this error instance. */
+  data$: EnvelopeCancelBadRequestErrorData;
+
+  constructor(
+    err: EnvelopeCancelBadRequestErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
+    const message = err.message || `API error occurred: ${JSON.stringify(err)}`;
+    super(message, httpMeta);
+    this.data$ = err;
+    this.code = err.code;
+    if (err.issues != null) this.issues = err.issues;
+
+    this.name = "EnvelopeCancelBadRequestError";
+  }
+}
+
+/** @internal */
+export const EnvelopeCancelInternalServerErrorIssue$inboundSchema: z.ZodType<
+  EnvelopeCancelInternalServerErrorIssue,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+});
+/** @internal */
+export type EnvelopeCancelInternalServerErrorIssue$Outbound = {
+  message: string;
+};
+
+/** @internal */
+export const EnvelopeCancelInternalServerErrorIssue$outboundSchema: z.ZodType<
+  EnvelopeCancelInternalServerErrorIssue$Outbound,
+  z.ZodTypeDef,
+  EnvelopeCancelInternalServerErrorIssue
+> = z.object({
+  message: z.string(),
+});
+
+export function envelopeCancelInternalServerErrorIssueToJSON(
+  envelopeCancelInternalServerErrorIssue:
+    EnvelopeCancelInternalServerErrorIssue,
+): string {
+  return JSON.stringify(
+    EnvelopeCancelInternalServerErrorIssue$outboundSchema.parse(
+      envelopeCancelInternalServerErrorIssue,
+    ),
+  );
+}
+export function envelopeCancelInternalServerErrorIssueFromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeCancelInternalServerErrorIssue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      EnvelopeCancelInternalServerErrorIssue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeCancelInternalServerErrorIssue' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeCancelInternalServerError$inboundSchema: z.ZodType<
+  EnvelopeCancelInternalServerError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+  code: z.string(),
+  issues: z.array(
+    z.lazy(() => EnvelopeCancelInternalServerErrorIssue$inboundSchema),
+  ).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new EnvelopeCancelInternalServerError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type EnvelopeCancelInternalServerError$Outbound = {
+  message: string;
+  code: string;
+  issues?: Array<EnvelopeCancelInternalServerErrorIssue$Outbound> | undefined;
+};
+
+/** @internal */
+export const EnvelopeCancelInternalServerError$outboundSchema: z.ZodType<
+  EnvelopeCancelInternalServerError$Outbound,
+  z.ZodTypeDef,
+  EnvelopeCancelInternalServerError
+> = z.instanceof(EnvelopeCancelInternalServerError)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    message: z.string(),
+    code: z.string(),
+    issues: z.array(
+      z.lazy(() => EnvelopeCancelInternalServerErrorIssue$outboundSchema),
+    ).optional(),
+  }));
+
+/** @internal */
+export const EnvelopeCancelForbiddenIssue$inboundSchema: z.ZodType<
+  EnvelopeCancelForbiddenIssue,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+});
+/** @internal */
+export type EnvelopeCancelForbiddenIssue$Outbound = {
+  message: string;
+};
+
+/** @internal */
+export const EnvelopeCancelForbiddenIssue$outboundSchema: z.ZodType<
+  EnvelopeCancelForbiddenIssue$Outbound,
+  z.ZodTypeDef,
+  EnvelopeCancelForbiddenIssue
+> = z.object({
+  message: z.string(),
+});
+
+export function envelopeCancelForbiddenIssueToJSON(
+  envelopeCancelForbiddenIssue: EnvelopeCancelForbiddenIssue,
+): string {
+  return JSON.stringify(
+    EnvelopeCancelForbiddenIssue$outboundSchema.parse(
+      envelopeCancelForbiddenIssue,
+    ),
+  );
+}
+export function envelopeCancelForbiddenIssueFromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeCancelForbiddenIssue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeCancelForbiddenIssue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeCancelForbiddenIssue' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeCancelForbiddenError$inboundSchema: z.ZodType<
+  EnvelopeCancelForbiddenError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+  code: z.string(),
+  issues: z.array(z.lazy(() => EnvelopeCancelForbiddenIssue$inboundSchema))
+    .optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new EnvelopeCancelForbiddenError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type EnvelopeCancelForbiddenError$Outbound = {
+  message: string;
+  code: string;
+  issues?: Array<EnvelopeCancelForbiddenIssue$Outbound> | undefined;
+};
+
+/** @internal */
+export const EnvelopeCancelForbiddenError$outboundSchema: z.ZodType<
+  EnvelopeCancelForbiddenError$Outbound,
+  z.ZodTypeDef,
+  EnvelopeCancelForbiddenError
+> = z.instanceof(EnvelopeCancelForbiddenError)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    message: z.string(),
+    code: z.string(),
+    issues: z.array(z.lazy(() => EnvelopeCancelForbiddenIssue$outboundSchema))
+      .optional(),
+  }));
+
+/** @internal */
+export const EnvelopeCancelUnauthorizedIssue$inboundSchema: z.ZodType<
+  EnvelopeCancelUnauthorizedIssue,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+});
+/** @internal */
+export type EnvelopeCancelUnauthorizedIssue$Outbound = {
+  message: string;
+};
+
+/** @internal */
+export const EnvelopeCancelUnauthorizedIssue$outboundSchema: z.ZodType<
+  EnvelopeCancelUnauthorizedIssue$Outbound,
+  z.ZodTypeDef,
+  EnvelopeCancelUnauthorizedIssue
+> = z.object({
+  message: z.string(),
+});
+
+export function envelopeCancelUnauthorizedIssueToJSON(
+  envelopeCancelUnauthorizedIssue: EnvelopeCancelUnauthorizedIssue,
+): string {
+  return JSON.stringify(
+    EnvelopeCancelUnauthorizedIssue$outboundSchema.parse(
+      envelopeCancelUnauthorizedIssue,
+    ),
+  );
+}
+export function envelopeCancelUnauthorizedIssueFromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeCancelUnauthorizedIssue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeCancelUnauthorizedIssue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeCancelUnauthorizedIssue' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeCancelUnauthorizedError$inboundSchema: z.ZodType<
+  EnvelopeCancelUnauthorizedError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+  code: z.string(),
+  issues: z.array(z.lazy(() => EnvelopeCancelUnauthorizedIssue$inboundSchema))
+    .optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new EnvelopeCancelUnauthorizedError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type EnvelopeCancelUnauthorizedError$Outbound = {
+  message: string;
+  code: string;
+  issues?: Array<EnvelopeCancelUnauthorizedIssue$Outbound> | undefined;
+};
+
+/** @internal */
+export const EnvelopeCancelUnauthorizedError$outboundSchema: z.ZodType<
+  EnvelopeCancelUnauthorizedError$Outbound,
+  z.ZodTypeDef,
+  EnvelopeCancelUnauthorizedError
+> = z.instanceof(EnvelopeCancelUnauthorizedError)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    message: z.string(),
+    code: z.string(),
+    issues: z.array(
+      z.lazy(() => EnvelopeCancelUnauthorizedIssue$outboundSchema),
+    ).optional(),
+  }));
+
+/** @internal */
+export const EnvelopeCancelBadRequestIssue$inboundSchema: z.ZodType<
+  EnvelopeCancelBadRequestIssue,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+});
+/** @internal */
+export type EnvelopeCancelBadRequestIssue$Outbound = {
+  message: string;
+};
+
+/** @internal */
+export const EnvelopeCancelBadRequestIssue$outboundSchema: z.ZodType<
+  EnvelopeCancelBadRequestIssue$Outbound,
+  z.ZodTypeDef,
+  EnvelopeCancelBadRequestIssue
+> = z.object({
+  message: z.string(),
+});
+
+export function envelopeCancelBadRequestIssueToJSON(
+  envelopeCancelBadRequestIssue: EnvelopeCancelBadRequestIssue,
+): string {
+  return JSON.stringify(
+    EnvelopeCancelBadRequestIssue$outboundSchema.parse(
+      envelopeCancelBadRequestIssue,
+    ),
+  );
+}
+export function envelopeCancelBadRequestIssueFromJSON(
+  jsonString: string,
+): SafeParseResult<EnvelopeCancelBadRequestIssue, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EnvelopeCancelBadRequestIssue$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EnvelopeCancelBadRequestIssue' from JSON`,
+  );
+}
+
+/** @internal */
+export const EnvelopeCancelBadRequestError$inboundSchema: z.ZodType<
+  EnvelopeCancelBadRequestError,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string(),
+  code: z.string(),
+  issues: z.array(z.lazy(() => EnvelopeCancelBadRequestIssue$inboundSchema))
+    .optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
+})
+  .transform((v) => {
+    return new EnvelopeCancelBadRequestError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
+  });
+
+/** @internal */
+export type EnvelopeCancelBadRequestError$Outbound = {
+  message: string;
+  code: string;
+  issues?: Array<EnvelopeCancelBadRequestIssue$Outbound> | undefined;
+};
+
+/** @internal */
+export const EnvelopeCancelBadRequestError$outboundSchema: z.ZodType<
+  EnvelopeCancelBadRequestError$Outbound,
+  z.ZodTypeDef,
+  EnvelopeCancelBadRequestError
+> = z.instanceof(EnvelopeCancelBadRequestError)
+  .transform(v => v.data$)
+  .pipe(z.object({
+    message: z.string(),
+    code: z.string(),
+    issues: z.array(z.lazy(() => EnvelopeCancelBadRequestIssue$outboundSchema))
+      .optional(),
+  }));