import React$1, { MouseEventHandler, RefObject } from 'react';
import { Profile, CredentialSubject, VerificationItem, VC, AchievementCredential, VerificationStatus } from '@learncard/types';

declare enum DisplayTypeEnum {
    Badge = "badge",
    Certificate = "certificate",
    ID = "id",
    Course = "course",
    Award = "award"
}

declare enum LCCategoryEnum {
    socialBadge = "Social Badge",
    achievement = "Achievement",
    course = "Course",
    job = "Job",
    id = "ID",
    workHistory = "Work History",
    currency = "Currency",
    learningHistory = "Learning History",
    skill = "Skill",
    membership = "Membership",
    event = "Event",
    accommodations = "Accommodation",
    accomplishments = "Accomplishment",
    meritBadge = "Merit Badge"
}
declare enum LCSubtypes {
    job = "job",
    achievement = "achievement",
    skill = "skill",
    course = "course",
    locked = "locked"
}
declare enum WalletCategoryTypes {
    achievements = "achievements",
    jobHistory = "jobhistory",
    learningHistory = "learningHistory",
    skills = "skills",
    socialBadge = "socialBadge",
    relationships = "relationships",
    accommodations = "accommodations",
    accomplishments = "accomplishments",
    events = "events",
    membership = "membership",
    goals = "goals",
    ids = "ids",
    currency = "currency"
}
type VCDisplayCardProps = {
    title?: string;
    createdAt?: string;
    issuer?: Profile;
    issuee?: Profile;
    subjectImageComponent?: React$1.ReactNode;
    issuerImageComponent?: React$1.ReactNode;
    hideProfileBubbles?: boolean;
    userImage?: string;
    className?: string;
    credentialSubject?: CredentialSubject;
    onClick?: () => void;
    loading?: boolean;
    verification?: VerificationItem[];
    handleClick?: () => void;
    overrideDetailsComponent?: React$1.ReactNode;
    overrideCardTitle?: string;
    overrideCardImageComponent?: React$1.ReactNode;
    customHeaderComponent?: React$1.ReactNode;
};
type SmallAchievementCardProps = {
    title?: string;
    thumbImgSrc?: string;
    showStatus?: boolean;
    showSkills?: boolean;
    date?: string;
    onClick?: () => void;
};
type AchievementCardProps = {
    title?: string;
    thumbImgSrc?: string;
    showStatus?: boolean;
    claimStatus?: boolean;
    showSkills?: boolean;
    skillCount?: number;
    showChecked?: boolean;
    checked?: boolean;
    onCheckClick?: () => void;
    onClick?: () => void;
};
type CourseCardProps = {
    status?: string;
    title?: string;
    semester?: string;
    skillCount?: string | number;
    thumbSrc?: string;
    jobCount?: string | number;
    className?: string;
    hideHeader?: boolean;
    check?: boolean;
    achievementCount: string | number;
    onClick?: () => void;
};
type CourseCardVerticalProps = {
    title?: string;
    className?: string;
    thumbImgSrc?: string;
    showStatus?: boolean;
    claimStatus?: boolean;
    achievementCount?: number;
    skillCount?: number;
    date?: string;
    checked?: boolean;
    showChecked?: boolean;
    showSubCount?: boolean;
    onCheckClick?: () => void;
    onClick?: () => void;
};
type SkillsCardProps = {
    count?: number;
    title?: string;
    level?: string;
    category?: string;
    levelCount?: number;
    skillColor?: string;
    onClick?: () => void;
    className?: string;
};
type SkillStat = {
    name?: string;
    percent: number | string;
    className?: string;
};
type SkillsStatsCardProps = {
    totalCount?: string | number;
    skills?: SkillStat[];
    className?: string;
    onClick?: () => void;
};
type SkillVerticalCardProps = {
    title: string;
    completed?: number;
    total?: number;
    thumbImg?: string;
    onClick?: () => void;
    className?: string;
};
type RoundedPillProps = {
    statusText?: string;
    type?: LCSubtypes.course | LCSubtypes.achievement | LCSubtypes.skill | 'locked';
    onClick?: () => void;
    showCheckmark?: boolean;
};
type JobQualificationsCount = {
    fulfilledCount: number;
    totalRequiredCount: number;
};
type JobQualificationDisplay = {
    skills?: JobQualificationsCount;
    achievements?: JobQualificationsCount;
    courses?: JobQualificationsCount;
};
type JobListCardProps = {
    title?: string;
    customButtonComponent?: React$1.ReactNode;
    company?: string;
    compensation?: string;
    location?: string;
    locationRequirement?: string;
    timeRequirement?: string;
    qualificationDisplay?: JobQualificationDisplay;
    percentQualifiedDisplay?: string;
    postDateDisplay?: string;
    imgThumb?: string;
    isBookmarked?: boolean;
    className?: string;
    onBookmark?: () => void;
    onClick?: () => void;
};
type LearnPillProps = {
    count: number | string;
    type: LCSubtypes.course | LCSubtypes.achievement | LCSubtypes.skill;
    className?: string;
};
type CircleCheckButtonProps = {
    onClick?: () => void;
    className?: string;
    bgColor?: string;
    checked?: boolean;
};
type SkillTabCardProps = {
    title?: string;
    description?: string;
    checked?: boolean;
    showChecked?: boolean;
    showStatus?: boolean;
    className?: string;
    onCheckClicked?: () => void;
    onClick?: () => void;
};
type JobHistoryCardProps = {
    title?: string;
    company?: string;
    description?: string;
    dateRange?: string;
    jobType?: string;
    className?: string;
    showArrow?: boolean;
    onClick?: () => void;
};
type GenericCardProps = {
    title?: string;
    className?: string;
    type?: WalletCategoryTypes;
    thumbImgSrc?: string;
    customThumbClass?: string;
    customHeaderClass?: string;
    showChecked?: boolean;
    checkStatus?: boolean;
    onClick?: () => void;
    flipped?: boolean;
};
type IssueHistory = {
    id?: string | number;
    name?: string;
    thumb?: string;
    date?: string;
};
type BoostSmallCardProps = {
    title?: string;
    customTitle?: React$1.ReactNode | string | null;
    className?: string;
    type?: WalletCategoryTypes;
    thumbImgSrc?: string;
    customThumbClass?: string;
    customHeaderClass?: string;
    customBodyClass?: string;
    showChecked?: boolean;
    checkStatus?: boolean;
    customButtonComponent?: React$1.ReactNode;
    customThumbComponent?: React$1.ReactNode;
    customBodyComponent?: React$1.ReactNode;
    customDraftComponent?: React$1.ReactNode;
    arrowOnClick?: () => void;
    buttonOnClick?: () => void;
    onCheckClick?: () => void;
    innerOnClick?: () => void;
    optionsTriggerOnClick?: () => void;
    issueHistory?: IssueHistory[];
    bgImgSrc?: string;
};
type BoostGenericCardProps = {
    title?: string;
    customTitle?: React$1.ReactNode | string | null;
    className?: string;
    type?: WalletCategoryTypes;
    thumbImgSrc?: string;
    customThumbClass?: string;
    customHeaderClass?: string;
    showChecked?: boolean;
    checkStatus?: boolean;
    onCheckClick?: () => void;
    customThumbComponent?: React$1.ReactNode;
    innerOnClick?: () => void;
    bgImgSrc?: string;
    issuerName?: string;
    customIssuerName?: React$1.ReactNode | string | null;
    optionsTriggerOnClick?: () => void;
    dateDisplay?: string;
    customDateDisplay?: React$1.ReactNode | string | null;
    verifierBadge?: React$1.ReactNode;
    credential?: VC;
    isInSkillsModal?: boolean;
    displayType?: DisplayTypeEnum | string;
    linkedCredentialsCount?: number;
    linkedCredentialsClassName?: string;
    checkBtnClass?: string;
};
type Attachment = {
    title: string;
    url: string;
    type: 'photo' | 'document' | 'video' | 'link';
};
type BoostAchievementCredential = AchievementCredential & {
    display?: {
        backgroundImage?: string;
        backgroundColor?: string;
    };
    image: string;
    attachments: Attachment[];
};
type MediaMetadata = {
    fileExtension?: string;
    sizeInBytes?: number;
    numberOfPages?: number;
};
type VideoMetadata = {
    title?: string;
    videoLength?: string;
    imageUrl?: string;
};
type KnownDIDRegistryType = {
    source: string;
    results: {
        matchingIssuers: any[];
        uncheckedRegistries: any[];
    } | {};
};

