@studyportals/fawkes 8.1.2-2 → 8.1.2-3

package/dist/src/programmes/rules/MasterOfArtsDisciplineRule.js

@@ -0,0 +1,41 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfArtsDisciplineRule extends BaseProgrammeRule {
+    // Master of Arts accepts all disciplines
+    degreeValue = 'master-of-arts';
+    getName() {
+        return 'MasterOfArtsDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-arts + all disciplines';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        // This rule only applies to Master of Arts
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Must have a discipline selected
+        if (!disciplineValue) {
+            return Promise.resolve(false);
+        }
+        // Master of Arts accepts all disciplines
+        return Promise.resolve(true);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const disciplineValues = filterKeyValues.get(FilterKey.DISCIPLINES);
+        if (!degreeTypeValues?.length || !disciplineValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        // This rule only applies to Master of Arts
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Master of Arts accepts all disciplines
+        return Promise.resolve(true);
+    }
+}

package/dist/src/programmes/rules/MasterOfEducationCountryDisciplineRule.d.ts

@@ -0,0 +1,11 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MasterOfEducationCountryDisciplineRule extends BaseProgrammeRule {
+    private readonly educationDisciplineIds;
+    private readonly allowedCountryIds;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/programmes/rules/MasterOfEducationCountryDisciplineRule.js

@@ -0,0 +1,69 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { DegreeTypeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfEducationCountryDisciplineRule extends BaseProgrammeRule {
+    educationDisciplineIds = [
+        '289', // Education & Training (main discipline)
+        '290', // Adult Education
+        '360', // Art Education
+        '291', // Coaching
+        '292', // School Counselling
+        '333', // Early Childhood Education
+        '8', // Education
+        '349', // Educational Leadership
+        '293', // Educational Psychology
+        '98', // Educational Research
+        '371', // Health Education
+        '363', // Higher Education
+        '355', // Instructional Design
+        '370', // Literacy Education
+        '348', // Primary Education
+        '97', // Special Education
+        '359', // Secondary Education
+        '345', // STEM Education
+        '295', // Teaching
+        '358' // Teaching English as a Foreign Language
+    ];
+    // Australia (202), Canada (32)
+    allowedCountryIds = ['202', '32'];
+    getName() {
+        return 'MasterOfEducationCountryDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-education (Australia, Canada) + education disciplines only';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        if (degreeTypeValue !== DegreeTypeFilterOptionValue.MED) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !disciplineValue) {
+            return Promise.resolve(false);
+        }
+        if (!this.allowedCountryIds.includes(countryValue)) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.educationDisciplineIds.includes(disciplineValue));
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const disciplineValues = filterKeyValues.get(FilterKey.DISCIPLINES);
+        if (!degreeTypeValues?.length || !countryValues?.length || !disciplineValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const disciplineValue = disciplineValues[0];
+        if (degreeTypeValue !== DegreeTypeFilterOptionValue.MED.valueOf()) {
+            return Promise.resolve(true);
+        }
+        if (!this.allowedCountryIds.includes(countryValue)) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.educationDisciplineIds.includes(disciplineValue));
+    }
+}

package/dist/src/programmes/rules/MasterOfLawsCountryAttendanceRule.d.ts

@@ -0,0 +1,12 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MasterOfLawsCountryAttendanceRule extends BaseProgrammeRule {
+    private readonly degreeValue;
+    private readonly attendanceValue;
+    private readonly allowedCountryIds;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/programmes/rules/MasterOfLawsCountryAttendanceRule.js

@@ -0,0 +1,43 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfLawsCountryAttendanceRule extends BaseProgrammeRule {
+    degreeValue = 'master-of-laws';
+    attendanceValue = 'online';
+    allowedCountryIds = ['82', '30', '32', '108'];
+    getName() {
+        return 'MasterOfLawsCountryAttendanceRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-laws (USA, UK, Canada, India) + online attendance';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        if (!degreeTypeValues?.length || !countryValues?.length || !attendanceValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const attendanceValue = attendanceValues[0];
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+}

package/dist/src/programmes/rules/MasterOfLawsCountryTuitionFeeRule.d.ts

@@ -0,0 +1,12 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MasterOfLawsCountryTuitionFeeRule extends BaseProgrammeRule {
+    private readonly degreeValue;
+    private readonly allowedCountryIds;
+    private readonly tuitionFeeValue;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/programmes/rules/MasterOfLawsCountryTuitionFeeRule.js

@@ -0,0 +1,46 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { TuitionFeeFilterOptionValue } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfLawsCountryTuitionFeeRule extends BaseProgrammeRule {
+    degreeValue = 'master-of-laws';
+    allowedCountryIds = ['82', '30', '32', '108']; // USA, UK, Canada, India
+    tuitionFeeValue = TuitionFeeFilterOptionValue.ZERO_TO_TWO_THOUSAND_FIVE_HUNDRED;
+    getName() {
+        return 'MasterOfLawsCountryTuitionFeeRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-laws (USA, UK, Canada, India) + affordable tuition (0-2500)';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const tuitionFeeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.TUITION_FEE, filterState);
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !tuitionFeeValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            tuitionFeeValue === this.tuitionFeeValue);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const tuitionFeeValues = filterKeyValues.get(FilterKey.TUITION_FEE);
+        if (!degreeTypeValues?.length || !countryValues?.length || !tuitionFeeValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const tuitionFeeValue = tuitionFeeValues[0];
+        // This rule only applies to Master of Laws
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Must be in allowed countries and have affordable tuition
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            tuitionFeeValue === this.tuitionFeeValue);
+    }
+}

package/dist/src/programmes/rules/MasterOfPhilosophyCountryAttendanceRule.d.ts

@@ -0,0 +1,12 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MasterOfPhilosophyCountryAttendanceRule extends BaseProgrammeRule {
+    private readonly degreeValue;
+    private readonly attendanceValue;
+    private readonly allowedCountryIds;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/programmes/rules/MasterOfPhilosophyCountryAttendanceRule.js

@@ -0,0 +1,43 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfPhilosophyCountryAttendanceRule extends BaseProgrammeRule {
+    degreeValue = 'master-of-philosophy';
+    attendanceValue = 'online';
+    allowedCountryIds = ['82', '30', '108']; // USA, UK, India
+    getName() {
+        return 'MasterOfPhilosophyCountryAttendanceRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-philosophy (USA, UK, India) + online attendance';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const countryValue = seoInfoBase.getFilterOptionValueBy(FilterKey.COUNTRY, filterState);
+        const attendanceValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DELIVERY_METHOD, filterState);
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        if (!countryValue || !attendanceValue) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const countryValues = filterKeyValues.get(FilterKey.COUNTRY);
+        const attendanceValues = filterKeyValues.get(FilterKey.DELIVERY_METHOD);
+        if (!degreeTypeValues?.length || !countryValues?.length || !attendanceValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        const countryValue = countryValues[0];
+        const attendanceValue = attendanceValues[0];
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true);
+        }
+        return Promise.resolve(this.allowedCountryIds.includes(countryValue) &&
+            attendanceValue === this.attendanceValue);
+    }
+}

package/dist/src/programmes/rules/MasterOfScienceDisciplineRule.d.ts

@@ -0,0 +1,10 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class MasterOfScienceDisciplineRule extends BaseProgrammeRule {
+    private readonly degreeValue;
+    getName(): string;
+    getDescription(): string;
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+}

package/dist/src/programmes/rules/MasterOfScienceDisciplineRule.js

@@ -0,0 +1,41 @@
+import { FilterKey } from '@studyportals/search-filters';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class MasterOfScienceDisciplineRule extends BaseProgrammeRule {
+    // Master of Science accepts all disciplines
+    degreeValue = 'master-of-science';
+    getName() {
+        return 'MasterOfScienceDisciplineRule';
+    }
+    getDescription() {
+        return 'Indexes: master-of-science + all disciplines';
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const degreeTypeValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DEGREE_TYPE, filterState);
+        const disciplineValue = seoInfoBase.getFilterOptionValueBy(FilterKey.DISCIPLINES, filterState);
+        // This rule only applies to Master of Science
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Must have a discipline selected
+        if (!disciplineValue) {
+            return Promise.resolve(false);
+        }
+        // Master of Science accepts all disciplines
+        return Promise.resolve(true);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const degreeTypeValues = filterKeyValues.get(FilterKey.DEGREE_TYPE);
+        const disciplineValues = filterKeyValues.get(FilterKey.DISCIPLINES);
+        if (!degreeTypeValues?.length || !disciplineValues?.length) {
+            return Promise.resolve(false);
+        }
+        const degreeTypeValue = degreeTypeValues[0];
+        // This rule only applies to Master of Science
+        if (degreeTypeValue !== this.degreeValue) {
+            return Promise.resolve(true); // Rule doesn't apply to other degrees
+        }
+        // Master of Science accepts all disciplines
+        return Promise.resolve(true);
+    }
+}

package/dist/src/programmes/rules/OneOrTwoYearDurationRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export declare class OneOrTwoYearDurationRule extends BaseProgrammeFilterKeyValueRule {
+    constructor();
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/programmes/rules/OneOrTwoYearDurationRule.js

@@ -0,0 +1,19 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { DurationFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class OneOrTwoYearDurationRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[
+                FilterKey.DURATION,
+                [DurationFilterOptionValue.ONE_YEAR, DurationFilterOptionValue.TWO_YEARS]
+            ]
+        ]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'OneOrTwoYearDurationRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected duration is one or two years.';
+    }
+}

