pfr-tk/dist/index.d.ts

Perkforce Tool Kit, specifically developed for perkforce in house development and testing.

import { ObjectId } from 'mongodb';
import { IUser as IUser$1 } from 'zaions-tool-kit/play-and-win';
import { PermissionCheckModeEnum as PermissionCheckModeEnum$1, IHasRequiredPermissions as IHasRequiredPermissions$1 } from 'zaions-tool-kit';
import moment from 'moment';

declare enum USER_TYPE {
    employer = "EMPLOYER",
    employee = "EMPLOYEE",
    merchant = "MERCHANT",
    student_body = "STUDENT_BODY",
    admin = "ADMIN"
}
declare enum INVITE_STATUS {
    PENDING = "PENDING",
    ACCEPTED = "ACCEPTED"
}
declare enum SCHEDULED_STATUS {
    LIVE = "LIVE",
    SCHEDULED = "SCHEDULED",
    ENDED = "ENDED"
}
declare enum PERK_STATUS {
    DRAFT = "DRAFT",
    APPROVED = "APPROVED",
    LIVE = "LIVE",
    SCHEDULED = "SCHEDULED",
    ENDED = "ENDED",
    ENDINGSOON = "ENDINGSOON",
    PENDINGAPPROVAL = "PENDINGAPPROVAL",
    DISAPPROVED = "DISAPPROVED"
}
declare enum PERK_SCHEDULE_STATUS {
    ENDED = "ENDED",
    ENDINGSOON = "ENDINGSOON",
    SCHEDULED = "SCHEDULED",
    LIVE = "LIVE"
}
declare enum PERK_BRAND_LOGO {
    NO_LOGO = "NO_LOGO",
    USE_PERK_LOGO = "USE_PERK_LOGO",
    USE_PROFILE_LOGO = "USE_PROFILE_LOGO"
}
declare enum EMAIL_DOMAIN_STATUS {
    PENDING = "PENDING",
    APPROVED = "APPROVED",
    REJECTED = "REJECTED"
}
declare enum PERK_REDEEM_STATUS {
    VERIFIED = "verified",
    UNVERIFIED = "unverified",
    PENDING = "pending"
}
declare enum ORDER_TYPE {
    PURCHASED = "PURCHASED",
    FREE = "FREE"
}
declare enum UNAVAILABLE_ITEM_TYPE {
    OUT_OF_STOCK = "out_of_stock",
    PER_USER_LIMIT_REACHED = "per_user_limit_reached",
    DRAFT = "draft",
    SCHEDULED = "scheduled",
    EXPIRED = "expired",
    DELETED = "deleted"
}
declare enum GROUP_TYPE {
    SUPER_USERS = "super_users",
    ALL_USERS = "all_users"
}
declare enum FORM_MODE {
    ADD = "add",
    EDIT = "edit",
    LIST = "list"
}
declare enum REDEEM_CODE_TYPE {
    TEXT = "text",
    FILE = "file",
    URL = "url"
}
declare enum ALLOWED_ACCESS_BECAUSE {
    MANUAL = "MANUAL",
    EMAIL_FORMAT = "EMAIL_FORMAT",
    NEW_SIGNUPS_EMPLOYEES = "NEW_SIGNUPS_EMPLOYEES"
}
declare enum PLATFORM {
    ANDROID = "android",
    IOS = "ios",
    WEB = "web"
}
declare enum VALIDATION_RULE {
    string = "string",
    email = "email",
    password = "password",
    positiveInt = "positiveInt",
    url = "url"
}
declare enum MOBILE_DATA_STORED_FROM {
    mobileBrowser = "browser",
    mobileApp = "app"
}
declare enum TEST_ACCOUNTS_TYPE {
    INTERNAL = "internal",
    EXTERNAL = "external"
}
declare enum INTEGRATION_APP {
    MICROSOFT_TEAMS = "microsoft_teams",
    SLACK = "slack",
    STRIPE = "stripe"
}
declare enum INTEGRATION_STATE {
    ENABLED = "enabled",
    DISABLED = "disabled",
    NOT_CONNECTED = "not_connected"
}
declare enum PERK_ACTION_ENUM {
    addEdit = "add_edit",
    pubUnPub = "pub_unpub",
    sendForApproval = "send_for_approval"
}
declare enum SORT_ORDER {
    ASCEND = "ascend",
    DESCEND = "descend"
}
declare enum LOCATION_TYPE {
    point = "Point",
    lineString = "LineString",
    polygon = "Polygon",
    multiPoint = "MultiPoint"
}
declare enum BUTTON_TYPE_ENUM {
    primary = "primary",
    dashed = "dashed",
    default = "default",
    link = "link",
    text = "text"
}
declare enum NotificationPermissions {
    granted = "granted",
    denied = "denied",
    default = "default"
}
declare enum APPROVAL_STATUS {
    PENDING = "PENDING",
    APPROVED = "APPROVED",
    DISAPPROVED = "DISAPPROVED"
}
declare enum USER_TYPE_FILTER {
    ALL = "ALL",
    MADE_BY_ME = "MADE_BY_ME",
    OWNER = "OWNER",
    MERCHANT = "MERCHANT",
    EMPLOYER = "EMPLOYER",
    SUPER_USER = "SUPER_USER",
    STANDARD_USER = "STANDARD_USER",
    STUDENT_BODY = "STUDENT_BODY",
    ADMIN = "ADMIN"
}
declare enum CAPTURE_METHOD {
    AUTOMATIC = "AUTOMATIC",
    MANUAL = "MANUAL"
}
declare enum BudgetStatusEnum {
    NOT_CLAIMED = "NOT_CLAIMED",
    REQUESTED = "REQUESTED",
    GRANTED = "GRANTED",
    REJECTED = "REJECTED",
    EXPIRED = "EXPIRED",
    REFUNDED = "REFUNDED"
}
declare enum BUTTON_SIZE_ENUM {
    small = "small",
    middle = "middle",
    large = "large"
}
declare enum FLEX_ALIGN_ENUM {
    flexStart = "flex-start",
    center = "center",
    flexEnd = "flex-end"
}
declare enum FLEX_JUSTIFY_ENUM {
    flexStart = "flex-start",
    center = "center",
    flexEnd = "flex-end",
    spaceBetween = "space-between",
    spaceAround = "space-around",
    spaceEvenly = "space-evenly"
}
declare enum CUSTOM_CATEGORY_IMAGE_TYPE {
    svg = "svg",
    other = "other"
}
declare enum SELECTED_CATEGORY_TYPE {
    category = "category",
    subcategory = "subcategory"
}
declare enum IMPORT_REDEEM_CODES_TYPE {
    file = "file",
    csv = "csv"
}
declare enum REDEEM_CODE_TYPES {
    FILE = "file",
    URL = "url",
    TEXT = "text"
}
declare enum PlatformTypeEnum {
    web = "web",
    android = "android",
    ios = "ios"
}
declare enum RoleStatus {
    active = "active",
    inactive = "inactive",
    deprecated = "deprecated"
}
declare enum ApiResponseStatusEnum {
    success = "success",
    error = "error"
}
declare enum PermissionCheckModeEnum {
    every = "every",
    any = "any"
}
declare enum EnvironmentTypeEnum {
    frontend = "frontend",
    backend = "backend"
}
declare enum DATA_STORED_FROM {
    mobileBrowser = "mobile-browser",
    mobileApp = "mobile-app"
}
declare enum BUDGET_STATUS {
    NOT_CLAIMED = "not claimed",
    REQUESTED = "requested",
    GRANTED = "granted",
    REJECTED = "rejected",
    EXPIRED = "expired",
    REFUNDED = "refunded"
}
declare enum EMPLOYEE_STATUS {
    ADDED = "added",
    INVITED = "invited",
    SIGNED_UP = "signed_up"
}
declare enum PERK_TYPE {
    PERK = "perk",
    BENEFIT = "benefit"
}
declare enum FORM_ACTION {
    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 BatchStatusEnum {
    completed = "completed",
    failed = "failed"
}
declare enum MigrationStatusEnum {
    pending = "pending",
    inProgress = "inProgress",
    completed = "completed",
    failed = "failed"
}
declare enum UserLogChangeTypeEnum {
    validationFailed = "validationFailed",
    roleUpdate = "roleUpdate",
    processingError = "processingError"
}
declare enum BatchDetailStatusEnum {
    pending = "pending",
    processing = "processing",
    completed = "completed",
    failed = "failed"
}
declare enum PermissionStatus$1 {
    active = "active",
    inactive = "inactive",
    deprecated = "deprecated"
}

declare enum PermissionCategory {
    userManagement = "userManagement",
    roleManagement = "roleManagement",
    perkManagement = "perkManagement",
    perkApprovalManagement = "perkApprovalManagement",
    permissionManagement = "permissionManagement"
}
declare enum PermissionsEnum {
    listPerks = "listPerks",
    viewPerk = "viewPerk",
    viewNonPublishedPerks = "viewNonPublishedPerks",
    viewAnyPerk = "viewAnyPerk",
    createPerk = "createPerk",
    updatePerk = "updatePerk",
    updateOrgUserPerk = "updateOrgUserPerk",
    updateAnyPerk = "updateAnyPerk",
    deletePerk = "deletePerk",
    deleteOrgUserPerk = "deleteOrgUserPerk",
    deleteAnyPerk = "deleteAnyPerk",
    restorePerk = "restorePerk",
    forceDeletePerk = "forceDeletePerk",
    listTrashedPerks = "listTrashedPerks",
    viewTrashedPerk = "viewTrashedPerk",
    canAddDescriptionToPerk = "canAddDescriptionToPerk",
    canAddImageToPerk = "canAddImageToPerk",
    canAddLogoToPerk = "canAddLogoToPerk",
    canAddCategoryToPerk = "canAddCategoryToPerk",
    canAddGroupsToPerk = "canAddGroupsToPerk",
    canAddContactToPerk = "canAddContactToPerk",
    canAddDisplayScheduleToPerk = "canAddDisplayScheduleToPerk",
    canAddDiscountToPerk = "canAddDiscountToPerk",
    canAddPurchasableToPerk = "canAddPurchasableToPerk",
    canAddLimitsAndConstraintsToPerk = "canAddLimitsAndConstraintsToPerk",
    canAddCodesToPerk = "canAddCodesToPerk",
    canAddInterestToPerk = "canAddInterestToPerk",
    canAddLocationsToPerk = "canAddLocationsToPerk",
    canPublishPerk = "canPublishPerk",
    listPerkApprovalRequests = "listPerkApprovalRequests",
    listAllPerkApprovalRequests = "listAllPerkApprovalRequests",
    viewPerkApprovalRequest = "viewPerkApprovalRequest",
    viewAnyPerkApprovalRequest = "viewAnyPerkApprovalRequest",
    createPerkApprovalRequest = "createPerkApprovalRequests",
    updatePerkApprovalRequest = "updatePerkApprovalRequest",
    deletePerkApprovalRequest = "deletePerkApprovalRequest",
    restorePerkApprovalRequest = "restorePerkApprovalRequest",
    forceDeletePerkApprovalRequest = "forceDeletePerkApprovalRequest",
    listTrashedPerkApprovalRequests = "listTrashedPerkApprovalRequests",
    viewTrashedPerkApprovalRequest = "viewTrashedPerkApprovalRequest",
    rejectPerkApprovalRequest = "rejectPerkApprovalRequest",
    rejectAnyPerkApprovalRequest = "rejectAnyPerkApprovalRequest",
    approvePerkApprovalRequest = "approvePerkApprovalRequest",
    approveAnyPerkApprovalRequest = "approveAnyPerkApprovalRequest",
    listRoles = "listRoles",
    viewRole = "viewRole",
    createRole = "createRole",
    updateRole = "updateRole",
    deleteRole = "deleteRole",
    restoreRole = "restoreRole",
    forceDeleteRole = "forceDeleteRole",
    listTrashedRole = "listTrashedRole",
    viewTrashedRole = "viewTrashedRole",
    canAssignRoleToUser = "canAssignRoleToUser",
    canRemoveRoleFromUser = "canRemoveRoleFromUser",
    canRunRoleValidatorManager = "canRunRoleValidatorManager",
    canRunUserRoleBackgroundMigration = "canRunUserRoleBackgroundMigration",
    canViewUserRoleBackgroundMigration = "canViewUserRoleBackgroundMigration",
    assignPermissionsToRole = "assignPermissionsToRole",
    removePermissionsFromRole = "removePermissionsFromRole",
    listPermissions = "listPermissions",
    viewPermission = "viewPermission",
    createPermission = "createPermission",
    updatePermission = "updatePermission",
    deletePermission = "deletePermission",
    restorePermission = "restorePermission",
    forceDeletePermission = "forceDeletePermission",
    listTrashedPermission = "listTrashedPermission",
    viewTrashedPermission = "viewTrashedPermission",
    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 ISortOptions {
    field: string;
    order: SORT_ORDER;
}
interface IContext {
    user: IUser$1;
    userId?: ObjectId;
    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?: ObjectId;
    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 IBenefitCategoryIconsData<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    title?: string;
    keywords?: string;
    iconUrl?: string;
    enabled?: boolean;
    createdAt?: string | Date;
    updatedAt?: string | Date;
}
interface IGetBenefitCategoryIconsResponse {
    getBenefitCategoryIcons?: IBenefitCategoryIcons;
}
interface IBenefitCategoryIcons {
    data?: Array<IBenefitCategoryIconsData>;
    count?: string;
    canLoadMore?: boolean;
    success?: boolean;
    message?: string;
}
interface ICategoriesFormInput extends IBenefitCategoryIconsData {
    icon?: File | null;
    previewUrl?: string;
}

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

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

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

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?: string;
    displayName?: string;
    internalId?: string;
    webUrl?: string;
    isArchived?: boolean;
    visibility?: string;
}
interface IMSTeamsChannel {
    id?: string;
    displayName?: string;
    webUrl?: string;
    membershipType?: string;
}
interface IMSTeamsNotificationsHistory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    userId?: string;
    userName?: string;
    userType?: USER_TYPE;
    perkId?: string;
    perkTitle?: string;
    organizationOwnerId?: string;
    userIsTheOrganizationOwner?: boolean;
    categoryName?: string;
    categoryLink?: string;
    msChannel?: IMSTeamsChannel;
    msTeam?: IMSTeamsTeam;
    createdAt?: string | Date;
}
interface ILastMSTeamsNotificationInfoResult {
    msTeamsTeam?: IMSTeamsTeam;
    msTeamsChannel?: IMSTeamsChannel;
}
interface IMSTeamsNotificationsHistoryResult {
    msTeamsNotificationsHistory?: Array<IMSTeamsNotificationsHistory>;
    lastMSTeamsNotificationInfo?: ILastMSTeamsNotificationInfoResult;
}
interface IMSTeamsGetJoinedTeams {
    message?: string;
    success?: boolean;
    joinedTeams?: Array<IMSTeamsTeam>;
}
interface MSTeamsSelectedTeamChannelsResult {
    message?: string;
    success?: boolean;
    channels?: Array<IMSTeamsChannel>;
}
interface IMicrosoftTeamsNotificationSend {
    message?: string;
    success?: boolean;
    notificationRecord?: IMSTeamsNotificationsHistory;
}
interface IGetMSTeamsNotificationsHistoryResponse {
    getMSTeamsNotificationsHistory?: IMSTeamsNotificationsHistoryResult;
}
interface IGetMSTeamsUserJoinedTeamsResponse {
    getMSTeamsUserJoinedTeams: {
        message?: string;
        success?: boolean;
        joinedTeams: Array<IMSTeamsTeam>;
    };
}
interface IGetMSTeamsSelectedTeamChannelsResponse {
    getMSTeamsSelectedTeamChannels: {
        message?: string;
        success?: boolean;
        channels?: Array<IMSTeamsChannel>;
    };
}

