import { IPaginationOptions, PermissionCheckModeEnum as PermissionCheckModeEnum$1, IHasRequiredPermissions as IHasRequiredPermissions$1 } from 'zaions-tool-kit';
import moment from 'moment';

declare enum UserTypeEnum {
    merchant = "merchant",
    employer = "employer",
    employee = "employee",
    studentBody = "studentBody",
    admin = "admin",
    all = "all",
    madeByMe = "madeByMe",
    owner = "owner",
    superUser = "superUser",
    standardUser = "standardUser",
    invalid = "invalid"
}
declare enum StatusEnum {
    draft = "draft",
    approved = "approved",
    live = "live",
    scheduled = "scheduled",
    ended = "ended",
    endingSoon = "endingSoon",
    pendingApproval = "pendingApproval",
    disapproved = "disapproved",
    invalid = "invalid",
    pending = "pending",
    accepted = "accepted",
    paused = "paused",
    available = "available",
    verified = "verified",
    unverified = "unverified",
    active = "active",
    inactive = "inactive",
    deprecated = "deprecated",
    added = "added",
    invited = "invited",
    signedUp = "signedUp",
    completed = "completed",
    failed = "failed",
    inProgress = "inProgress",
    processing = "processing"
}
declare enum BrandLogoEnum {
    noLogo = "noLogo",
    usePerkLogo = "usePerkLogo",
    useProfileLogo = "useProfileLogo"
}
declare enum OrderTypeEnum {
    purchased = "purchased",
    free = "free"
}
declare enum UnavailableItemTypeEnum {
    outOfStock = "outOfStock",
    perUserLimitReached = "perUserLimitReached",
    draft = "draft",
    scheduled = "scheduled",
    expired = "expired",
    deleted = "deleted"
}
declare enum GroupTypeEnum {
    superUsers = "superUsers",
    allUsers = "allUsers",
    normal = "normal"
}
declare enum FormModeEnum {
    add = "add",
    edit = "edit",
    list = "list"
}
declare enum AllowedAccessBecauseEnum {
    manual = "manual",
    emailFormat = "emailFormat",
    newSignupsEmployees = "newSignupsEmployees"
}
declare enum PlatformEnum {
    android = "android",
    ios = "ios",
    web = "web"
}
declare enum ValidationRuleEnum {
    string = "string",
    email = "email",
    password = "password",
    positiveInt = "positiveInt",
    url = "url"
}
declare enum TestAccountsTypeEnum {
    internal = "internal",
    external = "external"
}
declare enum IntegrationAppEnum {
    microsoftTeams = "microsoftTeams",
    slack = "slack",
    stripe = "stripe",
    pushNotifications = "pushNotifications"
}
declare enum IntegrationStateEnum {
    enabled = "enabled",
    disabled = "disabled",
    notConnected = "notConnected"
}
declare enum PerkActionEnum {
    addEdit = "addEdit",
    pubUnPub = "pubUnPub",
    sendForApproval = "sendForApproval"
}
declare enum SortOrderEnum {
    ascend = "ascend",
    descend = "descend"
}
declare enum LocationTypeEnum {
    point = "Point",
    lineString = "LineString",
    polygon = "Polygon",
    multiPoint = "MultiPoint"
}
declare enum ButtonTypeEnum {
    primary = "primary",
    dashed = "dashed",
    default = "default",
    link = "link",
    text = "text"
}
declare enum ButtonVariantEnum {
    link = "link",
    text = "text",
    dashed = "dashed",
    outlined = "outlined",
    solid = "solid",
    filled = "filled"
}
declare enum ButtonColorEnum {
    default = "default",
    danger = "danger",
    primary = "primary",
    blue = "blue",
    purple = "purple",
    cyan = "cyan",
    green = "green",
    magenta = "magenta",
    pink = "pink",
    red = "red",
    orange = "orange",
    yellow = "yellow",
    volcano = "volcano",
    geekBlue = "geekblue",
    lime = "lime",
    gold = "gold"
}
declare enum NotificationPermissionsEnum {
    granted = "granted",
    denied = "denied",
    default = "default"
}
declare enum CaptureMethodEnum {
    automatic = "automatic",
    manual = "manual"
}
declare enum ButtonSizeEnum {
    small = "small",
    middle = "middle",
    large = "large"
}
declare enum FlexAlignEnum {
    flexStart = "flex-start",
    center = "center",
    flexEnd = "flex-end"
}
declare enum FlexJustifyEnum {
    flexStart = "flex-start",
    center = "center",
    flexEnd = "flex-end",
    spaceBetween = "space-between",
    spaceAround = "space-around",
    spaceEvenly = "space-evenly"
}
declare enum CustomCategoryImageTypeEnum {
    svg = "svg",
    other = "other"
}
declare enum SelectedCategoryTypeEnum {
    category = "category",
    subcategory = "subcategory"
}
declare enum ImportRedeemCodesTypeEnum {
    file = "file",
    csv = "csv"
}
declare enum RedeemCodeTypeEnum {
    file = "file",
    url = "url",
    text = "text"
}
declare enum PlatformTypeEnum {
    web = "web",
    android = "android",
    ios = "ios"
}
declare enum ApiResponseStatusEnum {
    success = "success",
    error = "error"
}
declare enum PermissionCheckModeEnum {
    every = "every",
    any = "any"
}
declare enum EnvironmentTypeEnum {
    frontend = "frontend",
    backend = "backend"
}
declare enum DataStoredFromEnum {
    mobileBrowser = "mobileBrowser",
    mobileApp = "mobileApp"
}
declare enum BudgetStatusEnum {
    notClaimed = "notClaimed",
    requested = "requested",
    granted = "granted",
    rejected = "rejected",
    expired = "expired",
    refunded = "refunded"
}
declare enum PerkTypeEnum {
    perk = "perk",
    benefit = "benefit"
}
declare enum FormActionEnum {
    add = "add",
    update = "update"
}
declare enum QueryKeyTypeEnum {
    id = "id",
    roleIdentifier = "roleIdentifier",
    defaultRoleForEmployer = "defaultRoleForEmployer",
    defaultRoleForStudentBody = "defaultRoleForStudentBody",
    defaultRoleForMerchant = "defaultRoleForMerchant",
    defaultRoleForMerchantEmployee = "defaultRoleForMerchantEmployee",
    defaultRoleForStudentBodyEmployee = "defaultRoleForStudentBodyEmployee",
    defaultRoleForStudentBodySuperUser = "defaultRoleForStudentBodySuperUser",
    defaultRoleForEmployerEmployee = "defaultRoleForEmployerEmployee",
    defaultRoleForEmployerSuperUser = "defaultRoleForEmployerSuperUser",
    defaultRoleForAdmin = "defaultRoleForAdmin"
}
declare enum UserLogChangeTypeEnum {
    validationFailed = "validationFailed",
    roleUpdate = "roleUpdate",
    processingError = "processingError"
}
declare enum DateFormatEnum {
    default = "default",
    dateTimeWithAt = "dateTimeWithAt",
    dateTimeWithDash = "dateTimeWithDash"
}
declare enum BrandCarouselSettingEffectEnum {
    fade = "fade",
    scrollx = "scrollx"
}

declare enum PermissionCategoryEnum {
    userManagement = "userManagement",
    roleManagement = "roleManagement",
    perkManagement = "perkManagement",
    perkApprovalManagement = "perkApprovalManagement",
    permissionManagement = "permissionManagement"
}
declare enum PermissionsEnum {
    viewAnyPerk = "viewAnyPerk",
    deleteAnyPerk = "deleteAnyPerk",
    updateAnyPerk = "updateAnyPerk",
    listPerks = "listPerks",
    viewPerk = "viewPerk",
    canViewNonPublishedPerkOfOrganizationOwner = "canViewNonPublishedPerkOfOrganizationOwner",
    canViewNonPublishedPerkOfOrganizationSuperUser = "canViewNonPublishedPerkOfOrganizationSuperUser",
    canViewNonPublishedPerkOfOrganizationStandardUser = "canViewNonPublishedPerkOfOrganizationStandardUser",
    createPerk = "createPerk",
    updatePerk = "updatePerk",
    updateOrgUserPerk = "updateOrgUserPerk",
    deletePerk = "deletePerk",
    deleteOrgUserPerk = "deleteOrgUserPerk",
    canAddDescriptionToPerk = "canAddDescriptionToPerk",
    canAddImageToPerk = "canAddImageToPerk",
    canAddCustomCategoryToPerk = "canAddCustomCategoryToPerk",
    canAddLogoToPerk = "canAddLogoToPerk",
    canAddCategoryToPerk = "canAddCategoryToPerk",
    canAddGroupsToPerk = "canAddGroupsToPerk",
    canSelectOrganisationsInPerk = "canSelectOrganisationsInPerk",
    canAddContactToPerk = "canAddContactToPerk",
    canAddDisplayScheduleToPerk = "canAddDisplayScheduleToPerk",
    canAddDiscountToPerk = "canAddDiscountToPerk",
    canAddPurchasableToPerk = "canAddPurchasableToPerk",
    canAddLimitsAndConstraintsToPerk = "canAddLimitsAndConstraintsToPerk",
    canAddCodesToPerk = "canAddCodesToPerk",
    canAddInterestToPerk = "canAddInterestToPerk",
    canAddLocationsToPerk = "canAddLocationsToPerk",
    canPublishPerk = "canPublishPerk",
    listAllPerkApprovalRequests = "listAllPerkApprovalRequests",
    listPerkApprovalRequests = "listPerkApprovalRequests",
    viewAnyPerkApprovalRequest = "viewAnyPerkApprovalRequest",
    viewPerkApprovalRequest = "viewPerkApprovalRequest",
    rejectAnyPerkApprovalRequest = "rejectAnyPerkApprovalRequest",
    rejectPerkApprovalRequest = "rejectPerkApprovalRequest",
    approveAnyPerkApprovalRequest = "approveAnyPerkApprovalRequest",
    approvePerkApprovalRequest = "approvePerkApprovalRequest",
    listRoles = "listRoles",
    viewRole = "viewRole",
    createRole = "createRole",
    updateRole = "updateRole",
    deleteRole = "deleteRole",
    canAssignRoleToUser = "canAssignRoleToUser",
    canRemoveRoleFromUser = "canRemoveRoleFromUser",
    canRunRoleValidatorManager = "canRunRoleValidatorManager",
    canRunUserRoleBackgroundMigration = "canRunUserRoleBackgroundMigration",
    canViewUserRoleBackgroundMigration = "canViewUserRoleBackgroundMigration",
    assignPermissionsToRole = "assignPermissionsToRole",
    removePermissionsFromRole = "removePermissionsFromRole",
    listPermissions = "listPermissions",
    viewPermission = "viewPermission",
    createPermission = "createPermission",
    updatePermission = "updatePermission",
    deletePermission = "deletePermission",
    deprecatePermission = "deprecatePermission",
    initializePermissions = "initializePermissions"
}

declare enum FcmSendMethodEnum {
    tokens = "tokens",
    topics = "topics"
}
declare enum FCMTopicsEnum {
    allUsers = "allUsers",
    allAdmins = "allAdmins",
    allEmployers = "allEmployers",
    allMerchants = "allMerchants",
    allStudentBodies = "allStudentBodies",
    allStandardUsers = "allStandardUsers",
    allSuperUsers = "allSuperUsers",
    webAppUsers = "webAppUsers",
    androidAppUsers = "androidAppUsers",
    iosAppUsers = "iosAppUsers"
}
declare enum FirebasePushNotificationSendToEnum {
    specificUsers = "specificUsers",
    fcmTopics = "fcmTopics"
}

interface IGroup<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    name?: string;
    slug?: string;
    description?: string;
    department?: string;
    employerId?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    members?: Env extends EnvironmentTypeEnum.backend ? Array<any> : Array<IUser>;
    createdAt?: string | Date;
    type?: GroupTypeEnum;
}
interface IGetGroupsByEmployerResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getGroupsByEmployer?: {
        groups?: Array<IGroup<Env>>;
        count?: number;
    };
}
interface IGetGroupBySlugResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getGroupBySlug?: IGroup<Env>;
}
interface IGetMembersByGroupResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getMembersByGroup?: {
        members: Array<IUser<Env>>;
        count?: number;
    };
}
interface IGetAllowGroupDeleteResponse {
    getAllowGroupDelete?: {
        totalPerks?: number;
    };
}

interface IInvite<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    status?: StatusEnum;
    from?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    to?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    fromType?: UserTypeEnum;
    toType?: UserTypeEnum;
    toPaused?: boolean;
    fromPaused?: boolean;
    referrer?: IUser<Env>;
    detailsForRecipient?: string;
    toExists?: boolean;
    createdAt?: string | Date;
    acceptedAt?: string | Date;
    deletedAt?: string | Date;
}
interface IGetEmployerMerchantInvitesResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getEmployerMerchantInvites?: {
        invites?: Array<IInvite<Env>>;
        count?: number;
    };
}
interface IGetInviteByIdResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getInviteById?: IInvite<Env>;
}
interface IGetIsConnectedResponse {
    getIsConnected?: boolean;
}
interface IGetConnectionsResponse {
    getConnections?: {
        connectedCount?: number;
        pendingCount?: number;
    };
}
interface IInviteList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    invites?: Array<IInvite<Env>>;
    count?: number;
}

interface IMerchant<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    userId?: any;
    name?: string;
    description?: string;
    onboarded?: string;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IMainBanner<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    logo?: string;
    title?: string;
    description?: string;
    btnText?: string;
    image?: string;
    priority?: number;
    onHome?: boolean;
    merchantId?: Env extends EnvironmentTypeEnum.backend ? string : IMerchant<Env>;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface ICard<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    logo?: string;
    description?: string;
    image?: string;
    merchantId?: Env extends EnvironmentTypeEnum.backend ? string : IMerchant<Env>;
    priority?: number;
    onHome?: boolean;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface ICardOrBannerResult<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    logo?: string;
    title?: string;
    description?: string;
    btnText?: string;
    image?: string;
    merchantId?: Env extends EnvironmentTypeEnum.backend ? string : IMerchant<Env>;
    priority?: number;
    onHome?: boolean;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IGetEmployeeHomeBannerInterface<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getEmployeeHomeBanner?: Array<IMainBanner<Env>>;
}
interface IGetEmployeeHomeCardsInterface<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getEmployeeHomeCards?: Array<ICard<Env>>;
}
interface IGetMerchantByIdResponse {
    getMerchantById?: any;
}
interface IGetMerchantsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getMerchants?: Array<IMerchant<Env>>;
}
interface IGetMerchantByUserIdResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getMerchantByUserId?: IMerchant<Env>;
}
interface IGetMerchantByCardIdResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getMerchantByCardId?: IMerchant<Env>;
}
interface IGetCardOrBannerResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getCardOrBanner?: ICardOrBannerResult<Env>;
}

interface IBusinessCategoryFormInput {
    _id?: any;
    name?: string;
    createdById?: any;
    iconFile?: any;
    iconUrl?: string;
}
interface ISubCategory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    name?: string;
    slug?: string;
    categoryId?: Env extends EnvironmentTypeEnum.backend ? string : IBusinessCategory<Env>;
    order?: number;
    isDefault?: boolean;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    addedBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    count?: number;
    perkCount?: number;
    draftCount?: number;
    createdAt?: string | Date;
    updatedAt?: string | Date;
    deletedAt?: string | Date;
}

interface ICategoriesPerksCount<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    perksCount?: Env extends EnvironmentTypeEnum.backend ? Array<string> : string[];
}
interface IBusinessCategory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    name?: string;
    slug?: string;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    addedBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdAt?: string | Date;
    subCategories?: Array<ISubCategory<Env>>;
    subCatUser?: Array<IUser<Env>>;
    order?: number;
    deletedAt?: string | Date;
    iconUrl?: string;
    key?: number | string;
    index?: number;
    containPerks?: boolean;
    isDefault?: boolean;
}
interface IBusinessCategoriesListForAdmin<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    categories?: Array<IBusinessCategory<Env>>;
    count?: number;
}
interface IBusinessCategoriesList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    categories?: Array<IBusinessCategory<Env>>;
    count?: number;
    categoriesPerksCount?: Array<ICategoriesPerksCount<Env>>;
    activePerksCount?: number;
}
interface IGetBusinessCategoriesByUserResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getBusinessCategoriesByUser?: IBusinessCategoriesList<Env>;
}
interface IGetBusinessCategoryBySubCategoryResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getBusinessCategoryBySubCategory?: IBusinessCategory<Env>;
}
interface IGetBusinessCategoriesForAdminResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getBusinessCategoriesForAdmin?: IBusinessCategoriesListForAdmin<Env>;
}

interface IPerkCategory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    name?: string;
    slug?: string;
    isDefault?: boolean;
    order?: number;
    createdAt?: string | Date;
    perkCount?: number;
    draftCount?: number;
    deletedAt?: string | Date;
    isPopular?: boolean;
    newArrival?: boolean;
    key?: number | string;
}
interface IGetPerkCategoryBySlugResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerkCategoryBySlug?: IPerkCategory<Env>;
}
interface IPerkCategoriesList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    perkCategories?: Array<IPerkCategory<Env>>;
    count?: number;
}
interface IGetPerkCategoriesResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerkCategories?: IPerkCategoriesList<Env>;
}