declare const AchievementCard: React$1.FC<AchievementCardProps>;

declare const BoostGenericCard: React$1.FC<BoostGenericCardProps>;

declare const BoostSmallCard: React$1.FC<BoostSmallCardProps>;

type ButtonProps = {
    text?: string;
    onClick: MouseEventHandler<HTMLButtonElement>;
    className?: string;
};
declare const Button: React$1.FC<ButtonProps>;

declare const CertDisplayCardSkillsCount: React$1.FC<{
    skills: {
        category: string;
        skill: string;
        subSkills: string[];
    }[];
    onClick?: () => void;
    className?: string;
    isInSkillsModal?: boolean;
}>;

type CertificateBackFaceProps = {
    isFront?: boolean;
    credential: VC | BoostAchievementCredential;
    categoryType?: LCCategoryEnum;
    verificationItems: VerificationItem[];
    customSkillsComponent?: React$1.ReactNode;
    getFileMetadata?: (url: string) => MediaMetadata;
    getVideoMetadata?: (url: string) => VideoMetadata;
    onMediaAttachmentClick?: (url: string, type: 'photo' | 'document' | 'video' | 'link') => void;
    enableLightbox?: boolean;
    showBackButton?: boolean;
    handleViewFrontFace?: () => void;
    customLinkedCredentialsComponent?: React$1.ReactNode;
};
declare const CertificateBackFace: React$1.FC<CertificateBackFaceProps>;

type CertificateDisplayCardProps = {
    credential: VC | BoostAchievementCredential;
    categoryType?: LCCategoryEnum;
    verificationItems: VerificationItem[];
    issuerOverride?: Profile;
    issueeOverride?: Profile;
    knownDIDRegistry?: KnownDIDRegistryType;
    subjectImageComponent?: React$1.ReactNode;
    issuerImageComponent?: React$1.ReactNode;
    customBodyCardComponent?: React$1.ReactNode;
    hideIssueDate?: boolean;
    customSkillsComponent?: React$1.ReactNode;
    getFileMetadata?: (url: string) => MediaMetadata;
    getVideoMetadata?: (url: string) => VideoMetadata;
    onMediaAttachmentClick?: (url: string, type: 'photo' | 'document' | 'video' | 'link') => void;
    enableLightbox?: boolean;
    handleXClick?: () => void;
    onDotsClick?: () => void;
    isFrontOverride?: boolean;
    setIsFrontOverride?: (value: boolean) => void;
    hideNavButtons?: boolean;
    showBackButton?: boolean;
    showDetailsBtn?: boolean;
    formattedDisplayType?: string;
    customLinkedCredentialsComponent?: React$1.ReactNode;
    customBodyContentSlot?: React$1.ReactNode;
    unknownVerifierTitle?: string;
    hideAwardedTo?: boolean;
    hideFrontFaceDetails?: boolean;
};
declare const CertificateDisplayCard: React$1.FC<CertificateDisplayCardProps>;

type CertificateFrontFaceProps = {
    isFront?: boolean;
    credential: VC | BoostAchievementCredential | any;
    categoryType?: LCCategoryEnum;
    issuerOverride?: Profile;
    issueeOverride?: Profile;
    knownDIDRegistry?: KnownDIDRegistryType;
    subjectImageComponent?: React$1.ReactNode;
    issuerImageComponent?: React$1.ReactNode;
    customBodyCardComponent?: React$1.ReactNode;
    hideIssueDate?: boolean;
    handleViewBackFace?: () => void;
    showDetailsBtn?: boolean;
    formattedDisplayType?: string;
    customBodyContentSlot?: React$1.ReactNode;
    unknownVerifierTitle?: string;
    hideAwardedTo?: boolean;
    hideFrontFaceDetails?: boolean;
};
declare const CertificateFrontFace: React$1.FC<CertificateFrontFaceProps>;

declare const VERIFIER_STATES: {
    readonly selfVerified: "Self Issued";
    readonly trustedVerifier: "Trusted Issuer";
    readonly unknownVerifier: "Unknown Issuer";
    readonly appIssuer: "App Issuer";
    readonly untrustedVerifier: "Untrusted Issuer";
};
type VerifierState = (typeof VERIFIER_STATES)[keyof typeof VERIFIER_STATES];
type VerifierStateBadgeAndTextProps = {
    verifierState: VerifierState;
    className?: string;
    unknownVerifierTitle?: string;
};
declare const VerifierStateBadgeAndText: React$1.FC<VerifierStateBadgeAndTextProps>;