interface Loc {
    id?: string;
    lat?: number;
    lng?: number;
    desc?: string;
}
interface IProfile<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    userId?: IUser;
    websiteUrl?: string;
    perkPrefilPhone?: string;
    employees?: string;
    description?: string;
    createdAt?: string;
    locations?: Array<Loc>;
    budgetApprovalEmailAddresses?: string[];
    deletedAt?: string;
}
interface IGetProfileByUserResponse {
    getProfileByUser: IProfile;
}
interface IGetBrandProfileResponse {
    getBrandProfile?: IProfile;
}
interface EditProfileResult {
    success?: boolean;
    message?: string;
    user?: IUser;
}

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

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

interface IPerkUsed {
    perk: IPerk;
    used: string;
}
interface IUser<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    stripeCustomerIds?: string;
    firstName?: string;
    lastName?: string;
    type?: USER_TYPE;
    email?: string;
    phoneNo?: string;
    code?: string | number;
    codeGenAt?: string | Date;
    companyName?: string;
    verified?: boolean;
    active?: boolean;
    action?: string;
    stripe?: IUserStripeData;
    merchant?: IMerchant;
    employer?: IProfile;
    profile?: IProfile;
    createdAt?: string | Date;
    isLoggedIn?: boolean;
    lastSignIn?: string | Date;
    restrictAccess?: boolean;
    suspended?: boolean;
    onboarding?: boolean;
    invited?: boolean;
    invitedBy?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : IUser;
    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 ? string | ObjectId : IUser;
    distance?: string;
    region?: boolean;
    employerUserData?: IUser;
    deletedAt?: string | Date;
    termsAndConditionsAccepted?: boolean;
    termsAndConditionsAcceptedAt?: Array<string | Date>;
    codeRetries?: number;
    stripeAppFeePercent?: number;
    perksUsed?: Array<IPerkUsed>;
    perksUsedEveryDays?: Array<IPerkUsed>;
    allowStripeConnection?: boolean;
    allowCarousel?: boolean;
    perksPerBusiness?: number;
    carouselItemsPerBusiness?: number;
    perksPerCompany?: number;
    benefitsPerCompany?: number;
    slackConnectionDetails?: IUserSlackData;
    isActive?: boolean;
    lastActiveTime?: string;
    allowSlackConnection?: boolean;
    orderEmailRecipient?: boolean;
    groups?: Array<IGroup>;
    status?: string;
    allowedAccessBecause?: ALLOWED_ACCESS_BECAUSE;
    allowedAccessEmailFormat?: string;
    completedByAdminAt?: string;
    allowMSTeamsConnection?: boolean;
    msTeamsConDetails?: IMsTeamsApp;
    organization_unique_hash?: IUser;
    tinyMceFolderName?: string;
    microsoftTeamsIntegrationState?: INTEGRATION_STATE;
    slackIntegrationState?: INTEGRATION_STATE;
    stripeIntegrationState?: INTEGRATION_STATE;
    lastLocationUpdatedAt?: string;
    fcmTokens?: IFcmDeviceToken[];
    roleIdentifiers?: Array<string>;
    updatedAt: string | Date;
}
interface IFcmDeviceToken {
    token: string;
    addedAt: string;
    updatedAt: string;
    platform: PlatformTypeEnum;
}
interface EmployeesLandingCategory {
    isDefault?: boolean;
    categoryId?: string;
    categorySlug?: string;
}
interface IUserWithToken {
    token?: string;
    user?: IUser;
    success?: boolean;
    message?: string;
    noEmail?: boolean;
    vanityVerified?: string;
    codeRetriesLimitReached?: boolean;
    activationLink?: string;
}
interface IJWT {
    token?: string;
    success?: boolean;
    message?: string;
}
interface IImpersonateResponse {
    success?: boolean;
    message?: string;
    token?: string;
    user?: IUser;
    adminToken?: string;
}
interface IBudgetAndBalance {
    budget?: string;
    balance?: string;
}
interface IUsersList {
    users?: IUser[];
    count?: number;
}
interface ICompaniesAndBusinessWithInvitesList {
    users?: IUser[];
    count?: number;
}
interface IGetUserResponse {
    getUser?: IUser;
}
interface IGetUserByIdResponse {
    getUserById?: IUser;
}
interface IGetBrandUserResponse {
    getBrandUser?: IUser;
}
interface IGetUsersResponse {
    getUsers?: IUsersList;
}
interface IRenewTokenResponse {
    renewToken: IUserWithToken;
}
interface IResendCodeResponse {
    resendCode: IUser;
}
interface IGetHeaderImageResponse {
    getHeaderImage?: string;
}
interface IGetBudgetAndBalanceResponse {
    getHeaderImage?: IBudgetAndBalance;
}
interface IGetCompaniesAndBusinessWithInvitesResponse {
    getCompaniesAndBusinessWithInvites?: ICompaniesAndBusinessWithInvitesList;
}
interface IGetAllCompaniesAndBusinessWithInvitesResponse {
    getAllCompaniesAndBusinessWithInvites?: ICompaniesAndBusinessWithInvitesList;
}
interface IAdminSearchUserResponse {
    adminSearchUser: {
        users?: Array<IUser>;
        count?: number;
        success?: boolean;
        message?: string;
    };
}
interface IUserInputFormData {
    firstName?: string;
    lastName?: string;
    email?: string;
    phoneNo?: string;
    verified?: boolean;
    type?: USER_TYPE;
    active?: boolean;
    social?: boolean;
    action?: string;
    isMobile?: boolean;
    onboarding?: boolean;
    vanityUrl?: string;
    waitingApproval?: boolean;
    imageUrl?: string;
    phoneAttempts?: number;
    fbToken?: string;
    fbId?: string;
    signUp?: boolean;
}

