@studyportals/fawkes 8.0.1-0 → 8.0.1-1

package/dist/src/organisations/policies/our-picks/CountryAttendance.js

@@ -0,0 +1,43 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { SortingOptions } from '../../../enums/SortingOptions';
+import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { SearchVolumeCountriesAttendanceRule } from '../../../organisations/rules/SearchVolumeCountriesAttendanceRule';
+import { CountryPresenter } from '../../../presenters/CountryPresenter';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
+export class CountryAttendance extends OrganisationsSeoIndexabilityPolicy {
+    name = 'Country Attendance Policy';
+    description = 'Regulates indexability for pages combining country and attendance type filters, optimizing for country-specific study format pages.';
+    sortingOption = SortingOptions.OUR_PICKS;
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new OnlyFiltersSelectedRule([FilterKey.COUNTRY, FilterKey.DELIVERY_METHOD]),
+        new SearchVolumeCountriesAttendanceRule(),
+        new OnlineAttendanceRule()
+    ];
+    get filterCombination() {
+        return FilterCombinations.COUNTRY_ATTENDANCE;
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const country of countryFragments) {
+            for (const attendance of attendanceFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.COUNTRY, [country.id]],
+                    [FilterKey.DELIVERY_METHOD, [attendance.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${country.path}`));
+                }
+            }
+        }
+        return paths;
+    }
+}

package/dist/src/organisations/policies/our-picks/Unfiltered.d.ts

@@ -0,0 +1,12 @@
+import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { SortingOptions } from '../../../enums/SortingOptions';
+import { NoFiltersSelectedRule } from '../../../common/rules/NoFiltersSelectedRule';
+export declare class Unfiltered extends OrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly sortingOption = SortingOptions.OUR_PICKS;
+    protected readonly baseRules: NoFiltersSelectedRule[];
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/organisations/policies/our-picks/Unfiltered.js

@@ -0,0 +1,16 @@
+import { OrganisationsSeoIndexabilityPolicy } from '../../../organisations/policies/OrganisationsSeoIndexabilityPolicy';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { SortingOptions } from '../../../enums/SortingOptions';
+import { NoFiltersSelectedRule } from '../../../common/rules/NoFiltersSelectedRule';
+export class Unfiltered extends OrganisationsSeoIndexabilityPolicy {
+    name = 'Unfiltered Policy';
+    description = 'Defines indexability rules for unfiltered pages, managing crawl budget by ensuring only high-value aggregate pages are included in the sitemap.';
+    sortingOption = SortingOptions.OUR_PICKS;
+    baseRules = [new NoFiltersSelectedRule()];
+    generateUrls() {
+        return Promise.resolve([this.getPathWithSortingOption('')]);
+    }
+    get filterCombination() {
+        return FilterCombinations.UNFILTERED;
+    }
+}

package/dist/src/organisations/policies/ranked/RankedArea.d.ts

@@ -0,0 +1,13 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedArea extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/organisations/policies/ranked/RankedArea.js

@@ -0,0 +1,36 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { AreaPresenter } from '../../../presenters/AreaPresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedArea extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Area Policy';
+    description = 'Controls indexing for ranking-sorted pages filtered by geographic areas, optimizing for region-specific content with quality-based result ordering.';
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.AREA),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY])
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async generateUrls() {
+        const areaFragments = AreaPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const area of areaFragments) {
+            const filterKeyValues = new Map([
+                [FilterKey.AREA, [area.id]],
+                [FilterKey.COUNTRY, [area.countryId]]
+            ]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(area.path));
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_AREA;
+    }
+}

package/dist/src/organisations/policies/ranked/RankedAreaDiscipline.d.ts

@@ -0,0 +1,14 @@
+import { SearchVolumeAreasDisciplineRule } from '../../../organisations/rules/SearchVolumeAreasDisciplineRule';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedAreaDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | SearchVolumeAreasDisciplineRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
+}

package/dist/src/organisations/policies/ranked/RankedAreaDiscipline.js

@@ -0,0 +1,44 @@
+import { SearchVolumeAreasDisciplineRule } from '../../../organisations/rules/SearchVolumeAreasDisciplineRule';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { AreaPresenter } from '../../../presenters/AreaPresenter';
+import { DisciplinePresenter } from '../../../presenters/DisciplinePresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedAreaDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Area Discipline Policy';
+    description = 'Controls indexing for ranking-sorted pages filtered by geographic areas, optimizing for region-specific content with quality-based result ordering.';
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.AREA),
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
+        new OnlyFiltersSelectedRule([FilterKey.AREA, FilterKey.COUNTRY, FilterKey.DISCIPLINES]),
+        new SearchVolumeAreasDisciplineRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_AREA_DISCIPLINE;
+    }
+    async generateUrls() {
+        const areaFragments = AreaPresenter.getInstance().getFragments();
+        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const area of areaFragments) {
+            for (const discipline of disciplineFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.AREA, [area.id]],
+                    [FilterKey.COUNTRY, [area.countryId]],
+                    [FilterKey.DISCIPLINES, [discipline.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${area.path}/${discipline.path}`));
+                }
+            }
+        }
+        return paths;
+    }
+}