declare const CircleCheckButton: React$1.FC<CircleCheckButtonProps>;

type CircleIconProps = {
    iconSrc?: string;
    count?: string | number;
    onClick?: () => void;
    bgColor?: string;
    innerPadding?: string;
    size?: string;
    borderColor?: string;
    loading?: boolean;
    iconCircleClass?: string;
};
type CountCircleProps = {
    size?: string;
    count?: string | number;
    innerPadding?: string;
    onClick?: () => {};
    bgColor?: string;
    className?: string;
    loading?: boolean;
};
declare const CountCircle: React$1.FC<CountCircleProps>;
declare const CircleIcon: React$1.FC<CircleIconProps>;

declare const CourseCard: React$1.FC<CourseCardProps>;

declare const CourseVerticalCard: React$1.FC<CourseCardVerticalProps>;

type FlippyCardProps = {
    children: React$1.ReactChild[];
    flipState?: 'front' | 'back' | string;
};
declare const FlippyCard: React$1.FC<FlippyCardProps>;

declare const GenericCard: React$1.FC<GenericCardProps>;

declare const JobHistoryCard: React$1.FC<JobHistoryCardProps>;

type JobListingBubbleProps = {
    count: number | string | undefined;
    type: LCSubtypes.course | LCSubtypes.achievement | LCSubtypes.skill;
    className?: string;
};
declare const JobListingBubble: React$1.FC<JobListingBubbleProps>;
declare const JobListCard: React$1.FC<JobListCardProps>;

type LearnCardCreditCardBackFaceProps = {
    /**
     * custom className
     * @type {string}
     */
    className?: string;
    user: LearnCardCreditCardUserProps;
    card: LearnCardCreditCardProps;
};
type LearnCardCreditCardUserProps = {
    /**
     * unique user handle / username
     * @type {string}
     */
    username?: string;
    /**
     * user full name
     * @type {string}
     */
    fullName: string;
};
type LearnCardCreditCardProps = {
    /**
     * card number
     * @type {number}
     */
    cardNumber: string;
    /**
     * card issue date
     * @type {string}
     */
    cardIssueDate?: string;
    /**
     * card expiration date
     * @type {string}
     */
    cardExpirationDate: string;
    /**
     * card security code
     * @type {string}
     */
    cardSecurityCode?: string;
};

declare const LearnCardCreditCardBackFace: React$1.FC<LearnCardCreditCardBackFaceProps>;

type LearnCardCreditCardFrontFaceProps = {
    /**
     * user image
     * @type {string}
     */
    userImage?: string;
    /**
     * custom image component
     * @type {React.ReactNode}
     */
    userImageComponent?: React.ReactNode;
    /**
     * qr code value
     * @type {string}
     */
    qrCodeValue?: string;
    /**
     * custom className
     * @type {string}
     */
    className?: string;
    /**
     * show or hide an action button
     * @type {boolean}
     * @param {boolean=} false - Action button hidden by default.
     */
    showActionButton?: boolean;
    /**
     * action button text
     * @type {boolean}
     * @param {boolean=} "Open Card" - set as default text.
     */
    actionButtonText?: string;
    /**
     *
     * action button click handler
     * @type {function}
     */
    onClick?: () => void;
    children?: React.ReactNode;
};

declare const LearnCardCreditCardFrontFace: React$1.FC<LearnCardCreditCardFrontFaceProps>;

declare const LearnPill: React$1.FC<LearnPillProps>;

type LightboxItemType = 'photo' | 'video';
type LightboxItem = {
    url: string;
    type: LightboxItemType;
};
type LightboxImage = LightboxItem & {
    type: 'photo';
    alt?: string;
};
type LightboxVideo = LightboxItem & {
    type: 'video';
};
type LightboxProps = {
    items: LightboxItem[];
    currentUrl: string | undefined;
    setCurrentUrl: (url: string | undefined) => void;
    showCloseButton?: boolean;
    enableImageClick?: boolean;
};
declare const Lightbox: React$1.FC<LightboxProps>;

declare enum CircleLoadingState {
    spin = 0,
    stop = 1
}
type CircleSpinnerProps = {
    size?: number;
    thickness?: number;
    color?: string;
    loadingState?: CircleLoadingState;
    marginOffset?: number;
};

type MeritBadgeBackFaceProps = {
    isFront?: boolean;
    credential: VC | BoostAchievementCredential;
    categoryType?: LCCategoryEnum;
    verificationItems: VerificationItem[];
    customSkillsComponent?: React$1.ReactNode;
    getFileMetadata?: (url: string) => MediaMetadata;
    getVideoMetadata?: (url: string) => VideoMetadata;
    onMediaAttachmentClick?: (url: string, type: 'photo' | 'document' | 'video' | 'link') => void;
    enableLightbox?: boolean;
    showBackButton?: boolean;
    handleViewFrontFace?: () => void;
    customLinkedCredentialsComponent?: React$1.ReactNode;
};
declare const MeritBadgeBackFace: React$1.FC<MeritBadgeBackFaceProps>;

type MeritBadgeDisplayCardProps = {
    credential: VC | BoostAchievementCredential;
    categoryType?: LCCategoryEnum;
    verificationItems: VerificationItem[];
    issuerOverride?: Profile;
    issueeOverride?: Profile;
    knownDIDRegistry?: KnownDIDRegistryType;
    subjectImageComponent?: React$1.ReactNode;
    issuerImageComponent?: React$1.ReactNode;
    customBodyCardComponent?: React$1.ReactNode;
    hideIssueDate?: boolean;
    customSkillsComponent?: React$1.ReactNode;
    getFileMetadata?: (url: string) => MediaMetadata;
    getVideoMetadata?: (url: string) => VideoMetadata;
    onMediaAttachmentClick?: (url: string, type: 'photo' | 'document' | 'video' | 'link') => void;
    enableLightbox?: boolean;
    handleXClick?: () => void;
    onDotsClick?: () => void;
    isFrontOverride?: boolean;
    setIsFrontOverride?: (value: boolean) => void;
    hideNavButtons?: boolean;
    showBackButton?: boolean;
    showDetailsBtn?: boolean;
    formattedDisplayType?: string;
    customLinkedCredentialsComponent?: React$1.ReactNode;
    customBodyContentSlot?: React$1.ReactNode;
    unknownVerifierTitle?: string;
    hideAwardedTo?: boolean;
    hideFrontFaceDetails?: boolean;
};
declare const MeritBadgeDisplayCard: React$1.FC<MeritBadgeDisplayCardProps>;