interface ISlackAuthedUser {
    id?: any;
}
interface ISlackTeam {
    id?: any;
    name?: string;
}
interface ISlackIncomingWebhook {
    channel?: string;
    channel_id?: any;
    configuration_url?: string;
    url?: string;
}
interface ISlackResponseMetadata {
    scopes?: Array<string>;
}
interface IUserSlackData {
    ok?: boolean;
    app_id?: any;
    authed_user?: ISlackAuthedUser;
    scope?: string;
    token_type?: string;
    access_token?: string;
    bot_user_id?: string;
    team?: ISlackTeam;
    enterprise?: string;
    is_enterprise_install?: boolean;
    response_metadata?: ISlackResponseMetadata;
}
interface ISlackWorkspaceChannel {
    id?: any;
    name?: string;
    is_channel?: boolean;
    is_group?: boolean;
    is_private?: boolean;
}
interface ISlackWorkspaceTeam {
    id?: any;
    name?: string;
}
interface ILastSlackNotificationInfo {
    slackTeam?: ISlackWorkspaceTeam;
    slackChannel?: ISlackWorkspaceChannel;
}
interface ISlackNotificationsHistory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    userId?: any;
    userName?: string;
    perkId?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    organizationOwnerId?: Env extends EnvironmentTypeEnum.backend ? string : IUser<Env>;
    slackChannel?: ISlackWorkspaceChannel;
    slackChannelName?: string;
    slackTeam?: ISlackWorkspaceTeam;
    createdAt?: string;
}
interface ISlackNotificationsHistoryResult<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    slackNotificationsHistory?: Array<ISlackNotificationsHistory<Env>>;
    lastSlackNotificationInfo?: ILastSlackNotificationInfo;
}
interface ISlackWorkspaceChannels {
    channels?: Array<ISlackWorkspaceChannel>;
    team?: ISlackWorkspaceTeam;
    success?: boolean;
    message?: string;
}
interface ISendSlackNotification<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    success?: boolean;
    message?: string;
    notificationRecord?: ISlackNotificationsHistory<Env>;
}
interface IGetSlackNotificationsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getSlackNotifications?: ISlackNotificationsHistoryResult<Env>;
}
interface IGetSlackWorkspaceChannelsResponse {
    getSlackWorkspaceChannels?: ISlackWorkspaceChannels;
}
interface IGetLastUsedSlackInfoResponse {
    getSlackWorkspaceChannels?: ILastSlackNotificationInfo;
}

interface ILocation {
    id?: any;
    lat?: number;
    lng?: number;
    desc?: string;
    className?: string;
}

interface IRedeemCode<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    perkId?: Env extends EnvironmentTypeEnum.backend ? any : string;
    userId?: Env extends EnvironmentTypeEnum.backend ? any : string;
    code?: string;
    url?: string;
    type?: string;
    expireDate?: string;
    file?: File;
    createdAt?: string | Date;
    updatedAt?: string | Date;
}
interface IMaxAllowedPerUserEveryDays {
    allowedPerUser?: number;
    allowedEveryDays?: number;
}
interface IInterest {
    allowed?: boolean;
    email?: boolean;
}
interface IPerk<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    name?: string;
    perkType?: string;
    useProfileLocation?: boolean;
    businessCategory?: Env extends EnvironmentTypeEnum.backend ? string : IBusinessCategory<Env>;
    subCategory?: Env extends EnvironmentTypeEnum.backend ? string : ISubCategory<Env>;
    perkCategory?: Env extends EnvironmentTypeEnum.backend ? string : IPerkCategory<Env>;
    details: string;
    website?: string;
    contactName?: string;
    discountCode?: string;
    phoneNo?: string;
    image?: string;
    imageUrl?: string;
    brandLogoUrl?: string;
    brandLogo?: string;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdBySuperUser?: Env extends EnvironmentTypeEnum.backend ? string : IUser<Env>;
    createdByStandardUser?: Env extends EnvironmentTypeEnum.backend ? string : IUser<Env>;
    status?: StatusEnum;
    brandLogoType?: BrandLogoEnum;
    createdAt?: string | Date;
    locations?: Array<ILocation>;
    alwaysDisplay?: boolean;
    displayFromDate?: string | Date;
    displayUntilDate?: string | Date;
    updatedAt?: string | Date;
    notForGeneralPublic?: boolean;
    forUserType?: string;
    forUsers?: Env extends EnvironmentTypeEnum.backend ? string[] | string[] : string[];
    purchasable?: boolean;
    useRedeemCodes?: boolean;
    totalRedeemLimitAvailable?: boolean;
    hasMaxAllowedPerUser?: boolean;
    hasMaxAllowedPerUserEveryDays?: boolean;
    maxAllowedPerUserEveryDays?: IMaxAllowedPerUserEveryDays;
    maxAllowedPerUserEveryDaysPassed?: number;
    value?: number;
    totalRedeemLimit?: number;
    maxAllowedPerUser?: number;
    autoRedeemCodes?: boolean;
    deletedAt?: string;
    perkClicksCount?: number;
    slackNotificationsHistory?: Array<ISlackNotificationsHistory<Env>>;
    lastSlackNotificationInfo?: ILastSlackNotificationInfo;
    forGroups?: Env extends EnvironmentTypeEnum.backend ? string[] | string[] : string[];
    perkDetailsText?: string;
    interest?: IInterest;
    currentUserInterestRegistered?: boolean;
    scheduledStatus?: StatusEnum;
    startDate?: string;
    endDate?: string;
    action?: PerkActionEnum;
    sendSlackNotification?: boolean;
    sendMicrosoftTeamsNotification?: boolean;
    userSubDomain?: string;
    perkLocations?: {
        type?: LocationTypeEnum;
        coordinates?: Array<ILocation>;
    };
    isAlwaysAvailable?: boolean;
    displayNow?: boolean;
    createdById?: any;
}
interface IPerkForm<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> extends Partial<IPerk<Env>> {
    allowedPerUser?: number;
    allowedEveryDays?: number;
}
interface IPerkList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    perks?: Array<IPerk<Env>>;
    count?: number;
}
interface IPerkManagement {
    step?: FormModeEnum;
    searchQuery?: {
        value?: string;
        trigger?: boolean;
    };
    userTypeFilter?: string | null;
    purchasableFilter?: boolean;
    status?: string | null;
    showReferralModal?: boolean;
    showInviteModal?: boolean;
    showPageOptions?: boolean;
    processing?: boolean;
}
interface IGetPerksByUserResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerksByUser?: {
        perks?: Array<IPerk<Env>>;
        count?: number;
        perksPerPage?: number;
        isValidCategory?: boolean;
        isValidSubCategory?: boolean;
    };
}
interface IGetPerkByIdResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerkById?: {
        perk?: IPerk<Env>;
        perkRedeemCodes?: IRedeemCode<Env>;
        userAllowanceReached?: boolean;
    };
}
interface IGetAllowPerkDeleteResponse {
    getAllowPerkDelete?: boolean;
}
interface IGetAllowPerkRedeemResponse {
    getAllowPerkRedeem?: boolean;
}
interface IGetPurchasablePerksResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPurchasablePerks?: Array<IPerk<Env>>;
}
interface IAdminGetPerksResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    adminGetPerks?: IPerkList<Env>;
}
interface IGetBrandPerksResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getBrandPerks?: IPerkList<Env>;
}
interface IGetSuperUserPerksResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getSuperUserPerks?: Array<IPerk<Env>>;
}
interface IGetPerksByUserReq {
    status?: null | StatusEnum;
    searchQuery?: string;
    offset?: number;
    limit?: number;
    categoryId?: any;
    categorySlug?: string;
    subCategoryId?: any;
    subCategorySlug?: string;
    userType?: null | UserTypeEnum;
    purchasableFilter?: boolean;
}

interface IMsTeamsApp {
    processed?: boolean;
    inMicrosoftTeams?: boolean;
    errorOccurred?: boolean;
    errorMessage?: string;
    microsoftTeamsContext?: any;
}
interface IMSTeamsData {
    expiresOn?: Date;
    msTeamAppLog?: string;
    accessToken?: string;
    refreshToken?: string;
    refreshTokenAt?: Date;
    isConnected?: boolean;
}
interface IMSTeamsTeam {
    id?: any;
    displayName?: string;
    internalid?: any;
    webUrl?: string;
    isArchived?: boolean;
    visibility?: string;
}
interface IMSTeamsChannel {
    id?: any;
    displayName?: string;
    webUrl?: string;
    membershipType?: string;
}
interface IMSTeamsAppLogs<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    name?: string;
    userId?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    userEmail?: string;
    oldRefreshToken?: string;
    accessToken?: string;
    refreshToken?: string;
    expiresOn?: string | Date;
    oldConDetails?: {
        accessToken?: string;
        refreshToken?: string;
        expiresOn?: string | Date;
        lastUpdatedAt?: string | Date;
        updateCount?: number;
        msTeamAppLog?: Env extends EnvironmentTypeEnum.backend ? any : string;
    };
    time?: string | Date;
}
interface IMSTeamsNotificationsHistory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    userId?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    userName?: string;
    userType?: UserTypeEnum;
    perkId?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    perkTitle?: string;
    organizationOwnerId?: any;
    userIsTheOrganizationOwner?: boolean;
    categoryName?: string;
    categoryLink?: string;
    msChannel?: IMSTeamsChannel;
    msTeam?: IMSTeamsTeam;
    createdAt?: string | Date;
}
interface ILastMSTeamsNotificationInfoResult {
    msTeamsTeam?: IMSTeamsTeam;
    msTeamsChannel?: IMSTeamsChannel;
}
interface IMSTeamsNotificationsHistoryResult<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    msTeamsNotificationsHistory?: Array<IMSTeamsNotificationsHistory<Env>>;
    lastMSTeamsNotificationInfo?: ILastMSTeamsNotificationInfoResult;
}
interface IMSTeamsGetJoinedTeams {
    message?: string;
    success?: boolean;
    joinedTeams?: Array<IMSTeamsTeam>;
}
interface MSTeamsSelectedTeamChannelsResult {
    message?: string;
    success?: boolean;
    channels?: Array<IMSTeamsChannel>;
}
interface IMicrosoftTeamsNotificationSend<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    message?: string;
    success?: boolean;
    notificationRecord?: IMSTeamsNotificationsHistory<Env>;
}
interface IGetMSTeamsNotificationsHistoryResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getMSTeamsNotificationsHistory?: IMSTeamsNotificationsHistoryResult<Env>;
}
interface IGetMSTeamsUserJoinedTeamsResponse {
    getMSTeamsUserJoinedTeams?: {
        message?: string;
        success?: boolean;
        joinedTeams: Array<IMSTeamsTeam>;
    };
}
interface IGetMSTeamsSelectedTeamChannelsResponse {
    getMSTeamsSelectedTeamChannels?: {
        message?: string;
        success?: boolean;
        channels?: Array<IMSTeamsChannel>;
    };
}

interface IStripeError {
    code?: string;
    reason?: string;
    requirement?: string;
}
interface IUserStripeData {
    accountId?: any;
    disabled_reason?: string;
    errors?: Array<IStripeError>;
    enabled?: boolean;
}
interface ICreateAccountResult {
    url?: string;
    success?: boolean;
    message?: string;
}

interface Loc {
    id?: any;
    lat?: number;
    lng?: number;
    desc?: string;
}
interface IProfileFormInput {
    companyName?: string;
    websiteUrl?: string;
    employees?: string;
    description?: string;
    logo?: Buffer;
    brandLogo?: Buffer;
    brandLogoUrl?: string;
    headerLogo?: Buffer;
    imageUrl?: string;
    headerImageUrl?: string;
    locations?: Array<ILocation>;
    firstName?: string;
    lastName?: string;
    phoneNo?: string;
}
interface EditProfileResult<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.backend> {
    success?: boolean;
    message?: string;
    user?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
}

interface IPerkUsed<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    perk?: Env extends EnvironmentTypeEnum.backend ? any : IPerk;
    used?: string;
}
interface IUser<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    stripeCustomerIds?: {
        customerid?: any;
        customerId?: any;
        sellerId?: string;
    }[];
    firstName?: string;
    lastName?: string;
    type?: UserTypeEnum;
    email?: string;
    phoneNo?: string;
    code?: string | number;
    codeGenAt?: string | Date | number;
    companyName?: string;
    verified?: boolean;
    active?: boolean;
    action?: string;
    stripe?: IUserStripeData;
    merchant?: IMerchant<Env>;
    employer?: IUser<Env>;
    createdAt?: string | Date;
    isLoggedIn?: boolean;
    lastSignIn?: string | Date;
    restrictAccess?: boolean;
    suspended?: boolean;
    onboarding?: boolean;
    invited?: boolean;
    invitedBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    invite?: IInvite;
    vanityUrl?: string;
    skipPhoneStep?: boolean;
    skipAccountTypeStep?: boolean;
    phoneAttempts?: number;
    lastPhoneAttempt?: string | Date;
    logo?: string;
    headerLogo?: string;
    brandLogo?: string;
    isSuperUser?: boolean;
    employeesLandingCategory?: EmployeesLandingCategory;
    waitingApproval?: boolean;
    employerId?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    distance?: string;
    region?: boolean;
    employerUserData?: IUser<Env>;
    deletedAt?: string | Date;
    termsAndConditionsAccepted?: boolean;
    termsAndConditionsAcceptedAt?: Array<string | Date>;
    codeRetries?: number;
    stripeAppFeePercent?: number;
    perksUsed?: Array<IPerkUsed<Env>>;
    perksUsedEveryDays?: Array<IPerkUsed<Env>>;
    allowStripeConnection?: boolean;
    allowCarousel?: boolean;
    perksPerBusiness?: number;
    carouselItemsPerBusiness?: number;
    perksPerCompany?: number;
    benefitsPerCompany?: number;
    slackConnectionDetails?: IUserSlackData;
    isActive?: boolean;
    lastActiveTime?: string | Date | number;
    allowSlackConnection?: boolean;
    orderEmailRecipient?: boolean;
    groups?: Array<IGroup<Env>>;
    status?: string;
    allowedAccessBecause?: AllowedAccessBecauseEnum;
    allowedAccessEmailFormat?: string;
    completedByAdminAt?: string | Date | number;
    allowMSTeamsConnection?: boolean;
    msTeamsConDetails?: IMSTeamsData;
    organization_unique_hash?: any;
    tinyMceFolderName?: string;
    microsoftTeamsIntegrationState?: IntegrationStateEnum;
    slackIntegrationState?: IntegrationStateEnum;
    stripeIntegrationState?: IntegrationStateEnum;
    lastLocationUpdatedAt?: string | Date | number;
    fcmTokens?: IFcmDeviceToken[];
    roleIdentifiers?: Array<string>;
    updatedAt?: string | Date | number;
    stripeCustomerid?: any;
    websiteUrl?: string;
    employees?: string;
    description?: string;
    locations?: Array<Loc>;
    lastSlackNotificationInfo?: ILastSlackNotificationInfo;
    allowPushNotifications?: boolean;
    pushNotificationsIntegrationState?: IntegrationStateEnum;
}
type IPfFoBUser = IUser<EnvironmentTypeEnum.backend> | IUser<EnvironmentTypeEnum.frontend>;
interface IFcmDeviceToken {
    token?: string;
    addedAt?: string;
    updatedAt?: string;
    platform?: PlatformTypeEnum;
}
interface EmployeesLandingCategory {
    isDefault?: boolean;
    categoryId?: any;
    categorySlug?: string;
}
interface IUserWithToken<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    token?: string;
    user?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    success?: boolean;
    message?: string;
    noEmail?: boolean;
    vanityVerified?: string;
    codeRetriesLimitReached?: boolean;
    activationLink?: string;
}
interface IJWT {
    token?: string;
    success?: boolean;
    message?: string;
}
interface IImpersonateResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    success?: boolean;
    message?: string;
    token?: string;
    user?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    adminToken?: string;
}
interface IBudgetAndBalance {
    budget?: string;
    balance?: string;
}
interface IUsersList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    users?: Env extends EnvironmentTypeEnum.backend ? Array<string> : IUser<Env>[];
    count?: number;
}
interface ICompaniesAndBusinessWithInvitesList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    users?: Env extends EnvironmentTypeEnum.backend ? Array<string> : IUser<Env>[];
    count?: number;
}
interface IGetUserResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getUser?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
}
interface IGetUserByIdResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getUserById?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
}
interface IGetBrandUserResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getBrandUser?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
}
interface IGetUsersResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getUsers?: IUsersList<Env>;
}
interface IRenewTokenResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    renewToken?: IUserWithToken<Env>;
}
interface IResendCodeResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    resendCode?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
}
interface IGetHeaderImageResponse {
    getHeaderImage?: string;
}
interface IGetBudgetAndBalanceResponse {
    getHeaderImage?: IBudgetAndBalance;
}
interface IGetCompaniesAndBusinessWithInvitesResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getCompaniesAndBusinessWithInvites?: ICompaniesAndBusinessWithInvitesList<Env>;
}
interface IGetAllCompaniesAndBusinessWithInvitesResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getAllCompaniesAndBusinessWithInvites?: ICompaniesAndBusinessWithInvitesList<Env>;
}
interface IAdminSearchUserResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    adminSearchUser?: {
        users?: Array<IUser<Env>>;
        count?: number;
        success?: boolean;
        message?: string;
    };
}
interface IUserInputFormData {
    firstName?: string;
    lastName?: string;
    email?: string;
    phoneNo?: string;
    verified?: boolean;
    type?: UserTypeEnum;
    active?: boolean;
    social?: boolean;
    action?: string;
    isMobile?: boolean;
    onboarding?: boolean;
    vanityUrl?: string;
    waitingApproval?: boolean;
    imageUrl?: string;
    phoneAttempts?: number;
    fbToken?: string;
    fbid?: any;
    fbId?: any;
    signUp?: boolean;
}

interface ISortOptions {
    field?: string;
    order?: SortOrderEnum;
}
interface IContext {
    user?: IUser<EnvironmentTypeEnum.backend>;
    userId?: any;
    userPermissions?: PermissionsEnum[];
    impersonation?: boolean;
    token?: string;
}
interface ApiResponse {
    success?: boolean;
    message?: string;
    code?: string;
    errors?: {
        [key: string]: string[];
    } | null;
    error?: any | null;
    data?: any | null;
    statusCode?: number;
}
interface IFilterOptions {
    field?: string;
    values?: string[];
}

interface IFirebasePushNotification {
    title?: string;
    body?: string;
    icon?: string;
    image?: string;
}
interface updatePushNotificationDeviceTokenInput {
    token?: string;
    platform?: PlatformTypeEnum;
}
interface sendPushNotificationInput {
    notification?: IFirebasePushNotification;
    sendTo?: FirebasePushNotificationSendToEnum;
    specificUsersEmails?: string[];
    fcmTopics?: string[];
}
interface IPushNotificationFcmTopic {
    _id?: any;
    identifier?: string;
    description?: string;
    createdAt?: Date | string;
    updatedAt?: Date | string;
}

interface IApiResponseBase {
    status?: ApiResponseStatusEnum;
    success?: boolean;
}
interface ISendErrorResponseProps {
    errors?: any;
    error?: any;
    message?: string;
    [key: string]: any;
}
interface ISendSuccessResponseProps<T = any> {
    data?: T;
    message?: string;
    [key: string]: any;
}
interface IApiResponse<T = any> extends IApiResponseBase {
    message?: string;
    data?: T;
    errors?: any;
    error?: any;
    extra?: any;
}

