Reference

The enums below are exported from src/pages/PrivateKitPage/PrivateKitPage.tsx.

PRIVATE_KIT_MESSAGE_TYPES

enum PRIVATE_KIT_MESSAGE_TYPES {
  // iframe → parent
  INIT                       = 'PRIVATE_KIT_INIT',
  USERNAME_UPDATED           = 'PRIVATE_KIT_USERNAME_UPDATED',
  USERNAME_VALIDATION_ERROR  = 'PRIVATE_KIT_USERNAME_VALIDATION_ERROR',
  EMAIL_UPDATED              = 'PRIVATE_KIT_EMAIL_UPDATED',
  EMAIL_VALIDATION_ERROR     = 'PRIVATE_KIT_EMAIL_VALIDATION_ERROR',
  EMAIL_CONFIRMED            = 'PRIVATE_KIT_EMAIL_CONFIRMED',
  EMAIL_CONFIRMATION_ERROR   = 'PRIVATE_KIT_EMAIL_CONFIRMATION_ERROR',
  EMAIL_CODE_RESENT          = 'PRIVATE_KIT_EMAIL_CODE_RESENT',
  PHONE_UPDATED              = 'PRIVATE_KIT_PHONE_UPDATED',
  PHONE_VALIDATION_ERROR     = 'PRIVATE_KIT_PHONE_VALIDATION_ERROR',
  PHONE_CONFIRMED            = 'PRIVATE_KIT_PHONE_CONFIRMED',
  PHONE_CONFIRMATION_ERROR   = 'PRIVATE_KIT_PHONE_CONFIRMATION_ERROR',
  PHONE_CODE_RESENT          = 'PRIVATE_KIT_PHONE_CODE_RESENT',
  PASSWORD_UPDATED           = 'PRIVATE_KIT_PASSWORD_UPDATED',
  PASSWORD_VALIDATION_ERROR  = 'PRIVATE_KIT_PASSWORD_VALIDATION_ERROR',
  AUTH_TOKEN_401             = 'PRIVATE_KIT_AUTH_TOKEN_401',

  // parent → iframe
  UPDATE_USERNAME            = 'PRIVATE_KIT_UPDATE_USERNAME',
  UPDATE_EMAIL               = 'PRIVATE_KIT_UPDATE_EMAIL',
  CONFIRM_EMAIL              = 'PRIVATE_KIT_CONFIRM_EMAIL',
  RESEND_EMAIL_CODE          = 'PRIVATE_KIT_RESEND_EMAIL_CODE',
  UPDATE_PHONE               = 'PRIVATE_KIT_UPDATE_PHONE',
  CONFIRM_PHONE              = 'PRIVATE_KIT_CONFIRM_PHONE',
  RESEND_PHONE_CODE          = 'PRIVATE_KIT_RESEND_PHONE_CODE',
  UPDATE_PASSWORD            = 'PRIVATE_KIT_UPDATE_PASSWORD',
}

USERNAME_VALIDATION_REASON

enum USERNAME_VALIDATION_REASON {
  REQUIRED = 'required',
  INVALID  = 'invalid',
  EXIST    = 'exist',
  UNKNOWN  = 'unknown',
}

enum EMAIL_VALIDATION_REASON {
  REQUIRED      = 'required',
  INVALID       = 'invalid',
  EXIST         = 'exist',
  LIMIT_REACHED = 'limitReached',
  UNKNOWN       = 'unknown',
}

enum EMAIL_CONFIRMATION_REASON {
  REQUIRED     = 'required',
  MAX          = 'max',
  INVALID      = 'invalid',
  INVALID_CODE = 'invalidCode',
  UNKNOWN      = 'unknown',
}

enum PHONE_VALIDATION_REASON {
  REQUIRED      = 'required',
  INVALID       = 'invalid',
  EXIST         = 'exist',
  LIMIT_REACHED = 'limitReached',
  UNKNOWN       = 'unknown',
}

enum PHONE_CONFIRMATION_REASON {
  REQUIRED     = 'required',
  MAX          = 'max',
  INVALID      = 'invalid',
  INVALID_CODE = 'invalidCode',
  UNKNOWN      = 'unknown',
}

