dub 0.31.0 → 0.31.2

package/src/models/components/tagschema.ts

@@ -38,28 +38,53 @@ export type TagSchema = {
 };
 
 /** @internal */
+export const Color$inboundSchema: z.ZodNativeEnum<typeof Color> = z.nativeEnum(Color);
+
+/** @internal */
+export const Color$outboundSchema: z.ZodNativeEnum<typeof Color> = Color$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
 export namespace Color$ {
-    export const inboundSchema: z.ZodNativeEnum<typeof Color> = z.nativeEnum(Color);
-    export const outboundSchema: z.ZodNativeEnum<typeof Color> = inboundSchema;
+    /** @deprecated use `Color$inboundSchema` instead. */
+    export const inboundSchema = Color$inboundSchema;
+    /** @deprecated use `Color$outboundSchema` instead. */
+    export const outboundSchema = Color$outboundSchema;
 }
 
 /** @internal */
-export namespace TagSchema$ {
-    export const inboundSchema: z.ZodType<TagSchema, z.ZodTypeDef, unknown> = z.object({
-        id: z.string(),
-        name: z.string(),
-        color: Color$.inboundSchema,
-    });
+export const TagSchema$inboundSchema: z.ZodType<TagSchema, z.ZodTypeDef, unknown> = z.object({
+    id: z.string(),
+    name: z.string(),
+    color: Color$inboundSchema,
+});
 
-    export type Outbound = {
-        id: string;
-        name: string;
-        color: string;
-    };
+/** @internal */
+export type TagSchema$Outbound = {
+    id: string;
+    name: string;
+    color: string;
+};
 
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, TagSchema> = z.object({
+/** @internal */
+export const TagSchema$outboundSchema: z.ZodType<TagSchema$Outbound, z.ZodTypeDef, TagSchema> =
+    z.object({
         id: z.string(),
         name: z.string(),
-        color: Color$.outboundSchema,
+        color: Color$outboundSchema,
     });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace TagSchema$ {
+    /** @deprecated use `TagSchema$inboundSchema` instead. */
+    export const inboundSchema = TagSchema$inboundSchema;
+    /** @deprecated use `TagSchema$outboundSchema` instead. */
+    export const outboundSchema = TagSchema$outboundSchema;
+    /** @deprecated use `TagSchema$Outbound` instead. */
+    export type Outbound = TagSchema$Outbound;
 }

package/src/models/components/workspaceschema.ts

@@ -136,53 +136,101 @@ export type WorkspaceSchema = {
 };
 
 /** @internal */
+export const Plan$inboundSchema: z.ZodNativeEnum<typeof Plan> = z.nativeEnum(Plan);
+
+/** @internal */
+export const Plan$outboundSchema: z.ZodNativeEnum<typeof Plan> = Plan$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
 export namespace Plan$ {
-    export const inboundSchema: z.ZodNativeEnum<typeof Plan> = z.nativeEnum(Plan);
-    export const outboundSchema: z.ZodNativeEnum<typeof Plan> = inboundSchema;
+    /** @deprecated use `Plan$inboundSchema` instead. */
+    export const inboundSchema = Plan$inboundSchema;
+    /** @deprecated use `Plan$outboundSchema` instead. */
+    export const outboundSchema = Plan$outboundSchema;
 }
 
 /** @internal */
+export const Role$inboundSchema: z.ZodNativeEnum<typeof Role> = z.nativeEnum(Role);
+
+/** @internal */
+export const Role$outboundSchema: z.ZodNativeEnum<typeof Role> = Role$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
 export namespace Role$ {
-    export const inboundSchema: z.ZodNativeEnum<typeof Role> = z.nativeEnum(Role);
-    export const outboundSchema: z.ZodNativeEnum<typeof Role> = inboundSchema;
+    /** @deprecated use `Role$inboundSchema` instead. */
+    export const inboundSchema = Role$inboundSchema;
+    /** @deprecated use `Role$outboundSchema` instead. */
+    export const outboundSchema = Role$outboundSchema;
 }
 
 /** @internal */
-export namespace Users$ {
-    export const inboundSchema: z.ZodType<Users, z.ZodTypeDef, unknown> = z.object({
-        role: Role$.inboundSchema,
-    });
+export const Users$inboundSchema: z.ZodType<Users, z.ZodTypeDef, unknown> = z.object({
+    role: Role$inboundSchema,
+});
 
-    export type Outbound = {
-        role: string;
-    };
+/** @internal */
+export type Users$Outbound = {
+    role: string;
+};
 
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, Users> = z.object({
-        role: Role$.outboundSchema,
-    });
+/** @internal */
+export const Users$outboundSchema: z.ZodType<Users$Outbound, z.ZodTypeDef, Users> = z.object({
+    role: Role$outboundSchema,
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Users$ {
+    /** @deprecated use `Users$inboundSchema` instead. */
+    export const inboundSchema = Users$inboundSchema;
+    /** @deprecated use `Users$outboundSchema` instead. */
+    export const outboundSchema = Users$outboundSchema;
+    /** @deprecated use `Users$Outbound` instead. */
+    export type Outbound = Users$Outbound;
 }
 
 /** @internal */
-export namespace Domains$ {
-    export const inboundSchema: z.ZodType<Domains, z.ZodTypeDef, unknown> = z.object({
-        slug: z.string(),
-        primary: z.boolean().default(false),
-    });
+export const Domains$inboundSchema: z.ZodType<Domains, z.ZodTypeDef, unknown> = z.object({
+    slug: z.string(),
+    primary: z.boolean().default(false),
+});
 
-    export type Outbound = {
-        slug: string;
-        primary: boolean;
-    };
+/** @internal */
+export type Domains$Outbound = {
+    slug: string;
+    primary: boolean;
+};
 
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, Domains> = z.object({
-        slug: z.string(),
-        primary: z.boolean().default(false),
-    });
+/** @internal */
+export const Domains$outboundSchema: z.ZodType<Domains$Outbound, z.ZodTypeDef, Domains> = z.object({
+    slug: z.string(),
+    primary: z.boolean().default(false),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Domains$ {
+    /** @deprecated use `Domains$inboundSchema` instead. */
+    export const inboundSchema = Domains$inboundSchema;
+    /** @deprecated use `Domains$outboundSchema` instead. */
+    export const outboundSchema = Domains$outboundSchema;
+    /** @deprecated use `Domains$Outbound` instead. */
+    export type Outbound = Domains$Outbound;
 }
 
 /** @internal */
-export namespace WorkspaceSchema$ {
-    export const inboundSchema: z.ZodType<WorkspaceSchema, z.ZodTypeDef, unknown> = z.object({
+export const WorkspaceSchema$inboundSchema: z.ZodType<WorkspaceSchema, z.ZodTypeDef, unknown> =
+    z.object({
         id: z.string(),
         name: z.string(),
         slug: z.string(),
@@ -194,60 +242,78 @@ export namespace WorkspaceSchema$ {
         domainsLimit: z.number(),
         tagsLimit: z.number(),
         usersLimit: z.number(),
-        plan: Plan$.inboundSchema,
+        plan: Plan$inboundSchema,
         stripeId: z.nullable(z.string()),
         billingCycleStart: z.number(),
         stripeConnectId: z.nullable(z.string()),
         createdAt: z.string(),
-        users: z.array(z.lazy(() => Users$.inboundSchema)),
-        domains: z.array(z.lazy(() => Domains$.inboundSchema)),
+        users: z.array(z.lazy(() => Users$inboundSchema)),
+        domains: z.array(z.lazy(() => Domains$inboundSchema)),
         inviteCode: z.nullable(z.string()),
         betaTester: z.boolean().optional(),
     });
 
-    export type Outbound = {
-        id: string;
-        name: string;
-        slug: string;
-        logo: string | null;
-        usage: number;
-        usageLimit: number;
-        linksUsage: number;
-        linksLimit: number;
-        domainsLimit: number;
-        tagsLimit: number;
-        usersLimit: number;
-        plan: string;
-        stripeId: string | null;
-        billingCycleStart: number;
-        stripeConnectId: string | null;
-        createdAt: string;
-        users: Array<Users$.Outbound>;
-        domains: Array<Domains$.Outbound>;
-        inviteCode: string | null;
-        betaTester?: boolean | undefined;
-    };
-
-    export const outboundSchema: z.ZodType<Outbound, z.ZodTypeDef, WorkspaceSchema> = z.object({
-        id: z.string(),
-        name: z.string(),
-        slug: z.string(),
-        logo: z.nullable(z.string()).default(null),
-        usage: z.number(),
-        usageLimit: z.number(),
-        linksUsage: z.number(),
-        linksLimit: z.number(),
-        domainsLimit: z.number(),
-        tagsLimit: z.number(),
-        usersLimit: z.number(),
-        plan: Plan$.outboundSchema,
-        stripeId: z.nullable(z.string()),
-        billingCycleStart: z.number(),
-        stripeConnectId: z.nullable(z.string()),
-        createdAt: z.string(),
-        users: z.array(z.lazy(() => Users$.outboundSchema)),
-        domains: z.array(z.lazy(() => Domains$.outboundSchema)),
-        inviteCode: z.nullable(z.string()),
-        betaTester: z.boolean().optional(),
-    });
+/** @internal */
+export type WorkspaceSchema$Outbound = {
+    id: string;
+    name: string;
+    slug: string;
+    logo: string | null;
+    usage: number;
+    usageLimit: number;
+    linksUsage: number;
+    linksLimit: number;
+    domainsLimit: number;
+    tagsLimit: number;
+    usersLimit: number;
+    plan: string;
+    stripeId: string | null;
+    billingCycleStart: number;
+    stripeConnectId: string | null;
+    createdAt: string;
+    users: Array<Users$Outbound>;
+    domains: Array<Domains$Outbound>;
+    inviteCode: string | null;
+    betaTester?: boolean | undefined;
+};
+
+/** @internal */
+export const WorkspaceSchema$outboundSchema: z.ZodType<
+    WorkspaceSchema$Outbound,
+    z.ZodTypeDef,
+    WorkspaceSchema
+> = z.object({
+    id: z.string(),
+    name: z.string(),
+    slug: z.string(),
+    logo: z.nullable(z.string()).default(null),
+    usage: z.number(),
+    usageLimit: z.number(),
+    linksUsage: z.number(),
+    linksLimit: z.number(),
+    domainsLimit: z.number(),
+    tagsLimit: z.number(),
+    usersLimit: z.number(),
+    plan: Plan$outboundSchema,
+    stripeId: z.nullable(z.string()),
+    billingCycleStart: z.number(),
+    stripeConnectId: z.nullable(z.string()),
+    createdAt: z.string(),
+    users: z.array(z.lazy(() => Users$outboundSchema)),
+    domains: z.array(z.lazy(() => Domains$outboundSchema)),
+    inviteCode: z.nullable(z.string()),
+    betaTester: z.boolean().optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace WorkspaceSchema$ {
+    /** @deprecated use `WorkspaceSchema$inboundSchema` instead. */
+    export const inboundSchema = WorkspaceSchema$inboundSchema;
+    /** @deprecated use `WorkspaceSchema$outboundSchema` instead. */
+    export const outboundSchema = WorkspaceSchema$outboundSchema;
+    /** @deprecated use `WorkspaceSchema$Outbound` instead. */
+    export type Outbound = WorkspaceSchema$Outbound;
 }

package/src/models/errors/badrequest.ts

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