interface IBenefitCategoryIconCommon {
    title: string;
    keywords: string;
    enabled: boolean;
}
interface IBenefitCategoryIconInput extends IBenefitCategoryIconCommon {
    iconFile: Buffer;
}
interface IBenefitCategoryIconsData<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> extends Partial<IBenefitCategoryIconCommon> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    title?: string;
    keywords?: string;
    enabled?: boolean;
    iconUrl?: string;
    userId?: any;
    createdAt?: string | Date;
    updatedAt?: string | Date;
}
interface IGetBenefitCategoryIconsResponse {
    getBenefitCategoryIcons?: IBenefitCategoryIcons;
}
interface IBenefitCategoryIcons<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    data?: Array<IBenefitCategoryIconsData<Env>>;
    count?: string;
    canLoadMore?: boolean;
    success?: boolean;
    message?: string;
}
interface ICategoriesFormInput<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> extends IBenefitCategoryIconsData<Env> {
    icon?: File | null;
    previewUrl?: string;
}

interface IBenefitClickItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    count?: string;
    benefit?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    employeeId?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    benefitCreatedBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdAt?: string | Date;
}
interface IGetBenefitClicksResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getBenefitClicks?: IBenefitClicksList<Env>;
}
interface IBenefitClicksList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    benefitClicks?: Array<IBenefitClickItem<Env>>;
    count?: string;
}

interface IBlockEmailExpression<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    expression?: string;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IAdminGetBlockEmailExpressionsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    adminGetBlockEmailExpressions?: IBlockEmailExpressionList<Env>;
}
interface IBlockEmailExpressionList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    blockEmailExpressions?: Array<IBlockEmailExpression<Env>>;
    count?: number;
}

interface IBrandCarouselItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    details?: string;
    image?: string;
    perk?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IGetBrandCarouselItemsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getBrandCarouselItems?: Array<IBrandCarouselItem<Env>>;
}
interface IGetPerksForCarouselResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerksForCarousel?: IPerkList<Env>;
}

interface IBrandCarouselSetting<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    autoplay?: boolean;
    autoplaySpeed?: number;
    effect?: BrandCarouselSettingEffectEnum;
    dots?: boolean;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    deletedAt?: string | Date;
    arrows?: boolean;
    fade?: boolean;
}
interface IGetBrandCarouselSettingResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getBrandCarouselSetting?: IBrandCarouselSetting<Env>;
}
interface IUpdateBrandCarouselSettingResult {
    success?: boolean;
    message?: string;
    limitReached?: number;
}

interface IBudget<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    expiry?: string;
    onlyEmployerApproval?: boolean;
    budgetEntries?: Array<IBudgetDetail>;
    total?: number;
    stripeFee?: number;
    totalAmount?: number;
    amountToBeApproved?: number;
    amountApproved?: number;
    paymentIntentCaptured?: boolean;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IBudgetDetail<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    budget?: IBudget<Env>;
    claim?: IBudgetClaim<Env>;
    amount?: number;
    createdFor?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IBudgetClaim<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    budgetEntry?: IBudgetDetail<Env>;
    amountApproved?: number;
    receipt?: String;
    comment?: String;
    amountRequested?: number;
    status?: BudgetStatusEnum;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IBudgetDetailPagination<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    total?: number;
    budgetsDetail?: Array<IBudgetDetail<Env>>;
}
interface IGetBudgetAmountByUserResponse {
    getBudgetAmountByUser?: number;
}
interface IGetBudgetDetailByIdResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getBudgetDetailById?: IBudgetDetail<Env>;
}
interface IGetBudgetsDetailByUserResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getBudgetsDetailByUser?: IBudgetDetailPagination<Env>;
}

interface IBusinessCategoryClickItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    count?: number;
    businessCategory?: IBusinessCategory<Env>;
    employer?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
}
interface IGetBusinessCategoryClicksResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getBusinessCategoryClicks?: IBusinessCategoryClicksList<Env>;
}
interface IBusinessCategoryClicksList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    businessCategoryClicks?: Array<IBusinessCategoryClickItem<Env>>;
    count?: number;
}

interface ICarouselItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    name?: string;
    details?: string;
    image?: string;
    perk?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    order?: number;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdAt?: string | Date;
}
interface IGetCarouselItemsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getCarouselItems?: Array<ICarouselItem<Env>>;
}

interface ICartItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    perk?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    quantity?: number;
    price?: number;
    usedByCurrentUser?: number;
    usedEveryDaysByCurrentUser?: number;
    perkCopy?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    is_deleted?: boolean;
}
interface ICart<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    user?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    business?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    items?: Array<ICartItem<Env>>;
    total?: number;
}
interface IUnavailableItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    perk?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    perkCopy?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    type?: string;
    remaining?: number;
}
interface ICheckoutResult<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    url?: string;
    success?: boolean;
    message?: string;
    unavailableItems?: Array<IUnavailableItem<Env>>;
}
interface IAddCartItemResult {
    success?: boolean;
    message?: string;
    showHomeButton?: boolean;
}
interface ICartItemLimitReached {
    success?: boolean;
    message?: string;
    limitReached?: boolean;
}
interface ICartItemLimitReachedResponse {
    cartItemLimitReached?: ICartItemLimitReached;
}
interface IGetCartResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getCart?: ICart<Env>;
}
interface IGetCheckoutSessionResponse {
    getCheckoutSession?: any;
}

interface ICompaniesData<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    data?: Array<IUser<Env>>;
    success?: boolean;
    message?: string;
}
interface ICompaniesForMerchantPerkRedeem {
    data?: {
        _id?: any;
        email?: string;
        companyName?: string;
    };
    success?: boolean;
    message?: string;
}
interface IGetCompaniesForMerchantPerkRedeemResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getCompaniesForMerchantPerkRedeem?: ICompaniesData<Env>;
}
interface IGetCompaniesForAdminBenefitCategoriesResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getCompaniesForAdminBenefitCategories?: ICompaniesData<Env>;
}

interface ICreditCard<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    number?: string | number;
    user?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
}
interface IGetCreditCardsResponse {
    getCreditCards?: any;
}

interface IEmailDomain<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    request?: string;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdAt?: string;
    status?: StatusEnum;
    expression?: string;
    deletedAt?: string | Date;
}
interface IAdminEmailDomain<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> extends IEmailDomain<Env> {
}
interface IAdminGetEmailDomainsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    adminGetEmailDomains?: {
        emailDomains?: Array<IAdminEmailDomain<Env>>;
    };
    count?: number;
}
interface IGetEmailDomainsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getEmailDomains?: {
        emailDomains?: Array<IEmailDomain<Env>>;
        count?: number;
    };
}

interface IEmployee<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    firstName?: string;
    lastName?: string;
    email?: string;
    logo?: string;
    status?: string;
    allowedAccessBecause?: boolean;
    allowedAccessEmailFormat?: boolean;
    isSuperUser?: boolean;
    orderEmailRecipient?: string;
    groups?: Env extends EnvironmentTypeEnum.backend ? string[] | string[] : Array<IGroup<Env>>;
    type?: UserTypeEnum | string;
}
interface IGetEmployeesByEmployerResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getEmployeesByEmployer?: {
        employees?: Array<IEmployee<Env>>;
        count?: number;
    };
}
interface IGetSuperEmployeesResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getSuperEmployeesByEmployer?: Array<IUser<Env>>;
}
interface IGetOrderEmailRecipientsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getOrderEmailRecipients?: Array<IUser<Env>>;
}
interface IEmployeesList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    employees?: Array<IUser<Env>>;
    count?: number;
}
interface IGetSuperEmployeesByEmployerResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getSuperEmployeesByEmployer?: Array<IUser<Env>>;
}

interface IGeneralResponseResponse {
    success?: boolean;
    message?: string;
}

interface ImportEmployeeItem {
    firstname?: string;
    lastname?: string;
    email?: string;
}
interface ImportEmployeeHistoryUserItem {
    rowIndex?: number;
    employee?: ImportEmployeeItem;
}
interface ImportEmployeeFile {
    filename?: string;
    mimetype?: string;
    location?: string;
}
interface IImportEmployeesHistoryItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    duplicateUsersFound?: boolean;
    usersWithNoEmailFound?: boolean;
    usersWithInvalidEmailFound?: boolean;
    duplicateUsers?: Array<ImportEmployeeHistoryUserItem>;
    usersWithNoEmail?: Array<ImportEmployeeHistoryUserItem>;
    usersWithInvalidEmail?: Array<ImportEmployeeHistoryUserItem>;
    totalRowsHandled?: number;
    userId?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    errorOccurred?: boolean;
    errors?: string;
    file?: ImportEmployeeFile;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IGetImportEmployeesHistoryResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getImportEmployeesHistory?: {
        importEmployeesHistory?: Array<IImportEmployeesHistoryItem<Env>>;
    };
}
interface ImportEmployeesHistoryList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    importEmployeesHistory?: Array<IImportEmployeesHistoryItem<Env>>;
}

interface ILedger<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    ledgerDetail?: Array<ILedgerDetail<Env>>;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IMetaData {
    sender?: string;
    receiver?: string;
}
interface ILedgerDetail<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    ledgerId?: Env extends EnvironmentTypeEnum.backend ? any : string;
    actorId?: Env extends EnvironmentTypeEnum.backend ? any : string;
    debit?: number;
    credit?: number;
    balance?: number;
    metadata?: IMetaData;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IGetLedgerByActorResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getLedgerByActor?: Array<ILedger<Env>>;
}
interface IGetBalanceByUserResponse {
    getBalanceByUser?: number;
}

interface IUpdateUserMobileAppInfoInput {
    mobileAppIsUptoDate?: Boolean;
    installedAppVersionText?: string;
    installedAppVersionCode?: number;
    deviceLanguageCode?: string;
    deviceLanguageTag?: string;
    deviceUUid?: any;
    deviceName?: string;
    deviceModel?: string;
    devicePlatform?: PlatformEnum;
    deviceOperatingSystem?: string;
    deviceOSVersion?: string;
    deviceManufacturer?: string;
    deviceISVirtual?: Boolean;
    deviceWebViewVersion?: string;
    dataStoredFrom?: DataStoredFromEnum;
}
interface IUserMobileInfoData<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> extends Partial<IUpdateUserMobileAppInfoInput> {
    userId?: Env extends EnvironmentTypeEnum.backend ? any : IUser;
    userEmail?: string;
    createdAt?: string | Date;
    updatedAt?: string | Date;
}
interface IManagersListWhereDesktopIsAllowed<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    email?: string;
    description?: string;
    isActive?: boolean;
    createdAt?: string | Date;
    updatedAt?: string | Date;
}
interface IManagersListWhereDesktopIsAllowedResult<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    items?: Array<IManagersListWhereDesktopIsAllowed<Env>>;
    count?: number;
    success?: boolean;
    message?: string;
}
interface IUserMobileInfoDataList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    items?: Array<IUserMobileInfoData<Env>>;
    count?: number;
    success?: boolean;
    message?: string;
}
interface IGetUserMobileAppInfoListResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getUserMobileAppInfoList?: IUserMobileInfoDataList<Env>;
}
interface IGetManagersListWhereDesktopIsAllowedResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getManagersListWhereDesktopIsAllowed?: IManagersListWhereDesktopIsAllowedResult<Env>;
}
interface IManagerEmailExcludeInput {
    _id?: any;
    email?: string;
    description?: string;
    isActive?: boolean;
}
interface IExcludeManagerMobileAppUse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    managerId?: any;
    managerid?: any;
    email?: string;
    description?: string;
    isActive?: boolean;
    createdAt?: string | Date;
    updatedAt?: string | Date;
}

interface IPerkRedeemCode<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    userId?: Env extends EnvironmentTypeEnum.backend ? any : IUser;
    perkId?: Env extends EnvironmentTypeEnum.backend ? any : IPerk;
    organizationOwnerId?: Env extends EnvironmentTypeEnum.backend ? string : IUser;
    code?: string;
    type?: RedeemCodeTypeEnum;
    url?: string;
    file?: string;
    expireDate?: string;
    purchasedAt?: string;
    createdAt?: string | Date;
    updatedAt?: string | Date;
    deletedAt?: string | Date;
}
interface IRedeemCodesImportHistory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    userId?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    duplicateDataFound?: boolean;
    invalidImportDataFound?: boolean;
    duplicateCodes?: Array<{
        rowIndex?: number;
        data?: {
            type?: ImportRedeemCodesTypeEnum;
            code?: string;
            expireDate?: string | Date;
        };
    }>;
}
interface IGetPerkRedeemCodesResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerkRedeemCodes?: {
        redeemCodes?: Array<IPerkRedeemCode<Env>>;
        success?: boolean;
        message?: string;
        purchaseableRedeemCodesCount?: number;
    };
}
interface IPerkRedeemCodesResult<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    redeemCodes?: Array<IPerkRedeemCode<Env>>;
    success?: boolean;
    message?: string;
    purchaseableRedeemCodesCount?: number;
}

interface IUniqueDiscountCode {
    discountCode?: string;
    type?: string;
    message?: string;
    success?: boolean;
}
interface IPerksRedeemData<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: any;
    code?: string;
    perk?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    user?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    message?: string;
    status?: StatusEnum;
    perkCreatedBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    employer?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    statusUpdatedBy?: Env extends EnvironmentTypeEnum.backend ? string : IUser<Env>;
    type?: string;
    redeemCodeDetails?: IPerkRedeemCode<Env>;
    verifiedAt?: string | Date;
    createdAt?: string | Date;
    updatedAt?: string | Date;
    deletedAt?: string | Date;
}
interface IPerksRedeemDataList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    data?: Array<IPerksRedeemData<Env>>;
    count?: number;
    success?: boolean;
    message?: string;
}
interface SpecificPerkRedeemData<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    data?: IPerksRedeemData<Env>;
    success?: boolean;
    message?: string;
}
interface IGetAllCompanies {
    value?: string;
    text?: string;
}
interface IGetPerksRedeemDataResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerksRedeemData?: IPerksRedeemDataList<Env>;
}
interface IGetRedeemDataByCodeResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getRedeemDataByCode?: {
        data?: IPerksRedeemData<Env>;
        success?: boolean;
        message?: string;
    };
}
interface IGetUniqueDiscountCodeResponse {
    getUniqueDiscountCode?: {
        discountCode?: string;
        type?: string;
        message?: string;
        success?: boolean;
    };
}
interface IVerifyPerkRedeemResponse {
    verifyPerkRedeem?: {
        success?: boolean;
        message?: string;
    };
}

interface IOrderItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    name?: string;
    perk?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    total?: number;
    price?: number;
    quantity?: number;
    codes?: Array<Env extends EnvironmentTypeEnum.backend ? any : IPerksRedeemData>;
}
interface IOrder<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    items?: Array<IOrderItem<Env>>;
    type?: OrderTypeEnum;
    seller?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    user?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    total?: number;
    codes?: Array<IPerksRedeemData<Env>>;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IOrdersList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    data?: Array<IOrder<Env>>;
    count?: number;
}
interface IGetOrdersResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getOrders?: IOrdersList<Env>;
}

interface IPerkApprovalRequest<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    linkedPerk?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    status?: StatusEnum;
    remarks?: string;
    organizationOwnerId?: Env extends EnvironmentTypeEnum.backend ? string : string;
    reviewedBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    updatedBy?: string;
    reviewedAt?: string | Date;
    createdAt?: string | Date;
    updatedAt?: string | Date;
    isActive?: boolean;
}
interface IPerkApprovalRequestListRequest {
    filter?: unknown;
    searchQuery?: string;
    pagination?: {
        offset?: number;
        limit?: number;
    };
    sort?: {
        field: string;
        order: SortOrderEnum;
    };
}
interface IGetPerkApprovalRequestsByPerkIdRequest extends IPerkApprovalRequestListRequest {
    perkId?: any;
}
interface IPerkApprovalRequestProcessRequest {
    _id?: any;
    status: StatusEnum;
    remarks?: string;
}
interface IGetPerkApprovalRequestsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerkApprovalRequests?: {
        perkApprovalRequests?: IPerkApprovalRequest<Env>[];
        count?: number;
        message?: string;
    };
}
interface IGetActivePerkApprovalRequestByPerkIdResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getActivePerkApprovalRequestByPerkId?: {
        perkApprovalRequest?: IPerkApprovalRequest<Env>;
        count?: number;
        message?: string;
    };
}
interface IGetPerkApprovalRequestsByPerkIdResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerkApprovalRequestsByPerkId: {
        perkApprovalRequests?: IPerkApprovalRequest<Env>[];
        count?: number;
        success?: boolean;
        message?: string;
    };
}

interface IPerkCategoryClickItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    count?: number;
    perkCategory?: Env extends EnvironmentTypeEnum.backend ? string : IPerkCategory<Env>;
}
interface IGetPerkCategoryClicksResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerkCategoryClicks?: PerkCategoryClicksList<Env>;
}
interface PerkCategoryClicksList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    perkCategoryClicks?: Array<IPerkCategoryClickItem<Env>>;
    count?: number;
}

interface IPerkClick<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: any;
    perk?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    user?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdAt?: string;
    perkItem?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
}
interface IGetPerkClicksResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerkClicks?: {
        perkClicks?: Array<IPerkClick<Env>>;
        count?: number;
    };
}
interface IGetPerkGraphClicksResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPerkGraphClicks?: {
        perkGraphClicks?: Array<{
            _id?: any;
            perk?: IPerk<Env>;
            count?: number;
        }>;
        count?: number;
    };
}
interface IPerkClickItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    count?: number;
    perk?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
}
interface IPerkClickByUserItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    count?: number;
    perk?: IPerk<Env>;
    user?: IUser;
}
interface IPerkClicksList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    perkClicks?: Array<IPerkClickItem<Env>>;
    count?: number;
}
interface IPerkClicksByUserList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    perkClicks?: Array<IPerkClickByUserItem<Env>>;
    count?: number;
}
interface IPerkGraphClicksList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    perkGraphClicks?: Array<IPerkClickItem<Env>>;
    count?: number;
}