enum PASSWORD_VALIDATION_REASON {
  REQUIRED_CURRENT = 'requiredCurrent',
  REQUIRED_NEW     = 'requiredNew',
  MIN              = 'min',
  UPPERCASE        = 'uppercase',
  SPECIAL          = 'special',
  NUMBER           = 'number',
  INVALID_CURRENT  = 'invalidCurrent',
  UNKNOWN          = 'unknown',
}

Validation helpers

The same rules that power the standalone forms (src/helpers/validations.ts).

const userNameValidation = (username: string) => {
  if (username.length < 5) return false;
  if (!/^(?=.*[A-Za-z])[A-Za-z0-9]+$/.test(username)) return false;
  return true;
};

A username must be at least 5 characters, alphanumeric only, and contain at least one letter.

const emailValidation = (email: string) =>
  /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/.test(email);

An email must match the basic [email protected] pattern.

const phoneValidation = (phone: string) => {
  try {
    return phoneUtil.isValidNumber(phoneUtil.parseAndKeepRawInput(phone));
  } catch {
    return false;
  }
};

A phone number is validated via google-libphonenumber. The host should send the number in international format (with + prefix), exactly as produced by the project's PhoneInput (i.e. ${phoneCode}${phone} concatenated).

Password strength rules (inline in PrivateKitPage):

