@novu/api 3.15.0 → 3.15.1-rc.1

package/src/models/operations/domainscontrollerupdatedomainroute.ts

@@ -0,0 +1,91 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DomainsControllerUpdateDomainRouteRequest = {
+  domain: string;
+  address: string;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+  updateDomainRouteDto: components.UpdateDomainRouteDto;
+};
+
+export type DomainsControllerUpdateDomainRouteResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.DomainRouteResponseDto;
+};
+
+/** @internal */
+export type DomainsControllerUpdateDomainRouteRequest$Outbound = {
+  domain: string;
+  address: string;
+  "idempotency-key"?: string | undefined;
+  UpdateDomainRouteDto: components.UpdateDomainRouteDto$Outbound;
+};
+
+/** @internal */
+export const DomainsControllerUpdateDomainRouteRequest$outboundSchema:
+  z.ZodType<
+    DomainsControllerUpdateDomainRouteRequest$Outbound,
+    z.ZodTypeDef,
+    DomainsControllerUpdateDomainRouteRequest
+  > = z.object({
+    domain: z.string(),
+    address: z.string(),
+    idempotencyKey: z.string().optional(),
+    updateDomainRouteDto: components.UpdateDomainRouteDto$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "idempotency-key",
+      updateDomainRouteDto: "UpdateDomainRouteDto",
+    });
+  });
+
+export function domainsControllerUpdateDomainRouteRequestToJSON(
+  domainsControllerUpdateDomainRouteRequest:
+    DomainsControllerUpdateDomainRouteRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerUpdateDomainRouteRequest$outboundSchema.parse(
+      domainsControllerUpdateDomainRouteRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerUpdateDomainRouteResponse$inboundSchema:
+  z.ZodType<DomainsControllerUpdateDomainRouteResponse, z.ZodTypeDef, unknown> =
+    z.object({
+      Headers: z.record(z.array(z.string())).default({}),
+      Result: components.DomainRouteResponseDto$inboundSchema,
+    }).transform((v) => {
+      return remap$(v, {
+        "Headers": "headers",
+        "Result": "result",
+      });
+    });
+
+export function domainsControllerUpdateDomainRouteResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DomainsControllerUpdateDomainRouteResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerUpdateDomainRouteResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DomainsControllerUpdateDomainRouteResponse' from JSON`,
+  );
+}

package/src/models/operations/domainscontrollerverifydomain.ts

@@ -0,0 +1,79 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DomainsControllerVerifyDomainRequest = {
+  domain: string;
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+};
+
+export type DomainsControllerVerifyDomainResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.DomainResponseDto;
+};
+
+/** @internal */
+export type DomainsControllerVerifyDomainRequest$Outbound = {
+  domain: string;
+  "idempotency-key"?: string | undefined;
+};
+
+/** @internal */
+export const DomainsControllerVerifyDomainRequest$outboundSchema: z.ZodType<
+  DomainsControllerVerifyDomainRequest$Outbound,
+  z.ZodTypeDef,
+  DomainsControllerVerifyDomainRequest
+> = z.object({
+  domain: z.string(),
+  idempotencyKey: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    idempotencyKey: "idempotency-key",
+  });
+});
+
+export function domainsControllerVerifyDomainRequestToJSON(
+  domainsControllerVerifyDomainRequest: DomainsControllerVerifyDomainRequest,
+): string {
+  return JSON.stringify(
+    DomainsControllerVerifyDomainRequest$outboundSchema.parse(
+      domainsControllerVerifyDomainRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const DomainsControllerVerifyDomainResponse$inboundSchema: z.ZodType<
+  DomainsControllerVerifyDomainResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Headers: z.record(z.array(z.string())).default({}),
+  Result: components.DomainResponseDto$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "Headers": "headers",
+    "Result": "result",
+  });
+});
+
+export function domainsControllerVerifyDomainResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DomainsControllerVerifyDomainResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DomainsControllerVerifyDomainResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DomainsControllerVerifyDomainResponse' from JSON`,
+  );
+}

package/src/models/operations/index.ts