interface IPerkInterest<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.backend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    perk?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    user?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    createdAt?: Date;
}
interface IGetPerkInterestRegisteredResponse {
    getPerkInterestRegistered?: {
        _id?: any;
    };
}
interface IGetAllPerkInterestRegisteredUsersResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.backend> {
    getAllPerkInterestRegisteredUsers?: {
        perkInterests?: Array<IPerkInterest<Env>>;
        count?: number;
    };
}
interface PerkInterestOrganizationList {
    _id?: any;
    companyName?: string;
}
interface IGetPerkInterestRegisteredOrganizationsResponse {
    getPerkInterestRegisteredOrganisations?: Array<PerkInterestOrganizationList>;
}
interface IPerkInterestList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.backend> {
    perkInterests?: Array<IPerkInterest<Env>>;
    count?: number;
}
interface IPerkInterestOrganizationList {
    _id?: any;
    companyName?: string;
}

interface IPermission<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    identifier?: string;
    title?: string;
    description?: string;
    category?: PermissionCategoryEnum;
    status?: StatusEnum;
    higherLevelPermission?: Env extends EnvironmentTypeEnum.backend ? any : IPermission;
    createdAt?: Date;
    updatedAt?: Date;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    lastModifiedBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    deprecated?: boolean;
    deprecatedAt?: Date;
    deprecatedBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    deprecationReason?: string;
    isAdminPermission?: boolean;
}
interface IUpdatePermissionRequest {
    _id?: any;
    title?: string;
    description?: string;
    category?: PermissionCategoryEnum;
    status?: StatusEnum;
    higherLevelPermission?: string;
    deprecationReason?: string;
    isAdminPermission?: boolean;
}
interface IDeletePermissionRequest {
    _id?: any;
    transferToPermissionId?: any;
}
interface IPermissionListRequest {
    status?: StatusEnum[];
    categories?: PermissionCategoryEnum[];
    searchQuery?: string;
    includeDeprecated?: boolean;
    pagination?: IPaginationOptions;
    sort?: ISortOptions;
    filter?: IFilterOptions;
    roleId?: string;
    showUnattachedPermissions?: boolean;
}
interface ICreatePermissionRequest {
    identifier?: string;
    title?: string;
    description?: string;
    category?: PermissionCategoryEnum;
    higherLevelPermission?: string;
    isAdminPermission?: boolean;
}
interface IDeprecatePermissionRequest {
    _id?: any;
    deprecationReason?: string;
    replacementPermissionId?: any;
}
interface IPermissionResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    permission?: IPermission<Env>;
    success?: boolean;
    message?: string;
}
interface IPermissionListResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    permissions?: IPermission<Env>[];
    count?: number;
    success?: boolean;
    message?: string;
}
interface IUseHasRequiredPermissions {
    requiredPermissions?: Array<PermissionsEnum>;
    excludedPermissions?: Array<PermissionsEnum>;
    checkModeForRequiredPermissions?: PermissionCheckModeEnum;
    checkModeForExcludedPermissions?: PermissionCheckModeEnum;
}
type UseHasRequiredPermissionCheckPermissionType = (params?: IUseHasRequiredPermissions) => boolean;
interface IUseHasRequiredPermissionsReturn {
    checkPermission?: UseHasRequiredPermissionCheckPermissionType;
    canAccess?: boolean;
    userPermissions?: Array<PermissionsEnum>;
}
interface IHasRequiredPermissions extends IUseHasRequiredPermissions {
    userPermissions?: Array<PermissionsEnum>;
}

interface IPushNotificationGroup<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    name?: string;
    slug?: string;
    description?: string;
    department?: string;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    members?: Env extends EnvironmentTypeEnum.backend ? Array<string> : Array<IUser<Env>>;
    createdAt?: string | Date;
    organizationsFcmTopics?: string[];
    updatedAt?: string | Date;
}
interface IPushNotificationGroupFormInput {
    name?: string;
    description?: string;
    department?: string;
    memberIds?: Array<string>;
    organizationsFcmTopics?: string[];
}
interface IGetPushNotificationGroupsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPushNotificationGroups?: {
        groups?: IPushNotificationGroup<Env>[];
        count?: number;
    };
}
interface IGetPushNotificationGroupBySlugResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getPushNotificationGroupBySlug?: IPushNotificationGroup<Env>;
}
interface IGetFcmTopicsResponse {
    getFcmTopics?: string[];
}
interface IAddPushNotificationGroupResponse {
    addPushNotificationGroup?: {
        success?: boolean;
        message?: string;
    };
}
interface IEditPushNotificationGroupResponse {
    editPushNotificationGroup?: {
        success?: boolean;
        message?: string;
    };
}
interface IDeletePushNotificationGroupResponse {
    deletePushNotificationGroup?: {
        success?: boolean;
        message?: string;
    };
}
interface IOrganizationsFcmTopicsResponse {
    organizationsFcmTopics?: {
        success?: boolean;
        message?: string;
        fcmTopics?: string[];
    };
}

interface IReferral<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    from?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    to?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    detailsForRecipient?: string;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IGetReferralsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getReferrals?: IReferralList<Env>;
}
interface IReferralList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    referrals?: Array<IReferral<Env>>;
    count?: number;
}

interface IListRolesReq {
    status?: StatusEnum | null;
    searchQuery?: string | null;
    pagination: IPaginationOptions;
    sort: ISortOptions;
    filter: IFilterOptions;
    userId?: string;
    showUnassignedRoles?: boolean;
}
interface IDeleteRoleReq {
    _id?: any;
    replacementRoleId?: any;
}
interface IRoleAssignmentReq {
    userId?: any;
    roleIdentifier?: string;
}
interface IRolePermissionReq {
    roleId?: any;
    permissionIdentifiers?: string[];
}
interface IRoleForm<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    title?: string | null;
    description?: string | null;
    status?: StatusEnum | null;
    permissions?: Array<PermissionsEnum> | null;
    defaultRoleForEmployer?: boolean | null;
    defaultRoleForStudentBody?: boolean | null;
    defaultRoleForMerchant?: boolean | null;
    defaultRoleForMerchantEmployee?: boolean | null;
    defaultRoleForStudentBodyEmployee?: boolean | null;
    defaultRoleForStudentBodySuperUser?: boolean | null;
    defaultRoleForEmployerEmployee?: boolean | null;
    defaultRoleForEmployerSuperUser?: boolean | null;
    defaultRoleForAdmin?: boolean | null;
    deprecationReason?: string | null;
    versionNumber?: number;
    replacementRoleId?: string | null;
    isDefault?: boolean;
}
interface IRole<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> extends IRoleForm<Env> {
    roleIdentifier?: string | null;
    createdAt?: string | Date | null;
    updatedAt?: string | Date | null;
    createdBy?: string;
    verifiedInfo?: {
        lastVerifiedAt?: Date;
        lastVerifiedVersion?: number;
    };
    lastModifiedBy?: Env extends EnvironmentTypeEnum.backend ? any : string;
    deprecatedAt?: Date;
    deprecatedBy?: Env extends EnvironmentTypeEnum.backend ? any : string;
    replacedBy?: Env extends EnvironmentTypeEnum.backend ? any : string;
}

interface IUpdateSettingsInput {
    allowSignUp?: boolean;
    allowCarousel?: boolean;
    allowCarouselForEmployers?: boolean;
    allowCarouselForColleges?: boolean;
    stripeAppFeePercentForBusinesses?: number;
    stripeAppFeePercentForCompanies?: number;
    stripeAppFeePercentForUniversities?: number;
    perksPerBusiness?: number;
    carouselItemsPerBusiness?: number;
    perksPerCompany?: number;
    benefitsPerCompany?: number;
    perksPerPage?: number;
    perkFormAlertUptoConnections?: number;
    skipPhoneStep?: boolean;
}
interface ISettings<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> extends INewSignupsSettingType, IMobileAppInfoInput, IUpdateSettingsInput {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    appGenericSetting?: boolean;
    isDefault?: boolean;
    appDomain?: string;
    newSignupsSetting?: boolean;
    excludeTestAccounts?: boolean;
}
interface IAppFeaturesState<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    appDomain?: string;
    isDefault?: boolean;
    appFeaturesState?: string;
    success?: boolean;
    message?: string;
}
interface IMobileAppInfoInput {
    androidAppLink?: string;
    androidAppVersionCode?: number;
    androidAppVersionText?: string;
    iosAppLink?: string;
    iosAppVersionCode?: number;
    iosAppVersionText?: string;
    forceMobileAppUseForUsers?: string[];
    maintenanceModeEnabled?: boolean;
    blockMobileBrowserAccess?: boolean;
}
interface INewSignupsSettingType {
    newSignupsEmployerEmail?: string;
    newSignupsCheckEnabled?: boolean;
}
interface IMobileAppInfoType {
    androidAppLink?: string;
    androidAppVersionCode?: number;
    androidAppVersionText?: string;
    iosAppLink?: string;
    iosAppVersionCode?: number;
    iosAppVersionText?: string;
    forceMobileAppUseForUsers?: Array<string>;
    maintenanceModeEnabled?: boolean;
    blockMobileBrowserAccess?: boolean;
    managersIdsToAllowDesktopAppUse?: Array<string>;
}
interface IDeviceAndBundledAppInfo {
    mobileAppIsUptoDate?: boolean | null;
    installedAppVersionText?: string | null;
    installedAppVersionCode?: number | string | null;
    platform?: string | null;
    deviceId?: string | null;
    deviceUUID?: string | null;
    deviceInfo?: string | null;
    deviceLanguageCode?: string | null;
    deviceLanguageTag?: string | null;
    deviceName?: string | null;
    deviceModel?: string | null;
    devicePlatform?: string | null;
    deviceOperatingSystem?: string | null;
    deviceOSVersion?: string | null;
    deviceManufacturer?: string | null;
    deviceISVirtual?: boolean | null;
    deviceWebViewVersion?: string | null;
    androidAppLink?: string | null;
    iosAppLink?: string | null;
    androidAppVersionText?: string | null;
    iosAppVersionText?: string | null;
    androidAppVersionCode?: number | null;
    iosAppVersionCode?: number | null;
    forceMobileAppUseForUsers?: string[] | null;
    maintenanceModeEnabled?: boolean | null;
    blockMobileBrowserAccess?: boolean | null;
    managersIdsToAllowDesktopAppUse?: string[] | UserTypeEnum[] | null;
    minVersionTextRequiredByApi?: string | null;
    minVersionCodeRequiredByApi?: number | string | null;
    installedAppVersionTextIsValid?: boolean | null;
}
interface IGetSettingsResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getSettings?: ISettings<Env>;
}
interface IGetAppFeaturesStateResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getAppFeaturesState?: IAppFeaturesState<Env>;
}
interface IFetchNewSignupsSettingResponse {
    getSettings?: INewSignupsSettingType;
}
interface IFetchMobileAppInfoResponse {
    fetchMobileAppInfo?: IMobileAppInfoType;
}

interface ISlackChannel {
    id?: any;
    name?: string;
}
interface ISlackNotification<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: any;
    userId?: Env extends EnvironmentTypeEnum.backend ? any : string;
    userName?: string;
    slackChannel?: ISlackChannel;
    slackChannelName?: string;
    slackTeam?: ISlackTeam;
    createdAt?: string;
}
interface ILastSlackBotNotificationInfo {
    slackTeam?: ISlackTeam;
    slackChannel?: ISlackChannel;
}
interface IGetSlackNotificationsQResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getSlackNotifications?: {
        slackNotificationsHistory?: ISlackNotification<Env>[];
        lastSlackNotificationInfo?: ILastSlackNotificationInfo;
    };
}
interface IGetSlackWorkspaceChannelsQResponse {
    getSlackWorkspaceChannels?: {
        success?: boolean;
        message?: string;
        channels?: ISlackChannel[];
        team?: ISlackTeam;
    };
}

interface IPerkSubCategory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    name?: string;
    slug?: string;
    categoryId?: any;
    isDefault?: boolean;
    perkCount?: number;
    draftCount?: number;
}

interface ISubCategoryClickItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    count?: number;
    subCategory?: Env extends EnvironmentTypeEnum.backend ? string : ISubCategory<Env>;
    employer?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
}
interface ISubCategoryClicksList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    subCategoryClicks?: Array<ISubCategoryClickItem<Env>>;
    count?: number;
}
interface IGetSubCategoryClicksResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getSubCategoryClicks?: ISubCategoryClicksList<Env>;
}

interface ITestAccount<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    testAccountUserId?: Env extends EnvironmentTypeEnum.backend ? string : IUser<Env>;
    testAccountUserEmail?: string;
    testAccountType?: TestAccountsTypeEnum;
    description?: string;
    isActive?: boolean;
    finalCompanyName?: string;
    finalVanityUrl?: string;
    userType?: UserTypeEnum;
    createdAt?: string | Date;
    updatedAt?: string | Date;
}
interface ITestAccountsResultForEndUser {
    externalTesterEmails?: Array<string>;
    internalTesterEmails?: Array<string>;
    success?: boolean;
    message?: string;
    excludeTestAccounts?: boolean;
}
interface ITestAccountsResultForAdmin<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    testAccounts?: Array<ITestAccount<Env>>;
    success?: boolean;
    message?: string;
    excludeTestAccounts?: boolean;
    testAccountsCount?: number;
    testersCompanyNames?: Array<string>;
    testersVanityUrls?: Array<string>;
}
interface IGetTestAccountsEndUserResponse {
    getTestAccountsEndUser?: ITestAccountsResultForEndUser;
}
interface IGetTestAccountsAdminResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getTestAccountsAdmin?: ITestAccountsResultForAdmin<Env>;
}

interface IToken {
    _id?: any;
    token?: string;
    userId?: any;
    createdAt?: string | Date;
}

interface AwsV3Result {
    success?: Boolean;
    message?: String;
}

interface IUserHistory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    user?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    loggedInAt?: Date | string;
    type?: string;
}
interface IUserLocationHistory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    userId?: Env extends EnvironmentTypeEnum.backend ? any : string;
    user?: Env extends EnvironmentTypeEnum.backend ? any : string;
    lat?: number;
    lng?: number;
    accuracy?: number;
    altitude?: number;
    altitudeAccuracy?: number;
    lastLocationUpdatedAt?: Date | string;
}
interface IUserHistoryList<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    usersHistory?: Array<IUserHistory<Env>>;
    count?: number;
}
interface IGetUserHistoryResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    getUserHistory?: IUserHistoryList<Env>;
}

interface IVoucher<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    name?: string;
    employeeId?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    merchantId?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    status?: string;
    value?: string;
    code?: string;
    email?: string;
    redeemedValue?: number;
    partialRedeemedValues?: Array<number>;
    partialAmountExceeded?: boolean;
    isValid?: boolean;
    isRedeemed?: boolean;
    isSuccessful?: boolean;
    exist?: boolean;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface ICreateVoucherResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    createVoucher?: IVoucher<Env>;
}
interface IRedeemVoucherResponse<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    redeemVoucher?: IVoucher<Env>;
}

interface IPushNotificationHistory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? any : string;
    userId?: Env extends EnvironmentTypeEnum.backend ? any : IUser<Env>;
    userName?: string;
    userType?: UserTypeEnum;
    perkId?: Env extends EnvironmentTypeEnum.backend ? any : IPerk<Env>;
    perkTitle?: string;
    organizationOwnerId?: any;
    userIsTheOrganizationOwner?: boolean;
    categoryName?: string;
    categoryLink?: string;
    createdAt?: string | Date;
}

declare const formFieldsConstants: {
    readonly testArea: {
        readonly max: 10000;
    };
    readonly remarks: {
        readonly max: 500;
    };
};

