dub 0.31.1 → 0.31.2

package/src/models/errors/inviteexpired.ts

@@ -49,80 +49,129 @@ export class InviteExpired extends Error {
     data$: InviteExpiredData;
 
     constructor(err: InviteExpiredData) {
-        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 = "InviteExpired";
     }
 }
 
 /** @internal */
+export const InviteExpiredCode$inboundSchema: z.ZodNativeEnum<typeof InviteExpiredCode> =
+    z.nativeEnum(InviteExpiredCode);
+
+/** @internal */
+export const InviteExpiredCode$outboundSchema: z.ZodNativeEnum<typeof InviteExpiredCode> =
+    InviteExpiredCode$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
 export namespace InviteExpiredCode$ {
-    export const inboundSchema: z.ZodNativeEnum<typeof InviteExpiredCode> =
-        z.nativeEnum(InviteExpiredCode);
-    export const outboundSchema: z.ZodNativeEnum<typeof InviteExpiredCode> = inboundSchema;
+    /** @deprecated use `InviteExpiredCode$inboundSchema` instead. */
+    export const inboundSchema = InviteExpiredCode$inboundSchema;
+    /** @deprecated use `InviteExpiredCode$outboundSchema` instead. */
+    export const outboundSchema = InviteExpiredCode$outboundSchema;
 }
 
 /** @internal */