type MeritBadgeFrontFaceProps = {
    isFront?: boolean;
    credential: VC | BoostAchievementCredential;
    categoryType?: LCCategoryEnum;
    issuerOverride?: Profile;
    issueeOverride?: Profile;
    knownDIDRegistry?: KnownDIDRegistryType;
    subjectImageComponent?: React$1.ReactNode;
    issuerImageComponent?: React$1.ReactNode;
    customBodyCardComponent?: React$1.ReactNode;
    hideIssueDate?: boolean;
    handleViewBackFace?: () => void;
    showDetailsBtn?: boolean;
    formattedDisplayType?: string;
    customBodyContentSlot?: React$1.ReactNode;
    unknownVerifierTitle?: string;
    hideAwardedTo?: boolean;
    hideFrontFaceDetails?: boolean;
};
declare const MeritBadgeFrontFace: React$1.FC<MeritBadgeFrontFaceProps>;

declare const MeritBadgeSkillsCount: React$1.FC<{
    skills: {
        category: string;
        skill: string;
        subSkills: string[];
    }[];
    onClick?: () => void;
}>;

type MiniVCThumbnailProps = {
    /**
     * thumbnail title
     * @type {string}
     */
    title?: string;
    /**
     * issue date
     * @type {string}
     */
    createdAt?: string;
    /**
     * issuer image
     * @type {string}
     */
    issuerImage?: string;
    /**
     * badge image
     * @type {string}
     */
    badgeImage?: string;
    /**
     * custom className
     * @type {string}
     */
    className?: string;
    /**
     *
     * @type {function}
     */
    onClick?: () => void;
};

declare const MiniVCThumbnail: React$1.FC<MiniVCThumbnailProps>;

declare enum NotificationTypeEnum {
    Currency = "currency",
    ID = "id",
    Achievement = "achievement",
    Skill = "skill",
    Job = "job",
    Learning = "learning",
    SocialBadges = "socialBadge"
}
declare enum UserNotificationTypeEnum {
    ConnectionRequest = "connection",
    AcceptedBoost = "acceptedBoost"
}

type NotificationProps = {
    notificationType: NotificationTypeEnum;
    title: string;
    issuerImage?: string;
    issueDate: string;
    className?: string;
    handleViewOnClick: () => void;
    claimStatus: boolean;
    handleClaimOnClick: () => void;
    loadingState: boolean;
};
declare const NotificationTypeStyles: {
    [key: NotificationTypeEnum | string]: {
        viewButtonStyles: string;
        unclaimedButtonStyles: string;
        claimedButtonStyles: string;
        textStyles: string;
        iconCircleStyles: string;
        IconComponent: any;
        typeText: string;
    };
};

declare const Notification: React$1.FC<NotificationProps>;

interface NotificationIssuerMeta {
    image?: string;
    fullName?: string;
    profileId?: string;
    displayName?: string;
}
type NotificationBoostCardProps = {
    className?: string;
    thumbImage?: string;
    customThumbComponent?: React.ReactNode;
    notificationType: NotificationTypeEnum;
    issuerInfo?: NotificationIssuerMeta;
    issueDate?: string;
    handleButtonClick?: () => void;
    handleCancelClick?: () => void;
    handleCardClick?: () => void;
    claimStatus: boolean;
    loadingState?: boolean;
    showIssuerInfo?: boolean;
    title?: string;
    isArchived?: boolean;
};

declare const NotificationBoostCard: React$1.FC<NotificationBoostCardProps>;

type NotificationUserAcceptedBoostCardProps = {
    className?: string;
    thumbImage?: string;
    customThumbComponent?: React.ReactNode;
    notificationType?: UserNotificationTypeEnum.AcceptedBoost;
    issueDate?: string;
    handleCancelClick?: () => void;
    loadingState?: boolean;
    title?: string;
    isArchived?: boolean;
};

declare const NotificationUserAcceptedBoostCard: React$1.FC<NotificationUserAcceptedBoostCardProps>;

type NotificationUserCardProps = {
    className?: string;
    thumbImage?: string;
    customThumbComponent?: React.ReactNode;
    issueDate?: string;
    handleButtonClick?: () => void;
    handleCancelClick?: () => void;
    handleCardClick?: () => void;
    acceptStatus: boolean;
    loadingState?: boolean;
    title?: string;
    isArchived?: boolean;
};
declare const UserNotificationTypeStyles: {
    [key: UserNotificationTypeEnum | string]: {
        viewButtonStyles: string;
        unclaimedButtonStyles: string;
        claimedButtonStyles: string;
        textStyles: string;
        iconCircleStyles: string;
        typeText?: string;
    };
};

declare const NotificationUserCard: React$1.FC<NotificationUserCardProps>;

type QRCodeCardProps = {
    /**
     * user handle
     * @type {string}
     */
    userHandle?: string;
    /**
     * qr code value
     * @type {string}
     */
    qrCodeValue: string;
    /**
     * text to display on the card
     * @type {React.ReactNode | null}
     */
    text?: string;
    /**
     * custom className
     * @type {string}
     */
    className?: string;
};

declare const QRCodeCard: React$1.FC<QRCodeCardProps>;

type InlineSVGProps = {
    color?: string;
    size?: string | number;
};
declare const CheckmarkSvg: React$1.FC<InlineSVGProps>;
declare const RoundedPill: React$1.FC<RoundedPillProps>;

type RoundedSquareProps = {
    title?: string;
    description?: string;
    type?: WalletCategoryTypes;
    iconSrc?: string;
    imgSrc?: string;
    count?: string | number;
    onClick?: () => void;
    bgColor?: string;
    iconCircleClass?: string;
    loading?: boolean;
    containerClass?: string;
};
declare const RoundedSquare: React$1.FC<RoundedSquareProps>;

