@devdash/bofrid-api-types 0.1.5

package/dist/services/chat-access/unlock-chat.service.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Chat-Access Service — single entry point for unlocking the chat between
+ * a landlord and a tenant on a given listing.
+ *
+ * The same effect is reachable through several paths:
+ *   - landlord spends a free monthly reveal ('quota')
+ *   - the listing is upgraded to premium, granting unlimited unlocks
+ *     ('listing_premium')
+ *   - the tenant subscribes to Boost, which unlocks every existing
+ *     conversation involving them ('tenant_boost')
+ *   - admin / share-with-tenant flows ('admin')
+ *
+ * Previously each path duplicated three writes (applications.revealedAt,
+ * leads.revealed/revealedAt, conversations.isLocked) and skipped the unlock
+ * reason, which caused Boost-triggered unlocks to silently consume the
+ * landlord's free quota at counting time. This module centralises the
+ * three-way sync and tags every row with its origin so only 'quota' unlocks
+ * count against the monthly budget.
+ */
+export type UnlockReason = "quota" | "listing_premium" | "tenant_boost" | "admin";
+interface UnlockChatParams {
+    listingId: string;
+    tenantId: string;
+    landlordId: string;
+    reason: UnlockReason;
+    partnerId?: string | null;
+}
+interface UnlockChatResult {
+    conversationId: string;
+    /**
+     * True when this call flipped at least one application or lead row from
+     * unrevealed to revealed. Callers can use it to drive analytics / webhooks
+     * without double-firing on idempotent retries.
+     */
+    changed: boolean;
+}
+/**
+ * Atomically unlock the chat between (listingId, tenantId, landlordId).
+ *
+ * Idempotent: callable multiple times for the same triple with no extra
+ * writes once the unlock has happened.
+ */
+export declare function unlockChat(params: UnlockChatParams): Promise<UnlockChatResult>;
+/**
+ * Batch-unlock every (tenant, listing) pair where a locked conversation
+ * exists for the given listing. Used by the listing-upgrade webhook.
+ *
+ * Returns the number of conversations that were unlocked (i.e. count of
+ * tenants whose chat moved from locked → unlocked).
+ */
+export declare function unlockAllChatsForListing(listingId: string, landlordId: string): Promise<number>;
+/**
+ * Batch-unlock every locked conversation that involves the given tenant.
+ * Used by the Boost subscription activation hook.
+ *
+ * Each unlocked row is tagged `tenant_boost` so it never consumes a
+ * landlord's free monthly reveal quota.
+ *
+ * Returns the number of conversations that flipped from locked → unlocked.
+ */
+export declare function unlockAllChatsForTenant(tenantId: string): Promise<number>;
+export {};

package/dist/services/conversations/upsert-conversation.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Create or find a conversation for a tenant+listing pair (or couple+listing).
+ * Adds all participants if creating new.
+ * Returns the conversation ID.
+ *
+ * @param partnerId — If set, creates a couple/group conversation. All active
+ *   partner members are added as participants alongside the landlord.
+ */
+export declare function upsertConversation(listingId: string, tenantId: string, landlordId: string, partnerId?: string | null, opts?: {
+    locked?: boolean;
+}): Promise<string>;

package/dist/services/email-jobs/email-job-sender.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Email Job Sender — Renders and sends emails based on job type.
+ *
+ * Maps job types to their template renderers + email transport.
+ * Called by the cron worker via processNextBatch().
+ */
+export declare function sendEmailJobItem(jobPayload: Record<string, unknown>, itemPayload: Record<string, unknown>, recipientEmail: string, recipientUserId: string | null): Promise<void>;

