ce-storefront 0.4.6 → 0.4.8

package/src/models/operations/verifyotp.ts

@@ -0,0 +1,306 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export const VerifyOtpServerList = [
+  /**
+   * Staging Server
+   */
+  "https://staging.api.commercengine.io/api/v1/{store_id}/storefront",
+  /**
+   * Prod Server
+   */
+  "https://prod.api.commercengine.io/api/v1/{store_id}/storefront",
+] as const;
+
+/**
+ * A string indicating the action to be performed.
+ */
+export const OtpAction = {
+  Login: "login",
+  Register: "register",
+  ResetPassword: "reset-password",
+  VerifyPhone: "verify-phone",
+  VerifyEmail: "verify-email",
+  UpdatePhone: "update-phone",
+  UpdateEmail: "update-email",
+} as const;
+/**
+ * A string indicating the action to be performed.
+ */
+export type OtpAction = ClosedEnum<typeof OtpAction>;
+
+export type VerifyOtpRequestBody = {
+  /**
+   * A string representing the one-time password.
+   */
+  otp: string;
+  /**
+   * A string representing the OTP token.
+   */
+  otpToken: string;
+  /**
+   * A string indicating the action to be performed.
+   */
+  otpAction: OtpAction;
+};
+
+/**
+ * An object containing the response content.
+ */
+export type VerifyOtpContent = {
+  user?: components.User | undefined;
+  /**
+   * A string representing the access token.
+   */
+  accessToken?: string | undefined;
+  /**
+   * A string representing the refresh token.
+   */
+  refreshToken?: string | undefined;
+};
+
+/**
+ * OK
+ */
+export type VerifyOtpResponseBody = {
+  /**
+   * A string providing additional information about the response.
+   */
+  message?: string | undefined;
+  /**
+   *  A boolean indicating whether the operation was successful or not.
+   */
+  success?: boolean | undefined;
+  /**
+   * An object containing the response content.
+   */
+  content?: VerifyOtpContent | undefined;
+};
+
+/** @internal */
+export const OtpAction$inboundSchema: z.ZodNativeEnum<typeof OtpAction> = z
+  .nativeEnum(OtpAction);
+
+/** @internal */
+export const OtpAction$outboundSchema: z.ZodNativeEnum<typeof OtpAction> =
+  OtpAction$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace OtpAction$ {
+  /** @deprecated use `OtpAction$inboundSchema` instead. */
+  export const inboundSchema = OtpAction$inboundSchema;
+  /** @deprecated use `OtpAction$outboundSchema` instead. */
+  export const outboundSchema = OtpAction$outboundSchema;
+}
+
+/** @internal */
+export const VerifyOtpRequestBody$inboundSchema: z.ZodType<
+  VerifyOtpRequestBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  otp: z.string(),
+  otp_token: z.string(),
+  otp_action: OtpAction$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "otp_token": "otpToken",
+    "otp_action": "otpAction",
+  });
+});
+
+/** @internal */
+export type VerifyOtpRequestBody$Outbound = {
+  otp: string;
+  otp_token: string;
+  otp_action: string;
+};
+
+/** @internal */
+export const VerifyOtpRequestBody$outboundSchema: z.ZodType<
+  VerifyOtpRequestBody$Outbound,
+  z.ZodTypeDef,
+  VerifyOtpRequestBody
+> = z.object({
+  otp: z.string(),
+  otpToken: z.string(),
+  otpAction: OtpAction$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    otpToken: "otp_token",
+    otpAction: "otp_action",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace VerifyOtpRequestBody$ {
+  /** @deprecated use `VerifyOtpRequestBody$inboundSchema` instead. */
+  export const inboundSchema = VerifyOtpRequestBody$inboundSchema;
+  /** @deprecated use `VerifyOtpRequestBody$outboundSchema` instead. */
+  export const outboundSchema = VerifyOtpRequestBody$outboundSchema;
+  /** @deprecated use `VerifyOtpRequestBody$Outbound` instead. */
+  export type Outbound = VerifyOtpRequestBody$Outbound;
+}
+
+export function verifyOtpRequestBodyToJSON(
+  verifyOtpRequestBody: VerifyOtpRequestBody,
+): string {
+  return JSON.stringify(
+    VerifyOtpRequestBody$outboundSchema.parse(verifyOtpRequestBody),
+  );
+}
+
+export function verifyOtpRequestBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<VerifyOtpRequestBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VerifyOtpRequestBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VerifyOtpRequestBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const VerifyOtpContent$inboundSchema: z.ZodType<
+  VerifyOtpContent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  user: components.User$inboundSchema.optional(),
+  access_token: z.string().optional(),
+  refresh_token: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "access_token": "accessToken",
+    "refresh_token": "refreshToken",
+  });
+});
+
+/** @internal */
+export type VerifyOtpContent$Outbound = {
+  user?: components.User$Outbound | undefined;
+  access_token?: string | undefined;
+  refresh_token?: string | undefined;
+};
+
+/** @internal */
+export const VerifyOtpContent$outboundSchema: z.ZodType<
+  VerifyOtpContent$Outbound,
+  z.ZodTypeDef,
+  VerifyOtpContent
+> = z.object({
+  user: components.User$outboundSchema.optional(),
+  accessToken: z.string().optional(),
+  refreshToken: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    accessToken: "access_token",
+    refreshToken: "refresh_token",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace VerifyOtpContent$ {
+  /** @deprecated use `VerifyOtpContent$inboundSchema` instead. */
+  export const inboundSchema = VerifyOtpContent$inboundSchema;
+  /** @deprecated use `VerifyOtpContent$outboundSchema` instead. */
+  export const outboundSchema = VerifyOtpContent$outboundSchema;
+  /** @deprecated use `VerifyOtpContent$Outbound` instead. */
+  export type Outbound = VerifyOtpContent$Outbound;
+}
+
+export function verifyOtpContentToJSON(
+  verifyOtpContent: VerifyOtpContent,
+): string {
+  return JSON.stringify(
+    VerifyOtpContent$outboundSchema.parse(verifyOtpContent),
+  );
+}
+
+export function verifyOtpContentFromJSON(
+  jsonString: string,
+): SafeParseResult<VerifyOtpContent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VerifyOtpContent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VerifyOtpContent' from JSON`,
+  );
+}
+
+/** @internal */
+export const VerifyOtpResponseBody$inboundSchema: z.ZodType<
+  VerifyOtpResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  message: z.string().optional(),
+  success: z.boolean().optional(),
+  content: z.lazy(() => VerifyOtpContent$inboundSchema).optional(),
+});
+
+/** @internal */
+export type VerifyOtpResponseBody$Outbound = {
+  message?: string | undefined;
+  success?: boolean | undefined;
+  content?: VerifyOtpContent$Outbound | undefined;
+};
+
+/** @internal */
+export const VerifyOtpResponseBody$outboundSchema: z.ZodType<
+  VerifyOtpResponseBody$Outbound,
+  z.ZodTypeDef,
+  VerifyOtpResponseBody
+> = z.object({
+  message: z.string().optional(),
+  success: z.boolean().optional(),
+  content: z.lazy(() => VerifyOtpContent$outboundSchema).optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace VerifyOtpResponseBody$ {
+  /** @deprecated use `VerifyOtpResponseBody$inboundSchema` instead. */
+  export const inboundSchema = VerifyOtpResponseBody$inboundSchema;
+  /** @deprecated use `VerifyOtpResponseBody$outboundSchema` instead. */
+  export const outboundSchema = VerifyOtpResponseBody$outboundSchema;
+  /** @deprecated use `VerifyOtpResponseBody$Outbound` instead. */
+  export type Outbound = VerifyOtpResponseBody$Outbound;
+}
+
+export function verifyOtpResponseBodyToJSON(
+  verifyOtpResponseBody: VerifyOtpResponseBody,
+): string {
+  return JSON.stringify(
+    VerifyOtpResponseBody$outboundSchema.parse(verifyOtpResponseBody),
+  );
+}
+
+export function verifyOtpResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<VerifyOtpResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VerifyOtpResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VerifyOtpResponseBody' from JSON`,
+  );
+}

