@studyportals/fawkes 8.0.1-0 → 8.0.1-1

package/dist/src/programmes/policies/Continent.js

@@ -0,0 +1,36 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { ContinentPresenter } from '../../presenters/ContinentPresenter';
+export class Continent extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Continent Policy';
+    description = 'Governs indexing of continent-level filtered pages.';
+    filterKeys = [FilterKey.CONTINENT];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.CONTINENT),
+        new OnlyFiltersSelectedRule([FilterKey.CONTINENT])
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const continentFragments = ContinentPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const continent of continentFragments) {
+                const filterKeyValues = new Map([[FilterKey.CONTINENT, [continent.id]]]);
+                const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                if (result) {
+                    paths.push(this.getPathWithPageNumber(continent.path, pageNumber));
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.CONTINENT;
+    }
+}

package/dist/src/programmes/policies/ContinentTuitionFee.d.ts

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { AffordableTuitionFeeRule } from '../rules/AffordableTuitionFeeRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class ContinentTuitionFee extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | AffordableTuitionFeeRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/programmes/policies/ContinentTuitionFee.js

@@ -0,0 +1,46 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { AffordableTuitionFeeRule } from '../rules/AffordableTuitionFeeRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { ContinentPresenter } from '../../presenters/ContinentPresenter';
+import { TuitionFeePresenter } from '../../presenters/TuitionFeePresenter';
+export class ContinentTuitionFee extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Continent Tuition Fee Policy';
+    description = 'Determines indexing rules for pages filtered by both continent, and tuition fee, priotizing combinations with affordable tuition fees.';
+    filterKeys = [FilterKey.CONTINENT, FilterKey.TUITION_FEE];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.CONTINENT),
+        new SingleValueSelectedForFilterRule(FilterKey.TUITION_FEE),
+        new OnlyFiltersSelectedRule([FilterKey.CONTINENT, FilterKey.TUITION_FEE]),
+        new AffordableTuitionFeeRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const continentFragments = ContinentPresenter.getInstance().getFragments();
+        const tuitionFeeFragments = TuitionFeePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const continent of continentFragments) {
+                for (const tuitionFee of tuitionFeeFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.CONTINENT, [continent.id]],
+                        [FilterKey.TUITION_FEE, [tuitionFee.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${tuitionFee.path}/${continent.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.CONTINENT_TUITION_FEE;
+    }
+}

package/dist/src/programmes/policies/Country.d.ts

@@ -0,0 +1,15 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class Country extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/programmes/policies/Country.js

@@ -0,0 +1,33 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+export class Country extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Country Policy';
+    description = 'Governs indexing of country-level filtered pages.';
+    filterKeys = [FilterKey.COUNTRY];
+    rules = [new SingleValueSelectedForFilterRule(FilterKey.COUNTRY), new OnlyFiltersSelectedRule([FilterKey.COUNTRY])];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const country of countryFragments) {
+                const filterKeyValues = new Map([[FilterKey.COUNTRY, [country.id]]]);
+                const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                if (result) {
+                    paths.push(this.getPathWithPageNumber(country.path, pageNumber));
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.COUNTRY;
+    }
+}

package/dist/src/programmes/policies/CountryAttendance.d.ts

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class CountryAttendance extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/programmes/policies/CountryAttendance.js

@@ -0,0 +1,46 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
+export class CountryAttendance extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Country Attendance Policy';
+    description = 'Determines indexing rules for pages filtered by both country, and study format (online, on-campus, etc.).';
+    filterKeys = [FilterKey.COUNTRY, FilterKey.DELIVERY_METHOD];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new OnlyFiltersSelectedRule([FilterKey.COUNTRY, FilterKey.DELIVERY_METHOD]),
+        new OnlineAttendanceRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            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.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${attendance.path}/${country.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.COUNTRY_ATTENDANCE;
+    }
+}

package/dist/src/programmes/policies/CountryAttendanceDegree.d.ts

@@ -0,0 +1,17 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { MbaDegreeRule } from '../rules/MbaDegreeRule';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class CountryAttendanceDegree extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OnlineAttendanceRule | MbaDegreeRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/programmes/policies/CountryAttendanceDegree.js