package/dist/services/email-jobs/email-job.service.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Email Job Service — Persistent queue for bulk email sends.
+ *
+ * Design constraints:
+ * - Multiple jobs can be queued; cron processes one at a time (FIFO by createdAt)
+ * - Cron worker picks up pending items in batches of 50
+ * - Failed items retry up to 3 times before marking as failed
+ * - Jobs can be cancelled mid-flight (remaining pending items get cancelled)
+ * - Vercel cron runs every 1 minute, processing fits within 60s timeout
+ */
+export type EmailJobType = "bevakning_match" | "verification_reminder" | "profile_reminder";
+export interface CreateEmailJobInput {
+    type: EmailJobType;
+    referenceId?: string;
+    payload: Record<string, unknown>;
+    createdBy: string;
+    items: Array<{
+        recipientEmail: string;
+        recipientUserId?: string;
+        itemPayload: Record<string, unknown>;
+    }>;
+}
+export interface EmailJobStatus {
+    id: string;
+    type: string;
+    status: string;
+    referenceId: string | null;
+    referenceLabel: string | null;
+    totalItems: number;
+    sentCount: number;
+    failedCount: number;
+    pendingCount: number;
+    cancelledCount: number;
+    createdBy: string | null;
+    createdAt: string;
+    startedAt: string | null;
+    completedAt: string | null;
+    cancelledAt: string | null;
+}
+export declare function getActiveJob(): Promise<{
+    id: string;
+    type: string;
+    status: string;
+} | null>;
+export declare function createEmailJob(input: CreateEmailJobInput): Promise<{
+    jobId: string;
+    totalItems: number;
+}>;
+export declare function cancelEmailJob(jobId: string): Promise<EmailJobStatus>;
+export declare function getJobStatus(jobId: string): Promise<EmailJobStatus>;
+export declare function listEmailJobs(limit?: number, referenceId?: string): Promise<EmailJobStatus[]>;
+export declare function retryFailedItems(jobId: string): Promise<EmailJobStatus>;
+export interface ProcessBatchResult {
+    jobId: string;
+    processed: number;
+    sent: number;
+    failed: number;
+    jobCompleted: boolean;
+}
+/**
+ * Process the next batch of pending email items.
+ *
+ * @param sendFn - Callback that renders & sends a single email.
+ *   Receives the job payload + item payload. Must throw on failure.
+ * @returns Result of the batch, or null if no work to do.
+ */
+export declare function processNextBatch(sendFn: (jobPayload: Record<string, unknown>, itemPayload: Record<string, unknown>, recipientEmail: string, recipientUserId: string | null) => Promise<void>): Promise<ProcessBatchResult | null>;

package/dist/services/geo/bevakning-matching.service.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Bevakning Geographic Matching Service
+ *
+ * Uses PostGIS `ST_Contains` to check if a property's coordinates fall
+ * within the bevakning's stored polygon (`geom` column on
+ * `bofrid_location_interests`). The polygon is copied from
+ * `geo.geo_regions` / `geo.geo_municipalities` / `geo.geo_localities` when the
+ * bevakning is created.
+ *
+ * Matching uses exact polygon containment (ST_Contains) — a listing must
+ * be inside the bevakning polygon. No distance buffer is applied.
+ */
+export interface FindMatchingOpts {
+    /** Property longitude (EPSG:4326) */
+    lon: number;
+    /** Property latitude (EPSG:4326) */
+    lat: number;
+    /** Exclude bevakningar owned by this user (the landlord) */
+    excludeUserId: string;
+    /** Only return bevakningar with emailNotifications = true */
+    emailNotificationsOnly?: boolean;
+    /** Include nationwide bevakningar (default: false — too broad for most use cases) */
+    includeNationwide?: boolean;
+    /** Exclude specific bevakning IDs (e.g. already notified) */
+    excludeBevakningIds?: string[];
+}
+/**
+ * Find active bevakningar whose stored polygon contains the given point.
+ * Returns bevakning rows joined with the user's email.
+ */
+export declare function findMatchingBevakningar(opts: FindMatchingOpts): Promise<{
+    userEmail: string | null;
+    id: string;
+    userId: string;
+    name: string;
+    active: boolean;
+    location: unknown;
+    filters: unknown;
+    emailNotifications: boolean;
+    availableFrom: string | null;
+    furnishedPreference: string | null;
+    numberOfPeople: number | null;
+    partnerId: string | null;
+    countryCode: string;
+    locationName: string | null;
+    locationType: string | null;
+    geoSlug: string | null;
+    regionSlug: string | null;
+    municipalitySlug: string | null;
+    areaSlug: string | null;
+    isNationwide: boolean;
+    maxRent: number | null;
+    propertyTypes: string[] | null;
+    geom: string | null;
+    origin: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}[]>;
+/**
+ * Count active bevakningar whose stored polygon contains the given point.
+ */
+export declare function countMatchingBevakningar(opts: Omit<FindMatchingOpts, "excludeBevakningIds">): Promise<number>;
+export declare function backfillBevakningPolygons(dryRun?: boolean): Promise<{
+    lan: number;
+    kommun: number;
+    area: number;
+}>;