package/src/sdk/auth.ts

@@ -2,30 +2,25 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
+import { authCheckVerificationStatus } from "../funcs/authCheckVerificationStatus.js";
+import { authCreateNotificationPreferences } from "../funcs/authCreateNotificationPreferences.js";
 import { authGenerateOtp } from "../funcs/authGenerateOtp.js";
-import { authLoginAnonymously } from "../funcs/authLoginAnonymously.js";
+import { authGetAnonymousToken } from "../funcs/authGetAnonymousToken.js";
+import { authGetNotificationPreferences } from "../funcs/authGetNotificationPreferences.js";
+import { authGetUserDetail } from "../funcs/authGetUserDetail.js";
 import { authLoginWithEmail } from "../funcs/authLoginWithEmail.js";
-import { authLoginWithPassword } from "../funcs/authLoginWithPassword.js";
 import { authLoginWithPhone } from "../funcs/authLoginWithPhone.js";
 import { authLoginWithWhatsapp } from "../funcs/authLoginWithWhatsapp.js";
+import { authLogout } from "../funcs/authLogout.js";
 import { authRefreshToken } from "../funcs/authRefreshToken.js";
-import { authRegisterWithEmail } from "../funcs/authRegisterWithEmail.js";
-import { authRegisterWithPassword } from "../funcs/authRegisterWithPassword.js";
-import { authRegisterWithPhone } from "../funcs/authRegisterWithPhone.js";
-import { authRegisterWithWhatsapp } from "../funcs/authRegisterWithWhatsapp.js";
-import { authVerifyEmailPhone } from "../funcs/authVerifyEmailPhone.js";
+import { authUpdateNotificationPreferences } from "../funcs/authUpdateNotificationPreferences.js";
+import { authUpdateUser } from "../funcs/authUpdateUser.js";
 import { authVerifyOtp } from "../funcs/authVerifyOtp.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