@@ -17,6 +17,21 @@ export * from "./contextscontrollerdeletecontext.js";
 export * from "./contextscontrollergetcontext.js";
 export * from "./contextscontrollerlistcontexts.js";
 export * from "./contextscontrollerupdatecontext.js";
+export * from "./domainscontrollercreatedomain.js";
+export * from "./domainscontrollercreatedomainroute.js";
+export * from "./domainscontrollerdeletedomain.js";
+export * from "./domainscontrollerdeletedomainroute.js";
+export * from "./domainscontrollerdiagnosedomain.js";
+export * from "./domainscontrollergetdomain.js";
+export * from "./domainscontrollergetdomainautoconfigure.js";
+export * from "./domainscontrollergetdomainroute.js";
+export * from "./domainscontrollerlistdomainroutes.js";
+export * from "./domainscontrollerlistdomains.js";
+export * from "./domainscontrollerstartdomainautoconfigure.js";
+export * from "./domainscontrollertestdomainroute.js";
+export * from "./domainscontrollerupdatedomain.js";
+export * from "./domainscontrollerupdatedomainroute.js";
+export * from "./domainscontrollerverifydomain.js";
 export * from "./environmentscontrollerdiffenvironment.js";
 export * from "./environmentscontrollergetenvironmenttags.js";
 export * from "./environmentscontrollerpublishenvironment.js";
@@ -37,6 +52,8 @@ export * from "./eventscontrollertriggerbulk.js";
 export * from "./inboundwebhookscontrollerhandlewebhook.js";
 export * from "./integrationscontrollerautoconfigureintegration.js";
 export * from "./integrationscontrollercreateintegration.js";
+export * from "./integrationscontrollergenerateconnectoauthurl.js";
+export * from "./integrationscontrollergeneratelinkuseroauthurl.js";
 export * from "./integrationscontrollergetactiveintegrations.js";
 export * from "./integrationscontrollergetchatoauthurl.js";
 export * from "./integrationscontrollerlistintegrations.js";

package/src/models/operations/integrationscontrollergenerateconnectoauthurl.ts

