@arkasuryawan/gp-interfaces/dist/index.d.ts

Geonet Properties Data Interfaces

interface GooglePlacesInterface extends AuditInterface {
    business_status?: string;
    geometry: {
        location: {
            lat: number;
            lng: number;
        };
        viewport: {
            northeast: {
                lat: number;
                lng: number;
            };
            southwest: {
                lat: number;
                lng: number;
            };
        };
    };
    icon: string;
    icon_background_color: string;
    icon_mask_base_uri: string;
    name: string;
    opening_hours?: any;
    photos: [
        {
            height: 1252;
            html_attributions: string[];
            photo_reference: string;
            width: 1600;
        }
    ];
    place_id: string;
    plus_code: any;
    reference: string;
    rating?: number;
    scope: string;
    types: string[];
    vicinity: string;
    user_ratings_total?: string[];
}
interface ProjectGooglePlacesInterface extends AuditInterface {
    projectId: string;
    project: ProjectInterface;
    googlePlacesId: string;
    googlePlaces: GooglePlacesInterface;
}

declare type TenantAggregatorRequestType = "Requesting" | "Approved" | "Rejected";
interface TenantInterface extends AuditInterface {
    legalName?: string;
    name?: string;
    status?: "Active" | "Archived";
    /**
     * @deprecated The method should not be used move to `tenantTypes`
     */
    tenantType?: TenantType;
    /**
     * @abstract New field moving from `tenantType`
     */
    bannerURL?: string;
    thumbnailURL?: string;
    externalId?: string;
    slug?: string;
    shortDescription?: string;
    description?: string;
    address?: AddressInterface[];
    website?: string;
    email?: string;
    phone?: string;
    phone2?: string;
    legalName_lower?: string;
    name_lower?: string;
    website_lower?: string;
    email_lower?: string;
    accessToken?: string;
    referenceCode?: string;
    aggregatorIds?: string[];
    aggregators?: TenantInterface[];
}
interface TenantAggregatorRequestInterface extends AuditInterface {
    agencyId: string;
    agency?: TenantInterface;
    aggregatorId: string;
    aggregator?: TenantInterface;
    status: TenantAggregatorRequestType;
}
interface TenantExcludeProjectInterface extends AuditInterface {
    tenantId: string;
    projectId: string;
}
interface TenantProjectInterface extends AuditInterface {
    tenantId: string;
    tenant: TenantInterface;
    projectId: string;
    project: ProjectInterface;
    projectLotIds: string[];
    projectLots: ProjectLotInterface[];
}

interface OfficesInterface extends AuditInterface {
    legalName?: string;
    name?: string;
    status?: "Active" | "Archived";
    externalId?: string;
    address?: AddressInterface[];
    website?: string;
    email?: string;
    phone?: string;
    phone2?: string;
}

interface AgentInterface extends AuditInterface {
    uid?: string;
    fullName: string;
    firstName: string;
    lastName?: string;
    mobile?: string;
    phone?: string;
    image: string;
    email: string;
    dateOfBirth?: string;
    licenceNumber?: string;
    licenceExpiryDate?: string;
    address?: AddressInterface;
    OfficeId?: string;
    office?: OfficesInterface;
    jobTitle?: string;
    specialistAreas?: string[];
    awards?: string[];
    employeeType?: EmployeeType;
    /**
     * @deprecated The method should not be used move to `tenantTypes`
     */
    tenantType?: TenantType;
    /**
     * @abstract New field moving from `tenantType`
     */
    tenantId?: string;
    tenant?: TenantInterface;
    aggregatorIds?: string[];
    aggregators?: TenantInterface[];
    profile?: string;
    profileVideo?: string;
    startDate?: string;
    contractValedDate?: string;
    showOnWeb: boolean;
    status: "Active" | "Archived";
    customToken?: string;
    facebookUrl?: string;
    instagramUrl?: string;
    linkedInUrl?: string;
    twitterUrl?: string;
    keyword?: string;
    callCalenderUrl?: string;
    agentLanguages?: string[];
    deviceToken?: string[];
    groupId?: string;
    group?: GroupInterface;
    /**
    * @abstract just for JWT
    */
    groupAccess?: GroupAccessInterface[];
}
interface GroupInterface extends AuditInterface {
    name: string;
    description: string;
    tenantType: TenantType;
}
interface GroupAccessInterface extends AuditInterface {
    groupId: string;
    group: GroupInterface;
    menu: string;
    view: boolean;
    craete: boolean;
    update: boolean;
    delete: boolean;
    exceptField: string[];
}