interface ISubCategory<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    name?: string;
    slug?: string;
    categoryId: string;
    order?: number;
    isDefault?: boolean;
    createdBy?: string;
    addedBy?: IUser;
    count?: number;
    perkCount?: number;
    draftCount?: number;
    createdAt?: string | Date;
    updatedAt?: string | Date;
    deletedAt?: string | Date;
}
interface IGetSubCategoriesResponse {
    getSubCategories?: Array<ISubCategory>;
}
interface IGetSubCategoryBySlugResponse {
    getSubCategoryBySlug?: ISubCategory;
}

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

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

interface ILocationPerk {
    lat?: number;
    lng?: number;
    desc?: string;
    className?: string;
}
interface IRedeemCode<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    perkId?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    userId?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : 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 ? string | ObjectId : string;
    name?: string;
    perkType?: string;
    useProfileLocation?: boolean;
    businessCategory?: IBusinessCategory;
    subCategory?: ISubCategory;
    perkCategory?: IPerkCategory;
    details: string;
    website?: string;
    contactName?: string;
    discountCode?: string;
    phoneNo?: string;
    image?: string;
    imageUrl?: string;
    brandLogo?: string;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : IUser;
    createdBySuperUser?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : IUser;
    createdByStandardUser?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : IUser;
    status?: PERK_STATUS;
    brandLogoType?: PERK_BRAND_LOGO;
    createdAt?: string | Date;
    locations?: Array<ILocationPerk>;
    alwaysDisplay?: boolean;
    displayFromDate?: string | Date;
    displayUntilDate?: string | Date;
    updatedAt?: string | Date;
    notForGeneralPublic?: boolean;
    forUserType?: string;
    forUsers?: Env extends EnvironmentTypeEnum.backend ? string[] | ObjectId[] : 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>;
    lastSlackNotificationInfo?: ILastSlackNotificationInfo;
    forGroups?: Env extends EnvironmentTypeEnum.backend ? string[] | ObjectId[] : string[];
    perkDetailsText?: string;
    interest?: IInterest;
    currentUserInterestRegistered?: boolean;
    scheduledStatus?: SCHEDULED_STATUS;
    startDate?: string;
    endDate?: string;
    action?: PERK_ACTION_ENUM;
    sendSlackNotification?: boolean;
    sendMicrosoftTeamsNotification?: boolean;
    userSubDomain?: string;
    perkLocations?: {
        type: LOCATION_TYPE;
        coordinates: Array<ILocationPerk>;
    };
    isAlwaysAvailable?: boolean;
    displayNow?: boolean;
}
interface IPerkForm extends Partial<IPerk> {
    allowedPerUser?: number;
    allowedEveryDays?: number;
}
interface IPerkList {
    perks?: Array<IPerk>;
    count?: number;
}
interface IPerkManagement {
    step?: FORM_MODE;
    searchQuery?: {
        value?: string;
        trigger?: boolean;
    };
    userTypeFilter?: string | null;
    purchasableFilter?: boolean;
    status?: string | null;
    showReferralModal?: boolean;
    showInviteModal?: boolean;
    showPageOptions?: boolean;
    processing?: boolean;
}
interface IGetPerksByUserResponse {
    getPerksByUser?: {
        perks?: Array<IPerk>;
        count?: number;
        perksPerPage?: number;
        isValidCategory?: boolean;
        isValidSubCategory?: boolean;
    };
}
interface IGetPerkByIdResponse {
    getPerkById?: {
        perk?: IPerk;
        perkRedeemCodes?: IRedeemCode;
        userAllowanceReached?: boolean;
    };
}
interface IGetAllowPerkDeleteResponse {
    getAllowPerkDelete?: boolean;
}
interface IGetAllowPerkRedeemResponse {
    getAllowPerkRedeem?: boolean;
}
interface IGetPurchasablePerksResponse {
    getPurchasablePerks?: Array<IPerk>;
}
interface IAdminGetPerksResponse {
    adminGetPerks?: IPerkList;
}
interface IGetBrandPerksResponse {
    getBrandPerks?: IPerkList;
}
interface IGetSuperUserPerksResponse {
    getSuperUserPerks?: Array<IPerk>;
}