@@ -0,0 +1,91 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type IntegrationsControllerGenerateConnectOAuthUrlRequest = {
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+  generateConnectOauthUrlRequestDto:
+    components.GenerateConnectOauthUrlRequestDto;
+};
+
+export type IntegrationsControllerGenerateConnectOAuthUrlResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.GenerateChatOAuthUrlResponseDto;
+};
+
+/** @internal */
+export type IntegrationsControllerGenerateConnectOAuthUrlRequest$Outbound = {
+  "idempotency-key"?: string | undefined;
+  GenerateConnectOauthUrlRequestDto:
+    components.GenerateConnectOauthUrlRequestDto$Outbound;
+};
+
+/** @internal */
+export const IntegrationsControllerGenerateConnectOAuthUrlRequest$outboundSchema:
+  z.ZodType<
+    IntegrationsControllerGenerateConnectOAuthUrlRequest$Outbound,
+    z.ZodTypeDef,
+    IntegrationsControllerGenerateConnectOAuthUrlRequest
+  > = z.object({
+    idempotencyKey: z.string().optional(),
+    generateConnectOauthUrlRequestDto:
+      components.GenerateConnectOauthUrlRequestDto$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "idempotency-key",
+      generateConnectOauthUrlRequestDto: "GenerateConnectOauthUrlRequestDto",
+    });
+  });
+
+export function integrationsControllerGenerateConnectOAuthUrlRequestToJSON(
+  integrationsControllerGenerateConnectOAuthUrlRequest:
+    IntegrationsControllerGenerateConnectOAuthUrlRequest,
+): string {
+  return JSON.stringify(
+    IntegrationsControllerGenerateConnectOAuthUrlRequest$outboundSchema.parse(
+      integrationsControllerGenerateConnectOAuthUrlRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const IntegrationsControllerGenerateConnectOAuthUrlResponse$inboundSchema:
+  z.ZodType<
+    IntegrationsControllerGenerateConnectOAuthUrlResponse,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    Headers: z.record(z.array(z.string())).default({}),
+    Result: components.GenerateChatOAuthUrlResponseDto$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "Headers": "headers",
+      "Result": "result",
+    });
+  });
+
+export function integrationsControllerGenerateConnectOAuthUrlResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  IntegrationsControllerGenerateConnectOAuthUrlResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      IntegrationsControllerGenerateConnectOAuthUrlResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'IntegrationsControllerGenerateConnectOAuthUrlResponse' from JSON`,
+  );
+}

package/src/models/operations/integrationscontrollergeneratelinkuseroauthurl.ts

@@ -0,0 +1,90 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type IntegrationsControllerGenerateLinkUserOAuthUrlRequest = {
+  /**
+   * A header for idempotency purposes
+   */
+  idempotencyKey?: string | undefined;
+  generateLinkUserOauthUrlRequestDto:
+    components.GenerateLinkUserOauthUrlRequestDto;
+};
+
+export type IntegrationsControllerGenerateLinkUserOAuthUrlResponse = {
+  headers: { [k: string]: Array<string> };
+  result: components.GenerateChatOAuthUrlResponseDto;
+};
+
+/** @internal */
+export type IntegrationsControllerGenerateLinkUserOAuthUrlRequest$Outbound = {
+  "idempotency-key"?: string | undefined;
+  GenerateLinkUserOauthUrlRequestDto:
+    components.GenerateLinkUserOauthUrlRequestDto$Outbound;
+};
+
+/** @internal */
+export const IntegrationsControllerGenerateLinkUserOAuthUrlRequest$outboundSchema:
+  z.ZodType<
+    IntegrationsControllerGenerateLinkUserOAuthUrlRequest$Outbound,
+    z.ZodTypeDef,
+    IntegrationsControllerGenerateLinkUserOAuthUrlRequest
+  > = z.object({
+    idempotencyKey: z.string().optional(),
+    generateLinkUserOauthUrlRequestDto:
+      components.GenerateLinkUserOauthUrlRequestDto$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      idempotencyKey: "idempotency-key",
+      generateLinkUserOauthUrlRequestDto: "GenerateLinkUserOauthUrlRequestDto",
+    });
+  });
+
+export function integrationsControllerGenerateLinkUserOAuthUrlRequestToJSON(
+  integrationsControllerGenerateLinkUserOAuthUrlRequest:
+    IntegrationsControllerGenerateLinkUserOAuthUrlRequest,
+): string {
+  return JSON.stringify(
+    IntegrationsControllerGenerateLinkUserOAuthUrlRequest$outboundSchema.parse(
+      integrationsControllerGenerateLinkUserOAuthUrlRequest,
+    ),
+  );
+}
+
+/** @internal */
+export const IntegrationsControllerGenerateLinkUserOAuthUrlResponse$inboundSchema:
+  z.ZodType<
+    IntegrationsControllerGenerateLinkUserOAuthUrlResponse,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    Headers: z.record(z.array(z.string())).default({}),
+    Result: components.GenerateChatOAuthUrlResponseDto$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "Headers": "headers",
+      "Result": "result",
+    });
+  });
+
+export function integrationsControllerGenerateLinkUserOAuthUrlResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  IntegrationsControllerGenerateLinkUserOAuthUrlResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      IntegrationsControllerGenerateLinkUserOAuthUrlResponse$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'IntegrationsControllerGenerateLinkUserOAuthUrlResponse' from JSON`,
+  );
+}

package/src/sdk/autoconfigure.ts