interface BlogInterface extends AuditInterface {
    title?: string;
    slug?: string;
    shortDescription?: string;
    description?: string;
    categoryIds?: string[];
    categories?: CategoryInterface[];
    status?: StatusType;
    blogDisplay?: BlogDisplay;
    bannerURL?: string;
    thumbnailURL?: string;
    videoUrl?: string;
    author?: string;
}

interface AdditionalInformationContact {
    name: string;
    value: string;
}
interface ContactInterface extends AuditInterface {
    firstName: string;
    lastName: string;
    phoneNumber: string;
    mobileNumber?: string;
    email: string;
    source?: SourceList;
    address: AddressInterface;
    canSeeContactAgentIds?: string[];
    canSeeContactAgents?: AgentInterface[];
    belongsToAgentId?: string;
    belongsToAgent?: AgentInterface;
    image: string;
    subscribed: string[];
    status: "Active" | "Archived";
}

interface AppraisalInterface extends ProspectInterface {
    displayName: string;
    displayName_lower: string;
    description?: string;
    description_lower?: string;
    agentIds?: string[];
    agents?: AgentInterface[];
    bedrooms?: number;
    bathrooms?: number;
    ensuites?: number;
    toilets?: number;
    frontage?: number;
    rearDepth?: number;
    landSize?: number;
    livingAreas?: number;
    buildingSize?: number;
    garageSpaces?: number;
    carportSpaces?: number;
    openCarSpaces?: number;
    outDoorFeatures?: string[];
    inDoorFeatures?: string[];
    allowances?: string[];
    expectedPrice?: number;
    rentalEstimate?: number;
    minPrice: number;
    maxPrice: number;
    note: string;
    note_lower: string;
    occupancyTitle: "Whole Building" | "Parcial Building";
    prospectId?: string;
    prospect?: ProspectInterface;
    appraisalDate?: string;
    appraisalDocuments?: string[];
    appraisalDocumentsWithMetaData?: MetaDataFileInterface[];
    videoUrls?: string[];
    onlineTourUrl?: string;
    documents?: string[];
    documentsWithMetaData?: MetaDataFileInterface[];
    images?: string[];
    thumbnails?: {
        small: string;
        medium: string;
        large: string;
    }[];
    imagesMetaDataFile?: MetaDataFileInterface[];
    floorPlans?: string[];
    floorPlansMetaDataFile?: MetaDataFileInterface[];
}

declare type ListingType = "Sale" | "Lease" | "Sale & Lease";
declare type ListingStatus = "Appraisal" | "Presentation" | "Pending" | "Available" | "Conditional" | "Unconditional" | "Settled" | "Leased" | "Withdrawn" | "Archived";
declare type MarketingStatusType = "Not Listed" | "Available" | "Under Contract" | "Sold" | "Leased" | "Available Under Contract";
declare type PropertyType = "Residential" | "Rural" | "Commercial" | "Holiday" | "Business";
declare type PropertyCategory = "Apartment" | "Development" | "Factory" | "House" | "Land" | "Office" | "Semi/Duplex" | "Retail" | "Studio" | "Block Of Units" | "Terrace" | "Townhouse" | "Unit" | "Villa" | "Warehouse" | "Showroom" | "Cropping" | "Dairy" | "Farmlet" | "Horticulture" | "Lifestyle" | "Livestock" | "Viticulture" | "Mixed Farming" | "Acreage" | "Hotel/Leisure" | "Medical/Consulting" | "Other" | "BackpackerHostel" | "BedAndBreakfast" | "Campground" | "CaravanHolidayPark" | "ExecutiveRental" | "FarmStay" | "Flat" | "HouseBoat" | "Lodge" | "Motel" | "Resort" | "Retreat" | "SelfContainedCottage" | "ServicedApartment" | "Car Space" | "Accommodation/Tourism" | "Automotive" | "Beauty/Health" | "Food/Hospitality" | "Import/Export/Whole" | "Services" | "Education/Training" | "Franchise" | "Home/Garden" | "Industrial/Manufacturing" | "Leisure/Entertainment" | "Professional" | "Rural" | "Transport/Distribution";
declare type OrederBy = "soldPrice" | "searchPrice" | "address" | "lastModified" | "firstCreated" | "listedDate" | "nextInspectionDate" | "onMarketDate" | "auctionDate" | "soldDate" | "appraisalDate" | "presentationDate" | "status" | "marketingStatus" | "leasedDate";
declare type AuthorityType = "Exclusive" | "Multi List" | "Conjunctional" | "Open" | "Sale by Negotiation";
interface ListingParam {
    id?: string;
    page: number;
    limit: number;
    orderBy?: string;
    include?: string;
    order?: "ASC" | "DESC";
    filter?: ListingInterface;
    select?: string;
}
interface ListingInterface extends AppraisalInterface {
    fullAddressDisplay: boolean;
    addressDisplay?: string;
    marketingStatus: MarketingStatusType;
    authority: AuthorityType;
    listingDate?: string;
    listingExpiryDate?: string;
    priceDisplay?: string;
    price: number;
}