package/dist/services/geo/geo-listings.service.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Geo-listings service — resolves listings by geographic filter,
+ * joins with properties to get owner data, and groups by owner.
+ *
+ * Now queries listings directly via the dedicated geo columns
+ * (geo_lan, geo_kommun, geo_omrade) on bofrid_listings.
+ */
+export interface GeoFilter {
+    lan?: string;
+    kommun?: string;
+    tatort?: string;
+}
+export interface GeoListingRow {
+    listingId: string;
+    landlordId: string | null;
+    companyId: string | null;
+    geo: unknown;
+}
+export interface OwnerGeoStats {
+    count: number;
+    tatorter: Set<string>;
+    municipalities: Set<string>;
+}
+/**
+ * Query listings that match the given geographic filter.
+ * Uses the `geo` JSONB column on bofrid_listings for filtering,
+ * joined with properties for owner IDs.
+ *
+ * This is a single SQL query — no HTTP round-trip needed.
+ */
+export declare function resolveListingsByGeo(filter: GeoFilter): Promise<GeoListingRow[]>;
+/**
+ * Group GeoListingRows by owner type.
+ *
+ * - `"landlord"` → individual landlords (has landlordId, no companyId)
+ * - `"company"` → company-owned (has companyId)
+ */
+export declare function groupByOwner(rows: GeoListingRow[], ownerType: "landlord" | "company", tatort?: string): Map<string, OwnerGeoStats>;

package/dist/services/geo/geo.service.d.ts