const PASSWORD_MIN              = 6;
const PASSWORD_UPPERCASE_REGEX  = /[A-Z]/;
const PASSWORD_SPECIAL_REGEX    = /[!@#$%^&*(),.?":{}|<>-]/;
const PASSWORD_NUMBER_REGEX     = /[0-9]/;

A new password must be at least 6 characters and contain at least one uppercase letter, one digit and one special character. Rules are evaluated in order — only the first failing rule is reported back.

Verification codes are validated inline by PrivateKitPage:

const VERIFICATION_CODE_REGEX = /^\d+$/;
const VERIFICATION_CODE_MAX   = 6;

A code must be ≤ 6 characters and consist of digits only.

Full TypeScript interfaces

interface InitMessage {
  type: 'PRIVATE_KIT_INIT';
  payload: { connectionId: string };
}

interface UpdateUsernameMessage {
  type: 'PRIVATE_KIT_UPDATE_USERNAME';
  payload: {
    connectionId: string;
    username: string;
    authToken: string;
  };
}

interface UsernameUpdatedMessage {
  type: 'PRIVATE_KIT_USERNAME_UPDATED';
  payload: {
    connectionId: string;
    username: string;
  };
}

interface UsernameValidationErrorMessage {
  type: 'PRIVATE_KIT_USERNAME_VALIDATION_ERROR';
  payload: {
    connectionId: string;
    reason: USERNAME_VALIDATION_REASON;
    message?: string;
  };
}

interface UpdateEmailMessage {
  type: 'PRIVATE_KIT_UPDATE_EMAIL';
  payload: {
    connectionId: string;
    email: string;
    authToken: string;
  };
}

interface EmailUpdatedMessage {
  type: 'PRIVATE_KIT_EMAIL_UPDATED';
  payload: {
    connectionId: string;
    email: string;
  };
}

interface EmailValidationErrorMessage {
  type: 'PRIVATE_KIT_EMAIL_VALIDATION_ERROR';
  payload: {
    connectionId: string;
    reason: EMAIL_VALIDATION_REASON;
    message?: string;
  };
}

interface ConfirmEmailMessage {
  type: 'PRIVATE_KIT_CONFIRM_EMAIL';
  payload: {
    connectionId: string;
    confirmationCode: string;
    authToken: string;
  };
}

interface EmailConfirmedMessage {
  type: 'PRIVATE_KIT_EMAIL_CONFIRMED';
  payload: {
    connectionId: string;
    email: string;
    token: string;
    refreshToken: string;
  };
}

interface EmailConfirmationErrorMessage {
  type: 'PRIVATE_KIT_EMAIL_CONFIRMATION_ERROR';
  payload: {
    connectionId: string;
    reason: EMAIL_CONFIRMATION_REASON;
    message?: string;
  };
}

interface ResendEmailCodeMessage {
  type: 'PRIVATE_KIT_RESEND_EMAIL_CODE';
  payload: {
    connectionId: string;
    authToken: string;
  };
}

interface EmailCodeResentMessage {
  type: 'PRIVATE_KIT_EMAIL_CODE_RESENT';
  payload: {
    connectionId: string;
  };
}

interface UpdatePhoneMessage {
  type: 'PRIVATE_KIT_UPDATE_PHONE';
  payload: {
    connectionId: string;
    phoneNumber: string;
    authToken: string;
  };
}

interface PhoneUpdatedMessage {
  type: 'PRIVATE_KIT_PHONE_UPDATED';
  payload: {
    connectionId: string;
    phoneNumber: string;
  };
}

interface PhoneValidationErrorMessage {
  type: 'PRIVATE_KIT_PHONE_VALIDATION_ERROR';
  payload: {
    connectionId: string;
    reason: PHONE_VALIDATION_REASON;
    message?: string;
  };
}

interface ConfirmPhoneMessage {
  type: 'PRIVATE_KIT_CONFIRM_PHONE';
  payload: {
    connectionId: string;
    confirmationCode: string;
    authToken: string;
  };
}

interface PhoneConfirmedMessage {
  type: 'PRIVATE_KIT_PHONE_CONFIRMED';
  payload: {
    connectionId: string;
    phone: string;
    token: string;
    refreshToken: string;
  };
}

interface PhoneConfirmationErrorMessage {
  type: 'PRIVATE_KIT_PHONE_CONFIRMATION_ERROR';
  payload: {
    connectionId: string;
    reason: PHONE_CONFIRMATION_REASON;
    message?: string;
  };
}

interface ResendPhoneCodeMessage {
  type: 'PRIVATE_KIT_RESEND_PHONE_CODE';
  payload: {
    connectionId: string;
    authToken: string;
  };
}

interface PhoneCodeResentMessage {
  type: 'PRIVATE_KIT_PHONE_CODE_RESENT';
  payload: {
    connectionId: string;
  };
}

interface UpdatePasswordMessage {
  type: 'PRIVATE_KIT_UPDATE_PASSWORD';
  payload: {
    connectionId: string;
    currentPassword: string;
    newPassword: string;
    authToken: string;
  };
}

interface PasswordUpdatedMessage {
  type: 'PRIVATE_KIT_PASSWORD_UPDATED';
  payload: {
    connectionId: string;
  };
}

interface PasswordValidationErrorMessage {
  type: 'PRIVATE_KIT_PASSWORD_VALIDATION_ERROR';
  payload: {
    connectionId: string;
    reason: PASSWORD_VALIDATION_REASON;
    message?: string;
  };
}

interface AuthToken401Message {
  type: 'PRIVATE_KIT_AUTH_TOKEN_401';
  payload: {
    connectionId: string;
  };
}

type PrivateKitMessage =
  | InitMessage
  | UpdateUsernameMessage
  | UsernameUpdatedMessage
  | UsernameValidationErrorMessage
  | UpdateEmailMessage
  | EmailUpdatedMessage
  | EmailValidationErrorMessage
  | ConfirmEmailMessage
  | EmailConfirmedMessage
  | EmailConfirmationErrorMessage
  | ResendEmailCodeMessage
  | EmailCodeResentMessage
  | UpdatePhoneMessage
  | PhoneUpdatedMessage
  | PhoneValidationErrorMessage
  | ConfirmPhoneMessage
  | PhoneConfirmedMessage
  | PhoneConfirmationErrorMessage
  | ResendPhoneCodeMessage
  | PhoneCodeResentMessage
  | UpdatePasswordMessage
  | PasswordUpdatedMessage
  | PasswordValidationErrorMessage
  | AuthToken401Message;

Backend endpoints used by the iframe

Step	Endpoint	Method
Resolve current user	/private/api/v1/users	GET
Check whether username/email/phone is taken	/private/api/v1/users/exists	POST
Persist new username	/private/api/v1/users/{id}/setUsername	POST
Persist new email (triggers verification)	/private/api/v1/users/{id}/setEmail	POST
Persist new phone (triggers SMS)	/private/api/v1/users/{id}/setPhone	POST
Confirm pending email or phone change	/private/api/v1/verification/confirm/{id}	POST
Re-send the email verification code	/private/api/v1/verification/resendEmail/{id}	POST
Re-send the phone verification code (SMS)	/private/api/v1/verification/resendSms/{id}	POST
Change password	/private/api/v1/users/changePassword	POST

All endpoints require Authorization: Bearer <authToken>. The iframe never persists the token — it only forwards what arrives in each action message.