interface PropectSearchParams {
    id?: string;
    page: number;
    limit: number;
    orderBy?: string;
    include?: string;
    order?: "ASC" | "DESC";
    filter: ProspectInterface;
    select?: string;
}
interface ProspectInterface extends AuditInterface, AddressInterface {
    propertyType: PropertyType;
    propertyCategory: PropertyCategory;
    listingType: ListingType;
    interestLevel: "HOT" | "WARM" | "COLD";
    status: "Active" | "Archived";
    canSeeContactAgentIds?: string[];
    canSeeContactAgents?: AgentInterface[];
    belongsToAgentId?: string;
    belongsToAgent?: AgentInterface;
    officeId?: string;
    office?: OfficesInterface;
    ownerIds?: string[];
    owners?: ContactInterface[];
    tenantIds?: string[];
    tenants?: ContactInterface[];
    listingId?: string;
    listing?: ListingInterface;
    appraisalId?: string;
    appraisal?: AppraisalInterface;
}

interface PipelineInterface extends AuditInterface {
    _id?: string;
    name: string;
    note?: string;
    name_lower?: string;
    note_lower?: string;
    status?: "Active" | "Archived";
    pipelineFlowIds?: string[];
    pipelineFlows?: PipelineFlowInterface[];
    officeId?: string;
    office?: OfficesInterface;
}
interface PipelineFlowInterface extends AuditInterface {
    _id?: string;
    pipeLineId: string;
    pipeline?: PipelineInterface;
    name: string;
    name_lower?: string;
    status?: "Active" | "Archived";
    leadsIds?: string[];
    leads?: LeadsInterface[];
    order?: number;
}
interface LeadsInterface extends AuditInterface {
    _id?: string;
    contactId?: string;
    contact?: ContactInterface;
    pipelineId?: string;
    pipelineFlowId?: string;
    pipelineFlow?: PipelineFlowInterface;
    pipeLineSource?: string;
    agentIds?: string[];
    agents?: AgentInterface[];
    note?: string;
    note_lower?: string;
    prospectIds?: string[];
    prospects?: ProspectInterface[];
    listingsIds?: string[];
    listings?: ListingInterface[];
    appraisalIds?: string[];
    appraisals?: AppraisalInterface[];
    status?: "Active" | "Archived";
}

interface TAAddress {
    street1: string;
    street2: string;
    city: string;
    state: string;
    country: string;
    postalcode: string;
    address_string: string;
    phone: string;
    latitude: number;
    longitude: number;
}
interface TARankingData {
    geo_location_id: number;
    ranking_string: string;
    geo_location_name: string;
    ranking_out_of: number;
}
interface TAAncestor {
    abbrv: string;
    level: string;
    name: string;
    location_id: number;
    latitude: number;
    longitude: number;
    timezone: string;
    email: string;
    phone: string;
    website: string;
    write_review: string;
    ranking_data: TARankingData;
    ranking: number;
}
interface TAAward {
    award_type: string;
    year: number;
    images: {
        tiny: string;
        small: string;
        large: string;
    };
    categories: string[];
    display_name: string;
}
interface TALocalize {
    name: string;
    localized_name: string;
    rating_image_url?: string;
    value?: string;
}
interface TALocation extends AuditInterface {
    location_id: number;
    name: string;
    description?: string;
    web_url?: string;
    address_obj: TAAddress;
    ancestors?: TAAncestor[];
    rating_image_url?: string;
    num_reviews?: string;
    review_rating_count?: {
        [code: string]: string;
    };
    subratings?: {
        [code: string]: TALocalize;
    };
    photo_count?: number;
    see_all_photos?: string;
    price_level?: string;
    hours?: {
        periods: {
            open: {
                day: number;
                time: string;
            };
            close: {
                day: number;
                time: string;
            };
        }[];
        weekday_text: string[];
        subcategory: TALocalize;
    };
    amenities?: string[];
    features?: string[];
    cuisine?: TALocalize[];
    parent_brand?: string;
    brand?: string;
    category?: TALocalize;
    subcategory?: TALocalize[];
    groups?: TALocalize[];
    styles?: string[];
    neighborhood_info?: TALocation[];
    trip_types?: TALocalize[];
    awards?: TAAward[];
    distance?: string;
    rating?: string;
    bearing?: string;
}