-import { CeStorefrontUser } from "./cestorefrontuser.js";
 
 export class Auth extends ClientSDK {
-  private _user?: CeStorefrontUser;
-  get user(): CeStorefrontUser {
-    return (this._user ??= new CeStorefrontUser(this._options));
-  }
-
   /**
    * Anonymous user
    *
@@ -33,11 +28,11 @@ export class Auth extends ClientSDK {
    * This API’s focus is on anonymous users who have not undergone the formal account creation process. These anonymous users are associated with a unique ID, ensuring that even in the absence of a fully realized account, there is a distinct and trackable identity for each user.
    * To interact with the system, each anonymous user is issued an access token. This access token plays a dual role in the system: it serves as a means of authenticating the user and it also acts as a tool for authorization, determining what actions the authenticated user is permitted to perform.
    */
-  async loginAnonymously(
-    security: operations.PostAuthAnonymousSecurity,
+  async getAnonymousToken(
+    security: operations.GetAnonymousTokenSecurity,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthAnonymousResponseBody> {
-    return unwrapAsync(authLoginAnonymously(
+  ): Promise<operations.GetAnonymousTokenResponseBody> {
+    return unwrapAsync(authGetAnonymousToken(
       this,
       security,
       options,
@@ -51,9 +46,9 @@ export class Auth extends ClientSDK {
    * This API enables users to authenticate into the system using their phone number. It provides a secure way for users to log in by verifying their identity through a one-time password (OTP) sent to their registered phone.
    */
   async loginWithPhone(
-    request: operations.PostAuthLoginPhoneRequestBody,
+    request: operations.LoginWithPhoneRequestBody,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthLoginPhoneResponseBody> {
+  ): Promise<operations.LoginWithPhoneResponseBody> {
     return unwrapAsync(authLoginWithPhone(
       this,
       request,
@@ -68,9 +63,9 @@ export class Auth extends ClientSDK {
    * This API enables users to authenticate into the system using their email address. It provides a secure way for users to Login by verifying their identity through a one-time password (OTP) sent to their email address.
    */
   async loginWithEmail(
-    request: operations.PostAuthLoginEmailRequestBody,
+    request: operations.LoginWithEmailRequestBody,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthLoginEmailResponseBody> {
+  ): Promise<operations.LoginWithEmailResponseBody> {
     return unwrapAsync(authLoginWithEmail(
       this,
       request,
@@ -85,9 +80,9 @@ export class Auth extends ClientSDK {
    * This API enables users to authenticate into the system using their WhatsApp Number. It provides a secure way for users to Login by verifying their identity through a one-time password (OTP) sent to their WhatsApp Number.
    */
   async loginWithWhatsapp(
-    request: operations.PostAuthLoginWhatsappRequestBody,
+    request: operations.LoginWithWhatsappRequestBody,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthLoginWhatsappResponseBody> {
+  ): Promise<operations.LoginWithWhatsappResponseBody> {
     return unwrapAsync(authLoginWithWhatsapp(
       this,
       request,
@@ -96,16 +91,16 @@ export class Auth extends ClientSDK {
   }
 
   /**
-   * Login with password
+   * Verify OTP
    *
    * @remarks
-   * This API endpoint allows users to Login using their password. It requires the following parameters: email/phone and password. Also allows users to securely Login and obtain access and refresh tokens for subsequent API calls.
+   * This API endpoint allows you to verify a one-time password (OTP) for authentication purposes. By sending a request to this endpoint with the necessary parameters, you can confirm the validity of the OTP provided by the user.
    */
-  async loginWithPassword(
-    request: operations.PostAuthLoginPasswordRequestBody,
+  async verifyOtp(
+    request: operations.VerifyOtpRequestBody,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthLoginPasswordResponseBody> {
-    return unwrapAsync(authLoginWithPassword(
+  ): Promise<operations.VerifyOtpResponseBody> {
+    return unwrapAsync(authVerifyOtp(
       this,
       request,
       options,
@@ -113,16 +108,16 @@ export class Auth extends ClientSDK {
   }
 
   /**
-   * Verify OTP
+   * Retrieve a user
    *
    * @remarks
-   * This API endpoint allows you to verify a one-time password (OTP) for authentication purposes. By sending a request to this endpoint with the necessary parameters, you can confirm the validity of the OTP provided by the user.
+   * The Retrieve User API is designed to facilitate the retrieval of comprehensive user information from the system. A required parameter is a user-id of the user whose information needs to be retrieved.
    */
-  async verifyOtp(
-    request: operations.PostAuthVerifyOtpRequestBody,
+  async getUserDetail(
+    request: operations.GetUserDetailRequest,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthVerifyOtpResponseBody> {
-    return unwrapAsync(authVerifyOtp(
+  ): Promise<operations.GetUserDetailResponseBody> {
+    return unwrapAsync(authGetUserDetail(
       this,
       request,
       options,
@@ -130,16 +125,16 @@ export class Auth extends ClientSDK {
   }
 
   /**
-   * Register with phone
+   * Update a user
    *
    * @remarks
-   * This API provides the functionality to register a user using their phone number. This allows you to securely register users and obtain access and refresh tokens for subsequent API calls.
+   * The Update User API helps to efficiently modify and enhance user information within the system, ensuring that user profiles remain accurate and up-to-date. This API provides a secure and flexible mechanism for updating specific details while maintaining adherence to established conventions.
    */
-  async registerWithPhone(
-    request: operations.PostAuthRegisterPhoneRequestBody,
+  async updateUser(
+    request: operations.UpdateUserRequest,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthRegisterPhoneResponseBody> {
-    return unwrapAsync(authRegisterWithPhone(
+  ): Promise<operations.UpdateUserResponseBody> {
+    return unwrapAsync(authUpdateUser(
       this,
       request,
       options,
@@ -147,17 +142,16 @@ export class Auth extends ClientSDK {
   }
 
   /**
-   * Register with email
+   * Refresh access token
    *
    * @remarks
-   * The API allows users to register with their email address. This endpoint enables the registration process by requesting the user's email, first name, last name, phone number, and OTP token.
-   * The response will include a message indicating the success or failure of the registration process, as well as additional information such as the user's information, access token and refresh token.
+   * The Refresh Access Token API is an integral component designed to enhance security and user experience. It enables clients to refresh their access tokens seamlessly, extending user sessions without compromising security.
    */
-  async registerWithEmail(
-    request: operations.PostAuthRegisterEmailRequestBody,
+  async refreshToken(
+    request: operations.RefreshTokenRequestBody,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthRegisterEmailResponseBody> {
-    return unwrapAsync(authRegisterWithEmail(
+  ): Promise<operations.RefreshTokenResponseBody> {
+    return unwrapAsync(authRefreshToken(
       this,
       request,
       options,
@@ -165,17 +159,16 @@ export class Auth extends ClientSDK {
   }
 
   /**
-   * Register with whatsapp
+   * Retrieve user notification preferences
    *
    * @remarks
-   * The API allows users to register with their WhatsApp. This endpoint enables the registration process by requesting the user's WhatsApp number, first name, last name, email, and OTP token.
-   * The response will include a message indicating the success or failure of the registration process, as well as additional information such as the user's information, access token and refresh token.
+   * The Retrieve Notification Preferences API allows clients to fetch a user's notification preferences based on their unique user identifier (user_id).
    */
-  async registerWithWhatsapp(
-    request: operations.PostAuthRegisterWhatsappRequestBody,
+  async getNotificationPreferences(
+    request: operations.GetNotificationPreferencesRequest,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthRegisterWhatsappResponseBody> {
-    return unwrapAsync(authRegisterWithWhatsapp(
+  ): Promise<operations.GetNotificationPreferencesResponseBody> {
+    return unwrapAsync(authGetNotificationPreferences(
       this,
       request,
       options,
@@ -183,17 +176,16 @@ export class Auth extends ClientSDK {
   }
 
   /**
-   * Register with password
+   * Create user notification preferences
    *
    * @remarks
-   * The User Registration with Password API facilitates user onboarding by allowing registration through a combination of phone number and email. API collects essential registration details, including phone number, email, password and the confirmation of the chosen password.
-   * The response will include a message indicating the success or failure of the registration process, as well as additional information such as the user's information, access token and refresh token.
+   * Create user notification preferences API allows clients to create a user's notification preferences based on their unique user identifier (user_id).
    */
-  async registerWithPassword(
-    request: operations.PostAuthRegisterPasswordRequestBody,
+  async createNotificationPreferences(
+    request: operations.CreateNotificationPreferencesRequest,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthRegisterPasswordResponseBody> {
-    return unwrapAsync(authRegisterWithPassword(
+  ): Promise<operations.CreateNotificationPreferencesResponseBody> {
+    return unwrapAsync(authCreateNotificationPreferences(
       this,
       request,
       options,
@@ -201,16 +193,16 @@ export class Auth extends ClientSDK {
   }
 
   /**
-   * Refresh access token
+   * Update user notification preferences
    *
    * @remarks
-   * The Refresh Access Token API is an integral component designed to enhance security and user experience. It enables clients to refresh their access tokens seamlessly, extending user sessions without compromising security.
+   * Update Notification Preferences API allows clients to update a user's notification preferences based on their unique user identifier (user_id).
    */
-  async refreshToken(
-    request: operations.PostAuthRefreshTokenRequestBody,
+  async updateNotificationPreferences(
+    request: operations.UpdateNotificationPreferencesRequest,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthRefreshTokenResponseBody> {
-    return unwrapAsync(authRefreshToken(
+  ): Promise<operations.UpdateNotificationPreferencesResponseBody> {
+    return unwrapAsync(authUpdateNotificationPreferences(
       this,
       request,
       options,
@@ -224,9 +216,9 @@ export class Auth extends ClientSDK {
    * Generating a One-Time Password (OTP) typically involves creating a random code that is sent to a user for authentication or verification purposes.
    */
   async generateOtp(
-    request: operations.PostAuthGenerateOtpRequestBody,
+    request: operations.GenerateOtpRequestBody,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthGenerateOtpResponseBody> {
+  ): Promise<operations.GenerateOtpResponseBody> {
     return unwrapAsync(authGenerateOtp(
       this,
       request,
@@ -235,16 +227,31 @@ export class Auth extends ClientSDK {
   }
 
   /**
-   * Check verified email phone
+   * Logout user
+   *
+   * @remarks
+   * The Logout User API initiate the logout process for a user. Upon a successful request, the API responds with a confirmation message. If the user is not found or there's an issue with the request, an error response is returned with an appropriate message.
+   */
+  async logout(
+    options?: RequestOptions,
+  ): Promise<operations.LogoutResponseBody> {
+    return unwrapAsync(authLogout(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Check email/phone verification status
    *
    * @remarks
    * The Check Verification Status API allows to verify the status of email and phone number verification for a specific user. Upon a successful request, the API responds with the verification status of the provided email and phone number. If the user is not found or there's an issue with the request, an error response is returned with an appropriate message.
    */
-  async verifyEmailPhone(
-    request: operations.PostAuthVerifiedEmailPhoneRequestBody,
+  async checkVerificationStatus(
+    request: operations.CheckVerificationStatusRequestBody,
     options?: RequestOptions,
-  ): Promise<operations.PostAuthVerifiedEmailPhoneResponseBody> {
-    return unwrapAsync(authVerifyEmailPhone(
+  ): Promise<operations.CheckVerificationStatusResponseBody> {
+    return unwrapAsync(authCheckVerificationStatus(
       this,
       request,
       options,

package/src/sdk/campaigns.ts

@@ -2,12 +2,26 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { ClientSDK } from "../lib/sdks.js";
-import { Newsletter } from "./newsletter.js";
+import { campaignsSubscribeNewsletter } from "../funcs/campaignsSubscribeNewsletter.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
 
 export class Campaigns extends ClientSDK {
-  private _newsletter?: Newsletter;
-  get newsletter(): Newsletter {
-    return (this._newsletter ??= new Newsletter(this._options));
+  /**
+   * Subscribe to newsletter
+   *
+   * @remarks
+   * Subscribe to newsletter
+   */
+  async subscribeNewsletter(
+    request: operations.SubscribeNewsletterRequestBody,
+    options?: RequestOptions,
+  ): Promise<operations.SubscribeNewsletterResponseBody> {
+    return unwrapAsync(campaignsSubscribeNewsletter(
+      this,
+      request,
+      options,
+    ));
   }
 }