declare const TYPE_TO_MINI_ICON: any;
declare const WALLET_SUBTYPES: {
    ACHIEVEMENTS: string;
    IDS: string;
    JOB_HISTORY: string;
    CURRENCIES: string;
    LEARNING_HISTORY: string;
    SKILLS: string;
    SOCIAL_BADGES: string;
    MEMBERSHIP: string;
    ACCOMPLISHMENTS: string;
    ACCOMMODATIONS: string;
    MERIT_BADGES: string;
};
declare const TYPE_TO_IMG_SRC: {
    [x: string]: any;
};
declare const TYPE_TO_WALLET_COLOR: {
    [x: string]: string;
};

type SchoolIDCardProps = {
    /**
     * student image
     * @type {string}
     */
    userImage?: string;
    /**
     * student name
     * @type {string}
     */
    userName: string;
    /**
     * text to display below the student name
     * @type {React.ReactNode | string | undefined}
     */
    text?: React$1.ReactNode | string | undefined;
    /**
     * extra text to display on the ID card
     * @type {React.ReactNode | string | undefined}
     */
    extraText?: string;
    /**
     * fixed ID background
     * @type {string}
     */
    backgroundImage: string;
    /**
     * custom className
     * @type {string}
     */
    className?: string;
    /**
     * custom container className
     * @type {string}
     */
    containerClassName?: string;
    showBarcode?: boolean;
    subjectInitials?: string;
    subjectInitialsClass?: string;
};

declare const SchoolIDCard: React$1.FC<SchoolIDCardProps>;

declare const SkillTabCard: React$1.FC<SkillTabCardProps>;

declare const SkillVerticalCard: React$1.FC<SkillVerticalCardProps>;

type SkillsMeterSegmentProps = {
    filled?: boolean;
    className?: string;
    skillColor?: string;
};
declare const SkillsMeterSegment: React$1.FC<SkillsMeterSegmentProps>;
declare const SkillsCard: React$1.FC<SkillsCardProps>;

declare const SkillsStatsCard: React$1.FC<SkillsStatsCardProps>;

declare const SmallAchievementCard: React$1.FC<SmallAchievementCardProps>;

declare const UserProfilePicture: React$1.FC<{
    customContainerClass?: string;
    customImageClass?: string;
    user?: any;
    alt?: string;
    children?: React$1.ReactNode | null;
}>;