declare type ProjectStatus = "DRAFT" | "AVAILABLE" | "NOTAVAILABLE" | "DELETED" | "LEASED" | "BOOKED" | "SOLD" | "HOLD" | "CONTRACT" | "PARTIAL";
declare const ProjectStatusOptions: string[];
declare type ProjectType = "Apartment" | "House & Land" | "Land" | "Office" | "Semi/Duplex" | "Block Of Units" | "Townhouse" | "Unit" | "Villa" | "Warehouse" | "Hotel/Leisure" | "Other" | "Motel" | "Resort" | "Retreat" | "Rural";
declare type CurrencyId = "EUR" | "SGD" | "GBP" | "AUD" | "USD" | "IDR" | "THB";
declare const CurrencyIdOptions: string[];
declare type ProjectStatusType = "Off The Plan" | "Completed" | "Under Construction";
declare const ProjectStatusTypeOptions: string[];
interface AdditionalInformation {
    icon: string;
    headline: string;
    content: string;
}
interface AdditionalOption {
    icon: string;
    headline: string;
    content: string;
    priceType: string;
    price: number;
}
interface RentalRevenueEstimateInterface {
    headline: string;
    price: number;
    occupancy: number;
    rate: number;
    percentageCost: number;
    investmentTime: number;
}
interface ProjectSummaryInterface {
    unitAvailable: number;
    sold: number;
    minPrice: number;
    bed: {
        min: number;
        max: number;
    };
    bath: {
        min: number;
        max: number;
    };
    garage: {
        min: number;
        max: number;
    };
    area: {
        min: number;
        max: number;
    };
}
interface ProjectMainInformation extends AuditInterface {
    /**
     *
     */
    status: ProjectStatus | string[];
    headLine: string;
    shortDescription: string;
    content: string;
    featured: boolean;
    hideOnWebsite: boolean;
    address: string;
    addressCordinat: Cordinat | Cordinat[];
    suburbId: string;
    suburb: SuburbInterface | string;
    suburbName: string;
    stateId: string;
    state: StateInterface | string;
    stateName: string;
    countryId: string;
    country: CountryInterface | string;
    countryName: string;
    region: RegionInterface | string;
    regionId: string;
    regionName: string;
    postcode: string;
    additionalInformation?: AdditionalInformation[];
    taxIncluded?: boolean;
    tax?: number;
    tenantIds?: string[];
    tenants?: TenantInterface[];
    aggregatorIds?: string[];
    aggregators?: TenantInterface[];
    developerId?: string;
    developerDetail?: TenantInterface;
    developer?: TenantInterface;
    /**
     * @deprecated The method should not be used move to `projectTypeIds`
     */
    projectTypeId: string;
    /**
     * @deprecated The method should not be used move to `projectTypes`
     */
    projectType: ProjectTypeInterface;
    /**
     * @abstract New field moving from `projectTypeId`
     */
    projectTypeIds?: string[];
    /**
   * @abstract New field moving from `projectTypes`
   */
    projectTypes?: ProjectTypeInterface[];
    autdoorFeature: string[];
    indoorFeatures: string[];
}
interface ProjectImageFileAndOtherInfo extends ProjectMainInformation {
    videoUrl: string[];
    onlineTourUrl: string[];
    images: string[];
    interior: string[];
    exterior: string[];
    floorPlans: string[] | MetaDataFileInterface[];
    brochure: string[] | MetaDataFileInterface[];
    collateral: string[] | MetaDataFileInterface[];
    specifications: string[] | MetaDataFileInterface[];
    areaGuide: string;
    presentation: string;
    news: string[];
    podcast: string[];
    webinar: string;
    threesixty: string;
}
interface ProjectLotMainInformation extends ProjectImageFileAndOtherInfo {
    projectId: string;
    project: ProjectInterface;
    scheme: string;
    aspect: string;
    guarantee: string;
    level?: string;
    lot?: string;
    bed?: number;
    bath?: number;
    garage: number;
    internal: number;
    external: number;
    total: number;
    living: number;
    /**
     * @deprecated The method should not be used
     */
    type: string;
    price: number;
    /**
     * @abstract new field moving from developer
     */
    builder: string;
}
interface ProjectInterface extends ProjectImageFileAndOtherInfo {
    /**
     * @deprecated The method should not be used
     */
    type: ProjectType;
    /**
     * @abstract Image URl
     */
    sellingPoint: string;
    url: string;
    landingUrl: string;
    currency: CurrencyId;
    preSaleType: "Percentage" | "Fix Price";
    preSalePercentage?: number;
    preSalePrice?: number;
    percentageDeposit: number;
    /**
     * @deprecated The method should not be used
     */
    aboutProject: string;
    /**
     * @deprecated The method should not be used
     */
    step1?: string;
    /**
     * @deprecated The method should not be used
     */
    step2?: string;
    /**
     * @deprecated The method should not be used
     */
    step3?: string;
    /**
     * @deprecated The method should not be used
     */
    step4?: string;
    /**
     * @deprecated The method should not be used
     */
    blogIds?: string[];
    /**
     * @deprecated The method should not be used
     */
    blogs?: BlogInterface[];
    projectStatus?: ProjectStatusType;
    totalUnit?: number;
    startDate?: string;
    completionDate?: string;
    /**
     * @deprecated The method should not be used move to `projectlot`
     */
    variationTitle: string;
    /**
     * @deprecated The method should not be used will be move to `projectvariance`
     */
    variationPricing: "ADD" | "REPLACE" | "MULTIPLE" | "DEVIDE";
    rentalRevenueEstimate?: RentalRevenueEstimateInterface[];
    /**
     * @abstract when `true` if sold ? no information on front end
     */
    hidePriceOnSold?: boolean;
    summary?: ProjectSummaryInterface;
    /**
     * @abstract New field for summary by `proejctid`
     */
    summaryByProjectTypeIds?: {
        [projectTypeId: string]: ProjectSummaryInterface;
    };
    /**
     * @abstract Interfce only not for data to model
     * */
    searchPrice?: number;
    searchPriceMin?: number;
    searchPriceMax?: number;
    /**
     * @abstract New field for summary by proejctid
     */
    projectImageFileAndOtherInfoByTenants: {
        [tenantId: string]: ProjectImageFileAndOtherInfo;
    };
}
interface LotVariancesInterface {
    projectLotVarianceId: string;
    projectLotVariance: ProjectLotVarianceInterface;
    status: ProjectStatus;
    price: number;
    landPrice: number;
    housePrice: number;
    salesPackNumber: string;
    availabilityStock: number;
    additionalInformation?: AdditionalInformation[];
    additionalConst?: number;
    projectTypeId: string;
    projectType?: ProjectTypeInterface;
    variationPricing?: "ADD" | "REPLACE" | "MULTIPLE" | "DEVIDE";
}
interface ProjectLotInterface extends ProjectLotMainInformation {
    /**
     *@abstract moving from `Projects`
     */
    variationTitle: string;
    /**
    * @deprecated The method should not be used move to `variances`
    */
    projectLotVarianceIds?: string[];
    /**
    * @deprecated The method should not be used move to `variances`
    */
    projectLotVariances?: ProjectLotVarianceInterface[];
    variances?: LotVariancesInterface[];
    city: string;
    estate: string;
    landPrice: number;
    housePrice: number;
    salesPackNumber: string;
    landRegistration: string;
    stockType: "NORMAL" | "PARTIAL" | "FRACTIONAL";
    /**
     * Default availability stock is 1
     * when sold on variance availability stock  0-1 (100%)
     */
    availabilityStock: number;
    projectImageFileAndOtherInfoByTenants: {
        [tenantId: string]: ProjectImageFileAndOtherInfo;
    };
}
interface ProjectLotVarianceInterface extends ProjectLotMainInformation {
    variationPricing: "ADD" | "REPLACE" | "MULTIPLE" | "DEVIDE";
    projectImageFileAndOtherInfoByTenants: {
        [tenantId: string]: ProjectImageFileAndOtherInfo;
    };
    additionalOptions: AdditionalOption[];
    projectTypeId: string;
    projectType: ProjectTypeInterface;
}
interface ProjectRequestInterface extends AuditInterface {
    projectId: string;
    project?: ProjectInterface;
    agencyId: string;
    agency?: TenantInterface;
    developerId: string;
    developer?: TenantInterface;
    aggregatorId: string;
    aggregator?: TenantInterface;
}
/**
 * @deprecated The method should not be used
 */