package/dist/src/programmes/rules/OneYearOnlyRule.d.ts

@@ -0,0 +1,11 @@
+import { ISearchDependencies } from '../../common/ISearchDependencies';
+import { FilterKeyValuesMap } from '../../common/FilterKeyValuesMap';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export declare class OneYearOnlyRule extends BaseProgrammeRule {
+    constructor();
+    forSearch(dependencies: ISearchDependencies): Promise<boolean>;
+    forSitemapGenerator(filterKeyValues: FilterKeyValuesMap): Promise<boolean>;
+    getName(): string;
+    getDescription(): string;
+    private isOneYear;
+}

package/dist/src/programmes/rules/OneYearOnlyRule.js

@@ -0,0 +1,34 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { DurationFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeRule } from '../BaseProgrammeRule';
+export class OneYearOnlyRule extends BaseProgrammeRule {
+    constructor() {
+        super();
+    }
+    forSearch(dependencies) {
+        const { seoInfoBase, filterState } = dependencies;
+        const selectedDuration = seoInfoBase.getFilterOptionValueBy(FilterKey.DURATION, filterState);
+        if (!selectedDuration) {
+            return Promise.resolve(false);
+        }
+        const isOneYear = this.isOneYear(selectedDuration);
+        return Promise.resolve(isOneYear);
+    }
+    forSitemapGenerator(filterKeyValues) {
+        const [selectedDuration] = filterKeyValues.get(FilterKey.DURATION);
+        if (!selectedDuration) {
+            return Promise.resolve(false);
+        }
+        const isOneYear = this.isOneYear(selectedDuration);
+        return Promise.resolve(isOneYear);
+    }
+    getName() {
+        return 'OneYearOnlyRule';
+    }
+    getDescription() {
+        return 'Indexable only if duration is exactly 1 year ([360,360]).';
+    }
+    isOneYear(value) {
+        return value === DurationFilterOptionValue.ONE_YEAR;
+    }
+}