interface IBenefitClickItem<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    count?: string;
    benefit?: IPerk;
}
interface IGetBenefitClicksResponse {
    getBenefitClicks?: IBenefitClicksList;
}
interface IBenefitClicksList {
    benefitClicks?: Array<IBenefitClickItem>;
    count?: string;
}

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

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

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

interface IBudget<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : 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 ? string | ObjectId : IUser;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IBudgetDetail<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    budget?: IBudget;
    claim?: IBudgetClaim;
    amount?: number;
    createdFor?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : IUser;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : IUser;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IBudgetClaim<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    budgetEntry?: IBudgetDetail;
    amountApproved?: number;
    receipt?: String;
    comment?: String;
    amountRequested?: number;
    status?: BudgetStatusEnum;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : IUser;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IBudgetDetailPagination {
    total?: number;
    budgetsDetail?: Array<IBudgetDetail>;
}
interface IGetBudgetAmountByUserResponse {
    getBudgetAmountByUser?: number;
}
interface IGetBudgetDetailByIdResponse {
    getBudgetDetailById?: IBudgetDetail;
}
interface IGetBudgetsDetailByUserResponse {
    getBudgetsDetailByUser?: IBudgetDetailPagination;
}

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

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

interface ICarouselSetting<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    autoplay?: boolean;
    autoplaySpeed?: number;
    effect?: string;
    dots?: boolean;
    arrows?: boolean;
    createdBy?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : IUser;
}
interface IGetCarouselSettingResponse {
    getCarouselSetting?: ICarouselSetting;
}

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