interface ProjectTripadvisorInterface extends AuditInterface {
    projectId: string;
    project: ProjectInterface;
    tripadvisorId: string;
    tripadvisor: TALocation;
    distance?: string;
    bearing?: string;
}

interface UserInterface extends AuditInterface {
    uid: string;
    name?: string;
    fullname?: string;
    displayName?: string;
    firstName?: string;
    lastName?: string;
    email?: string;
    email_verified?: boolean;
    emailVerified?: boolean;
    phoneNumber?: string;
    isAnonymous?: boolean;
    photoURL?: string;
    address?: AddressInterface;
    status: StatusType;
    validThrough?: string;
    slug?: string;
    birthDay?: string;
    nationality?: string;
    socialMedia?: {
        [code: string]: string;
    };
    wishlist?: string[];
}
interface UserWishlistInterface extends AuditInterface {
    uid: string;
    userId: string;
    user: UserInterface;
    projectId: string;
    Project: ProjectInterface;
}

interface TestimonialInterface extends AuditInterface {
    imageUrl: string;
    headline: string;
    description: string;
    user: UserInterface;
}

interface TokenData {
    token: string;
    expiresIn: number;
}
interface DataStoredInToken {
    _id: string;
}

declare type NotificationType = "NEW" | "READED";
interface NotificationInterface extends AuditInterface {
    headline?: string;
    description?: string;
    link?: string;
    userIdReaded?: string[];
    status?: string;
    type?: string;
    to?: {
        type: "USER" | "TENANT";
        id: string;
    }[];
}

