import * as i0 from '@angular/core';
import { InjectionToken, OnInit, ElementRef, EventEmitter, TemplateRef, OnDestroy, AfterViewInit, Injector, OnChanges, ChangeDetectorRef, SimpleChanges, ViewContainerRef, ComponentFactoryResolver, Renderer2, ModuleWithProviders, PipeTransform, NgZone } from '@angular/core';
import * as _angular_forms from '@angular/forms';
import { FormGroup, FormBuilder, FormControl, FormArray, UntypedFormGroup, UntypedFormBuilder, ControlValueAccessor, NgForm, AbstractControl } from '@angular/forms';
import * as i17 from '@angular/router';
import { Router, RouterOutlet } from '@angular/router';
import { Observable, Subscription } from 'rxjs';
import { BsModalRef, BsModalService } from 'ngx-bootstrap/modal';
import { TokenService, RoleContextService, AuthLogoutService, RoleContextModel } from '@rangs/auth0-lib';
import { AuthService } from '@auth0/auth0-angular';
import { HttpClient } from '@angular/common/http';
import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
import * as i2 from '@angular/common';
import { ViewportScroller } from '@angular/common';
import * as i19 from '@ng-select/ng-select';
import * as i20 from 'ngx-bootstrap/datepicker';
import * as i25 from 'ngx-bootstrap/tooltip';
import * as i26 from 'ngx-bootstrap/tabs';
import * as i27 from 'ngx-bootstrap/accordion';
import * as i29 from '@angular/google-maps';

interface MasterModel {
}

interface ProviderAccoladeModel extends MasterModel {
    providerId?: string;
    accoladeId?: string;
}

interface ProviderAffiliationModel extends MasterModel {
    providerId?: string;
    affiliationId?: string;
}

interface LookupItem extends LookupItem1<string> {
}
interface LookupItem1<TValue> {
    value: any;
    text: string;
    selected: boolean;
    title?: string;
    providerId?: string;
}

declare enum SocialMediaType {
    Facebook = 1,
    Twitter = 2,
    Instagram = 3,
    LinkedIn = 4,
    Pinterest = 5,
    GooglePlus = 6,
    WhatsApp = 7,
    Telegram = 8,
    Youtube = 9,
    Yelp = 10,
    Others = 11
}

interface ProviderSocialLinkModel extends MasterModel {
    providerId?: string;
    socialMediaType?: SocialMediaType;
    link?: string;
}

declare enum ProviderStatus {
    Active = 1,
    Inactive = 2,
    Pending = 3,
    Reject = 4
}

declare enum ProviderType {
    ServiceProvider = 1,
    InsuranceAgency = 2,
    RealEstateAgency = 3,
    Carrier = 4,
    Contractor = 5,
    Bank = 5
}

interface ProviderModel extends MasterModel {
    providerType?: ProviderType;
    providerName?: string;
    providerBio?: string;
    yearsInBusiness?: string;
    address1?: string;
    address2?: string;
    xactnetAddress?: string;
    city?: string;
    state?: string;
    zipcode?: string;
    county?: string;
    subDivision?: string;
    country?: string;
    latitude?: number | null;
    longitude?: number | null;
    mobileNumberCode?: string;
    phone?: string;
    phoneNumberCode?: string;
    mobile?: string;
    fax?: string;
    emailId?: string;
    website?: string;
    registrationDate?: Date;
    isPublic?: boolean;
    logoId?: string;
    status?: ProviderStatus;
    comments?: string;
    skipLicense?: boolean;
    skipCertificate?: boolean;
    skipInsurance?: boolean;
    skipOtherCredential?: boolean;
    isNationWideCoverage?: boolean;
    skipProfileCompletionPopup?: boolean;
    providerSocialLinks?: ProviderSocialLinkModel[];
    providerAffiliations?: ProviderAffiliationModel[];
    providerAccolades?: ProviderAccoladeModel[];
    annualRevenue?: number;
    contactPerson?: string;
    headshotId?: string;
}

interface ReadModel extends ReadModel1<string> {
}
interface ReadModel1<TKey> {
    id?: TKey;
}

interface CustomReadModel extends ReadModel {
    createdByUserId?: string;
    createdDateTime?: Date;
    createdDateTimeDisplay?: string;
    createdByBrowserName?: string;
    createdByIP?: string;
    modifiedByUserId?: string;
    modifiedDateTime?: Date;
    modifiedDateTimeDisplay?: string;
    modifiedByBrowserName?: string;
    modifiedByIP?: string;
}

interface ContractorSubCategoryReadModel extends CustomReadModel {
    contractorCategoryId?: string;
    contractorCategory?: string;
    name?: any;
    id?: any;
    description?: string;
    isActive?: boolean;
}

interface PrivacyAndTerms {
    companyName?: string | null;
    modifiedDate?: string | null;
    phone?: string | null;
    registeredin?: string | null;
    contactEmail?: string | null;
    privacyEmail?: string | null;
    requestForm?: string | null;
    privacyPolicyLink?: string | null;
    termsOfSaleLink?: string | null;
    copyrightPolicyLink?: string | null;
    companyTrademarks?: string | null;
    privacyPolicyUrl?: string | null;
    address1?: string | null;
    state?: string | null;
    city?: string | null;
    zipCode?: string | null;
    country?: string | null;
    email?: string | null;
    websiteurl?: string | null;
    currentYear?: any | null;
}

interface GridResult<TReadModel> {
    data: TReadModel[];
    count: number;
}

interface GridifyQuery {
    page?: number;
    pageSize?: number;
    orderBy?: string;
    filter?: any;
    targetUserId?: string;
    targetProviderId?: string;
}

interface ValidationFailure {
    memberName: string;
    message: string;
}
interface Result {
    failed: boolean;
    message: string;
    failures: ValidationFailure[];
}
interface Result1<T> extends Result {
    value: T;
}

interface UserDetailReadModel extends MasterModel {
    userId: string;
    fullName: string;
    firstName: string;
    lastName: string;
    isDefault: boolean;
    isActive: boolean;
    email: string;
    phoneNumber: string;
    employeeType?: any;
    yearsOfExperince?: any;
    userJobTitle?: any;
    userIndustryNames?: any;
    id?: any;
    officeNumber: string;
    userBio: string;
    address1: string;
    address2: string;
    city: string;
    state: string;
    zipcode: string;
    county: string;
    subDivision: string;
    country: string;
    latitude: number | null;
    longitude: number | null;
    dateOfBirth: string | null;
    website: string;
    isHire: boolean;
    yearsActive?: number | null;
    headshotFileId?: string | null;
    initialFileId?: string | null;
    initialUrl?: string | null;
    headshotUrl?: string | null;
    signatureFileId?: string | null;
    signatureUrl?: string | null;
    isInitialSetupCompleted?: boolean;
}

interface UserAccountReadModel extends UserDetailReadModel {
    providerId: string | null;
    providerName: string;
    roleId: string | null;
    roleName: string;
    emailConfirmed: boolean;
    phoneNumberConfirmed: boolean;
}

interface UserUpdateModel {
    updateModel: {
        id?: string;
        firstName?: string;
        lastName?: string;
        email?: string;
        phoneNumber: string;
        officeNumber: string;
    };
    userDetailModel: {
        id?: string;
        userId?: string;
        userBio?: string;
        address1?: string;
        address2?: string;
        city?: string;
        state?: string;
        zipcode?: string;
        county?: string;
        subDivision?: string;
        country?: string;
        latitude: number;
        longitude: number;
        dateOfBirth?: string;
        website?: string;
        isHire?: boolean;
        headshotFileId?: string;
        headshotUrl?: string;
        initialFileId?: string;
        initialUrl?: string;
        signatureFileId?: string;
        signatureUrl?: string;
        isInitialSetupCompleted?: boolean;
    };
}

interface TermsandConditionModel {
    versionName: string;
    content: string;
    orderby: number;
    createdDate: string;
    createdBy: string;
    type: number;
    id: string;
}

declare class UserDetailService {
    private http;
    private readonly baseUrl;
    isInitialSetupCompleted(): Observable<boolean>;
    updateMyProfile(model: UserUpdateModel): Observable<Result>;
    AddUserIndustry(payload: any[]): Observable<Result>;
    reSendVerificationEmail(): Observable<Result>;
    initialSetUpCreateUserDetail(model: any): Observable<Result>;
    updateMyProfileData(model: any): Observable<Result>;
    getUserAccounts(query: any): Observable<GridResult<UserAccountReadModel>>;
    resetPassword(model: any): Observable<Result>;
    private buildParams;
    getByUserId(userId: string, query?: any): Observable<UserAccountReadModel>;
    getTermsAndConditions(query: {
        type: number;
    }): Observable<TermsandConditionModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserDetailService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserDetailService>;
}

interface FileModel extends MasterModel {
    fileName?: string;
    filePath?: string;
    fileSize?: number;
    fileType?: string;
    publicUrl?: string;
}
interface AwsFileRequestModel extends MasterModel {
    fileName: string;
    fileLocation: any;
    fileSize: number;
    fileType: string;
    publicUrl: any;
    encrypted: boolean;
    deleteFileId?: string;
}
interface AwsFileResponseModel {
    id: string;
    publicUrl: string;
    fileId: string;
    fileUrl?: string;
    fileName?: string;
}
interface UpdateAwsFileModelModel {
    fileId: string;
    isActive: boolean;
}

declare enum FileSource {
    UserHeadshot = 1001,
    UserSignature = 1002,
    UserInitial = 1003,
    ProducerHeadshot = 1004,
    ProviderLogo = 2001,
    ProviderProfilePhoto = 2002,
    UserLicense = 3001,
    UserCertificate = 3002,
    UserExperience = 3003,
    UserInsurance = 3004,
    UserEducation = 3005,
    UserOtherCredential = 3006,
    UserRequestedCredentials = 3007,
    ProducerProfilePhoto = 3008,
    ProgramLogo = 4002,
    EventLogo = 4003,
    ProviderLicense = 5001,
    ProviderCertificate = 5002,
    ProviderInsurance = 5003,
    ProviderOtherCredential = 5004,
    MessageAttachment = 6001,
    DocumentBuilder = 7001,
    ServiceTemplateFile = 7002,
    ProducerInvitationExcelImport = 8001,
    ProgramInvitationExcelImport = 8002,
    AssignmentExcelImport = 8003,
    UserExcelImport = 8004,
    ServiceCategoryImage = 10000,
    ServiceTypeImage = 10001,
    IndustryLogo = 10003,
    ServiceTypeAgreement = 10004,
    ServiceTypeAgreementVideo = 10005,
    ServiceTypeAgreementImage = 10006,
    ServiceTypeAgreementAttachment = 10007,
    ClientContactLogAttachment = 11000,
    OrderAudit = 11001,
    OrderReportPdf = 11002,
    AgencyLogo = 12000,
    CourseVideo = 13000,
    CourseImage = 13001,
    ProjectAsset = 14000,
    Proposal = 15000,
    ProposalContactLogAttachment = 15001,
    RecruitmentApplication = 16000,
    RecruitmentApplicationContactLogAttachment = 16001,
    HomeInspection = 17000,
    Accolade = 18000,
    Affiliation = 18001,
    ProgramApplication = 4004,
    ProgramApplicationContactLogAttachment = 4005,
    OrderSubmit = 11004,
    OrderReimbursement = 11005,
    Icon = 18002
}

interface FileUploadResultModel {
    id?: string;
    url?: string;
    imageUrl?: string;
    noOfPages?: number;
}