package/dist/src/organisations/policies/ranked/RankedAttendance.d.ts

@@ -0,0 +1,14 @@
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedAttendance extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/organisations/policies/ranked/RankedAttendance.js

@@ -0,0 +1,34 @@
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedAttendance extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Attendance Policy';
+    description = 'Determines which ranking-sorted pages filtered by attendance type qualify for indexing based on format-specific search patterns.';
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD]),
+        new OnlineAttendanceRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async generateUrls() {
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const attendance of attendanceFragments) {
+            const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, [attendance.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(attendance.path));
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_ATTENDANCE;
+    }
+}

package/dist/src/organisations/policies/ranked/RankedAttendanceDiscipline.d.ts

@@ -0,0 +1,14 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedAttendanceDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    get filterCombination(): FilterCombinations;
+    protected generateUrls(): Promise<string[]>;
+}

package/dist/src/organisations/policies/ranked/RankedAttendanceDiscipline.js

@@ -0,0 +1,42 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
+import { DisciplinePresenter } from '../../../presenters/DisciplinePresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedAttendanceDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Attendance Discipline Policy';
+    description = 'Manages indexing for ranking-sorted pages at the intersection of attendance type and academic discipline filters.';
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
+        new OnlyFiltersSelectedRule([FilterKey.DELIVERY_METHOD, FilterKey.DISCIPLINES]),
+        new OnlineAttendanceRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_ATTENDANCE_DISCIPLINE;
+    }
+    async generateUrls() {
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const attendance of attendanceFragments) {
+            for (const discipline of disciplineFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.DELIVERY_METHOD, [attendance.id]],
+                    [FilterKey.DISCIPLINES, [discipline.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${discipline.path}`));
+                }
+            }
+        }
+        return paths;
+    }
+}

package/dist/src/organisations/policies/ranked/RankedContinent.d.ts

@@ -0,0 +1,13 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedContinent extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/organisations/policies/ranked/RankedContinent.js

@@ -0,0 +1,32 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { ContinentPresenter } from '../../../presenters/ContinentPresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedContinent extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Continent Policy';
+    description = 'Regulates indexability of ranking-sorted continent-level filtered pages, prioritizing high-value continental views with quality-based sorting.';
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.CONTINENT),
+        new OnlyFiltersSelectedRule([FilterKey.CONTINENT])
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async generateUrls() {
+        const continentFragments = ContinentPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const continent of continentFragments) {
+            const filterKeyValues = new Map([[FilterKey.CONTINENT, [continent.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(continent.path));
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_CONTINENT;
+    }
+}

package/dist/src/organisations/policies/ranked/RankedContinentAttendance.d.ts

@@ -0,0 +1,15 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { ContinentIsEuropeRule } from '../../../organisations/rules/ContinentIsEuropeRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedContinentAttendance extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | ContinentIsEuropeRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/organisations/policies/ranked/RankedContinentAttendance.js

@@ -0,0 +1,44 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { ContinentIsEuropeRule } from '../../../organisations/rules/ContinentIsEuropeRule';
+import { ContinentPresenter } from '../../../presenters/ContinentPresenter';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedContinentAttendance extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Continent Attendance Policy';
+    description = 'Controls indexing for ranking-sorted pages combining continent and attendance filters, optimizing for continental study format combinations.';
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.CONTINENT),
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new OnlyFiltersSelectedRule([FilterKey.CONTINENT, FilterKey.DELIVERY_METHOD]),
+        new ContinentIsEuropeRule(),
+        new OnlineAttendanceRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async generateUrls() {
+        const continentFragments = ContinentPresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const continent of continentFragments) {
+            for (const attendance of attendanceFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.CONTINENT, [continent.id]],
+                    [FilterKey.DELIVERY_METHOD, [attendance.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${continent.path}`));
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_CONTINENT_ATTENDANCE;
+    }
+}

package/dist/src/organisations/policies/ranked/RankedCountry.d.ts

@@ -0,0 +1,13 @@
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedCountry extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/organisations/policies/ranked/RankedCountry.js