declare enum BoostCMSSKillsCategoryEnum {
    Durable = "durable",
    Stem = "stem",
    Athletic = "athletic",
    Creative = "creative",
    Business = "business",
    Trade = "trade",
    Social = "social",
    Digital = "digital",
    Medical = "medical"
}
declare enum BoostCMSCategorySkillEnum {
    Adaptability = "adaptability",
    Perseverance = "perseverance",
    MentalToughness = "mentalToughness",
    PhysicalEndurance = "physicalEndurance",
    LifelongLearning = "lifelongLearning",
    Mathematics = "mathematics",
    Science = "science",
    Technology = "technology",
    Engineering = "engineering",
    Research = "research",
    SportSpecificSkills = "sportSpecificSkills",
    StrengthAndConditioning = "strengthAndConditioning",
    Coordination = "coordination",
    MentalFocus = "mentalFocus",
    Teamwork = "teamwork",
    VisualArts = "visualArts",
    PerformingArts = "performingArts",
    Writing = "writing",
    Design = "design",
    Ideation = "ideation",
    Management = "management",
    Finance = "finance",
    Marketing = "marketing",
    Operations = "operations",
    Entrepreneurship = "entrepreneurship",
    Construction = "construction",
    Mechanics = "mechanics",
    Manufacturing = "manufacturing",
    Cosmetology = "cosmetology",
    CulinaryArts = "culinaryArts",
    History = "history",
    Psychology = "psychology",
    Sociology = "sociology",
    Economics = "economics",
    PoliticalScience = "politicalScience",
    BasicComputerSkills = "basicComputerSkills",
    InformationLiteracy = "informationLiteracy",
    SoftwareProficiency = "softwareProficiency",
    OnlineCommunication = "onlineCommunication",
    Cybersecurity = "cybersecurity",
    ClinicalSkills = "clinicalSkills",
    AnatomyAndPhysiology = "anatomyAndPhysiology",
    PatientCare = "patientCare",
    MedicalSpecialties = "medicalSpecialties",
    HealthcareAdministration = "healthcareAdministration"
}
declare enum BoostCMSSubSkillEnum {
    flexibility = "flexibility",
    resilience = "resilience",
    problemSolving = "problemSolving",
    resourcefulness = "resourcefulness",
    stressManagement = "stressManagement",
    discipline = "discipline",
    focus = "focus",
    commitment = "commitment",
    grit = "grit",
    tenacity = "tenacity",
    optimism = "optimism",
    selfConfidence = "selfConfidence",
    emotionalRegulation = "emotionalRegulation",
    growthMindset = "growthMindset",
    positiveSelfTalk = "positiveSelfTalk",
    strength = "strength",
    stamina = "stamina",
    cardiovascularFitness = "cardiovascularFitness",
    painTolerance = "painTolerance",
    injuryPrevention = "injuryPrevention",
    curiosity = "curiosity",
    openMindedness = "openMindedness",
    criticalThinking = "critical thinking",
    selfDirectedLearning = "selfDirectedLearning",
    knowledgeRetention = "knowledgeRetention",
    algebra = "algebra",
    geometry = "geometry",
    trigonometry = "trigonometry",
    calculus = "calculus",
    statistics = "statistics",
    physics = "physics",
    chemistry = "chemistry",
    biology = "biology",
    earthScience = "earthScience",
    environmentalScience = "environmentalScience",
    coding = "coding",
    softwareDevelopment = "softwareDevelopment",
    dataAnalysis = "dataAnalysis",
    robotics = "robotics",
    cybersecurity = "cybersecurity",
    mechanicalEngineering = "mechanicalEngineering",
    electricalEngineering = "electricalEngineering",
    civilEngineering = "civilEngineering",
    chemicalEngineering = "chemicalEngineering",
    computerEngineering = "computerEngineering",
    hypothesisDevelopment = "hypothesisDevelopment",
    experimentalDesign = "experimentalDesign",
    dataCollection = "dataCollection",
    analysis = "analysis",
    presentation = "presentation",
    ballHandling = "ballHandling",
    runningTechnique = "runningTechnique",
    swingMechanics = "swingMechanics",
    tackling = "tackling",
    swimmingStrokes = "swimmingStrokes",
    weightLifting = "weightLifting",
    speedTraining = "speedTraining",
    agility = "agility",
    lexibility = "flexibility",
    handEyeCoordination = "handEyeCoordination",
    footwork = "footwork",
    balance = "balance",
    reactionTime = "reactionTime",
    spatialAwareness = "spatialAwareness",
    visualization = "visualization",
    goalSetting = "goalSetting",
    competitiveness = "competitiveness",
    handlingPressure = "handlingPressure",
    communication = "communication",
    cooperation = "cooperation",
    roleUnderstanding = "roleUnderstanding",
    strategy = "strategy",
    sportsmanship = "sportsmanship",
    drawing = "drawing",
    painting = "painting",
    sculpture = "sculpture",
    graphicDesign = "graphicDesign",
    photography = "photography",
    acting = "acting",
    dance = "dance",
    singing = "singing",
    instrumental = "instrumental",
    theaterProduction = "theaterProduction",
    costumeDesign = "costumeDesign",
    directing = "directing",
    poetry = "poetry",
    fiction = "fiction",
    nonfiction = "nonfiction",
    scriptWriting = "scriptWriting",
    copyWriting = "copyWriting",
    journalism = "journalism",
    fashionDesign = "fashionDesign",
    interiorDesign = "interiorDesign",
    webDesign = "webDesign",
    productDesign = "productDesign",
    gameDesign = "gameDesign",
    brainstorming = "brainstorming",
    conceptDevelopment = "concept development",
    innovation = "innovation",
    outOfTheBoxThinking = "outOfTheBoxThinking",
    leadership = "leadership",
    strategicPlanning = "strategicPlanning",
    teamBuilding = "teamBuilding",
    delegation = "delegation",
    conflictResolution = "conflictResolution",
    accounting = "accounting",
    budgeting = "budgeting",
    financialAnalysis = "financialAnalysis",
    investment = "investment",
    riskManagement = "riskManagement",
    marketResearch = "marketResearch",
    branding = "branding",
    advertising = "advertising",
    sales = "sales",
    customerRelationshipManagement = "customerRelationshipManagement",
    logistics = "logistics",
    supplyChainManagement = "supplyChainManagement",
    processImprovement = "processImprovement",
    projectManagement = "projectManagement",
    qualityControl = "qualityControl",
    opportunityRecognition = "opportunityRecognition",
    businessPlanning = "businessPlanning",
    fundraising = "fundraising",
    networking = "networking",
    decisionMaking = "decisionMaking",
    carpentry = "carpentry",
    electricalWork = "electricalWork",
    plumbing = "plumbing",
    masonry = "masonry",
    HVAC = "HVAC",
    automotiveRepair = "automotiveRepair",
    dieselEngineRepair = "dieselEngineRepair",
    smallEngineRepair = "smallEngineRepair",
    aircraftMaintenance = "aircraftMaintenance",
    heavyEquipmentOperation = "heavyEquipmentOperation",
    welding = "welding",
    machining = "machining",
    assembly = "assembly",
    fabrication = "fabrication",
    qualityAssurance = "qualityAssurance",
    hairstyling = "hairstyling",
    barbering = "barbering",
    nailTechnology = "nailTechnology",
    makeupArtistry = "makeupArtistry",
    esthetics = "esthetics",
    cookingTechniques = "cookingTechniques",
    baking = "baking",
    foodSafety = "foodSafety",
    menuPlanning = "menuPlanning",
    restaurantManagement = "restaurantManagement",
    researchMethods = "researchMethods",
    analysisOfPrimarySources = "analysisOfPrimarySources",
    chronologicalReasoning = "chronologicalReasoning",
    comparativeHistory = "comparativeHistory",
    historiography = "historiography",
    cognitivePsychology = "cognitivePsychology",
    developmentalPsychology = "developmentalPsychology",
    socialPsychology = "socialPsychology",
    experimentalMethods = "experimentalMethods",
    clinicalPsychology = "clinicalPsychology",
    socialInequality = "socialInequality",
    socialInstitutions = "socialInstitutions",
    socialChange = "socialChange",
    socialMovements = "socialMovements",
    microeconomics = "microeconomics",
    macroeconomics = "macroeconomics",
    econometrics = "econometrics",
    economicPolicy = "economicPolicy",
    internationalEconomics = "internationalEconomics",
    governmentSystems = "governmentSystems",
    politicalTheory = "politicalTheory",
    internationalRelations = "internationalRelations",
    comparativePolitics = "comparativePolitics",
    publicPolicy = "publicPolicy",
    typing = "typing",
    fileManagement = "fileManagement",
    internetNavigation = "internetNavigation",
    email = "email",
    wordProcessing = "wordProcessing",
    searchEngineProficiency = "searchEngineProficiency",
    evaluatingSources = "evaluatingSources",
    factChecking = "factChecking",
    criticalMediaAnalysis = "criticalMediaAnalysis",
    understandingBias = "understandingBias",
    productivitySuites = "productivitySuites",
    specializedSoftware = "specializedSoftware",
    designSoftware = "designSoftware",
    programmingBasics = "programmingBasics",
    dataVisualizationTools = "dataVisualizationTools",
    netiquette = "netiquette",
    effectiveEmailAndMessaging = "effectiveEmailAndMessaging",
    socialMediaPlatforms = "socialMediaPlatforms",
    videoConferencing = "videoConferencing",
    collaborationTools = "collaborationTools",
    passwordManagement = "passwordManagement",
    phishingAwareness = "phishingAwareness",
    dataPrivacy = "dataPrivacy",
    safeOnlinePractices = "safeOnlinePractices",
    protectingDevices = "protectingDevices",
    patientAssessment = "patientAssessment",
    diagnosticProcedures = "diagnosticProcedures",
    medicationAdministration = "medicationAdministration",
    woundCare = "woundCare",
    basicLifeSupport = "basicLifeSupport",
    bodySystems = "bodySystems",
    medicalTerminology = "medicalTerminology",
    diseaseProcesses = "diseaseProcesses",
    pharmacology = "pharmacology",
    pathophysiology = "pathophysiology",
    bedsideManner = "bedsideManner",
    empathy = "empathy",
    culturalSensitivity = "culturalSensitivity",
    ethics = "ethics",
    surgery = "surgery",
    emergencyMedicine = "emergencyMedicine",
    pediatrics = "pediatrics",
    radiology = "radiology",
    diagnosticReasoning = "diagnosticReasoning",
    treatmentPlanning = "treatmentPlanning",
    interdisciplinaryCollaboration = "interdisciplinaryCollaboration",
    insuranceAndBilling = "insuranceAndBilling",
    medicalRecords = "medicalRecords",
    patientScheduling = "patientScheduling",
    regulatoryCompliance = "regulatoryCompliance",
    facilityManagement = "facilityManagement"
}