interface ICompaniesData {
    data?: Array<IUser>;
    success?: boolean;
    message?: string;
}
interface ICompaniesForMerchantPerkRedeem {
    data?: {
        _id?: string;
        email?: string;
        companyName?: string;
    };
    success?: boolean;
    message?: string;
}
interface IGetCompaniesForMerchantPerkRedeemResponse {
    getCompaniesForMerchantPerkRedeem?: ICompaniesData;
}
interface IGetCompaniesForAdminBenefitCategoriesResponse {
    getCompaniesForAdminBenefitCategories?: ICompaniesData;
}

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

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

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

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 ? string | ObjectId : string;
    duplicateUsersFound?: boolean;
    usersWithNoEmailFound?: boolean;
    usersWithInvalidEmailFound?: boolean;
    duplicateUsers?: Array<ImportEmployeeHistoryUserItem>;
    usersWithNoEmail?: Array<ImportEmployeeHistoryUserItem>;
    usersWithInvalidEmail?: Array<ImportEmployeeHistoryUserItem>;
    totalRowsHandled?: number;
    userId?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : IUser;
    errorOccured?: boolean;
    errors?: string;
    file?: ImportEmployeeFile;
    createdAt?: string | Date;
    deletedAt?: string | Date;
}
interface IGetImportEmployeesHistoryResponse {
    getImportEmployeesHistory?: {
        importEmployeesHistory?: Array<IImportEmployeesHistoryItem>;
    };
}
interface ImportEmployeesHistoryList {
    importEmployeesHistory?: Array<IImportEmployeesHistoryItem>;
}

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