@@ -0,0 +1,233 @@
+/**
+ * Geo Service — direct Drizzle queries against the `geo.*` tables.
+ *
+ * The geo tables live in the same Supabase instance, so we query them
+ * directly via SQL rather than over HTTP.
+ */
+import type { GeoCenter, GeoBoundingBox } from "@bofrid/db/geo-schema";
+export interface GeoReverseResult {
+    region: {
+        name: string;
+        slug: string;
+    };
+    municipality: {
+        name: string;
+        slug: string;
+    };
+    areas: Array<{
+        name: string;
+        slug: string;
+        type: string;
+    }>;
+}
+export interface GeoAutocompleteResult {
+    id: string;
+    name: string;
+    type: "region" | "municipality" | "tatort" | "regso" | "stadsdelsomrade";
+    slug: string;
+    /** ISO 3166-1 alpha-2 ("SE", "DK", ...). Lets the UI render flags + filter cross-market. */
+    countryCode: string;
+    municipalitySlug?: string;
+    municipalityName?: string;
+    regionSlug?: string;
+    regionName?: string;
+    center: GeoCenter | null;
+    boundingbox: GeoBoundingBox | null;
+    population?: number;
+}
+export interface GeoHierarchyLan {
+    slug: string;
+    name: string;
+    kommunCount: number | null;
+    tatortCount: number | null;
+}
+export interface GeoHierarchyKommun {
+    type: "municipality";
+    slug: string;
+    name: string;
+    areas: Array<{
+        type: string;
+        slug: string;
+        name: string;
+        population?: number | null;
+    }>;
+}
+export interface GeoEntityWithPolygon {
+    name: string;
+    slug: string;
+    type: string;
+    center: GeoCenter | null;
+    boundingbox: GeoBoundingBox | null;
+    municipalitySlug?: string | null;
+    municipalityName?: string | null;
+    regionSlug?: string | null;
+    regionName?: string | null;
+    polygonJson: string | null;
+    population?: number | null;
+}
+/**
+ * Reverse geocode coordinates → län + kommun + areas.
+ * Uses PostGIS `ST_Contains` against the `geom` column.
+ */
+export declare function reverseGeocode(lat: number, lng: number): Promise<GeoReverseResult | null>;
+export declare function getLanBySlug(slug: string): Promise<{
+    slug: string;
+    name: string;
+    nameEn: string | null;
+    code: string;
+    countryCode: string;
+    center: GeoCenter | null;
+    boundingbox: GeoBoundingBox | null;
+    polygonJson: string | null;
+    disabled: boolean | null;
+    seo: import("@bofrid/db").GeoSeo | null;
+    content: unknown;
+    landlordContent: unknown;
+    tenantContent: unknown;
+    wikipediaData: unknown;
+    searchTokens: string[] | null;
+    osmId: number | null;
+    osmType: string | null;
+    wikidataId: string | null;
+    kommunCount: number | null;
+    tatortCount: number | null;
+    postalCodeCount: number | null;
+    population: number | null;
+    listingCount: number | null;
+    listings: unknown;
+    tenantAds: unknown;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    geom: string | null;
+}>;
+export declare function getKommunBySlug(slug: string): Promise<{
+    slug: string;
+    name: string;
+    code: string;
+    countryCode: string;
+    regionSlug: string;
+    regionCode: string | null;
+    regionName: string | null;
+    center: GeoCenter | null;
+    boundingbox: GeoBoundingBox | null;
+    polygonJson: string | null;
+    disabled: boolean | null;
+    seo: import("@bofrid/db").GeoSeo | null;
+    content: unknown;
+    landlordContent: unknown;
+    tenantContent: unknown;
+    wikipediaData: unknown;
+    postalCodes: unknown;
+    searchTokens: string[] | null;
+    osmId: number | null;
+    osmType: string | null;
+    wikidataId: string | null;
+    hasUniversity: boolean | null;
+    targetStudents: boolean | null;
+    universities: import("@bofrid/db").GeoUniversity[] | null;
+    areaCount: number | null;
+    tatortCount: number | null;
+    postalCodeCount: number | null;
+    population: number | null;
+    listingCount: number | null;
+    listings: unknown;
+    tenantAds: unknown;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    geom: string | null;
+}>;
+export declare function getAreaBySlugAndKommun(slug: string, municipalitySlug: string): Promise<{
+    id: string;
+    type: string;
+    slug: string;
+    name: string;
+    countryCode: string;
+    municipalitySlug: string | null;
+    municipalityCode: string | null;
+    municipalityName: string | null;
+    regionSlug: string | null;
+    regionCode: string | null;
+    regionName: string | null;
+    center: GeoCenter | null;
+    boundingbox: GeoBoundingBox | null;
+    polygonJson: string | null;
+    disabled: boolean | null;
+    seo: import("@bofrid/db").GeoSeo | null;
+    content: unknown;
+    landlordContent: unknown;
+    tenantContent: unknown;
+    wikipediaData: unknown;
+    famousFor: string | null;
+    highlights: string[] | null;
+    searchTokens: string[] | null;
+    tatortskod: string | null;
+    population2023: number | null;
+    population2024: number | null;
+    areaHa: string | null;
+    code: string | null;
+    source: string | null;
+    version: string | null;
+    objektidentitet: string | null;
+    areaUuid: string | null;
+    districtType: string | null;
+    osmId: number | null;
+    osmType: string | null;
+    wikidataId: string | null;
+    dataYear: number | null;
+    validFrom: Date | null;
+    validTo: Date | null;
+    hasUniversity: boolean | null;
+    targetStudents: boolean | null;
+    universities: import("@bofrid/db").GeoUniversity[] | null;
+    listingCount: number | null;
+    listings: unknown;
+    tenantAds: unknown;
+    createdAt: Date | null;
+    updatedAt: Date | null;
+    geom: string | null;
+}>;
+export declare function getGeoEntityWithPolygon(type: string, slug: string, municipalitySlug?: string): Promise<GeoEntityWithPolygon | null>;
+/**
+ * Search geo entities by name prefix. Searches län, kommuner, and areas.
+ * Returns results sorted by population (largest first).
+ */
+export declare function autocomplete(query: string, limit?: number, 
+/**
+ * Restrict results to one country. If omitted, results are restricted to
+ * the markets currently flipped `enabled=true` on geo_countries — which is
+ * SE-only today, so backwards-compatible for existing callers.
+ */
+countryCode?: string): Promise<GeoAutocompleteResult[]>;
+/** Get all 21 län with stats. */
+export declare function getHierarchyList(): Promise<GeoHierarchyLan[]>;
+/** Get a län's full hierarchy: kommuner → areas. */
+export declare function getHierarchyForLan(regionSlug: string): Promise<{
+    slug: string;
+    name: string;
+    kommuner: GeoHierarchyKommun[];
+} | null>;
+/**
+ * Fetch ALL län hierarchies in 3 bulk queries instead of 63 individual ones.
+ * Used by /geo/hierarchy-bulk to avoid connection pool starvation.
+ */
+export declare function getAllHierarchies(): Promise<Array<{
+    slug: string;
+    name: string;
+    kommuner: GeoHierarchyKommun[];
+}>>;
+/** Count published listings in a län */
+export declare function getLiveListingCountByLan(regionSlug: string): Promise<number>;
+/** Count published listings in a kommun */
+export declare function getLiveListingCountByKommun(municipalitySlug: string): Promise<number>;
+/** Count published listings in an area within a kommun */
+export declare function getLiveListingCountByArea(municipalitySlug: string, areaSlug: string): Promise<number>;
+/** Count active location interests targeting a län (directly or via kommun/area within it) */
+export declare function getActiveSeekerCountByLan(regionSlug: string): Promise<number>;
+/** Count active location interests targeting a kommun (directly or via area within it) */
+export declare function getActiveSeekerCountByKommun(municipalitySlug: string): Promise<number>;
+/** Listing stats grouped by län (for /geo/listings/stats endpoint) */
+export declare function getListingStatsByLan(): Promise<Array<{
+    slug: string;
+    name: string;
+    count: number;
+}>>;