@@ -0,0 +1,55 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { MbaDegreeRule } from '../rules/MbaDegreeRule';
+import { OnlineAttendanceRule } from '../../common/rules/OnlineAttendanceRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+import { AttendancePresenter } from '../../presenters/AttendancePresenter';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+export class CountryAttendanceDegree extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Country Attendance Degree Policy';
+    description = `Determines indexing rules for pages filtered by country,
+		study format (online, on-campus, etc.), and degree type.`;
+    filterKeys = [FilterKey.COUNTRY, FilterKey.DELIVERY_METHOD, FilterKey.DEGREE_TYPE];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DELIVERY_METHOD),
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new OnlyFiltersSelectedRule([FilterKey.COUNTRY, FilterKey.DELIVERY_METHOD, FilterKey.DEGREE_TYPE]),
+        new OnlineAttendanceRule(),
+        new MbaDegreeRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const attendanceFragments = AttendancePresenter.getInstance().getFragments();
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const country of countryFragments) {
+                for (const attendance of attendanceFragments) {
+                    for (const degree of degreeFragments) {
+                        const filterKeyValues = new Map([
+                            [FilterKey.COUNTRY, [country.id]],
+                            [FilterKey.DELIVERY_METHOD, [attendance.id]],
+                            [FilterKey.DEGREE_TYPE, [degree.id]]
+                        ]);
+                        const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                        if (result) {
+                            paths.push(this.getPathWithPageNumber(`${degree.path}/${attendance.path}/${country.path}`, pageNumber));
+                        }
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.COUNTRY_ATTENDANCE_DEGREE;
+    }
+}

package/dist/src/programmes/policies/CountryDegree.d.ts

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { IndexableDegreeRule } from '../rules/IndexableDegreeRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class CountryDegree extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | IndexableDegreeRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/programmes/policies/CountryDegree.js

@@ -0,0 +1,46 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { IndexableDegreeRule } from '../rules/IndexableDegreeRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+export class CountryDegree extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Country Degree Policy';
+    description = 'Determines indexing rules for pages filtered by both country, and degree type.';
+    filterKeys = [FilterKey.COUNTRY, FilterKey.DEGREE_TYPE];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new OnlyFiltersSelectedRule([FilterKey.COUNTRY, FilterKey.DEGREE_TYPE]),
+        new IndexableDegreeRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const country of countryFragments) {
+                for (const degree of degreeFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.COUNTRY, [country.id]],
+                        [FilterKey.DEGREE_TYPE, [degree.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${degree.path}/${country.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.COUNTRY_DEGREE;
+    }
+}

package/dist/src/programmes/policies/CountryDuration.d.ts

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { IndexableDurationRule } from '../rules/IndexableDurationRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class CountryDuration extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | IndexableDurationRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/programmes/policies/CountryDuration.js

@@ -0,0 +1,46 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { IndexableDurationRule } from '../rules/IndexableDurationRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+import { DurationPresenter } from '../../presenters/DurationPresenter';
+export class CountryDuration extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Country Duration Policy';
+    description = 'Determines indexing rules for pages filtered by both country, and duration (1 year, 2 years, etc.).';
+    filterKeys = [FilterKey.COUNTRY, FilterKey.DURATION];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DURATION),
+        new OnlyFiltersSelectedRule([FilterKey.COUNTRY, FilterKey.DURATION]),
+        new IndexableDurationRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const durationFragments = DurationPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const country of countryFragments) {
+                for (const duration of durationFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.COUNTRY, [country.id]],
+                        [FilterKey.DURATION, [duration.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${duration.path}/${country.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.COUNTRY_DURATION;
+    }
+}

package/dist/src/programmes/policies/CountryDurationDegree.d.ts

@@ -0,0 +1,17 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { OneYearDurationRule } from '../rules/OneYearDurationRule';
+import { MbaOrMscDegreeRule } from '../rules/MbaOrMscDegreeRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class CountryDurationDegree extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | OneYearDurationRule | MbaOrMscDegreeRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/programmes/policies/CountryDurationDegree.js

@@ -0,0 +1,55 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { OneYearDurationRule } from '../rules/OneYearDurationRule';
+import { MbaOrMscDegreeRule } from '../rules/MbaOrMscDegreeRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+import { DegreePresenter } from '../../presenters/DegreePresenter';
+import { DurationPresenter } from '../../presenters/DurationPresenter';
+export class CountryDurationDegree extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Country Duration Degree Policy';
+    description = `Determines indexing rules for pages filtered by country,
+		duration (1 year, 2 years, etc.), and degree type.`;
+    filterKeys = [FilterKey.COUNTRY, FilterKey.DURATION, FilterKey.DEGREE_TYPE];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.DURATION),
+        new SingleValueSelectedForFilterRule(FilterKey.DEGREE_TYPE),
+        new OnlyFiltersSelectedRule([FilterKey.COUNTRY, FilterKey.DURATION, FilterKey.DEGREE_TYPE]),
+        new MbaOrMscDegreeRule(),
+        new OneYearDurationRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const degreeFragments = DegreePresenter.getInstance().getFragments();
+        const durationFragments = DurationPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const country of countryFragments) {
+                for (const duration of durationFragments) {
+                    for (const degree of degreeFragments) {
+                        const filterKeyValues = new Map([
+                            [FilterKey.COUNTRY, [country.id]],
+                            [FilterKey.DURATION, [duration.id]],
+                            [FilterKey.DEGREE_TYPE, [degree.id]]
+                        ]);
+                        const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                        if (result) {
+                            paths.push(this.getPathWithPageNumber(`${degree.path}/${duration.path}/${country.path}`, pageNumber));
+                        }
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.COUNTRY_DURATION_DEGREE;
+    }
+}

package/dist/src/programmes/policies/CountryEducationalForm.d.ts

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { IndexableEducationalFormRule } from '../rules/IndexableEducationalFormRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class CountryEducationalForm extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | IndexableEducationalFormRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/programmes/policies/CountryEducationalForm.js

@@ -0,0 +1,47 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { IndexableEducationalFormRule } from '../rules/IndexableEducationalFormRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+import { EducationalFormPresenter } from '../../presenters/EducationalFormPresenter';
+export class CountryEducationalForm extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Country Educational Form Policy';
+    description = `Determines indexing rules for pages filtered by both country,
+		and educational form (academic, semester, summer school, etc.).`;
+    filterKeys = [FilterKey.COUNTRY, FilterKey.EDUCATIONAL_FORM];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.EDUCATIONAL_FORM),
+        new OnlyFiltersSelectedRule([FilterKey.COUNTRY, FilterKey.EDUCATIONAL_FORM]),
+        new IndexableEducationalFormRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const educationalFormFragments = EducationalFormPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const country of countryFragments) {
+                for (const form of educationalFormFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.COUNTRY, [country.id]],
+                        [FilterKey.EDUCATIONAL_FORM, [form.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${country.path}/${form.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.COUNTRY_EDUCATIONAL_FORM;
+    }
+}

package/dist/src/programmes/policies/CountryFormat.d.ts

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { PartTimeFormatRule } from '../rules/PartTimeFormatRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class CountryFormat extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | PartTimeFormatRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}

package/dist/src/programmes/policies/CountryFormat.js

@@ -0,0 +1,46 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { PartTimeFormatRule } from '../rules/PartTimeFormatRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { CountryPresenter } from '../../presenters/CountryPresenter';
+import { FormatPresenter } from '../../presenters/FormatPresenter';
+export class CountryFormat extends ProgrammesBaseIndexabilityPolicy {
+    name = 'Country Format Policy';
+    description = 'Determines indexing rules for pages filtered by both country, and attendance type (part-time or fulltime).';
+    filterKeys = [FilterKey.COUNTRY, FilterKey.ATTENDANCE];
+    rules = [
+        new SingleValueSelectedForFilterRule(FilterKey.COUNTRY),
+        new SingleValueSelectedForFilterRule(FilterKey.ATTENDANCE),
+        new OnlyFiltersSelectedRule([FilterKey.COUNTRY, FilterKey.ATTENDANCE]),
+        new PartTimeFormatRule()
+    ];
+    constructor(dependencies) {
+        super(dependencies);
+        this.initateBaseRules();
+    }
+    async generateUrls() {
+        const countryFragments = CountryPresenter.getInstance().getFragments();
+        const formatFragments = FormatPresenter.getInstance().getFragments();
+        const paths = [];
+        for (const pageNumber of this.indexablePageNumbers) {
+            for (const country of countryFragments) {
+                for (const format of formatFragments) {
+                    const filterKeyValues = new Map([
+                        [FilterKey.COUNTRY, [country.id]],
+                        [FilterKey.ATTENDANCE, [format.id]]
+                    ]);
+                    const result = await this.checkRulesForSitemapWithPageNumber(filterKeyValues, pageNumber);
+                    if (result) {
+                        paths.push(this.getPathWithPageNumber(`${country.path}/${format.path}`, pageNumber));
+                    }
+                }
+            }
+        }
+        return paths;
+    }
+    get filterCombination() {
+        return FilterCombinations.COUNTRY_FORMAT;
+    }
+}

package/dist/src/programmes/policies/CountryTuitionFee.d.ts

@@ -0,0 +1,16 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { OnlyFiltersSelectedRule } from '../../common/rules/OnlyFiltersSelectedRule';
+import { SingleValueSelectedForFilterRule } from '../../common/rules/SingleValueSelectedForFilterRule';
+import { FilterCombinations } from '../../enums/FilterCombinations';
+import { AffordableTuitionFeeRule } from '../rules/AffordableTuitionFeeRule';
+import { ProgrammesBaseIndexabilityPolicy } from '../ProgrammesBaseIndexabilityPolicy';
+import { IProgrammeSeoDependencies } from '../types/IProgrammeSeoDependencies';
+export declare class CountryTuitionFee extends ProgrammesBaseIndexabilityPolicy {
+    readonly name: string;
+    readonly description: string;
+    readonly filterKeys: FilterKey[];
+    protected readonly rules: (SingleValueSelectedForFilterRule | OnlyFiltersSelectedRule | AffordableTuitionFeeRule)[];
+    constructor(dependencies: IProgrammeSeoDependencies);
+    protected generateUrls(): Promise<string[]>;
+    get filterCombination(): FilterCombinations;
+}