declare const URL_PARAMS: {
    readonly GOOGLE_MAPS_API_KEY: "{{googleMapsApiKey}}";
};
declare const GENERAL_CONFIG: {
    readonly NOT_AVAILABLE: "-";
    readonly DEFAULT_OFFSET: 0;
    readonly DEFAULT_LIMIT: 10;
    readonly DEFAULT_PERKS_CATEGORY: "perks";
};
declare const MAP_CONFIG: {
    readonly DEFAULT_ZOOM: 12;
    readonly OFFICE_COORDINATES: {
        readonly LAT: 51.931934000000005;
        readonly LNG: -8.123001;
    };
};
declare const COMMUNICATION_CONFIG: {
    readonly PHONE_ATTEMPTS_LIMIT: 3;
    readonly SMS_CODE_EXPIRY_SECONDS: 600;
    readonly PHONE_ATTEMPTS_TIME_LIMIT_IN_MINUTES: 60;
    readonly CODE_RETRIES_LIMIT: 5;
};
declare const DATE_FORMATS: {
    readonly DEFAULT: "DD MMMM YYYY";
    readonly TIME: "hh:mmA";
};
declare const IMAGE_CONFIG: {
    readonly SIZE_LIMIT_MB: 4;
    readonly ALLOWED_IMAGE_TYPES: "image/png, image/jpeg, image/gif";
};
declare const CHART_TYPES: readonly [{
    readonly value: "bar";
    readonly label: "Bar";
}, {
    readonly value: "line";
    readonly label: "Line";
}, {
    readonly value: "doughnut";
    readonly label: "Doughnut";
}, {
    readonly value: "pie";
    readonly label: "Pie";
}, {
    readonly value: "polar";
    readonly label: "Polar";
}];
declare const CHART_OPTIONS: {
    readonly maintainAspectRatio: false;
    readonly scales: {
        readonly y: {
            readonly beginAtZero: true;
            readonly precision: 0;
        };
    };
    readonly plugins: {
        readonly legend: {
            readonly display: true;
            readonly labels: {
                readonly boxWidth: 0;
                readonly font: {
                    readonly size: 18;
                };
            };
        };
    };
};
declare const CHART_DATASET_OPTIONS: {
    readonly backgroundColor: readonly ["rgba(255, 99, 132, 0.2)", "rgba(54, 162, 235, 0.2)", "rgba(255, 206, 86, 0.2)", "rgba(75, 192, 192, 0.2)", "rgba(153, 102, 255, 0.2)", "rgba(255, 159, 64, 0.2)", "rgba(255, 99, 232, 0.2)", "rgba(54, 162, 135, 0.2)", "rgba(255, 206, 186, 0.2)", "rgba(75, 192, 12, 0.2)", "rgba(153, 202, 55, 0.2)", "rgba(25, 159, 64, 0.2)"];
    readonly borderColor: readonly ["rgba(255, 99, 132, 1)", "rgba(54, 162, 235, 1)", "rgba(255, 206, 86, 1)", "rgba(75, 192, 192, 1)", "rgba(153, 102, 255, 1)", "rgba(255, 159, 64, 1)", "rgba(255, 99, 32, 1)", "rgba(54, 162, 35, 1)", "rgba(255, 206, 186, 1)", "rgba(75, 292, 192, 1)", "rgba(153, 202, 255, 1)", "rgba(255, 259, 64, 1)"];
    readonly borderWidth: 1;
    readonly barThickness: 30;
};
declare const GOOGLE_OAUTH_STATIC_URL = "https://accounts.google.com/o/oauth2/auth/oauthchooseaccount?access_type=online&response_type=token&scope=email%20profile&flowName=GeneralOAuthFlow";
declare const LINKEDIN_OAUTH_STATIC_URL = "https://www.linkedin.com/oauth/v2/authorization?response_type=code&scope=r_liteprofile%20r_emailaddress";
declare const LINKEDIN_OAUTH_USER_INFO_URL = "https://api.linkedin.com/v2/me?projection=(id,firstName,lastName,profilePicture(displayImage~:playableStreams))";
declare const LINKEDIN_OAUTH_ACCESS_TOKEN_URL = "https://api.linkedin.com/oauth/v2/accessToken";
declare const LINKEDIN_OAUTH_USER_DATA_URL = "https://api.linkedin.com/v2/emailAddress?q=members&projection=(elements*(handle~))";
declare const GOOGLE_OAUTH_USER_INFO_URL = "https://www.googleapis.com/oauth2/v1/userinfo";
declare const FACEBOOK_OAUTH_USER_DATA_URL = "https://graph.facebook.com/me?fields=id,first_name,last_name,email,picture";
declare const GOOGLE_OAUTH_REVOKE_TOKEN = "https://oauth2.googleapis.com/revoke?token=";
declare const AUTH_REDIRECTS: {
    readonly GOOGLE_AUTH_SIGNIN_CALLBACK: "/social-auth/googlesignin/callback";
    readonly GOOGLE_AUTH_SIGNUP_CALLBACK: "/social-auth/googlesignup/callback";
    readonly FACEBOOK_AUTH_SIGNUP_CALLBACK: "/social-auth/facebooksignup/callback";
    readonly FACEBOOK_AUTH_SIGNIN_CALLBACK: "/social-auth/facebooksignin/callback";
    readonly LINKEDIN_AUTH_CALLBACK: "/social-auth/linkedin/callback";
    readonly LINKEDIN_AUTH_SIGNUP_CALLBACK: "/social-auth/linkedinsignup/callback";
    readonly LINKEDIN_AUTH_SIGNIN_CALLBACK: "/social-auth/linkedinsignin/callback";
    readonly GOOGLE_AUTH_CALLBACK: "/social-auth/google/callback";
    readonly FACEBOOK_AUTH_CALLBACK: "/social-auth/facebook/callback";
    readonly MS_AUTH_REDIRECT: "/ms-auth";
    readonly MicrosoftTeamsConfigTab: "/microsoft-teams/channel-app/config";
};
declare const FACEBOOK_OAUTH_URL = "https://www.facebook.com/v12.0/dialog/oauth?response_type=token&scope=email";
declare const TRUNCATE_TEXT_LENGTH_SMALL = 10;
declare const TRUNCATE_TEXT_LENGTH_MEDIUM = 30;
declare const TOKEN_LOCALSTORAGE_KEY = "pf_r32_4ui3_234";
declare const ADMIN_TOKEN_LOCALSTORAGE_KEY = "pf_r32_nhg_5t";
declare const IMPERSONATE_LOCALSTORAGE_KEY = "vcx_sdf_Ge_rhb";
declare const USER_LOCALSTORAGE_KEY = "we_lk_gpf_rre_23";
declare const SHOW_MODAL_LOCALSTORAGE_KEY = "re_2we_lk_gpf_r3";
declare const VERIFY_EMAIL_TOKEN_LOCALSTORAGE_KEY = "wer_Vssdf_vf_r3";
declare const PAGE_REFRESHED_ONCE_LOCALSTORAGE_KEY = "ds09sdf_vf_r3";
declare const TRY_AND_REDIRECT_USER_TO_MOBILE_APP = "dscr38g4-234-r23-4_Vd2";
declare const TOKEN_HEADER_KEY = "cus_5rge_svsb_5pf_3r";
declare const USER_HEADER_KEY = "o5r_5pf_3r4ui3_90";
declare const IMPERSONATE_HEADER_KEY = "r4uo5r_5pf_3i3_90";
declare const VERIFY_EMAIL_TOKEN_HEADER_KEY = "r_5vnopf_3i3_90";
declare const GET_USER_API_UPDATED_AT = "pf_3i3_9das42_30";
declare const TOKEN_VERIFICATION_URL_KEY = "rb_5pf_3_3i3_90";
declare const PERKS_PARENT_CATEGORY = "perks";
declare const S3_BUCKET_FOLDERS: {
    readonly RedeemCodes: "redeem-codes";
    readonly ImportRedeemCodes: "import-redeem-codes";
};
declare const SEND_IN_BLUE_TEMPLATES: {
    readonly ORDER_CHECKOUT: 52;
    readonly GET_PERK_CODE: 53;
};
declare const PERKFORCE_LOGO = "https://perkforce.com/wp-content/uploads/2022/03/perkforce-logo.png";
declare const SLACK_BOT: {
    SLACK_OAUTH_URL: (stateData: string, clientId: string, url: string) => string;
    SLACK_AUTH_REDIRECT_URL: string;
};
declare const FIREBASE_RESPONSES: {
    readonly CLOSED_BY_USER: "auth/popup-closed-by-user";
};
declare const VAR_TYPES: {
    readonly STRING: "string";
    readonly OBJECT: "object";
    readonly ARRAY: "array";
    readonly boolean: "boolean";
    readonly NUMBER: "number";
    readonly FUNCTION: "function";
};
declare const PERKFORCE_DOMAINS: readonly ["perkforce.com", "pfstag.com", "pfdevqa.com"];
declare const TIME_UNIT_TYPE: {
    readonly MINUTES: "minutes";
};
declare const LOTTIE_ANIMATION_START_DELAY = 2000;
declare const DEVICE_UUID_LOCALSTORAGE_KEY = "WFE_vwevV_sf_F-ssdfdsf_";
declare const SOCKET_IO_EVENTS: {
    readonly client: {
        readonly perksDataChanged: "perksDataChanged__client";
        readonly userSettingChanged: "userSettingChanged__client";
    };
    readonly server: {
        readonly perksDataChanged: "perksDataChanged__server";
        readonly userSettingChanged: "userSettingChanged__server";
    };
};
declare const URL_TARGET: {
    readonly blank: "_blank";
};
declare const TOOLTIP_TRIGGER_ALL: readonly ["click", "hover", "focus", "contextMenu"];
declare const MS_TEAMS: {
    TENANT_TYPE: string;
    RESPONSE_TYPE: string;
    REQUESTED_SCOPES: string;
    GET_SERVER_AUTH_URL: (msAuthStateData: string, id: string, url: string) => string;
    AUTH_SCOPES: string;
    GRAPH_API_ENDPOINTS: {
        JOINED_TEAMS: string;
        CHANNELS_IN_TEAM: (teamId: string) => string;
        SEND_MESSAGE_IN_CHANNEL: (teamId: string, channelId: string) => string;
    };
};
declare const POPOVER_TRIGGER: readonly ["click", "hover"];
declare const PERKFORCE_DETAILS: {
    readonly supportEmail: "support@perkforce.com";
    readonly webAppUrl: "https://app.perkforce.com";
    readonly androidAppUrl: "https://play.google.com/store/apps/details?id=com.perkforce.app";
    readonly iosAppUrl: "https://apps.apple.com/pk/app/perkforce/id1608229415";
};
declare const SVG_ICON_TYPES: readonly ["image/svg", "image/svg+xml"];
declare const PERK_FORM_GROUPS: {
    readonly YOU: {
        readonly name: "You";
        readonly _id: "you";
    };
    readonly CREATOR: {
        readonly name: "Creator";
        readonly _id: "creator";
    };
};

declare const APP_FEATURES: {
    readonly PERK_UNIQUE_REDEEM_ENABLED: "perk_unique_redeem_enabled";
};

declare const googleApis: {
    readonly geoLocationApi: {
        readonly url: "https://www.googleapis.com/geolocation/v1/geolocate?key={{googleMapsApiKey}}";
    };
};