declare class FileService {
    private httpClient;
    private readonly apiUrl?;
    private baseUrl;
    constructor(httpClient: HttpClient, apiUrl?: string | undefined);
    uploadFile(file: File, deleteAndInsert?: boolean, fileId?: string, encrypted?: string): Observable<FileModel>;
    DeleteFiles(deletedFiles: string): Observable<Boolean>;
    uploadFileTemplate(sourceId: FileSource, deleteAndInsert: boolean, file: File, fileId?: string): Observable<Result1<FileUploadResultModel>>;
    deleteFiles(deletedFiles: string): Observable<boolean>;
    download(id: string): Observable<{
        file: Blob;
        filename: string;
    }>;
    awsFileUpload(fileData: AwsFileRequestModel[]): Observable<AwsFileResponseModel[]>;
    updateAwsFileUpload(fileData: UpdateAwsFileModelModel[]): Observable<Result1<string>>;
    uploadImageAsync(file: File, data: {
        key: string;
        contentType: string;
        Expires: number;
    }): Promise<{
        success: boolean;
        message: string;
        publicUrl: string | null;
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileService, [null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FileService>;
}

interface UserDetailModel extends MasterModel {
    userId?: string;
    userBio?: string;
    address1?: any;
    address2?: any;
    city?: any;
    state?: any;
    yearsOfExperince?: any;
    industries?: any;
    userJobTitle?: any;
    zipcode?: any;
    county?: any;
    subDivision?: string;
    country?: any;
    latitude?: number;
    longitude?: number;
    website?: string;
    xactnetAddress?: string;
    dateOfBirth?: Date;
    isInitialSetupCompleted?: boolean;
    id?: any;
    isInitialSetupSkip?: boolean;
    isBusiness?: boolean;
    isBusinessCreated?: boolean;
    acceptingAssignments?: boolean;
    yearsActive?: number;
    isHire?: boolean;
    isPublic?: boolean;
    headshotFileId?: string;
    initialFileId?: string;
    signatureFileId?: string;
    designationStatus?: Object;
    skipWorkHistory?: boolean;
    skipEducationHistory?: boolean;
    skipLicense?: boolean;
    skipCertificate?: boolean;
    skipInsurance?: boolean;
    skipOtherCredential?: boolean;
    skipProfileCompletionPopup?: boolean;
    displayView?: string;
    assignmentDisplayView?: string;
    firstName?: any;
    lastName?: any;
    email: any;
    headshotUrl?: string;
    signatureUrl?: string;
    middleName?: any;
    businessName?: any;
    phoneNumber?: any;
    timeZone?: string;
    datePattern?: string;
    dateTimePattern?: string;
    timePattern?: string;
}

interface IBasicPoint {
    x: number;
    y: number;
    time: number;
}

declare global {
    interface Window {
        PointerEvent: typeof PointerEvent;
    }
}
interface IOptions {
    dotSize?: number | (() => number);
    minWidth?: number;
    maxWidth?: number;
    minDistance?: number;
    backgroundColor?: string;
    penColor?: string;
    throttle?: number;
    velocityFilterWeight?: number;
    onBegin?: (event: MouseEvent | Touch) => void;
    onEnd?: (event: MouseEvent | Touch) => void;
}
interface IPointGroup {
    color: string;
    points: IBasicPoint[];
}
declare class SignaturePad {
    private canvas;
    private options;
    dotSize: number | (() => number);
    minWidth: number;
    maxWidth: number;
    minDistance: number;
    backgroundColor: string;
    penColor: string;
    throttle: number;
    velocityFilterWeight: number;
    onBegin?: (event: MouseEvent | Touch) => void;
    onEnd?: (event: MouseEvent | Touch) => void;
    private _ctx;
    private _mouseButtonDown;
    private _isEmpty;
    private _lastPoints;
    private _data;
    private _lastVelocity;
    private _lastWidth;
    private _strokeMoveUpdate;
    constructor(canvas: HTMLCanvasElement, options?: IOptions);
    clear(): void;
    fromDataURL(dataUrl: string, options?: {
        ratio?: number;
        width?: number;
        height?: number;
    }, callback?: (error?: ErrorEvent) => void): void;
    toDataURL(type?: string, encoderOptions?: number): string;
    on(): void;
    off(): void;
    isEmpty(): boolean;
    fromData(pointGroups: IPointGroup[]): void;
    toData(): IPointGroup[];
    private _handleMouseDown;
    private _handleMouseMove;
    private _handleMouseUp;
    private _handleTouchStart;
    private _handleTouchMove;
    private _handleTouchEnd;
    private _strokeBegin;
    private _strokeUpdate;
    private _strokeEnd;
    private _handlePointerEvents;
    private _handleMouseEvents;
    private _handleTouchEvents;
    private _reset;
    private _createPoint;
    private _addPoint;
    private _calculateCurveWidths;
    private _strokeWidth;
    private _drawCurveSegment;
    private _drawCurve;
    private _drawDot;
    private _fromData;
    private _toSVG;
}

declare class ProvidersService {
    private http;
    private baseUrl;
    constructor(http: HttpClient);
    private generateParams;
    getContractors(query: any): Observable<GridResult<any>>;
    getUserDetail(query: any): Observable<GridResult<UserDetailReadModel>>;
    adminCreateProvider(model: any): Observable<Result>;
    updateInitialSetUpProvider(model: any): Observable<Result>;
    changeStatus(model: any): Observable<Result>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProvidersService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProvidersService>;
}

declare enum UserProviderMappingStatus {
    Active = 1,
    Inactive = 2,
    Remove = 3
}

interface UserRoleReadModel extends ReadModel {
    providerId?: string;
    providerName?: string;
    isAdmin?: boolean;
    providerLogo?: string;
    userProviderMappingStatus?: UserProviderMappingStatus;
    userId?: string;
    userName?: string;
    userEmail?: string;
    userPhone?: string;
    userHeadShot?: string;
    roleId?: string;
    roleName?: string;
}

interface CacheUserClaimModel {
    roleId?: string;
    claimType?: string;
    claimValue?: string;
}

declare class RolesService {
    private httpClient;
    private baseUrl;
    constructor(httpClient: HttpClient);
    private buildParams;
    getUserRoles(query: any): Observable<UserRoleReadModel[]>;
    getUserPermission(query: any): Observable<CacheUserClaimModel>;
    setRoleContext(query: any): Observable<string[]>;
    assignRole(model: any): Observable<Result>;
    assignProviderRole(model: any): Observable<Result>;
    updateRole(model: any): Observable<Result>;
    getRoles(query: any): Observable<GridResult<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RolesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RolesService>;
}

interface ProviderContractorSubCategoryReadModel extends CustomReadModel {
    providerId?: string;
    contractorSubCategoryId?: string;
    contractorCategoryName?: string;
    contractorCategory?: any;
    contractorSubCategoryName?: string;
    contractorCategoryId?: any;
}

declare class ProviderContractorSubCategoryService {
    private baseUrl;
    private http;
    private buildParams;
    getContractorSubCategories(query: any): Observable<GridResult<ProviderContractorSubCategoryReadModel>>;
    get(query: any): Observable<GridResult<any>>;
    getUserAccounts(query: any): Observable<GridResult<UserAccountReadModel>>;
    bulkDelete(ids: any[]): Observable<Result>;
    bulkInsert(models: any[]): Observable<Result>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProviderContractorSubCategoryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProviderContractorSubCategoryService>;
}

declare enum AppType {
    AdjusterMatch = "AdjusterMatch",
    Ameripro = "Ameripro",
    Bootog = "Bootog",
    DroneSnap = "DroneSnap",
    IDClaims = "IDClaims",
    IDEnergy = "IDEnergy",
    InspectionDepot = "InspectionDepot",
    InspectorMatch = "InspectorMatch",
    MoldDepot = "MoldDepot",
    TermiteDepot = "TermiteDepot",
    VirtualInspector = "VirtualInspector"
}

interface LibraryConfig {
    appType: AppType;
    dashboardUrl: any;
    cloudfrontUrl: any;
    providerId: any;
    providerName: any;
    isLogout: any;
    navigateUrl?: string;
}
declare const LIBRARY_CONFIG: InjectionToken<LibraryConfig>;

interface AppBranding {
    logo: string;
    displayName: string;
}
declare class InitialProcessComponent implements OnInit {
    private router;
    private userDetailService;
    private formBuilder;
    private fileService;
    private providerService;
    private roleService;
    private modalService;
    private contractorSubCategoryService;
    private providerContractorSubCategoryService;
    private authService;
    private tokenService;
    private roleContextService;
    private authLogoutService;
    private libConfig;
    signatureFileId: any;
    signatureUrl: any;
    private signatureDirty;
    isAgreeEnabled: boolean;
    isneeded: boolean;
    isLogoRequired: boolean;
    logo: any;
    private readonly uploadToAws;
    selectedRoleValue: string | null;
    selectedRole: any;
    isUserSelected: boolean;
    title: string;
    state: any;
    logoName: any;
    branding: {
        logo: string;
        displayName: string;
    };
    credentialingData: any;
    modalRef?: BsModalRef;
    DefaultButtonSpinnerConfig: {
        spinnerColor: string;
        spinnerSize: string;
        buttonText: string;
    };
    view: number;
    validatePage: number;
    isBusiness: boolean;
    isImageRequired: boolean;
    user: any;
    assignProviderRoleModel: any;
    provider: ProviderModel;
    userId: any;
    fileName: string;
    model: {
        acceptTerms: boolean;
        privacy: boolean;
    };
    showContent: boolean;
    showLoader: boolean;
    isShowDelete: boolean;
    path: string;
    isCopy: boolean;
    rolesApiCall: Subscription;
    roles: any;
    canvasRef: ElementRef;
    signaturePad: SignaturePad;
    signaturePadData: {
        publicUrl: null;
    };
    points: never[];
    showlogout: boolean;
    pointsChange: EventEmitter<string>;
    cleared: EventEmitter<any>;
    companyForm: FormGroup;
    userForm: FormGroup;
    fileData: any;
    fileDataUser: File | null;
    fileDataLogo: File | null;
    zipcodeMask: RegExp[];
    options: {
        componentRestrictions: {
            country: string[];
        };
    };
    appType: any;
    users: LookupItem;
    providerError: any;
    userError: any;
    uploadError: string | null;
    providerRoleId: any;
    termsAndConditionTitle: string;
    showTermsAndConditions: boolean;
    termsAndConditions: string[];
    isTermsAccept: boolean;
    isPrivacyAccept: boolean;
    skipRole: boolean;
    modelRef: BsModalRef;
    userRoles: any;
    cloudfront: any;
    private destroy$;
    currentUserRoles: any;
    userViewRoles: ({
        name: string;
        value: string;
        img: string;
        selected: boolean;
        code: null;
        id: string;
        roleId: string;
    } | {
        name: string;
        value: string;
        img: string;
        selected: boolean;
        code: ProviderType;
        id: string;
        roleId: string;
    })[];
    onCredentialingBack(): void;
    selectedUserRole(role: any): void;
    privacyAndTerms: PrivacyAndTerms;
    setPrivacyAndTerms(appType: string): void;
    private getDefaultPrivacy;
    setRoleContext(roleId: any, name: any): void;
    selectedContractorCategories: string[];
    selectedContractorSubCategories: {
        name: string;
        id: string;
        selected: boolean;
        selectAll: boolean;
        items: ContractorSubCategoryReadModel[];
    }[];
    contractorSubCategories: {
        name: any;
        id: any;
        selected: boolean;
        selectAll: boolean;
        items: ContractorSubCategoryReadModel[];
    }[];
    contractorCategories: ContractorSubCategoryReadModel[];
    isLoadingSubCategories: boolean;
    appBrandingMap: Record<string, AppBranding>;
    constructor(router: Router, userDetailService: UserDetailService, formBuilder: FormBuilder, fileService: FileService, providerService: ProvidersService, roleService: RolesService, modalService: BsModalService, contractorSubCategoryService: ProviderContractorSubCategoryService, providerContractorSubCategoryService: ProviderContractorSubCategoryService, authService: AuthService, tokenService: TokenService, roleContextService: RoleContextService, authLogoutService: AuthLogoutService, libConfig: LibraryConfig);
    selectedContract: any;
    changeContractor(event?: any[]): void;
    selectAll(event: any, items: any[]): void;
    unCheckedEvent(event: any, items: any): void;
    findCategory(contractorCategories: any): boolean;
    getUserRoles(): void;
    ngOnInit(): Promise<void>;
    getUser(): Promise<void>;
    get f(): {
        [key: string]: _angular_forms.AbstractControl<any, any, any>;
    };
    get u(): {
        [key: string]: _angular_forms.AbstractControl<any, any, any>;
    };
    ngAfterViewInit(): void;
    clearPad(): void;
    private applyPoints;
    private emitPoints;
    uploadSignImage(event: any): void;
    uploadUserImage(event: any): void;
    uploadLogo(event: any): void;
    AddressChange(address: any): void;
    AddressChangeUser(address: any): void;
    previous(): void;
    next(page?: number): void;
    handleSignatureAndMoveToNext(): Promise<void>;
    saveSignatureAndIncrement(): Promise<boolean>;
    private dataURLtoFile;
    uploadFileBrowseHandler(): Promise<void>;
    saveAWSLogo(): Promise<boolean>;
    formatPhone(event: any, form: FormGroup): void;
    saveAWSHeadShot(): Promise<void>;
    saveAWSSignature(): Promise<void>;
    saveSignature(): void;
    private saveInitial;
    bindProviderDetails(): {
        userName: string;
        providerType: ProviderType;
        providerName: any;
        address1: any;
        address2: any;
        city: any;
        state: any;
        zipcode: any;
        county: any;
        subDivision: any;
        country: any;
        latitude: any;
        longitude: any;
        phoneNumber: any;
        userAddress1: any;
        userAddress2: any;
        userCity: any;
        userState: any;
        userZipcode: any;
        userCounty: any;
        userCountry: any;
        headshotUrl: any;
        userMobile: any;
        userEmailId: any;
        logoId: any;
        logoFileName: any;
        logoUrl: any;
    };
    isProviderCall: boolean;
    isResponse: boolean;
    saveBusiness(): void;
    getRoles(): void;
    formatDateTime(date: Date): {
        mmddyyyy: string;
        mmddyyyyhhmmtt: string;
        hhmmtt: string;
    };
    bindUserDetails(): UserDetailModel;
    saveFinal(): void;
    dashboard(): void;
    changeAddressUser(): void;
    scrollProgress: number;
    private autoScrollRaf;
    private autoScrollDelay;
    onTermsScroll(event: Event): void;
    openModal(template: TemplateRef<any>, title: string, event: any): void;
    startAutoScroll(): void;
    stopAutoScroll(): void;
    scrollToBottomClick(event: Event): void;
    agree(title: string): void;
    decline(title: string): void;
    logout(): Promise<void>;
    getContractorSubCategories(): void;
    saveContractorSubCategory(id: any): void;
    private get STORAGE_KEY();
    private preRestoreView;
    private saveState;
    private restoreState;
    private clearState;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InitialProcessComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InitialProcessComponent, "app-initial-process", never, {}, {}, never, never, false, never>;
}

interface ProcessedSection$1 {
    id: string;
    versionName: string;
    content: SafeHtml;
    orderby: number;
    createdDate: string;
    createdBy: string;
    type: number;
}
declare class TermsConditionsComponent implements OnInit, OnDestroy {
    private sanitizer;
    private userDetailsService;
    title: string;
    branding: {
        logo: string;
        displayName: string;
    };
    PrivacyAndTerms: PrivacyAndTerms;
    parsedSections: ProcessedSection$1[];
    isLoading: boolean;
    private destroy$;
    constructor(sanitizer: DomSanitizer, userDetailsService: UserDetailService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private getTermsAndConditions;
    private buildSections;
    private interpolate;
    isFilteredBrand(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<TermsConditionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TermsConditionsComponent, "app-terms-conditions", never, { "title": { "alias": "title"; "required": false; }; "branding": { "alias": "branding"; "required": false; }; "PrivacyAndTerms": { "alias": "PrivacyAndTerms"; "required": false; }; }, {}, never, never, false, never>;
}

interface ProcessedSection {
    id: string;
    versionName: string;
    content: SafeHtml;
    orderby: number;
    createdDate: string;
    createdBy: string;
    type: number;
}
declare class PrivacyPolicyComponent implements OnInit, OnDestroy {
    private sanitizer;
    private userDetailsService;
    title: string;
    branding: {
        logo: string;
        displayName: string;
    };
    PrivacyAndTerms: PrivacyAndTerms;
    parsedSections: ProcessedSection[];
    isLoading: boolean;
    private destroy$;
    constructor(sanitizer: DomSanitizer, userDetailsService: UserDetailService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private getPrivacyPolicy;
    private buildSections;
    private interpolate;
    isFilteredBrand(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<PrivacyPolicyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PrivacyPolicyComponent, "app-privacy-policy", never, { "title": { "alias": "title"; "required": false; }; "branding": { "alias": "branding"; "required": false; }; "PrivacyAndTerms": { "alias": "PrivacyAndTerms"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum ForUser {
    ForProvider = 1,
    ForProducer = 2
}

declare enum RequestedStatus {
    Requested = 1,
    InReview = 2,
    Rejected = 3,
    Resubmitted = 4,
    Approved = 5,
    Canceled = 6
}

interface UserSkillSetModel extends MasterModel {
    forUser: ForUser;
    id?: any;
    providerId?: string;
    providerName?: string;
    userId?: string;
    userName?: string;
    emailId?: string;
    phoneNumber?: string;
    userHeadShotUrl?: string;
    skillSetId?: string;
    skillSetName?: string;
    notes?: string;
    dueDate?: string;
    starRating?: number;
    year?: number;
    profileVisibility?: boolean;
    reviewNotes?: string;
    status?: RequestedStatus;
    rejectionCategory?: string;
    isActive?: boolean;
    isOpen?: boolean;
}

interface UserToolModel extends MasterModel {
    showOption?: boolean;
    forUser: ForUser;
    providerId?: string;
    providerName?: string;
    userId?: string;
    targetUserId?: string;
    userName?: string;
    id?: any;
    toolName?: string;
    emailId?: string;
    phoneNumber?: string;
    userHeadShotUrl?: string;
    toolId?: string;
    starRating?: number;
    year?: number;
    make?: string;
    model?: string;
    serialNumber?: string;
    reviewBy?: string;
    reviewByName?: string;
    status?: RequestedStatus;
    reviewDateTime?: string;
    reviewComments?: string;
    profileVisibility?: boolean;
    notes?: string;
    rejectionCategory?: string;
    isActive?: boolean;
    isOpen?: boolean;
}

/**
 * Represents the complete resume profile for a candidate.
 */
interface CompanyDetails {
    companyName: string;
    companyPhoneNumber: string;
    address1: string;
    city: string;
    state: string;
    zipcode: string;
    country: string;
    logoId?: string;
    logoUrl?: string;
    logoFileName?: string;
}
interface ResumeProfile {
    id: string;
    roleData?: any;
    targetProviderId?: string;
    targetProviderName?: string;
    cloudfrontUrl?: string;
    targetUserId?: string;
    basicDetails: BasicDetails;
    companyDetails?: CompanyDetails;
    workExperience: WorkExperience$1[];
    education: Education$1[];
    certifications: Certification$3[];
    licenses: License$1[];
    skills: string[];
    tools: string[];
}
/**
 * Personal and contact information including a professional summary.
 */
interface BasicDetails {
    firstName: string;
    lastName: string;
    email: string;
    phone: string;
    address: string;
    city: string;
    state: string;
    zipCode: string;
    country: string;
    jobTitle: string;
    yearsOfExperience: number;
    summary: string;
}
/**
 * Details regarding professional work history.
 */
interface WorkExperience$1 {
    company: string;
    jobTitle: string;
    country: string;
    state: string;
    city: string;
    startDate: string;
    endDate: string | null;
    isCurrent: boolean;
    responsibilities: string[];
}
/**
 * Educational background, including degrees, certificates, and specific courses.
 */
interface Education$1 {
    degree: string;
    degreeType: 'Associate' | 'Certificate' | 'Course' | 'Bachelors' | 'Masters' | string;
    institution: string;
    country: string;
    state: string | null;
    city: string | null;
    startDate: string;
    endDate: string;
    achievements: string[];
}
/**
 * Professional certifications and credentials.
 */
interface Certification$3 {
    name: string;
    issuingOrganization: string | null;
    state: string | null;
    issueDate: string | null;
    expiryDate: string | null;
    credentialId: string | null;
}
/**
 * Legal licenses, such as driver's or professional operating licenses.
 */
interface License$1 {
    name: string;
    issuingAuthority: string | null;
    licenseNumber: string | null;
    state: string | null;
    issueDate: string | null;
    expiryDate: string | null;
}

interface ResumeSkillMeta {
    providerName?: string;
    starRating?: number;
    year?: number | null;
    profileVisibility?: boolean;
    notes?: string;
}
interface ResumeToolMeta {
    providerName?: string;
    starRating?: number;
    year?: number | null;
    profileVisibility?: boolean;
    notes?: string;
}
interface Certification$2 {
    name: string;
    type: string;
    issuedBy: string;
    issueDate: string;
    expiryDate: string;
    city: string;
    state: string;
    description: string;
}
interface License {
    title: string;
    number: string;
    institution: string;
    issueDate: string;
    expiryDate: string;
    city: string;
    state: string;
    description: string;
}
interface Tool {
    name: string;
    selected: boolean;
    model?: string;
    serialNumber?: string;
    yearsExperience?: number;
    profileVisible?: boolean;
    manufacturer?: string;
    rating?: number;
}
declare class CredentialingStore {
    private readonly STORAGE_KEY;
    completedSteps: i0.WritableSignal<number[]>;
    constructor();
    private saveToStorage;
    private loadFromStorage;
    clearStorage(): void;
    toolsList: i0.WritableSignal<Tool[]>;
    uploadOption: i0.WritableSignal<"manual" | "upload" | null>;
    certifications: i0.WritableSignal<Certification$2[]>;
    licenses: i0.WritableSignal<License[]>;
    stepView: i0.WritableSignal<"add" | "preview">;
    goToPreview(): void;
    goToAdd(): void;
    userSkills: i0.WritableSignal<UserSkillSetModel[]>;
    setUserSkills(skills: UserSkillSetModel[]): void;
    updateUserSkill(updated: UserSkillSetModel): void;
    addUserSkills(skills: UserSkillSetModel | UserSkillSetModel[]): void;
    toggleSkill(skillSetId: string): void;
    toolStepView: i0.WritableSignal<"add" | "preview">;
    goToToolPreview(): void;
    goToToolAdd(): void;
    userTools: i0.WritableSignal<UserToolModel[]>;
    setUserTools(tools: UserToolModel[]): void;
    updateUserTool(updated: UserToolModel): void;
    addUserTools(tools: UserToolModel | UserToolModel[]): void;
    toggleTool(toolId: string): void;
    currentStep: i0.WritableSignal<number>;
    role: i0.WritableSignal<string | null>;
    education: i0.WritableSignal<any>;
    initialSelection: i0.WritableSignal<string | null>;
    selectedTools: i0.WritableSignal<Tool[]>;
    selectedRoles: i0.WritableSignal<string[]>;
    selectedJobs: i0.WritableSignal<string[]>;
    city: i0.WritableSignal<string>;
    state: i0.WritableSignal<string>;
    showMap: i0.WritableSignal<boolean>;
    currentCoverage: i0.WritableSignal<boolean>;
    notApplicable: i0.WritableSignal<boolean>;
    selectedStates: i0.WritableSignal<string[]>;
    isUploadSuccess: i0.WritableSignal<string | null>;
    uploadedResumeFile: i0.WritableSignal<{
        name: string;
        size: number;
        lastModified: number;
    } | null>;
    setUploadedResumeFile(file: File): void;
    profileSignal: i0.WritableSignal<ResumeProfile | null>;
    resumeSkillMeta: i0.WritableSignal<Record<number, ResumeSkillMeta>>;
    resumeToolMeta: i0.WritableSignal<Record<number, ResumeToolMeta>>;
    profile: ResumeProfile | null;
    selectInitial(value: string): void;
    setUploadOption(option: 'upload' | 'manual'): void;
    addRole(role: string): void;
    setResumeSkillMeta(index: number, meta: ResumeSkillMeta): void;
    setResumeToolMeta(index: number, meta: ResumeToolMeta): void;
    removeRole(role: string): void;
    setRole(role: string): void;
    setEducation(data: any): void;
    setCoverage(data: {
        city: string;
        state: string;
        selectedStates: string[];
        currentCoverage: boolean;
        notApplicable: boolean;
        showMap: boolean;
    }): void;
    setSelectedJobs(jobs: string[]): void;
    addCertification(cert: Certification$2): void;
    removeCertification(index: number): void;
    addLicense(license: License): void;
    removeLicense(index: number): void;
    nextStep(): void;
    previousStep(): void;
    updateToolDetails(toolName: string, data: Partial<Tool>): void;
    addSuccess(value: any): void;
    setProfile(data: ResumeProfile): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CredentialingStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CredentialingStore>;
}

interface StateModel {
    stateCode: string;
    stateName: string;
}
interface CountyModel extends StateModel {
    countyName: string;
}
interface ZipCodeModel extends CountyModel {
    countryCode: string;
    postalCode: string;
    placeName: string;
    countyCode: string;
    communityCode: string;
    communityName: string;
    latitude: number;
    longitude: number;
    accuracy: number;
}

declare class PostalCodeServices {
    protected httpClient: HttpClient;
    protected readonly apiUrl?: string | undefined;
    private selectedCountryCode;
    private endpoint;
    private cachedStates;
    private statesRequestCache;
    private get url();
    constructor(httpClient: HttpClient, apiUrl?: string | undefined);
    getCountryCode(): string;
    GetStatesByCountryCode(countryCode: string): Observable<StateModel[]>;
    GetCountiesByState(countryCode: string, stateCode: string): Observable<CountyModel[]>;
    getCountiesByStates(countryCode: string, stateCodes: string[]): Observable<CountyModel[]>;
    GetZipcodesByCounty(countryCode: string, countyName: string): Observable<ZipCodeModel[]>;
    SearchZipcodeDetails(countryCode: string, zipCode: string): Observable<ZipCodeModel[]>;
    GetNearestZipcodeDetails(countryCode: string, zipCode: string, totalCount: number): Observable<ZipCodeModel[]>;
    GetZipcodeDetails(countryCode: string, zipCode: string): Observable<ZipCodeModel>;
    GetZipcodeDetailsByCoordinate(countryCode: string, latitude: number, longitude: number): Observable<ZipCodeModel>;
    static ɵfac: i0.ɵɵFactoryDeclaration<PostalCodeServices, [null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PostalCodeServices>;
}

declare class CredentialingComponent implements OnInit {
    store: CredentialingStore;
    private postalCodeService;
    private libConfig;
    private viewport;
    animation: string | undefined;
    signatureFileId: any;
    signatureUrl: any;
    cloudfrontUrl: any;
    providerId: any;
    providerName: any;
    data: any;
    back: EventEmitter<void>;
    onActivate(outlet: RouterOutlet): void;
    states: any;
    constructor(store: CredentialingStore, postalCodeService: PostalCodeServices, libConfig: LibraryConfig, viewport: ViewportScroller);
    ngOnInit(): void;
    goBackToInitialProcess(): void;
    onProviderSaved(event: {
        providerId: string;
        providerName: string;
    }): void;
    getstates(countryCode: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CredentialingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CredentialingComponent, "app-credentialing", never, { "signatureFileId": { "alias": "signatureFileId"; "required": false; }; "signatureUrl": { "alias": "signatureUrl"; "required": false; }; "data": { "alias": "data"; "required": false; }; }, { "back": "back"; }, never, never, false, never>;
}

declare class UserExperienceService {
    private httpClient;
    private readonly baseUrl;
    constructor(httpClient: HttpClient);
    createUserExperience(model: any): Observable<Result>;
    updateUserExperience(model: any): Observable<Result>;
    getUserExperience(query: GridifyQuery): Observable<{
        data: WorkExperience[];
    }>;
    bulkDelete(ids: string[]): Observable<Result>;
    private buildParams;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserExperienceService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserExperienceService>;
}

interface WorkExperience {
    id?: string;
    companyName: string;
    jobTitle: string;
    country: string;
    state: string;
    city: string;
    fromDate: string;
    toDate: string;
    jobDescription: string;
    fileUrl?: string;
    fileName?: string;
    reviewStatus?: number;
}
declare class WorkExperienceStore {
    userExperienceService: UserExperienceService;
    private _experiences;
    readonly experiences: i0.Signal<WorkExperience[]>;
    API_URL: any;
    constructor(userExperienceService: UserExperienceService);
    loadFromApi(userId: string): void;
    addExperience(exp: WorkExperience): void;
    updateExperience(index: number, exp: WorkExperience): void;
    getExperience(index: number): WorkExperience;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkExperienceStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WorkExperienceStore>;
}

declare class UserEducationService {
    private httpClient;
    private readonly baseUrl;
    constructor(httpClient: HttpClient);
    createUserEducation(model: any): Observable<Result>;
    updateUserEducation(model: any): Observable<Result>;
    getUserEducation(query: GridifyQuery): Observable<{
        data: WorkExperience[];
    }>;
    bulkDelete(ids: string[]): Observable<Result>;
    private buildParams;
    getByUserId(userId: string): Observable<{
        data: Education[];
    }>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserEducationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserEducationService>;
}

interface Education {
    id?: string;
    courseName: string;
    courseType: string;
    instituteName: string;
    country: string;
    state: string;
    city: string;
    startDate: string;
    endDate: string;
    fileId?: any;
    fileUrl?: string;
    fileName?: string;
    comments: string;
    reviewStatus?: number;
}
declare class EducationStore {
    private userEducationService;
    private educations;
    readonly experiences: i0.Signal<Education[]>;
    API_URL: any;
    constructor(userEducationService: UserEducationService);
    loadFromApi(userId: string): void;
    addExperience(exp: Education): void;
    updateExperience(index: number, exp: Education): void;
    getExperience(index: number): Education;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EducationStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EducationStore>;
}

declare class UserDocumentService {
    private httpClient;
    private readonly baseUrl;
    private readonly baseUrlUpdated;
    constructor(httpClient: HttpClient);
    createUserDocument(model: any): Observable<Result>;
    updateUserDocument(model: any): Observable<Result>;
    getUserDocument(query: GridifyQuery): Observable<{
        data: any[];
    }>;
    bulkDelete(ids: string[]): Observable<Result>;
    private buildParams;
    getDocumentTypes(maintype: any, providerId: string, searchText?: string): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserDocumentService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserDocumentService>;
}

interface Certification$1 {
    id?: string;
    number: string;
    issuedBy: string;
    issuedState: string;
    expiryDate: string;
    issueDate: string;
    mainType: string;
    forUser: string;
    status: string;
    fileId?: any;
    fileUrl?: string;
    fileName?: string;
    notes: string;
    documentTypeId?: string;
    documentTypeName?: string;
}
declare class CertificationStore {
    userDocumentService: UserDocumentService;
    private certifications;
    readonly experiences: i0.Signal<Certification$1[]>;
    API_URL: any;
    constructor(userDocumentService: UserDocumentService);
    loadFromApi(userId: string): void;
    addExperience(exp: Certification$1): void;
    updateExperience(index: number, exp: Certification$1): void;
    getExperience(index: number): Certification$1;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CertificationStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CertificationStore>;
}

interface Certification {
    id?: string;
    number: string;
    issuedBy: string;
    issuedState: string;
    expiryDate: string;
    issueDate: string;
    mainType: string;
    forUser: string;
    status: string;
    fileId?: any;
    fileUrl?: string;
    fileName?: string;
    notes: string;
    documentTypeId?: string;
    documentTypeName?: string;
}
declare class LicenseStore {
    userDocumentService: UserDocumentService;
    private certifications;
    readonly experiences: i0.Signal<Certification[]>;
    API_URL: any;
    constructor(userDocumentService: UserDocumentService);
    loadFromApi(userId: string): void;
    addExperience(exp: Certification): void;
    updateExperience(index: number, exp: Certification): void;
    getExperience(index: number): Certification;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LicenseStore, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LicenseStore>;
}

declare class StepperComponent implements AfterViewInit {
    store: CredentialingStore;
    private workExperienceStore;
    private educationStore;
    private certificationStore;
    private licenseStore;
    tabsRow: ElementRef<HTMLElement>;
    steps: string[];
    showLockWarning: boolean;
    private warningTimer;
    constructor(store: CredentialingStore, workExperienceStore: WorkExperienceStore, educationStore: EducationStore, certificationStore: CertificationStore, licenseStore: LicenseStore);
    isStepComplete(step: number): boolean;
    ngAfterViewInit(): void;
    private scrollActiveTab;
    get basicDetailsCompleted(): boolean;
    get completedCount(): number;
    get progressPercent(): number;
    get progressOffset(): number;
    /**
     * A tab is locked when it is an optional step (index > BASIC_DETAILS_INDEX)
     * and the user has not yet completed Basic Details.
     */
    isLocked(index: number): boolean;
    goToStep(index: number): void;
    private triggerLockWarning;
    static ɵfac: i0.ɵɵFactoryDeclaration<StepperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StepperComponent, "app-stepper", never, {}, {}, never, never, false, never>;
}

interface CountryModel {
    countryCode2: string;
    countryCode3: string;
    country: string;
    capital: string;
    area: any;
    population: number;
    continent: string;
    currencyCode: string;
    currencyName: string;
    phone: string;
    postalCodeFormat: string;
    postalCodeRegex: string;
    languages: string[];
    neighbours: string[];
}

declare class CountryServices {
    protected httpClient: HttpClient;
    protected readonly apiUrl?: string | undefined;
    private endpoint;
    private get url();
    constructor(httpClient: HttpClient, apiUrl?: string | undefined);
    GetCountries(): Observable<CountryModel[]>;
    SearchCountries(name: string): Observable<CountryModel[]>;
    GetCountryDetail(countryCode: string): Observable<CountryModel[]>;
    GetCountryCode(countryCode: string): Observable<CountryModel[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CountryServices, [null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CountryServices>;
}

declare class UserService {
    userDetails: any;
    setUserDetails(data: any): void;
    getUserDetails(): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserService>;
}

declare class EducationComponent implements OnInit {
    private roleContextService;
    userEducation: UserEducationService;
    private userService;
    store: CredentialingStore;
    workStore: EducationStore;
    private countryService;
    private postalCodeService;
    private tokenService;
    private fb;
    private fileService;
    private http;
    originalFormValue: any;
    fileChanged: boolean;
    user: any;
    isAdding: i0.WritableSignal<boolean>;
    showedit: boolean;
    private readonly uploadToAws;
    educationForm: FormGroup;
    providerId: string;
    providerName: string;
    cloudfrontUrl: string;
    editingIndex: number;
    isEditing: i0.WritableSignal<boolean>;
    fileData: any;
    API_URL: any;
    API_URL_UPDATE: any;
    awsFileUpdate: UpdateAwsFileModelModel[];
    model: any;
    fileName: any;
    preferredStartDate: string | null;
    minDate: Date;
    countries: any[];
    states: any[];
    selectedCountry: string;
    selectedStates: string | null;
    userId: any;
    userName: any;
    cloudfront: any;
    proposalLoader: boolean;
    showSuccess: i0.WritableSignal<boolean>;
    showpreview: i0.Signal<boolean>;
    maxDate: Date;
    userdata: any;
    constructor(roleContextService: RoleContextService, userEducation: UserEducationService, userService: UserService, store: CredentialingStore, workStore: EducationStore, countryService: CountryServices, postalCodeService: PostalCodeServices, tokenService: TokenService, fb: FormBuilder, fileService: FileService, http: HttpClient);
    ngOnInit(): Promise<void>;
    selectFile(event: any): void;
    hasChanges(): boolean;
    removeFile(): void;
    saveFile(): void;
    getcountry(): void;
    getstates(countryCode: any): void;
    onCountryChange(countryCode: string): void;
    onPreferredDateChange(date: Date): void;
    private getFileExtension;
    private saveAWSFile;
    saveAndContinue(): void;
    refreshForEdit(): void;
    edit(index: number): void;
    delete(index: number): void;
    triggerSuccess(): void;
    back(): void;
    nextStep(): void;
    handleLeftButton(): void;
    add(): void;
    cancelForm(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<EducationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<EducationComponent, "app-education", never, { "providerId": { "alias": "providerId"; "required": false; }; "providerName": { "alias": "providerName"; "required": false; }; "cloudfrontUrl": { "alias": "cloudfrontUrl"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CertificationComponent {
    roleContextService: RoleContextService;
    userDocumentService: UserDocumentService;
    private userService;
    store: CredentialingStore;
    workStore: CertificationStore;
    private tokenService;
    private postalCodeService;
    private fb;
    private fileService;
    private http;
    originalFormValue: any;
    states: any[];
    isAdding: i0.WritableSignal<boolean>;
    showedit: boolean;
    fileChanged: boolean;
    user: any;
    private readonly uploadToAws;
    providerId: string;
    providerName: string;
    cloudfrontUrl: string;
    editingIndex: number;
    selectedDocumentTypeId: string | null;
    selectedDocumentId: any | null;
    selectedDocumentName: any | null;
    isEditing: i0.WritableSignal<boolean>;
    searchControl: FormControl<string | null>;
    documentTypes: any[];
    userId: any;
    selectedDocument: {
        id: string | null;
        name: string | null;
    };
    certificateForm: FormGroup;
    API_URL: any;
    API_URL_UPDATE: any;
    fileData: any;
    awsFileUpdate: UpdateAwsFileModelModel[];
    model: any;
    fileName: any;
    preferredStartDate: string | null;
    selectedCountry: string;
    selectedStates: string | null;
    userName: any;
    cloudfront: any;
    proposalLoader: boolean;
    showSuccess: i0.WritableSignal<boolean>;
    manualTypeError: string;
    showpreview: i0.Signal<boolean>;
    userdata: any;
    maxDate: Date;
    constructor(roleContextService: RoleContextService, userDocumentService: UserDocumentService, userService: UserService, store: CredentialingStore, workStore: CertificationStore, tokenService: TokenService, postalCodeService: PostalCodeServices, fb: FormBuilder, fileService: FileService, http: HttpClient);
    ngOnInit(): Promise<void>;
    loadDocumentTypes(searchText?: string): void;
    loadDocumentTypesDefault(searchText?: string): void;
    isChecked(id: string): boolean;
    toggleSelection(item: any, event: Event): void;
    getstates(): void;
    onPreferredDateChange(date: Date): void;
    saveFile(): void;
    edit(index: number): void;
    delete(index: number): void;
    selectFile(event: any): void;
    removeFile(): void;
    hasChanges(): boolean;
    private getFileExtension;
    private saveAWSFile;
    saveAndContinue(): void;
    triggerSuccess(): void;
    back(): void;
    nextStep(): void;
    handleLeftButton(): void;
    add(): void;
    addManualDocumentType(): void;
    cancelForm(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CertificationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CertificationComponent, "app-certification", never, { "states": { "alias": "states"; "required": false; }; "providerId": { "alias": "providerId"; "required": false; }; "providerName": { "alias": "providerName"; "required": false; }; "cloudfrontUrl": { "alias": "cloudfrontUrl"; "required": false; }; }, {}, never, never, false, never>;
}

interface SkillSetModel extends MasterModel {
    providerId?: string;
    skillSetCategoryId?: string;
    name?: string;
    description?: string;
    isPublic?: boolean;
    isActive?: boolean;
    selected?: boolean;
    cloneId?: string;
    isModified?: boolean;
    id?: any;
}

interface SkillSetCategoryModel extends MasterModel {
    name?: string;
    description?: string;
    isPublic?: boolean;
    providerId?: string;
    isActive?: boolean;
    cloneId?: string;
    isModified?: boolean;
    id?: any;
}

declare class SkillSetService {
    private httpClient;
    private readonly baseUrl;
    constructor(httpClient: HttpClient);
    getSkillSetNames(providerId?: string): Observable<LookupItem[]>;
    getSkillSets(query: any): Observable<any>;
    private generateParams;
    static ɵfac: i0.ɵɵFactoryDeclaration<SkillSetService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SkillSetService>;
}

declare class UserSkillSetService {
    private httpClient;
    private readonly baseUrl;
    constructor(httpClient: HttpClient);
    changeStatus(model: any): Observable<Result>;
    createUserSkillSet(models: UserSkillSetModel[]): Observable<any>;
    updateUserSkillSet(model: UserSkillSetModel): Observable<any>;
    bulkDelete(ids: string[]): Observable<Result>;
    getUserSkillSet(query: GridifyQuery): Observable<any>;
    private generateParams;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserSkillSetService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserSkillSetService>;
}

declare class AlertService {
    private injector;
    constructor(injector: Injector);
    info(message: string): void;
    success(message: string): void;
    warning(message: string, isHtml?: boolean): void;
    error(message: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AlertService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AlertService>;
}

declare enum FileTypes {
    EMPTY = 0,
    PDF = 1,
    DOCUMENT = 2,
    EXCEL = 3,
    IMAGE = 4,
    TEXT = 5,
    OTHER = 6
}

declare class UtilsService {
    protected alertService: AlertService;
    private router;
    constructor(alertService: AlertService, router: Router);
    parseResult(result: Result, message: string, redirect?: string): Promise<Result>;
    handleError(error: any): Promise<never>;
    setTimeZone(date: string | number | Date | null | undefined): Date | null;
    imageToFormData(image: any, name: string): FormData;
    base64ToBlob(base64: string, mime: string): Blob;
    arrayToPairwise(arr: any[]): any[];
    parseQuery(queryString: string): {
        [key: string]: string;
    };
    getFileType(fileName: string): FileTypes;
    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;
}

declare class SkillsComponent {
    private skillSetService;
    private userSkillSetService;
    private userService;
    private formBuilder;
    private utils;
    private roleContextService;
    store: CredentialingStore;
    private tokenService;
    private userSkillsSub?;
    providerId: string;
    providerName: string;
    userdata: any;
    user: any;
    tab: FormArray;
    showLoading: boolean;
    showLoader: boolean;
    userSkillSetModel: UserSkillSetModel;
    skillSetModel: any;
    userSkillSetModels: any[];
    skillSets: SkillSetModel[];
    skillSetForm: UntypedFormGroup;
    showForm: boolean;
    showCreate: boolean;
    isCopy: boolean;
    copyOptionIndex: number;
    initialStarts: number;
    searchSkillQry: string | undefined | null;
    selectedSkillSetCategory: SkillSetCategoryModel;
    skillSubmitted: boolean;
    skillSubmittedValue: boolean;
    userSkillSubmitted: boolean;
    showUserSkills: boolean;
    expYears: LookupItem[];
    tabs: any;
    selectedTab: any;
    nameError: string | undefined | null;
    copyData: any;
    getSkillCall: Subscription;
    userContext: RoleContextModel | null;
    form: UntypedFormGroup;
    model: UserSkillSetModel | null;
    userToolSubmitted: boolean;
    errMsg: boolean;
    userSkillsPreview: any[];
    isEditMode: boolean;
    emailId: any;
    userId: any;
    showAllSkills: boolean;
    skillDetailList?: ElementRef;
    constructor(skillSetService: SkillSetService, userSkillSetService: UserSkillSetService, userService: UserService, formBuilder: UntypedFormBuilder, utils: UtilsService, roleContextService: RoleContextService, store: CredentialingStore, tokenService: TokenService);
    private ctxProviderName;
    private ctxProviderId;
    private markTabPristine;
    goToAddSkillsMode(): void;
    createGroup(skillSetId?: any, skillName?: any): UntypedFormGroup;
    AddGroup(skillSetId: null, skillName: string): UntypedFormGroup;
    initialData(): void;
    getYears(): void;
    ngOnInit(): Promise<void>;
    getuserSkillsData(): void;
    cancel(): void;
    backToSkill(accGroup: any): void;
    onSkillAccordionChange(skill: any, isOpen: boolean): void;
    getSkillKey(skill: any): string;
    editSkillFromPreview(skill: any, accGroup: any, event: Event): void;
    onEditRating(stars: any): void;
    removeTab(index: number, skillId?: string): void;
    deleteSkillFromPreview(skill: any, event: Event): void;
    setTabGroup(g: any): void;
    onRatingSet(rating: number, index: number): void;
    reset(): void;
    onYearChange(group: any): void;
    setCopyToAllTabs(index: number, group: any): void;
    private scrollToDetailList;
    onSelectedSkillsets(event: Event, skill: SkillSetModel): void;
    createNewSkills(): void;
    getSkillSets(): void;
    setDefault(): void;
    onContinue(): void;
    saveUserSkillset(): void;
    private extractNameError;
    get g(): {
        [key: string]: _angular_forms.AbstractControl<any, any, any>;
    };
    get k(): any;
    back(): void;
    next(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SkillsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SkillsComponent, "app-skills", never, { "providerId": { "alias": "providerId"; "required": false; }; "providerName": { "alias": "providerName"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LicensesComponent {
    userDocumentService: UserDocumentService;
    private userService;
    private roleContextService;
    store: CredentialingStore;
    workStore: LicenseStore;
    private tokenService;
    private postalCodeService;
    private fb;
    private fileService;
    private http;
    providerId: string;
    providerName: string;
    cloudfrontUrl: string;
    originalFormValue: any;
    fileChanged: boolean;
    user: any;
    states: any[];
    isAdding: i0.WritableSignal<boolean>;
    showedit: boolean;
    private readonly uploadToAws;
    editingIndex: number;
    selectedDocumentTypeId: string | null;
    selectedDocumentId: any | null;
    selectedDocumentName: any | null;
    isEditing: i0.WritableSignal<boolean>;
    searchControl: FormControl<string | null>;
    documentTypes: any[];
    userId: any;
    selectedDocument: {
        id: string | null;
        name: string | null;
    };
    certificateForm: FormGroup;
    fileData: any;
    awsFileUpdate: UpdateAwsFileModelModel[];
    model: any;
    fileName: any;
    preferredStartDate: string | null;
    selectedCountry: string;
    selectedStates: string | null;
    userName: any;
    cloudfront: any;
    proposalLoader: boolean;
    showSuccess: i0.WritableSignal<boolean>;
    manualTypeError: string;
    showpreview: i0.Signal<boolean>;
    userdata: any;
    maxDate: Date;
    constructor(userDocumentService: UserDocumentService, userService: UserService, roleContextService: RoleContextService, store: CredentialingStore, workStore: LicenseStore, tokenService: TokenService, postalCodeService: PostalCodeServices, fb: FormBuilder, fileService: FileService, http: HttpClient);
    ngOnInit(): Promise<void>;
    loadDocumentTypes(searchText?: string): void;
    loadDocumentTypesDefault(searchText?: string): void;
    toggleSelection(item: any, event: Event): void;
    getstates(): void;
    onPreferredDateChange(date: Date): void;
    saveFile(): void;
    edit(index: number): void;
    delete(index: number): void;
    selectFile(event: any): void;
    removeFile(): void;
    hasChanges(): boolean;
    private getFileExtension;
    private saveAWSFile;
    saveAndContinue(): void;
    isChecked(id: string): boolean;
    triggerSuccess(): void;
    back(): void;
    nextStep(): void;
    handleLeftButton(): void;
    add(): void;
    addManualDocumentType(): void;
    cancelForm(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LicensesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LicensesComponent, "app-licenses", never, { "providerId": { "alias": "providerId"; "required": false; }; "providerName": { "alias": "providerName"; "required": false; }; "cloudfrontUrl": { "alias": "cloudfrontUrl"; "required": false; }; "states": { "alias": "states"; "required": false; }; }, {}, never, never, false, never>;
}

interface ToolModel extends MasterModel {
    toolCategoryName?: string;
    providerId?: string;
    toolCategoryId?: string;
    name?: string;
    description?: string;
    isPublic?: boolean;
    isActive?: boolean;
    id?: any;
    cloneId?: string;
    isModified?: boolean;
    selected?: boolean;
}

interface ToolCategoryModel extends MasterModel {
    selected?: boolean;
    providerId?: string;
    name?: string;
    description?: string;
    isPublic?: boolean;
    isActive?: boolean;
    cloneId?: string;
    isModified?: boolean;
    id?: any;
}

declare class UserToolService {
    private httpClient;
    private readonly baseUrl;
    constructor(httpClient: HttpClient);
    changeStatus(model: any): Observable<Result>;
    sendUserToolsRequest(model: any): Observable<Result>;
    createUserTool(model: any): Observable<any>;
    updateUserTool(model: UserToolModel): Observable<any>;
    bulkDelete(ids: string[]): Observable<Result>;
    getUserTool(query: GridifyQuery): Observable<any>;
    private buildParams;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserToolService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserToolService>;
}

declare class ToolService {
    private httpClient;
    private readonly baseUrl;
    constructor(httpClient: HttpClient);
    getToolNames(providerId?: string): Observable<LookupItem[]>;
    getTool(query: GridifyQuery): Observable<any>;
    private buildParams;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ToolService>;
}

declare class ToolsComponent {
    private toolService;
    private userToolService;
    private formBuilder;
    private userService;
    private utils;
    store: CredentialingStore;
    private tokenService;
    private roleContextService;
    private userDetailService;
    private libConfig;
    roleData: any;
    providerId: any;
    providerName: string;
    user: any;
    form: UntypedFormGroup;
    submitted: boolean;
    apiSubmit: boolean;
    model: UserToolModel | null;
    toolModel: any;
    userToolModels: UserToolModel[];
    tools: ToolModel[];
    toolCategories: ToolCategoryModel[];
    toolForm: UntypedFormGroup;
    showCreate: boolean;
    showLoader: boolean;
    homeLoader: boolean;
    toolsName: string | null | undefined;
    showForm: boolean;
    isCopy: boolean;
    copyOptionIndex: number;
    initialStarts: number;
    searchToolQry: string | null | undefined;
    selectedToolCategory: ToolCategoryModel;
    toolSubmitted: boolean;
    toolSubmittedValue: boolean;
    userToolSubmitted: boolean;
    expYears: LookupItem[];
    tabs: any[];
    tab?: FormArray<any> | null | undefined;
    selectedTab: any;
    nameError: string | null | undefined;
    showLoading: boolean | null | undefined;
    copyData: any;
    getToolCall: Subscription;
    userId: any;
    emailId: any;
    isEditMode: boolean;
    userToolsPreview: any[];
    showDashboardModal: boolean;
    showAllTools: boolean;
    toolDetailList?: ElementRef;
    userDetails: any;
    userdata: any;
    signatureUrl: any;
    signatureFileId: any;
    constructor(toolService: ToolService, userToolService: UserToolService, formBuilder: UntypedFormBuilder, userService: UserService, utils: UtilsService, store: CredentialingStore, tokenService: TokenService, roleContextService: RoleContextService, userDetailService: UserDetailService, libConfig: LibraryConfig);
    ngOnInit(): Promise<void>;
    private ctxProviderName;
    private ctxProviderId;
    createGroup(toolId: string | null | undefined, toolName: string): UntypedFormGroup;
    AddGroup(toolId: null, toolName: string): UntypedFormGroup;
    setDefault(): void;
    removeTab(index: number, toolId: string | undefined): void;
    deleteToolFromPreview(tool: any, event: Event): void;
    initialData(): void;
    getYears(): void;
    getuserToolsData(): void;
    getToolKey(tool: any): string;
    editingToolKey: string | null;
    onRatingSets(stars: number): void;
    editToolFromPreview(tool: any, accGroup: any, event: Event): void;
    onAccordionChange(tool: any, isOpen: boolean): void;
    backTool(group: any): void;
    private markTabPristine;
    onRatingSet(rating: number, index: number): void;
    setCopyToAllTabs(index: number, group: any, viewTab: boolean): void;
    onChangeCategory(obj: any): void;
    private scrollToDetailList;
    onSelectedTools(event: {
        target: {
            checked: boolean;
        };
    }, tool: {
        selected: boolean;
        name: string;
        id: string | undefined;
    }): void;
    reset(): void;
    createNewTools(): void;
    cancel(): void;
    goToAddSkillsMode(): void;
    getTools(): void;
    onToolContinue(): void;
    saveUserTools(): void;
    private extractNameError;
    get g(): {
        [key: string]: _angular_forms.AbstractControl<any, any, any>;
    };
    get k(): any;
    onYearChange(group: any): void;
    setTabGroup(g: any): void;
    goBack(): void;
    openDashboardModal(): void;
    closeDashboardModal(): void;
    saveFinal(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToolsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToolsComponent, "app-tools", never, { "roleData": { "alias": "roleData"; "required": false; }; "providerId": { "alias": "providerId"; "required": false; }; "providerName": { "alias": "providerName"; "required": false; }; "signatureUrl": { "alias": "signatureUrl"; "required": false; }; "signatureFileId": { "alias": "signatureFileId"; "required": false; }; }, {}, never, never, false, never>;
}

declare enum EmployeeDesignation {
    CEO = 0,
    Owner = 1,
    Employee = 2,
    IndependentContractor = 3
}

declare class IndustryService {
    private http;
    private readonly baseUrl;
    getUserIndustry(query: any): Observable<GridResult<any>>;
    private buildParams;
    static ɵfac: i0.ɵɵFactoryDeclaration<IndustryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<IndustryService>;
}

declare class FrontEndProvidersService {
    private http;
    private baseUrl;
    constructor(http: HttpClient);
    private generateParams;
    getProviderDetails(id: any): Observable<any[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FrontEndProvidersService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FrontEndProvidersService>;
}

interface UserFormControls {
    firstName: FormControl<any | null>;
    lastName: FormControl<any | null>;
    email: FormControl<string | null>;
    address1: FormControl<string | null>;
    address2: FormControl<string | null>;
    city: FormControl<string | null>;
    state: FormControl<string | null>;
    zipcode: FormControl<string | null>;
    country: FormControl<string | null>;
    county: FormControl<string | null>;
    latitude: FormControl<any | null>;
    longitude: FormControl<any | null>;
    phoneNumber: FormControl<string | null>;
    userJobTitle: FormControl<any | null>;
    yearsOfExperince: FormControl<any | null>;
    industries: FormControl<any | null>;
}
interface CompanyFormControls {
    companyName: FormControl<any | null>;
    companyPhoneNumber: FormControl<string | null>;
    address1: FormControl<string | null>;
    city: FormControl<string | null>;
    state: FormControl<string | null>;
    zipcode: FormControl<string | null>;
    country: FormControl<string | null>;
    county: FormControl<string | null>;
}
declare class RoleSelectComponent implements OnInit {
    store: CredentialingStore;
    private providerService;
    private userService;
    userDocumentService: UserDocumentService;
    router: Router;
    private industrydata;
    private userDetailService;
    private fileService;
    private tokenService;
    private roleContextService;
    private providerdetail;
    private fb;
    isLoaded: boolean;
    previewUrl: string | null;
    isImageLoading: boolean;
    isresumeLoading: boolean;
    isResumeRequired: boolean;
    model: any;
    isMappingCreated: boolean;
    initialSelectedJobValue: any;
    previousEmployeeType: EmployeeDesignation;
    companyForm: FormGroup<CompanyFormControls>;
    selectedTab: any;
    resumeName: any;
    industries: any[];
    selectedIndustries: any[];
    isIndustriesLoading: boolean;
    expYears: LookupItem[];
    jobTitles: LookupItem1<number>[];
    selectedIndustryIds: string[];
    selectedIndustryObjects: any[];
    private readonly uploadToAws;
    backToParent: EventEmitter<void>;
    providerSaved: EventEmitter<{
        providerId: string;
        providerName: string;
    }>;
    roleData: any;
    providerError: any;
    jobTypes: LookupItem1<number>[];
    userId: any;
    user: any;
    userError: any;
    showLoader: boolean;
    fileData: any;
    fileDataUser: any;
    zipcodeMask: RegExp[];
    options: {
        componentRestrictions: {
            country: string[];
        };
    };
    logo: any;
    userDetails: any;
    fileDataCompany: any;
    roleForm: FormGroup;
    userForm: FormGroup<UserFormControls>;
    fileName: any;
    signaturePad: SignaturePad;
    signaturePadData: {
        publicUrl: null;
    };
    previewresumeUrl: string | null;
    useremail: any;
    awsFileUpdate: UpdateAwsFileModelModel[];
    fileNameCompany: any;
    selectedJobs: i0.WritableSignal<string[]>;
    selectedJobValues: number[];
    isLogoLoading: boolean;
    previewCompanyUrl: string | null;
    userViewRoles: ({
        name: string;
        value: string;
        img: string;
        selected: boolean;
        code: null;
        id: string;
        roleId: string;
    } | {
        name: string;
        value: string;
        img: string;
        selected: boolean;
        code: ProviderType;
        id: string;
        roleId: string;
    })[];
    provider: any;
    constructor(store: CredentialingStore, providerService: ProvidersService, userService: UserService, userDocumentService: UserDocumentService, router: Router, industrydata: IndustryService, userDetailService: UserDetailService, fileService: FileService, tokenService: TokenService, roleContextService: RoleContextService, providerdetail: FrontEndProvidersService, fb: FormBuilder);
    cloudfrontUrl: string;
    providerId: any;
    providerName: string;
    providerdata: any;
    randomId: string;
    ngOnInit(): Promise<void>;
    getprovider(): void;
    private mappingKey;
    getYears(): void;
    uploacompanyImage(event: any): void;
    saveAWSCompanyLogo(): Promise<void>;
    getIndustries(): void;
    bindProviderDetails(): {
        userName: string;
        providerType: ProviderType;
        providerName: any;
        address1: string | null | undefined;
        city: string | null | undefined;
        state: string | null | undefined;
        zipcode: string | null | undefined;
        country: string | null | undefined;
        county: string | null | undefined;
        phoneNumber: string | null | undefined;
        userAddress1: string | null | undefined;
        userAddress2: string | null | undefined;
        userCity: string | null | undefined;
        userState: string | null | undefined;
        userZipcode: string | null | undefined;
        userCountry: string | null | undefined;
        userCounty: string | null | undefined;
        userMobile: string | null | undefined;
        userEmailId: string | null | undefined;
        logoId: any;
        logoFileName: any;
        logoUrl: any;
    };
    saveProvider(): Promise<string | null>;
    AddressChangeCompany(address: any): void;
    saveUserIndustries(): void;
    setSelectedIndustries(ids: string[]): void;
    onBackClick(): void;
    list: any;
    loadFromApi(userId: string): void;
    getUserDetail(): void;
    getDetailsSave(): void;
    onYearChange(group: any): void;
    hasChanges(): boolean;
    selectRole(role: string): void;
    get u(): UserFormControls;
    get c(): CompanyFormControls;
    uploadUserImage(event: any): void;
    selectFile(event: any): void;
    private saveAWSFile;
    saveResume(): void;
    uploadFileBrowseHandler(): void;
    saveAWSHeadShot(): Promise<void>;
    saveFinal(): Promise<void>;
    bindUserDetails(): UserDetailModel;
    formatDateTime(date: Date): {
        mmddyyyy: string;
        mmddyyyyhhmmtt: string;
        hhmmtt: string;
    };
    removeRole(role: string): void;
    phoneMask(event: Event, formType?: 'user' | 'company'): void;
    AddressChangeUser(address: any): void;
    back(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RoleSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RoleSelectComponent, "app-role-select", never, { "roleData": { "alias": "roleData"; "required": false; }; "cloudfrontUrl": { "alias": "cloudfrontUrl"; "required": false; }; "providerId": { "alias": "providerId"; "required": false; }; "providerName": { "alias": "providerName"; "required": false; }; }, { "backToParent": "backToParent"; "providerSaved": "providerSaved"; }, never, never, false, never>;
}

interface CoordinateLocation {
    name?: string;
    id?: string;
    path?: string;
    state?: string;
    county?: string;
    fillColor?: any;
    strokeColor?: any;
    isAllCounty?: boolean;
    latitude?: number;
    longitude?: number;
}
interface Coordinate {
    label: string;
    viewBox: string;
    locations: CoordinateLocation[];
}
interface CoordinateLocationDetail {
    label: string;
    locations: CoordinateLocation[];
}

declare class UsMapLatestService {
    private coordinates;
    getUsMapCoordinates(): Promise<Coordinate>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UsMapLatestService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UsMapLatestService>;
}

declare class UserCoverageAreaService {
    private httpClient;
    private readonly baseUrl;
    constructor(httpClient: HttpClient);
    getUserCoverageArea(query: GridifyQuery): Observable<any>;
    getUserCoverageAreaByUserId(userId: string): Observable<any>;
    private buildParams;
    bulkDelete(ids: string[]): Observable<Result>;
    bulkInsert(models: any[]): Observable<Result>;
    static ɵfac: i0.ɵɵFactoryDeclaration<UserCoverageAreaService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UserCoverageAreaService>;
}

declare class Step2CoverageComponent {
    store: CredentialingStore;
    private usMapService;
    private postalCodeService;
    private userCoverageAreaService;
    private alertService;
    private roleContextService;
    private tokenService;
    providerId: string;
    providerName: string;
    states: any;
    city: i0.WritableSignal<string>;
    state: i0.WritableSignal<string>;
    showMap: boolean;
    currentCoverage: i0.WritableSignal<boolean>;
    isStatesLoading: boolean;
    selectedStates: string[];
    coverages: any[];
    usCoordinates: Coordinate;
    filteredLocations: CoordinateLocationDetail[];
    showCoverage: boolean;
    showLoading: boolean;
    userCoverageArea: {
        forUser: ForUser;
        providerId: string;
        providerName: string;
        userId: string;
        userName: string;
        state: string;
        counties: never[];
    };
    isProvider: boolean;
    coverageSave: boolean;
    userContext: RoleContextModel;
    userId: any;
    emailId: any;
    userDetail: any;
    existingCoverageIds: string[];
    private initialCoverageSnapshot;
    constructor(store: CredentialingStore, usMapService: UsMapLatestService, postalCodeService: PostalCodeServices, userCoverageAreaService: UserCoverageAreaService, alertService: AlertService, roleContextService: RoleContextService, tokenService: TokenService);
    ngOnInit(): Promise<void>;
    toggleMap(): void;
    setSelectedStates(values: StateModel[]): void;
    onChangedCounty(event: any, stateCode: string, countyName: string, lat?: number, lng?: number): void;
    onSelectAllChanged(coverage: any): void;
    toggleCheckBox(state: string): any;
    updateFilteredLocations(): void;
    getCoverage(userId: string): void;
    syncStateCheckboxes(): void;
    skip(): void;
    saveCoverage(): void;
    previousStep(): void;
    prefillCoverage(data: any[]): void;
    hasCoverageChanged(): boolean;
    buildMapLocations(data: any[]): void;
    private buildCoveragePayload;
    static ɵfac: i0.ɵɵFactoryDeclaration<Step2CoverageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Step2CoverageComponent, "app-coverage", never, { "providerId": { "alias": "providerId"; "required": false; }; "providerName": { "alias": "providerName"; "required": false; }; "states": { "alias": "states"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WorkexperienceComponent implements OnInit {
    userExperienceService: UserExperienceService;
    private userService;
    workStore: WorkExperienceStore;
    store: CredentialingStore;
    private countryService;
    private postalCodeService;
    private tokenService;
    private roleContextService;
    private fb;
    private fileService;
    private http;
    originalFormValue: any;
    fileChanged: boolean;
    user: any;
    isAdding: i0.WritableSignal<boolean>;
    showedit: boolean;
    providerId: string;
    maxDate: Date;
    providerName: string;
    cloudfrontUrl: string;
    private readonly uploadToAws;
    editingIndex: number;
    workexperienceForm: FormGroup;
    isEditing: i0.WritableSignal<boolean>;
    API_URL: any;
    API_URL_UPDATE: any;
    fileData: any;
    awsFileUpdate: UpdateAwsFileModelModel[];
    model: any;
    fileName: any;
    preferredStartDate: string | null;
    minDate: Date;
    countries: any[];
    states: any[];
    selectedCountry: string;
    selectedStates: string | null;
    userId: any;
    userName: any;
    cloudfront: any;
    proposalLoader: boolean;
    showSuccess: i0.WritableSignal<boolean>;
    showpreview: i0.Signal<boolean>;
    userdata: any;
    constructor(userExperienceService: UserExperienceService, userService: UserService, workStore: WorkExperienceStore, store: CredentialingStore, countryService: CountryServices, postalCodeService: PostalCodeServices, tokenService: TokenService, roleContextService: RoleContextService, fb: FormBuilder, fileService: FileService, http: HttpClient);
    ngOnInit(): Promise<void>;
    getcountry(): void;
    getstates(countryCode: any): void;
    onCountryChange(countryCode: string): void;
    onPreferredDateChange(date: Date): void;
    selectFile(event: any): void;
    hasChanges(): boolean;
    saveFile(): void;
    private getFileExtension;
    private saveAWSFile;
    removeFile(): void;
    edit(index: number): void;
    delete(index: number): void;
    saveAndContinue(): void;
    triggerSuccess(): void;
    back(): void;
    nextStep(): void;
    handleLeftButton(): void;
    add(): void;
    cancelForm(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WorkexperienceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WorkexperienceComponent, "app-workexperience", never, { "providerId": { "alias": "providerId"; "required": false; }; "providerName": { "alias": "providerName"; "required": false; }; "cloudfrontUrl": { "alias": "cloudfrontUrl"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ResumeDetailService {
    private httpClient;
    private readonly baseUrl;
    constructor(httpClient: HttpClient);
    uploadResume(model: any): Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResumeDetailService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ResumeDetailService>;
}

declare class FirstComponent implements OnInit {
    store: CredentialingStore;
    private roleContextService;
    private tokenService;
    private resumedetail;
    private fileService;
    isUploading: boolean;
    resumeData: ResumeProfile | null;
    awsFileUpdate: UpdateAwsFileModelModel[];
    backToParent: EventEmitter<void>;
    userId: any;
    isDragOver: boolean;
    uploadError: string | null;
    sample: {
        basicDetails: {
            firstName: string;
            lastName: string;
            email: string;
            phone: string;
            address: string;
            city: string;
            state: string;
            zipCode: string;
            country: string;
            jobTitle: string;
            yearsOfExperience: number;
            summary: string;
        };
        workExperience: {
            company: string;
            jobTitle: string;
            country: string;
            state: string;
            city: string;
            startDate: string;
            endDate: string;
            isCurrent: boolean;
            responsibilities: string[];
        }[];
        education: ({
            degree: string;
            degreeType: string;
            institution: string;
            country: string;
            state: string;
            city: string;
            startDate: string;
            endDate: string;
            achievements: string[];
        } | {
            degree: string;
            degreeType: string;
            institution: string;
            country: string;
            state: string;
            city: null;
            startDate: string;
            endDate: string;
            achievements: never[];
        })[];
        certifications: {
            name: string;
            issuingOrganization: null;
            state: null;
            issueDate: null;
            expiryDate: null;
            credentialId: null;
        }[];
        licenses: {
            name: string;
            issuingAuthority: null;
            licenseNumber: null;
            state: null;
            issueDate: null;
            expiryDate: null;
        }[];
        skills: string[];
        tools: string[];
        id: string;
    };
    fileData: any;
    resumeName: any;
    fileDataUser: any;
    model: any;
    nextStep: EventEmitter<void>;
    constructor(store: CredentialingStore, roleContextService: RoleContextService, tokenService: TokenService, resumedetail: ResumeDetailService, fileService: FileService);
    ngOnInit(): Promise<void>;
    selectedRole: 'producer' | 'serviceProvider' | null;
    select(role: 'producer' | 'serviceProvider'): void;
    next(role: any): void;
    onFileSelected(event: any): void;
    openFile(fileInput: HTMLInputElement, event: Event): void;
    handleAutoNavigation(): void;
    manual(): void;
    private getFileExtension;
    private saveAWSFile;
    uploadresume(): void;
    private isAllowedResumeFile;
    private processSelectedResumeFile;
    onDragOver(event: DragEvent): void;
    onDragLeave(event: DragEvent): void;
    onDrop(event: DragEvent): void;
    onBackClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FirstComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FirstComponent, "app-first", never, {}, { "backToParent": "backToParent"; "nextStep": "nextStep"; }, never, never, false, never>;
}

declare class UsMapComponent implements OnChanges, OnInit, AfterViewInit {
    private cdr;
    private usMapService;
    viewinisialized: boolean;
    coordinates: any;
    selectedCoordinates: string[];
    selectedStates: any;
    changedSelectedStates: any;
    allowedStates: any;
    changedAllowedStates: any;
    isReadOnly: boolean;
    fillColor: string;
    fillStateColor: string;
    strokeColor: string;
    fillSelected: string;
    removeStateColor: string;
    click: EventEmitter<any>;
    usCoordinates: Coordinate;
    allCoordinates: Coordinate;
    filteredLocations: CoordinateLocationDetail[];
    usFillColor: string;
    usStrokeColor: string;
    constructor(cdr: ChangeDetectorRef, usMapService: UsMapLatestService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    fetchData(): void;
    modelValueChanged(): void;
    onUsMapClick(state: any, check?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<UsMapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UsMapComponent, "us-map", never, { "selectedStates": { "alias": "selectedStates"; "required": false; }; "allowedStates": { "alias": "allowedStates"; "required": false; }; "isReadOnly": { "alias": "isReadOnly"; "required": false; }; "filteredLocations": { "alias": "filteredLocations"; "required": false; }; }, { "click": "onMapClick"; }, never, never, false, never>;
}

declare class UsMapModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<UsMapModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<UsMapModule, [typeof UsMapComponent], [typeof i2.CommonModule], [typeof UsMapComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<UsMapModule>;
}

interface INg2LoadingSpinnerConfig {
    animationType?: string;
    backdropColor?: any;
    backdropBorderRadius?: any;
    spinnerColor?: any;
    spinnerPosition?: any;
    spinnerSize?: any;
    spinnerFontSize?: any;
}
declare class Ng2LoadingSpinnerConfig implements INg2LoadingSpinnerConfig {
    private config;
    animationType: string | undefined;
    backdropColor: string;
    spinnerColor: string;
    spinnerPosition: string;
    backdropBorderRadius: string;
    spinnerSize: string;
    spinnerFontSize: string;
    constructor(config: INg2LoadingSpinnerConfig);
}

declare class Ng2LoadingSpinnerComponent implements OnInit {
    vcRef: ViewContainerRef;
    config: Ng2LoadingSpinnerConfig;
    template: TemplateRef<any>;
    ANIMATION_TYPES: {
        dualCircle: string;
        scalingBars: string;
        chasingDots: string;
        bouncingDots: string;
        fadingCircle: string;
        halfCircle: string;
        cubeGrid: string;
    };
    constructor(vcRef: ViewContainerRef);
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<Ng2LoadingSpinnerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<Ng2LoadingSpinnerComponent, "ng2-loading-spinner", never, { "config": { "alias": "config"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ConfigService {
    private readonly config;
    private readonly defaultConfig;
    constructor(config: INg2LoadingSpinnerConfig);
    normalizeConfigs(config: INg2LoadingSpinnerConfig): INg2LoadingSpinnerConfig;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
}

declare class Ng2LoadingSpinnerDirective implements OnInit, OnChanges, OnDestroy {
    private el;
    private vcRef;
    private cfResolver;
    private renderer;
    private configService;
    show: any;
    config: any;
    template: TemplateRef<any>;
    private spinnerComponentRef;
    constructor(el: ElementRef, vcRef: ViewContainerRef, cfResolver: ComponentFactoryResolver, renderer: Renderer2, configService: ConfigService);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    setPosition(): void;
    createSpinner(): void;
    destroySpinner(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<Ng2LoadingSpinnerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<Ng2LoadingSpinnerDirective, "[ng2-loading]", never, { "show": { "alias": "ng2-loading"; "required": false; }; "config": { "alias": "config"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, {}, never, never, false, never>;
}

declare class Ng2LoadingSpinnerModule {
    static forRoot(globalConfig: INg2LoadingSpinnerConfig): ModuleWithProviders<Ng2LoadingSpinnerModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<Ng2LoadingSpinnerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<Ng2LoadingSpinnerModule, [typeof Ng2LoadingSpinnerComponent, typeof Ng2LoadingSpinnerDirective], [typeof i2.CommonModule], [typeof Ng2LoadingSpinnerDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<Ng2LoadingSpinnerModule>;
}

declare class LoaderComponent {
    show: boolean;
    small: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LoaderComponent, "loader", never, { "show": { "alias": "show"; "required": false; }; "small": { "alias": "small"; "required": false; }; }, {}, never, never, false, never>;
}

declare class LoaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<LoaderModule, [typeof LoaderComponent], [typeof i2.CommonModule], [typeof LoaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<LoaderModule>;
}

declare class MinutesToHoursPipe implements PipeTransform {
    transform(value: number, dateFormat: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<MinutesToHoursPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<MinutesToHoursPipe, "minutesToHours", false>;
}

declare class SearchPipe implements PipeTransform {
    transform(value: any, keys: string, term: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SearchPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SearchPipe, "SearchBy", false>;
}

declare class ValidateNullValuePipe implements PipeTransform {
    transform(value: string, args?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ValidateNullValuePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ValidateNullValuePipe, "validateNullValue", false>;
}

declare class TitleCaseExceptPipe implements PipeTransform {
    transform(value: string): any;
    private isPreposition;
    private toTilteCase;
    static ɵfac: i0.ɵɵFactoryDeclaration<TitleCaseExceptPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<TitleCaseExceptPipe, "titleCaseExcept", false>;
}

declare class CustomPipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomPipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CustomPipesModule, [typeof MinutesToHoursPipe, typeof SearchPipe, typeof ValidateNullValuePipe, typeof TitleCaseExceptPipe], never, [typeof MinutesToHoursPipe, typeof SearchPipe, typeof ValidateNullValuePipe, typeof TitleCaseExceptPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CustomPipesModule>;
}

declare class NgxStarsComponent implements OnChanges, OnInit, OnDestroy {
    maxStars: number;
    initialStars: number;
    readonly: boolean;
    size: number;
    color: string;
    animation: boolean;
    animationSpeed: number;
    customPadding: string;
    wholeStars: boolean;
    customStarIcons: {
        empty: string;
        half: string;
        full: string;
    };
    ratingOutput: EventEmitter<number>;
    rating: number;
    editableStars: EditableStar[];
    animationInterval: any;
    animationRunning: boolean;
    private customCssClasses;
    private customClassIdentifier;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private setupStarImages;
    private createCssClass;
    starPadding(): {
        [p: string]: string;
    };
    starColorAndSize(): {
        [p: string]: string;
    };
    private starColor;
    starSize(): {
        [p: string]: string;
    };
    private safeSize;
    starAnimation(): void;
    cancelStarAnimation(): void;
    setRating(rating: number): void;
    onStarHover(event: MouseEvent, clickedStar: EditableStar): void;
    onStarClick(event: MouseEvent, clickedStar: EditableStar): void;
    onZeroStarClick(): void;
    onZeroStarHover(): void;
    onStarsUnhover(): void;
    private clickedInFirstHalf;
    noop(): void;
    private getStarClass;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxStarsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgxStarsComponent, "ngx-stars", never, { "maxStars": { "alias": "maxStars"; "required": false; }; "initialStars": { "alias": "initialStars"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "animation": { "alias": "animation"; "required": false; }; "animationSpeed": { "alias": "animationSpeed"; "required": false; }; "customPadding": { "alias": "customPadding"; "required": false; }; "wholeStars": { "alias": "wholeStars"; "required": false; }; "customStarIcons": { "alias": "customStarIcons"; "required": false; }; }, { "ratingOutput": "ratingOutput"; }, never, never, false, never>;
}
declare class EditableStar {
    position: number;
    classname: any;
    constructor(position: number);
}

declare class NgxStarsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgxStarsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxStarsModule, [typeof NgxStarsComponent], [typeof i2.CommonModule], [typeof NgxStarsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgxStarsModule>;
}

interface AddressComponent {
    long_name: string;
    short_name: string;
    types: string[];
}

interface LatLng {
    /** Comparison function. */
    equals(other: LatLng): boolean;
    /** Returns the latitude in degrees. */
    lat(): number;
    /** Returns the longitude in degrees. */
    lng(): number;
    /** Converts to string representation. */
    toString(): string;
    /** Returns a string of the form "lat,lng". We round the lat/lng values to 6 decimal places by default. */
    toUrlValue(precision?: number): string;
    /** Converts to JSON representation. This function is intended to be used via JSON.stringify. */
    toJSON(): LatLngLiteral;
}
type LatLngLiteral = {
    lat: number;
    lng: number;
};
type LatLngBoundsLiteral = {
    east: number;
    north: number;
    south: number;
    west: number;
};

/**
 * A LatLngBounds instance represents a rectangle in geographical coordinates, including one
 * that crosses the 180 degrees longitudinal meridian.
 */

interface LatLngBounds {
    /** Returns true if the given lat/lng is in this bounds. */
    contains(latLng: LatLng | LatLngLiteral): boolean;
    /** Returns true if this bounds approximately equals the given bounds. */
    equals(other: LatLngBounds | LatLngBoundsLiteral): boolean;
    /** Extends this bounds to contain the given point. */
    extend(point: LatLng | LatLngLiteral): LatLngBounds;
    /** Computes the center of this LatLngBounds */
    getCenter(): LatLng;
    /** Returns the north-east corner of this bounds. */
    getNorthEast(): LatLng;
    /** Returns the south-west corner of this bounds. */
    getSouthWest(): LatLng;
    /** Returns true if this bounds shares any points with the other bounds. */
    intersects(other: LatLngBounds | LatLngBoundsLiteral): boolean;
    /** Returns if the bounds are empty. */
    isEmpty(): boolean;
    /** Converts to JSON representation. This function is intended to be used via JSON.stringify. */
    toJSON(): LatLngBoundsLiteral;
    /** Converts the given map bounds to a lat/lng span. */
    toSpan(): LatLng;
    /** Converts to string. */
    toString(): string;
    /**
     * Returns a string of the form "lat_lo,lng_lo,lat_hi,lng_hi" for this bounds, where "lo" corresponds to the
     * southwest corner of the bounding box, while "hi" corresponds to the northeast corner of that box.
     */
    toUrlValue(precision?: number): string;
    /** Extends this bounds to contain the union of this and the given bounds. */
    union(other: LatLngBounds | LatLngBoundsLiteral): LatLngBounds;
}

interface Geometry {
    location: LatLng;
    viewport: LatLngBounds;
}

interface Photo {
    height: number;
    html_attributions: string[];
    width: number;
    getUrl(request: PhotoRequest): string;
}
declare class PhotoRequest {
    maxWidth: number;
    maxHeight: number;
}

interface OpeningHours {
    open_now: boolean;
    periods: OpeningPeriod[];
    weekday_text: string[];
}
interface OpeningPeriod {
    open: OpeningHoursTime;
    close?: OpeningHoursTime;
}
interface OpeningHoursTime {
    day: number;
    hours: number;
    minutes: number;
    nextDate: number;
    time: string;
}

interface PlaceReview {
    aspects: PlaceAspectRating[];
    author_name: string;
    author_url: string;
    language: string;
    text: string;
}
interface PlaceAspectRating {
    rating: number;
    type: string;
}

declare class Address {
    address_components: AddressComponent[];
    adr_address: string;
    formatted_address: string;
    formatted_phone_number: string;
    geometry: Geometry;
    html_attributions: string[];
    icon: string;
    id: string;
    international_phone_number: string;
    name: string;
    opening_hours: OpeningHours;
    permanently_closed: boolean;
    photos: Photo[];
    place_id: string;
    price_level: number;
    rating: number;
    reviews: PlaceReview[];
    types: string[];
    url: string;
    utc_offset: number;
    vicinity: string;
    website: string;
}

declare class ComponentRestrictions {
    country: string;
    constructor(obj?: Partial<ComponentRestrictions>);
}

declare class Options {
    bounds: LatLngBounds;
    componentRestrictions: ComponentRestrictions;
    types: string[];
    fields: string[];
    strictBounds: boolean;
    origin: LatLng;
    constructor(opt?: Partial<Options>);
}

declare class GooglePlaceDirective implements AfterViewInit {
    private el;
    private ngZone;
    options: Options;
    onAddressChange: EventEmitter<Address>;
    private autocomplete;
    private eventListener;
    place: Address;
    constructor(el: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    private isGoogleLibExists;
    private initialize;
    reset(): void;
    private handleChangeEvent;
    static ɵfac: i0.ɵɵFactoryDeclaration<GooglePlaceDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GooglePlaceDirective, "[ngx-google-places-autocomplete]", ["ngx-places"], { "options": { "alias": "options"; "required": false; }; }, { "onAddressChange": "onAddressChange"; }, never, never, false, never>;
}

declare class GooglePlaceModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<GooglePlaceModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<GooglePlaceModule, [typeof GooglePlaceDirective], never, [typeof GooglePlaceDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<GooglePlaceModule>;
}

declare class TextMaskConfig {
    mask: Array<string | RegExp> | ((raw: string) => Array<string | RegExp>) | false;
    guide?: boolean;
    placeholderChar?: string;
    pipe?: (conformedValue: string, config: TextMaskConfig) => false | string | object;
    keepCharPositions?: boolean;
    showMask?: boolean;
}
declare class MaskedInputDirective implements ControlValueAccessor, OnChanges {
    private _renderer;
    private _elementRef;
    private _compositionMode;
    textMaskConfig: TextMaskConfig;
    onChange: (_: any) => void;
    onTouched: () => void;
    private textMaskInputElement;
    private inputElement;
    /** Whether the user is creating a composition string (IME events). */
    private _composing;
    constructor(_renderer: Renderer2, _elementRef: ElementRef, _compositionMode: boolean);
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: any): void;
    registerOnChange(fn: (_: any) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    _handleInput(value: any): void;
    _setupMask(create?: boolean): void;
    _compositionStart(): void;
    _compositionEnd(value: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MaskedInputDirective, [null, null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<MaskedInputDirective, "[textMask]", ["textMask"], { "textMaskConfig": { "alias": "textMask"; "required": false; }; }, {}, never, never, false, never>;
}
declare class TextMaskModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<TextMaskModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<TextMaskModule, [typeof MaskedInputDirective], never, [typeof MaskedInputDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<TextMaskModule>;
}

declare class SignaturePadComponent implements OnInit, AfterViewInit, OnChanges {
    private signaturePad;
    canvasRef: ElementRef;
    uploadImage: ElementRef;
    currentPoints: any[];
    points: any[];
    pointsChange: EventEmitter<any>;
    editable: boolean;
    isSubmit: boolean;
    Title: string;
    signData: any;
    penColor: string;
    backgroundColor: string;
    showDoneButton: boolean;
    doneButtonText: string;
    doneButtonClass: string;
    showClearButton: boolean;
    clearButtonText: string;
    clearButtonClass: string;
    showUploadButton: boolean;
    uploadButtonText: string;
    uploadButtonClass: string;
    format: 'blob' | 'base64' | 'json';
    height: number;
    width: number;
    done: EventEmitter<any>;
    upload: EventEmitter<any>;
    cleared: EventEmitter<any>;
    signatureData: EventEmitter<any>;
    isShown: boolean;
    croppedImage: any;
    imageChangedEvent: any;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    initPad(): void;
    clearPad(): void;
    applyPoints(): void;
    emitPoints(): void;
    emitPointsAndBlob(): void;
    emitBlob(): void;
    uploadSignImage(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SignaturePadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SignaturePadComponent, "ng-signature-pad", never, { "points": { "alias": "points"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "isSubmit": { "alias": "isSubmit"; "required": false; }; "Title": { "alias": "Title"; "required": false; }; "signData": { "alias": "signData"; "required": false; }; "penColor": { "alias": "penColor"; "required": false; }; "backgroundColor": { "alias": "backgroundColor"; "required": false; }; "showDoneButton": { "alias": "showDoneButton"; "required": false; }; "doneButtonText": { "alias": "doneButtonText"; "required": false; }; "doneButtonClass": { "alias": "doneButtonClass"; "required": false; }; "showClearButton": { "alias": "showClearButton"; "required": false; }; "clearButtonText": { "alias": "clearButtonText"; "required": false; }; "clearButtonClass": { "alias": "clearButtonClass"; "required": false; }; "showUploadButton": { "alias": "showUploadButton"; "required": false; }; "uploadButtonText": { "alias": "uploadButtonText"; "required": false; }; "uploadButtonClass": { "alias": "uploadButtonClass"; "required": false; }; "format": { "alias": "format"; "required": false; }; "height": { "alias": "height"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, { "pointsChange": "pointsChange"; "done": "done"; "upload": "upload"; "cleared": "cleared"; "signatureData": "signatureData"; }, never, never, false, never>;
}

declare class SignaturePadModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SignaturePadModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SignaturePadModule, [typeof SignaturePadComponent], [typeof i2.CommonModule], [typeof SignaturePadComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SignaturePadModule>;
}

interface SkillToolEditorData {
    name: string;
    providerName: string;
    stars: number;
    year: number | null;
    profileVisibility: boolean;
    notes: string;
}

declare class PreviewComponent {
    store: CredentialingStore;
    private fileService;
    private userSkillSetService;
    private userToolService;
    userDocumentService: UserDocumentService;
    userEducation: UserEducationService;
    private userDetailService;
    userExperienceService: UserExperienceService;
    private tokenService;
    private roleContextService;
    private providerService;
    private libConfig;
    providerId: string;
    useremail: any;
    readonly educationDegreeTypeOptions: string[];
    readonly monthPickerConfig: {
        minMode: string;
        adaptivePosition: boolean;
        showWeekNumbers: boolean;
        isAnimated: boolean;
        dateInputFormat: string;
        containerClass: string;
    };
    futureMaxDate: Date;
    maxDate: Date;
    companyForm: NgForm;
    options: {
        componentRestrictions: {
            country: string[];
        };
    };
    isResume: boolean;
    resumeModel: ResumeProfile | null;
    providerName: string;
    roleData: any;
    backToParent: EventEmitter<void>;
    fileData: any;
    model: any;
    awsFileUpdate: UpdateAwsFileModelModel[];
    fileName: string;
    fileChanged: boolean;
    isSavingWork: boolean;
    isSavingEducation: boolean;
    isSavingCertification: boolean;
    isSavingLicense: boolean;
    isSavingBasic: boolean;
    basicDetailsSaved: boolean;
    hasUserDetailData: boolean;
    isSavingSkill: boolean;
    isSavingTool: boolean;
    showBulkSkillConfirm: boolean;
    bulkSkillStars: number;
    bulkSkillYear: number | null;
    showBulkToolConfirm: boolean;
    bulkToolStars: number;
    bulkToolYear: number | null;
    private workConfirmAllQueue;
    private educationConfirmAllQueue;
    payloadUserId: any;
    payloadUserName: any;
    cloudfrontUrl: string;
    signatureFileId: any;
    signatureUrl: any;
    headshotFileName: string;
    headshotPreviewUrl: string | null;
    isHeadshotLoading: boolean;
    headshotFileId: string | null;
    headshotUrl: string | null;
    fileDataHeadshot: any;
    workExperienceServerIds: Record<number, string>;
    educationServerIds: Record<number, string>;
    certificationServerIds: Record<number, string>;
    licenseServerIds: Record<number, string>;
    skillServerIds: Record<number, string>;
    toolServerIds: Record<number, string>;
    workExperienceLocallySaved: Record<number, boolean>;
    educationLocallySaved: Record<number, boolean>;
    certificationLocallySaved: Record<number, boolean>;
    licenseLocallySaved: Record<number, boolean>;
    skillLocallySaved: Record<number, boolean>;
    toolLocallySaved: Record<number, boolean>;
    private readonly monthDateCache;
    private readonly uploadFolderBySection;
    resumeData: ResumeProfile | null;
    statusList: any[];
    isSavingCompany: boolean;
    isSavingProviderSetup: boolean;
    providerSetupError: string | null;
    showPopup: boolean;
    showBackConfirmPopup: boolean;
    showDashboardConfirmPopup: boolean;
    companyDetailsSaved: boolean;
    companyEditMode: boolean;
    companyDetails: i0.WritableSignal<CompanyDetails | null>;
    tempCompanyDetails: any;
    tempCompanyLogoUrl: string | null;
    fileDataCompany: any;
    fileNameCompany: any;
    isLogoLoading: boolean;
    logo: any;
    private provider;
    companyFormSubmitted: boolean;
    companyNameError: string | null;
    userViewRoles: ({
        name: string;
        value: string;
        img: string;
        selected: boolean;
        code: null;
        id: string;
        roleId: string;
    } | {
        name: string;
        value: string;
        img: string;
        selected: boolean;
        code: ProviderType;
        id: string;
        roleId: string;
    })[];
    constructor(store: CredentialingStore, fileService: FileService, userSkillSetService: UserSkillSetService, userToolService: UserToolService, userDocumentService: UserDocumentService, userEducation: UserEducationService, userDetailService: UserDetailService, userExperienceService: UserExperienceService, tokenService: TokenService, roleContextService: RoleContextService, providerService: ProvidersService, libConfig: LibraryConfig);
    email: any;
    expYears: number[];
    details: i0.WritableSignal<BasicDetails | undefined>;
    ngOnInit(): Promise<void>;
    experience: i0.Signal<WorkExperience$1[]>;
    educationList: i0.Signal<Education$1[]>;
    certs: i0.Signal<Certification$3[]>;
    licenses: i0.Signal<License$1[]>;
    skills: i0.Signal<string[]>;
    tools: i0.Signal<string[]>;
    private isBlank;
    private isBlankOrNull;
    sanitizePhone(value: string | null | undefined): string;
    getDigitCount(value: string | null | undefined): number;
    sanitizeZipCode(value: string | null | undefined): string;
    isMonthRangeInvalid(start: string | null | undefined, end: string | null | undefined): boolean;
    private compareMonth;
    private prefillSectionFieldsFromBasicDetails;
    private basicDetailsIssues;
    private workItemIssues;
    private educationItemIssues;
    private certificationItemIssues;
    private licenseItemIssues;
    private skillItemIssues;
    private toolItemIssues;
    basicIssues: i0.Signal<string[]>;
    basicSectionHasIssues: i0.Signal<boolean>;
    workIssuesByIndex: i0.Signal<string[][]>;
    educationIssuesByIndex: i0.Signal<string[][]>;
    certIssuesByIndex: i0.Signal<string[][]>;
    licenseIssuesByIndex: i0.Signal<string[][]>;
    skillIssuesByIndex: i0.Signal<string[][]>;
    toolIssuesByIndex: i0.Signal<string[][]>;
    skillFormIssues: i0.Signal<string[]>;
    toolFormIssues: i0.Signal<string[]>;
    workSectionHasIssues: i0.Signal<boolean>;
    educationSectionHasIssues: i0.Signal<boolean>;
    certificationsSectionHasIssues: i0.Signal<boolean>;
    licensesSectionHasIssues: i0.Signal<boolean>;
    skillsSectionHasIssues: i0.Signal<boolean>;
    toolsSectionHasIssues: i0.Signal<boolean>;
    workSectionHasUnsavedItems(): boolean;
    educationSectionHasUnsavedItems(): boolean;
    certificationSectionHasUnsavedItems(): boolean;
    licenseSectionHasUnsavedItems(): boolean;
    skillsSectionHasUnsavedItems(): boolean;
    toolsSectionHasUnsavedItems(): boolean;
    isAnyEditorOpen: i0.Signal<boolean>;
    canConfirmAndContinue(): boolean;
    get isProviderSetupFormComplete(): boolean;
    saveProviderSetup(): Promise<void>;
    expandedIndex: i0.WritableSignal<number>;
    toggleJob(index: number): void;
    private commitProfile;
    private appendToMainModel;
    private updateInMainModel;
    private toMonthInput;
    monthInputToDate(value: string | null | undefined): Date | null;
    private dateToMonthInput;
    setTempJobMonth(field: 'startDate' | 'endDate', value: Date | null | undefined): void;
    setTempCertificationMonth(field: 'issueDate' | 'expiryDate', value: Date | null | undefined): void;
    setTempLicenseMonth(field: 'issueDate' | 'expiryDate', value: Date | null | undefined): void;
    setTempEducationMonth(field: 'startDate' | 'endDate', value: Date | null | undefined): void;
    confirmAllCertifications(): Promise<void>;
    confirmAllLicenses(): Promise<void>;
    private buildSectionQuery;
    private buildSectionForUserQuery;
    private buildUserName;
    private getCreatedId;
    private getEntityId;
    private reindexServerIdsAfterDelete;
    private reindexSavedFlagsAfterDelete;
    private markItemSaved;
    hasUnsavedWorkItem(index: number): boolean;
    hasUnsavedEducationItem(index: number): boolean;
    hasUnsavedCertificationItem(index: number): boolean;
    hasUnsavedLicenseItem(index: number): boolean;
    hasUnsavedSkillItem(index: number): boolean;
    hasUnsavedToolItem(index: number): boolean;
    private mapSavedWorkToPreview;
    private mapSavedEducationToPreview;
    private mapSavedCertificationToPreview;
    private mapSavedLicenseToPreview;
    private normalizedText;
    private workSignature;
    private educationSignature;
    private certificationSignature;
    private licenseSignature;
    private mergeSavedAndCurrent;
    private ensureWorkServerId;
    private ensureEducationServerId;
    private ensureCertificationServerId;
    private ensureLicenseServerId;
    private ensureSkillServerId;
    private ensureToolServerId;
    private loadSavedSectionsFromApis;
    formatMonthYear(value: string | null | undefined): string;
    private confirmDelete;
    private jobEditor;
    isAddingJob(): boolean;
    editingJobIndex(): number | null;
    tempJob(): WorkExperience$1 | null;
    addJob(): void;
    startEditJob(jobIndex: number): void;
    cancelEditJob(): void;
    private advanceWorkConfirmQueue;
    confirmAllWork(): Promise<void>;
    saveEditJob(): Promise<void>;
    deleteJob(index: number): Promise<void>;
    updateTempResponsibilities(value: string): void;
    patchTempJob(patch: Partial<WorkExperience$1>): void;
    onWorkExperienceFileSelected(event: Event): void;
    setTempJobIsCurrent(isCurrent: boolean): void;
    private skillEditor;
    isSkillEditorOpen(): boolean;
    isAddingSkill(): boolean;
    editingSkillIndex(): number | null;
    skillForm(): SkillToolEditorData | null;
    patchSkillForm(patch: Partial<SkillToolEditorData>): void;
    openSkillEditor(index: number): void;
    addSkill(): void;
    closeSkillEditor(): void;
    setTempSkillStars(stars: number): void;
    saveSkillEditor(): Promise<void>;
    private reindexSkillMetaAfterDelete;
    deleteSkill(index: number): Promise<void>;
    private toolEditor;
    isToolEditorOpen(): boolean;
    isAddingTool(): boolean;
    editingToolIndex(): number | null;
    toolForm(): SkillToolEditorData | null;
    patchToolForm(patch: Partial<SkillToolEditorData>): void;
    openToolEditor(index: number): void;
    addTool(): void;
    closeToolEditor(): void;
    setTempToolStars(stars: number): void;
    confirmAllSkills(): Promise<void>;
    cancelBulkSkillConfirm(): void;
    applyBulkSkillConfirm(): Promise<void>;
    confirmAllTools(): Promise<void>;
    cancelBulkToolConfirm(): void;
    applyBulkToolConfirm(): Promise<void>;
    saveToolEditor(): Promise<void>;
    private reindexToolMetaAfterDelete;
    deleteTool(index: number): Promise<void>;
    private certificationEditor;
    isAddingCertification(): boolean;
    editingCertificationIndex(): number | null;
    tempCertification(): Certification$3 | null;
    private normalizeNullableString;
    private normalizeMonthInput;
    addCertification(): void;
    startEditCertification(index: number): void;
    cancelEditCertification(): void;
    patchTempCertification(patch: Partial<Certification$3>): void;
    onCertificationFileSelected(event: Event): void;
    saveCertificationEditor(): Promise<void>;
    deleteCertification(index: number): Promise<void>;
    private licenseEditor;
    isAddingLicense(): boolean;
    editingLicenseIndex(): number | null;
    tempLicense(): License$1 | null;
    addLicense(): void;
    startEditLicense(index: number): void;
    cancelEditLicense(): void;
    patchTempLicense(patch: Partial<License$1>): void;
    onLicenseFileSelected(event: Event): void;
    saveLicenseEditor(): Promise<void>;
    deleteLicense(index: number): Promise<void>;
    private educationEditor;
    isAddingEducation(): boolean;
    editingEducationIndex(): number | null;
    tempEducation(): Education$1 | null;
    addEducation(): void;
    startEditEducation(index: number): void;
    cancelEditEducation(): void;
    private advanceEducationConfirmQueue;
    confirmAllEducation(): Promise<void>;
    patchTempEducation(patch: Partial<Education$1>): void;
    onEducationFileSelected(event: Event): void;
    saveEducation(): Promise<void>;
    deleteEducation(index: number): Promise<void>;
    onBackClick(): void;
    stayOnPreview(): void;
    goToDashboard(): Promise<void>;
    proceedBack(): void;
    onGoToDashboardClick(): void;
    cancelDashboardRedirect(): void;
    tempProfile: BasicDetails;
    isEditMode: i0.WritableSignal<boolean>;
    toggleEdit(): void;
    cancel(): void;
    save(): Promise<void>;
    private persistWorkExperience;
    private persistEducation;
    private persistCertification;
    private persistLicense;
    private persistSkill;
    private batchPersistSkills;
    private persistTool;
    private batchPersistTools;
    private saveAWSFile;
    uploadHeadshotImage(event: any): void;
    private saveAWSHeadShot;
    selectFile(event: any): void;
    private toAbsoluteFileUrl;
    private revokeObjectUrl;
    previewSelectedFile(item: any): void;
    private get isProviderRole();
    get hasRoleContextUserId(): boolean;
    private get effectiveProviderName();
    private get effectiveTargetProviderId();
    mapBasicDetailsToUserDetail(data: any): {
        providerName: string;
        targetProviderId: string | null;
        UserRoleId: any;
        userDetail: {
            userBio: any;
            firstName: any;
            lastName: any;
            email: any;
            address1: any;
            address2: string;
            city: any;
            state: any;
            zipcode: any;
            county: string;
            country: any;
            latitude: null;
            longitude: null;
            yearsActive: number;
            isInitialSetupCompleted: boolean;
            id: any;
            phoneNumber: any;
            yearsOfExperince: any;
            userJobTitle: any[];
            timeZone: string;
            datePattern: string;
            dateTimePattern: string;
            timePattern: string;
            signatureFileId: any;
            signatureUrl: any;
            headshotFileId: string | null;
            headshotUrl: string | null;
        };
    };
    mapCompanyDetail(data: any): {
        providerName: string;
        targetProviderId: string | null;
        UserRoleId: any;
        userDetail: {
            userBio: any;
            firstName: any;
            lastName: any;
            email: any;
            address1: any;
            address2: string;
            city: any;
            state: any;
            zipcode: any;
            county: string;
            country: any;
            latitude: null;
            longitude: null;
            yearsActive: number;
            isInitialSetupCompleted: boolean;
            id: any;
            phoneNumber: any;
            yearsOfExperince: any;
            userJobTitle: any[];
            timeZone: string;
            datePattern: string;
            dateTimePattern: string;
            timePattern: string;
            signatureFileId: any;
            signatureUrl: any;
            headshotFileId: string | null;
            headshotUrl: string | null;
        };
    };
    mapBasicDetailsDashboard(data: any): {
        providerName: string;
        targetProviderId: string;
        UserRoleId: any;
        userDetail: {
            userBio: any;
            firstName: any;
            lastName: any;
            email: any;
            address1: any;
            address2: string;
            city: any;
            state: any;
            zipcode: any;
            county: string;
            country: any;
            latitude: null;
            longitude: null;
            yearsActive: number;
            isInitialSetupCompleted: boolean;
            id: any;
            phoneNumber: any;
            yearsOfExperince: any;
            userJobTitle: any[];
            timeZone: string;
            datePattern: string;
            dateTimePattern: string;
            timePattern: string;
        };
    };
    private mapSavedBasicDetailsToPreview;
    private hasUserDetailPayload;
    mapWorkExperience(data: any): any;
    mapEducation(data: any): any;
    mapCertifications(data: any): any;
    mapLicenses(data: any): any;
    mapSkills(data: any): any;
    mapTools(data: any): any;
    formatDate(date: string): string | null;
    workActionLabel(index: number | null): string;
    educationActionLabel(index: number | null): string;
    certificationActionLabel(index: number | null): string;
    licenseActionLabel(index: number | null): string;
    skillActionLabel(index: number | null): string;
    toolActionLabel(index: number | null): string;
    isCompanyEditMode(): boolean;
    toggleCompanyEdit(): void;
    cancelCompanyEdit(): void;
    companyLogoUrl(): string | null;
    uploadCompanyImage(event: any): void;
    saveAWSCompanyLogo(): Promise<void>;
    bindProviderDetails(): {
        userName: string;
        providerType: ProviderType;
        providerName: any;
        address1: any;
        city: any;
        state: any;
        zipcode: any;
        country: any;
        county: any;
        phoneNumber: any;
        userAddress1: string | undefined;
        userAddress2: string;
        userCity: string | undefined;
        userState: string | undefined;
        userZipcode: string | undefined;
        userCounty: string;
        userCountry: string | undefined;
        userMobile: string | undefined;
        userEmailId: string | undefined;
        logoId: any;
        logoFileName: any;
        logoUrl: any;
    };
    saveProvider(): Promise<void>;
    validateCompanyDetails(): boolean;
    saveCompanyDetails(): Promise<void>;
    AddressChangeCompany(address: any): void;
    phoneMask(event: Event, type: 'profile' | 'company'): void;
    formatPhone(phone: string): string;
    AddressChangeUser(address: any): void;
    allowOnlyNumbers(event: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PreviewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PreviewComponent, "app-preview", never, { "providerId": { "alias": "providerId"; "required": false; }; "isResume": { "alias": "isResume"; "required": false; }; "resumeModel": { "alias": "resumeModel"; "required": false; }; "providerName": { "alias": "providerName"; "required": false; }; "roleData": { "alias": "roleData"; "required": false; }; "cloudfrontUrl": { "alias": "cloudfrontUrl"; "required": false; }; "signatureFileId": { "alias": "signatureFileId"; "required": false; }; "signatureUrl": { "alias": "signatureUrl"; "required": false; }; }, { "backToParent": "backToParent"; }, never, never, true, never>;
}

declare class AssetUrlsService {
    private roleContextService;
    private readonly base;
    constructor(roleContextService: RoleContextService);
    resolve(path?: string | null): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AssetUrlsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AssetUrlsService>;
}

declare class AssetUrlsPipe {
    private asset;
    constructor(asset: AssetUrlsService);
    transform(value: string | null | undefined): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<AssetUrlsPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<AssetUrlsPipe, "assetUrls", false>;
}

interface State {
    stateCode: string;
    stateName: string;
}
declare class StateService {
    private states;
    getStateName(code: string): string;
    getStates(): State[];
    static ɵfac: i0.ɵɵFactoryDeclaration<StateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StateService>;
}

declare class StateNamePipe implements PipeTransform {
    private stateService;
    constructor(stateService: StateService);
    transform(code: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<StateNamePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<StateNamePipe, "stateName", false>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StateNamePipe>;
}

declare class CommonPipesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CommonPipesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CommonPipesModule, [typeof AssetUrlsPipe, typeof StateNamePipe], [typeof i2.CommonModule], [typeof i2.CommonModule, typeof AssetUrlsPipe, typeof StateNamePipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CommonPipesModule>;
}

declare class InitialProcessModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<InitialProcessModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<InitialProcessModule, [typeof InitialProcessComponent, typeof TermsConditionsComponent, typeof PrivacyPolicyComponent, typeof CredentialingComponent, typeof StepperComponent, typeof EducationComponent, typeof CertificationComponent, typeof SkillsComponent, typeof LicensesComponent, typeof ToolsComponent, typeof RoleSelectComponent, typeof Step2CoverageComponent, typeof WorkexperienceComponent, typeof FirstComponent], [typeof i2.CommonModule, typeof _angular_forms.FormsModule, typeof _angular_forms.ReactiveFormsModule, typeof i17.RouterModule, typeof UsMapModule, typeof i19.NgSelectModule, typeof i20.BsDatepickerModule, typeof Ng2LoadingSpinnerModule, typeof LoaderModule, typeof CustomPipesModule, typeof NgxStarsModule, typeof i25.TooltipModule, typeof i26.TabsModule, typeof i27.AccordionModule, typeof GooglePlaceModule, typeof i29.GoogleMapsModule, typeof TextMaskModule, typeof SignaturePadModule, typeof PreviewComponent, typeof CommonPipesModule], [typeof InitialProcessComponent, typeof TermsConditionsComponent, typeof PrivacyPolicyComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<InitialProcessModule>;
}

declare class MustChangePasswordComponent {
    private fb;
    private auth;
    userService: UserDetailService;
    private tokenService;
    private roleContextService;
    private authLogoutService;
    changePasswordForm: FormGroup;
    submitted: boolean;
    isLoading: boolean;
    errorMessage: string;
    constructor(fb: FormBuilder, auth: AuthService, userService: UserDetailService, tokenService: TokenService, roleContextService: RoleContextService, authLogoutService: AuthLogoutService);
    get f(): {
        [key: string]: AbstractControl;
    };
    passwordMatchValidator(form: AbstractControl): {
        mismatch: boolean;
    } | null;
    onSubmit(): Promise<void>;
    logout(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MustChangePasswordComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MustChangePasswordComponent, "app-must-change-password", never, {}, {}, never, never, true, never>;
}

declare class VerifyEmailComponent implements OnInit, OnDestroy {
    private libConfig;
    userService: UserDetailService;
    private authLogoutService;
    private tokenService;
    private router;
    private auth;
    loading: boolean;
    successMessage: boolean;
    errorMessage: boolean;
    pageLoader: boolean;
    cooldown: number;
    interval: any;
    constructor(libConfig: LibraryConfig, userService: UserDetailService, authLogoutService: AuthLogoutService, tokenService: TokenService, router: Router, auth: AuthService);
    ngOnInit(): Promise<void>;
    resendVerification(): Promise<void>;
    startCooldown(): void;
    logout(): Promise<void>;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VerifyEmailComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VerifyEmailComponent, "app-verify-email", never, {}, {}, never, never, true, never>;
}

export { AppType, InitialProcessComponent, InitialProcessModule, LIBRARY_CONFIG, MustChangePasswordComponent, PreviewComponent, PrivacyPolicyComponent, TermsConditionsComponent, VerifyEmailComponent };
export type { LibraryConfig };