dub 0.46.7 → 0.46.9

package/docs/sdks/track/README.md

@@ -7,7 +7,6 @@
 
 * [lead](#lead) - Track a lead
 * [sale](#sale) - Track a sale
-* [~~customer~~](#customer) - Track a customer :warning: **Deprecated**
 
 ## lead
 
@@ -158,89 +157,6 @@ run();
 
 ### Errors
 
-| Error Type                 | Status Code                | Content Type               |
-| -------------------------- | -------------------------- | -------------------------- |
-| errors.BadRequest          | 400                        | application/json           |
-| errors.Unauthorized        | 401                        | application/json           |
-| errors.Forbidden           | 403                        | application/json           |
-| errors.NotFound            | 404                        | application/json           |
-| errors.Conflict            | 409                        | application/json           |
-| errors.InviteExpired       | 410                        | application/json           |
-| errors.UnprocessableEntity | 422                        | application/json           |
-| errors.RateLimitExceeded   | 429                        | application/json           |
-| errors.InternalServerError | 500                        | application/json           |
-| errors.SDKError            | 4XX, 5XX                   | \*/\*                      |
-
-## ~~customer~~
-
-Track a customer for an authenticated workspace.
-
-> :warning: **DEPRECATED**: This will be removed in a future release, please migrate away from it as soon as possible.
-
-### Example Usage
-
-```typescript
-import { Dub } from "dub";
-
-const dub = new Dub({
-  token: "DUB_API_KEY",
-});
-
-async function run() {
-  const result = await dub.track.customer();
-
-  // Handle the result
-  console.log(result);
-}
-
-run();
-```
-
-### Standalone function
-
-The standalone function version of this method:
-
-```typescript
-import { DubCore } from "dub/core.js";
-import { trackCustomer } from "dub/funcs/trackCustomer.js";
-
-// Use `DubCore` for best tree-shaking performance.
-// You can create one instance of it to use across an application.
-const dub = new DubCore({
-  token: "DUB_API_KEY",
-});
-
-async function run() {
-  const res = await trackCustomer(dub);
-
-  if (!res.ok) {
-    throw res.error;
-  }
-
-  const { value: result } = res;
-
-  // Handle the result
-  console.log(result);
-}
-
-run();
-```
-
-### Parameters
-
-| Parameter                                                                                                                                                                      | Type                                                                                                                                                                           | Required                                                                                                                                                                       | Description                                                                                                                                                                    |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `request`                                                                                                                                                                      | [operations.TrackCustomerRequestBody](../../models/operations/trackcustomerrequestbody.md)                                                                                     | :heavy_check_mark:                                                                                                                                                             | The request object to use for the request.                                                                                                                                     |
-| `options`                                                                                                                                                                      | RequestOptions                                                                                                                                                                 | :heavy_minus_sign:                                                                                                                                                             | Used to set various options for making HTTP requests.                                                                                                                          |
-| `options.fetchOptions`                                                                                                                                                         | [RequestInit](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options)                                                                                        | :heavy_minus_sign:                                                                                                                                                             | Options that are passed to the underlying HTTP request. This can be used to inject extra headers for examples. All `Request` options, except `method` and `body`, are allowed. |
-| `options.retries`                                                                                                                                                              | [RetryConfig](../../lib/utils/retryconfig.md)                                                                                                                                  | :heavy_minus_sign:                                                                                                                                                             | Enables retrying HTTP requests under certain failure conditions.                                                                                                               |
-
-### Response
-
-**Promise\<[operations.TrackCustomerResponseBody](../../models/operations/trackcustomerresponsebody.md)\>**
-
-### Errors
-
 | Error Type                 | Status Code                | Content Type               |
 | -------------------------- | -------------------------- | -------------------------- |
 | errors.BadRequest          | 400                        | application/json           |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dub",
-  "version": "0.46.7",
+  "version": "0.46.9",
   "author": "Dub",
   "tshy": {
     "exports": {

package/src/funcs/domainsList.ts

@@ -209,7 +209,7 @@ export async function domainsList(
     >;
     "~next"?: { page: number };
   } => {
-    const page = request?.page || 0;
+    const page = request?.page ?? 1;
     const nextPage = page + 1;
 
     if (!responseData) {
@@ -221,7 +221,7 @@ export async function domainsList(
     if (!Array.isArray(results) || !results.length) {
       return { next: () => null };
     }
-    const limit = request?.pageSize || 0;
+    const limit = request?.pageSize ?? 50;
     if (results.length < limit) {
       return { next: () => null };
     }

package/src/funcs/linksList.ts

@@ -214,7 +214,7 @@ export async function linksList(
     >;
     "~next"?: { page: number };
   } => {
-    const page = request?.page || 0;
+    const page = request?.page ?? 1;
     const nextPage = page + 1;
 
     if (!responseData) {
@@ -226,7 +226,7 @@ export async function linksList(
     if (!Array.isArray(results) || !results.length) {
       return { next: () => null };
     }
-    const limit = request?.pageSize || 0;
+    const limit = request?.pageSize ?? 100;
     if (results.length < limit) {
       return { next: () => null };
     }

package/src/lib/config.ts

@@ -57,7 +57,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "0.0.1",
-  sdkVersion: "0.46.7",
-  genVersion: "2.481.0",
-  userAgent: "speakeasy-sdk/typescript 0.46.7 2.481.0 0.0.1 dub",
+  sdkVersion: "0.46.9",
+  genVersion: "2.484.0",
+  userAgent: "speakeasy-sdk/typescript 0.46.9 2.484.0 0.0.1 dub",
 } as const;

package/src/lib/security.ts

@@ -117,7 +117,7 @@ export function resolveSecurity(
   ...options: SecurityInput[][]
 ): SecurityState | null {
   const state: SecurityState = {
-    basic: { username: "", password: "" },
+    basic: {},
     headers: {},
     queryParams: {},
     cookies: {},

package/src/models/components/leadcreatedevent.ts

@@ -20,6 +20,60 @@ export const LeadCreatedEventEvent = {
 } as const;
 export type LeadCreatedEventEvent = ClosedEnum<typeof LeadCreatedEventEvent>;
 
+export type LeadCreatedEventDataLink = {
+  /**
+   * The unique ID of the short link.
+   */
+  id: string;
+  /**
+   * The domain of the short link. If not provided, the primary domain for the workspace will be used (or `dub.sh` if the workspace has no domains).
+   */
+  domain: string;
+  /**
+   * The short link slug. If not provided, a random 7-character slug will be generated.
+   */
+  key: string;
+  /**
+   * The full URL of the short link, including the https protocol (e.g. `https://dub.sh/try`).
+   */
+  shortLink: string;
+  /**
+   * The ID of the program the short link is associated with.
+   */
+  programId: string | null;
+};
+
+export type LeadCreatedEventPartner = {
+  id: string;
+  name: string;
+  email: string;
+  image?: string | null | undefined;
+};
+
+export const LeadCreatedEventType = {
+  Percentage: "percentage",
+  Flat: "flat",
+} as const;
+export type LeadCreatedEventType = ClosedEnum<typeof LeadCreatedEventType>;
+
+export const LeadCreatedEventInterval = {
+  Month: "month",
+  Year: "year",
+} as const;
+export type LeadCreatedEventInterval = ClosedEnum<
+  typeof LeadCreatedEventInterval
+>;
+
+export type LeadCreatedEventDiscount = {
+  id: string;
+  couponId: string | null;
+  couponTestId: string | null;
+  amount: number;
+  type: LeadCreatedEventType;
+  duration: number | null;
+  interval: LeadCreatedEventInterval | null;
+};
+
 export type LeadCreatedEventCustomer = {
   /**
    * The unique identifier of the customer in Dub.
@@ -41,10 +95,17 @@ export type LeadCreatedEventCustomer = {
    * Avatar URL of the customer.
    */
   avatar?: string | null | undefined;
+  /**
+   * Country of the customer.
+   */
+  country?: string | null | undefined;
   /**
    * The date the customer was created.
    */
   createdAt: string;
+  link?: LeadCreatedEventDataLink | null | undefined;
+  partner?: LeadCreatedEventPartner | null | undefined;
+  discount?: LeadCreatedEventDiscount | null | undefined;
 };
 
 export type LeadCreatedEventClick = {
@@ -497,6 +558,249 @@ export namespace LeadCreatedEventEvent$ {
   export const outboundSchema = LeadCreatedEventEvent$outboundSchema;
 }
 
+/** @internal */
+export const LeadCreatedEventDataLink$inboundSchema: z.ZodType<
+  LeadCreatedEventDataLink,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  domain: z.string(),
+  key: z.string(),
+  shortLink: z.string(),
+  programId: z.nullable(z.string()),
+});
+
+/** @internal */
+export type LeadCreatedEventDataLink$Outbound = {
+  id: string;
+  domain: string;
+  key: string;
+  shortLink: string;
+  programId: string | null;
+};
+
+/** @internal */
+export const LeadCreatedEventDataLink$outboundSchema: z.ZodType<
+  LeadCreatedEventDataLink$Outbound,
+  z.ZodTypeDef,
+  LeadCreatedEventDataLink
+> = z.object({
+  id: z.string(),
+  domain: z.string(),
+  key: z.string(),
+  shortLink: z.string(),
+  programId: z.nullable(z.string()),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace LeadCreatedEventDataLink$ {
+  /** @deprecated use `LeadCreatedEventDataLink$inboundSchema` instead. */
+  export const inboundSchema = LeadCreatedEventDataLink$inboundSchema;
+  /** @deprecated use `LeadCreatedEventDataLink$outboundSchema` instead. */
+  export const outboundSchema = LeadCreatedEventDataLink$outboundSchema;
+  /** @deprecated use `LeadCreatedEventDataLink$Outbound` instead. */
+  export type Outbound = LeadCreatedEventDataLink$Outbound;
+}
+
+export function leadCreatedEventDataLinkToJSON(
+  leadCreatedEventDataLink: LeadCreatedEventDataLink,
+): string {
+  return JSON.stringify(
+    LeadCreatedEventDataLink$outboundSchema.parse(leadCreatedEventDataLink),
+  );
+}
+
+export function leadCreatedEventDataLinkFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadCreatedEventDataLink, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadCreatedEventDataLink$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadCreatedEventDataLink' from JSON`,
+  );
+}
+
+/** @internal */
+export const LeadCreatedEventPartner$inboundSchema: z.ZodType<
+  LeadCreatedEventPartner,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string(),
+  image: z.nullable(z.string()).optional(),
+});
+
+/** @internal */
+export type LeadCreatedEventPartner$Outbound = {
+  id: string;
+  name: string;
+  email: string;
+  image?: string | null | undefined;
+};
+
+/** @internal */
+export const LeadCreatedEventPartner$outboundSchema: z.ZodType<
+  LeadCreatedEventPartner$Outbound,
+  z.ZodTypeDef,
+  LeadCreatedEventPartner
+> = z.object({
+  id: z.string(),
+  name: z.string(),
+  email: z.string(),
+  image: z.nullable(z.string()).optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace LeadCreatedEventPartner$ {
+  /** @deprecated use `LeadCreatedEventPartner$inboundSchema` instead. */
+  export const inboundSchema = LeadCreatedEventPartner$inboundSchema;
+  /** @deprecated use `LeadCreatedEventPartner$outboundSchema` instead. */
+  export const outboundSchema = LeadCreatedEventPartner$outboundSchema;
+  /** @deprecated use `LeadCreatedEventPartner$Outbound` instead. */
+  export type Outbound = LeadCreatedEventPartner$Outbound;
+}
+
+export function leadCreatedEventPartnerToJSON(
+  leadCreatedEventPartner: LeadCreatedEventPartner,
+): string {
+  return JSON.stringify(
+    LeadCreatedEventPartner$outboundSchema.parse(leadCreatedEventPartner),
+  );
+}
+
+export function leadCreatedEventPartnerFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadCreatedEventPartner, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadCreatedEventPartner$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadCreatedEventPartner' from JSON`,
+  );
+}
+
+/** @internal */
+export const LeadCreatedEventType$inboundSchema: z.ZodNativeEnum<
+  typeof LeadCreatedEventType
+> = z.nativeEnum(LeadCreatedEventType);
+
+/** @internal */
+export const LeadCreatedEventType$outboundSchema: z.ZodNativeEnum<
+  typeof LeadCreatedEventType
+> = LeadCreatedEventType$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace LeadCreatedEventType$ {
+  /** @deprecated use `LeadCreatedEventType$inboundSchema` instead. */
+  export const inboundSchema = LeadCreatedEventType$inboundSchema;
+  /** @deprecated use `LeadCreatedEventType$outboundSchema` instead. */
+  export const outboundSchema = LeadCreatedEventType$outboundSchema;
+}
+
+/** @internal */
+export const LeadCreatedEventInterval$inboundSchema: z.ZodNativeEnum<
+  typeof LeadCreatedEventInterval
+> = z.nativeEnum(LeadCreatedEventInterval);
+
+/** @internal */
+export const LeadCreatedEventInterval$outboundSchema: z.ZodNativeEnum<
+  typeof LeadCreatedEventInterval
+> = LeadCreatedEventInterval$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace LeadCreatedEventInterval$ {
+  /** @deprecated use `LeadCreatedEventInterval$inboundSchema` instead. */
+  export const inboundSchema = LeadCreatedEventInterval$inboundSchema;
+  /** @deprecated use `LeadCreatedEventInterval$outboundSchema` instead. */
+  export const outboundSchema = LeadCreatedEventInterval$outboundSchema;
+}
+
+/** @internal */
+export const LeadCreatedEventDiscount$inboundSchema: z.ZodType<
+  LeadCreatedEventDiscount,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  couponId: z.nullable(z.string()),
+  couponTestId: z.nullable(z.string()),
+  amount: z.number(),
+  type: LeadCreatedEventType$inboundSchema,
+  duration: z.nullable(z.number()),
+  interval: z.nullable(LeadCreatedEventInterval$inboundSchema),
+});
+
+/** @internal */
+export type LeadCreatedEventDiscount$Outbound = {
+  id: string;
+  couponId: string | null;
+  couponTestId: string | null;
+  amount: number;
+  type: string;
+  duration: number | null;
+  interval: string | null;
+};
+
+/** @internal */
+export const LeadCreatedEventDiscount$outboundSchema: z.ZodType<
+  LeadCreatedEventDiscount$Outbound,
+  z.ZodTypeDef,
+  LeadCreatedEventDiscount
+> = z.object({
+  id: z.string(),
+  couponId: z.nullable(z.string()),
+  couponTestId: z.nullable(z.string()),
+  amount: z.number(),
+  type: LeadCreatedEventType$outboundSchema,
+  duration: z.nullable(z.number()),
+  interval: z.nullable(LeadCreatedEventInterval$outboundSchema),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace LeadCreatedEventDiscount$ {
+  /** @deprecated use `LeadCreatedEventDiscount$inboundSchema` instead. */
+  export const inboundSchema = LeadCreatedEventDiscount$inboundSchema;
+  /** @deprecated use `LeadCreatedEventDiscount$outboundSchema` instead. */
+  export const outboundSchema = LeadCreatedEventDiscount$outboundSchema;
+  /** @deprecated use `LeadCreatedEventDiscount$Outbound` instead. */
+  export type Outbound = LeadCreatedEventDiscount$Outbound;
+}
+
+export function leadCreatedEventDiscountToJSON(
+  leadCreatedEventDiscount: LeadCreatedEventDiscount,
+): string {
+  return JSON.stringify(
+    LeadCreatedEventDiscount$outboundSchema.parse(leadCreatedEventDiscount),
+  );
+}
+
+export function leadCreatedEventDiscountFromJSON(
+  jsonString: string,
+): SafeParseResult<LeadCreatedEventDiscount, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => LeadCreatedEventDiscount$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'LeadCreatedEventDiscount' from JSON`,
+  );
+}
+
 /** @internal */
 export const LeadCreatedEventCustomer$inboundSchema: z.ZodType<
   LeadCreatedEventCustomer,
@@ -508,7 +812,14 @@ export const LeadCreatedEventCustomer$inboundSchema: z.ZodType<
   name: z.string(),
   email: z.nullable(z.string()).optional(),
   avatar: z.nullable(z.string()).optional(),
+  country: z.nullable(z.string()).optional(),
   createdAt: z.string(),
+  link: z.nullable(z.lazy(() => LeadCreatedEventDataLink$inboundSchema))
+    .optional(),
+  partner: z.nullable(z.lazy(() => LeadCreatedEventPartner$inboundSchema))
+    .optional(),
+  discount: z.nullable(z.lazy(() => LeadCreatedEventDiscount$inboundSchema))
+    .optional(),
 });
 
 /** @internal */
@@ -518,7 +829,11 @@ export type LeadCreatedEventCustomer$Outbound = {
   name: string;
   email?: string | null | undefined;
   avatar?: string | null | undefined;
+  country?: string | null | undefined;
   createdAt: string;
+  link?: LeadCreatedEventDataLink$Outbound | null | undefined;
+  partner?: LeadCreatedEventPartner$Outbound | null | undefined;
+  discount?: LeadCreatedEventDiscount$Outbound | null | undefined;
 };
 
 /** @internal */
@@ -532,7 +847,14 @@ export const LeadCreatedEventCustomer$outboundSchema: z.ZodType<
   name: z.string(),
   email: z.nullable(z.string()).optional(),
   avatar: z.nullable(z.string()).optional(),
+  country: z.nullable(z.string()).optional(),
   createdAt: z.string(),
+  link: z.nullable(z.lazy(() => LeadCreatedEventDataLink$outboundSchema))
+    .optional(),
+  partner: z.nullable(z.lazy(() => LeadCreatedEventPartner$outboundSchema))
+    .optional(),
+  discount: z.nullable(z.lazy(() => LeadCreatedEventDiscount$outboundSchema))
+    .optional(),
 });
 
 /**