declare const MESSAGES: {
    readonly SETUP: {
        CHECK_STATUS: string;
    };
    readonly PERK: {
        readonly START_DATE_REQUIRED: "Display From Date is required when perk is not always displayed.";
        readonly END_DATE_GREATER: "Display Until Date should be greater than Display From Date.";
        readonly USER_REQUIRED: "User is required.";
        readonly INVALID_NAME: "'Perks' as a name is not allowed.";
        readonly NOT_FOUND: "Perk not found.";
        readonly NOT_AVAILABLE: "Perk not available.";
        readonly ACCEPT_TERMS: "Please accept the terms and conditions.";
        readonly CREATED: "Perk created.";
        readonly UPDATED: "Perk updated.";
        readonly EDIT_UNPUB_IN_CAROUSEL: "Perk updated. Users will not be able to view this unpublished perk in the carousel.";
        readonly STATUS_UPDATED: "Perk status updated.";
        readonly DELETED: "Perk deleted.";
        readonly PROVIDE_PRICE_FOR_PURCHASABLE: "Please provide a price to make this perk purchasable.";
        readonly INVALID_PRICE: "Please provide valid price.";
        readonly REMAINING_QUANTITY_REQUIRED: "Remaining quantity is required.";
        readonly INVALID_REMAINING_QUANTITY: "Please provide valid remaining quantity.";
        readonly INVALID_MAX_ALLOWED_PER_USER: "Please provide valid max allowed per user value.";
        readonly INVALID_ALLOWED_PER_USER: "Please provide valid per user value.";
        readonly INVALID_ALLOWED_EVERY_DAY: "Please provide valid every day(s) value.";
        readonly START_DATE_SHOULD_LESS_THEN_END_DATE: "Perk display from date cannot be after the display until date.";
        readonly START_DATE_OR_ALWAYS_AVAILABLE_REQUIRED: "Please provide display from date or check \"Always Display\" box.";
        readonly REDEEM_LIMIT_EXCEEDED_PROVIDED_CODES: "Remaining quantity cannot be greater than provided redeem codes.";
        readonly REDEEM_CODE_COPIED: "Code copied to clipboard.";
        readonly REDEEM_CODE_DUPLICATE: "Redeem Code already available.";
        readonly REDEEM_CODE_DUPLICATE_IN_ALL_PERKS: "Redeem Code already available in other perk.";
        readonly REDEEM_CODE_SPACE: "Redeem Code cannot contain white spaces.";
        readonly REDDEM_CODES_REQUIRED: "You need to add your redeem codes, or you can select to have us automatically create redeem codes for you.";
        readonly MAX_USER_REDEEM_LIMIT_EXCEEDED: "Your allowance has been reached, try again later.";
        readonly LIMITS_NOT_ALLOWED: "Limits/Constraints can’t be implemented without \"Use Redeem Codes\".";
        readonly DISCOUNT_CODE_NOT_ALLOWED: "Discount code is not allowed with these controls selection made (Purchasable, Use Redeem Codes, Total Quantity Available, Max Allowed Per User/Days).";
        readonly DESCRIPTION_PERMISSION_ERROR_MESSAGE: "You do not have permission to add a description to this perk. Please contact your administrator for assistance.";
        readonly IMAGE_PERMISSION_ERROR_MESSAGE: "You do not have permission to add an image to this perk. Please contact your administrator for assistance.";
        readonly CATEGORY_PERMISSION_ERROR_MESSAGE: "You do not have permission to assign a category to this perk. Please contact your administrator for assistance.";
        readonly LOGO_PERMISSION_ERROR_MESSAGE: "You do not have permission to add a logo image to this perk. Please contact your administrator for assistance.";
        readonly GROUP_PERMISSION_ERROR_MESSAGE: "You do not have permission to modify the user selector for this perk. Please contact your administrator for assistance.";
        readonly CONTACT_PERMISSION_ERROR_MESSAGE: "You do not have permission to add contact information (name, website, phone number) to this perk. Please contact your administrator for assistance.";
        readonly DISPLAY_SCHEDULE_PERMISSION_ERROR_MESSAGE: "You do not have permission to modify the display schedule settings. Please contact your administrator for assistance.";
        readonly DISCOUNT_PERMISSION_ERROR_MESSAGE: "You are not authorized to set discounts. Please contact your administrator if you need this permission.";
        readonly PURCHASABLE_PERMISSION_ERROR_MESSAGE: "You do not have the required permissions to modify the purchasable options or set a price. Contact your administrator for help.";
        readonly LIMITS_CONSTRAINTS_PERMISSION_ERROR_MESSAGE: "You are not permitted to modify limits or constraints for this perk. Please reach out to your administrator for further assistance.";
        readonly CODES_PERMISSION_ERROR_MESSAGE: "You do not have permission to manage redeem codes for this perk. Contact your administrator for permission.";
        readonly REGISTER_INTEREST_PERMISSION_ERROR_MESSAGE: "You are not authorized to manage the 'Register Interest'. Please reach out to your administrator for assistance.";
        readonly LOCATIONS_PERMISSION_ERROR_MESSAGE: "You do not have permission to add or modify locations. Contact your administrator for further help.";
        readonly PERK_CREATE_LIMIT_REACHED: (perkCreateLimit: number) => string;
        readonly VERIFY_PERK_REDEEM_ERROR: "Error occurred while verifying perk redeem.";
        readonly INVALID_STATUS: "Cannot send a notification while the perk is in Draft mode. You'll need to Publish it first.";
        readonly NOTIFICATION_ON_UNPUBLISH: "Cannot send a notification, while trying to unpublish a perk.";
        readonly PERK_WEBSITE_OPEN_ERROR: "Error occurred while trying to open the perk website URL.";
        readonly FOR_USERS: "Select the organisations that can avail of your perk.";
        readonly FOR_USERS_PREVIEW: "Allow your perk to be previewed by Companies and Colleges, before connecting with them.";
        readonly LEGEND_STUDENT_DESC: "The graduate cap represents a connected College, their <b>Students</b> will see your perk 👩🏾‍🎓👨‍🎓";
    };
    readonly CART: {
        readonly NOT_FOUND: "Cart not found.";
        readonly CART_EMPTY: "Cart is empty.";
        readonly ITEM_NOT_FOUND: "Cart item not found.";
        readonly ITEM_ADDED: "Item added in cart.";
        readonly QUANTITY_REQUIRED: "Quantity is required.";
        readonly CHECKOUT_SUCCESS: "Transaction in process.";
        readonly ITEMS_OUT_OF_STOCK: "One or more items are not available.";
        readonly ITEM_OUT_OF_STOCK_AND_UPDATED: "Item not available. Removed it from cart.";
        readonly PURCHASE_SUCCESS: "Purchased Successfully.";
        readonly BUSINESS_NOT_FOUND: "Business not found.";
        readonly ITEM_NOT_AVAILABLE_FOR_PURCHASE: "Item(s) not available to purchase.";
        readonly ONLY_SAME_BUSINESS_ALLOWED: "Items from different seller cannot be added in Cart. Please clear your cart to add items from a different seller.";
        readonly ADD_QUANTITY_EXCEEDED: (limit: number) => string;
    };
    readonly GIVE_PERKS: {
        readonly TRANSACTION_PROCESS: "Transaction is processing.";
    };
    readonly GROUP: {
        readonly AT_LAST_1_MEMBER: "Please select at least 1 group member.";
        readonly CREATED: "Group created.";
        readonly NOT_FOUND: "Group not found.";
        readonly DELETED: "Group deleted.";
        readonly UPDATED: "Group updated.";
        readonly MEMBER_CREATED: "Group member added.";
        readonly MEMBER_DELETED: "Group member deleted.";
        readonly MEMBER_EXISTS: "Group member already added.";
        readonly MEMBER_NOT_FOUND: "Group member not found";
        readonly MEMBERS_ADDED_TO_GROUPS: "Groups updated.";
        readonly DUPLICATE: "Group name already exists.";
    };
    readonly EMAIL_DOMAIN: {
        readonly INVALID: "Please enter valid domain name";
        readonly EMPTY_REQUEST: "Please enter request";
        readonly EMPTY_EXPRESSION: "Please enter expression";
        readonly CREATED: "Email domain created. Pending for approval.";
        readonly UPDATED: "Email domain updated.";
        readonly NOT_FOUND: "Email domain not found.";
        readonly DELETED: "Email domain deleted.";
        readonly EXPRESSION_ADDED: "Regular Expression created.";
    };
    readonly DISCOUNT_CODE: {
        readonly CODE_COPIED: "Code copied successfully.";
        readonly AMOUNT_SELECTION: "Please select amount.";
    };
    readonly GENERAL: {
        readonly RELOAD_DATA: "Reload Data";
        readonly FILE_SIZE_LIMIT: "File size has exceeded it's max limit of 4MB";
        readonly INVALID_FILE_TYPE: "Invalid file type selected. Allowed file types are image/png, image/jpeg, image/gif.";
        readonly INVALID_FILE: "Invalid file selected. Please try again.";
        readonly INVALID_PHONE: "Please enter valid Phone No.";
        readonly THANKS_FOR_FEEDBACK: "Thank you for the feedback.";
        readonly CHAR_LIMIT_EXCEEDED: (prop: string | number) => string;
        readonly SPECIAL_CHARS_NOT_ALLOWED: "Special characters are not allowed.";
        readonly SPECIAL_CHARS_AND_SPACES_NOT_ALLOWED: "Special characters and spaces are not allowed.";
        readonly IMAGE_REQUIRED: "Image is required.";
        readonly INVALID_URL: "Please enter a valid URL";
        readonly AFFILIATE_LINK_WARNING: "Please ensure this is not an affiliate link. See Perkforce Terms & Conditions for more details";
        readonly INVALID_REQUEST: "Invalid request.";
        readonly ERROR_OCCURRED: "Error occurred, try again later";
        readonly CANCELLED_BY_USER: "Request cancelled by user.";
        readonly ACCEPT_CONDITION: "Please accept the condition.";
        readonly REQUEST_EXPIRED: "Requested token expired, try again later.";
        readonly INVALID_EMPLOYEE_PERMISSIONS: "Invalid request. Your permissions are changed. Please refresh your page.";
        readonly INVALID_ICON_TYPE: (type?: string) => string;
        readonly GIVE_FEEDBACK: "Give Feedback";
        readonly COLLEGE: "College";
        readonly BUSINESS: "Business";
        readonly COMPANY: "Company";
        readonly COMPANY_OR_COLLEGE: "Company or College";
        readonly SUCCESS: "Request completed successfully.";
        readonly NAME_REQUIRED: "Name is required.";
        readonly ID_REQUIRED: "Id is required, can't proceed without id.";
        readonly REMARKS_MAX_ERROR: "Remarks must contain at most 500 character(s)";
        readonly REMARKS_REQUIRED: "Remarks is required.";
        readonly INVALID: "Invalid request.";
        readonly EMAIL_EXISTS: "Email address already occupied.";
        readonly CARD_BANNER_NOT_FOUND: "Card or Banner not found.";
        readonly PERKS_SENT: "Perks Sent.";
        readonly DB_CONNECTED: "Database Connected Successfully.";
        readonly UNAUTHENTICATED: "please authenticate";
        readonly SPECIAL_CHARACTERS_NOT_ALLOWED: "Please provide a valid value, Special characters are not allowed.";
        readonly CHARATCER_LIMIT_EXCEEDED: "Characters Limit Exceeded.";
        readonly FILE_UPLOAD_SUCCESS: "File upload completed successfully.";
        readonly FILE_UPLOAD_FAILED: "File upload failed.";
        readonly NOT_FOUND: "Item not found.";
        readonly INVALID_SLUG: "Invalid category name, name should contain at least one alphabet and should be unique.";
        readonly INVALID_EMAIL: "Please provide a valid email address.";
        readonly UNAUTHORIZED: "Unauthorized access. You do not have permission to perform this action. Please check your credentials or contact support if you believe this is a mistake.";
        readonly UNEXPECTED_ERROR_MESSAGE: "An unexpected error occurred. Please try again.";
        readonly DEPRECATION_REASON_REQUIRED: "Deprecated reason is required.";
    };
    readonly USER: {
        readonly PERKFORCE_DOMAIN_UPDATE_INFO: "Perkforce domain change will take effect in next sign in.";
        readonly DESCRIPTON_REQUIRED: "Description is required.";
        readonly CREATED: "User Created.";
        readonly NOT_FOUND: "User not found.";
        readonly VANITY_URL_EXISTS: "Vanity url already occupied.";
        readonly COMPANY_NAME_EXISTS: (type: string) => string;
        readonly INVALID_TOKEN: "Invalid token.";
        readonly CODE_EXPIRED: "Code is expired.";
        readonly CODE_INVALID: "Code is invalid.";
        readonly LOGGED_OUT: "User logged out.";
        readonly UPDATED: "User updated.";
        readonly ORDER_EMAIL_RECIPIENTS_UPDATED: "Order email recipients updated.";
        readonly NOT_ONBOARDED: "User not onboarded.";
        readonly PHONE_CODE: (code: string | number, phoneNo: string) => string;
        readonly INVALID_PHONE_ATTEMPT: (minutes: string) => string;
        readonly PRIVACY_POLICY_RESET: "Terms, conditions and privacy policy reset done for all users.";
        readonly ACTIVE_STATUS_UPDATED: "User Active Status Updated Successfully.";
        readonly DELETED: "User Deleted Successfully.";
        readonly CANNOT_DOWNGRADE_EMAIL_ORDER_RECIPIENT: "Can not remove superuser access, Please remove the user from order email recipient list first.";
        readonly CANNOT_REMOE_LAST_EMAIL_ORDER_RECIPIENT: "Can not remove last order email recipient.";
        readonly INVALID_EMPLOYER_ID: "Error Occurred, Invalid employer id, please try again later.";
        readonly LOCATION_UPDATED: "Location Updated Successfully.";
        readonly FAILED_TO_FETCH_PERMISSIONS: "Failed to fetch permissions, please try again.";
        readonly NO_ROLE_ASSIGNED: "You currently don't have any roles assigned. Please contact the administrator for assistance.";
    };
    readonly USER_HISTORY: {
        readonly CREATED: "User history created.";
    };
    readonly SETTINGS: {
        readonly INVALID_STRIPE_FEE: "Fee percentage cannot be less than 0 or greater than 100.";
        readonly CANNOT_NEGATIVE: "Cannot be less than 1.";
        readonly FEE_FOR_ORGANIZATION: (org: string | number) => string;
        readonly UPDATED: "Settings updated.";
        readonly INVALID_PERKS_PER_PAGE: "Perks per page should not be less than 1.";
        readonly INVALID_CONNECTIONS_UPTO: "Number of connections should not be less than 1.";
        readonly NEW_SIGNUPS: {
            readonly SUCCESS: "New signups settings updated successfully.";
            readonly INVALID_EMAIL: "Invalid email, no emplopyer/merchant/student-body user found with this email.";
        };
        readonly MOBILE_APP_INFO: {
            readonly SUCCESS: "Mobile app info updated successfully.";
        };
    };
    readonly INVITES: {
        readonly INVITE_SENT: "Connection invite sent.";
        readonly CONNECTION_REQUEST_SENT: "Connection request sent.";
        readonly REFER_A_BUSINESS: "Refer a Business";
        readonly SENT: "Connection request sent.";
        readonly NOT_FOUND: "Connection request not found";
        readonly NOT_FOUND_OR_ACCEPTED: "Connection request not found or already accepted.";
        readonly EXISTS: "Connection request already exists or invalid.";
        readonly CONNECTION_EXISTS: "Users already connected.";
        readonly DELETED: "Connection request deleted.";
        readonly INVALID: "Invalid connection request.";
        readonly ACCEPTED: "Connection request accepted.";
        readonly CONNECTION_CREATED: "Connection created.";
        readonly STATUS_CHANGED: "Status updated.";
        readonly INVALID_USER: "Cannot send connection request to this user. Please reach out to Perkforce or send feedback for help.";
        readonly REFERRAL_SENT: "Referral sent.";
    };
    readonly SLACK: {
        readonly NOTIFICATION_SENT: "Notification sent successfully.";
        readonly CONNECTED: "Congrats! You're now connected to Slack.\nNow each perk has a feature where you can notify your Slack channels about it. 🚀";
        readonly DISCONNECTED: "You're now disconnected from Slack.\nReconnect anytime to access its amazing features again.";
        readonly ENABLED: "Slack is enabled again!\nAll its amazing features are ready for you to enjoy.";
        readonly DISABLED: "Slack is disabled.\nYou're still connected, so turning it back on is easy whenever you're ready!";
    };
    readonly SLACK_BOT: {
        readonly ACCESS_DENIED: "Access Denied By User.";
        readonly SEND_PERK_NOTIFICATION: "Click here to send a notification about this perk to your slack organisation.";
        readonly NO_CHANNELS_FOUND: "No channels found, please create some public channels in your workspace or add perkforce slack app to some private channels to continue.";
        readonly INVALID_CHANNEL: "Invalid channel, please try again.";
        readonly INVALID_WORKSPACE_DATA: "Invalid workspace data, please try again.";
        readonly SELECT_CHANNEL: "Please select channel to continue to send a notification to slack.";
        readonly ERROR_OCCURRED: "Error ocurred while opening slack app to complete the integration process.";
        readonly ENABLE_INTEGRATION: "Please enable slack integration to use this feature.";
    };
    readonly CATEGORY: {
        readonly NO_ICON_PROVIDED: "No icon provided for category.";
        readonly NO_ICONS_FOUND: "No Icons Found!";
        readonly ICON_DIMENSION_LIMIT_EXCEED: "Image dimensions should be less than or equal to 256*256";
        readonly CREATED: "Category created.";
        readonly EXISTS: "Category with the same name already exists.";
        readonly UPDATED: "Category updated.";
        readonly DELETED: "Category deleted.";
        readonly NOT_FOUND: "Category not found.";
        readonly CONTAIN_SUB_CATEGORIES: "Cannot delete because there are sub categories in this category.";
        readonly REORDER: "Categories reordered.";
    };
    readonly SUB_CATEGORY: {
        readonly CREATED: "Sub Category created.";
        readonly EXISTS: "Sub Category with the same name already exists.";
        readonly UPDATED: "Sub Category updated.";
        readonly DELETED: "Sub Category deleted.";
        readonly NOT_FOUND: "Sub Category not found.";
        readonly DEFAULT: "Cannot update default Sub Category.";
        readonly CONTAIN_PERKS: "Cannot delete because there are perks in this sub category.";
        readonly REORDER: "Sub Categories reordered.";
    };
    readonly SENTRY: {
        readonly TEST_ERROR_REPORTING: "Testing frontend sentry error reporting.";
    };
    readonly PERK_REDEEM_CODES: {
        readonly INVALID_REQUEST: "Cannot change, once a purchase has occured.";
        readonly ADDED: "Perk Redeem Code added.";
        readonly EDITED: "Perk Redeem Code edited.";
        readonly DELETED: "Perk Redeem Code deleted.";
        readonly PERK_ID_REQUIRED: "Perk id is required.";
        readonly COMPLETED: "Redeem Codes added successfully.";
        readonly FAILED: "Failed to add requested redeem Codes.";
        readonly LIMIT_REACHED: (redeemCodesImportLimit: number) => string;
        readonly NO_FILE_FOUND: "No file found to import data.";
        readonly NO_REDEEM_CODE_AVAILABLE: "No Perk code available right now, try again later.";
        readonly INVALID_REDEEM_CODE: "Invalid redeem code found, please try again later.";
        readonly DUPLICATE_RECORDS_FOUND: (unique: string, duplicate: string) => string;
        readonly INVALID_RECORDS_FOUND: (unique: string, invalid: string) => string;
        readonly DUPLICATE_INVALID_RECORDS_FOUND: (unique: string, duplicate: string, invalid: string) => string;
        readonly REDEEM_CODE_DUPLICATE_IN_ALL_PERKS: "Redeem Code already available in other perk.";
    };
    readonly TEST_ACCOUNTS: {
        readonly ALREADY_EXISTS: "Test account email already exists.";
        readonly INVALID_ACTION: "Invalid test account form action passed, please try again.";
        readonly ADDED: "Test account added successfully.";
        readonly UPDATED: "Test account updated successfully.";
        readonly DELETED: "Test account deleted successfully.";
        readonly SETTING_UPDATED: "Test accounts setting updated successfully.";
        readonly INVALID_EMAIL: "Please add a valid email to add new test account.";
        readonly EXISTS: "Test account already exists, please try a different user.";
        readonly NOT_FOUND: "Test account not found, please try again.";
        readonly MUST_BE_MANAGER: "Internal tester should be a manager account.";
    };
    readonly STRIPE: {
        readonly REDIRECT_FAILED: "Error occured while trying to redirect to Stripe to complete checkout request.";
        readonly DISCONNECTED: "You're now disconnected from Stripe.\nReconnect anytime to access its amazing features again.";
        readonly ENABLED: "Stripe is enabled again!\nAll its amazing features are ready for you to enjoy.";
        readonly DISABLED: "Stripe is disabled.\nYou're still connected, so turning it back on is easy whenever you're ready!";
    };
    readonly BLOCK_EMAIL_EXPRESSION: {
        readonly EMPTY_EXPRESSION: "Please enter valid regular expression to block emails";
        readonly INVALID_EXPRESSION: "Please enter a valid regular expression.";
        readonly CREATED: "A new regular expression added to\nblock Emails.";
        readonly NOT_FOUND: "Block Email expression not found.";
        readonly DELETED: "Block Email expression deleted.";
        readonly EXPRESSION_ALREADY_EXISTS: "This regular expression already exists.";
        readonly REQUEST_BLOCKED: "Sorry, this request is not permitted.\nFor further information contact us using the Give Feedback button <svg style=\"position:relative;top:3px;\" viewBox=\"64 64 896 896\" focusable=\"false\" data-icon=\"notification\" width=\"1em\" height=\"1em\" fill=\"currentColor\" aria-hidden=\"true\"><path d=\"M880 112c-3.8 0-7.7.7-11.6 2.3L292 345.9H128c-8.8 0-16 7.4-16 16.6v299c0 9.2 7.2 16.6 16 16.6h101.7c-3.7 11.6-5.7 23.9-5.7 36.4 0 65.9 53.8 119.5 120 119.5 55.4 0 102.1-37.6 115.9-88.4l408.6 164.2c3.9 1.5 7.8 2.3 11.6 2.3 16.9 0 32-14.2 32-33.2V145.2C912 126.2 897 112 880 112zM344 762.3c-26.5 0-48-21.4-48-47.8 0-11.2 3.9-21.9 11-30.4l84.9 34.1c-2 24.6-22.7 44.1-47.9 44.1zm496 58.4L318.8 611.3l-12.9-5.2H184V417.9h121.9l12.9-5.2L840 203.3v617.4z\"></path></svg> or email <a href=\"mailto:support@perkforce.com\">support@perkforce.com</a>";
    };
    readonly MS_TEAMS: {
        readonly SEND_PERK_NOTIFICATION: "Click here to send a notification about this perk to your Microsoft Teams.";
        readonly NO_TEAMS_FOUND: "No teams found, please create some public teams with public channels in your Microsoft Teams account.";
        readonly NO_CHANNELS_FOUND: "No public channels found in selected team, please selected another team or create some public channels and try again.";
        readonly MS_CONNECTION_NOT_ALLOWED: "MS Connection is not allowed, please request admin and try again later.";
        readonly ERROR_OCCURRED: "Error occurred while processing microsoft auth request.";
        readonly SELECT_TEAM: "Please select team to continue to send a notification to microsoft teams.";
        readonly SELECT_CHANNEL: "Please select channel to continue to send a notification to microsoft teams.";
        readonly NOT_IN_MS_TEAMS: "Initialization Failed. No Parent window found.";
        readonly ENABLE_INTEGRATION: "Please enable microsoft teams integration to use this feature.";
        readonly ID_TOKEN_REQUIRED: "ID Token is required to complete the MS Teams SSO Auth Request.";
        readonly ACCESS_TOKEN_EXPIRED: "Access Token Expired, please open perkforce app in ms teams again to refresh your access token.";
        readonly TEAM_ID_IS_REQUIRED: "Team Id is required to fetch the channels for that team.";
        readonly TEAM_CHANNEL_ID_IS_REQUIRED: "Team & Channel Id is required to send notification message to the channel.";
        readonly MESSAGE_SENDING_FAILED: "Error occurred while sending the message to channel in MS Teams, please try again.";
        readonly ADAPTIVE_CARD_FAILED: "Error Occurred while creating adaptive card to send message to MS Teams.";
        readonly NOT_ALLOWED: "You are not allowed to use MS Teams feature.";
        readonly INVALID_DATA: "No valid data found for requested MS Teams action, please try again.";
        readonly ERROR_WHILE_SENDING_NOTIFICATION: "Error occurred while sending notification to MS Teams.";
        readonly NOTIFICATION_SENT: "Notification sent successfully.";
        readonly CONNECTED: "Congrats! You're now connected to Microsoft Teams.\nNow each perk has a feature where you can notify your Microsoft Teams channels about it. 🚀";
        readonly DISCONNECTED: "You're now disconnected from Microsoft Teams.\nReconnect anytime to access its amazing features again.";
        readonly ENABLED: "Microsoft Teams is enabled again!\nAll its amazing features are ready for you to enjoy.";
        readonly DISABLED: "Microsoft Teams is disabled.\nYou're still connected, so turning it back on is easy whenever you're ready!";
    };
    readonly PERK_APPROVAL_REQUEST: {
        readonly NO_DISAPPROVE_PERMISSION: "You do not have permission to disapprove this request.";
        readonly REQUEST_ALREADY_PROCESSED: "This request has already been processed.";
        readonly NO_APPROVE_PERMISSION: "You do not have permission to approve this request.";
        readonly NO_VIEW_PERMISSION: "You do not have permission to view the details of this request.";
        readonly NOT_FOUND: "Perk approval request not found.";
        readonly UPDATED: "Perk approval request updated successfully.";
        readonly ALREADY_PROCESSED: "Perk approval request already processed.";
        readonly NO_APPROVAL_HISTORY: "No approval history exists for this perk";
    };
    readonly ROLE: {
        readonly DUPLICATE_TITLE: "A role with the same title already exists.";
        readonly CREATED: "Role created successfully.";
        readonly UPDATED: "Role updated successfully.";
        readonly DELETED: "Role deleted successfully.";
        readonly MISSING_TITLE: "Role title is required.";
        readonly NOT_FOUND: "Role not found.";
        readonly ERROR_DEFAULT_ROLE_UNSET: (role: string) => string;
        readonly ERROR_DEFAULT_ROLE_DELETE: (role: string) => string;
        readonly ERROR_ASSIGNED_ROLE_DELETE: "Cannot delete role because it is assigned to existing users";
        readonly REPLACEMENT_ROLE_NOT_FOUND: "Replacement role not found";
        readonly REPLACEMENT_ROLE_MUST_ACTIVE: "Replacement role must be active.";
        readonly REPLACEMENT_INVALID_DEPRECATED_ROLE: "Invalid replacement role, provided replacement role is in deprecated state";
        readonly INVALID_DEPRECATED_ROLE: "Invalid role, provided role is in deprecated state";
        readonly ROLE_DELETE_REQUIRES_REPLACEMENT: "Cannot delete the role as it is assigned to users. Please provide a replacement role to proceed.";
        readonly ROLE_ALREADY_ASSIGNED: "Role already assigned to user.";
        readonly USER_ROLE_NOT_ASSIGNED: "Role is not assigned to the user.";
        readonly USER_LAST_ROLE_REMOVAL: "You cannot remove the last role assigned to the user.";
        readonly ASSIGNED: "Role successfully assigned to user.";
        readonly REMOVED: "Role successfully removed from user.";
        readonly ROLES_UPDATED: "Roles updated successfully";
        readonly SOME_ROLES_UPDATED_FAILED: "Some roles failed to update";
        readonly CANNOT_SET_DEPRECATED_AS_DEFAULT: "Cannot set a deprecated role as default for any user type";
        readonly REPLACEMENT_ROLE_REQUIRED: "Replacement role id is required in case of deprecated state";
        readonly PERMISSIONS_ASSIGNED: "Permissions assigned to role successfully.";
        readonly PERMISSIONS_REMOVED: "Permissions removed from role successfully.";
        readonly CANNOT_REMOVE_ALL_PERMISSIONS: "Cannot remove all permissions from role.";
        readonly NO_NEW_PERMISSIONS: "The requested permissions are already assigned to this role";
        readonly CANNOT_UPDATE_DEFAULT_ROLE: "Cannot update default roles. Default roles are system-defined and cannot be modified.";
        readonly CANNOT_DELETE_DEFAULT_ROLE: "Cannot delete default roles. Default roles are system-defined and cannot be removed.";
    };
    readonly PERMISSION: {
        readonly NOT_FOUND: "Permission not found.";
        readonly CREATED: "Permission created successfully.";
        readonly UPDATED: "Permission updated successfully.";
        readonly UPDATED_PERMISSIONS: "Permissions updated successfully.";
        readonly DELETED: "Permission deleted successfully.";
        readonly REPLACEMENT_PERMISSION_NOT_FOUND: "Replacement permission not found.";
        readonly REPLACEMENT_PERMISSION_ID_REQUIRED: "Replacement permission id is required.";
        readonly CANNOT_DEPRECATE_PERMISSION_IN_USE: "Cannot deprecate permission that is in use without a replacement.";
        readonly DEPRECATED_SUCCESSFULLY: "Permission deprecated successfully.";
        readonly IN_USE: (count: number) => string;
        readonly TRANSFER_TARGET_NOT_FOUND: "The permission to transfer to does not exist.";
        readonly TRANSFER_TARGET_INVALID: "The target permission for transfer must be active and not deprecated.";
        readonly PERMISSION_ALREADY_EXISTS: "Permission with this identifier already exists.";
        readonly DELETED_BY_ADMINISTRATOR: "Deleted by administrator.";
        readonly INITIALIZED: "Permissions successfully initialized.";
        readonly IDENTIFIER_REQUIRED: "Permission identifier is required.";
        readonly ID_REQUIRED: "Permission id is required.";
        readonly TITLE_REQUIRED: "Permission title is required.";
        readonly TRANSFERRED_AND_DELETED: "Permission transferred and deleted successfully.";
    };
    readonly AUTH: {
        readonly RESTRICT_ACCESS: "Unable to access for now. Please Try Later. Sorry for inconvenience.";
        readonly CODE_RETRIES_LIMIT_REACHED: "5 unsuccessful attempts were made to Sign-in to your account. Access to your account is restricted.";
        readonly CODE_RETRIES: (retryNumber: number) => string;
        readonly ACCOUNT_UNDER_REVIEW: "We are reviewing your account. We will get back to you soon.";
        readonly NO_TERMS_CONDITION_STATUS: "Please accept the Terms of Service and Privacy Policy to continue.";
    };
    readonly PROFILE: {
        readonly UPDATED: "Profile updated.";
    };
    readonly BUDGET: {
        readonly NOT_FOUND: "Budget not found or you do not have access to this budget.";
        readonly EXPIRED_OR_CLAIMED: "Budget expired or already claimed.";
        readonly REFUND_REQUEST: "Refund Requested.";
        readonly APPROVED: "Amount approved.";
        readonly REJECTED: "Amount rejected.";
        readonly REFUNDED: "Budget Refunded.";
    };
    readonly EMPLOYEE: {
        readonly CREATED: "User created.";
        readonly NOT_FOUND: "User not found.";
        readonly DELETED: "User deleted.";
        readonly UPDATED: "User updated.";
        readonly NO_FILE_FOUND: "No file found to import users.";
        readonly EMPLOYEES_IMPORT_SUCCESS: "Users imported successfully.";
        readonly EMPLOYEES_IMPORT_FAILED: "Users import failed.";
        readonly INVALID_FILE_TYPE: "Invalid file type, upload csv file.";
        readonly MAXIMUM_IMPORT_LIMIT: (importEmployeesLimit: string) => string;
        readonly EMPLOYEES_EMAIL_COLUMN_NOT_FOUND: "Users email column not found.";
        readonly INVITE_SENT: "Invite sent.";
    };
    readonly VOUCHER: {
        readonly NOT_ENOUGH_BALANCE: "You dont have enough balance for this voucher.";
    };
    readonly CAROUSEL: {
        readonly ITEM_CREATED: "Carousel item created.";
        readonly NOT_FOUND: "Carousel item not found.";
        readonly ITEM_DELETED: "Carousel item deleted.";
        readonly ITEM_UPDATED: "Carousel item updated.";
        readonly REORDER: "Carousel items reordered.";
    };
    readonly BRAND_CAROUSEL: {
        readonly ITEM_CREATED: "Carousel item created.";
        readonly NOT_FOUND: "Carousel item not found.";
        readonly ITEM_DELETED: "Carousel item deleted.";
        readonly ITEM_UPDATED: "Carousel item updated.";
        readonly LIMIT_REACHED: "Cannot create carousel item, limit reached. Please contact Perkforce for furthur information.";
    };
    readonly CARD: {
        readonly ITEM_CREATED: "Card item created.";
        readonly NOT_FOUND: "Card item not found.";
        readonly ITEM_DELETED: "Card item deleted.";
        readonly ITEM_UPDATED: "Card item updated.";
        readonly REORDER: "Card items reordered.";
    };
    readonly CAROUSEL_SETTINGS: {
        readonly UPDATED: "Carousel settings updated.";
    };
    readonly BRAND_CAROUSEL_SETTINGS: {
        readonly UPDATED: "Carousel settings updated.";
    };
    readonly CARD_SETTINGS: {
        readonly UPDATED: "Card settings updated.";
    };
    readonly PERK_CLICK: {
        readonly CAPTURED: "Perk Click captured.";
    };
    readonly PERK_CATEGORY: {
        readonly DEFAULT: "Cannot update default Perk Category.";
        readonly NOT_FOUND: "Default Perk Category not found.";
        readonly CREATED: "Default Perk Category created.";
        readonly DELETED: "Default Perk Category deleted";
        readonly UPDATED: "Default Perk Category updated";
        readonly EXISTS: "Default Perk Category with the same name already exists.";
        readonly CONTAIN_PERKS: "Cannot delete because there are perks in this category.";
        readonly REORDER: "Default Perk Categories reordered.";
    };
    readonly EMPLOYER: {
        readonly EMPLOYEES_LANDING_CAT_CHANGED: "Users landing category changed.";
    };
    readonly USER_FEEDBACK: {
        readonly FEEDBACK_SUCCESS: "Feedback submitted successfully.";
        readonly FEEDBACK_FAILED: "Feedback submission failed.";
    };
    readonly VERIFY_PERK_REDEEM: {
        readonly FOUND: "Perk redeem code found.";
        readonly NOT_FOUND: "Perk redeem code not found.";
        readonly CODE_CREATED: "Code created successfully.";
        readonly UPDATED: "Perk redeem updated.";
    };
    readonly ORDER: {
        readonly NOT_FOUND: "Order not found.";
        readonly DELETED: "Order deleted.";
    };
    readonly CREDIT_CARD: {
        readonly ADDED: "Credit card added.";
        readonly EXISTS: "Credit card already exists.";
        readonly DELETED: "Credit card deleted.";
    };
    readonly CUSTOM_CATEGORY_ICONS: {
        readonly ADDED: "Custom category icon added.";
        readonly UPDATED: "Custom category icon updated.";
        readonly DELETED: "Custom category icon deleted.";
    };
    readonly PERK_INTEREST: {
        readonly ADDED: "Perk interest registered.";
        readonly REMOVED: "Perk interest unregistered.";
        readonly NOT_FOUND: "Interest not registered for this perk.";
        readonly DUPLICATE: "Perk interest already registered.";
    };
    readonly MOBILE_APP_FORCE_EXCLUDE: {
        readonly ADDED: "Manager Email added successfully.";
        readonly UPDATED: "Manager Email updated successfully.";
        readonly DELETED: "Manager Email deleted successfully.";
        readonly ITEM_EXISTS: "Manager Email already added in the list.";
        readonly MANAGER_NOT_FOUND: "Manager not found, please make sure to enter a manager email.";
    };
    readonly APPS_INTEGRATIONS: {
        readonly INVALID_APP_OR_STATUS: "Invalid integration app or status, please try again.";
    };
    readonly PUSH_NOTIFICATIONS: {
        readonly SUCCESS: "Push notification sent successfully.";
        readonly FAILED: "Error occurred while sending push notification to users.";
        readonly ENABLED: "Push notifications are enabled.";
        readonly DISABLED: "Push notifications are disabled.";
    };
    readonly MIGRATION: {
        USER_TYPE_MISSING: string;
        INVALID_USER_TYPE: string;
        NO_EMAIL: string;
        ALREADY_IN_PROGRESS: string;
    };
};