@@ -0,0 +1,29 @@
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { CountryPresenter } from '../../../presenters/CountryPresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedCountry extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Country Policy';
+    description = 'Manages indexability of ranking-sorted country-specific pages, applying rules to prioritize countries where quality-based sorting adds search value.';
+    baseRules = [new SingleValueSelectedForFilterRule(FilterKey.COUNTRY), new OnlyFiltersSelectedRule([FilterKey.COUNTRY])];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const country of countryFragments) {
+            const filterKeyValues = new Map([[FilterKey.COUNTRY, [country.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(country.path));
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_COUNTRY;
+    }
+}

package/dist/src/organisations/policies/ranked/RankedCountryAttendance.d.ts

@@ -0,0 +1,14 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedCountryAttendance extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/organisations/policies/ranked/RankedCountryAttendance.js

@@ -0,0 +1,42 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { OnlineAttendanceRule } from '../../../common/rules/OnlineAttendanceRule';
+import { CountryPresenter } from '../../../presenters/CountryPresenter';
+import { AttendancePresenter } from '../../../presenters/AttendancePresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedCountryAttendance extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Country Attendance Policy';
+    description = 'Governs indexing for ranking-sorted pages filtered by both country and attendance type, optimizing for country-specific study format combinations with quality sorting.';
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new OnlyFiltersSelectedRule([FilterKey.COUNTRY, FilterKey.DELIVERY_METHOD]),
+        new OnlineAttendanceRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const country of countryFragments) {
+            for (const attendance of attendanceFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.COUNTRY, [country.id]],
+                    [FilterKey.DELIVERY_METHOD, [attendance.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${attendance.path}/${country.path}`));
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_COUNTRY_ATTENDANCE;
+    }
+}

package/dist/src/organisations/policies/ranked/RankedCountryDiscipline.d.ts

@@ -0,0 +1,13 @@
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedCountryDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/organisations/policies/ranked/RankedCountryDiscipline.js

@@ -0,0 +1,40 @@
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { CountryPresenter } from '../../../presenters/CountryPresenter';
+import { DisciplinePresenter } from '../../../presenters/DisciplinePresenter';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+export class RankedCountryDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Country Discipline Policy';
+    description = 'Determines which ranking-sorted pages at the intersection of country and discipline filters qualify for indexing based on search value.';
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
+        new OnlyFiltersSelectedRule([FilterKey.COUNTRY, FilterKey.DISCIPLINES])
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const country of countryFragments) {
+            for (const discipline of disciplineFragments) {
+                const filterKeyValues = new Map([
+                    [FilterKey.COUNTRY, [country.id]],
+                    [FilterKey.DISCIPLINES, [discipline.id]]
+                ]);
+                const result = await this.checkRulesForSitemap(filterKeyValues);
+                if (result) {
+                    paths.push(this.getPathWithSortingOption(`${country.path}/${discipline.path}`));
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_DISCIPLINE_COUNTRY;
+    }
+}

package/dist/src/organisations/policies/ranked/RankedDiscipline.d.ts

@@ -0,0 +1,13 @@
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/organisations/policies/ranked/RankedDiscipline.js

@@ -0,0 +1,32 @@
+import { SingleValueSelectedForFilterRule } from '../../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../../common/rules/OnlyFiltersSelectedRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { DisciplinePresenter } from '../../../presenters/DisciplinePresenter';
+export class RankedDiscipline extends RankedOrganisationsSeoIndexabilityPolicy {
+    name = 'Ranked Discipline Policy';
+    description = 'Regulates indexability of ranking-sorted discipline-specific pages, prioritizing academic fields where quality-based sorting enhances user experience.';
+    baseRules = [
+        new SingleValueSelectedForFilterRule(FilterKey.DISCIPLINES),
+        new OnlyFiltersSelectedRule([FilterKey.DISCIPLINES])
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+    }
+    async generateUrls() {
+        const disciplineFragments = DisciplinePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const discipline of disciplineFragments) {
+            const filterKeyValues = new Map([[FilterKey.DISCIPLINES, [discipline.id]]]);
+            const result = await this.checkRulesForSitemap(filterKeyValues);
+            if (result) {
+                paths.push(this.getPathWithSortingOption(discipline.path));
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.RANKED_DISCIPLINE;
+    }
+}

package/dist/src/organisations/policies/ranked/RankedUnfiltered.d.ts

@@ -0,0 +1,12 @@
+import { FilterCombinations } from '../../../enums/FilterCombinations';
+import { NoFiltersSelectedRule } from '../../../common/rules/NoFiltersSelectedRule';
+import { RankedOrganisationsSeoIndexabilityPolicy } from '../RankedOrganisationsSeoIndexabilityPolicy';
+import { IOrganisationsSeoDependencies } from '../../../organisations/types/IOrganisationsSeoDependencies';
+export declare class RankedUnfiltered extends RankedOrganisationsSeoIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    protected readonly baseRules: NoFiltersSelectedRule[];
+    constructor(dependencies: IOrganisationsSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}