@@ -0,0 +1,52 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { domainsAutoConfigureRetrieve } from "../funcs/domainsAutoConfigureRetrieve.js";
+import { domainsAutoConfigureStart } from "../funcs/domainsAutoConfigureStart.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class AutoConfigure extends ClientSDK {
+  /**
+   * Retrieve auto-configuration availability
+   *
+   * @remarks
+   * Returns whether DNS auto-configuration (Domain Connect) is available for this domain. When `available` is `false`, `manualRecords` lists the DNS records the customer must add manually.
+   */
+  async retrieve(
+    domain: string,
+    idempotencyKey?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.DomainsControllerGetDomainAutoConfigureResponse> {
+    return unwrapAsync(domainsAutoConfigureRetrieve(
+      this,
+      domain,
+      idempotencyKey,
+      options,
+    ));
+  }
+
+  /**
+   * Start DNS auto-configuration
+   *
+   * @remarks
+   * Generates a signed redirect URL the customer can follow to apply Novu DNS records at their DNS provider. After the provider completes the flow, it redirects back to `redirectUri`.
+   */
+  async start(
+    createDomainConnectApplyUrlDto: components.CreateDomainConnectApplyUrlDto,
+    domain: string,
+    idempotencyKey?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.DomainsControllerStartDomainAutoConfigureResponse> {
+    return unwrapAsync(domainsAutoConfigureStart(
+      this,
+      createDomainConnectApplyUrlDto,
+      domain,
+      idempotencyKey,
+      options,
+    ));
+  }
+}

package/src/sdk/domains.ts

@@ -0,0 +1,162 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { domainsCreate } from "../funcs/domainsCreate.js";
+import { domainsDelete } from "../funcs/domainsDelete.js";
+import { domainsDiagnose } from "../funcs/domainsDiagnose.js";
+import { domainsList } from "../funcs/domainsList.js";
+import { domainsRetrieve } from "../funcs/domainsRetrieve.js";
+import { domainsUpdate } from "../funcs/domainsUpdate.js";
+import { domainsVerify } from "../funcs/domainsVerify.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { AutoConfigure } from "./autoconfigure.js";
+import { Routes } from "./routes.js";
+
+export class Domains extends ClientSDK {
+  private _autoConfigure?: AutoConfigure;
+  get autoConfigure(): AutoConfigure {
+    return (this._autoConfigure ??= new AutoConfigure(this._options));
+  }
+
+  private _routes?: Routes;
+  get routes(): Routes {
+    return (this._routes ??= new Routes(this._options));
+  }
+
+  /**
+   * List domains for an environment
+   *
+   * @remarks
+   * Returns a paginated list of inbound-email domains in the current environment. Supports cursor pagination and a name contains filter.
+   */
+  async list(
+    request: operations.DomainsControllerListDomainsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.DomainsControllerListDomainsResponse> {
+    return unwrapAsync(domainsList(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create a domain
+   *
+   * @remarks
+   * Registers a new inbound-email domain. The response includes the DNS records customers must add at their DNS provider before the domain can receive mail.
+   */
+  async create(
+    createDomainDto: components.CreateDomainDto,
+    idempotencyKey?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.DomainsControllerCreateDomainResponse> {
+    return unwrapAsync(domainsCreate(
+      this,
+      createDomainDto,
+      idempotencyKey,
+      options,
+    ));
+  }
+
+  /**
+   * Retrieve a domain by name
+   *
+   * @remarks
+   * Returns the domain configuration and the DNS records that must be in place. This is a pure read; call `domains.verify` to refresh verification status from DNS.
+   */
+  async retrieve(
+    domain: string,
+    idempotencyKey?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.DomainsControllerGetDomainResponse> {
+    return unwrapAsync(domainsRetrieve(
+      this,
+      domain,
+      idempotencyKey,
+      options,
+    ));
+  }
+
+  /**
+   * Update a domain
+   *
+   * @remarks
+   * Updates optional domain fields. When `data` is provided, it replaces the entire metadata object; omit `data` to leave it unchanged.
+   */
+  async update(
+    updateDomainDto: components.UpdateDomainDto,
+    domain: string,
+    idempotencyKey?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.DomainsControllerUpdateDomainResponse> {
+    return unwrapAsync(domainsUpdate(
+      this,
+      updateDomainDto,
+      domain,
+      idempotencyKey,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a domain
+   *
+   * @remarks
+   * Removes the domain and cascades the deletion to all of its routes. Inbound mail for that domain stops being processed immediately.
+   */
+  async delete(
+    domain: string,
+    idempotencyKey?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.DomainsControllerDeleteDomainResponse | undefined> {
+    return unwrapAsync(domainsDelete(
+      this,
+      domain,
+      idempotencyKey,
+      options,
+    ));
+  }
+
+  /**
+   * Diagnose inbound DNS for a domain
+   *
+   * @remarks
+   * Runs live DNS checks for inbound email readiness (MX correctness, apex CNAME collision, and common DNS blocklists for the Novu mail host). Returns structured issues with plain-language fixes.
+   */
+  async diagnose(
+    domain: string,
+    idempotencyKey?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.DomainsControllerDiagnoseDomainResponse> {
+    return unwrapAsync(domainsDiagnose(
+      this,
+      domain,
+      idempotencyKey,
+      options,
+    ));
+  }
+
+  /**
+   * Verify a domain
+   *
+   * @remarks
+   * Performs a live DNS lookup to refresh the MX record status of the domain and updates the verification status accordingly. Returns the latest domain configuration.
+   */
+  async verify(
+    domain: string,
+    idempotencyKey?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.DomainsControllerVerifyDomainResponse> {
+    return unwrapAsync(domainsVerify(
+      this,
+      domain,
+      idempotencyKey,
+      options,
+    ));
+  }
+}

package/src/sdk/integrations.ts

@@ -5,6 +5,8 @@
 import { integrationsCreate } from "../funcs/integrationsCreate.js";
 import { integrationsDelete } from "../funcs/integrationsDelete.js";
 import { integrationsGenerateChatOAuthUrl } from "../funcs/integrationsGenerateChatOAuthUrl.js";
+import { integrationsGenerateConnectOAuthUrl } from "../funcs/integrationsGenerateConnectOAuthUrl.js";
+import { integrationsGenerateLinkUserOAuthUrl } from "../funcs/integrationsGenerateLinkUserOAuthUrl.js";
 import { integrationsIntegrationsControllerAutoConfigureIntegration } from "../funcs/integrationsIntegrationsControllerAutoConfigureIntegration.js";
 import { integrationsList } from "../funcs/integrationsList.js";
 import { integrationsListActive } from "../funcs/integrationsListActive.js";
@@ -157,13 +159,60 @@ export class Integrations extends ClientSDK {
     ));
   }
 
+  /**
+   * Generate OAuth URL for a workspace/tenant connection
+   *
+   * @remarks
+   * Generate an OAuth URL that creates a workspace or tenant-level channel connection (Slack workspace install or MS Teams admin consent).
+   *     The generated URL expires after 5 minutes.
+   */
+  async generateConnectOAuthUrl(
+    generateConnectOauthUrlRequestDto:
+      components.GenerateConnectOauthUrlRequestDto,
+    idempotencyKey?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.IntegrationsControllerGenerateConnectOAuthUrlResponse> {
+    return unwrapAsync(integrationsGenerateConnectOAuthUrl(
+      this,
+      generateConnectOauthUrlRequestDto,
+      idempotencyKey,
+      options,
+    ));
+  }
+
+  /**
+   * Generate OAuth URL to link a subscriber user identity
+   *
+   * @remarks
+   * Generate an OAuth URL that links a specific subscriber to their chat identity (Slack user ID or MS Teams user OID).
+   *     The generated URL expires after 5 minutes.
+   */
+  async generateLinkUserOAuthUrl(
+    generateLinkUserOauthUrlRequestDto:
+      components.GenerateLinkUserOauthUrlRequestDto,
+    idempotencyKey?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<
+    operations.IntegrationsControllerGenerateLinkUserOAuthUrlResponse
+  > {
+    return unwrapAsync(integrationsGenerateLinkUserOAuthUrl(
+      this,
+      generateLinkUserOauthUrlRequestDto,
+      idempotencyKey,
+      options,
+    ));
+  }
+
   /**
    * Generate chat OAuth URL
    *
    * @remarks
-   * Generate an OAuth URL for chat integrations like Slack and MS Teams.
+   * **Deprecated** — use `POST /integrations/channel-connections/oauth` (connect) or `POST /integrations/channel-endpoints/oauth` (link_user) instead.
+   *     Generate an OAuth URL for chat integrations like Slack and MS Teams.
    *     This URL allows subscribers to authorize the integration, enabling the system to send messages
    *     through their chat workspace. The generated URL expires after 5 minutes.
+   *
+   * @deprecated method: This will be removed in a future release, please migrate away from it as soon as possible.
    */
   async generateChatOAuthUrl(
     generateChatOauthUrlRequestDto: components.GenerateChatOauthUrlRequestDto,