interface MenuType {
    name: any;
    url: string;
    subItems?: MenuType[];
    class?: string;
    col?: number;
}
interface WhiteLabelInterface extends AuditInterface {
    logo: string;
    cssRoot: string;
    menu: MenuType[];
    footer: string;
    type: "MULTI PROJECTS" | "SINGLE PROJECT";
    accessToken: string;
    domainName: string;
    proejctUrl?: string;
    favicon?: string;
    metaTitle?: string;
    metaDescription?: string;
    keyword?: string;
    bannerUrl?: string;
    metaImage?: string;
}

declare enum TransactionType {
    "EOI" = 0,
    "HOLD" = 1,
    "CONTRACT" = 2,
    "DEPOSIT" = 3,
    "DEPOSIT RETURNED" = 4,
    "SOLD" = 5
}
interface TransactionInterface extends AuditInterface {
    id: string;
    projectId: string;
    project: ProjectInterface;
    lotId: string;
    lot: ProjectLotInterface;
    lotVarianceId?: string;
    lotVariance?: ProjectLotVarianceInterface;
    lastStatus: TransactionType;
    whiteLabelId?: string;
    whiteLabel?: WhiteLabelInterface;
    description?: string;
    clientId: string;
    client: ContactInterface;
    price: number;
    deposit: number;
    currency: CurrencyId;
}
interface TransactionDetailInterface extends AuditInterface {
    id: string;
    transactionID: string;
    transaction: TransactionInterface;
    type: TransactionType;
    description?: string;
    exporeDate?: string;
}

declare type PermissionTypeEnum = "EVERYONE" | "SELECT" | "EXCLUSIVE";
declare type SourceList = "Website" | "Facebook" | "Instagram" | "Phone-in" | "Newspaper" | "Wolk-in" | "Door Knoking" | "Other";
declare type EmployeeType = "Administrator" | "Director" | "Personal Sisten" | "Office Admin" | "Agent Repesentative" | "Property Management" | "Sales Repesentative" | "Inactive";
declare const EmployeeTypeData: string[];
declare type TenantType = "Developer" | "Agency" | "Geonet" | "Aggregator" | "M2";
declare type BlogDisplay = "APPS" | "WEBSITE" | "BOTH";
declare type StatusType = "Active" | "Archived";
declare type EditorState = "ADD" | "DELETE" | "UPDATE" | "VIEW";

