ce-storefront 0.5.2 → 0.5.4

package/src/models/operations/verifyotp.ts

@@ -21,6 +21,25 @@ export const VerifyOtpServerList = [
   "https://prod.api.commercengine.io/api/v1/{store_id}/storefront",
 ] as const;
 
+export type VerifyOtpSecurityOption1 = {
+  xApiKey: string;
+};
+
+export type VerifyOtpSecurityOption2 = {
+  authorization: string;
+};
+
+export type VerifyOtpSecurityOption3 = {
+  xApiKey: string;
+  authorization: string;
+};
+
+export type VerifyOtpSecurity = {
+  option1?: VerifyOtpSecurityOption1 | undefined;
+  option2?: VerifyOtpSecurityOption2 | undefined;
+  option3?: VerifyOtpSecurityOption3 | undefined;
+};
+
 /**
  * A string indicating the action to be performed.
  */
@@ -86,6 +105,269 @@ export type VerifyOtpResponseBody = {
   content?: VerifyOtpContent | undefined;
 };
 
+/** @internal */
+export const VerifyOtpSecurityOption1$inboundSchema: z.ZodType<
+  VerifyOtpSecurityOption1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-Api-Key": z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "X-Api-Key": "xApiKey",
+  });
+});
+
+/** @internal */
+export type VerifyOtpSecurityOption1$Outbound = {
+  "X-Api-Key": string;
+};
+
+/** @internal */
+export const VerifyOtpSecurityOption1$outboundSchema: z.ZodType<
+  VerifyOtpSecurityOption1$Outbound,
+  z.ZodTypeDef,
+  VerifyOtpSecurityOption1
+> = z.object({
+  xApiKey: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    xApiKey: "X-Api-Key",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace VerifyOtpSecurityOption1$ {
+  /** @deprecated use `VerifyOtpSecurityOption1$inboundSchema` instead. */
+  export const inboundSchema = VerifyOtpSecurityOption1$inboundSchema;
+  /** @deprecated use `VerifyOtpSecurityOption1$outboundSchema` instead. */
+  export const outboundSchema = VerifyOtpSecurityOption1$outboundSchema;
+  /** @deprecated use `VerifyOtpSecurityOption1$Outbound` instead. */
+  export type Outbound = VerifyOtpSecurityOption1$Outbound;
+}
+
+export function verifyOtpSecurityOption1ToJSON(
+  verifyOtpSecurityOption1: VerifyOtpSecurityOption1,
+): string {
+  return JSON.stringify(
+    VerifyOtpSecurityOption1$outboundSchema.parse(verifyOtpSecurityOption1),
+  );
+}
+
+export function verifyOtpSecurityOption1FromJSON(
+  jsonString: string,
+): SafeParseResult<VerifyOtpSecurityOption1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VerifyOtpSecurityOption1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VerifyOtpSecurityOption1' from JSON`,
+  );
+}
+
+/** @internal */
+export const VerifyOtpSecurityOption2$inboundSchema: z.ZodType<
+  VerifyOtpSecurityOption2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Authorization: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "Authorization": "authorization",
+  });
+});
+
+/** @internal */
+export type VerifyOtpSecurityOption2$Outbound = {
+  Authorization: string;
+};
+
+/** @internal */
+export const VerifyOtpSecurityOption2$outboundSchema: z.ZodType<
+  VerifyOtpSecurityOption2$Outbound,
+  z.ZodTypeDef,
+  VerifyOtpSecurityOption2
+> = z.object({
+  authorization: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    authorization: "Authorization",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace VerifyOtpSecurityOption2$ {
+  /** @deprecated use `VerifyOtpSecurityOption2$inboundSchema` instead. */
+  export const inboundSchema = VerifyOtpSecurityOption2$inboundSchema;
+  /** @deprecated use `VerifyOtpSecurityOption2$outboundSchema` instead. */
+  export const outboundSchema = VerifyOtpSecurityOption2$outboundSchema;
+  /** @deprecated use `VerifyOtpSecurityOption2$Outbound` instead. */
+  export type Outbound = VerifyOtpSecurityOption2$Outbound;
+}
+
+export function verifyOtpSecurityOption2ToJSON(
+  verifyOtpSecurityOption2: VerifyOtpSecurityOption2,
+): string {
+  return JSON.stringify(
+    VerifyOtpSecurityOption2$outboundSchema.parse(verifyOtpSecurityOption2),
+  );
+}
+
+export function verifyOtpSecurityOption2FromJSON(
+  jsonString: string,
+): SafeParseResult<VerifyOtpSecurityOption2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VerifyOtpSecurityOption2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VerifyOtpSecurityOption2' from JSON`,
+  );
+}
+
+/** @internal */
+export const VerifyOtpSecurityOption3$inboundSchema: z.ZodType<
+  VerifyOtpSecurityOption3,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  "X-Api-Key": z.string(),
+  Authorization: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "X-Api-Key": "xApiKey",
+    "Authorization": "authorization",
+  });
+});
+
+/** @internal */
+export type VerifyOtpSecurityOption3$Outbound = {
+  "X-Api-Key": string;
+  Authorization: string;
+};
+
+/** @internal */
+export const VerifyOtpSecurityOption3$outboundSchema: z.ZodType<
+  VerifyOtpSecurityOption3$Outbound,
+  z.ZodTypeDef,
+  VerifyOtpSecurityOption3
+> = z.object({
+  xApiKey: z.string(),
+  authorization: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    xApiKey: "X-Api-Key",
+    authorization: "Authorization",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace VerifyOtpSecurityOption3$ {
+  /** @deprecated use `VerifyOtpSecurityOption3$inboundSchema` instead. */
+  export const inboundSchema = VerifyOtpSecurityOption3$inboundSchema;
+  /** @deprecated use `VerifyOtpSecurityOption3$outboundSchema` instead. */
+  export const outboundSchema = VerifyOtpSecurityOption3$outboundSchema;
+  /** @deprecated use `VerifyOtpSecurityOption3$Outbound` instead. */
+  export type Outbound = VerifyOtpSecurityOption3$Outbound;
+}
+
+export function verifyOtpSecurityOption3ToJSON(
+  verifyOtpSecurityOption3: VerifyOtpSecurityOption3,
+): string {
+  return JSON.stringify(
+    VerifyOtpSecurityOption3$outboundSchema.parse(verifyOtpSecurityOption3),
+  );
+}
+
+export function verifyOtpSecurityOption3FromJSON(
+  jsonString: string,
+): SafeParseResult<VerifyOtpSecurityOption3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VerifyOtpSecurityOption3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VerifyOtpSecurityOption3' from JSON`,
+  );
+}
+
+/** @internal */
+export const VerifyOtpSecurity$inboundSchema: z.ZodType<
+  VerifyOtpSecurity,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  Option1: z.lazy(() => VerifyOtpSecurityOption1$inboundSchema).optional(),
+  Option2: z.lazy(() => VerifyOtpSecurityOption2$inboundSchema).optional(),
+  Option3: z.lazy(() => VerifyOtpSecurityOption3$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "Option1": "option1",
+    "Option2": "option2",
+    "Option3": "option3",
+  });
+});
+
+/** @internal */
+export type VerifyOtpSecurity$Outbound = {
+  Option1?: VerifyOtpSecurityOption1$Outbound | undefined;
+  Option2?: VerifyOtpSecurityOption2$Outbound | undefined;
+  Option3?: VerifyOtpSecurityOption3$Outbound | undefined;
+};
+
+/** @internal */
+export const VerifyOtpSecurity$outboundSchema: z.ZodType<
+  VerifyOtpSecurity$Outbound,
+  z.ZodTypeDef,
+  VerifyOtpSecurity
+> = z.object({
+  option1: z.lazy(() => VerifyOtpSecurityOption1$outboundSchema).optional(),
+  option2: z.lazy(() => VerifyOtpSecurityOption2$outboundSchema).optional(),
+  option3: z.lazy(() => VerifyOtpSecurityOption3$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    option1: "Option1",
+    option2: "Option2",
+    option3: "Option3",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace VerifyOtpSecurity$ {
+  /** @deprecated use `VerifyOtpSecurity$inboundSchema` instead. */
+  export const inboundSchema = VerifyOtpSecurity$inboundSchema;
+  /** @deprecated use `VerifyOtpSecurity$outboundSchema` instead. */
+  export const outboundSchema = VerifyOtpSecurity$outboundSchema;
+  /** @deprecated use `VerifyOtpSecurity$Outbound` instead. */
+  export type Outbound = VerifyOtpSecurity$Outbound;
+}
+
+export function verifyOtpSecurityToJSON(
+  verifyOtpSecurity: VerifyOtpSecurity,
+): string {
+  return JSON.stringify(
+    VerifyOtpSecurity$outboundSchema.parse(verifyOtpSecurity),
+  );
+}
+
+export function verifyOtpSecurityFromJSON(
+  jsonString: string,
+): SafeParseResult<VerifyOtpSecurity, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => VerifyOtpSecurity$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'VerifyOtpSecurity' from JSON`,
+  );
+}
+
 /** @internal */
 export const OtpAction$inboundSchema: z.ZodNativeEnum<typeof OtpAction> = z
   .nativeEnum(OtpAction);

package/src/sdk/auth.ts

@@ -46,11 +46,13 @@ 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(
+    security: operations.LoginWithPhoneSecurity,
     request: operations.LoginWithPhoneRequestBody,
     options?: RequestOptions,
   ): Promise<operations.LoginWithPhoneResponseBody> {
     return unwrapAsync(authLoginWithPhone(
       this,
+      security,
       request,
       options,
     ));
@@ -63,11 +65,13 @@ 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(
+    security: operations.LoginWithEmailSecurity,
     request: operations.LoginWithEmailRequestBody,
     options?: RequestOptions,
   ): Promise<operations.LoginWithEmailResponseBody> {
     return unwrapAsync(authLoginWithEmail(
       this,
+      security,
       request,
       options,
     ));
@@ -80,11 +84,13 @@ 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(
+    security: operations.LoginWithWhatsappSecurity,
     request: operations.LoginWithWhatsappRequestBody,
     options?: RequestOptions,
   ): Promise<operations.LoginWithWhatsappResponseBody> {
     return unwrapAsync(authLoginWithWhatsapp(
       this,
+      security,
       request,
       options,
     ));
@@ -97,11 +103,13 @@ export class Auth extends ClientSDK {
    * 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 verifyOtp(
+    security: operations.VerifyOtpSecurity,
     request: operations.VerifyOtpRequestBody,
     options?: RequestOptions,
   ): Promise<operations.VerifyOtpResponseBody> {
     return unwrapAsync(authVerifyOtp(
       this,
+      security,
       request,
       options,
     ));
@@ -216,11 +224,13 @@ 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(
+    security: operations.GenerateOtpSecurity,
     request: operations.GenerateOtpRequestBody,
     options?: RequestOptions,
   ): Promise<operations.GenerateOtpResponseBody> {
     return unwrapAsync(authGenerateOtp(
       this,
+      security,
       request,
       options,
     ));