package/dist/src/programmes/rules/OnlineAttendanceRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export declare class OnlineAttendanceRule extends BaseProgrammeFilterKeyValueRule {
+    constructor();
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/programmes/rules/OnlineAttendanceRule.js

@@ -0,0 +1,15 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { AttendanceFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class OnlineAttendanceRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[FilterKey.DELIVERY_METHOD, [AttendanceFilterOptionValue.ONLINE]]]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'OnlineAttendanceRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected attendance is online.';
+    }
+}

package/dist/src/programmes/rules/TwoYearDurationRule.d.ts

@@ -0,0 +1,6 @@
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export declare class TwoYearDurationRule extends BaseProgrammeFilterKeyValueRule {
+    constructor();
+    getName(): string;
+    getDescription(): string;
+}

package/dist/src/programmes/rules/TwoYearDurationRule.js

@@ -0,0 +1,19 @@
+import { FilterKey } from '@studyportals/search-filters/server-side';
+import { DurationFilterOptionValue } from '@studyportals/search-filters/server-side';
+import { BaseProgrammeFilterKeyValueRule } from '../BaseProgrammeFilterKeyValueRule';
+export class TwoYearDurationRule extends BaseProgrammeFilterKeyValueRule {
+    constructor() {
+        const filterKeyValues = new Map([[
+                FilterKey.DURATION,
+                [DurationFilterOptionValue.TWO_YEARS]
+            ]
+        ]);
+        super(filterKeyValues);
+    }
+    getName() {
+        return 'TwoYearDurationRule';
+    }
+    getDescription() {
+        return 'Is indexable if the selected duration is two years.';
+    }
+}

package/dist/src/sitemap-generator/BaseSitemapUrlGeneratorManager.js

@@ -3,7 +3,6 @@ export class BaseSitemapUrlGeneratorManager {
     async generateUrls() {
         const map = new Map();
         for (const policy of this.policies) {
-            console.debug(`Generating sitemap urls for policy: ${policy.filterCombination}`); // eslint-disable-line no-console
             const filterCombination = policy.filterCombination;
             const urls = await policy.generateSitemapUrls();
             console.debug(`Generated ${urls.length} urls for policy: ${filterCombination}`); // eslint-disable-line no-console

package/dist/src/sitemap-generator/IPageNumberProvider.d.ts

@@ -0,0 +1,3 @@
+export interface IPageNumberProvider {
+    getPageNumber(): number;
+}

package/dist/src/sitemap-generator/IPageNumberProvider.js

@@ -0,0 +1 @@
+export {};