declare const SelectedSkills: React$1.FC<{
    skill: {
        id: number;
        title: string;
        IconComponent: React$1.ReactNode | string;
        iconClassName: string;
        iconCircleClass: string;
        category: BoostCMSSKillsCategoryEnum | string;
        type: BoostCMSCategorySkillEnum | string;
    };
    skillSelected: {
        category: BoostCMSSKillsCategoryEnum | string;
        skill: BoostCMSCategorySkillEnum | string;
        subskills: BoostCMSSubSkillEnum[] | string[];
    };
}>;

type CredentialIconType = {
    image?: React$1.ReactNode;
    color?: string;
};
type VCDisplayCard2Props = {
    categoryType?: LCCategoryEnum;
    credential: VC | BoostAchievementCredential;
    verificationItems: VerificationItem[];
    issueeOverride?: Profile;
    issuerOverride?: Profile;
    subjectDID?: string;
    subjectImageComponent?: React$1.ReactNode;
    issuerImageComponent?: React$1.ReactNode;
    verificationInProgress?: boolean;
    handleXClick?: () => void;
    getFileMetadata?: (url: string) => MediaMetadata;
    getVideoMetadata?: (url: string) => VideoMetadata;
    onMediaAttachmentClick?: (url: string, type: 'photo' | 'document' | 'video' | 'link') => void;
    bottomRightIcon?: CredentialIconType;
    customFooterComponent?: React$1.ReactNode;
    customBodyCardComponent?: React$1.ReactNode;
    customThumbComponent?: React$1.ReactNode;
    customDescription?: React$1.ReactNode;
    customCriteria?: React$1.ReactNode;
    customIssueHistoryComponent?: React$1.ReactNode;
    issueHistory?: IssueHistory[];
    titleOverride?: string;
    showBackButton?: boolean;
    enableLightbox?: boolean;
    customRibbonCategoryComponent?: React$1.ReactNode;
    customFrontButton?: React$1.ReactNode;
    knownDIDRegistry?: KnownDIDRegistryType;
    hideIssueDate?: boolean;
    onDotsClick?: () => void;
    customSkillsComponent?: React$1.ReactNode;
    isFrontOverride?: boolean;
    setIsFrontOverride?: (value: boolean) => void;
    hideNavButtons?: boolean;
    hideQRCode?: boolean;
    qrCodeOnClick?: () => void;
    showDetailsBtn?: boolean;
    customIDDescription?: React$1.ReactNode;
    hideGradientBackground?: boolean;
    formattedDisplayType?: string;
    customLinkedCredentialsComponent?: React$1.ReactNode;
    customContentSlot?: React$1.ReactNode;
    customBodyContentSlot?: React$1.ReactNode;
    unknownVerifierTitle?: string;
    hideAwardedTo?: boolean;
    hideFrontFaceDetails?: boolean;
};
declare const VCDisplayCard2: React$1.FC<VCDisplayCard2Props>;

declare const VCDisplayCardSkillsCount: React$1.FC<{
    skills: {
        category: string;
        skill: string;
        subSkills: string[];
    }[];
    onClick?: () => void;
}>;

type VCIDDisplayCardProps = {
    credential: VC | BoostAchievementCredential;
    verificationItems: VerificationItem[];
    getFileMetadata?: (url: string) => MediaMetadata;
    getVideoMetadata?: (url: string) => VideoMetadata;
    onMediaAttachmentClick?: (url: string, type: 'photo' | 'document' | 'video' | 'link') => void;
    customThumbComponent?: React$1.ReactNode;
    customDescription?: React$1.ReactNode;
    customCriteria?: React$1.ReactNode;
    customIssueHistoryComponent?: React$1.ReactNode;
    issueHistory?: IssueHistory[];
    showBackButton?: boolean;
    enableLightbox?: boolean;
    knownDIDRegistry?: KnownDIDRegistryType;
    customSkillsComponent?: React$1.ReactNode;
    isFrontOverride?: boolean;
    setIsFrontOverride?: (value: boolean) => void;
    hideNavButtons?: boolean;
    hideQRCode?: boolean;
    qrCodeOnClick?: () => void;
    showDetailsBtn?: boolean;
    customIDDescription?: React$1.ReactNode;
    hideGradientBackground?: boolean;
    customLinkedCredentialsComponent?: React$1.ReactNode;
    unknownVerifierTitle?: string;
};
declare const VCIDDisplayCard: React$1.FC<VCIDDisplayCardProps>;

type VCCardProps = {
    credential: VC;
    issueeOverride?: Profile;
    className?: string;
    version?: '1' | '2';
    subjectImageComponent?: React$1.ReactNode;
    handleXClick?: () => void;
    getFileMetadata?: (url: string) => MediaMetadata;
    getVideoMetadata?: (url: string) => VideoMetadata;
    onMediaAttachmentClick?: (url: string) => void;
    bottomRightIcon?: CredentialIconType;
};
declare const VCCard: React$1.FC<VCCardProps>;

declare const VCDisplayBackFace: React$1.FC<VCDisplayCardProps>;

type VCDisplayCardPropsReal = {
    credential: VC | AchievementCredential;
    issueeOverride?: Profile;
    issuerOverride?: Profile;
    className?: string;
    hideProfileBubbles?: boolean;
    loading?: boolean;
    verification?: VerificationItem[];
    subjectImageComponent?: React$1.ReactNode;
    issuerImageComponent?: React$1.ReactNode;
    overrideDetailsComponent?: React$1.ReactNode;
    overrideCardTitle?: string;
    overrideCardImageComponent?: React$1.ReactNode;
    customHeaderComponent?: React$1.ReactNode;
};
declare const VCDisplayCard: React$1.FC<VCDisplayCardPropsReal>;