package/dist/services/geo/geocode.service.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Geocode Service — forward geocoding via Google Places Text Search.
+ *
+ * Extracted from the /geocoding/search route handler for reuse in
+ * the publish flow (ensurePropertyLocation) and elsewhere.
+ */
+/**
+ * Geocode a street address to coordinates using Google Places Text Search.
+ * Biased to Sweden (lat 55–69.5, lng 10–24.5).
+ *
+ * @returns `{ lat, lon }` or `null` if the address could not be resolved.
+ */
+export declare function geocodeAddress(address: string): Promise<{
+    lat: number;
+    lon: number;
+} | null>;

package/dist/services/geo/market-insights-by-coords.service.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Market Insights by Coordinates
+ *
+ * Takes (lat, lng) → reverse geocodes to area/municipality/län via PostGIS polygons
+ * → queries geo.unified_listings for market data at ALL three levels
+ * and for ALL property types.
+ *
+ * Returns a complete picture: area + municipality + län insights, each broken down
+ * by property type (apartment, house, room, all).
+ */
+export interface MarketStats {
+    sampleSize: number;
+    avgKvmPris: number;
+    medianKvmPris: number;
+    avgRent: number;
+    medianRent: number;
+    rentP25: number;
+    rentP75: number;
+    avgSqm: number;
+    /** Suggested rent if sqm was provided */
+    suggestedRent: number | null;
+}
+export interface YearlyMarketStats {
+    year: number;
+    byType: Record<string, MarketStats>;
+}
+export interface MarketInsightLevel {
+    level: "area" | "municipality" | "region";
+    name: string;
+    slug: string;
+    /** Extra info: area type, municipality code, etc. */
+    meta?: Record<string, string>;
+    /** Stats per property type + "all" (all time) */
+    byType: Record<string, MarketStats>;
+    /** Stats per year (only years with enough data) */
+    byYear: YearlyMarketStats[];
+}
+export interface CoordsMarketInsightResult {
+    lat: number;
+    lng: number;
+    /** Resolved location hierarchy */
+    location: {
+        area: {
+            name: string;
+            slug: string;
+            type: string;
+        } | null;
+        municipality: {
+            name: string;
+            slug: string;
+        } | null;
+        region: {
+            name: string;
+            slug: string;
+        } | null;
+    };
+    /** Insights at each geographic level (area, municipality, län) */
+    insights: MarketInsightLevel[];
+}
+export interface CoordsMarketInsightParams {
+    lat: number;
+    lng: number;
+    sqm?: number | null;
+    /** Skip yearly breakdown (default true — saves 3 queries) */
+    skipYearly?: boolean;
+}
+export declare function getMarketInsightsByCoords(params: CoordsMarketInsightParams): Promise<CoordsMarketInsightResult>;