-export namespace InviteExpiredError$ {
-    export const inboundSchema: z.ZodType<InviteExpiredError, z.ZodTypeDef, unknown> = z
-        .object({
-            code: InviteExpiredCode$.inboundSchema,
-            message: z.string(),
-            doc_url: z.string().optional(),
-        })
-        .transform((v) => {
-            return remap$(v, {
-                doc_url: "docUrl",
-            });
+export const InviteExpiredError$inboundSchema: z.ZodType<
+    InviteExpiredError,
+    z.ZodTypeDef,
+    unknown
+> = z
+    .object({
+        code: InviteExpiredCode$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, InviteExpiredError> = z
-        .object({
-            code: InviteExpiredCode$.outboundSchema,
-            message: z.string(),
-            docUrl: z.string().optional(),
-        })
-        .transform((v) => {
-            return remap$(v, {
-                docUrl: "doc_url",
-            });
+/** @internal */
+export type InviteExpiredError$Outbound = {
+    code: string;
+    message: string;
+    doc_url?: string | undefined;
+};
+
+/** @internal */
+export const InviteExpiredError$outboundSchema: z.ZodType<
+    InviteExpiredError$Outbound,
+    z.ZodTypeDef,
+    InviteExpiredError
+> = z
+    .object({
+        code: InviteExpiredCode$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 InviteExpiredError$ {
+    /** @deprecated use `InviteExpiredError$inboundSchema` instead. */
+    export const inboundSchema = InviteExpiredError$inboundSchema;
+    /** @deprecated use `InviteExpiredError$outboundSchema` instead. */
+    export const outboundSchema = InviteExpiredError$outboundSchema;
+    /** @deprecated use `InviteExpiredError$Outbound` instead. */
+    export type Outbound = InviteExpiredError$Outbound;
 }
 
 /** @internal */
-export namespace InviteExpired$ {
-    export const inboundSchema: z.ZodType<InviteExpired, z.ZodTypeDef, unknown> = z
-        .object({
-            error: z.lazy(() => InviteExpiredError$.inboundSchema),
+export const InviteExpired$inboundSchema: z.ZodType<InviteExpired, z.ZodTypeDef, unknown> = z
+    .object({
+        error: z.lazy(() => InviteExpiredError$inboundSchema),
+    })
+    .transform((v) => {
+        return new InviteExpired(v);
+    });
+
+/** @internal */
+export type InviteExpired$Outbound = {
+    error: InviteExpiredError$Outbound;
+};
+
+/** @internal */
+export const InviteExpired$outboundSchema: z.ZodType<
+    InviteExpired$Outbound,
+    z.ZodTypeDef,
+    InviteExpired
+> = z
+    .instanceof(InviteExpired)
+    .transform((v) => v.data$)
+    .pipe(
+        z.object({
+            error: z.lazy(() => InviteExpiredError$outboundSchema),
         })
-        .transform((v) => {
-            return new InviteExpired(v);
-        });
+    );
 
-    export type Outbound = {
-        error: InviteExpiredError$.Outbound;
-    };
-
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, InviteExpired> = z
-        .instanceof(InviteExpired)
-        .transform((v) => v.data$)
-        .pipe(
-            z.object({
-                error: z.lazy(() => InviteExpiredError$.outboundSchema),
-            })
-        );
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace InviteExpired$ {
+    /** @deprecated use `InviteExpired$inboundSchema` instead. */
+    export const inboundSchema = InviteExpired$inboundSchema;
+    /** @deprecated use `InviteExpired$outboundSchema` instead. */
+    export const outboundSchema = InviteExpired$outboundSchema;
+    /** @deprecated use `InviteExpired$Outbound` instead. */
+    export type Outbound = InviteExpired$Outbound;
 }

package/src/models/errors/notfound.ts

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

package/src/models/errors/ratelimitexceeded.ts

@@ -49,80 +49,130 @@ export class RateLimitExceeded extends Error {
     data$: RateLimitExceededData;
 
     constructor(err: RateLimitExceededData) {
-        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 = "RateLimitExceeded";
     }
 }
 
 /** @internal */
+export const RateLimitExceededCode$inboundSchema: z.ZodNativeEnum<typeof RateLimitExceededCode> =
+    z.nativeEnum(RateLimitExceededCode);
+
+/** @internal */
+export const RateLimitExceededCode$outboundSchema: z.ZodNativeEnum<typeof RateLimitExceededCode> =
+    RateLimitExceededCode$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
 export namespace RateLimitExceededCode$ {
-    export const inboundSchema: z.ZodNativeEnum<typeof RateLimitExceededCode> =
-        z.nativeEnum(RateLimitExceededCode);
-    export const outboundSchema: z.ZodNativeEnum<typeof RateLimitExceededCode> = inboundSchema;
+    /** @deprecated use `RateLimitExceededCode$inboundSchema` instead. */
+    export const inboundSchema = RateLimitExceededCode$inboundSchema;
+    /** @deprecated use `RateLimitExceededCode$outboundSchema` instead. */
+    export const outboundSchema = RateLimitExceededCode$outboundSchema;
 }
 
 /** @internal */
-export namespace RateLimitExceededError$ {
-    export const inboundSchema: z.ZodType<RateLimitExceededError, z.ZodTypeDef, unknown> = z
-        .object({
-            code: RateLimitExceededCode$.inboundSchema,
-            message: z.string(),
-            doc_url: z.string().optional(),
-        })
-        .transform((v) => {
-            return remap$(v, {
-                doc_url: "docUrl",
-            });
+export const RateLimitExceededError$inboundSchema: z.ZodType<
+    RateLimitExceededError,
+    z.ZodTypeDef,
+    unknown
+> = z
+    .object({
+        code: RateLimitExceededCode$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;
-    };
+/** @internal */
+export type RateLimitExceededError$Outbound = {
+    code: string;
+    message: string;
+    doc_url?: string | undefined;
+};
 
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, RateLimitExceededError> = z
-        .object({
-            code: RateLimitExceededCode$.outboundSchema,
-            message: z.string(),
-            docUrl: z.string().optional(),
-        })
-        .transform((v) => {
-            return remap$(v, {
-                docUrl: "doc_url",
-            });
+/** @internal */
+export const RateLimitExceededError$outboundSchema: z.ZodType<
+    RateLimitExceededError$Outbound,
+    z.ZodTypeDef,
+    RateLimitExceededError
+> = z
+    .object({
+        code: RateLimitExceededCode$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 RateLimitExceededError$ {
+    /** @deprecated use `RateLimitExceededError$inboundSchema` instead. */
+    export const inboundSchema = RateLimitExceededError$inboundSchema;
+    /** @deprecated use `RateLimitExceededError$outboundSchema` instead. */
+    export const outboundSchema = RateLimitExceededError$outboundSchema;
+    /** @deprecated use `RateLimitExceededError$Outbound` instead. */
+    export type Outbound = RateLimitExceededError$Outbound;
 }
 
 /** @internal */
-export namespace RateLimitExceeded$ {
-    export const inboundSchema: z.ZodType<RateLimitExceeded, z.ZodTypeDef, unknown> = z
+export const RateLimitExceeded$inboundSchema: z.ZodType<RateLimitExceeded, z.ZodTypeDef, unknown> =
+    z
         .object({
-            error: z.lazy(() => RateLimitExceededError$.inboundSchema),
+            error: z.lazy(() => RateLimitExceededError$inboundSchema),
         })
         .transform((v) => {
             return new RateLimitExceeded(v);
         });
 
-    export type Outbound = {
-        error: RateLimitExceededError$.Outbound;
-    };
-
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, RateLimitExceeded> = z
-        .instanceof(RateLimitExceeded)
-        .transform((v) => v.data$)
-        .pipe(
-            z.object({
-                error: z.lazy(() => RateLimitExceededError$.outboundSchema),
-            })
-        );
+/** @internal */
+export type RateLimitExceeded$Outbound = {
+    error: RateLimitExceededError$Outbound;
+};
+
+/** @internal */
+export const RateLimitExceeded$outboundSchema: z.ZodType<
+    RateLimitExceeded$Outbound,
+    z.ZodTypeDef,
+    RateLimitExceeded
+> = z
+    .instanceof(RateLimitExceeded)
+    .transform((v) => v.data$)
+    .pipe(
+        z.object({
+            error: z.lazy(() => RateLimitExceededError$outboundSchema),
+        })
+    );
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace RateLimitExceeded$ {
+    /** @deprecated use `RateLimitExceeded$inboundSchema` instead. */
+    export const inboundSchema = RateLimitExceeded$inboundSchema;
+    /** @deprecated use `RateLimitExceeded$outboundSchema` instead. */
+    export const outboundSchema = RateLimitExceeded$outboundSchema;
+    /** @deprecated use `RateLimitExceeded$Outbound` instead. */
+    export type Outbound = RateLimitExceeded$Outbound;
 }