type VCThumbnailProps = {
    /**
     * thumbnail title
     * @type {string}
     */
    title?: string;
    /**
     * issue date
     * @type {string}
     */
    createdAt?: string;
    /**
     * issuer image
     * @type {string}
     */
    issuerImage?: string;
    /**
     * user image
     * @type {string}
     */
    userImage?: string;
    userImageComponent?: React$1.ReactNode;
    /**
     * badge image
     * @type {string}
     */
    badgeImage?: string;
    /**
     * custom className
     * @type {string}
     */
    className?: string;
    /**
     * condensed or full view of the thumbnail
     * @type {boolean}
     * @param {boolean=} false - shows full view by default.
     */
    listView?: boolean;
    /**
     *
     * @type {function}
     */
    onClick?: () => void;
};

declare const VCThumbnail: React$1.FC<VCThumbnailProps>;

type VCVerificationCheckProps = {
    size?: string | number;
    loading?: boolean;
};
declare const VCVerificationCheck: React$1.FC<VCVerificationCheckProps>;

declare const VCVerificationCheckWithSpinner: React$1.FC<VCVerificationCheckProps & {
    spinnerSize?: string;
    withBorder?: boolean;
}>;
declare const VCVerificationCheckWithText: React$1.FC<VCVerificationCheckProps & {
    spinnerSize?: string;
}>;

type VerifiableStateIndicatorProps = {
    status: VerificationStatus;
};
declare const ValidationStateIndicator: React$1.FC<VerifiableStateIndicatorProps>;

declare const AwardDisplayIcon: React$1.FC<{
    className?: string;
}>;

declare const AwardRibbon: React$1.FC<{
    className?: string;
}>;

declare const BadgeDisplayIcon: React$1.FC<{
    className?: string;
}>;

declare const Briefcase: React$1.FC<{
    className?: string;
    size?: string;
}>;

declare const CertificateDisplayIcon: React$1.FC<{
    className?: string;
}>;

declare const Checkmark: React$1.FC<{
    className?: string;
}>;

declare const Coins: React$1.FC<{
    className?: string;
}>;

declare const CourseDisplayIcon: React$1.FC<{
    className?: string;
}>;

declare const GenericArrow: React$1.FC<{
    className?: string;
    color?: string;
    width?: string;
    height?: string;
}>;

declare const Graduation: React$1.FC<{
    className?: string;
    size?: string;
}>;

declare const IDDisplayIcon: React$1.FC<{
    className?: string;
}>;

declare const IDIcon: React$1.FC<{
    className?: string;
}>;

declare const IDSleeve: React$1.FC<{
    className?: string;
}>;

declare const Lightbulb: React$1.FC<{
    className?: string;
}>;

declare const QRCodeIcon: React$1.FC<{
    className?: string;
}>;

declare const ThreeDotVertical: ({ className }: {
    className?: string;
}) => React$1.JSX.Element;

declare const Trophy: React$1.FC<{
    className?: string;
    color?: string;
    size?: string;
}>;

declare const User: React$1.FC<{
    className?: string;
    size?: string;
}>;

declare const useOnMomentumScrollEnd: ({ onScroll: _onScroll, onMomentumScrollEnd, debounceTime, }: {
    onScroll?: React$1.UIEventHandler;
    onMomentumScrollEnd: React$1.UIEventHandler;
    debounceTime?: number;
}) => React$1.UIEventHandler<Element>;

declare const useScrollBorders: <Ref extends HTMLElement>({ ref, topShowClassName, topHideClassName, bottomShowClassName, bottomHideClassName, }?: {
    ref?: RefObject<Ref>;
    topShowClassName?: string;
    topHideClassName?: string;
    bottomShowClassName?: string;
    bottomHideClassName?: string;
}) => React$1.RefObject<Ref>;

export { AchievementCard, AwardDisplayIcon, AwardRibbon, BadgeDisplayIcon, BoostGenericCard, BoostSmallCard, Briefcase, Button, ButtonProps, CertDisplayCardSkillsCount, CertificateBackFace, CertificateDisplayCard, CertificateDisplayIcon, CertificateFrontFace, Checkmark, CheckmarkSvg, CircleCheckButton, CircleIcon, CircleIconProps, CircleLoadingState, CircleSpinnerProps, Coins, CountCircle, CountCircleProps, CourseCard, CourseDisplayIcon, CourseVerticalCard, CredentialIconType, FlippyCard, FlippyCardProps, GenericArrow, GenericCard, Graduation, IDDisplayIcon, IDIcon, IDSleeve, JobHistoryCard, JobListCard, JobListingBubble, LearnCardCreditCardBackFace, LearnCardCreditCardBackFaceProps, LearnCardCreditCardFrontFace, LearnCardCreditCardFrontFaceProps, LearnCardCreditCardProps, LearnCardCreditCardUserProps, LearnPill, Lightbox, LightboxImage, LightboxItem, LightboxItemType, LightboxProps, LightboxVideo, Lightbulb, MeritBadgeBackFace, MeritBadgeDisplayCard, MeritBadgeFrontFace, MeritBadgeSkillsCount, MiniVCThumbnail, MiniVCThumbnailProps, Notification, NotificationBoostCard, NotificationBoostCardProps, NotificationIssuerMeta, NotificationProps, NotificationTypeStyles, NotificationUserAcceptedBoostCard, NotificationUserAcceptedBoostCardProps, NotificationUserCard, NotificationUserCardProps, QRCodeCard, QRCodeCardProps, QRCodeIcon, RoundedPill, RoundedSquare, RoundedSquareProps, SchoolIDCard, SchoolIDCardProps, SelectedSkills, SkillTabCard, SkillVerticalCard, SkillsCard, SkillsMeterSegment, SkillsStatsCard, SmallAchievementCard, TYPE_TO_IMG_SRC, TYPE_TO_MINI_ICON, TYPE_TO_WALLET_COLOR, ThreeDotVertical, Trophy, User, UserNotificationTypeStyles, UserProfilePicture, VCCard, VCCardProps, VCDisplayBackFace, VCDisplayCard, VCDisplayCard2, VCDisplayCard2Props, VCDisplayCardPropsReal, VCDisplayCardSkillsCount, VCIDDisplayCard, VCIDDisplayCardProps, VCThumbnail, VCThumbnailProps, VCVerificationCheck, VCVerificationCheckProps, VCVerificationCheckWithSpinner, VCVerificationCheckWithText, VERIFIER_STATES, ValidationStateIndicator, VerifierState, VerifierStateBadgeAndText, VerifierStateBadgeAndTextProps, WALLET_SUBTYPES, useOnMomentumScrollEnd, useScrollBorders };
