@documenso/sdk-typescript 0.2.0 → 0.3.0

package/src/models/errors/templatedeletetemplate.ts

@@ -5,6 +5,7 @@
 import * as z from "zod";
 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 TemplateDeleteTemplateInternalServerErrorIssue = {
@@ -23,20 +24,22 @@ export type TemplateDeleteTemplateInternalServerErrorData = {
 /**
  * Internal server error
  */
-export class TemplateDeleteTemplateInternalServerError extends Error {
+export class TemplateDeleteTemplateInternalServerError extends DocumensoError {
   code: string;
   issues?: Array<TemplateDeleteTemplateInternalServerErrorIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateDeleteTemplateInternalServerErrorData;
 
-  constructor(err: TemplateDeleteTemplateInternalServerErrorData) {
+  constructor(
+    err: TemplateDeleteTemplateInternalServerErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -60,20 +63,22 @@ export type TemplateDeleteTemplateBadRequestErrorData = {
 /**
  * Invalid input data
  */
-export class TemplateDeleteTemplateBadRequestError extends Error {
+export class TemplateDeleteTemplateBadRequestError extends DocumensoError {
   code: string;
   issues?: Array<TemplateDeleteTemplateBadRequestIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateDeleteTemplateBadRequestErrorData;
 
-  constructor(err: TemplateDeleteTemplateBadRequestErrorData) {
+  constructor(
+    err: TemplateDeleteTemplateBadRequestErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -160,9 +165,16 @@ export const TemplateDeleteTemplateInternalServerError$inboundSchema: z.ZodType<
   issues: z.array(
     z.lazy(() => TemplateDeleteTemplateInternalServerErrorIssue$inboundSchema),
   ).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new TemplateDeleteTemplateInternalServerError(v);
+    return new TemplateDeleteTemplateInternalServerError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */
@@ -277,9 +289,16 @@ export const TemplateDeleteTemplateBadRequestError$inboundSchema: z.ZodType<
   issues: z.array(
     z.lazy(() => TemplateDeleteTemplateBadRequestIssue$inboundSchema),
   ).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new TemplateDeleteTemplateBadRequestError(v);
+    return new TemplateDeleteTemplateBadRequestError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/templatedeletetemplatedirectlink.ts

@@ -5,6 +5,7 @@
 import * as z from "zod";
 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 TemplateDeleteTemplateDirectLinkInternalServerErrorIssue = {
@@ -25,7 +26,9 @@ export type TemplateDeleteTemplateDirectLinkInternalServerErrorData = {
 /**
  * Internal server error
  */
-export class TemplateDeleteTemplateDirectLinkInternalServerError extends Error {
+export class TemplateDeleteTemplateDirectLinkInternalServerError
+  extends DocumensoError
+{
   code: string;
   issues?:
     | Array<TemplateDeleteTemplateDirectLinkInternalServerErrorIssue>
@@ -34,13 +37,15 @@ export class TemplateDeleteTemplateDirectLinkInternalServerError extends Error {
   /** The original data that was passed to this error instance. */
   data$: TemplateDeleteTemplateDirectLinkInternalServerErrorData;
 
-  constructor(err: TemplateDeleteTemplateDirectLinkInternalServerErrorData) {
+  constructor(
+    err: TemplateDeleteTemplateDirectLinkInternalServerErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -64,20 +69,24 @@ export type TemplateDeleteTemplateDirectLinkBadRequestErrorData = {
 /**
  * Invalid input data
  */
-export class TemplateDeleteTemplateDirectLinkBadRequestError extends Error {
+export class TemplateDeleteTemplateDirectLinkBadRequestError
+  extends DocumensoError
+{
   code: string;
   issues?: Array<TemplateDeleteTemplateDirectLinkBadRequestIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateDeleteTemplateDirectLinkBadRequestErrorData;
 
-  constructor(err: TemplateDeleteTemplateDirectLinkBadRequestErrorData) {
+  constructor(
+    err: TemplateDeleteTemplateDirectLinkBadRequestErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -166,9 +175,16 @@ export const TemplateDeleteTemplateDirectLinkInternalServerError$inboundSchema:
         TemplateDeleteTemplateDirectLinkInternalServerErrorIssue$inboundSchema
       ),
     ).optional(),
+    request$: z.instanceof(Request),
+    response$: z.instanceof(Response),
+    body$: z.string(),
   })
     .transform((v) => {
-      return new TemplateDeleteTemplateDirectLinkInternalServerError(v);
+      return new TemplateDeleteTemplateDirectLinkInternalServerError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
     });
 
 /** @internal */
@@ -296,9 +312,16 @@ export const TemplateDeleteTemplateDirectLinkBadRequestError$inboundSchema:
         TemplateDeleteTemplateDirectLinkBadRequestIssue$inboundSchema
       ),
     ).optional(),
+    request$: z.instanceof(Request),
+    response$: z.instanceof(Response),
+    body$: z.string(),
   })
     .transform((v) => {
-      return new TemplateDeleteTemplateDirectLinkBadRequestError(v);
+      return new TemplateDeleteTemplateDirectLinkBadRequestError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
     });
 
 /** @internal */

package/src/models/errors/templateduplicatetemplate.ts

@@ -5,6 +5,7 @@
 import * as z from "zod";
 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 TemplateDuplicateTemplateInternalServerErrorIssue = {
@@ -23,20 +24,24 @@ export type TemplateDuplicateTemplateInternalServerErrorData = {
 /**
  * Internal server error
  */
-export class TemplateDuplicateTemplateInternalServerError extends Error {
+export class TemplateDuplicateTemplateInternalServerError
+  extends DocumensoError
+{
   code: string;
   issues?: Array<TemplateDuplicateTemplateInternalServerErrorIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateDuplicateTemplateInternalServerErrorData;
 
-  constructor(err: TemplateDuplicateTemplateInternalServerErrorData) {
+  constructor(
+    err: TemplateDuplicateTemplateInternalServerErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -60,20 +65,22 @@ export type TemplateDuplicateTemplateBadRequestErrorData = {
 /**
  * Invalid input data
  */
-export class TemplateDuplicateTemplateBadRequestError extends Error {
+export class TemplateDuplicateTemplateBadRequestError extends DocumensoError {
   code: string;
   issues?: Array<TemplateDuplicateTemplateBadRequestIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateDuplicateTemplateBadRequestErrorData;
 
-  constructor(err: TemplateDuplicateTemplateBadRequestErrorData) {
+  constructor(
+    err: TemplateDuplicateTemplateBadRequestErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -163,9 +170,16 @@ export const TemplateDuplicateTemplateInternalServerError$inboundSchema:
         TemplateDuplicateTemplateInternalServerErrorIssue$inboundSchema
       ),
     ).optional(),
+    request$: z.instanceof(Request),
+    response$: z.instanceof(Response),
+    body$: z.string(),
   })
     .transform((v) => {
-      return new TemplateDuplicateTemplateInternalServerError(v);
+      return new TemplateDuplicateTemplateInternalServerError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
     });
 
 /** @internal */
@@ -286,9 +300,16 @@ export const TemplateDuplicateTemplateBadRequestError$inboundSchema: z.ZodType<
   issues: z.array(
     z.lazy(() => TemplateDuplicateTemplateBadRequestIssue$inboundSchema),
   ).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new TemplateDuplicateTemplateBadRequestError(v);
+    return new TemplateDuplicateTemplateBadRequestError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/templatefindtemplates.ts

@@ -5,6 +5,7 @@
 import * as z from "zod";
 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 TemplateFindTemplatesInternalServerErrorIssue = {
@@ -23,20 +24,22 @@ export type TemplateFindTemplatesInternalServerErrorData = {
 /**
  * Internal server error
  */
-export class TemplateFindTemplatesInternalServerError extends Error {
+export class TemplateFindTemplatesInternalServerError extends DocumensoError {
   code: string;
   issues?: Array<TemplateFindTemplatesInternalServerErrorIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateFindTemplatesInternalServerErrorData;
 
-  constructor(err: TemplateFindTemplatesInternalServerErrorData) {
+  constructor(
+    err: TemplateFindTemplatesInternalServerErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -60,20 +63,22 @@ export type TemplateFindTemplatesNotFoundErrorData = {
 /**
  * Not found
  */
-export class TemplateFindTemplatesNotFoundError extends Error {
+export class TemplateFindTemplatesNotFoundError extends DocumensoError {
   code: string;
   issues?: Array<TemplateFindTemplatesNotFoundIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateFindTemplatesNotFoundErrorData;
 
-  constructor(err: TemplateFindTemplatesNotFoundErrorData) {
+  constructor(
+    err: TemplateFindTemplatesNotFoundErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -97,20 +102,22 @@ export type TemplateFindTemplatesBadRequestErrorData = {
 /**
  * Invalid input data
  */
-export class TemplateFindTemplatesBadRequestError extends Error {
+export class TemplateFindTemplatesBadRequestError extends DocumensoError {
   code: string;
   issues?: Array<TemplateFindTemplatesBadRequestIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateFindTemplatesBadRequestErrorData;
 
-  constructor(err: TemplateFindTemplatesBadRequestErrorData) {
+  constructor(
+    err: TemplateFindTemplatesBadRequestErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -196,9 +203,16 @@ export const TemplateFindTemplatesInternalServerError$inboundSchema: z.ZodType<
   issues: z.array(
     z.lazy(() => TemplateFindTemplatesInternalServerErrorIssue$inboundSchema),
   ).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new TemplateFindTemplatesInternalServerError(v);
+    return new TemplateFindTemplatesInternalServerError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */
@@ -311,9 +325,16 @@ export const TemplateFindTemplatesNotFoundError$inboundSchema: z.ZodType<
   issues: z.array(
     z.lazy(() => TemplateFindTemplatesNotFoundIssue$inboundSchema),
   ).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new TemplateFindTemplatesNotFoundError(v);
+    return new TemplateFindTemplatesNotFoundError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */
@@ -422,9 +443,16 @@ export const TemplateFindTemplatesBadRequestError$inboundSchema: z.ZodType<
   issues: z.array(
     z.lazy(() => TemplateFindTemplatesBadRequestIssue$inboundSchema),
   ).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new TemplateFindTemplatesBadRequestError(v);
+    return new TemplateFindTemplatesBadRequestError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/templategettemplatebyid.ts

@@ -5,6 +5,7 @@
 import * as z from "zod";
 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 TemplateGetTemplateByIdInternalServerErrorIssue = {
@@ -23,20 +24,22 @@ export type TemplateGetTemplateByIdInternalServerErrorData = {
 /**
  * Internal server error
  */
-export class TemplateGetTemplateByIdInternalServerError extends Error {
+export class TemplateGetTemplateByIdInternalServerError extends DocumensoError {
   code: string;
   issues?: Array<TemplateGetTemplateByIdInternalServerErrorIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateGetTemplateByIdInternalServerErrorData;
 
-  constructor(err: TemplateGetTemplateByIdInternalServerErrorData) {
+  constructor(
+    err: TemplateGetTemplateByIdInternalServerErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -60,20 +63,22 @@ export type TemplateGetTemplateByIdNotFoundErrorData = {
 /**
  * Not found
  */
-export class TemplateGetTemplateByIdNotFoundError extends Error {
+export class TemplateGetTemplateByIdNotFoundError extends DocumensoError {
   code: string;
   issues?: Array<TemplateGetTemplateByIdNotFoundIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateGetTemplateByIdNotFoundErrorData;
 
-  constructor(err: TemplateGetTemplateByIdNotFoundErrorData) {
+  constructor(
+    err: TemplateGetTemplateByIdNotFoundErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -97,20 +102,22 @@ export type TemplateGetTemplateByIdBadRequestErrorData = {
 /**
  * Invalid input data
  */
-export class TemplateGetTemplateByIdBadRequestError extends Error {
+export class TemplateGetTemplateByIdBadRequestError extends DocumensoError {
   code: string;
   issues?: Array<TemplateGetTemplateByIdBadRequestIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateGetTemplateByIdBadRequestErrorData;
 
-  constructor(err: TemplateGetTemplateByIdBadRequestErrorData) {
+  constructor(
+    err: TemplateGetTemplateByIdBadRequestErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -197,9 +204,16 @@ export const TemplateGetTemplateByIdInternalServerError$inboundSchema:
           TemplateGetTemplateByIdInternalServerErrorIssue$inboundSchema
         ),
       ).optional(),
+      request$: z.instanceof(Request),
+      response$: z.instanceof(Response),
+      body$: z.string(),
     })
       .transform((v) => {
-        return new TemplateGetTemplateByIdInternalServerError(v);
+        return new TemplateGetTemplateByIdInternalServerError(v, {
+          request: v.request$,
+          response: v.response$,
+          body: v.body$,
+        });
       });
 
 /** @internal */
@@ -314,9 +328,16 @@ export const TemplateGetTemplateByIdNotFoundError$inboundSchema: z.ZodType<
   issues: z.array(
     z.lazy(() => TemplateGetTemplateByIdNotFoundIssue$inboundSchema),
   ).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new TemplateGetTemplateByIdNotFoundError(v);
+    return new TemplateGetTemplateByIdNotFoundError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */
@@ -427,9 +448,16 @@ export const TemplateGetTemplateByIdBadRequestError$inboundSchema: z.ZodType<
   issues: z.array(
     z.lazy(() => TemplateGetTemplateByIdBadRequestIssue$inboundSchema),
   ).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new TemplateGetTemplateByIdBadRequestError(v);
+    return new TemplateGetTemplateByIdBadRequestError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */

package/src/models/errors/templatemovetemplatetoteam.ts

@@ -5,6 +5,7 @@
 import * as z from "zod";
 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 TemplateMoveTemplateToTeamInternalServerErrorIssue = {
@@ -25,7 +26,9 @@ export type TemplateMoveTemplateToTeamInternalServerErrorData = {
 /**
  * Internal server error
  */
-export class TemplateMoveTemplateToTeamInternalServerError extends Error {
+export class TemplateMoveTemplateToTeamInternalServerError
+  extends DocumensoError
+{
   code: string;
   issues?:
     | Array<TemplateMoveTemplateToTeamInternalServerErrorIssue>
@@ -34,13 +37,15 @@ export class TemplateMoveTemplateToTeamInternalServerError extends Error {
   /** The original data that was passed to this error instance. */
   data$: TemplateMoveTemplateToTeamInternalServerErrorData;
 
-  constructor(err: TemplateMoveTemplateToTeamInternalServerErrorData) {
+  constructor(
+    err: TemplateMoveTemplateToTeamInternalServerErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -64,20 +69,22 @@ export type TemplateMoveTemplateToTeamBadRequestErrorData = {
 /**
  * Invalid input data
  */
-export class TemplateMoveTemplateToTeamBadRequestError extends Error {
+export class TemplateMoveTemplateToTeamBadRequestError extends DocumensoError {
   code: string;
   issues?: Array<TemplateMoveTemplateToTeamBadRequestIssue> | undefined;
 
   /** The original data that was passed to this error instance. */
   data$: TemplateMoveTemplateToTeamBadRequestErrorData;
 
-  constructor(err: TemplateMoveTemplateToTeamBadRequestErrorData) {
+  constructor(
+    err: TemplateMoveTemplateToTeamBadRequestErrorData,
+    httpMeta: { response: Response; request: Request; body: string },
+  ) {
     const message = "message" in err && typeof err.message === "string"
       ? err.message
       : `API error occurred: ${JSON.stringify(err)}`;
-    super(message);
+    super(message, httpMeta);
     this.data$ = err;
-
     this.code = err.code;
     if (err.issues != null) this.issues = err.issues;
 
@@ -167,9 +174,16 @@ export const TemplateMoveTemplateToTeamInternalServerError$inboundSchema:
         TemplateMoveTemplateToTeamInternalServerErrorIssue$inboundSchema
       ),
     ).optional(),
+    request$: z.instanceof(Request),
+    response$: z.instanceof(Response),
+    body$: z.string(),
   })
     .transform((v) => {
-      return new TemplateMoveTemplateToTeamInternalServerError(v);
+      return new TemplateMoveTemplateToTeamInternalServerError(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+      });
     });
 
 /** @internal */
@@ -291,9 +305,16 @@ export const TemplateMoveTemplateToTeamBadRequestError$inboundSchema: z.ZodType<
   issues: z.array(
     z.lazy(() => TemplateMoveTemplateToTeamBadRequestIssue$inboundSchema),
   ).optional(),
+  request$: z.instanceof(Request),
+  response$: z.instanceof(Response),
+  body$: z.string(),
 })
   .transform((v) => {
-    return new TemplateMoveTemplateToTeamBadRequestError(v);
+    return new TemplateMoveTemplateToTeamBadRequestError(v, {
+      request: v.request$,
+      response: v.response$,
+      body: v.body$,
+    });
   });
 
 /** @internal */