declare const PERK_CONFIG: {
    readonly PERKS_PER_PAGE: 9;
};
declare const ROLE_CONFIG: {
    readonly ROLES_PER_PAGE: 9;
};

declare const routeSearchParams: {
    readonly pageStep: "p";
};
declare const pagesInnerRoutes: {
    readonly profile: {
        readonly details: "details";
        readonly edit: "edit";
    };
};
declare const routeParams: {
    readonly perkEditId: ":perkEditId";
    readonly perkViewId: ":perkViewId";
    readonly perkIdIU: ":perkIdIU";
    readonly groupSlug: ":groupSlug";
    readonly brandVanityUrlOrId: ":brandVanityUrlOrId";
    readonly brandSubCat: ":brandSubCat";
    readonly brandPerkViewId: ":brandPerkViewId";
    readonly perkBenefitListCat: ":perkBenefitListCat";
    readonly perkBenefitListSubCat: ":perkBenefitListSubCat";
    readonly roleId: ":roleId";
    readonly permissionId: ":permissionId";
};
declare const SHARED_ROUTES: {
    readonly APP_ROOT_URL: "/";
    readonly SIGN_IN_ROUTE: "/sign-in";
    readonly SIGN_UP_ROUTE: "/sign-up";
    readonly ONBOARDING_ROUTE: "/onboarding";
    readonly HOME: "/dashboard";
    readonly PROFILE: "/profile";
    readonly INVITATIONS: "/invitations";
    readonly PERK_INSIGHTS: "/perk-insights";
    readonly LOGOUT: "/logout";
    readonly PERK_MANAGEMENT: "/perk";
    readonly PERK_APPROVAL_REQUESTS: "/perk-approval-requests";
    readonly SINGLE_PERK: "/perk/:perkViewId";
    readonly PERK_INTERESTED_USERS: "/perk/:perkIdIU/interested-users";
    readonly PERK_APPROVAL_REQUEST_HISTORY: "/perk/:perkIdIU/approval-request-history";
    readonly SINGLE_GROUP: "/group/:groupSlug";
    readonly EDIT_PERK: "/perk/edit/:perkEditId";
    readonly CATEGORIES: "/categories";
    readonly EMPLOYEES: "/employees";
    readonly MERCHANTS: "/merchants";
    readonly EDIT_EMPLOYEE_DASHBOARD: "/employee-dashboard";
    readonly GROUPS: "/groups";
    readonly IMPORT_EMPLOYEES: "/import-employees";
    readonly VERIFIED_MEMBER: "/verified-member";
    readonly INVALID_INVITE: "/invalid-invite";
    readonly CHECKOUT_SUCCESS: "/checkout-success";
    readonly CART: "/cart";
    readonly PURCHASES: "/purchases";
    readonly VERIFY_PERK_REDEEM: "/orders";
    readonly PERKS: "/perks";
    readonly EMPLOYERS: "/employers";
    readonly USERS: "/users";
    readonly MERCHANDIZE: "/organisation/:brandVanityUrlOrId";
    readonly MERCHANDIZE_SUB: "/organisation/:brandVanityUrlOrId/:brandSubCat";
    readonly SINGLE_PERK_BRAND: "/organisation/:brandVanityUrlOrId/perk/:brandPerkViewId";
    readonly NEARBY_LOCATION: "/nearby-location";
    readonly NEARBY_LOCATION_CAT: "/nearby-location/:perkBenefitListCat";
    readonly NEARBY_LOCATION_SUB_CAT: "/nearby-location/:perkBenefitListCat/:perkBenefitListSubCat";
    readonly PERK_MANAGEMENT_CAT: "/:perkBenefitListCat";
    readonly PERK_MANAGEMENT_SUBCAT: "/:perkBenefitListCat/:perkBenefitListSubCat";
    readonly REFERRALS: "/referrals";
    readonly SETTINGS: "/settings";
    readonly EMAIL_DOMAINS: "/email-domains";
    readonly BLOCK_EMAIL_EXPRESSIONS: "/block-email-expressions";
    readonly USER_HISTORY: "/user-history";
    readonly PERK_CATEGORIES: "/perk-categories";
    readonly BENEFIT_CATEGORIES: "/benefit-categories";
    readonly LANDIND_PAGE: (userData: IUser) => string;
    readonly EMAIL_SIGNIN_VERIFY: "/callback/verification";
    readonly PAGE_NOT_FOUND: "/page-not-found";
    readonly WILD_CARD: "*";
    readonly APP_ROOT_SIGN_UP_MODAL: "/?type=signup";
    readonly INTEGRATIONS_LIST_PAGE: "/integrations";
    readonly PUSH_NOTIFICATIONS_PAGE: "/push-notifications";
    readonly PUSH_NOTIFICATION_GROUPS: "/push-notification-groups";
    readonly SINGLE_PUSH_NOTIFICATION_GROUP: "/push-notification-groups/:groupSlug";
};

declare const pfrTextTerms: {
    readonly standardUsers: {
        readonly pluralCapitalized: "Standard users";
        readonly pluralPascalCase: "Standard Users";
        readonly pluralLowerCase: "standard users";
        readonly pluralUpperCase: "STANDARD USERS";
        readonly singularCapitalized: "Standard user";
        readonly singularPascalCase: "Standard User";
        readonly singularLowerCase: "standard user";
        readonly singularUpperCase: "STANDARD USER";
    };
    readonly approve: {
        readonly pluralCapitalized: "Approve";
        readonly pluralLowerCase: "approve";
        readonly pluralUpperCase: "APPROVE";
        readonly singularCapitalized: "Approve";
        readonly singularLowerCase: "approve";
        readonly singularUpperCase: "APPROVE";
    };
    readonly disapprove: {
        readonly pluralCapitalized: "Disapprove";
        readonly pluralLowerCase: "disapprove";
        readonly pluralUpperCase: "DISAPPROVE";
        readonly singularCapitalized: "Disapprove";
        readonly singularLowerCase: "disapprove";
        readonly singularUpperCase: "DISAPPROVE";
    };
};

declare const organizationsFcmTopicIdentifiers: {
    readonly mtu: "mtuOrganizationFcmTopic";
    readonly doterra: "doterraOrganizationFcmTopic";
    readonly republicofwork: "republicofworkOrganizationFcmTopic";
    readonly everymancork: "everymancorkOrganizationFcmTopic";
};

declare const hasPfPermission: ({ permission, userPermissions, }: {
    userPermissions: PermissionsEnum[];
    permission: PermissionsEnum;
}) => boolean;
declare const validatePfRequiredPermissions: ({ userPermissions, requiredPermissions, checkModeForRequiredPermissions, }: {
    userPermissions: Array<PermissionsEnum>;
    requiredPermissions?: Array<PermissionsEnum>;
    checkModeForRequiredPermissions?: PermissionCheckModeEnum$1;
}) => boolean;
declare const validatePfExcludedPermissions: ({ userPermissions, excludedPermissions, checkModeForExcludedPermissions, }: {
    userPermissions: Array<PermissionsEnum>;
    excludedPermissions?: Array<PermissionsEnum>;
    checkModeForExcludedPermissions?: PermissionCheckModeEnum$1;
}) => boolean;
declare const validatePfUserPermissions: ({ userPermissions, requiredPermissions, excludedPermissions, checkModeForRequiredPermissions, checkModeForExcludedPermissions, }: IHasRequiredPermissions$1<PermissionsEnum>) => boolean;

