dub 0.31.1 → 0.31.2

package/src/models/errors/conflict.ts

@@ -49,79 +49,121 @@ export class Conflict extends Error {
     data$: ConflictData;
 
     constructor(err: ConflictData) {
-        super("");
+        const message =
+            "message" in err && typeof err.message === "string"
+                ? err.message
+                : `API error occurred: ${JSON.stringify(err)}`;
+        super(message);
         this.data$ = err;
 
         this.error = err.error;
 
-        this.message =
-            "message" in err && typeof err.message === "string"
-                ? err.message
-                : "API error occurred";
-
         this.name = "Conflict";
     }
 }
 
 /** @internal */
+export const ConflictCode$inboundSchema: z.ZodNativeEnum<typeof ConflictCode> =
+    z.nativeEnum(ConflictCode);
+
+/** @internal */
+export const ConflictCode$outboundSchema: z.ZodNativeEnum<typeof ConflictCode> =
+    ConflictCode$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
 export namespace ConflictCode$ {
-    export const inboundSchema: z.ZodNativeEnum<typeof ConflictCode> = z.nativeEnum(ConflictCode);
-    export const outboundSchema: z.ZodNativeEnum<typeof ConflictCode> = inboundSchema;
+    /** @deprecated use `ConflictCode$inboundSchema` instead. */
+    export const inboundSchema = ConflictCode$inboundSchema;
+    /** @deprecated use `ConflictCode$outboundSchema` instead. */
+    export const outboundSchema = ConflictCode$outboundSchema;
 }
 
 /** @internal */
