"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
var GeocodingService_1;
var _a, _b, _c, _d, _e;
Object.defineProperty(exports, "__esModule", { value: true });
exports.GeocodingService = void 0;
const common_1 = require("@nestjs/common");
const typeorm_1 = require("@nestjs/typeorm");
const typeorm_2 = require("typeorm");
const cache_manager_1 = require("@nestjs/cache-manager");
const place_syria_entity_1 = require("./entities/place-syria.entity");
const place_jordan_entity_1 = require("./entities/place-jordan.entity");
const place_egypt_entity_1 = require("./entities/place-egypt.entity");
const osm_area_entity_1 = require("./entities/osm-area.entity");
const osm_point_with_area_entity_1 = require("./entities/osm-point-with-area.entity");
let GeocodingService = GeocodingService_1 = class GeocodingService {
    placesSyriaRepository;
    placesJordanRepository;
    placesEgyptRepository;
    osmAreasRepository;
    osmPointsRepository;
    cacheManager;
    logger = new common_1.Logger(GeocodingService_1.name);
    DB_TIMEOUT_MS = 1100;
    constructor(placesSyriaRepository, placesJordanRepository, placesEgyptRepository, osmAreasRepository, osmPointsRepository, cacheManager) {
        this.placesSyriaRepository = placesSyriaRepository;
        this.placesJordanRepository = placesJordanRepository;
        this.placesEgyptRepository = placesEgyptRepository;
        this.osmAreasRepository = osmAreasRepository;
        this.osmPointsRepository = osmPointsRepository;
        this.cacheManager = cacheManager;
    }
    getRepositoryForCoords(lat, lng) {
        if (lat >= 29 && lat <= 37.5 && lng >= 34.5 && lng <= 42.5) {
            if (lat > 32.5 && lng > 35.8)
                return this.placesSyriaRepository;
            return this.placesJordanRepository;
        }
        if (lat >= 22 && lat <= 32 && lng >= 24.5 && lng <= 37) {
            return this.placesEgyptRepository;
        }
        return this.placesSyriaRepository;
    }
    identifyRegion(lat, lng) {
        if (lat === undefined || lng === undefined)
            return undefined;
        if (lat >= 29 && lat <= 37.5 && lng >= 34.5 && lng <= 42.5) {
            if (lat > 32.5 && lng > 35.8)
                return 'syria';
            return 'jordan';
        }
        if (lat >= 22 && lat <= 32 && lng >= 24.5 && lng <= 37) {
            return 'egypt';
        }
        return undefined;
    }
    getTableNameForRepo(repo) {
        if (repo === this.placesJordanRepository)
            return 'places_jordan';
        if (repo === this.placesEgyptRepository)
            return 'places_egypt';
        return 'places_syria';
    }
    async searchPlaces(query, lat, lon, radius = 20000, country) {
        try {
            let cleanQuery = query.trim();
            if (!cleanQuery)
                return { results: [] };
            let relativePrefix = '';
            const relativeQueryRegex = /^(قرب|بالقرب من|قريب من|عند|بجانب|جنب|حد|بجوار|مقابل|قبال|خلف|ورا|وراء)\s+(.+)$/i;
            const match = cleanQuery.match(relativeQueryRegex);
            if (match) {
                relativePrefix = match[1];
                cleanQuery = match[2];
            }
            const hasLocation = lat !== undefined && lon !== undefined;
            const geoSegment = hasLocation ? `${lat.toFixed(2)}_${lon.toFixed(2)}` : 'global';
            const cacheKey = `geo_search:${country || 'auto'}:${geoSegment}:${cleanQuery.toLowerCase()}`;
            const cached = await this.cacheManager.get(cacheKey);
            if (cached)
                return { results: cached, source: 'cache_hit' };
            let targetRegion = country?.toLowerCase() || this.identifyRegion(lat, lon);
            const [normalizedQueryRes] = await this.osmPointsRepository.query(`SELECT normalize_arabic($1) as nq`, [cleanQuery]);
            const normalizedQuery = normalizedQueryRes?.nq || cleanQuery.toLowerCase();
            let queryParams = [normalizedQuery];
            let locationCondition = '';
            if (hasLocation) {
                locationCondition = `AND ST_DistanceSphere(location, ST_SetSRID(ST_MakePoint($3::float, $2::float), 4326)) <= $4`;
                queryParams.push(lat, lon, radius);
            }
            let regionCondition = '';
            if (targetRegion && ['syria', 'jordan', 'egypt'].includes(targetRegion)) {
                regionCondition = `AND (region = '${targetRegion}' OR region = 'global')`;
            }
            const sqlQuery = `
        SELECT 
          id, name, name_ar, category, 
          '' as neighbourhood, '' as district, '' as governorate,
          latitude, longitude, address, region, source, popularity_score,
          ${hasLocation ? 'ST_DistanceSphere(location, ST_SetSRID(ST_MakePoint($3::float, $2::float), 4326))' : '0'} as distance,
          similarity(normalized_name, $1) as relevance
        FROM unified_search_index
        WHERE normalized_name % $1
        ${locationCondition}
        ${regionCondition}
        ORDER BY (normalized_name <-> $1) ASC
        LIMIT 50
      `;
            const allResults = await Promise.race([
                this.osmPointsRepository.query(sqlQuery, queryParams),
                new Promise((_, reject) => setTimeout(() => reject(new Error('QUERY_TIMEOUT')), this.DB_TIMEOUT_MS))
            ]).catch(e => {
                this.logger.warn(`Search optimization threshold hit: ${e.message}`);
                return [];
            });
            const formatted = this.formatResults(allResults, hasLocation, relativePrefix);
            const placeIds = formatted.map(r => r.id);
            if (placeIds.length > 0) {
                try {
                    const gates = await this.osmPointsRepository.query(`SELECT place_id, gate_name_ar, gate_name_en, latitude, longitude, is_main_gate 
             FROM place_gates 
             WHERE place_id = ANY($1)`, [placeIds]);
                    if (gates.length > 0) {
                        formatted.forEach(r => {
                            const placeGates = gates.filter((g) => g.place_id === r.id).map((g) => ({
                                name_ar: g.gate_name_ar,
                                name_en: g.gate_name_en,
                                latitude: parseFloat(g.latitude),
                                longitude: parseFloat(g.longitude),
                                is_main_gate: g.is_main_gate
                            }));
                            if (placeGates.length > 0) {
                                r.gates = placeGates;
                            }
                        });
                    }
                }
                catch (err) {
                    this.logger.warn('Failed to fetch POI gates, table might not exist yet.');
                }
            }
            if (formatted.length > 0) {
                await this.cacheManager.set(cacheKey, formatted, 3600000);
            }
            else {
                this.logFailedSearch(cleanQuery, normalizedQuery, targetRegion, lat, lon).catch(err => {
                    this.logger.error('Failed to log zero-result search:', err);
                });
                try {
                    const whereClause = regionCondition ? `WHERE ${regionCondition.substring(4)}` : '';
                    const fallbackQuery = `
            SELECT name_ar, name, (normalized_name <-> $1) as dist
            FROM unified_search_index
            ${whereClause}
            ORDER BY normalized_name <-> $1 ASC
            LIMIT 1
          `;
                    const suggestions = await this.osmPointsRepository.query(fallbackQuery, [normalizedQuery]);
                    if (suggestions.length > 0 && suggestions[0].dist < 0.6) {
                        return {
                            results: [],
                            did_you_mean: suggestions[0].name_ar || suggestions[0].name
                        };
                    }
                }
                catch (err) {
                    this.logger.warn('Did You Mean fallback failed: ' + err.message);
                }
            }
            return { results: formatted };
        }
        catch (e) {
            this.logger.error('Search failed:', e);
            return { results: [] };
        }
    }
    formatResults(results, hasLocation, relativePrefix = '') {
        const seenStreets = new Set();
        const maxPopularity = Math.max(...results.map(r => r.popularity_score || 10), 100);
        return results
            .map(r => {
            const textScore = Number(r.relevance);
            const popularityScore = (r.popularity_score || 10) / maxPopularity;
            const proximityBonus = hasLocation ? Math.max(0, 1 - (Number(r.distance) / 10000)) : 0;
            const totalScore = (textScore * 0.5) + (popularityScore * 0.3) + (proximityBonus * 0.2);
            return { ...r, totalScore };
        })
            .sort((a, b) => b.totalScore - a.totalScore)
            .filter(r => {
            if (r.category === 'street') {
                const key = `${r.name_ar || r.name}_${r.district}_${r.governorate}`;
                if (seenStreets.has(key))
                    return false;
                seenStreets.add(key);
            }
            return true;
        })
            .slice(0, 4)
            .map(r => {
            const addressParts = [r.neighbourhood, r.district, r.governorate].filter(Boolean);
            const full_address = addressParts.length > 0 ? addressParts.join('، ') : (r.address || '');
            const nameAr = r.name_ar || r.name;
            const displayName = relativePrefix ? `${relativePrefix} ${nameAr}` : nameAr;
            return {
                ...r,
                name: displayName,
                name_ar: displayName,
                latitude: parseFloat(r.latitude),
                longitude: parseFloat(r.longitude),
                distance_km: r.distance ? (Number(r.distance) / 1000).toFixed(2) : null,
                location: { lat: parseFloat(r.latitude), lng: parseFloat(r.longitude) },
                full_address,
            };
        });
    }
    getRepoByTableName(tableName) {
        if (tableName === 'places_egypt')
            return this.placesEgyptRepository;
        if (tableName === 'places_jordan')
            return this.placesJordanRepository;
        return this.placesSyriaRepository;
    }
    async logFailedSearch(query, normalizedQuery, country, lat, lon) {
        const q = `
      INSERT INTO failed_searches (query_text, normalized_query, country, latitude, longitude)
      VALUES ($1, $2, $3, $4, $5)
      ON CONFLICT (normalized_query, COALESCE(country, 'global')) 
      DO UPDATE SET search_count = failed_searches.search_count + 1, last_seen_at = CURRENT_TIMESTAMP;
    `;
        await this.osmPointsRepository.query(q, [query, normalizedQuery, country || null, lat || null, lon || null]);
    }
    async autocomplete(query, country) {
        try {
            let cleanQuery = query.trim();
            if (cleanQuery.length < 2)
                return { results: [] };
            let relativePrefix = '';
            const relativeQueryRegex = /^(قرب|بالقرب من|قريب من|عند|بجانب|جنب|حد|بجوار|مقابل|قبال|خلف|ورا|وراء)\s+(.+)$/i;
            const match = cleanQuery.match(relativeQueryRegex);
            if (match) {
                relativePrefix = match[1];
                cleanQuery = match[2];
                if (cleanQuery.length < 2)
                    return { results: [] };
            }
            const targetRegion = country?.toLowerCase();
            const cacheKey = `geo_auto:${targetRegion || 'auto'}:${cleanQuery.toLowerCase()}`;
            const cached = await this.cacheManager.get(cacheKey);
            if (cached)
                return { results: cached, source: 'cache_hit' };
            const [normalizedQueryRes] = await this.osmPointsRepository.query(`SELECT normalize_arabic($1) as nq`, [cleanQuery]);
            const normalizedQuery = normalizedQueryRes?.nq || cleanQuery.toLowerCase();
            let queryParams = [`${normalizedQuery}%`];
            let regionCondition = '';
            if (targetRegion && ['syria', 'jordan', 'egypt'].includes(targetRegion)) {
                regionCondition = `AND (region = '${targetRegion}' OR region = 'global')`;
            }
            const sqlQuery = `
        SELECT 
          id, name, name_ar, category, region, source, address
        FROM unified_search_index
        WHERE normalized_name LIKE $1
        ${regionCondition}
        ORDER BY LENGTH(normalized_name) ASC
        LIMIT 7
      `;
            const results = await this.osmPointsRepository.query(sqlQuery, queryParams);
            const formatted = results.map(r => {
                const nameAr = r.name_ar || r.name;
                const displayName = relativePrefix ? `${relativePrefix} ${nameAr}` : nameAr;
                return {
                    id: r.id,
                    name: displayName,
                    category: r.category,
                    region: r.region,
                    address: r.address
                };
            });
            if (formatted.length > 0) {
                await this.cacheManager.set(cacheKey, formatted, 3600000);
            }
            return { results: formatted };
        }
        catch (e) {
            this.logger.error('Autocomplete failed:', e);
            return { results: [] };
        }
    }
    async reverseGeocode(lat, lng) {
        try {
            const repo = this.getRepositoryForCoords(lat, lng);
            const tableName = this.getTableNameForRepo(repo);
            const queryPromises = [];
            queryPromises.push(repo.query(`
        SELECT 
          p.id, p.name, p.name_ar, p.category, 
          n.name_ar as neighbourhood,
          d.name_ar as district,
          g.name_ar as governorate,
          p.latitude, p.longitude, p.address, 'user_place' as source,
          ST_DistanceSphere(p.location::geometry, ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326)) as distance 
        FROM ${tableName} p
        LEFT JOIN neighborhood_polygons n ON p.neighborhood_id = n.id
        LEFT JOIN admin_boundaries d ON p.sub_district_id = d.id
        LEFT JOIN admin_boundaries g ON p.governorate_id = g.id
        WHERE p.location IS NOT NULL
        ORDER BY p.location::geometry <-> ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326) ASC LIMIT 5
      `, [lng, lat]));
            queryPromises.push(repo.query(`
        SELECT 
          o.osm_id::text as id, o.name, o.name_ar, COALESCE(o.amenity, o.shop, 'place') as category,
          '' as neighbourhood, '' as district, '' as governorate,
          o.latitude, o.longitude, o.addr_street as address, 'osm_global' as source,
          ST_DistanceSphere(o.geom, ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326)) as distance
        FROM osm_points_with_area o
        WHERE o.geom IS NOT NULL AND (o.name IS NOT NULL OR o.name_ar IS NOT NULL)
        ORDER BY o.geom <-> ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326) ASC LIMIT 5
      `, [lng, lat]));
            queryPromises.push(repo.query(`
        SELECT 
          id::text, COALESCE(names->>'primary', names->>'common', 'Street') as name, COALESCE(names->>'primary', names->>'common', 'Street') as name_ar, 'street' as category,
          '' as neighbourhood, '' as district, '' as governorate,
          ST_Y(ST_Centroid(location))::text as latitude, ST_X(ST_Centroid(location))::text as longitude, '' as address, 'overture_global' as source,
          ST_DistanceSphere(location, ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326)) as distance
        FROM overture_segment
        WHERE location IS NOT NULL AND (names->>'primary' IS NOT NULL OR names->>'common' IS NOT NULL)
        ORDER BY location <-> ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326) ASC LIMIT 5
      `, [lng, lat]));
            queryPromises.push(repo.query(`
        SELECT 
          id::text, COALESCE(names->>'primary', names->>'common', 'Building') as name, COALESCE(names->>'primary', names->>'common', 'Building') as name_ar, 'building' as category,
          '' as neighbourhood, '' as district, '' as governorate,
          ST_Y(ST_Centroid(location))::text as latitude, ST_X(ST_Centroid(location))::text as longitude, '' as address, 'overture_global' as source,
          ST_DistanceSphere(location, ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326)) as distance
        FROM overture_building
        WHERE location IS NOT NULL AND (names->>'primary' IS NOT NULL OR names->>'common' IS NOT NULL)
        ORDER BY location <-> ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326) ASC LIMIT 5
      `, [lng, lat]));
            queryPromises.push(repo.query(`
        SELECT 
          id::text, COALESCE(names->>'primary', names->>'common', 'Place') as name, COALESCE(names->>'primary', names->>'common', 'Place') as name_ar, 'place' as category,
          '' as neighbourhood, '' as district, '' as governorate,
          ST_Y(ST_Centroid(location))::text as latitude, ST_X(ST_Centroid(location))::text as longitude, '' as address, 'overture_global' as source,
          ST_DistanceSphere(location, ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326)) as distance
        FROM overture_place
        WHERE location IS NOT NULL AND (names->>'primary' IS NOT NULL OR names->>'common' IS NOT NULL)
        ORDER BY location <-> ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326) ASC LIMIT 5
      `, [lng, lat]));
            const results = await Promise.allSettled(queryPromises);
            let allResults = [];
            results.forEach(res => {
                if (res.status === 'fulfilled' && res.value)
                    allResults.push(...res.value);
            });
            return allResults
                .sort((a, b) => Number(a.distance) - Number(b.distance))
                .slice(0, 5)
                .map(r => {
                const distance = Number(r.distance);
                const fullAddressParts = [r.name_ar || r.name, r.address, r.neighbourhood, r.district, r.governorate].filter(Boolean);
                let humanReadable = r.name_ar || r.name;
                if (distance <= 20) {
                    humanReadable = r.name_ar || r.name;
                }
                else if (distance <= 70 && r.category !== 'street') {
                    const streetName = r.address ? `، ${r.address}` : '';
                    humanReadable = `أمام ${r.name_ar || r.name}${streetName}`;
                }
                else if (r.category === 'street' || distance > 70) {
                    const streetPart = r.category === 'street' ? (r.name_ar || r.name) : (r.address || r.name_ar || r.name);
                    const districtPart = r.neighbourhood || r.district || '';
                    humanReadable = [streetPart, districtPart].filter(Boolean).join('، ');
                }
                return {
                    ...r,
                    latitude: parseFloat(r.latitude),
                    longitude: parseFloat(r.longitude),
                    human_readable_address: humanReadable,
                    full_address: fullAddressParts.join('، ')
                };
            });
        }
        catch (error) {
            this.logger.error('Reverse geocoding error:', error);
            return [];
        }
    }
    async addPlace(data) {
        try {
            const lat = Number(data.latitude), lng = Number(data.longitude);
            const repo = this.getRepositoryForCoords(lat, lng), tableName = this.getTableNameForRepo(repo);
            const newPlace = repo.create({ ...data, latitude: lat, longitude: lng, created_at: new Date(), location: { type: 'Point', coordinates: [lng, lat] } });
            const savedPlace = await repo.save(newPlace);
            await repo.query(`UPDATE ${tableName} SET location = ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326) WHERE id = $3`, [lng, lat, savedPlace.id]);
            return { ...savedPlace, latitude: lat, longitude: lng, location: `POINT(${lng} ${lat})` };
        }
        catch (error) {
            throw new common_1.HttpException(error.message, common_1.HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
    async upsertPlace(data) {
        try {
            const lat = Number(data.latitude), lng = Number(data.longitude);
            const repo = this.getRepositoryForCoords(lat, lng), tableName = this.getTableNameForRepo(repo);
            const existing = await repo.query(`SELECT id, name FROM ${tableName} WHERE ST_DistanceSphere(location, ST_SetSRID(ST_MakePoint($1::float, $2::float), 4326)) < 15 LIMIT 1`, [lng, lat]);
            if (existing && existing.length > 0) {
                await repo.update(existing[0].id, { name: data.name || undefined, name_ar: data.name_ar || undefined, category: data.category || undefined });
                return { id: existing[0].id, action: 'updated' };
            }
            const result = await this.addPlace(data);
            return { id: result.id, action: 'created' };
        }
        catch (error) {
            throw error;
        }
    }
    async upsertBatch(places) {
        const results = [];
        for (const place of places) {
            try {
                const r = await this.addPlace(place);
                results.push({ id: r.id, action: 'created' });
            }
            catch (e) { }
        }
        return { total: places.length, processed: results.length, created: results.length, updated: 0 };
    }
    async getRecentPlaces(limit = 50) {
        const s = await this.placesSyriaRepository.find({ order: { created_at: 'DESC' }, take: limit });
        const j = await this.placesJordanRepository.find({ order: { created_at: 'DESC' }, take: limit });
        const e = await this.placesEgyptRepository.find({ order: { created_at: 'DESC' }, take: limit });
        return [...s, ...j, ...e].sort((a, b) => b.created_at.getTime() - a.created_at.getTime()).slice(0, limit);
    }
    async getAllPlacesGeoJSON() {
        try {
            const q = `
        SELECT id::text, name_ar as name, category, latitude, longitude, address, 'user' as region FROM places_syria 
        UNION ALL SELECT id::text, name_ar as name, category, latitude, longitude, address, 'user' as region FROM places_jordan 
        UNION ALL SELECT id::text, name_ar as name, category, latitude, longitude, address, 'user' as region FROM places_egypt
        UNION ALL SELECT id::text, COALESCE(names->>'primary', names->>'common', 'Building') as name, 'building' as category, ST_Y(ST_Centroid(location)) as latitude, ST_X(ST_Centroid(location)) as longitude, '' as address, 'overture' as region FROM overture_building WHERE names->>'primary' IS NOT NULL LIMIT 500
        UNION ALL SELECT id::text, COALESCE(names->>'primary', names->>'common', 'Street') as name, 'street' as category, ST_Y(ST_Centroid(location)) as latitude, ST_X(ST_Centroid(location)) as longitude, '' as address, 'overture' as region FROM overture_segment WHERE names->>'primary' IS NOT NULL LIMIT 500
        UNION ALL SELECT id::text, COALESCE(names->>'primary', names->>'common', 'Place') as name, 'place' as category, ST_Y(ST_Centroid(location)) as latitude, ST_X(ST_Centroid(location)) as longitude, '' as address, 'overture' as region FROM overture_place WHERE names->>'primary' IS NOT NULL LIMIT 500
      `;
            const res = await this.placesSyriaRepository.query(q);
            const features = res.map(p => ({
                type: 'Feature',
                geometry: { type: 'Point', coordinates: [parseFloat(p.longitude), parseFloat(p.latitude)] },
                properties: { id: p.id, name: p.name, category: p.category, address: p.address, region: p.region }
            }));
            return { type: 'FeatureCollection', features };
        }
        catch (e) {
            return { type: 'FeatureCollection', features: [] };
        }
    }
    async deletePlacesByName(name, country) {
        const repo = this.getRepoByCountry(country);
        const r1 = await repo.delete({ name_ar: name }), r2 = await repo.delete({ name_en: name }), r3 = await repo.delete({ name: name });
        return { success: true, affected: (r1.affected || 0) + (r2.affected || 0) + (r3.affected || 0) };
    }
    async deletePlaceById(id, country) {
        const repo = this.getRepoByCountry(country);
        return { success: true, affected: (await repo.delete(id)).affected };
    }
    getRepoByCountry(country) {
        switch (country?.toLowerCase()) {
            case 'syria': return this.placesSyriaRepository;
            case 'jordan': return this.placesJordanRepository;
            case 'egypt': return this.placesEgyptRepository;
            default: throw new common_1.HttpException('Invalid country: ' + country, common_1.HttpStatus.BAD_REQUEST);
        }
    }
};
exports.GeocodingService = GeocodingService;
exports.GeocodingService = GeocodingService = GeocodingService_1 = __decorate([
    (0, common_1.Injectable)(),
    __param(0, (0, typeorm_1.InjectRepository)(place_syria_entity_1.PlaceSyria)),
    __param(1, (0, typeorm_1.InjectRepository)(place_jordan_entity_1.PlaceJordan)),
    __param(2, (0, typeorm_1.InjectRepository)(place_egypt_entity_1.PlaceEgypt)),
    __param(3, (0, typeorm_1.InjectRepository)(osm_area_entity_1.OsmArea)),
    __param(4, (0, typeorm_1.InjectRepository)(osm_point_with_area_entity_1.OsmPointWithArea)),
    __param(5, (0, common_1.Inject)(cache_manager_1.CACHE_MANAGER)),
    __metadata("design:paramtypes", [typeof (_a = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _a : Object, typeof (_b = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _b : Object, typeof (_c = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _c : Object, typeof (_d = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _d : Object, typeof (_e = typeof typeorm_2.Repository !== "undefined" && typeorm_2.Repository) === "function" ? _e : Object, Object])
], GeocodingService);
//# sourceMappingURL=geocoding.service.js.map