interface Cordinat {
    lat: number;
    lng: number;
}
interface CategoryInterface extends AuditInterface {
    name?: string;
    shortDescription?: string;
    description?: string;
    slug?: string;
    parentCategoryId?: string;
    parentCategory?: CategoryInterface;
    bannerURL?: string;
    thumbnailURL?: string;
    status?: StatusType;
}
declare const PipeLineFlowData: string[];
declare const SourceListData: string[];
interface GroupRole {
    code: EmployeeType;
    role: string;
    allow: boolean;
}
declare type agentLanguage = "English" | "Bahasa" | "French" | "Mandarin";
declare const agentLanguageOption: string[];
declare const PropertyTypeData: string[];
declare const ProductCategoryData: string[];
declare const SubscribedOptions: string[];
interface MetaDataFileInterface {
    name: string;
    url: string;
    fileType: string;
}
interface AuditInterface {
    _id?: string;
    _ids?: string;
    featured?: boolean;
    hideOnWebsite?: boolean;
    extraFilter?: any;
    keyword?: string;
    order?: number;
    createdAt: string;
    createdBy: string;
    updateddAt?: string;
    updatedBy?: string;
    ArchivedAt?: string;
    ArchivedBy?: string;
}
interface SearchParamInterface<DATA> {
    id?: string;
    page?: number;
    limit?: number;
    orderBy?: string;
    include?: string;
    order?: "ASC" | "DESC";
    sort?: any;
    filter?: DATA;
    select?: string;
    total?: number;
}
interface singgleResponse<DATA> {
    data?: DATA;
    haveError: boolean;
    errorCode?: string;
    errorMessage?: string;
    code?: string;
    message?: string;
}
interface ListResponse<DATA> {
    total: number;
    page: number;
    limit: number;
    data: DATA[];
    haveError: boolean;
}
interface AddressInterface {
    _id?: string;
    streetAddress: string;
    suburb: string;
    state: string;
    postcode: string;
    country: string;
    location: locationType;
}
interface locationType {
    _id?: string;
    lat: number;
    long: number;
}
interface ImageThumbnail {
    height: number;
    size: string;
    url: string;
    width: number;
}
interface ImageInterface {
    id: number;
    lastModified: string;
    order: number;
    thumbnails: ImageThumbnail[];
    title: string;
    url: string;
}
interface ProjectTypeInterface extends AuditInterface {
    name: string;
    bannerURL?: string;
    iconURL?: string;
    thumbnailURL?: string;
    slug?: string;
    shortDescription?: string;
    description?: string;
    promotionBanner: {
        general: string;
        country: {
            [slug: string]: string;
        };
        state: {
            [slug: string]: string;
        };
        suburb: {
            [slug: string]: string;
        };
    };
}
interface AddressDetail extends AuditInterface {
    name: string;
    displayName: string;
    bannerURL?: string;
    thumbnailURL?: string;
    iconUrl?: string;
    slug?: string;
    shortDescription?: string;
    description?: string;
    tenantIds?: string[];
    tenants?: TenantInterface[];
}
interface CountryInterface extends AddressDetail {
}
interface StateInterface extends CountryInterface {
    countryId: string;
    country: CountryInterface;
}
interface RegionInterface extends StateInterface {
    stateId: string;
    state: StateInterface;
}
interface SuburbInterface extends RegionInterface {
    regionId: string;
    region: RegionInterface;
}
interface SuburbDataReport extends AuditInterface {
    headline: string;
    type: string;
    label: string;
    value: string;
    valueType: "percent" | "money";
    suburbId: string;
    suburb: SuburbInterface;
}
interface SuburbDemographic extends AuditInterface {
    label: string;
    icon: string;
    value: string;
    suburbId: string;
    suburb: SuburbInterface;
}
interface SuburbStatistic extends AuditInterface {
    category: string;
    label: string;
    value: number;
    suburbId: string;
    suburb: SuburbInterface;
}
interface CurrencyDataInterface {
    _id?: string;
    code: string;
    value: number;
}
interface AuthInterface {
    uid: string;
    token: string;
    sessionTime: string;
}

declare const MakeId: (length: number) => string;