-export namespace ConflictError$ {
-    export const inboundSchema: z.ZodType<ConflictError, z.ZodTypeDef, unknown> = z
-        .object({
-            code: ConflictCode$.inboundSchema,
-            message: z.string(),
-            doc_url: z.string().optional(),
-        })
-        .transform((v) => {
-            return remap$(v, {
-                doc_url: "docUrl",
-            });
+export const ConflictError$inboundSchema: z.ZodType<ConflictError, z.ZodTypeDef, unknown> = z
+    .object({
+        code: ConflictCode$inboundSchema,
+        message: z.string(),
+        doc_url: z.string().optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            doc_url: "docUrl",
         });
+    });
 
-    export type Outbound = {
-        code: string;
-        message: string;
-        doc_url?: string | undefined;
-    };
-
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, ConflictError> = z
-        .object({
-            code: ConflictCode$.outboundSchema,
-            message: z.string(),
-            docUrl: z.string().optional(),
-        })
-        .transform((v) => {
-            return remap$(v, {
-                docUrl: "doc_url",
-            });
+/** @internal */
+export type ConflictError$Outbound = {
+    code: string;
+    message: string;
+    doc_url?: string | undefined;
+};
+
+/** @internal */
+export const ConflictError$outboundSchema: z.ZodType<
+    ConflictError$Outbound,
+    z.ZodTypeDef,
+    ConflictError
+> = z
+    .object({
+        code: ConflictCode$outboundSchema,
+        message: z.string(),
+        docUrl: z.string().optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            docUrl: "doc_url",
         });
+    });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ConflictError$ {
+    /** @deprecated use `ConflictError$inboundSchema` instead. */
+    export const inboundSchema = ConflictError$inboundSchema;
+    /** @deprecated use `ConflictError$outboundSchema` instead. */
+    export const outboundSchema = ConflictError$outboundSchema;
+    /** @deprecated use `ConflictError$Outbound` instead. */
+    export type Outbound = ConflictError$Outbound;
 }
 
 /** @internal */
-export namespace Conflict$ {
-    export const inboundSchema: z.ZodType<Conflict, z.ZodTypeDef, unknown> = z
-        .object({
-            error: z.lazy(() => ConflictError$.inboundSchema),
+export const Conflict$inboundSchema: z.ZodType<Conflict, z.ZodTypeDef, unknown> = z
+    .object({
+        error: z.lazy(() => ConflictError$inboundSchema),
+    })
+    .transform((v) => {
+        return new Conflict(v);
+    });
+
+/** @internal */
+export type Conflict$Outbound = {
+    error: ConflictError$Outbound;
+};
+
+/** @internal */
+export const Conflict$outboundSchema: z.ZodType<Conflict$Outbound, z.ZodTypeDef, Conflict> = z
+    .instanceof(Conflict)
+    .transform((v) => v.data$)
+    .pipe(
+        z.object({
+            error: z.lazy(() => ConflictError$outboundSchema),
         })
-        .transform((v) => {
-            return new Conflict(v);
-        });
+    );
 
-    export type Outbound = {
-        error: ConflictError$.Outbound;
-    };
-
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, Conflict> = z
-        .instanceof(Conflict)
-        .transform((v) => v.data$)
-        .pipe(
-            z.object({
-                error: z.lazy(() => ConflictError$.outboundSchema),
-            })
-        );
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Conflict$ {
+    /** @deprecated use `Conflict$inboundSchema` instead. */
+    export const inboundSchema = Conflict$inboundSchema;
+    /** @deprecated use `Conflict$outboundSchema` instead. */
+    export const outboundSchema = Conflict$outboundSchema;
+    /** @deprecated use `Conflict$Outbound` instead. */
+    export type Outbound = Conflict$Outbound;
 }

package/src/models/errors/forbidden.ts

@@ -49,79 +49,121 @@ export class Forbidden extends Error {
     data$: ForbiddenData;
 
     constructor(err: ForbiddenData) {
-        super("");
+        const message =
+            "message" in err && typeof err.message === "string"
+                ? err.message
+                : `API error occurred: ${JSON.stringify(err)}`;
+        super(message);
         this.data$ = err;
 
         this.error = err.error;
 
-        this.message =
-            "message" in err && typeof err.message === "string"
-                ? err.message
-                : "API error occurred";
-
         this.name = "Forbidden";
     }
 }
 
 /** @internal */
+export const ForbiddenCode$inboundSchema: z.ZodNativeEnum<typeof ForbiddenCode> =
+    z.nativeEnum(ForbiddenCode);
+
+/** @internal */
+export const ForbiddenCode$outboundSchema: z.ZodNativeEnum<typeof ForbiddenCode> =
+    ForbiddenCode$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
 export namespace ForbiddenCode$ {
-    export const inboundSchema: z.ZodNativeEnum<typeof ForbiddenCode> = z.nativeEnum(ForbiddenCode);
-    export const outboundSchema: z.ZodNativeEnum<typeof ForbiddenCode> = inboundSchema;
+    /** @deprecated use `ForbiddenCode$inboundSchema` instead. */
+    export const inboundSchema = ForbiddenCode$inboundSchema;
+    /** @deprecated use `ForbiddenCode$outboundSchema` instead. */
+    export const outboundSchema = ForbiddenCode$outboundSchema;
 }
 
 /** @internal */
-export namespace ForbiddenError$ {
-    export const inboundSchema: z.ZodType<ForbiddenError, z.ZodTypeDef, unknown> = z
-        .object({
-            code: ForbiddenCode$.inboundSchema,
-            message: z.string(),
-            doc_url: z.string().optional(),
-        })
-        .transform((v) => {
-            return remap$(v, {
-                doc_url: "docUrl",
-            });
+export const ForbiddenError$inboundSchema: z.ZodType<ForbiddenError, z.ZodTypeDef, unknown> = z
+    .object({
+        code: ForbiddenCode$inboundSchema,
+        message: z.string(),
+        doc_url: z.string().optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            doc_url: "docUrl",
         });
+    });
 
-    export type Outbound = {
-        code: string;
-        message: string;
-        doc_url?: string | undefined;
-    };
-
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, ForbiddenError> = z
-        .object({
-            code: ForbiddenCode$.outboundSchema,
-            message: z.string(),
-            docUrl: z.string().optional(),
-        })
-        .transform((v) => {
-            return remap$(v, {
-                docUrl: "doc_url",
-            });
+/** @internal */
+export type ForbiddenError$Outbound = {
+    code: string;
+    message: string;
+    doc_url?: string | undefined;
+};
+
+/** @internal */
+export const ForbiddenError$outboundSchema: z.ZodType<
+    ForbiddenError$Outbound,
+    z.ZodTypeDef,
+    ForbiddenError
+> = z
+    .object({
+        code: ForbiddenCode$outboundSchema,
+        message: z.string(),
+        docUrl: z.string().optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            docUrl: "doc_url",
         });
+    });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace ForbiddenError$ {
+    /** @deprecated use `ForbiddenError$inboundSchema` instead. */
+    export const inboundSchema = ForbiddenError$inboundSchema;
+    /** @deprecated use `ForbiddenError$outboundSchema` instead. */
+    export const outboundSchema = ForbiddenError$outboundSchema;
+    /** @deprecated use `ForbiddenError$Outbound` instead. */
+    export type Outbound = ForbiddenError$Outbound;
 }
 
 /** @internal */
-export namespace Forbidden$ {
-    export const inboundSchema: z.ZodType<Forbidden, z.ZodTypeDef, unknown> = z
-        .object({
-            error: z.lazy(() => ForbiddenError$.inboundSchema),
+export const Forbidden$inboundSchema: z.ZodType<Forbidden, z.ZodTypeDef, unknown> = z
+    .object({
+        error: z.lazy(() => ForbiddenError$inboundSchema),
+    })
+    .transform((v) => {
+        return new Forbidden(v);
+    });
+
+/** @internal */
+export type Forbidden$Outbound = {
+    error: ForbiddenError$Outbound;
+};
+
+/** @internal */
+export const Forbidden$outboundSchema: z.ZodType<Forbidden$Outbound, z.ZodTypeDef, Forbidden> = z
+    .instanceof(Forbidden)
+    .transform((v) => v.data$)
+    .pipe(
+        z.object({
+            error: z.lazy(() => ForbiddenError$outboundSchema),
         })
-        .transform((v) => {
-            return new Forbidden(v);
-        });
+    );
 
-    export type Outbound = {
-        error: ForbiddenError$.Outbound;
-    };
-
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, Forbidden> = z
-        .instanceof(Forbidden)
-        .transform((v) => v.data$)
-        .pipe(
-            z.object({
-                error: z.lazy(() => ForbiddenError$.outboundSchema),
-            })
-        );
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Forbidden$ {
+    /** @deprecated use `Forbidden$inboundSchema` instead. */
+    export const inboundSchema = Forbidden$inboundSchema;
+    /** @deprecated use `Forbidden$outboundSchema` instead. */
+    export const outboundSchema = Forbidden$outboundSchema;
+    /** @deprecated use `Forbidden$Outbound` instead. */
+    export type Outbound = Forbidden$Outbound;
 }

package/src/models/errors/internalservererror.ts

@@ -49,80 +49,135 @@ export class InternalServerError extends Error {
     data$: InternalServerErrorData;
 
     constructor(err: InternalServerErrorData) {
-        super("");
+        const message =
+            "message" in err && typeof err.message === "string"
+                ? err.message
+                : `API error occurred: ${JSON.stringify(err)}`;
+        super(message);
         this.data$ = err;
 
         this.error = err.error;
 
-        this.message =
-            "message" in err && typeof err.message === "string"
-                ? err.message
-                : "API error occurred";
-
         this.name = "InternalServerError";
     }
 }
 
 /** @internal */
+export const InternalServerErrorCode$inboundSchema: z.ZodNativeEnum<
+    typeof InternalServerErrorCode
+> = z.nativeEnum(InternalServerErrorCode);
+
+/** @internal */
+export const InternalServerErrorCode$outboundSchema: z.ZodNativeEnum<
+    typeof InternalServerErrorCode
+> = InternalServerErrorCode$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
 export namespace InternalServerErrorCode$ {
-    export const inboundSchema: z.ZodNativeEnum<typeof InternalServerErrorCode> =
-        z.nativeEnum(InternalServerErrorCode);
-    export const outboundSchema: z.ZodNativeEnum<typeof InternalServerErrorCode> = inboundSchema;
+    /** @deprecated use `InternalServerErrorCode$inboundSchema` instead. */
+    export const inboundSchema = InternalServerErrorCode$inboundSchema;
+    /** @deprecated use `InternalServerErrorCode$outboundSchema` instead. */
+    export const outboundSchema = InternalServerErrorCode$outboundSchema;
 }
 
 /** @internal */
-export namespace InternalServerErrorError$ {
-    export const inboundSchema: z.ZodType<InternalServerErrorError, z.ZodTypeDef, unknown> = z
-        .object({
-            code: InternalServerErrorCode$.inboundSchema,
-            message: z.string(),
-            doc_url: z.string().optional(),
-        })
-        .transform((v) => {
-            return remap$(v, {
-                doc_url: "docUrl",
-            });
+export const InternalServerErrorError$inboundSchema: z.ZodType<
+    InternalServerErrorError,
+    z.ZodTypeDef,
+    unknown
+> = z
+    .object({
+        code: InternalServerErrorCode$inboundSchema,
+        message: z.string(),
+        doc_url: z.string().optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            doc_url: "docUrl",
         });
+    });
 
-    export type Outbound = {
-        code: string;
-        message: string;
-        doc_url?: string | undefined;
-    };
-
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, InternalServerErrorError> = z
-        .object({
-            code: InternalServerErrorCode$.outboundSchema,
-            message: z.string(),
-            docUrl: z.string().optional(),
-        })
-        .transform((v) => {
-            return remap$(v, {
-                docUrl: "doc_url",
-            });
+/** @internal */
+export type InternalServerErrorError$Outbound = {
+    code: string;
+    message: string;
+    doc_url?: string | undefined;
+};
+
+/** @internal */
+export const InternalServerErrorError$outboundSchema: z.ZodType<
+    InternalServerErrorError$Outbound,
+    z.ZodTypeDef,
+    InternalServerErrorError
+> = z
+    .object({
+        code: InternalServerErrorCode$outboundSchema,
+        message: z.string(),
+        docUrl: z.string().optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            docUrl: "doc_url",
         });
+    });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InternalServerErrorError$ {
+    /** @deprecated use `InternalServerErrorError$inboundSchema` instead. */
+    export const inboundSchema = InternalServerErrorError$inboundSchema;
+    /** @deprecated use `InternalServerErrorError$outboundSchema` instead. */
+    export const outboundSchema = InternalServerErrorError$outboundSchema;
+    /** @deprecated use `InternalServerErrorError$Outbound` instead. */
+    export type Outbound = InternalServerErrorError$Outbound;
 }
 
 /** @internal */
-export namespace InternalServerError$ {
-    export const inboundSchema: z.ZodType<InternalServerError, z.ZodTypeDef, unknown> = z
-        .object({
-            error: z.lazy(() => InternalServerErrorError$.inboundSchema),
+export const InternalServerError$inboundSchema: z.ZodType<
+    InternalServerError,
+    z.ZodTypeDef,
+    unknown
+> = z
+    .object({
+        error: z.lazy(() => InternalServerErrorError$inboundSchema),
+    })
+    .transform((v) => {
+        return new InternalServerError(v);
+    });
+
+/** @internal */
+export type InternalServerError$Outbound = {
+    error: InternalServerErrorError$Outbound;
+};
+
+/** @internal */
+export const InternalServerError$outboundSchema: z.ZodType<
+    InternalServerError$Outbound,
+    z.ZodTypeDef,
+    InternalServerError
+> = z
+    .instanceof(InternalServerError)
+    .transform((v) => v.data$)
+    .pipe(
+        z.object({
+            error: z.lazy(() => InternalServerErrorError$outboundSchema),
         })
-        .transform((v) => {
-            return new InternalServerError(v);
-        });
+    );
 
-    export type Outbound = {
-        error: InternalServerErrorError$.Outbound;
-    };
-
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, InternalServerError> = z
-        .instanceof(InternalServerError)
-        .transform((v) => v.data$)
-        .pipe(
-            z.object({
-                error: z.lazy(() => InternalServerErrorError$.outboundSchema),
-            })
-        );
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InternalServerError$ {
+    /** @deprecated use `InternalServerError$inboundSchema` instead. */
+    export const inboundSchema = InternalServerError$inboundSchema;
+    /** @deprecated use `InternalServerError$outboundSchema` instead. */
+    export const outboundSchema = InternalServerError$outboundSchema;
+    /** @deprecated use `InternalServerError$Outbound` instead. */
+    export type Outbound = InternalServerError$Outbound;
 }