declare const getCompanyText: (userData: IUser) => string;
declare const distanceBusiness: (loc?: Array<Loc>, curr?: Loc) => number | false;
declare const getNearestSortedBusiness: ({ curr, locBusiness, nearby, region, sort, }: {
    curr: Loc;
    locBusiness: Array<IUser>;
    nearby: any;
    sort: any;
    region: string;
}) => Promise<{
    distance: number | false;
    region: string;
    _id?: string | undefined;
    stripeCustomerIds?: {
        customerid?: any;
        customerId?: any;
        sellerId?: string;
    }[];
    firstName?: string;
    lastName?: string;
    type?: UserTypeEnum;
    email?: string;
    phoneNo?: string;
    code?: string | number;
    codeGenAt?: string | Date | number;
    companyName?: string;
    verified?: boolean;
    active?: boolean;
    action?: string;
    stripe?: IUserStripeData;
    merchant?: IMerchant<EnvironmentTypeEnum.frontend> | undefined;
    employer?: IUser<EnvironmentTypeEnum.frontend> | undefined;
    createdAt?: string | Date;
    isLoggedIn?: boolean;
    lastSignIn?: string | Date;
    restrictAccess?: boolean;
    suspended?: boolean;
    onboarding?: boolean;
    invited?: boolean;
    invitedBy?: IUser<EnvironmentTypeEnum.frontend> | undefined;
    invite?: IInvite;
    vanityUrl?: string;
    skipPhoneStep?: boolean;
    skipAccountTypeStep?: boolean;
    phoneAttempts?: number;
    lastPhoneAttempt?: string | Date;
    logo?: string;
    headerLogo?: string;
    brandLogo?: string;
    isSuperUser?: boolean;
    employeesLandingCategory?: EmployeesLandingCategory;
    waitingApproval?: boolean;
    employerId?: IUser<EnvironmentTypeEnum.frontend> | undefined;
    employerUserData?: IUser<EnvironmentTypeEnum.frontend> | undefined;
    deletedAt?: string | Date;
    termsAndConditionsAccepted?: boolean;
    termsAndConditionsAcceptedAt?: Array<string | Date>;
    codeRetries?: number;
    stripeAppFeePercent?: number;
    perksUsed?: IPerkUsed<EnvironmentTypeEnum.frontend>[] | undefined;
    perksUsedEveryDays?: IPerkUsed<EnvironmentTypeEnum.frontend>[] | undefined;
    allowStripeConnection?: boolean;
    allowCarousel?: boolean;
    perksPerBusiness?: number;
    carouselItemsPerBusiness?: number;
    perksPerCompany?: number;
    benefitsPerCompany?: number;
    slackConnectionDetails?: IUserSlackData;
    isActive?: boolean;
    lastActiveTime?: string | Date | number;
    allowSlackConnection?: boolean;
    orderEmailRecipient?: boolean;
    groups?: IGroup<EnvironmentTypeEnum.frontend>[] | undefined;
    status?: string;
    allowedAccessBecause?: AllowedAccessBecauseEnum;
    allowedAccessEmailFormat?: string;
    completedByAdminAt?: string | Date | number;
    allowMSTeamsConnection?: boolean;
    msTeamsConDetails?: IMSTeamsData;
    organization_unique_hash?: any;
    tinyMceFolderName?: string;
    microsoftTeamsIntegrationState?: IntegrationStateEnum;
    slackIntegrationState?: IntegrationStateEnum;
    stripeIntegrationState?: IntegrationStateEnum;
    lastLocationUpdatedAt?: string | Date | number;
    fcmTokens?: IFcmDeviceToken[];
    roleIdentifiers?: Array<string>;
    updatedAt?: string | Date | number;
    stripeCustomerid?: any;
    websiteUrl?: string;
    employees?: string;
    description?: string;
    locations?: Array<Loc>;
    lastSlackNotificationInfo?: ILastSlackNotificationInfo;
    allowPushNotifications?: boolean;
    pushNotificationsIntegrationState?: IntegrationStateEnum;
}[]>;
declare const isMerchantEmployee: (user: IUser) => boolean;
declare const isTestAccount: (user: IUser, testAccountEmails: string[]) => boolean;
declare const isScheduledPerk: <Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend>(perk: IPerk<Env> | null) => boolean;
declare const isScheduledPerkV2: <Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend>(perk: IPerk<Env> | null) => boolean;
declare const isEndingSoonPerk: <Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend>(perk: IPerk<Env> | null) => boolean;
declare const isEndedPerk: <Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend>(perk: IPerk<Env> | null) => boolean;
declare const currentPerkStatus: <Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend>(perk: IPerk<Env> | null) => StatusEnum;
declare const getPerkScheduledStatus: <Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend>(perk: IPerk<Env> | null) => StatusEnum;
declare const checkIntegrationIsAllowedAndItsState: (userData: IUser) => {
    msTeamsIntegrationIsAllowed: boolean;
    msTeamsIsConnected: boolean;
    slackIntegrationIsAllowed?: boolean;
    slackIsConnected?: boolean;
    stripeIntegrationIsAllowed?: boolean;
    slackIntegrationIsEnabled?: boolean;
    microsoftTeamsIntegrationIsEnabled?: boolean;
    userCanSendSlackNotifications?: boolean;
    userCanSendMSTeamsNotifications?: boolean;
};
declare const getDefaultBrandLogoType: (_userData: IUser) => BrandLogoEnum;
declare const getPhoneAttemptsV1: (user: IUser) => {
    invalid: boolean;
    timeDiff: string;
};
declare const getPhoneAttempts: (user: IPfFoBUser | null) => {
    invalid: boolean;
    timeDiff: string;
};
declare const getSortQuery: (sort: ISortOptions) => Record<string, number>;
declare const isSuperUser: <Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend>(user: IUser<Env>) => boolean;
declare const generatePfCouponCode: () => string;
declare const getPerkViewUrl: ({ perkId, userSubDomain, frontEndUrl, }: {
    perkId: string;
    userSubDomain: string;
    frontEndUrl?: string;
}) => string;
declare const addTimeToDate: (time?: number, unit?: moment.DurationInputArg2, date?: Date) => string;
declare const formatDate: ({ dateString, formate, }: {
    dateString: string;
    formate?: DateFormatEnum;
}) => string;
declare const formatCompanyName: ({ companyName, }: {
    companyName?: string;
}) => {
    companyName: string;
    vanityUrl: string | undefined;
};

export { ADMIN_TOKEN_LOCALSTORAGE_KEY, APP_FEATURES, AUTH_REDIRECTS, AllowedAccessBecauseEnum, type ApiResponse, ApiResponseStatusEnum, type AwsV3Result, BrandCarouselSettingEffectEnum, BrandLogoEnum, BudgetStatusEnum, ButtonColorEnum, ButtonSizeEnum, ButtonTypeEnum, ButtonVariantEnum, CHART_DATASET_OPTIONS, CHART_OPTIONS, CHART_TYPES, COMMUNICATION_CONFIG, CaptureMethodEnum, CustomCategoryImageTypeEnum, DATE_FORMATS, DEVICE_UUID_LOCALSTORAGE_KEY, DataStoredFromEnum, DateFormatEnum, type EditProfileResult, type EmployeesLandingCategory, EnvironmentTypeEnum, FACEBOOK_OAUTH_URL, FACEBOOK_OAUTH_USER_DATA_URL, FCMTopicsEnum, FIREBASE_RESPONSES, FcmSendMethodEnum, FirebasePushNotificationSendToEnum, FlexAlignEnum, FlexJustifyEnum, FormActionEnum, FormModeEnum, GENERAL_CONFIG, GET_USER_API_UPDATED_AT, GOOGLE_OAUTH_REVOKE_TOKEN, GOOGLE_OAUTH_STATIC_URL, GOOGLE_OAUTH_USER_INFO_URL, GroupTypeEnum, type IAddCartItemResult, type IAddPushNotificationGroupResponse, type IAdminEmailDomain, type IAdminGetBlockEmailExpressionsResponse, type IAdminGetEmailDomainsResponse, type IAdminGetPerksResponse, type IAdminSearchUserResponse, type IApiResponse, type IApiResponseBase, type IAppFeaturesState, type IBenefitCategoryIconCommon, type IBenefitCategoryIconInput, type IBenefitCategoryIcons, type IBenefitCategoryIconsData, type IBenefitClickItem, type IBenefitClicksList, type IBlockEmailExpression, type IBlockEmailExpressionList, type IBrandCarouselItem, type IBrandCarouselSetting, type IBudget, type IBudgetAndBalance, type IBudgetClaim, type IBudgetDetail, type IBudgetDetailPagination, type IBusinessCategoriesList, type IBusinessCategoriesListForAdmin, type IBusinessCategory, type IBusinessCategoryClickItem, type IBusinessCategoryClicksList, type IBusinessCategoryFormInput, type ICard, type ICardOrBannerResult, type ICarouselItem, type ICart, type ICartItem, type ICartItemLimitReached, type ICartItemLimitReachedResponse, type ICategoriesFormInput, type ICategoriesPerksCount, type ICheckoutResult, type ICompaniesAndBusinessWithInvitesList, type ICompaniesData, type ICompaniesForMerchantPerkRedeem, type IContext, type ICreateAccountResult, type ICreatePermissionRequest, type ICreateVoucherResponse, type ICreditCard, type IDeletePermissionRequest, type IDeletePushNotificationGroupResponse, type IDeleteRoleReq, type IDeprecatePermissionRequest, type IDeviceAndBundledAppInfo, type IEditPushNotificationGroupResponse, type IEmailDomain, type IEmployee, type IEmployeesList, type IExcludeManagerMobileAppUse, type IFcmDeviceToken, type IFetchMobileAppInfoResponse, type IFetchNewSignupsSettingResponse, type IFilterOptions, type IFirebasePushNotification, type IGeneralResponseResponse, type IGetActivePerkApprovalRequestByPerkIdResponse, type IGetAllCompanies, type IGetAllCompaniesAndBusinessWithInvitesResponse, type IGetAllPerkInterestRegisteredUsersResponse, type IGetAllowGroupDeleteResponse, type IGetAllowPerkDeleteResponse, type IGetAllowPerkRedeemResponse, type IGetAppFeaturesStateResponse, type IGetBalanceByUserResponse, type IGetBenefitCategoryIconsResponse, type IGetBenefitClicksResponse, type IGetBrandCarouselItemsResponse, type IGetBrandCarouselSettingResponse, type IGetBrandPerksResponse, type IGetBrandUserResponse, type IGetBudgetAmountByUserResponse, type IGetBudgetAndBalanceResponse, type IGetBudgetDetailByIdResponse, type IGetBudgetsDetailByUserResponse, type IGetBusinessCategoriesByUserResponse, type IGetBusinessCategoriesForAdminResponse, type IGetBusinessCategoryBySubCategoryResponse, type IGetBusinessCategoryClicksResponse, type IGetCardOrBannerResponse, type IGetCarouselItemsResponse, type IGetCartResponse, type IGetCheckoutSessionResponse, type IGetCompaniesAndBusinessWithInvitesResponse, type IGetCompaniesForAdminBenefitCategoriesResponse, type IGetCompaniesForMerchantPerkRedeemResponse, type IGetConnectionsResponse, type IGetCreditCardsResponse, type IGetEmailDomainsResponse, type IGetEmployeeHomeBannerInterface, type IGetEmployeeHomeCardsInterface, type IGetEmployeesByEmployerResponse, type IGetEmployerMerchantInvitesResponse, type IGetFcmTopicsResponse, type IGetGroupBySlugResponse, type IGetGroupsByEmployerResponse, type IGetHeaderImageResponse, type IGetImportEmployeesHistoryResponse, type IGetInviteByIdResponse, type IGetIsConnectedResponse, type IGetLastUsedSlackInfoResponse, type IGetLedgerByActorResponse, type IGetMSTeamsNotificationsHistoryResponse, type IGetMSTeamsSelectedTeamChannelsResponse, type IGetMSTeamsUserJoinedTeamsResponse, type IGetManagersListWhereDesktopIsAllowedResponse, type IGetMembersByGroupResponse, type IGetMerchantByCardIdResponse, type IGetMerchantByIdResponse, type IGetMerchantByUserIdResponse, type IGetMerchantsResponse, type IGetOrderEmailRecipientsResponse, type IGetOrdersResponse, type IGetPerkApprovalRequestsByPerkIdRequest, type IGetPerkApprovalRequestsByPerkIdResponse, type IGetPerkApprovalRequestsResponse, type IGetPerkByIdResponse, type IGetPerkCategoriesResponse, type IGetPerkCategoryBySlugResponse, type IGetPerkCategoryClicksResponse, type IGetPerkClicksResponse, type IGetPerkGraphClicksResponse, type IGetPerkInterestRegisteredOrganizationsResponse, type IGetPerkInterestRegisteredResponse, type IGetPerkRedeemCodesResponse, type IGetPerksByUserReq, type IGetPerksByUserResponse, type IGetPerksForCarouselResponse, type IGetPerksRedeemDataResponse, type IGetPurchasablePerksResponse, type IGetPushNotificationGroupBySlugResponse, type IGetPushNotificationGroupsResponse, type IGetRedeemDataByCodeResponse, type IGetReferralsResponse, type IGetSettingsResponse, type IGetSlackNotificationsQResponse, type IGetSlackNotificationsResponse, type IGetSlackWorkspaceChannelsQResponse, type IGetSlackWorkspaceChannelsResponse, type IGetSubCategoryClicksResponse, type IGetSuperEmployeesByEmployerResponse, type IGetSuperEmployeesResponse, type IGetSuperUserPerksResponse, type IGetTestAccountsAdminResponse, type IGetTestAccountsEndUserResponse, type IGetUniqueDiscountCodeResponse, type IGetUserByIdResponse, type IGetUserHistoryResponse, type IGetUserMobileAppInfoListResponse, type IGetUserResponse, type IGetUsersResponse, type IGroup, type IHasRequiredPermissions, type IImpersonateResponse, type IImportEmployeesHistoryItem, type IInterest, type IInvite, type IInviteList, type IJWT, type ILastMSTeamsNotificationInfoResult, type ILastSlackBotNotificationInfo, type ILastSlackNotificationInfo, type ILedger, type ILedgerDetail, type IListRolesReq, type ILocation, IMAGE_CONFIG, IMPERSONATE_HEADER_KEY, IMPERSONATE_LOCALSTORAGE_KEY, type IMSTeamsAppLogs, type IMSTeamsChannel, type IMSTeamsData, type IMSTeamsGetJoinedTeams, type IMSTeamsNotificationsHistory, type IMSTeamsNotificationsHistoryResult, type IMSTeamsTeam, type IMainBanner, type IManagerEmailExcludeInput, type IManagersListWhereDesktopIsAllowed, type IManagersListWhereDesktopIsAllowedResult, type IMaxAllowedPerUserEveryDays, type IMerchant, type IMetaData, type IMicrosoftTeamsNotificationSend, type IMobileAppInfoInput, type IMobileAppInfoType, type IMsTeamsApp, type INewSignupsSettingType, type IOrder, type IOrderItem, type IOrdersList, type IOrganizationsFcmTopicsResponse, type IPerk, type IPerkApprovalRequest, type IPerkApprovalRequestListRequest, type IPerkApprovalRequestProcessRequest, type IPerkCategoriesList, type IPerkCategory, type IPerkCategoryClickItem, type IPerkClick, type IPerkClickByUserItem, type IPerkClickItem, type IPerkClicksByUserList, type IPerkClicksList, type IPerkForm, type IPerkGraphClicksList, type IPerkInterest, type IPerkInterestList, type IPerkInterestOrganizationList, type IPerkList, type IPerkManagement, type IPerkRedeemCode, type IPerkRedeemCodesResult, type IPerkSubCategory, type IPerkUsed, type IPerksRedeemData, type IPerksRedeemDataList, type IPermission, type IPermissionListRequest, type IPermissionListResponse, type IPermissionResponse, type IProfileFormInput, type IPushNotificationFcmTopic, type IPushNotificationGroup, type IPushNotificationGroupFormInput, type IPushNotificationHistory, type IRedeemCode, type IRedeemCodesImportHistory, type IRedeemVoucherResponse, type IReferral, type IReferralList, type IRenewTokenResponse, type IResendCodeResponse, type IRole, type IRoleAssignmentReq, type IRoleForm, type IRolePermissionReq, type ISendErrorResponseProps, type ISendSlackNotification, type ISendSuccessResponseProps, type ISettings, type ISlackAuthedUser, type ISlackChannel, type ISlackIncomingWebhook, type ISlackNotification, type ISlackNotificationsHistory, type ISlackNotificationsHistoryResult, type ISlackResponseMetadata, type ISlackTeam, type ISlackWorkspaceChannel, type ISlackWorkspaceChannels, type ISlackWorkspaceTeam, type ISortOptions, type IStripeError, type ISubCategory, type ISubCategoryClickItem, type ISubCategoryClicksList, type ITestAccount, type ITestAccountsResultForAdmin, type ITestAccountsResultForEndUser, type IToken, type IUnavailableItem, type IUniqueDiscountCode, type IUpdateBrandCarouselSettingResult, type IUpdatePermissionRequest, type IUpdateSettingsInput, type IUpdateUserMobileAppInfoInput, type IUseHasRequiredPermissions, type IUseHasRequiredPermissionsReturn, type IUser, type IUserHistory, type IUserHistoryList, type IUserInputFormData, type IUserLocationHistory, type IUserMobileInfoData, type IUserMobileInfoDataList, type IUserSlackData, type IUserStripeData, type IUserWithToken, type IUsersList, type IVerifyPerkRedeemResponse, type IVoucher, type ImportEmployeeFile, type ImportEmployeeHistoryUserItem, type ImportEmployeeItem, type ImportEmployeesHistoryList, ImportRedeemCodesTypeEnum, IntegrationAppEnum, IntegrationStateEnum, LINKEDIN_OAUTH_ACCESS_TOKEN_URL, LINKEDIN_OAUTH_STATIC_URL, LINKEDIN_OAUTH_USER_DATA_URL, LINKEDIN_OAUTH_USER_INFO_URL, LOTTIE_ANIMATION_START_DELAY, type Loc, LocationTypeEnum, MAP_CONFIG, MESSAGES, type MSTeamsSelectedTeamChannelsResult, MS_TEAMS, NotificationPermissionsEnum, OrderTypeEnum, PAGE_REFRESHED_ONCE_LOCALSTORAGE_KEY, PERKFORCE_DETAILS, PERKFORCE_DOMAINS, PERKFORCE_LOGO, PERKS_PARENT_CATEGORY, PERK_CONFIG, PERK_FORM_GROUPS, POPOVER_TRIGGER, PerkActionEnum, type PerkCategoryClicksList, type PerkInterestOrganizationList, PerkTypeEnum, PermissionCategoryEnum, PermissionCheckModeEnum, PermissionsEnum, PlatformEnum, PlatformTypeEnum, QueryKeyTypeEnum, ROLE_CONFIG, RedeemCodeTypeEnum, S3_BUCKET_FOLDERS, SEND_IN_BLUE_TEMPLATES, SHARED_ROUTES, SHOW_MODAL_LOCALSTORAGE_KEY, SLACK_BOT, SOCKET_IO_EVENTS, SVG_ICON_TYPES, SelectedCategoryTypeEnum, SortOrderEnum, type SpecificPerkRedeemData, StatusEnum, TIME_UNIT_TYPE, TOKEN_HEADER_KEY, TOKEN_LOCALSTORAGE_KEY, TOKEN_VERIFICATION_URL_KEY, TOOLTIP_TRIGGER_ALL, TRUNCATE_TEXT_LENGTH_MEDIUM, TRUNCATE_TEXT_LENGTH_SMALL, TRY_AND_REDIRECT_USER_TO_MOBILE_APP, TestAccountsTypeEnum, URL_PARAMS, URL_TARGET, USER_HEADER_KEY, USER_LOCALSTORAGE_KEY, UnavailableItemTypeEnum, type UseHasRequiredPermissionCheckPermissionType, UserLogChangeTypeEnum, UserTypeEnum, VAR_TYPES, VERIFY_EMAIL_TOKEN_HEADER_KEY, VERIFY_EMAIL_TOKEN_LOCALSTORAGE_KEY, ValidationRuleEnum, addTimeToDate, checkIntegrationIsAllowedAndItsState, currentPerkStatus, distanceBusiness, formFieldsConstants, formatCompanyName, formatDate, generatePfCouponCode, getCompanyText, getDefaultBrandLogoType, getNearestSortedBusiness, getPerkScheduledStatus, getPerkViewUrl, getPhoneAttempts, getPhoneAttemptsV1, getSortQuery, googleApis, hasPfPermission, isEndedPerk, isEndingSoonPerk, isMerchantEmployee, isScheduledPerk, isScheduledPerkV2, isSuperUser, isTestAccount, organizationsFcmTopicIdentifiers, pagesInnerRoutes, pfrTextTerms, routeParams, routeSearchParams, type sendPushNotificationInput, type updatePushNotificationDeviceTokenInput, validatePfExcludedPermissions, validatePfRequiredPermissions, validatePfUserPermissions };