interface FormatMoneyInterface {
    num: number;
    currencyCode?: string;
    format?: "en-US";
    minimumFractionDigits?: number;
}
declare const formatMoney: (data: FormatMoneyInterface) => string;

declare const CerateSlug: (str: string) => string;

/**
 * Generates a random UUID
 * @param a - The parameter a is a number that is used to generate the UUID. If you don't pass a
 * parameter, the function will generate a random number.
 */
/**
 * Return a new array with the elements of the original array in a random order.
 * @param arr - The array to shuffle.
 */
declare const shuffleArray: (arr: any[]) => any[];
/**
 * It takes an array, converts it to a Set, and then converts it back to an array
 * @param arr - The array to be filtered.
 */
declare const getUniqueArray: (arr: any[]) => any[];
/**
 * If the current element is an array, flatten it, otherwise, add it to the accumulator.
 */
/**
 * Generate a random hex colour code.
 */
declare const generateRandomHexColor: () => string;
/**
* It takes three numbers, one for red, one for green, and one for blue, and returns a hexadecimal
* string representing the color
* @param r - red value
* @param g - The green value of the color.
* @param b - blue
*/
declare const rgbToHex: (r: number, g: number, b: number) => string;
/**
 * It converts a hexadecimal color code to an RGB color code.
 * @param hex - The hexadecimal color code.
 */
declare const hexToRgb: (hex: any) => any;
/**
 * Given an array of numbers, return the average of those numbers.
 */
declare const average: (arr: any[]) => number;
/**
 * It converts a string to camel case.
 */
declare const toCamelCase: (str: string) => string;
/**
 * Replace all words in a string with the first letter capitalized and the rest of the letters
 * lowercase.
 */
declare const toTitleCase: (str: string) => string;
/**
 * Replace all whitespace characters with underscores and convert the string to lowercase.
 */
declare const toSnakeCase: (str: string) => string;

export { AdditionalInformation, AdditionalInformationContact, AdditionalOption, AddressDetail, AddressInterface, AgentInterface, AppraisalInterface, AuditInterface, AuthInterface, AuthorityType, BlogDisplay, BlogInterface, CategoryInterface, CerateSlug, ContactInterface, Cordinat, CountryInterface, CurrencyDataInterface, CurrencyId, CurrencyIdOptions, DataStoredInToken, EditorState, EmployeeType, EmployeeTypeData, GooglePlacesInterface, GroupAccessInterface, GroupInterface, GroupRole, ImageInterface, ImageThumbnail, LeadsInterface, ListResponse, ListingInterface, ListingParam, ListingStatus, ListingType, LotVariancesInterface, MakeId, MarketingStatusType, MenuType, MetaDataFileInterface, NotificationInterface, NotificationType, OfficesInterface, OrederBy, PermissionTypeEnum, PipeLineFlowData, PipelineFlowInterface, PipelineInterface, ProductCategoryData, ProjectGooglePlacesInterface, ProjectImageFileAndOtherInfo, ProjectInterface, ProjectLotInterface, ProjectLotMainInformation, ProjectLotVarianceInterface, ProjectMainInformation, ProjectRequestInterface, ProjectStatus, ProjectStatusOptions, ProjectStatusType, ProjectStatusTypeOptions, ProjectSummaryInterface, ProjectTripadvisorInterface, ProjectType, ProjectTypeInterface, PropectSearchParams, PropertyCategory, PropertyType, PropertyTypeData, ProspectInterface, RegionInterface, RentalRevenueEstimateInterface, SearchParamInterface, SourceList, SourceListData, StateInterface, StatusType, SubscribedOptions, SuburbDataReport, SuburbDemographic, SuburbInterface, SuburbStatistic, TAAddress, TAAncestor, TAAward, TALocalize, TALocation, TARankingData, TenantAggregatorRequestInterface, TenantAggregatorRequestType, TenantExcludeProjectInterface, TenantInterface, TenantProjectInterface, TenantType, TestimonialInterface, TokenData, TransactionDetailInterface, TransactionInterface, TransactionType, UserInterface, UserWishlistInterface, WhiteLabelInterface, agentLanguage, agentLanguageOption, average, formatMoney, generateRandomHexColor, getUniqueArray, hexToRgb, locationType, rgbToHex, shuffleArray, singgleResponse, toCamelCase, toSnakeCase, toTitleCase };