interface IUserMobileInfoData<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    userId?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : IUser;
    userEmail?: string;
    deviceUUID?: string;
    mobileAppIsUptoDate?: boolean;
    installedAppVersionText?: string;
    installedAppVersionCode?: number;
    deviceLanguageCode?: string;
    deviceLanguageTag?: string;
    deviceName?: string;
    deviceModel?: string;
    devicePlatform?: PLATFORM;
    deviceOperatingSystem?: string;
    deviceOSVersion?: string;
    deviceManufacturer?: string;
    deviceISVirtual?: boolean;
    deviceWebViewVersion?: string;
    dataStoredFrom?: DATA_STORED_FROM;
    createdAt?: string | Date;
    updatedAt?: string | Date;
}
interface IManagersListWhereDesktopIsAllowed<Env extends EnvironmentTypeEnum = EnvironmentTypeEnum.frontend> {
    _id?: Env extends EnvironmentTypeEnum.backend ? string | ObjectId : string;
    email?: string;
    description?: string;
    isActive?: boolean;
    createdAt?: string | Date;
    updatedAt?: string | Date;
}
interface IManagersListWhereDesktopIsAllowedResult {
    items?: Array<IManagersListWhereDesktopIsAllowed>;
    count?: number;
    success?: boolean;
    message?: string;
}
interface IUserMobileInfoDataList {
    items?: Array<IUserMobileInfoData>;
    count?: number;
    success?: boolean;
    message?: string;
}
interface IGetUserMobileAppInfoListResponse {
    getUserMobileAppInfoList?: IUserMobileInfoDataList;
}
interface IGetManagersListWhereDesktopIsAllowedResponse {
    getManagersListWhereDesktopIsAllowed?: IManagersListWhereDesktopIsAllowedResult;
}

interface IPerkRedeemCode {
    _id?: string;
    userId?: string;
    perkId?: string;
    code?: string;
    type?: REDEEM_CODE_TYPE;
    url?: string;
    file?: string;
    expireDate?: string;
    purchasedAt?: string;
    createdAt?: string | Date;
    updatedAt?: string | Date;
    deletedAt?: string | Date;
}
interface IGetPerkRedeemCodesResponse {
    getPerkRedeemCodes?: {
        redeemCodes?: Array<IPerkRedeemCode>;
        success?: boolean;
        message?: string;
        purchaseableRedeemCodesCount?: number;
    };
}
interface IPerkRedeemCodesResult {
    redeemCodes?: Array<IPerkRedeemCode>;
    success?: boolean;
    message?: string;
    purchaseableRedeemCodesCount?: number;
}

interface IUniqueDiscountCode {
    discountCode?: string;
    type?: string;
    message?: string;
    success?: b