package/dist/services/geo/market-insights.service.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Market Insights Service
+ *
+ * Provides real rental market data from geo.unified_listings (86k+ listings
+ * scraped from 329 Swedish rental platforms) to help landlords price competitively.
+ *
+ * Returns kvm-pris (kr/kvm/month), rent ranges, and sample sizes
+ * at the most granular available level: area → kommun → län.
+ */
+export interface MarketInsight {
+    /** Geographic level the data comes from */
+    level: "area" | "municipality" | "region";
+    /** Human-readable location name */
+    locationName: string;
+    /** Number of comparable listings used */
+    sampleSize: number;
+    /** Average kr/kvm/month */
+    avgKvmPris: number;
+    /** Median kr/kvm/month */
+    medianKvmPris: number;
+    /** Average monthly rent (SEK) */
+    avgRent: number;
+    /** Median monthly rent (SEK) */
+    medianRent: number;
+    /** 25th percentile rent */
+    rentP25: number;
+    /** 75th percentile rent */
+    rentP75: number;
+    /** Average size in m² */
+    avgSqm: number;
+    /** Suggested rent based on property size (avgKvmPris × sqm) */
+    suggestedRent: number | null;
+    /** Property type used for filtering */
+    propertyType: string | null;
+}
+export interface MarketInsightParams {
+    municipalitySlug: string;
+    areaId?: string | null;
+    regionSlug?: string | null;
+    propertyType?: string | null;
+    /** Property size in m² — used to calculate suggested rent */
+    sqm?: number | null;
+}
+export declare function getMarketInsights(params: MarketInsightParams): Promise<MarketInsight | null>;

package/dist/services/geo/market-overview.service.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Market Overview Service
+ *
+ * Bulk variant of `getMarketInsights` — returns aggregated rent stats for
+ * many kommuner in one query against `geo.unified_listings` (the 86k+
+ * listings scraped from Qasa, Homii, HomeQ and Kvalster).
+ *
+ * Used by the landlord-facing /dashboard/hyresmarknad page to render a
+ * sortable table of kommuner with median rent, kr/kvm and sample size.
+ */
+export type PropertyTypeFilter = "apartment" | "house" | "room" | "student" | "all";
+export interface MarketOverviewParams {
+    regionSlug?: string | null;
+    propertyType?: PropertyTypeFilter | null;
+    minSamples?: number;
+    limit?: number;
+    sortBy?: "sampleSize" | "medianRent" | "medianKvmPris";
+}
+export interface MarketOverviewRow {
+    municipalitySlug: string;
+    municipalityName: string;
+    regionSlug: string;
+    regionName: string;
+    sampleSize: number;
+    medianRent: number;
+    medianKvmPris: number;
+    avgSqm: number;
+    rentP25: number;
+    rentP75: number;
+}
+export interface MarketOverviewSwedenWide {
+    medianRent: number;
+    medianKvmPris: number;
+    avgSqm: number;
+    sampleSize: number;
+}
+export interface MarketOverviewResult {
+    totalListings: number;
+    swedenWide: MarketOverviewSwedenWide | null;
+    rows: MarketOverviewRow[];
+}
+export declare function getMarketOverview(params?: MarketOverviewParams): Promise<MarketOverviewResult>;

package/dist/services/homii/image.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Homii image service — fetch JPEG from Bofrid CDN and upload to Homii.
+ *
+ * Homii only accepts image/jpeg via their Cloud Run upload endpoint.
+ * We fetch the JPEG variant from our CDN (bofrid.media) to avoid needing sharp.
+ */
+export interface ImageUploadResult {
+    success: boolean;
+    imageUrl?: string;
+    error?: string;
+}
+/**
+ * Get the best JPEG URL from property image data.
+ * Prefers medium JPEG, falls back to original URL.
+ */
+export declare function getJpegUrl(images: Array<{
+    url: string;
+    urls: unknown;
+    isPrimary: boolean;
+}>): string | null;
+/**
+ * Fetch a JPEG image from source URL and upload to Homii's Cloud Run endpoint.
+ */
+export declare function uploadImage(sourceUrl: string, homiiListingId: string, maxRetries?: number): Promise<ImageUploadResult>;