import * as _angular_core from '@angular/core';
import { OnInit, EventEmitter, InjectionToken, AfterViewInit, ElementRef, QueryList, ChangeDetectorRef, OnChanges, SimpleChanges, OnDestroy, DestroyRef, Signal } from '@angular/core';
import * as _annalib_anna_core from '@annalib/anna-core';
import { ICustomSingleSelect, IRadioButtonComponentConfig, IGtTableHeader, ITotalRowInfo, IGtGeneralConfig, ICustomMultiSelect, IConfirmationPopupConfig, ListingTab, AnnaGlobalConfigService, AnnaDateTimeFormatService, IWeekCalendar, NgbDateType, AnnaPersistingFilterService, AnnaFilterService, IHeaderInfo } from '@annalib/anna-core';
import { SingleSelectIdText, IdText, MultiSelectIdText, KeyValue as KeyValue$1, EasyFilters, MessageBoxData, GenericCommentPopupModel, EasyFilterEmittedData, ConfirmationPopupComponent, PeriodSelectionPopUp, PrimaryFiltersData, PersistedDashboardPrimaryFilters, DashboardFilterSelectionPopUp, BreadcrumbsService } from '@annalib/anna-design-components-lib';
import { NgbDate, NgbModalRef, NgbModalOptions, NgbModal, NgbTooltip } from '@ng-bootstrap/ng-bootstrap';
import * as _annalib_anna_feature_radiant from '@annalib/anna-feature-radiant';
import { CurrencyPipe } from '@angular/common';
import { Observable, Subject } from 'rxjs';
import * as _angular_router from '@angular/router';
import { ActivatedRoute, ParamMap } from '@angular/router';
import * as _angular_forms from '@angular/forms';
import { ControlValueAccessor, FormGroup, FormControl, FormArray, AbstractControl, ValidationErrors, Validators } from '@angular/forms';
import { HubConnection } from '@microsoft/signalr';
import { ChartTypeRegistry, ChartData } from 'chart.js';

interface GeneralRulesSelectedData {
    maxSpotsStripPerHalfHrDaily: number;
    maxSpotsStripPerHalfHrWeekly: number;
    maxSpotsStripPerHalfHrToOneHrDaily: number;
    maxSpotsStripPerHalfHrToOneHrWeekly: number;
    maxSpotsStripPerOneHrToTwoHrDaily: number;
    maxSpotsStripPerOneHrToTwoHrWeekly: number;
    maxSpotsStripPerTwoHrPlusDaily: number;
    maxSpotsStripPerTwoHrPlusWeekly: number;
    maxSpotsOtoPerHalfHrDaily: number;
    maxSpotsOtoPerHalfHrToOneHrDaily: number;
    maxSpotsOtoPerOneHrToTwoHrDaily: number;
    maxSpotsOtoPerTwoHrPlusDaily: number;
}
interface MakeGoodRulesSelectedData {
    allowedInventory: SingleSelectIdText;
    timeWindow: SingleSelectIdText;
    primeTime: SingleSelectIdText;
    sports: SingleSelectIdText;
    allowWeekendsOnWeekdays: boolean;
    allowWeekdaysOnWeekends: boolean;
    allowSportsPermittedAlternative: boolean;
    programThresholdAllowed: boolean;
}
interface AduRulesSelectedData {
    maximumCap: number;
    timeWindow: SingleSelectIdText;
    programThresholdAllowed: boolean;
    daypartGroups: DaypartGroupsList[];
}
declare class MaxSpots {
    perHalfHour: number;
    halfHourToOneHour: number;
    oneHourToTwoHour: number;
    twoHourPlus: number;
    constructor(data: any);
}
declare class GeneralRules {
    minSeparationTime: string;
    maxSpotsAllowedInOto: MaxSpots;
    maxSpotsAllowedInStripeDaily: MaxSpots;
    maxSpotsAllowedInStripeWeekly: MaxSpots;
    constructor(data: any);
}
declare class MakegoodRules {
    allowedInventory: SingleSelectIdText[];
    timeWindow: SingleSelectIdText[];
    sportsPermittedAlternative: SingleSelectIdText[];
    primeTimePermittedAlternative: SingleSelectIdText[];
    allowWeekendsOnWeekdays: boolean;
    allowWeekdaysOnWeekends: boolean;
    allowSportsPermittedAlternative: boolean;
    programThresholdAllowed: boolean;
    constructor(data: any);
}
declare class AduRules {
    programThresholdAllowed: boolean;
    maxPercentageThreshold: number;
    timeWindow: SingleSelectIdText[];
    daypartGroups: DaypartGroups;
    constructor(data: any);
}
declare class DaypartGroups {
    daypartGroupList: DaypartGroupsList[];
    allDaypartGroups: IdText[];
    constructor(data: any);
}
declare class DaypartGroupsList {
    groupName: string;
    dayparts: IdText[];
    isDuplicateGroupName: boolean;
    constructor(groupName: string, daypartList: any);
}
interface BusinessRulesForPayload {
    GeneralBusinessRules: GeneralBusinessRules;
    MakeGoodBusinessRules: MakeGoodBusinessRules;
    AduBusinessRules: AduBusinessRules;
}
interface GeneralBusinessRules {
    MinimumSeparationTime: string;
    MaxSpotsAllowedInOTO: MaxSpotsPayload;
    MaxSpotsAllowedInStripeDaily: MaxSpotsPayload;
    MaxSpotsAllowedInStripeWeekly: MaxSpotsPayload;
}
interface MaxSpotsPayload {
    PerHalfHour: number;
    HalfHourToOneHour: number;
    OneHourToTwoHours: number;
    TwoHoursPlus: number;
}
interface MakeGoodBusinessRules {
    AllowedInventory: string;
    TimeWindow: string;
    AllowWeekdaysOnWeekends: boolean;
    AllowWeekendsOnWeekdays: boolean;
    IsSportsPermittedAlternativeEnabled: boolean;
    SportsPermittedAlternative: string;
    PrimeTimePermittedAlternative: string;
    ProgramThresholdAllowed: boolean;
}
interface AduBusinessRules {
    MaxPercentageThreshold: number;
    TimeWindow: string;
    ProgramThresholdAllowed: boolean;
    DaypartGroups: DaypartGroupPayload[];
}
interface DaypartGroupPayload {
    GroupName: string;
    Dayparts: string[];
}

type State = "SELECTED" | "UNSELECTED" | "INDETERMINATE";
declare function getSelectionState(selectedCount: number, totalCount: number): State;
interface DaypartFormData {
    tableData: DaypartCategory[];
    timezoneHeaders: string[];
}
/** Major category code → GRP % entered in daypart dispersion (0 allowed; null = missing). */
type GrpByMajorDp = Record<string, number | null>;
declare class DaypartCategory {
    category: string;
    state: State;
    dayparts: Daypart[];
    selectedCount: number;
    totalCount: number;
    /** Major-level GRP % used in daypart dispersion mode. */
    grp?: number | null;
    constructor(data: any, draftDp: CommonDaypartTarget[]);
}
declare class Daypart {
    id: string;
    name: string;
    isSelected: boolean;
    grp: number | null;
    daysDropdown: MultiSelectIdText[];
    displayDays: string;
    selectedDays: MultiSelectIdText[];
    timezones: TimezoneEntry[];
    static daysIndex: Record<number, string>;
    static stringDaysIndex: any;
    static shortDaysIndex: Record<number, string>;
    constructor(dp: any, selectedDps: CommonDaypartTarget[]);
    getDisplayDays(): string;
}
declare class TimezoneEntry {
    timezoneRegion: string;
    displayTime: string;
    startTime: string;
    endTime: string;
    originalStartTime: string;
    originalEndTime: string;
    constructor(tz: any, draftTz: TimezonePayload);
    getDisplayTime(): string;
}
interface DaypartPayload {
    StationNames: string[];
}
interface CommonDaypartTarget {
    DaypartId: string;
    TimezonesForDaypart: TimezonePayload[];
    DaysValid: number[];
    IsSelected: boolean;
}
interface TimezonePayload {
    TimezoneRegion: string;
    StartTime: string;
    EndTime: string;
}
interface DaypartDispersionEntry {
    DaypartName: string;
    TargetImpressionsPercentage: number | null;
}

interface MarketUniverseEstimatesGrpBudgetPayload {
    Demo: string;
    FlightStartDate: string;
    FlightEndDate: string;
    MarketNames: string[];
}
interface MeasurementAgencyUniverseSize {
    MeasurementAgencyName: string;
    UniverseSize: number;
}
interface MarketEquivalentImpressionResponse {
    MarketName: string;
    UniverseSize: MeasurementAgencyUniverseSize[];
}
interface MarketTarget {
    MarketName: string;
    TargetGrp: number;
    TargetImpressions: number;
    TargetBudget: number;
}
interface SelectedMarketWiseGrpOrBudget {
    selectedRadio: "GRP" | "BUDGET";
    isInputTouched: boolean;
    GrpOrBudget: string;
    marketWiseData: MarketWiseValue[];
    plannedDemo: string;
}
interface MarketWiseValue {
    name: string;
    value: DigitOnlyValue;
    marketNameWoRank: string;
    marketWiseUniverseSize: number;
    equivalentImpressions: number | null;
    displayEquivalentImpressions: string;
    displayUniverseSize: string;
    gtClass?: string;
}
interface DigitOnlyValue {
    value: string | null;
    decimalPlaces: number;
    prefix?: string;
}

interface PrimaryInfoDropdowns {
    advertisers: SingleSelectIdText[];
    agencies: SingleSelectIdText[];
    postingTypes: SingleSelectIdText[];
    demos: SingleSelectIdText[];
    spotDurations: SingleSelectIdText[];
    productCodes: SingleSelectIdText[];
}
interface PrimaryInfoSelectedData {
    advertiser: SingleSelectIdText;
    agency?: SingleSelectIdText;
    campaignName: string;
    buyerEstimate: string;
    startDate: NgbDate;
    endDate: NgbDate;
    postingType: SingleSelectIdText;
    demo: SingleSelectIdText;
    spotDurations: SingleSelectIdText;
    productCode: SingleSelectIdText;
    productDesc: string;
}
interface BuyerContactDetails {
    name: string;
    email: string;
    phoneNo: string;
}
interface BuyerContactFromDraft {
    Name: string;
    Email: string;
    ContactNumber: string;
}

interface PrimeTimePayload {
    FlightStartDate: string;
    FlightEndDate: string;
    StationNames: string[];
    DaypartTarget: CommonDaypartTarget[];
}
interface PrimeProgramsTimeWise {
    StartTime: string;
    EndTime: string;
    ProgramIds: string[];
}
interface PrimeProgramsDayWise {
    DayOfWeek: string;
    PrimeProgramsTimeWise: PrimeProgramsTimeWise[];
}
declare class PrimeTime {
    showOtherPrimeProgramsCheckbox: boolean;
    previousShowOtherPrimeProgramsCheckbox: boolean;
    programsForWeek: DayProgram[];
    constructor(data: any, draftProgramsForWeek: PrimeProgramsDayWise[], draftIsOtherPrimeProgramsSelected: boolean);
}
declare class DayProgram {
    day: string;
    displayDay: string;
    state: State;
    time: TimeSlotGroup[];
    selectedCount: number;
    totalCount: number;
    constructor(data: any, draftProgramsForWeek: PrimeProgramsDayWise[]);
}
declare class TimeSlotGroup {
    timeSlot: string;
    startTime: string;
    endTime: string;
    state: State;
    affiliates: AffiliateProgram[];
    selectedCount: number;
    totalCount: number;
    constructor(data: any, timeWisePrograms: PrimeProgramsTimeWise[]);
}
declare class AffiliateProgram {
    affiliateName: string;
    programs: string;
    programIds: string[];
    isSelected: boolean;
    constructor(data: any, programIds: string[]);
}

interface SportsProgramPayload {
    StartDate: string;
    EndDate: string;
}
interface SportsProgramApiResponse {
    League: string;
    SportsName: string;
    Stage: string;
    EventTier: string;
    StartDate: string;
    EndDate: string;
    IsMajorEvent: boolean;
    IsSelected: boolean;
}
interface SportsProgramsApiResponse {
    MajorSportProgramming: SportsProgramApiResponse[];
    SpecialitySportProgramming: SportsProgramApiResponse[];
}
interface SportEvent {
    League: string;
    SportsName: string;
    Stage: string;
    EventTier: string;
    StartDate: string;
    EndDate: string;
    IsMajorEvent: boolean;
}
interface SportEventToBEResponse {
    League: string;
    SportsName: string;
    Stage: string;
    EventTier: string;
}
declare class SportsProgram {
    League: string;
    SportsName: string;
    Stage: string;
    EventTier: string;
    IsMajorEvent: boolean;
    IsSelected: boolean;
    Date: string;
    startDate: string;
    endDate: string;
    MajorEventLabel: string;
    constructor(data: SportsProgramApiResponse, draftSportsProgram?: SportEvent[]);
}

interface HiatusDate {
    StartDate: string;
    EndDate: string;
}
interface MonthWiseHiatusDateData {
    displayDate: string;
    monthName: string;
    value: string;
    isDisabled: boolean;
    schedulableDays: number;
}
interface HiatusDateMonthSpotDispersion {
    hiatusDates: HiatusDate[];
    monthWiseSpotData: MonthWiseHiatusDateData[];
}
interface WeekSpotDispersionPayload {
    FlightStartDate: string;
    FlightEndDate: string;
    HiatusDates: HiatusDate[];
}
/** Broadcast-month row used while building spot-dispersion month pacing data. */
interface SpotDispersionMonthRange {
    MonthName: string;
    MonthNameWithRange: string;
    IsEnabled: boolean;
    schedulableDays: number;
}
interface MonthWiseTargetPercentage {
    MonthName: string;
    MonthNameWithRange: string;
    TargetPercentage: number;
}
interface TimeInput {
    hour: number;
    minute: number;
    second: number;
}

declare class MarketWiseStationTableData {
    marketName: string;
    stations: StationTableData[];
    constructor(marketName: string, stations: any, selectedStations: string[]);
}
declare class StationTableData {
    stationName: string;
    isSelected: boolean;
    state: string;
    affiliate: string;
    measurementAgencies: SingleSelectIdText[];
    selectedMeasurementAgency: SingleSelectIdText;
    marketShare: number;
    error: "EXCEED" | "OVERFLOW";
    disableInput: boolean;
    constructor(data: any, selectedStations: string[]);
}
interface StationTableHeaders {
    headerName: string;
    width: string;
}
interface Affiliates {
    name: string;
    isSelected: boolean;
}
interface StationTarget extends CommonStationTarget {
    TargetPercentage: number;
}
interface CommonStationTarget {
    StationName: string;
    MeasurementAgencyName: string;
    IsSelected: boolean;
}

interface AvailsPropertyFromBackend {
    MarketName: string;
    MarketDisplayName: string;
    StationName: string;
    Program: string;
    ProgramGenre: string;
    StartDate: string;
    EndDate: string;
    Days: string;
    Cpm: number;
    CpmAsDisplay: string;
    Cpp: number;
    CppAsDisplay: string;
    ProgramTimeData: string[];
    Daypart: string;
    Length: string;
    BookedImps: number;
    BookedImpsAsDisplay: string;
    BookedRating: number;
    BookedRatingAsDisplay: string;
    BookedNormalizedImps: number;
    BookedNormalizedImpsAsDisplay: string;
    BookedNormalizedRating: number;
    BookedNormalizedRatingAsDisplay: string;
    Rate: number;
    RateAsDisplay: string;
    YmcRate?: number;
    YmcRateAsDisplay?: string;
    FloorRate?: number;
    FloorRateAsDisplay?: string;
    IsSelected: boolean;
    InvCodeId: number;
    InventoryCode: string;
    StationProgramId: string;
    AvailableWeeks: string[];
    ProgramRepeatStatus: string;
    BookedDemoUniverseSize: number;
    NormalizedDemoUniverseSize: number;
    ModifiedRate: number;
    ModifiedRateAsDisplay: string;
    ModifiedBookedCpm: number;
    ModifiedBookedCpmAsDisplay: string;
    ModifiedNormalizedCpm: number;
    ModifiedNormalizedCpmAsDisplay: string;
    ModifiedBookedCpp: number;
    ModifiedBookedCppAsDisplay: string;
    ModifiedNormalizedCpp: number;
    ModifiedNormalizedCppAsDisplay: string;
    ModifiedBookedImps: number;
    ModifiedBookedImpsAsDisplay: string;
    ModifiedBookedRating: number;
    ModifiedBookedRatingAsDisplay: string;
    ModifiedBookedNormalizedImps: number;
    ModifiedBookedNormalizedImpsAsDisplay: string;
    ModifiedBookedNormalizedRating: number;
    ModifiedBookedNormalizedRatingAsDisplay: string;
    Status?: "Edited" | "Removed" | "Added";
    ChangeLog?: {
        Key: string;
        OldValue: string;
    }[];
    NegotiationRowId?: string;
}
interface Avails extends AvailsPropertyFromBackend {
    formattedTime: string;
    startTime: string;
    endTime: string;
    startEndTime: string[];
    startDate: string;
    endDate: string;
    displayLengthForUIPurposeOnly: string;
    rateDigitOnlyInput: AvailsDigitOnlyInput;
    bookedImpsDigitOnlyInput: AvailsDigitOnlyInput;
    normalizedImpsDigitOnlyInput: AvailsDigitOnlyInput;
    [key: string]: any;
}
interface AvailsDigitOnlyInput {
    type: string;
    min: number;
    value: number;
    placeholder: string;
    disabled: boolean;
    /**
     * Optional prefix shown inside the input UI (e.g. '$').
     * Kept optional so existing digit-only inputs don't change.
     */
    prefix?: string;
    showWarning?: boolean;
    hasError?: boolean;
    warningTooltip?: string;
}
interface GenerateAvailsPayload {
    AdvertiserName: string;
    PlanningDemo: string;
    PostingType: string;
    SpotDuration: string;
    FlightStartDate: string;
    FlightEndDate: string;
    MarketNames: string[];
    StationTarget: CommonStationTarget[];
    DaypartTarget: CommonDaypartTarget[];
    DaypartDispersion: DaypartDispersionEntry[] | null;
    SpecialProgramIds: string[];
    SportEvents: SportEventToBEResponse[];
    PrimeProgramsDayWise: PrimeProgramsDayWise[];
    IsOtherPrimeProgramsSelected: boolean;
    HiatusDates: HiatusDate[] | null;
    MonthWiseTargetPercentage: MonthWiseTargetPercentage[] | null;
    BusinessRules: BusinessRulesForPayload | null;
}
type DownloadButtonValue = "EntireAvails" | "ShortlistedAvails";
interface DownloadSheetData {
    generatedBy: string;
    advertiser: string;
    agency: string;
    flightStartDate: string;
    flightEndDate: string;
    postingType: string;
    marketNames: string[];
    stationNames: string[];
}
interface PayloadForDownloadAvails {
    GeneratedBy: string;
    AdvertiserName: string;
    AgencyName: string;
    FlightStartDate: string;
    FlightEndDate: string;
    PostingType: string;
    BookedDemo: string;
    Avails: AvailsPropertyFromBackend[];
    Markets: string[];
    Stations: string[];
}
interface PayloadForEmailAvails extends PayloadForDownloadAvails {
    CampaignId: number;
    CampaignName: string;
    SpotDuration: string;
    ProductCode: string;
    BuyerEstimate: string;
    ProductDescription: string;
    LastSavedStep: string;
    LastUpdatedBy: string;
    CreatedByUserId: string;
    IsAvailsFinalized: boolean;
    AvailsGeneratedOn: string;
    MarketTarget: MarketTarget[];
    StationTarget: StationTarget[];
    DaypartTarget: CommonDaypartTarget[];
    DaypartDispersion: DaypartDispersionEntry[] | null;
    SpecialProgramIds: string[];
    SportEvents: SportEventToBEResponse[];
    PrimeProgramsDayWise: PrimeProgramsDayWise[];
    IsOtherPrimeProgramsSelected: boolean;
    Buyers?: BuyerContactFromDraft[];
    Comment?: string;
}

type CampaignStatus = 'NEW' | 'EXPIRED' | 'STATION_PENDING' | 'REVISED' | 'PLAN_IN_PROGRESS';
type AvailLineEditStatus = 'Edited' | 'Removed' | 'Added';
type AvailCommentFilter = 'All' | 'Buyer' | 'Station';
type AvailAuthorRole = 'Buyer' | 'Station';
interface AvailChangeLogEntry {
    Key: string;
    OldValue: string;
}
interface AvailCommentEntry {
    CommentId?: string;
    Text: string;
    AuthorRole: AvailAuthorRole;
    AuthorDisplayName: string;
    CreatedAtUtc: string;
    Version: string;
}
declare function getLatestAvailCommentForVersion(commentHistory: AvailCommentEntry[] | null | undefined, versionNumber: string | null | undefined): AvailCommentEntry | null;
interface AvailVersionSummaryEntry {
    VersionNumber: string;
    UserType: AvailAuthorRole;
    CreatedBy: string;
    CreatedDate: string;
}
/** Backend fields compared when seller edits avails before SubmitAvailRevision. */
type SubmitRevisionEditKey = 'ModifiedRate' | 'ModifiedBookedImps' | 'ModifiedBookedNormalizedImps' | 'IsSelected';
declare const SUBMIT_REVISION_EDIT_KEYS: readonly SubmitRevisionEditKey[];
declare function createNegotiationRowId(): string;
declare function ensureAvailNegotiationRowIds(rows: Avails[]): Avails[];
interface SubmitAvailRevisionRequest {
    AvailId: number;
    LatestVersion: string;
    Comment: string;
    CreatedBy: string;
    CreatedDate: string;
    Avails: AvailsPropertyFromBackend[];
}
type SubmitAvailRevisionResponse = boolean;
declare function getAvailRowMatchKey(row: AvailsPropertyFromBackend): string;
declare function buildSubmitRevisionAvailRows(currentRows: Avails[], snapshotRows: Avails[]): AvailsPropertyFromBackend[];
interface SendNegotiationRequest {
    AvailId: number;
    VersionNumber: string;
    Comment: string;
    UserId: string;
}
type SendNegotiationResponse = boolean;
declare const AVAIL_NEGOTIATION_CHANGED_CELL_CLASS = "avail-negotiation-changed-cell";
declare const AVAIL_NEGOTIATION_REMOVED_ROW_CLASS = "avail-negotiation-removed-row";
declare const AVAIL_NEGOTIATION_ADDED_ROW_CLASS = "avail-negotiation-added-row";
declare function composeVersionedListingDisplayId(id: string | number | null | undefined, versionNumber: string | null | undefined): string;
declare function campaignStatusToDisplayLabel(status: CampaignStatus | string | undefined): string;
declare function campaignStatusToCssClass(status: CampaignStatus | string | undefined): string;
declare const AVAIL_HIGHLIGHT_COMPANION_KEYS: Record<string, string[]>;
declare function hasBackendAvailRowEditStatus(status: string | null | undefined): boolean;
declare function isAvailRowEditedForEasyFilter(row: Avails, editSnapshotRow?: Avails | null): boolean;

declare class AfrAvailCommentHistoryModalComponent {
    private readonly commentHistoryState;
    set commentHistory(value: AvailCommentEntry[] | null | undefined);
    readonly commentFilterDropdownItems: SingleSelectIdText[];
    readonly selectedCommentFilterItem: _angular_core.WritableSignal<SingleSelectIdText>;
    readonly filteredComments: _angular_core.Signal<AvailCommentEntry[]>;
    readonly commentFilterDropdownConfig: ICustomSingleSelect;
    private readonly activeModal;
    onCommentFilterChanged(item: SingleSelectIdText): void;
    close(): void;
    commentRoleLabel(role: AvailCommentEntry['AuthorRole']): string;
    formatCommentCreatedAt(createdAtUtc: string): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrAvailCommentHistoryModalComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrAvailCommentHistoryModalComponent, "afr-avail-comment-history-modal", never, { "commentHistory": { "alias": "commentHistory"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AfrAvailNegotiationBarComponent {
    readonly latestComment: _angular_core.InputSignal<AvailCommentEntry>;
    readonly viewAllComments: _angular_core.OutputEmitterRef<void>;
    readonly showBar: _angular_core.Signal<boolean>;
    readonly commentBody: _angular_core.Signal<string>;
    readonly commentMetaLine: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrAvailNegotiationBarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrAvailNegotiationBarComponent, "afr-avail-negotiation-bar", never, { "latestComment": { "alias": "latestComment"; "required": false; "isSignal": true; }; }, { "viewAllComments": "viewAllComments"; }, never, never, true, never>;
}

declare class AfrAvailVersionSelectorComponent {
    readonly versionSummaries: _angular_core.InputSignal<AvailVersionSummaryEntry[]>;
    readonly selectedVersion: _angular_core.InputSignal<string>;
    readonly versionChange: _angular_core.OutputEmitterRef<string>;
    readonly versionDropdownItems: _angular_core.Signal<SingleSelectIdText[]>;
    readonly selectedVersionItem: _angular_core.Signal<SingleSelectIdText>;
    readonly selectedVersionMeta: _angular_core.Signal<AvailVersionSummaryEntry>;
    readonly versionCreatorLabel: _angular_core.Signal<string>;
    readonly versionCreatedDateDisplay: _angular_core.Signal<string>;
    readonly versionDropdownConfig: ICustomSingleSelect;
    private readonly annaGlobalConfig;
    constructor();
    onVersionItemChanged(item: SingleSelectIdText): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrAvailVersionSelectorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrAvailVersionSelectorComponent, "afr-avail-version-selector", never, { "versionSummaries": { "alias": "versionSummaries"; "required": false; "isSignal": true; }; "selectedVersion": { "alias": "selectedVersion"; "required": false; "isSignal": true; }; }, { "versionChange": "versionChange"; }, never, never, true, never>;
}

declare class AfrCampaignEmailAvailsPopupComponent implements OnInit {
    showSecondStep: boolean;
    sendEmail: EventEmitter<any>;
    private emailAvailsPopup;
    emailAvailsModalRef: NgbModalRef;
    emailAvailsOptions: NgbModalOptions;
    email: string;
    private readonly modalService;
    private readonly config;
    ngOnInit(): void;
    openEmailAvailsPopup(): void;
    closeEmailAvailsPopup(): void;
    emailAvailsAsXml(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrCampaignEmailAvailsPopupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrCampaignEmailAvailsPopupComponent, "afr-campaign-email-avails-popup", never, { "showSecondStep": { "alias": "showSecondStep"; "required": false; }; }, { "sendEmail": "sendEmail"; }, never, never, true, never>;
}

/**
 * Extended avail details response from backend.
 * Base fields (Advertiser, Agency, Avails, etc.) are shared with existing getAvailsInfo.
 * Optional fields support new UI: created at/by, dynamic rates, orders, published-by.
 */
interface AvailDetailsResponse {
    StationNames: string[];
    AvailId: number;
    ForwardId?: number;
    Advertiser: string;
    Agency: string;
    BuyerEstimate: string;
    FlightStartDate: string;
    FlightEndDate: string;
    BookedDemo: string;
    SpotDuration: number;
    PostingType: string;
    ProductCode?: string;
    CampaignName?: string;
    ProductDescription?: string;
    ExpiresOn: string;
    AvailsGeneratedOn?: string;
    AvailCreatedAt?: string;
    Avails: Avails[];
    IsExpired?: boolean;
    MarketNames?: string[];
    StationTarget?: StationTarget[];
    DaypartTarget?: CommonDaypartTarget[];
    DaypartDispersion?: DaypartDispersionEntry[] | null;
    PrimeProgramsDayWise?: PrimeProgramsDayWise[];
    SpecialProgramIds?: string[];
    SportEvents?: SportEvent[];
    IsOtherPrimeProgramsSelected?: boolean;
    CreatedAt?: string;
    CreatedBy?: string;
    StationRatesTimeInfo?: StationRatesTimeInfo[];
    SyncedOrders?: AvailOrderRow[];
    OrderMapped?: AvailOrderRow[];
    AvailUsage?: AvailUsage;
    CampaignStatus?: CampaignStatus;
    LatestVersion?: string;
    CommentHistory?: AvailCommentEntry[];
    VersionSummaries?: AvailVersionSummaryEntry[];
}
interface StationRatesTimeInfo {
    StationName: string;
    PublishedBy: number;
    PublishedOn: string;
    PublishedByUser: string;
    DynamicRateVersionName?: string;
}
interface AvailOrderRow {
    TrafficOrderId: number | string;
    RepOrderId: number | string;
}
interface AvailOrderTableRow extends AvailOrderRow {
    stationOrderDisplay: string | number;
    repOrderDisplay: string | number;
    detailsLinkLabel: string;
    orderDetailsLinks: {
        id: string;
        name: string;
        class: string;
        isDisabled: boolean;
    }[];
}
interface AvailUsage {
    PlanIds: number[];
    DraftIds: number[];
}
interface AvailUsageTableRow extends AvailUsage {
    UsageType: string;
    UsageId: string;
    UsageLinkLabel: string;
    usageLink: {
        id: string;
        name: string;
        class: string;
        isDisabled: boolean;
    }[];
}

interface EditableLineDetails {
    MarketId: number;
    BuylineId: string;
    MarketName: string;
    MarketDisplayName: string;
    StationName: string;
    Program: string;
    ProgramGenre: string;
    StartDate: string;
    EndDate: string;
    Days: string;
    Cpm: number;
    CpmAsDisplay: string;
    Cpp: number;
    CppAsDisplay: string;
    ProgramTimeData: string[];
    Daypart: string;
    Length: string;
    BookedImps: number;
    BookedImpsAsDisplay: string;
    BookedRating: number;
    BookedRatingAsDisplay: string;
    SpotCount: number;
    ProjectedGrossImps: number;
    ProjectedGrossImpsAsDisplay: string;
    PostedGrossImps: number;
    PostedGrossImpsAsDisplay: string;
    ProjectedGrossRating: number;
    ProjectedGrossRatingAsDisplay: string;
    PostedGrossRating: number;
    PostedGrossRatingAsDisplay: string;
    Rate: number;
    RateAsDisplay: string;
    Amount: number;
    AmountAsDisplay: string;
    WeekWiseSpotCount: ModifiedWeekWiseSpotCount[];
    formattedTime: string;
    startTime: string;
    endTime: string;
    startEndTime: string[];
    gtClass: string;
    ModifiedRate: number;
    ModifiedCpm: number;
    ModifiedCpmAsDisplay: string;
    ModifiedCpp: number;
    ModifiedCppAsDisplay: string;
    ModifiedAmount: number;
    ModifiedAmountAsDisplay: string;
    ModifiedProjectedGrossRating: number;
    ModifiedProjectedGrossRatingAsDisplay: string;
    ModifiedSpotCount: number;
    ModifiedProjectedGrossImps: number;
    ModifiedProjectedGrossImpsAsDisplay: string;
    ModifiedStartDate: string;
    ModifiedFilterStartDate: string;
    ModifiedEndDate: string;
    ModifiedFilterEndDate: string;
    IsSelected: boolean;
    IsDeleted: boolean;
    IsAdded: boolean;
    AddedOn: string;
    AddedByUserId: string;
    InvCodeId: number;
    InventoryCode: string;
    ProgramRepeatStatus: string;
    StationProgramId: string;
    [key: string]: any;
}
interface ModifiedWeekWiseSpotCount {
    WeekStartDate: string;
    Year: string;
    SpotCount: number;
    ModifiedSpotCount: number;
    disabled?: boolean;
}
interface ReviewPlanContainerMetaData {
    showHeader: boolean;
    showAddEditButtons: boolean;
    showGoBackButton: boolean;
    naturalContentScroll?: boolean;
    integratedStationForwardPackageLayout?: boolean;
}
interface ReviewPlanMarketMapping {
    markets: MultiSelectIdText[];
    selectedMarkets: MultiSelectIdText[];
    actualMarketNameAndMarketDisplayNameObj: Record<string, string>;
}
interface ReviewPlanChartDataPatch {
    showHeaderForBudget: boolean;
    showDesiredImps: boolean;
    summary: SummaryDetails | null;
    marketSplit: MarketWiseSplit[];
    stationSplit: StationWiseSplit[];
    daypartSplit: DaypartWiseSplit[];
    monthWiseSplit: MonthWiseSplit[];
    showNoData: boolean;
}
interface ReviewPlanCampaignInfoPatch extends ReviewPlanChartDataPatch {
    campaignsExpiresOn: string;
    planId: number | null;
    availUsage: ReviewAvailUsage | null;
    syncedOrders: AvailOrderRow[];
    isApproved: boolean;
    lineDetails: EditableLineDetails[];
    marketMapping?: ReviewPlanMarketMapping;
}
interface ReviewPlanRuntimeSnapshot {
    summary: SummaryDetails | null;
    marketSplit: MarketWiseSplit[];
    stationSplit: StationWiseSplit[];
    daypartSplit: DaypartWiseSplit[];
    monthWiseSplit: MonthWiseSplit[];
    markets: MultiSelectIdText[];
    selectedMarkets: MultiSelectIdText[];
    campaignExpiresOn: string;
    tableData: EditableLineDetails[];
    clonedTableData: EditableLineDetails[];
    showHeaderForBudget: boolean;
    showDesiredImps: boolean;
    selectedMetric: SingleSelectIdText;
    currentAllMarketsLineData: EditableLineDetails[];
    previousAllMarketsLineData: EditableLineDetails[];
    actualMarketNameAndMarketDisplayNameObj: Record<string, string>;
    weekArr: ModifiedWeekWiseSpotCount[];
    planId: number | null;
    availUsage: ReviewAvailUsage | null;
    syncedOrders: AvailOrderRow[];
    isApproved: boolean;
}
interface ReviewPlanContainerData {
    markets: MultiSelectIdText[];
    selectedMarkets: MultiSelectIdText[];
    actualMarketNameAndMarketDisplayNameObj: Record<string, string>;
    campaignExpiresOn: string;
    selectedMetric: SingleSelectIdText;
    tableData: EditableLineDetails[];
    clonedTableData: EditableLineDetails[];
    currentAllMarketsLineData: EditableLineDetails[];
    previousAllMarketsLineData: EditableLineDetails[];
    showHeaderForBudget: boolean;
    showDesiredImps: boolean;
    summary: SummaryDetails | null;
    marketSplit: MarketWiseSplit[];
    stationSplit: StationWiseSplit[];
    daypartSplit: DaypartWiseSplit[];
    monthWiseSplit: MonthWiseSplit[];
    weekArr: ModifiedWeekWiseSpotCount[];
    planId?: number | null;
    availUsage?: ReviewAvailUsage;
    syncedOrders?: AvailOrderRow[];
    isApproved?: boolean;
}
interface ReviewAvailUsage {
    PlanId?: number | null;
    DraftId?: number | null;
}
interface ReviewDays {
    label: string;
    isChecked: boolean;
}
interface TimeInputOutput {
    startTime: string;
    endTime: string;
    days?: ReviewDays[];
}
interface SummaryDetails {
    StationNames: string[];
    TotalBudget: number;
    TotalBudgetAsDisplay: string;
    BookedDemoCpm: number;
    BookedDemoCpmAsDisplay: string;
    NormalizedDemoCpm: number;
    NormalizedDemoCpmAsDisplay: string;
    BookedDemoImps: number;
    BookedDemoImpsAsDisplay: string;
    NormalizedDemoImps: number;
    NormalizedDemoImpsAsDisplay: string;
    AdvertiserName: string;
    AgencyName: string;
    CampaignName: string;
    PostingType: string;
    MarketNames: string[];
    BookedDemo: string;
    SpotDuration: number;
    FlightStartPeriod: string;
    FlightEndPeriod: string;
    CampaignId: number;
    BuyerEstimate: string;
    MeasurementAgency: string;
    BookedDemoRating: number;
    BookedDemoRatingAsDisplay: string;
    BookedDemoCpp: number;
    BookedDemoCppAsDisplay: string;
    NormalizedDemoCpp: number;
    NormalizedDemoCppAsDisplay: string;
    NormalizedDemoRating: number;
    NormalizedDemoRatingAsDisplay: string;
    HiatusDates: HiatusDate[];
    MinimumSeparation: string;
    ProductName: string;
    ProductCategory: string;
    MaxPossibleImpressions: number;
    MaxPossibleRating: number;
    MaxPossibleRatingAsDisplay: string;
    MaxPossibleImpressionsAsDisplay: string;
}
interface SplitGraphCommonData {
    Budget: number;
    BudgetAsDisplay: string;
    PercentageBookedImpsAsDisplay: string;
    BookedDemoCpmAsDisplay: string;
    BookedNormalizedDemoCpmAsDisplay: string;
    ProjectedCpmAsDisplay: string;
    ProjectedNormalizedDemoCpmAsDisplay: string;
    PostedCpmAsDisplay: string;
    PostedNormalizedDemoCpmAsDisplay: string;
    BookedImpressionsAsDisplay: string;
    BookedNormalizedImpressionsAsDisplay: string;
    ProjectedImpressionsAsDisplay: string;
    ProjectedNormalizedImpressionsAsDisplay: string;
    PostedImpressionsAsDisplay: string;
    PostedNormalizedImpressionsAsDisplay: string;
    PercentageBookedImps: number;
    BookedDemoCpm: number;
    BookedNormalizedDemoCpm: number;
    ProjectedCpm: number;
    ProjectedNormalizedDemoCpm: number;
    PostedCpm: number;
    PostedNormalizedDemoCpm: number;
    BookedImpressions: number;
    BookedNormalizedImpressions: number;
    ProjectedImpressions: number;
    ProjectedNormalizedImpressions: number;
    PostedImpressions: number;
    PostedNormalizedImpressions: number;
    ProjectedCppAsDisplay: string;
    ProjectedNormalizedDemoCppAsDisplay: string;
    PostedCppAsDisplay: string;
    PostedNormalizedDemoCppAsDisplay: string;
    ProjectedRatingAsDisplay: string;
    PostedRatingAsDisplay: string;
    ProjectedCpp: number;
    ProjectedNormalizedDemoCpp: number;
    PostedCpp: number;
    PostedNormalizedDemoCpp: number;
    ProjectedRating: number;
    PostedRating: number;
    PercentageBookedRating: number;
    BookedDemoCpp: number;
    BookedDemoCppAsDisplay: string;
    BookedNormalizedDemoCpp: number;
    BookedNormalizedDemoCppAsDisplay: string;
    BookedRating: number;
    BookedRatingAsDisplay: string;
}
interface MarketWiseSplit extends SplitGraphCommonData, ProjectedDataForGraph {
    MarketName: string;
    DesiredImps: number;
    DesiredImpsAsDisplay: string;
    DesiredBudget: number;
    DesiredBudgetAsDisplay: string;
}
interface DaypartWiseSplit extends SplitGraphCommonData, ProjectedDataForGraph {
    DaypartName: string;
    PercentageDesiredImps: number;
    PercentageDesiredImpsAsDisplay: string;
    PercentageDesiredRating?: number;
    PercentageDesiredRatingAsDisplay?: string;
}
interface StationWiseSplit extends SplitGraphCommonData, ProjectedDataForGraph {
    StationName: string;
    Affiliate: string;
    MarketName: string;
}
interface MonthWiseSplit extends SplitGraphCommonData, ProjectedDataForGraph {
    MonthName: string;
    MonthNameWithRange: string;
    PercentageDesiredImps: number;
    PercentageDesiredImpsAsDisplay: string;
    PercentageDesiredRatingAsDisplay: string;
    PercentageDesiredRating: number;
}
interface AddedBuyLines extends EditableLineDetails {
    isValid: boolean;
    marketItem: SingleSelectIdText[];
    selectedMarket: SingleSelectIdText;
    stationItem: SingleSelectIdText[];
    selectedStation: SingleSelectIdText;
    programNameItem: SingleSelectIdText[];
    selectedProgramName: SingleSelectIdText;
    daypartItem: SingleSelectIdText[];
    selectedDaypart: SingleSelectIdText;
    rateItem: SingleSelectIdText[];
    selectedRate: SingleSelectIdText;
    minStartTime: string;
    maxEndTime: string;
    startTime: string;
    endTime: string;
    weekCalenderDaysToEnableInFuture: number;
    weekCalenderDaysToEnableInPast: number;
    weekCalendarMinStartDate: NgbDate;
    weekCalendarMaxEndDate: NgbDate;
    weekCalendarStartDate: NgbDate;
    weekCalendarEndDate: NgbDate;
    dayItems: ReviewDays[];
}
interface AddedBuyLinesEmittedData {
    isValid: boolean;
    addedLines: AddedBuyLines[];
}
interface LineSelection {
    MarketDisplayName: string;
    StationName: string;
    Program: string;
    Daypart: string;
    Rate: number;
}
declare class EditableLineDetailsTotalRow {
    currencyPipe: CurrencyPipe;
    bookedImps: number;
    spots: number;
    projectedGi: number;
    amount: number;
    bookedRtg: number;
    projectedGrp: number;
    displayBookedImps: string;
    displayProjectedGi: string;
    displayAmount: string;
    displayBookedRtg: string;
    displayProjectedGrp: string;
    [key: string]: unknown;
    constructor(data: EditableLineDetails[]);
}
type Mode = "READ" | "EDIT" | "ADD";
interface CampaignInfoRequest {
    CampaignId: number;
    MarketNames: string[];
    PeriodStartDate?: string;
    PeriodEndDate?: string;
}
interface CampaignMarketStation {
    MarketName: string;
    MarketDisplayName: string;
    StationNames?: string[];
}
interface CampaignInfoSummarySplit {
    MarketWiseSplit: MarketWiseSplit[];
    StationSplit: StationWiseSplit[];
    DaypartSplit: DaypartWiseSplit[];
    MonthWiseSplit: MonthWiseSplit[];
}
interface CampaignInfoSummary {
    Summary: SummaryDetails;
    TotalSplit: CampaignInfoSummarySplit;
}
interface CampaignAddedBuyline {
    MarketName: string;
    StationName: string;
    Program: string;
    Daypart: string;
    Rate: number;
    BuylineId: string;
}
interface CampaignInfoResponse {
    LineDetails?: EditableLineDetails[];
    CampaignExpiresOn?: string;
    IsGrpTargetSet?: boolean;
    HasSpecifiedDaypartPercentages?: boolean;
    Summary?: CampaignInfoSummary;
    PlanId?: number | null;
    AvailUsage?: ReviewAvailUsage | null;
    IsApproved?: boolean;
    SyncedOrders?: AvailOrderRow[];
    OrderMapped?: AvailOrderRow[];
    MarketsAndStationsForCampaign?: CampaignMarketStation[];
    AddedBuylines?: CampaignAddedBuyline[];
}
interface CampaignDispersionResponse {
    IsGrpTargetSet?: boolean;
    HasSpecifiedDaypartPercentages?: boolean;
    Summary?: CampaignInfoSummary;
    AddedBuylines?: CampaignAddedBuyline[];
}
interface CampaignPrimaryFilterResponse {
    MarketsAndStationsForCampaign: CampaignMarketStation[];
    CampaignDateRange?: unknown;
}
interface ApproveCampaignResponse {
    PlanId?: number;
    CampaignName?: string;
}
interface CampaignDispersionPayload extends ApproveCampaignPayload {
    MarketNames: string[];
}
interface ApproveCampaignPayload {
    CampaignId: number | null;
    StationPlanId?: number | null;
    CreatedByUserId?: string | null;
    LineDetails: EditableLineDetails[];
}
interface ProjectedDataForGraph {
    ProjectedBudget: number;
    ProjectedBudgetDisplay: string;
    PercentageProjectedImps: number;
    PercentageProjectedImpsAsDisplay: string;
    PercentageProjectedRating: number;
    PercentageProjectedRatingAsDisplay: string;
    ProjectedImpressions: number;
    ProjectedImpressionsAsDisplay: string;
    ProjectedRating: number;
    ProjectedRatingAsDisplay: string;
    ProjectedCpm: number;
    ProjectedCpmAsDisplay: string;
    ProjectedCpp: number;
    ProjectedCppAsDisplay: string;
}

interface SelectedDataPreview {
    heading: string;
    keyValues: KeyValue$1[];
}
interface PlanCampaignRequestPayload {
    CampaignName: string;
    RequestedByUserId: string;
    AdvertiserName: string;
    AgencyName: string;
    BuyerEstimate: string;
    SpotDuration: string;
    PostingType: string;
    BudgetTarget: number;
    PlanningDemo: string;
    MarketNames: string[];
    StationTarget: StationTarget[];
    FlightStartDate: string;
    FlightEndDate: string;
    HasSpecifiedDaypartPercentages: boolean;
    DaypartTarget: CommonDaypartTarget[];
    DaypartDispersion: DaypartDispersionEntry[] | null;
    MonthWiseTargetPercentage: MonthWiseTargetPercentage[];
    MarketTarget: MarketTarget[];
    HiatusDates: HiatusDate[];
    BusinessRules: BusinessRulesForPayload;
    ProductCode: string;
    ProductDescription: string;
    Avails: Avails[];
    SpecialProgramIds: string[];
    SportEvents: SportEventToBEResponse[];
    PrimeProgramsDayWise: PrimeProgramsDayWise[];
    IsOtherPrimeProgramsSelected: boolean;
    AvailsGeneratedOn: string;
    LastUpdatedBy: string;
    TypicalGrp: number;
    CampaignId: number;
    Buyers?: BuyerContactDetails[];
}
interface SaveDraftPayload extends PlanCampaignRequestPayload {
    LineDetails: EditableLineDetails[];
    LastSavedStep: string;
    IsCampaignFinalized: boolean;
    CreatedByUserId: string;
    CampaignType: "AVAILS" | "CAMPAIGN";
}
interface PlanCampaignHubResponse {
    CampaignId: number;
    Status: "ALLOCATION_FOUND" | "ALLOCATION_NOT_FOUND" | "ERROR";
}
type CampaignFlow = "Radiant" | "ManualPlanning" | "ExportAvails" | "Package" | "Avails";

declare class AfrCampaignFlowSelectionPopupComponent implements OnInit {
    queryParams: any;
    private flowSelectionPopup;
    flowSelectionModalRef: NgbModalRef;
    flowSelectionModalOptions: NgbModalOptions;
    selectedRadio: CampaignFlow;
    radioButtonConfig: IRadioButtonComponentConfig;
    popupHeaderText: string;
    popupInfoText: string;
    popupWindowClass: string;
    private readonly modalService;
    private readonly router;
    private readonly route;
    private readonly config;
    ngOnInit(): void;
    overRideDefaultConfig(): void;
    setRadioButtonConfig(): void;
    flowSelectionChanged(selectedRadio: CampaignFlow): void;
    openPopup(): void;
    closePopup(): void;
    private getFlowSelectionOptions;
    private getConfiguredFlows;
    private isStationForwardPlanOrdersContext;
    private getFlowLabel;
    moveToPlanCampaignPage(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrCampaignFlowSelectionPopupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrCampaignFlowSelectionPopupComponent, "afr-campaign-flow-selection-popup", never, { "queryParams": { "alias": "queryParams"; "required": false; }; }, {}, never, never, true, never>;
}

interface KeyValue {
    key: string;
    value: string;
    keyClass: string;
    valueClass: string;
    /** Optional tooltip text shown on hover when the value is truncated or when a custom tooltip is needed. */
    tooltipValue?: string;
    maxWidth: string;
}
interface OrderDetailsNavigationResult {
    path: string[];
    queryParams?: Record<string, string>;
}
interface AvailDetailsConfig {
    /** When true (e.g. ANNA InstaPitch), stationNames must be in the URL and are passed to getAvailDetails. When false (e.g. EOS), not used. */
    stationRequired?: boolean;
    /** Path segments to navigate to when stationRequired is true but stationNames is missing from the URL. */
    getListingPathForRedirect?(): string[];
    availsMetaInfo: {
        showExpireDateAndTime: boolean;
        showCreatedBy: boolean;
        showDynamicRates: boolean;
        showOrders: boolean;
        showAvailUsage?: boolean;
        showEmailAvails: boolean;
        showPlanOrders?: boolean;
        showNegotiationBar?: boolean;
        showVersionSelector?: boolean;
        showNegotiateButton?: boolean;
        showSellerEditActions?: boolean;
    };
    getAvailSummaryPanelData(availRes: AvailDetailsResponse): KeyValue[];
    getAvailDetails(availId: number, stationNames?: string, versionNumber?: string): Observable<AvailDetailsResponse>;
    emailAvails(payload: PayloadForEmailAvails): Observable<any>;
    getBuyerId?(): string;
    getBuyerName?(): string;
    getLoggedInUserName?(): string;
    getOrderDetailsPath?(order: AvailOrderRow): OrderDetailsNavigationResult;
    getAvailUsageDetailsPath?(usage: AvailUsage): OrderDetailsNavigationResult;
    navigateToRateCardVersionHistory?(versionId: string): void;
    getTableHeaders?(bookedDemo: string | undefined, mode: "READ" | "EDIT"): IGtTableHeader[];
    getExtraHeaderRowForAdjustingColumnWidths?(): {
        objectKey: string;
        width: string;
    }[];
    sendNegotiation?(payload: SendNegotiationRequest): Observable<SendNegotiationResponse>;
    submitAvailRevision?(payload: SubmitAvailRevisionRequest): Observable<SubmitAvailRevisionResponse>;
}
declare const AVAIL_DETAILS_CONFIG: InjectionToken<AvailDetailsConfig>;

declare class AfrAvailsGeneratedDetailsComponent {
    readonly tableHeaders: _angular_core.WritableSignal<IGtTableHeader[]>;
    readonly totalRowInfo: _angular_core.WritableSignal<ITotalRowInfo[]>;
    readonly gtDimension: {
        rowHeight: number;
        headerHeight: number;
    };
    readonly gtGeneralConfig: _angular_core.WritableSignal<IGtGeneralConfig>;
    readonly disableResetAllBtn: _angular_core.WritableSignal<boolean>;
    readonly loading: _angular_core.WritableSignal<boolean>;
    readonly tableInstanceId: _angular_core.WritableSignal<number>;
    readonly tableData: _angular_core.WritableSignal<Avails[]>;
    readonly clonedTableData: _angular_core.WritableSignal<Avails[]>;
    readonly editedRowsEasyFilters: EasyFilters[];
    readonly extraHeaderRowForAdjustingColumnWidths: _angular_core.WritableSignal<{
        objectKey: string;
        width: string;
    }[]>;
    readonly availRes: _angular_core.WritableSignal<AvailDetailsResponse>;
    readonly availsExpireOnDate: _angular_core.WritableSignal<string>;
    readonly availsExpiresAt: _angular_core.WritableSignal<string>;
    readonly showNoData: _angular_core.WritableSignal<boolean>;
    readonly hasAvailContent: _angular_core.Signal<boolean>;
    readonly summaryInfo: _angular_core.WritableSignal<KeyValue[]>;
    readonly isStationForwardsAvailDetails: _angular_core.WritableSignal<boolean>;
    readonly flowSelectionQueryParams: _angular_core.WritableSignal<Record<string, unknown>>;
    readonly availUsageRows: _angular_core.WritableSignal<AvailUsage[]>;
    readonly canShowViewOrdersLink: _angular_core.WritableSignal<boolean>;
    readonly selectedVersionNumber: _angular_core.WritableSignal<string>;
    readonly isEditMode: _angular_core.WritableSignal<boolean>;
    readonly editSnapshot: _angular_core.WritableSignal<Avails[]>;
    readonly hasHardBlock: _angular_core.WritableSignal<boolean>;
    readonly hardBlockMessageBoxData: MessageBoxData;
    private negotiationCommentModal;
    private genericTableComponent?;
    negotiationCommentConfig: GenericCommentPopupModel;
    private negotiationCommentMode;
    readonly emailAvailsPopupComponent: _angular_core.Signal<AfrCampaignEmailAvailsPopupComponent>;
    readonly flowSelectionPopup: _angular_core.Signal<AfrCampaignFlowSelectionPopupComponent>;
    private availId;
    private filtersFromRoute;
    private sortStateFromRoute;
    private stationNamesFromUrl;
    private breadcrumbs;
    private readonly destroyRef;
    private readonly availDetailsPersistedFilterService;
    private readonly modalService;
    private readonly annaSortService;
    private readonly annaFilterService;
    private readonly annaGtHelperService;
    private readonly availService;
    private readonly versionDiffService;
    private readonly annaGlobalConfig;
    private readonly route;
    private readonly toastr;
    private readonly ngxService;
    private readonly breadcrumbService;
    private readonly router;
    private readonly cdr;
    private readonly currencyPipe;
    readonly availDetailsConfig: AvailDetailsConfig;
    constructor();
    private initializeFromRoute;
    private initTableHeaderConfig;
    detectUrlChanges(): void;
    setPersistingVariableForColumnAndEasyFilter(columnAndEasyFilter: string | undefined): void;
    private resetTableFilterStateIfNotInUrl;
    storeBreadcrumbsFromUrl(): void;
    setBreadcrumbs(): void;
    fetchAvailsDetail(): void;
    createSummaryInfoSection(): void;
    formatAvailsData(): void;
    refreshHardBlockState(): void;
    private getFilteredAndSortedRows;
    private mapAvailRowForTable;
    setGtGeneralConfig(): void;
    resetAllFilter(): void;
    createTotalRowData(): void;
    /**
     * Prefer mutating the existing total-row objects so the generic table's
     * `totalRowInfo` @Input reference stays stable. Replacing the array on every
     * keystroke triggers ngOnChanges → setInitialRowsForTable and jumps scroll to top.
     */
    private applyTotalRowInfo;
    private canPatchTotalRowInPlace;
    /** 0-based index among visible non-dummy body columns, or null if not found. */
    private getVisibleBodyColumnIndex;
    private getTotalRowSelectionState;
    private getTotalRowCheckboxIconClass;
    private getSelectedAvailsCount;
    private hasSelectedAvailsForEmail;
    private getVisibleTableColumnCount;
    selectUnselectLine(_event: {
        rowData: Avails;
        columnKeys: string;
        isCheckboxSelected: boolean;
    }): void;
    totalRowIconClicked(colName: string): void;
    rateImpressionsInputChanged(emittedData: {
        data: Avails;
        key: string;
        valueEntered: string;
    }): void;
    private syncAvailResAvailsFromTable;
    filterAppliedToTable(tableData: Avails[]): void;
    sortingAppliedToTable(tableData: Avails[]): void;
    intelliFilterClicked(emittedObj: EasyFilterEmittedData): void;
    enableDisableResetAllBtn(): void;
    removeA18Header(): void;
    openEmailAvailsPopup(): void;
    openPlanOrdersPopup(): void;
    emailAvails(): void;
    createPayloadForEmailAvails(): PayloadForEmailAvails;
    removeUiKeysFromPayload(data: Avails[]): Avails[];
    openPublishedByPopup(): void;
    openOrdersPopup(): void;
    private hasBackendOrderReferences;
    private extractAvailOrders;
    openAvailUsagePopup(): void;
    getDisplayTime(time: string): string;
    updateNavigationHistory(): void;
    prepareQueryParamOnFilterApplication(): Record<string, unknown>;
    private getConfiguredTableHeaders;
    private getConfiguredExtraHeaderRowForAdjustingColumnWidths;
    private createPlanOrdersQueryParams;
    private extractAvailUsageRows;
    private readonly isViewingLatestVersion;
    readonly isNegotiationUiContext: _angular_core.Signal<boolean>;
    readonly latestCommentForBar: _angular_core.Signal<_annalib_anna_feature_radiant.AvailCommentEntry>;
    readonly showNegotiationBar: _angular_core.Signal<boolean>;
    readonly showCampaignStatusPill: _angular_core.Signal<boolean>;
    readonly campaignStatusLabel: _angular_core.Signal<string>;
    readonly campaignStatusCssClass: _angular_core.Signal<string>;
    readonly showVersionSelector: _angular_core.Signal<boolean>;
    readonly showSellerEditButton: _angular_core.Signal<boolean>;
    /** Same eligibility as Edit, but stays true while editing so YMC remains visible. */
    readonly shouldShowYmcRateColumn: _angular_core.Signal<boolean>;
    readonly showNegotiateButton: _angular_core.Signal<boolean>;
    readonly showPlanOrdersButton: _angular_core.Signal<boolean>;
    readonly isPlanOrdersDisabled: _angular_core.Signal<boolean>;
    onVersionChange(versionNumber: string): void;
    private applyAvailDetailsResponse;
    private applyHistoricalVersionTableData;
    openCommentHistoryModal(): void;
    openNegotiateModal(): void;
    onNegotiationCommentSaved(comment: string): void;
    private sendNegotiation;
    private submitSellerRevision;
    startEditMode(): void;
    cancelEditMode(): void;
    openSendRevisionModal(): void;
    private refreshTableHeadersAndDataPreservingColumnFilters;
    private restoreFilterSortUiStateAfterTableRender;
    private refreshTableHeadersForMode;
    private withEditedRowFlag;
    private findEditSnapshotRow;
    private syncEditStateForEasyFilter;
    private syncEditedRowFlagsForCurrentRows;
    private applyEditedRowFlagOnExistingRows;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrAvailsGeneratedDetailsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrAvailsGeneratedDetailsComponent, "afr-avails-generated-details", never, {}, {}, never, never, true, never>;
}

declare class AvailVersionDiffService {
    applyRowHighlights(rows: Avails[]): Avails[];
    private applyRowHighlight;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvailVersionDiffService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AvailVersionDiffService>;
}

interface ListingEnabledPeriod {
    statDate: string;
    endDate: string;
}
interface ListingColumnSortFilterState {
    appliedFilters?: string[];
    selectedFilterData?: string;
    sortState?: string;
}
interface ListingGtTextActionEvent {
    data: any;
    id: string | number;
    columnHeader: unknown;
    isIconClicked: boolean;
}

declare class AfrListingPageComponent {
    readonly flowSelectionPopup: _angular_core.Signal<AfrCampaignFlowSelectionPopupComponent>;
    readonly expiredStationForwardDraftModal: _angular_core.Signal<ConfirmationPopupComponent>;
    readonly periodModalTitle: _angular_core.WritableSignal<string>;
    readonly periodModalMessage: _angular_core.WritableSignal<string>;
    readonly periodOptions: _angular_core.WritableSignal<string[]>;
    readonly selectedPeriodData: _angular_core.WritableSignal<PeriodSelectionPopUp>;
    readonly loadingPeriodData: _angular_core.WritableSignal<boolean>;
    readonly enabledPeriod: _angular_core.WritableSignal<ListingEnabledPeriod>;
    readonly adcContainerQueryParams: _angular_core.WritableSignal<_angular_router.Params>;
    readonly loadingTableData: _angular_core.WritableSignal<boolean>;
    readonly tableHeaders: _angular_core.WritableSignal<IGtTableHeader[]>;
    readonly gtDimension: _angular_core.WritableSignal<{
        rowHeight: number;
        headerHeight: number;
        dataOnTopHeight: number;
        marginFromBottom: number;
    }>;
    readonly gtGeneralConfig: _angular_core.WritableSignal<IGtGeneralConfig>;
    readonly tableData: _angular_core.WritableSignal<any[]>;
    readonly clonedTableData: _angular_core.WritableSignal<any[]>;
    readonly disableResetAllBtn: _angular_core.WritableSignal<boolean>;
    readonly errorInQuarterFilter: _angular_core.WritableSignal<boolean>;
    readonly includeBorderInTableHeight: _angular_core.WritableSignal<boolean>;
    readonly tableBorderBottomClassRequired: _angular_core.WritableSignal<boolean>;
    readonly showAllInMonthsDropdown: _angular_core.WritableSignal<boolean>;
    readonly showAllInQuartersDropdown: _angular_core.WritableSignal<boolean>;
    readonly tableClassMap: _angular_core.WritableSignal<Record<string, boolean>>;
    readonly loadingSkeletonRowsToRender: _angular_core.WritableSignal<number>;
    readonly showNegotiationEasyFilters: _angular_core.WritableSignal<boolean>;
    readonly negotiationEasyFilters: _angular_core.WritableSignal<EasyFilters[]>;
    readonly showAddButton: _angular_core.WritableSignal<boolean>;
    readonly showMultiSelectStationDropdown: _angular_core.WritableSignal<boolean>;
    readonly showDashboardPrimaryFilter: _angular_core.WritableSignal<boolean>;
    readonly stationsForMultiSelect: _angular_core.WritableSignal<MultiSelectIdText[]>;
    readonly initialStationsForMultiSelect: _angular_core.WritableSignal<MultiSelectIdText[]>;
    readonly multiStationDropdownConfig: _angular_core.WritableSignal<ICustomMultiSelect>;
    readonly dashboardFilterData: _angular_core.WritableSignal<PrimaryFiltersData>;
    readonly persistingDashboardFilter: _angular_core.WritableSignal<PersistedDashboardPrimaryFilters>;
    readonly expiredStationForwardDraftConfig: _angular_core.WritableSignal<IConfirmationPopupConfig>;
    private readonly ngxService;
    private readonly route;
    private readonly router;
    private readonly config;
    private readonly stateSvc;
    private readonly dataSvc;
    private readonly nav;
    private readonly breadcrumbs;
    private readonly quarterFilters;
    private readonly filterService;
    private readonly annaGlobalConfig;
    private readonly toastr;
    private readonly pageConfig;
    private readonly destroyRef;
    private readonly calendarQuarterYearFilterService;
    private currentTab;
    private currentTabId;
    private lastSelectedPeriod?;
    /** Cached page-default period (current broadcast quarter). */
    private initialPeriodFilter;
    /**
     * After sidebar hard-reset, empty-URL queryParams and selectedPeriod would update together;
     * the period modal skips reseed when both inputs change. Defer applying defaults to the next tick.
     */
    private pendingHardResetPeriodDefaults;
    private dataSub?;
    private suppressNextRowClick;
    private filtersFromRoute;
    constructor();
    onAddClick(): void;
    onApplyPeriodSelection(selectedPeriod: {
        isEntireFlightPeriod: boolean;
        startDate: string;
        endDate: string;
    }): void;
    onResetAllFilter(): void;
    onNegotiationEasyFilterClick(emittedObj: {
        filteredData: any[];
    }): void;
    onFilterAppliedToTable(tableData: any[]): void;
    onSortingAppliedToTable(tableData: any[]): void;
    onRowClicked(row: any): void;
    onTextActionClicked(event: ListingGtTextActionEvent): void;
    isThereAnyChangeInStationSelection(newStations: MultiSelectIdText[]): boolean;
    onStationSelectionChange(stations: MultiSelectIdText[]): void;
    getSelectedStationNames(): string[];
    setPersistedStationIds(stationIds: string): void;
    onDashboardFilterApplied(filters: DashboardFilterSelectionPopUp): void;
    private applyConfigDefaults;
    private setCurrentTab;
    private setInitialLoadingSkeletonRows;
    private resolveListingRowHeight;
    private setTableHeight;
    private setTableHeadersBasedOnTabs;
    private resolveShowMultiSelectStationDropdown;
    private initStationsForMultiSelect;
    private updateTableClassMap;
    private setGtGeneralConfig;
    private detectUrlChanges;
    /**
     * Sidebar hard-reset: clear column filters and stash page-default period.
     * Defaults are applied after empty-URL lands (see detectUrlChanges) so the period
     * modal gets a selectedData-only change and reseeds the chip.
     */
    private listenForPrimaryFiltersHardReset;
    private applyHardResetPeriodDefaults;
    private buildDefaultBroadcastQuarterPeriod;
    private updateListingState;
    private setBreadcrumbs;
    private getBreadcrumbLabel;
    private getQuartersdata;
    private ensureInitialDashboardPersistedFilter;
    private getDefaultQuarterPeriodForStation;
    private normalizePeriodDateFormat;
    private getStationCalendarData;
    private fetchDataForCurrentTab;
    private normalizeRows;
    private buildNegotiationEasyFilters;
    private updateNegotiationEasyFilterCounts;
    private buildRequestContext;
    private ensureBreadcrumbsForNavigation;
    private updateNavigationHistory;
    private getQueryParamsForNavigation;
    private executeNav;
    private executeFlow;
    private openFlowPopup;
    private shouldOpenExpiredStationForwardDraftPopup;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrListingPageComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrListingPageComponent, "afr-listing-page", never, {}, {}, never, never, true, never>;
}

declare class AfrCampaignsListingParentComponent {
    private readonly config;
    private readonly router;
    private readonly route;
    private readonly listingStateService;
    private readonly listingNavigation;
    private readonly parentNavLinks;
    readonly navLinks: _angular_core.WritableSignal<ListingTab[]>;
    readonly activeTabUrl: _angular_core.WritableSignal<string>;
    constructor();
    tabChangeClicked(tab: ListingTab): void;
    setActiveTab(currentUrl: string): void;
    resetAndSetTab(): void;
    private static resolveActiveTabUrl;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrCampaignsListingParentComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrCampaignsListingParentComponent, "afr-campaigns-listing-parent", never, {}, {}, never, never, true, never>;
}

declare class AfrDaypartGroupsControlComponent implements ControlValueAccessor, AfterViewInit, OnInit {
    private cdr;
    private modalService;
    private annaGlobalConfig;
    private addDaypartGroupModal;
    addDaypartGroupingModalReference: NgbModalRef;
    removeGroupingConfirmation: ConfirmationPopupComponent;
    removeGroupingConfirmationConfig: IConfirmationPopupConfig;
    groupsContainer: ElementRef<HTMLDivElement>;
    measureItems: QueryList<ElementRef>;
    daypartGroups: DaypartGroups;
    showViewAll: EventEmitter<any>;
    daypartRules: DaypartGroupsList[];
    visibleGroups: DaypartGroupsList[];
    hiddenGroups: DaypartGroupsList[];
    modalTitleForDpGroups: string;
    expanded: boolean;
    resizeObserver: ResizeObserver;
    ngbModalOptions: NgbModalOptions;
    onChange: (value: any) => void;
    onTouched: () => void;
    constructor(cdr: ChangeDetectorRef, modalService: NgbModal, annaGlobalConfig: AnnaGlobalConfigService);
    ngOnInit(): void;
    writeValue(value: DaypartGroupsList[]): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(disabled: boolean): void;
    ngAfterViewInit(): void;
    calculateVisibleGroups(): void;
    toggleExpanded(): void;
    saveDaypartGroups(groups: DaypartGroupsList[]): void;
    removeGrouping(): void;
    removeGroupingModalConfig(): void;
    openDaypartGroupsModal(): void;
    closeAddDaypartGroupModal(): void;
    popupModalConfig(): void;
    openRemoveGroupingModal(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrDaypartGroupsControlComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrDaypartGroupsControlComponent, "afr-daypart-groups-control", never, { "daypartGroups": { "alias": "daypartGroups"; "required": false; }; }, { "showViewAll": "showViewAll"; }, never, never, true, never>;
}

declare class AfrInstapitchEmailAvailsConfirmationPopupComponent implements OnInit {
    sendEmail: EventEmitter<void>;
    private emailAvailsPopup;
    emailAvailsModalRef: NgbModalRef;
    emailAvailsOptions: NgbModalOptions;
    private readonly modalService;
    private readonly state;
    buyers: BuyerContactDetails[];
    ngOnInit(): void;
    openEmailAvailsPopup(): void;
    closeEmailAvailsPopup(): void;
    emailAvailsAsXml(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrInstapitchEmailAvailsConfirmationPopupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrInstapitchEmailAvailsConfirmationPopupComponent, "afr-instapitch-email-avails-confirmation-popup", never, {}, { "sendEmail": "sendEmail"; }, never, never, true, never>;
}

declare class AfrInstapitchEmailPackageConfirmationPopupComponent implements OnInit {
    sendPackage: EventEmitter<void>;
    private emailPackagePopup;
    packageModalRef: NgbModalRef;
    packageModalOptions: NgbModalOptions;
    private readonly modalService;
    private readonly state;
    buyers: BuyerContactDetails[];
    ngOnInit(): void;
    openPackagePopup(): void;
    closePackagePopup(): void;
    confirmSendPackage(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrInstapitchEmailPackageConfirmationPopupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrInstapitchEmailPackageConfirmationPopupComponent, "afr-instapitch-email-package-confirmation-popup", never, {}, { "sendPackage": "sendPackage"; }, never, never, true, never>;
}

declare class AfrPlanCampaignAddBuylinesComponent implements OnChanges {
    avails: Avails[];
    isImpsMetric: boolean;
    allMarketsBuyLines: EditableLineDetails[];
    weekArr: ModifiedWeekWiseSpotCount[];
    tableHeaders: IGtTableHeader[];
    updateSaveBtn: EventEmitter<AddedBuyLinesEmittedData>;
    addedBuyerLines: AddedBuyLines[];
    disableAddBuyLinesBtn: boolean;
    totalRowInfo: ITotalRowInfo[];
    renderedData: EditableLineDetails[];
    limit: number;
    start: number;
    end: number;
    isTableScrolled: boolean;
    globalConfigService: AnnaGlobalConfigService;
    currencyPipe: CurrencyPipe;
    annaDateTimeFormatService: AnnaDateTimeFormatService;
    private readonly config;
    marketDropdownConfig: ICustomSingleSelect;
    stationDropdownConfig: ICustomSingleSelect;
    programNameDropdownConfig: ICustomSingleSelect;
    daypartDropdownConfig: ICustomSingleSelect;
    rateDropdownConfig: ICustomSingleSelect;
    daysDropdownConfig: ICustomMultiSelect;
    selectedLine: AddedBuyLines;
    tooltip: any;
    days: {
        key: string;
        len: number;
    }[];
    weekConfig: IWeekCalendar;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    setDaypartDropdownConfig(): void;
    setMarketDropdownConfig(): void;
    setStationDropdownConfig(): void;
    setProgramNameDropdownConfig(): void;
    setRateDropdownConfig(): void;
    addNewBuyLine(): void;
    removeBuyerLine(index: number): void;
    onMarketChanged(selectedMarket: SingleSelectIdText, line: AddedBuyLines): void;
    updateRatesForLine(line: AddedBuyLines, rates: number[]): void;
    updateStationDataForLine(line: AddedBuyLines, stations: string[]): void;
    updateProgramDataForLine(line: AddedBuyLines, programs: string[]): void;
    updateDaypartDataForLine(line: AddedBuyLines, dayparts: string[]): void;
    updateMarketDataForLine(line: AddedBuyLines, markets: string[]): void;
    onStationChanged(selectedStation: SingleSelectIdText, line: AddedBuyLines): void;
    onProgramNameChanged(selectedProgram: SingleSelectIdText, line: AddedBuyLines): void;
    onDaypartChanged(selectedDp: SingleSelectIdText, line: AddedBuyLines): void;
    updateOtherInfoForLine(line: AddedBuyLines, rates: number[], updateRates?: boolean): void;
    onRateChanged(selectedRate: SingleSelectIdText, line: AddedBuyLines): void;
    resetComputedDataForLine(line: AddedBuyLines): void;
    currencyStringToNumber(value: string): number;
    onInputChange(line: AddedBuyLines, weekData: ModifiedWeekWiseSpotCount, event: Event): void;
    checkIfStationMarketProgramDaypartPresent(line: AddedBuyLines): SingleSelectIdText;
    getDropdownOptions(selectedValues: LineSelection, currentDropdown: string): any[];
    getSelectionObjectFromLine(line: AddedBuyLines): LineSelection;
    extractDays(day: string): ReviewDays[];
    checkIfLineIsValid(line: AddedBuyLines): void;
    checkIfAddedBuyersLinesAreValid(): void;
    createTotalRowData(): void;
    bindTheValueToToolTip(line: AddedBuyLines, tooltip: any): void;
    openTooltip(tooltip: any, line: AddedBuyLines): void;
    closeTooltip(): void;
    getDisplayTime(): string;
    objectArrayToDayString(days: ReviewDays[]): string;
    onSavingTime(time: TimeInputOutput): void;
    onSavingDate(date: {
        fromDate: null;
        toDate: null;
    }): void;
    onTableContainerScroll(event: any): void;
    getTableData(start: number, end: number): EditableLineDetails[];
    updateIndex(): void;
    setInitialRowsForTable(): void;
    resetIndex(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignAddBuylinesComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignAddBuylinesComponent, "afr-plan-campaign-add-buylines", never, { "avails": { "alias": "avails"; "required": false; }; "isImpsMetric": { "alias": "isImpsMetric"; "required": false; }; "allMarketsBuyLines": { "alias": "allMarketsBuyLines"; "required": false; }; "weekArr": { "alias": "weekArr"; "required": false; }; "tableHeaders": { "alias": "tableHeaders"; "required": false; }; }, { "updateSaveBtn": "updateSaveBtn"; }, never, never, true, never>;
}

interface AduRulesFormChangeEvent {
    currentValues: AduRulesSelectedData;
    isFormValid: boolean;
}
type AduRulesFormControls = {
    maximumCap: FormControl<number | null>;
    timeWindow: FormControl<SingleSelectIdText | null>;
    programThresholdAllowed: FormControl<boolean | null>;
    daypartGroups: FormControl<DaypartGroupsList[] | null>;
};
declare class AfrPlanCampaignAduRulesComponent implements OnChanges {
    readonly aduRules: _angular_core.InputSignal<AduRules>;
    readonly aduRulesSelectedData: _angular_core.InputSignal<AduRulesSelectedData>;
    readonly formValueChanged: _angular_core.OutputEmitterRef<AduRulesFormChangeEvent>;
    dpGroupComponent?: AfrDaypartGroupsControlComponent;
    readonly showViewAllText: _angular_core.WritableSignal<boolean>;
    readonly minValue = 85;
    readonly maxValue = 200;
    aduRulesForm: FormGroup<AduRulesFormControls>;
    private readonly annaGlobalConfigService;
    private readonly destroyRef;
    private readonly fb;
    private formSubscription?;
    readonly timeWindowConfig: ICustomSingleSelect;
    ngOnChanges(changes: SimpleChanges): void;
    createFormGroup(): void;
    showHideViewAllText(show: boolean): void;
    onScroll(event: WheelEvent): void;
    expandCollapseGroups(): void;
    private emitFormState;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignAduRulesComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignAduRulesComponent, "afr-plan-campaign-adu-rules", never, { "aduRules": { "alias": "aduRules"; "required": false; "isSignal": true; }; "aduRulesSelectedData": { "alias": "aduRulesSelectedData"; "required": true; "isSignal": true; }; }, { "formValueChanged": "formValueChanged"; }, never, never, true, never>;
}

interface PlanCampaignPrimaryInfoConfig {
    showBuyerContactSection: boolean;
    showPlanName: boolean;
    buyerEstimateRequired: boolean;
    showProductDescription: boolean;
    showProductCode: boolean;
    showSpotDurations: () => boolean;
    isAgencyDependentOnAdvertiser: boolean;
}
interface PlanCampaignFlowConfig {
    defaultFlow: CampaignFlow;
    queryParamKey: string;
    queryParamMap: Record<string, CampaignFlow>;
    flowsToDisable: CampaignFlow[];
    planCampaignUrl: string;
    popupHeaderText?: string;
    popupInfoText?: string;
    windowClass?: string;
}
interface PlanCampaignConfig {
    flow: PlanCampaignFlowConfig;
    primaryInfo: PlanCampaignPrimaryInfoConfig;
    iconUrl: string;
    allowEditingOfAvails?: boolean;
    isCampaignPlanningSeparateStep?: boolean;
    getUserId: () => string;
    getLoggedInUserName: () => string;
    getEmailIdForEmailAvails?: () => string;
    tabUrlMap: Map<string, string>;
    isEosApplication?: boolean;
}
declare const PLAN_CAMPAIGN_CONFIG: InjectionToken<PlanCampaignConfig>;

declare class AfrPlanCampaignAvailsComponent implements OnInit, OnChanges, OnDestroy {
    loading: boolean;
    avails: Avails[];
    dataForDownloadSheet: DownloadSheetData;
    clonedAvails: Avails[];
    selectedDemo: string;
    availsGeneratedOn: string;
    refreshAvails: boolean;
    availSelectionChanged: EventEmitter<any>;
    fetchLatestAvails: EventEmitter<any>;
    createDataForCampaignPlanning: EventEmitter<any>;
    sendEmail: EventEmitter<string>;
    tableHeaders: IGtTableHeader[];
    totalRowInfo: ITotalRowInfo[];
    gtDimension: {
        rowHeight: number;
        headerHeight: number;
        dataOnTopHeight: number;
        marginFromBottom: number;
    };
    gtGeneralConfig: IGtGeneralConfig;
    disableResetAllBtn: boolean;
    extraHeaderRowForAdjustingColumnWidths: {
        objectKey: string;
        width: string;
    }[];
    downloadRadioBtnConfig: IRadioButtonComponentConfig;
    isUpdatedForFirstTime: boolean;
    private downloadModalPopup;
    downloadModalRef: NgbModalRef;
    private refreshAvailsModal;
    refreshAvailsModalReference: NgbModalRef;
    private emailAvailsPopupComponent;
    private instaPitchEmailAvailsPopupComponent;
    private sellerCommentModal;
    private genericTableComponent?;
    sellerCommentConfig: GenericCommentPopupModel;
    downloadModalOptions: NgbModalOptions;
    selectedRadioForDownload: DownloadButtonValue;
    showLoaderForDownload: boolean;
    percentDone: number;
    availsGeneratedOnDate: string;
    availsGeneratedAt: string;
    isAvailsSelected: boolean;
    selectedClonedLineLength: number;
    disableButtonWhenEditing: boolean;
    private availService;
    private annaGlobalConfig;
    private annaFilterService;
    private annaGtHelperService;
    private annaSortService;
    private modalService;
    private downloadService;
    private cdRef;
    private readonly currencyPipe;
    private availsDataService;
    config: PlanCampaignConfig;
    destroyRef: DestroyRef;
    disableSaveBtn: boolean;
    mode: Mode;
    previousSavedAvailsForEdit: Avails[];
    messageBoxData: MessageBoxData;
    hardBlockMessageBoxData: MessageBoxData;
    hasHardBlock: boolean;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    setMessageBoxData(): void;
    refreshHardBlockState(): void;
    removeA18Header(): void;
    setRadioButtonConfigForDownloadPopup(): void;
    selectUnselectLine(data: {
        rowData: Avails;
        columnKeys: string;
        isCheckboxSelected: boolean;
    }): void;
    filterAppliedToTable(tableData: Avails[]): void;
    checkRadioButtonConfig(): void;
    setGtGeneralConfig(): void;
    createTotalRowData(): void;
    /**
     * Prefer mutating the existing total-row objects so the generic table's
     * `totalRowInfo` @Input reference stays stable. Replacing the array on every
     * keystroke triggers ngOnChanges → setInitialRowsForTable and jumps scroll to top.
     */
    private applyTotalRowInfo;
    private canPatchTotalRowInPlace;
    getTotalRowMessage(selectedCount: number, totalCount: number): string;
    enableDisableResetAllBtn(): void;
    sortingAppliedToTable(tableData: Avails[]): void;
    showUnselectedRowAtLast(): void;
    emitEvent(): void;
    resetAllFilter(): void;
    initResetFilterVar(): void;
    closeDownloadPopup(): void;
    openDownloadPopup(): void;
    downloadRadioButtonChanged(selectedRadio: DownloadButtonValue): void;
    download(): void;
    createPayloadForDownloadSheet(): PayloadForDownloadAvails;
    ngOnDestroy(): void;
    openReloadAvailsPopup(): void;
    reloadAvails(): void;
    openEmailAvailsPopup(res: CampaignFlow): void;
    sendAvailEmails(): void;
    openSellerCommentPopup(): void;
    onSellerCommentSaved(comment: string): void;
    rateImpressionsInputChanged(emittedData: {
        data: Avails;
        key: string;
        valueEntered: string;
    }): void;
    proceedToEdit(mode: Mode): void;
    setTableHeaders(): void;
    cancelUnsavedChanges(): void;
    saveChangesForAvails(): void;
    revertChangesForAvails(): void;
    private setProgramSelectionDisabledForRows;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignAvailsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignAvailsComponent, "afr-plan-campaign-avails", never, { "loading": { "alias": "loading"; "required": false; }; "avails": { "alias": "avails"; "required": false; }; "dataForDownloadSheet": { "alias": "dataForDownloadSheet"; "required": false; }; "clonedAvails": { "alias": "clonedAvails"; "required": false; }; "selectedDemo": { "alias": "selectedDemo"; "required": false; }; "availsGeneratedOn": { "alias": "availsGeneratedOn"; "required": false; }; "refreshAvails": { "alias": "refreshAvails"; "required": false; }; }, { "availSelectionChanged": "availSelectionChanged"; "fetchLatestAvails": "fetchLatestAvails"; "createDataForCampaignPlanning": "createDataForCampaignPlanning"; "sendEmail": "sendEmail"; }, never, never, true, never>;
}

type MarketWiseGrpOrBudgetChangeEvent = {
    data: SelectedMarketWiseGrpOrBudget;
    isValid: boolean;
};
declare class AfrPlanCampaignBudgetComponent implements OnChanges {
    readonly selectedMarketWiseGrpOrBudget: _angular_core.InputSignal<SelectedMarketWiseGrpOrBudget>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly selectedMarketWiseGrpOrBudgetChanged: _angular_core.OutputEmitterRef<MarketWiseGrpOrBudgetChangeEvent>;
    readonly radioButtonConfig: IRadioButtonComponentConfig;
    readonly planForRadioButtonConfig: IRadioButtonComponentConfig;
    readonly selectedPlanForRadio: "LOCAL_TV" | "LOCAL_TV_CTV";
    readonly messageBoxData: MessageBoxData;
    readonly gtDimension: {
        rowHeight: number;
        headerHeight: number;
        dataOnTopHeight: number;
        marginFromBottom: number;
    };
    readonly gtGeneralConfig: IGtGeneralConfig;
    readonly showError: _angular_core.WritableSignal<boolean>;
    readonly selectedRadioMessage: _angular_core.WritableSignal<string>;
    readonly tableHeaders: _angular_core.WritableSignal<IGtTableHeader[]>;
    readonly leftTableData: _angular_core.WritableSignal<MarketWiseValue[]>;
    readonly rightTableData: _angular_core.WritableSignal<MarketWiseValue[]>;
    readonly marketTables: _angular_core.Signal<{
        data: MarketWiseValue[];
        isRight: boolean;
    }[]>;
    readonly totalImpressionsDisplay: _angular_core.Signal<string>;
    readonly showTotalImpsOnRightTable: _angular_core.Signal<boolean>;
    private readonly universeSizeSum;
    private readonly annaGlobalConfig;
    private readonly planCampaignMarketService;
    private readonly planCampaignPlanningSvc;
    private readonly utilitySvc;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    private refreshFromInputs;
    private model;
    splitData(): void;
    setTableHeaders(): void;
    setInfoMessage(): void;
    budgetImpsRadioButtonChanged(selectedRadio: "GRP" | "BUDGET"): void;
    planForRadioButtonChanged(_selectedRadio: "LOCAL_TV" | "LOCAL_TV_CTV"): void;
    setMarketWiseData(valueEntered: number | null): void;
    onInputChange(value: Event): void;
    getBudgetBasedOnUniverseSize(universeSize: number, value: number): number;
    marketValueChanged(event: {
        data: MarketWiseValue;
        valueEntered: string;
    }): void;
    private emitChange;
    private syncBudgetDigitPrefixOnMarketRows;
    private recalculateTotalFromMarketWiseValues;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignBudgetComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignBudgetComponent, "afr-plan-campaign-budget", never, { "selectedMarketWiseGrpOrBudget": { "alias": "selectedMarketWiseGrpOrBudget"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "selectedMarketWiseGrpOrBudgetChanged": "selectedMarketWiseGrpOrBudgetChanged"; }, never, never, true, never>;
}

interface SpecialProgramPayload {
    FlightStartDate: string;
    FlightEndDate: string;
    StationNames: string[];
    DaypartTarget: CommonDaypartTarget[];
}
interface SpecialProgramApiData {
    ProgramName: string;
    TimeOfYear: string;
    Affiliates: string;
    ProgramIds: string[];
}
declare class SpecialProgram {
    programName: string;
    timeOfYear: string;
    affiliates: string;
    programIds: string[];
    isSelected: boolean;
    constructor(data: SpecialProgramApiData, draftProgramIds: string[] | undefined);
}

interface CommonWizardStep {
    title: string;
    isValid: boolean;
    isVisited: boolean;
    userReviewNeeded: boolean;
    nextBtnText?: string;
    textToDisplayInsideCircle: string;
    showPreviousBtn: boolean;
    previousBtnText?: string;
}
interface PlanCampaignMainWizardStep extends CommonWizardStep {
    id: MainWizardId;
    popupToShowBeforeMovingToNextStep?: PopupToShow;
    popupToShowBeforeMovingToPrevStep?: PopupToShow;
    disablePreviousBtn?: boolean;
    iconClass?: string;
}
type PopupToShow = "Avails" | "Reject";
interface PlanCampaignSubWizardStep extends CommonWizardStep {
    id: SubWizardId;
    showNextBtn: boolean;
    /** Circle navigation allowed at this step given the first-invalid barrier; sub-wizard sets when `steps` updates. */
    isAllowedToNavigate?: boolean;
}
type MainWizardId = "General" | "Avails" | "Planning" | "Review";
type SubWizardId = "PrimaryInfo" | "Markets" | "Stations" | "Dayparts" | "PrimeTime" | "MajorSportsProgramming" | "SpecialitySportsProgramming" | "SpecialProgramming" | "GrpBudget" | "StationDispersion" | "DaypartDispersion" | "SpotDispersion";

interface PrimaryInfoFormChangeEvent {
    currentValues: PrimaryInfoSelectedData;
    isFormValid: boolean;
}
interface BuyerContactFormChangeEvent {
    currentValues: {
        buyers: BuyerContactDetails[];
    };
    isFormValid: boolean;
}
type PlanCampaignGeneralInfoUpdateEvent = {
    type: "primaryInfo";
    payload: PrimaryInfoFormChangeEvent;
} | {
    type: "buyerContact";
    payload: BuyerContactFormChangeEvent;
} | {
    type: "markets";
    payload: MultiSelectIdText[];
} | {
    type: "stations";
    payload: {
        tableData: MarketWiseStationTableData[];
        isValid: boolean;
    };
} | {
    type: "dayparts";
    payload: {
        dayparts: DaypartCategory[];
        isValid: boolean;
    };
} | {
    type: "primeTime";
    payload: {
        primeTime: PrimeTime;
        isValid: boolean;
    };
} | {
    type: "majorSportsProgramming";
    payload: {
        sportsProgram: SportsProgram[];
        isValid: boolean;
    };
} | {
    type: "specialitySportsProgramming";
    payload: {
        sportsProgram: SportsProgram[];
        isValid: boolean;
    };
} | {
    type: "specialProgramming";
    payload: {
        specialProgram: SpecialProgram[];
        isValid: boolean;
    };
} | {
    type: "subWizardStep";
    payload: PlanCampaignSubWizardStep;
} | {
    type: "grpBudget";
    payload: {
        data: SelectedMarketWiseGrpOrBudget;
        isValid: boolean;
    };
} | {
    type: "stationDispersion";
    payload: {
        tableData: MarketWiseStationTableData[];
        isValid: boolean;
    };
} | {
    type: "daypartDispersion";
    payload: {
        grpByMajorDp: GrpByMajorDp;
        isValid: boolean;
    };
} | {
    type: "hiatusDates";
    payload: HiatusDate[];
} | {
    type: "spotDispersion";
    payload: {
        data: HiatusDateMonthSpotDispersion;
        isValid: boolean;
    };
} | {
    type: "generalRules";
    payload: {
        currentValues: GeneralRulesSelectedData;
        isFormValid: boolean;
    };
} | {
    type: "makeGoodRules";
    payload: {
        currentValues: MakeGoodRulesSelectedData;
        isFormValid: boolean;
    };
} | {
    type: "aduRules";
    payload: {
        currentValues: AduRulesSelectedData;
        isFormValid: boolean;
    };
} | {
    type: "minSeparation";
    payload: string | null;
};

type BuyerContactRowControls = {
    email: FormControl<string | null>;
    name: FormControl<string | null>;
    phoneNo: FormControl<string | null>;
};
type BuyerContactFormControls = {
    buyers: FormArray<FormGroup<BuyerContactRowControls>>;
};
declare class AfrPlanCampaignBuyerContactComponent implements OnChanges {
    static readonly FORM_VALUE_CHANGE_DEBOUNCE_MS = 300;
    readonly buyers: _angular_core.InputSignal<BuyerContactDetails[]>;
    readonly showLoader: _angular_core.InputSignal<boolean>;
    readonly formValueChanged: _angular_core.OutputEmitterRef<BuyerContactFormChangeEvent>;
    buyerForm: FormGroup<BuyerContactFormControls>;
    readonly activeEmailIndex: _angular_core.WritableSignal<number>;
    readonly skeletonLoaderColumns: number[];
    private readonly destroyRef;
    private readonly fb;
    private readonly primaryInfoSvc;
    private formSubscription?;
    ngOnChanges(changes: SimpleChanges): void;
    get buyerControls(): FormGroup<BuyerContactRowControls>[];
    get buyersArray(): FormArray<FormGroup<BuyerContactRowControls>>;
    private syncFormWithBuyers;
    private rebuildBuyerForm;
    private buildBuyerForm;
    private bindFormSubscriptions;
    private normalizeBuyersInput;
    addBuyer(): void;
    removeBuyer(index: number): void;
    canAddBuyer(): boolean;
    isDuplicateEmailAt(index: number): boolean;
    onEmailInput(index: number): void;
    shouldShowDuplicateEmailError(index: number): boolean;
    hasEmailFieldError(index: number): boolean;
    hasPhonePatternError(index: number): boolean;
    private createBuyerGroup;
    private emitFormState;
    private hasDuplicateEmails;
    private normalizeEmail;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignBuyerContactComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignBuyerContactComponent, "afr-plan-campaign-buyer-contact", never, { "buyers": { "alias": "buyers"; "required": false; "isSignal": true; }; "showLoader": { "alias": "showLoader"; "required": false; "isSignal": true; }; }, { "formValueChanged": "formValueChanged"; }, never, never, true, never>;
}

declare class PlanCampaignAvailsSection {
    private readonly state;
    private readonly availDataSvc;
    private readonly primaryInfoSvc;
    private readonly marketSvc;
    private readonly stationSvc;
    private readonly daypartSvc;
    private readonly annaDateTimeService;
    private readonly wizardSvc;
    private readonly previewSvc;
    private readonly commonSvc;
    private readonly commonNavSvc;
    private readonly injector;
    private readonly config;
    private readonly toastr;
    private readonly destroyRef;
    openEmailAvailsPopupSubject$: Subject<CampaignFlow>;
    openFetchLatestAvailsPopupSubject$: Subject<boolean>;
    setIsUpdatedForFirstTimeSubject$: Subject<boolean>;
    /** Invalidates in-flight generate-avails responses after reset or a newer request. */
    private generateAvailsRequestId;
    private inFlightAvailsPayload;
    private readonly generateAvailsTrigger$;
    constructor();
    fetchLatestAvails(): void;
    resetDataForAvailsSection(): void;
    /** Clears cached generate-avails payload so the next Generate Avails is not deduplicated away. */
    invalidateGenerateAvailsCache(): void;
    generateAvails(): void;
    createDataForDownloadSheet(): void;
    formatAvailsData(res: any): void;
    private syncAvailsWizardValidity;
    createPayloadForAvails(): GenerateAvailsPayload;
    getSportsProgramPayload(): _annalib_anna_feature_radiant.SportEventToBEResponse[];
    getSpecialProgramPayload(): string[];
    getPrimeProgramPayload(): _annalib_anna_feature_radiant.PrimeProgramsDayWise[];
    availSectionUpdated(data: {
        tableData: Avails[];
        isValid: boolean;
    }): boolean;
    emailAvails(comment?: string): Observable<unknown>;
    createPayloadForEmailAvails(comment?: string): PayloadForEmailAvails;
    removeUiKeysFromPayload(data: Avails[]): Avails[];
    openReloadAvailsPopup(): void;
    getTableHeaders(bookedDemo: string | null, mode: Mode): IGtTableHeader[];
    getEosAvailDetailsTableHeaders(bookedDemo: string, mode: Mode): IGtTableHeader[];
    getExtraHeaderRowForAdjustingColumnWidths(): {
        objectKey: string;
        width: string;
    }[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignAvailsSection, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignAvailsSection>;
}

declare class PlanCampaignCommonService {
    private readonly state;
    /** Triggers station dispersion rebuild in the container (GrpBudget planning sub-step). */
    readonly refreshStationDispersion$: Subject<void>;
    /** Triggers daypart dispersion rebuild in the container (DaypartDispersion sub-step). */
    readonly refreshDaypartDispersion$: Subject<void>;
    /** Triggers GrpBudget universe estimates refresh in the container. */
    readonly refreshGrpBudgetUniverse$: Subject<void>;
    checkIfThereAreUnsavedChanges(): void;
    private hasGeneralInfoChanges;
    private hasPlanningChanges;
    private hasAvailsChanges;
    private hasReviewChanges;
    private normalizeGeneralSectionData;
    private normalizeGeneralSelectedData;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignCommonService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignCommonService>;
}

declare class UsaMapMarketConstants {
    static readonly marketsUnderAlaska: string[];
    static readonly alaska = "Alaska";
    static readonly allowedDMARegionColor = "#ffdeb0";
    static readonly disabledDMARegionColor = "#ffffff";
    static readonly selectedDMARegionColor = "#F39C1F";
}
interface StationInfoForEachMarket {
    StationName: string;
    AffiliateName: string;
    StateName: string;
    MeasurementAgency: string;
}
interface MarketLegend {
    class: string;
    text: string;
}
interface MarketListResponse {
    arcs: number[][] | number[][][];
    type: "Polygon" | "MultiPolygon";
    properties: {
        MarketName: string;
        MarketRank: number;
        IsEligible: boolean;
        MarketDisplayName: string;
        StationInfo: StationInfoForEachMarket[];
    };
}
declare class MarketInfoWithStationData {
    MarketsList: MarketListResponse[];
    arcs: number[][] | number[][][];
    bbox: number[];
    marketsUnderAlaska: string[];
    constructor(BEData: any, topoJson: any, marketWiseArcInfo: any);
    isAlaskaRegion(marketName: string): boolean;
}
interface MarketFormData {
    dropdownData: MultiSelectIdText[];
    marketsWithStationResponse: MarketInfoWithStationData;
}

interface GeneralInfoData {
    primaryInfo: PrimaryInfoDropdowns;
    isStartDateInPast: boolean;
    markets: MarketFormData;
    marketWiseStationTableData: MarketWiseStationTableData[];
    daypart: DaypartFormData;
    primeTime?: PrimeTime;
    specialPrograms?: SpecialProgram[];
    clonedSpecialPrograms?: SpecialProgram[];
    majorSportPrograms?: SportsProgram[];
    clonedMajorSportPrograms?: SportsProgram[];
    specialitySportPrograms?: SportsProgram[];
    clonedSpecialitySportPrograms?: SportsProgram[];
}
interface GeneralInfoSelectedData {
    primaryInfo: PrimaryInfoSelectedData;
    markets: MultiSelectIdText[];
    buyers?: BuyerContactDetails[];
}

interface FinalCampaignPlanningData {
    selectedMarketWiseGrpOrBudget: SelectedMarketWiseGrpOrBudget;
    selectedMarketWiseStationTableData: MarketWiseStationTableData[];
    grpByMajorDp: GrpByMajorDp;
    daypartDispersionDisplayRows: DaypartCategory[];
    spotDispersionData: SpotDispersionFormData;
}
interface SpotDispersionFormData {
    calendarMinEnabledDate: NgbDateType;
    calendarMaxEnabledDate: NgbDateType;
    hiatusDateMonthWiseData: HiatusDateMonthSpotDispersion;
    makegoodRules: MakegoodRules;
    aduRules: AduRules;
    generalRules: GeneralRules;
    minSeparationTime: string;
}
interface FinalCampaignPlanningSelectedData {
    spotDispersionSelectedData: SpotDispersionSelectedData;
}
interface SpotDispersionSelectedData {
    generalRulesSelectedData: GeneralRulesSelectedData;
    makeGoodRulesSelectedData: MakeGoodRulesSelectedData;
    aduRulesSelectedData: AduRulesSelectedData;
}

interface CampaignWizardVM {
    steps: PlanCampaignMainWizardStep[];
    selectedStep: PlanCampaignMainWizardStep;
    flowType: CampaignFlow;
    disableSaveProgressBtn: boolean;
    isStationForwardPlanOrderFlow: boolean;
}
interface CampaignLoaderVM {
    showPlanCampaignLoader: boolean;
    showGeneralInfoLoader: boolean;
    showAgencyListLoading: boolean;
    showAvailsLoader: boolean;
    showLoaderForPrimeTime: boolean;
    showLoaderForSportsProgram: boolean;
    showLoaderForSpecialProgram: boolean;
    showLoaderForDaypart: boolean;
    showLoaderForGrpBudget: boolean;
    showLoaderForStationDispersion: boolean;
}
interface CampaignComponentStateVM {
    hasDaypartsInitialized: boolean;
    hasStationsInitialized: boolean;
    hasSpotDispersionInitialized: boolean;
}
interface SpotDispersionValidationVM {
    isMonthDispersionSectionValid: boolean;
    isGeneralRuleValid: boolean;
    isMgRuleValid: boolean;
    isAduRuleValid: boolean;
    isMinSeparationValid: boolean;
}
interface GrpBudgetVM {
    marketNameUniverseSizeMap: Map<string, number>;
    totalUniverseSizeSum: number;
}
interface CampaignPreviousPayloadVM {
    grpBudgetUniverseEstimatesPayload: MarketUniverseEstimatesGrpBudgetPayload;
    spotDispersion: WeekSpotDispersionPayload;
    dayparts: DaypartPayload;
    primeTime: PrimeTimePayload;
    special: SpecialProgramPayload;
    sport: SportsProgramPayload;
    avails: GenerateAvailsPayload;
    plan: PlanCampaignRequestPayload;
}
interface CampaignSubWizardVM {
    generalSection: PlanCampaignSubWizardStep[];
    selectedStepForGeneralInfo: PlanCampaignSubWizardStep;
    planningSection: PlanCampaignSubWizardStep[];
    selectedStepForPlanningSection: PlanCampaignSubWizardStep;
}
interface GeneralInfoVM {
    sectionData: GeneralInfoData;
    selectedData: GeneralInfoSelectedData;
    previousSectionData: GeneralInfoData;
    previousSelectedData: GeneralInfoSelectedData;
}
interface AvailsVM {
    data: Avails[];
    clonedData: Avails[];
    previousData: Avails[];
    draftAvails: Avails[];
    refreshAvails: boolean;
    availsGeneratedOn: string;
}
interface PlanningVM {
    sectionData: FinalCampaignPlanningData;
    selectedData: FinalCampaignPlanningSelectedData;
    previousSectionData: FinalCampaignPlanningData;
    previousSelectedData: FinalCampaignPlanningSelectedData;
}
/**
 * Review step state. `data` is the live review container payload; `previousData` is the last
 * committed snapshot (initial load, buy-line save, save progress). Compared in
 * `PlanCampaignCommonService.checkIfThereAreUnsavedChanges()` to drive `unsavedChangesPresent`.
 */
interface ReviewVM {
    data: ReviewPlanContainerData;
    previousData: ReviewPlanContainerData;
}
interface StationsVM {
    previousData: MarketWiseStationTableData[];
}
interface DaypartsVM {
    previousData: DaypartCategory[];
    previousGrpByMajorDp: GrpByMajorDp;
}
interface PrimeSportsSpecialPreviousVM {
    prime: PrimeTime;
    specials: SpecialProgram[];
    majorSports: SportsProgram[];
    specialitySports: SportsProgram[];
}
interface DraftVM {
    id: number;
    response: any;
}
interface DraftStateVM {
    pendingDaypartDraftHydration: boolean;
    /** When false, refetched prime/sports/special data must not reuse draft selections and steps stay invalid until revisited. */
    pendingProgramDraftHydration: boolean;
    pendingPrimeSportsSpecialDraftHydration: boolean;
    pendingPlanningDaypartDraftHydration: boolean;
    pendingPlanningGrpBudgetDraftHydration: boolean;
    pendingPlanningStationDraftHydration: boolean;
    pendingSpotDispersionDraftHydration: boolean;
    /** Live edit: refetch GetStationMarketShare when demo or posting type changes. */
    pendingDispersionStationMarketSharePrefill: boolean;
}
interface AvailsSelectionVM {
    avails: Avails[];
    dp: string[];
    stations: string[];
    markets: string[];
}
interface LineDetailsSetVM {
    AfterSpotDispersion: boolean;
    AfterGrpBudget: boolean;
}
interface SaveProgressVM {
    hasStationPreviousSnapshot: boolean;
    hasDaypartPreviousSnapshot: boolean;
    hasPrimePreviousSnapshot: boolean;
    hasSpecialPreviousSnapshot: boolean;
    hasSportsPreviousSnapshot: boolean;
    hasAvailsPreviousSnapshot: boolean;
    hasGrpBudgetPreviousSnapshot: boolean;
    hasStationDispersionPreviousSnapshot: boolean;
    hasDaypartDispersionPreviousSnapshot: boolean;
}
interface PlanningPreviousSelectionVM {
    grpBudget: SelectedMarketWiseGrpOrBudget;
}
interface CampaignViewModel {
    wizard: CampaignWizardVM;
    progress: number;
    loader: CampaignLoaderVM;
    componentState: CampaignComponentStateVM;
    noPlanFound: boolean;
    hubConnection: HubConnection;
    validation: SpotDispersionValidationVM;
    grpBudget: GrpBudgetVM;
    businessRulesData: any;
    previousPayload: CampaignPreviousPayloadVM;
    subWizard: CampaignSubWizardVM;
    generalInfo: GeneralInfoVM;
    avails: AvailsVM;
    planning: PlanningVM;
    review: ReviewVM;
    markAllBtnAsDisabled: boolean;
    stations: StationsVM;
    dp: DaypartsVM;
    dataForDownloadSheet: DownloadSheetData;
    draft: DraftVM;
    draftState: DraftStateVM;
    availsSelection: AvailsSelectionVM;
    lineDetailsSet: LineDetailsSetVM;
    toastrId: number;
    navigateBackTo: string;
    rejectCallHappening: boolean;
    unsavedChangesPresent: boolean;
    unsavedChangesConfirmationConfig: IConfirmationPopupConfig;
    redirectToListing: boolean;
    saveProgress: SaveProgressVM;
    planningSelection: PlanningPreviousSelectionVM;
    planCampaignConfig: PlanCampaignConfig;
}

interface DraftPrimaryInfoFields {
    AdvertiserName?: string | null;
    AgencyName?: string | null;
    PostingType?: string | null;
    PlanningDemo?: string | null;
    SpotDuration?: string | null;
    ProductCode?: string | null;
    CampaignName?: string | null;
    BuyerEstimate?: string | null;
    ProductDescription?: string | null;
    FlightStartDate?: string | null;
    FlightEndDate?: string | null;
    IsFlightStartDateInPast?: boolean;
    IsExpired?: boolean;
}
interface DraftBootstrapResponse extends DraftPrimaryInfoFields {
    Avails?: Array<{
        IsSelected?: boolean;
    }>;
    AvailsGeneratedOn?: string | null;
    MarketNames?: string[] | null;
    MarketTarget?: MarketTarget[];
    StationTarget?: unknown;
    DaypartTarget?: CommonDaypartTarget[] | null;
    DaypartDispersion?: DaypartDispersionEntry[] | null;
    PrimeProgramsDayWise?: unknown;
    SpecialProgramIds?: string[] | null;
    SportEvents?: unknown;
    IsOtherPrimeProgramsSelected?: boolean;
    CampaignExpiresOn?: string | null;
    CreatedByUserId?: string;
    Buyers?: Array<{
        Name: string;
        Email: string;
        ContactNumber: string;
    }>;
}
interface PlanCampaignBootstrapRawResponse {
    advertisers: unknown;
    agencies?: unknown;
    productCodes?: unknown;
    postingTypes: unknown;
    demos: unknown;
    spotDurations?: unknown;
    usaMapTopoJson: unknown;
    markets: unknown;
    marketWiseArcInfo: unknown;
    businessRules: unknown;
    draft?: unknown;
    stationForwardAvailDetails?: unknown;
}

type DraftFlowHelpers = {
    createPayloadForAvails: () => any;
    createDataForDownloadSheet: () => void;
    formatAvailsData: (res: unknown) => void;
    createDataForCampaignPlanning: () => void;
    createPayloadForCampaignPlanning: () => PlanCampaignRequestPayload;
    openReloadAvailsPopup: () => void;
    startLoader: () => void;
    startBlockingLoader: () => void;
    stopLoader: () => void;
    showExpiredToast: (message: string) => number;
};
declare class PlanCampaignDraftSection {
    private readonly state;
    private readonly spotDispersionSvc;
    private readonly wizardSvc;
    private readonly previewSvc;
    private readonly reviewSvc;
    private readonly config;
    draftHelpers: DraftFlowHelpers;
    openExpiredDraftModal$: Subject<boolean>;
    private hasTriggeredExpiredDraftModal;
    /** When false, `setSelectedStepFromDrafts` must not override user wizard navigation. */
    private allowDraftWizardStepSelection;
    /** Initial-draft shell-loader gate (`PlanCampaignDraftInitialLoadPhase`). See `docs/plan-campaign-container-loader.md`. */
    private draftInitialLoadPhase;
    /**
     * Nested follow-up HTTP (etc.) bracket count; while greater than zero, hiding the loader (stop) is deferred
     * until matching `endNestedDraftLoadWorkForAsyncCalls`.
     */
    private nestedAsyncCallsBlockingLoaderStopDepth;
    private static readonly STOP_INITIAL_DRAFT_LOADER_DELAY_MS;
    /** Defers hiding the container loader briefly after initial draft load completes. */
    private scheduleStopDraftHelpersLoader;
    /** Draft JSON received and nested landing async may still be in flight — keeps shell overlay up unless explicitly stopped elsewhere. */
    isDraftInitialLoadGatePending(): boolean;
    /** `plan-campaign-container-loader`; wired via container `setDraftHelpers`. */
    startPlanningShellLoader(): void;
    startBlockingShellLoader(): void;
    stopPlanningShellLoader(): void;
    /** `InProgress`, no nested async deferring stop — safe to hide loader if landing logic allows. */
    private canAttemptStopInitialDraftLoader;
    /** Arm after draft JSON is loaded; further async may run before showing the wizard. Shell stays visible via `startPlanningShellLoader()` (draft bootstrap) — do not start again here to avoid stacking ngx foreground. */
    beginInitialDraftLoader(): void;
    /** Clear gate bookkeeping for non-draft routes (loader stopped elsewhere via `draftHelpers.stopLoader`). */
    resetInitialDraftLoader(): void;
    /** Nested async tied to draft open began (e.g. market-share forkJoin pair with `end…`). Increments blocking depth. */
    beginNestedDraftLoadWorkForAsyncCalls(): void;
    /** Matching end after nested draft-load async completes. Decrements blocking depth (floors at 0). */
    endNestedDraftLoadWorkForAsyncCalls(): void;
    /**
     * If the gate expects a loader stop and no nested async is still deferring stop, hides the overlay once
     * after a 1.5s delay.
     */
    tryStopInitialDraftLoader(): void;
    /**
     * Errors / bailout: clears nested-async blocking depth and hides the overlay so the shell never stays masked.
     */
    forceStopInitialDraftLoader(): void;
    /**
     * Under gate: only stops loader via `tryStop…` when no nested async blocks stop; otherwise callers may still defer stop.
     * Outside gate: same as unconditional `draftHelpers.stopLoader`.
     */
    applyContainerLoaderStopPolicy(): void;
    setDayjsDraft(): void;
    getDraftId(route: ActivatedRoute): void;
    /**
     * When a draft was saved with a past flight start, returns whether the user-selected date is still on or before
     * the draft's original flight start date.
     */
    checkIfStartDateIsInPast(startDate: NgbDate): boolean;
    updateAvailsFromDrafts(): void;
    checkIfLineDetailsPresent(): void;
    buildGeneralRulesSelectedData(draftResponse: DraftBootstrapResponse | null, planningSectionData: FinalCampaignPlanningData, planningSelectedData: FinalCampaignPlanningSelectedData): {
        planningSectionData: FinalCampaignPlanningData;
        planningSelectedData: FinalCampaignPlanningSelectedData;
        isMinSeparationValid: boolean;
    };
    buildMakeGoodRulesSelectedData(draftResponse: DraftBootstrapResponse | null, planningSectionData: FinalCampaignPlanningData, planningSelectedData: FinalCampaignPlanningSelectedData, businessRulesData: {
        MakeGoodBusinessRules?: unknown;
    } | null): FinalCampaignPlanningSelectedData;
    buildAduRulesSelectedData(draftResponse: DraftBootstrapResponse | null, planningSectionData: FinalCampaignPlanningData, planningSelectedData: FinalCampaignPlanningSelectedData, businessRulesData: {
        AduBusinessRules?: unknown;
    } | null): FinalCampaignPlanningSelectedData;
    buildBootstrapPlanningRulesState(draftResponse: DraftBootstrapResponse | null, planningSectionData: FinalCampaignPlanningData, businessRulesData: {
        GeneralBusinessRules?: unknown;
        MakeGoodBusinessRules?: unknown;
        AduBusinessRules?: unknown;
    } | null): {
        planningSectionData: FinalCampaignPlanningData;
        planningSelectedData: FinalCampaignPlanningSelectedData;
        isMinSeparationValid: boolean;
    };
    setSelectedStepFromDrafts(): void;
    /**
     * Wizard step navigation from draft metadata runs only during the first draft open
     * (while the initial-load gate is InProgress). Later calls — e.g. after the user edits
     * a field — may still run loader/preview side effects but must not change the active step.
     */
    private shouldRestoreWizardStepNavigationFromDraft;
    private hydrateAvailsStepFromDraft;
    private hydrateReviewStepFromDraft;
    /**
     * Applies draft-driven wizard navigation rules. Returns whether preview data should be generated.
     */
    private resolveWizardStepFromDraft;
    private handleExpiredDraftNavigation;
    private navigateToGeneralStart;
    private navigateToAvailsWithReloadPrompt;
    private restoreWizardFromLastSavedStep;
    private withSpotDispersionSelectedData;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignDraftSection, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignDraftSection>;
}

declare class PlanCampaignExecutionSection {
    private readonly state;
    private readonly toastr;
    private readonly saveService;
    private readonly realTimeDataService;
    private readonly config;
    /** Payload for the in-flight plan request; committed once planning reaches a terminal hub status. */
    private pendingPlanPayload;
    /** Submits the campaign plan when the payload changed since the last run. */
    planCampaign(): void;
    /**
     * Skip replanning only when planning inputs are unchanged and a campaign already exists.
     * `previousPayload.plan` is also updated on save progress / draft hydration, so payload
     * equality alone must not suppress the first plan run.
     */
    private shouldSkipDuplicatePlanRequest;
    private hasPlanPayloadChanged;
    private withoutCampaignId;
    private beginPlanCampaign;
    private handlePlanCampaignRequestFailure;
    private handleHubConnectionFailure;
    private clearPlanningAttempt;
    private connectToCampaignHub;
    private stopExistingHubConnection;
    private stopHubConnection;
    private parseAndHandleCampaignHubMessage;
    private handleCampaignHubMessage;
    private finishNoPlanFound;
    private commitSuccessfulPlanPayload;
    private clearReviewData;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignExecutionSection, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignExecutionSection>;
}

type PrimaryInfoFormChangeInput = {
    currentValues: PrimaryInfoSelectedData;
    isFormValid: boolean;
};
declare class PlanCampaignGeneralSection {
    private readonly state;
    private readonly daypartDataService;
    private readonly toastr;
    private readonly draftSvc;
    private readonly primaryInfoSvc;
    private readonly wizardSvc;
    private readonly saveSvc;
    private readonly commonSvc;
    private readonly stationSvc;
    private readonly daypartSvc;
    private readonly primeSvc;
    private readonly sportsProgramSvc;
    private readonly specialProgramSvc;
    private readonly availSvc;
    private readonly reviewSvc;
    private readonly spotSvc;
    private readonly previewSvc;
    private readonly annaDateTimeService;
    private readonly config;
    private readonly bootstrapSvc;
    private readonly destroyRef;
    private readonly daypartFetchTrigger$;
    /** Supersedes stale `primaryInfoFormChanged` runs when the user edits faster than agency load completes. */
    private primaryInfoFormChangedInvocationId;
    constructor();
    getDataForDropdowns(): void;
    hydrateDraftGeneralWizardSteps(): void;
    checkIfDaypartSectionValid(tableData: DaypartCategory[], showGrpColumn: boolean): boolean;
    checkIfDaypartsAreValid(tableData: DaypartCategory[]): void;
    checkIfPrimeSportsSpecialValid(_prime: unknown, _special: unknown, _sports: unknown): void;
    primaryInfoFormChanged(newData: PrimaryInfoFormChangeInput): Promise<void>;
    buyerContactFormChanged(data: {
        currentValues: {
            buyers: BuyerContactDetails[];
        };
        isFormValid: boolean;
    }): void;
    checkIfDependentDataChangedForPrimeSportsSpecial(): void;
    marketFormChanged(newValue: MultiSelectIdText[]): void;
    markGeneralSubWizardAsInvalidAndNotVisited(id: SubWizardId): void;
    stationSectionUpdated(data: {
        tableData: MarketWiseStationTableData[];
        isValid: boolean;
    }): void;
    removePrimeSportsAndSpecialStep(): void;
    createTableDataForStationSection(applyDraftStationTarget?: boolean): void;
    fetchDayparts(): void;
    extractTimezoneHeaders(data: DaypartCategory[]): string[];
    createPayloadForDayparts(): DaypartPayload;
    daypartFormUpdated(data: {
        dayparts: DaypartCategory[];
        isValid: boolean;
    }): void;
    primeTimeFormUpdated(data: {
        primeTime: PrimeTime;
        isValid: boolean;
    }): void;
    specialProgramFormUpdated(data: {
        specialProgram: SpecialProgram[];
        isValid: boolean;
    }): void;
    majorSportsProgramFormUpdated(data: {
        sportsProgram: SportsProgram[];
        isValid: boolean;
    }): void;
    specialitySportsProgramFormUpdated(data: {
        sportsProgram: SportsProgram[];
        isValid: boolean;
    }): void;
    getParticularCategory(categoryName: string): DaypartCategory | undefined;
    fetchDataForPrimeSportsAndSpecialProgram(): void;
    createFinalPlanningDataFromDraft(): void;
    createPayloadForPrimeTime(): PrimeTimePayload | null;
    getSelectedStationNames(): string[];
    createPayloadForSportsCategory(): SportsProgramPayload | null;
    createPayloadForSpecialCategory(): SpecialProgramPayload | null;
    private syncPrimaryInfoValidationState;
    private syncDownstreamSteps;
    private handleMarketsAndStationsValidation;
    private resetMarketSelections;
    private syncProgramSubStepValidation;
    private invalidateProgramSubStepsAfterAvailsDependentChange;
    private isStalePrimaryInfoFormChangedInvocation;
    /** Skips re-processing when the form re-emits values already committed to state (e.g. after agency sync). */
    private isPrimaryInfoFormRedundantEmit;
    private buildPrimaryInfoSectionDataForChange;
    private shouldResetDownstreamForPrimaryInfoChange;
    private hasPrimaryInfoAdvertiserChanged;
    /** Returns null when a newer primary-info change superseded this invocation. */
    private fetchAgenciesForAdvertiserChange;
    private patchAdvertiserDependentAgencyState;
    private applyPrimaryInfoFormChangeSideEffects;
    private reactToRadiantPrimaryInfoPlanningFieldChanges;
    private areMarketSelectionsEqual;
    private getSortedMarketIds;
    private resetDownstreamAfterGeneralDataChange;
    private checkIfUniverseSizeDependentPrimaryInfoChanged;
    private checkIfStationShareDependentPrimaryInfoChanged;
    private hasSelectedStationsForPlanning;
    private refreshRadiantStationAndUniversePlanningData;
    private resolvePrimaryInfoSubStepValidity;
    private notifyGeneralFormChanged;
    private updateProgramFormSection;
    private applyDaypartFetchSuccess;
    private handleDaypartFetchFailed;
    /** Skips avails/dispersion/program cascade while the user is mid-edit on an invalid form (e.g. missing days). */
    private shouldRunDaypartDownstreamCascade;
    private setupWizardAndDraftForProgramFetch;
    private buildProgramFetchRequests;
    private shouldRefetchProgramSection;
    private removeProgramSection;
    private clearProgramSectionData;
    private getPreviousPayloadKey;
    private getPrimeSportsPreviousKey;
    private getWizardStepToggle;
    private fetchAndApplyProgramData;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignGeneralSection, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignGeneralSection>;
}

declare class PlanCampaignNavigationSection {
    private readonly state;
    private readonly route;
    private readonly annaGlobalConfig;
    private readonly reviewSection;
    private readonly saveSection;
    private readonly commonNavSvc;
    private readonly commonSvc;
    readonly openUnsavedChangesPopup$: Subject<void>;
    captureListingTabFromRoute(): void;
    initUnsavedChangesPopupConfig(): void;
    cancelClicked(): void;
    navigateToCampaignListing(closeIconClicked: boolean): void;
    saveProgressAndNavigateToListing(): void;
    private buildUnsavedChangesPopupConfig;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignNavigationSection, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignNavigationSection>;
}

declare class PlanCampaignPlanningSection {
    private readonly state;
    private readonly wizardSvc;
    private readonly reviewSvc;
    private readonly previewSvc;
    private readonly commonSvc;
    private readonly stationSvc;
    private readonly draftSvc;
    private readonly spotSvc;
    private readonly generalSvc;
    private readonly availSvc;
    private readonly annaDateTimeService;
    private readonly campaignPlanningDataSvc;
    private readonly utilitySvc;
    private readonly marketSvc;
    private readonly config;
    private readonly destroyRef;
    private readonly toastr;
    private readonly grpBudgetUniverseEstimatesFetchTrigger$;
    private readonly stationMarketSharePrefillTrigger$;
    constructor();
    subscribeToGrpBudgetUniverseEstimatesFetch(): void;
    subscribeToStationMarketSharePrefill(): void;
    budgetFormChanged(value: {
        data: SelectedMarketWiseGrpOrBudget;
        isValid: boolean;
    }): void;
    finalCampaignStationSectionUpdated(data: {
        tableData: MarketWiseStationTableData[];
        isValid: boolean;
    }): void;
    private finalizePlanningSubStepEdit;
    refreshStationDispersion(): void;
    private getSelectedDraftStationNames;
    private resolveMarketsTableForDispersion;
    private buildStationDispersionRows;
    private resolveStationMarketSharesForDispersion;
    private syncStationForwardFlowDependencies;
    private applyStationDispersionPlanningState;
    private updateStationDispersionValidation;
    private prefillStationMarketSharesForDispersionFromApi;
    private applyStationMarketSharePrefillSuccess;
    private buildMarketSharePrefillRequests;
    private patchStationDispersionData;
    finalCampaignDaypartSectionUpdated(data: {
        grpByMajorDp: GrpByMajorDp;
        isValid: boolean;
    }): void;
    buildDaypartDispersionDisplayRows(): DaypartCategory[];
    refreshDaypartDispersion(): void;
    private shouldPrefetchDaypartsForDispersion;
    private resolveDispersionSource;
    private buildSyncedGrpByMajorDp;
    private resolveCategoryGrp;
    private applyDaypartDispersionState;
    private patchDaypartDispersionDisplayRows;
    private captureDaypartDispersionPreviousSnapshotIfNeeded;
    private syncDaypartTimezoneHeadersToGeneral;
    private updateDaypartDispersionSubStepValidity;
    private runDaypartDispersionDraftBootstrapSideEffects;
    private convertDraftHiatusDatesForSpotDispersion;
    private isGrpBudgetSelectionValid;
    createDataForCampaignPlanning(): void;
    private shouldSkipStationForwardPlanningRebuild;
    private collectSelectedAvailsSummary;
    private syncPlanningForSeparateStepMode;
    private syncPlanningForStationForwardMode;
    private createGrpBudgetUniverseEstimatesPayload;
    refreshGrpBudgetUniverse(): void;
    private handleGrpBudgetUniverseEstimatesFetchFailure;
    private applyGrpBudgetUniverseEstimatesFetchSuccess;
    private shouldBuildGrpBudgetRowsWithoutFetch;
    createBudgetOrGrpSelectedData(): void;
    private hasGrpBudgetTargetChanged;
    private toGrpBudgetTargetComparable;
    private clearGrpBudgetPlanningSelection;
    private toNumberOrNull;
    private resolveGrpBudgetTotals;
    private buildSelectedMarketWiseGrpOrBudget;
    private buildGrpBudgetMarketWiseRows;
    private applyDraftGrpBudgetSideEffects;
    private captureGrpBudgetPreviousSnapshotIfNeeded;
    private resolveSelectedMarketsForGrpBudget;
    getDisplayUniverseSizeText(universeSize: number, percentage: number): string;
    getTableHeadersForMarketBudgetSection(demo: string): IGtTableHeader[];
    getTableHeadersForMarketGrpSection(demo: string): IGtTableHeader[];
    private shouldHydrateStationSharesFromDraft;
    private shouldHydrateDaypartGrpFromDraft;
    private isMarketInDraftMarketNames;
    private getStationForwardPlanningSelectionFromApi;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignPlanningSection, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignPlanningSection>;
}

declare class PlanCampaignReviewSection {
    private readonly state;
    private readonly wizard;
    private readonly saveProgressService;
    private readonly commonSvc;
    private readonly reviewDataService;
    approveCampaign$: Subject<boolean>;
    updateReviewCampaignData(data: ReviewPlanContainerData): void;
    /** Commits the current review data as the baseline for unsaved-change detection. */
    snapshotReviewDataAsPrevious(): void;
    private shouldTakeInitialSnapshot;
    openPopup(popupToOpen: PopupToShow): void;
    /**
     * Rejects the server-side review campaign when planning inputs change after a plan was generated,
     * then clears stale review and payload state.
     *
     * @param shouldRejectStaleCampaign When false (navigation/reset flows), skip the reject call
     *   when a draft is already persisted — the draft owns the campaign lifecycle in that case.
     */
    resetDataForReviewCampaignIfUserUpdatedTheData(shouldRejectStaleCampaign?: boolean): void;
    private clearStateAfterReviewCampaignRejected;
    getHeadersForEditableLineDetails(mode: Mode, isImpsMetric: boolean, isLoading: boolean, weekArr: ModifiedWeekWiseSpotCount[], noOfPlaceholderColumn: number): IGtTableHeader[];
    getTabs(): ListingTab[];
    getMetricDropdown(): SingleSelectIdText[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignReviewSection, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignReviewSection>;
}

declare class PlanCampaignSaveSection {
    private readonly state;
    private readonly planCampaignDraftDataService;
    private readonly route;
    private readonly router;
    private readonly toastr;
    private readonly planCampaignPrimaryInfoService;
    private readonly planCampaignStationService;
    private readonly planCampaignDaypartService;
    private readonly planCampaignMarketService;
    private readonly planCampaignConfig;
    private readonly commonSvc;
    private readonly commonNavigationSvc;
    resetSubject$: Subject<boolean>;
    private saveInProgress;
    saveProgress(): void;
    updateDataOnSaveProgress(savedPlanPayload?: PlanCampaignRequestPayload): void;
    checkIfSaveBtnToBeEnabled(): void;
    createPayloadForCampaignPlanning(): PlanCampaignRequestPayload;
    private getPayloadBuildContext;
    private getStationForwardRouteFlags;
    private buildSaveDraftPayload;
    private resolveStationPlanIdFromRoute;
    private handleDraftSaveSuccess;
    private resolveLastSavedStep;
    private withStationForwardDraftFallback;
    private resolveStationTarget;
    private resolveDaypartPayload;
    private applyGrpBudgetTargets;
    private applySpotDispersionPayload;
    private createMarketTargetFromGrpBudgetSelection;
    private resolveMarketTarget;
    private applyAvailsAndProgramsPayload;
    private resolveIsOtherPrimeProgramsSelected;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignSaveSection, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignSaveSection>;
}

interface MakeGoodBusinessRulesInfo {
    TimeWindow?: BusinessRuleApiOption[];
    AllowedInventory?: BusinessRuleApiOption[];
    SportsPermittedAlternatives?: BusinessRuleApiOption[];
    PrimeTimePermittedAlternative?: BusinessRuleApiOption[];
}
interface AduBusinessRulesInfo {
    TimeWindow?: BusinessRuleApiOption[];
}
interface BusinessRuleApiOption {
    Value?: unknown;
    IsSelected?: boolean;
    DisplayText?: string;
}
declare class PlanCampaignSpotSection {
    private readonly store;
    private readonly wizardSection;
    private readonly reviewSection;
    private readonly primaryInfo;
    private readonly utilityService;
    private readonly previewSvc;
    private readonly datepickerService;
    private readonly config;
    static readonly minValue = 85;
    static readonly maxValue = 200;
    static readonly minValueForGeneralRules = 1;
    static readonly maxValueForGeneralRules = 100;
    lineDetailSubject$: Subject<boolean>;
    private readonly dateFormatApi;
    private readonly dateFormatDisplay;
    setGeneralRulesSelectedData(selectedGeneralRules: GeneralRulesSelectedData, generalRules: GeneralRules, dataFromDraft: unknown): void;
    setMakeGoodRulesSelectedData(selected: MakeGoodRulesSelectedData, makegoodRules: MakegoodRules, makeGoodBusinessRulesInfo: MakeGoodBusinessRulesInfo, dataFromDraft: unknown): void;
    setAduRulesSelectedData(selected: AduRulesSelectedData, aduRules: AduRules, aduBusinessRulesInfo: AduBusinessRulesInfo, dataFromDraft: unknown): void;
    getSumOfMonthWiseDispersion(arr: MonthWiseHiatusDateData[]): number;
    isApproximately100(dispersionSum: number, tolerance?: number): boolean;
    runAduRulesValidation(adu: AduRulesSelectedData): boolean;
    runMakegoodRulesValidation(makegood: MakeGoodRulesSelectedData): boolean;
    runGeneralRulesValidation(data: GeneralRulesSelectedData): boolean;
    checkIfBusinessRuleFormValid(): boolean;
    /** Syncs hiatus calendar min/max from primary-info flight dates into planning spot-dispersion state. */
    syncSpotDispersionCalendarBoundsFromFlightDates(options?: {
        includePreviousSnapshot?: boolean;
    }): void;
    checkIfDependentDataForSpotDispersionChanged(): void;
    /**
     * Rebuilds month-wise spot dispersion from flight dates and hiatus ranges.
     * Skips the rebuild when the payload matches `previousPayload.spotDispersion`,
     * unless draft month percentages still need to be applied.
     */
    computeSpotDispersionWeek(hiatusDates: HiatusDate[], resetCampaign?: boolean): void;
    convertStartDateEndDateIntoSpecifiedFormat(currentFormat: string, expectedFormat: string, date: HiatusDate): {
        StartDate: string;
        EndDate: string;
    };
    createHiatusSelectedData(hiatusDates: HiatusDate[], monthRanges: SpotDispersionMonthRange[]): void;
    monthSpotDispersionUpdated(value: {
        data: HiatusDateMonthSpotDispersion;
        isValid: boolean;
    }): void;
    generalRulesUpdated(event: {
        currentValues: GeneralRulesSelectedData;
        isFormValid: boolean;
    }): void;
    makegoodRulesUpdated(event: {
        currentValues: MakeGoodRulesSelectedData;
        isFormValid: boolean;
    }): void;
    aduRulesUpdated(event: {
        currentValues: AduRulesSelectedData;
        isFormValid: boolean;
    }): void;
    minSeparationUpdated(event: string | null): void;
    syncSpotDispersionValidityForCurrentState(): void;
    private getFlightDates;
    private resolveDraftOrDefault;
    private getSelectedBusinessRuleOptionText;
    private getSelectedOption;
    private resolveDropdownSelection;
    private isRequiredValid;
    private isInRange;
    private applySpotDispersionCalendarBounds;
    private buildSpotDispersionPayload;
    private generateMonthRangesForSpotDispersion;
    /** Total days in range minus days covered by any hiatus overlap. */
    private countSchedulableDays;
    private buildDraftTargetPercentagesByMonth;
    private buildDefaultTargetPercentagesByMonth;
    private resolveMonthTargetPercentage;
    private patchHiatusDateMonthWiseData;
    private patchSpotDispersionValidationFromCurrentState;
    private applySpotDispersionDraftInitializationSideEffects;
    private markSpotDispersionSubStepVisited;
    private recomputeSpotDispersionStepValidity;
    private isSpotDispersionStepActive;
    private updateSelectedRuleData;
    private applyFormUpdateSideEffects;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignSpotSection, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignSpotSection>;
}

type Patch<T> = Partial<T>;
/** ---------- Store ---------- */
declare class PlanCampaignStateService {
    private readonly _wizard;
    private readonly _progress;
    private readonly _loader;
    private readonly _componentState;
    private readonly _noPlanFound;
    private readonly _markAllBtnAsDisabled;
    private readonly _hubConnection;
    private readonly _validation;
    private readonly _grpBudget;
    private readonly _businessRulesData;
    private readonly _previousPayload;
    private readonly _subWizard;
    private readonly _generalInfo;
    private readonly _avails;
    private readonly _planning;
    private readonly _review;
    private readonly _stations;
    private readonly _dp;
    private readonly _primeSportsSpecial;
    private readonly _dataForDownloadSheet;
    private readonly _draft;
    private readonly _draftState;
    private readonly _availsSelection;
    private readonly _lineDetailsSet;
    private readonly _toastrId;
    private readonly _navigateBackTo;
    private readonly _rejectCallHappening;
    private readonly _unsavedChangesPresent;
    private readonly _unsavedChangesConfirmationConfig;
    private readonly _redirectToListing;
    private readonly _saveProgress;
    private readonly _planningSelection;
    private readonly _campaignId;
    readonly wizard: Signal<CampaignWizardVM>;
    readonly progress: Signal<number>;
    readonly loader: Signal<CampaignLoaderVM>;
    readonly componentState: Signal<CampaignComponentStateVM>;
    readonly noPlanFound: Signal<boolean>;
    readonly markAllBtnAsDisabled: Signal<boolean>;
    readonly hubConnection: Signal<HubConnection | null>;
    readonly validation: Signal<SpotDispersionValidationVM>;
    readonly grpBudget: Signal<GrpBudgetVM>;
    readonly businessRulesData: Signal<CampaignViewModel["businessRulesData"]>;
    readonly previousPayload: Signal<CampaignPreviousPayloadVM>;
    readonly subWizard: Signal<CampaignSubWizardVM>;
    readonly generalInfo: Signal<GeneralInfoVM>;
    readonly avails: Signal<AvailsVM>;
    readonly planning: Signal<PlanningVM>;
    readonly review: Signal<ReviewVM>;
    readonly stations: Signal<StationsVM>;
    readonly dp: Signal<DaypartsVM>;
    readonly primeSportsSpecial: Signal<PrimeSportsSpecialPreviousVM>;
    readonly dataForDownloadSheet: Signal<DownloadSheetData | null>;
    readonly draft: Signal<DraftVM>;
    readonly draftState: Signal<DraftStateVM>;
    readonly availsSelection: Signal<AvailsSelectionVM>;
    readonly lineDetailsSet: Signal<LineDetailsSetVM>;
    readonly toastrId: Signal<number | null>;
    readonly navigateBackTo: Signal<string | null>;
    readonly rejectCallHappening: Signal<boolean>;
    readonly unsavedChangesPresent: Signal<boolean>;
    readonly unsavedChangesConfirmationConfig: Signal<CampaignViewModel["unsavedChangesConfirmationConfig"] | null>;
    readonly redirectToListing: Signal<boolean>;
    readonly saveProgress: Signal<SaveProgressVM>;
    readonly planningSelection: Signal<PlanningPreviousSelectionVM>;
    readonly campaignId: Signal<number>;
    patchWizard(p: Patch<CampaignWizardVM>): void;
    setProgress(progress: number): void;
    patchLoader(p: Patch<CampaignLoaderVM>): void;
    patchComponentState(p: Patch<CampaignComponentStateVM>): void;
    patchValidation(p: Patch<SpotDispersionValidationVM>): void;
    patchGrpBudget(p: Patch<GrpBudgetVM>): void;
    setBusinessRulesData(next: CampaignViewModel["businessRulesData"]): void;
    patchPreviousPayload(p: Patch<CampaignPreviousPayloadVM>): void;
    patchSubWizard(p: Patch<CampaignSubWizardVM>): void;
    patchGeneralInfo(p: Patch<GeneralInfoVM>): void;
    patchAvails(p: Patch<AvailsVM>): void;
    patchPlanning(p: Patch<PlanningVM>): void;
    patchReview(p: Patch<ReviewVM>): void;
    patchStations(p: Patch<StationsVM>): void;
    patchDayparts(p: Patch<DaypartsVM>): void;
    patchPrimeSportSpecialPrevious(p: Patch<PrimeSportsSpecialPreviousVM>): void;
    setDownloadSheetData(data: DownloadSheetData | null): void;
    patchDraft(p: Patch<DraftVM>): void;
    patchDraftState(p: Patch<DraftStateVM>): void;
    patchAvailsSelection(p: Patch<AvailsSelectionVM>): void;
    patchLineDetailsSet(p: Patch<LineDetailsSetVM>): void;
    patchSaveProgress(p: Patch<SaveProgressVM>): void;
    patchPlanningSelection(p: Patch<PlanningPreviousSelectionVM>): void;
    patchFlags(p: {
        noPlanFound?: boolean;
        markAllBtnAsDisabled?: boolean;
        toastrId?: number | null;
        navigateBackTo?: string | null;
        rejectCallHappening?: boolean;
        unsavedChangesPresent?: boolean;
        unsavedChangesConfirmationConfig?: CampaignViewModel["unsavedChangesConfirmationConfig"] | null;
        redirectToListing?: boolean;
    }): void;
    setHubConnection(conn: HubConnection | null): void;
    setCampaignId(id: number | null): void;
    getCampaignId(): number | null;
    resetAll(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignStateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignStateService>;
}

declare class PlanCampaignWizardSection {
    private readonly state;
    private readonly config;
    isStationForwardPlanOrderFlowActive(): boolean;
    getWizardStepsForFlow(flow: CampaignFlow): PlanCampaignMainWizardStep[];
    getWizardStepsForStationForwardFlow(): PlanCampaignMainWizardStep[];
    getDefaultWizardSteps(): PlanCampaignMainWizardStep[];
    getWizardStepsForManualPlanningFlow(): PlanCampaignMainWizardStep[];
    getWizardStepsForExportAvailsFlow(): PlanCampaignMainWizardStep[];
    getWizardStepsForAnnaAvailsFlow(): PlanCampaignMainWizardStep[];
    getWizardStepsForAnnaPackageFlow(): PlanCampaignMainWizardStep[];
    getStepsForGeneralSection(): PlanCampaignSubWizardStep[];
    getStepsForStationForwardGeneralSection(): PlanCampaignSubWizardStep[];
    getStepsForCampaignPlanningSection(): PlanCampaignSubWizardStep[];
    initFlowFromRoute(route: ActivatedRoute): void;
    initFlowFromParamMap(paramMap: ParamMap): void;
    initMainWizard(): void;
    initSubWizardForGeneralSection(): void;
    initSubWizardForPlanningSection(): void;
    wizardStepChanged(step: PlanCampaignMainWizardStep): void;
    subWizardStepChanged(step: PlanCampaignSubWizardStep): void;
    planningSubWizardStepChanged(step: PlanCampaignSubWizardStep): void;
    moveToPrevWizardStep(): void;
    moveToNextWizardStep(): void;
    resetMainWizardStepsAfterSelectedStep(): void;
    resetGeneralSubWizardStepsAfterSelectedStep(): void;
    updateValidationForSubStep(stepId: SubWizardId, isValid: boolean, isGeneralSection: boolean, isVisited?: boolean): void;
    checkIfAllGeneralMainWizardFormsAreValid(): void;
    checkIfAllPlanningMainWizardFormsAreValid(): void;
    checkIfPlanningFormValid(): void;
    updatePlanningSubStepValidity(id: SubWizardId, isValid: boolean): void;
    patchSubWizardStep(section: "general" | "planning", id: SubWizardId, patch: Partial<PlanCampaignSubWizardStep>): void;
    updateMainWizard(id: MainWizardId, patch: Partial<PlanCampaignMainWizardStep>): void;
    addPrimeTimeAsWizardStep(addStep: boolean): void;
    addSportsAsWizardStep(addStep: boolean): void;
    addSpecialAsWizardStep(addStep: boolean): void;
    private buildAvailsOnlyMainWizard;
    private buildCoreGeneralSubSteps;
    private buildDispersionSubSteps;
    private selectSubWizardStep;
    private validateSubWizardSection;
    private patchSubWizardSteps;
    private syncSelectedSubStep;
    /** Re-resolve the general sub-wizard selection from an updated step list (handles removed steps). */
    private resolveSelectedGeneralSubStepWhenOptionalStepRemoved;
    /**
     * Insert Prime / Sports / Special after the general "Dayparts" step when it exists.
     * If there is no "Dayparts" step (unusual), anchor before "GrpBudget" so optional steps do not
     * splice at index 0. Station Forward Plan Orders never insert these steps — see
     * {@link toggleOptionalProgramStep} — so Primary Info stays immediately before GRP/Budget.
     */
    private getOptionalProgramWizardInsertIndex;
    private resolveOptionalStepInsertIndex;
    private toggleOptionalProgramStep;
    private renumberGeneralSection;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignWizardSection, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignWizardSection>;
}

declare class AfrPlanCampaignContainerComponent implements OnInit, OnDestroy {
    private static readonly PLAN_CAMPAIGN_CONTAINER_LOADER_ID;
    private readonly router;
    private readonly toastr;
    private readonly route;
    private readonly ngxService;
    wizardSvc: PlanCampaignWizardSection;
    draftSvc: PlanCampaignDraftSection;
    state: PlanCampaignStateService;
    navigationSvc: PlanCampaignNavigationSection;
    generalSvc: PlanCampaignGeneralSection;
    availSvc: PlanCampaignAvailsSection;
    saveSvc: PlanCampaignSaveSection;
    execution: PlanCampaignExecutionSection;
    reviewSvc: PlanCampaignReviewSection;
    generalInfoSvc: PlanCampaignGeneralSection;
    planningSvc: PlanCampaignPlanningSection;
    spotSvc: PlanCampaignSpotSection;
    commonSvc: PlanCampaignCommonService;
    config: PlanCampaignConfig;
    annaGlobalConfig: AnnaGlobalConfigService;
    persistingFilterService: AnnaPersistingFilterService;
    breadcrumbsService: BreadcrumbsService;
    modalService: NgbModal;
    destroyRef: DestroyRef;
    private cdr;
    unsavedChangesConfirmationModal: _angular_core.Signal<ConfirmationPopupComponent>;
    expiredDraftConfirmationModal: _angular_core.Signal<ConfirmationPopupComponent>;
    expiredDraftConfirmationConfig: IConfirmationPopupConfig;
    isStationForwardPackageReview: boolean;
    disableStationForwardPackageApprove: boolean;
    packageInitialLoaderActive: boolean;
    readonly planCampaignContainerLoaderId = "plan-campaign-container-loader";
    private readonly defaultReviewMetaData;
    private readonly stationForwardPackageReviewMetaData;
    /** `true` hides the ngx shell loader until `startLoader()` runs (e.g. opening an existing draft). */
    isLoaderStopped: boolean;
    private persistedBreadcrumbs;
    private isStationForwardPlanOrderFlow;
    /**
     * Listing reads `filters` / `quarterFilter` / `stationIds` from the URL. Package deep links carry a
     * `listingPageFilter` hash; expand it the same way as PlanCampaignCommonNavigationService.navigateToListing.
     */
    private getStationForwardsListingQueryParamsForNavigation;
    private isStationForwardPackageContext;
    get stationForwardPackageId(): string;
    private getLinkedPlanIdFromRoute;
    private applyStationForwardPackageReviewLanding;
    private stopPackageInitialLoaderIfActive;
    private storePackageBreadcrumbsFromUrl;
    private setPackageBreadcrumbs;
    get reviewMetaData(): ReviewPlanContainerMetaData;
    get stationForwardCampaignExpiresOn(): string | null;
    get isStationForwardPackageExpired(): boolean;
    onStationForwardPackageApprove(): void;
    get stationForwardApprovedPlanId(): number;
    get shouldShowStationForwardShowPlanButton(): boolean;
    get isStationForwardPackageApproved(): boolean;
    get isStationForwardPackageDataLoaded(): boolean;
    goToStationForwardApprovedPlan(): void;
    goToStationForwardsListing(): void;
    ngOnInit(): void;
    setDraftHelpers(): void;
    stopPlanCampaignContainerLoader(): void;
    showPlanCampaignContainerLoader(): void;
    /**
     * Shows the container ngx-ui-loader overlay only while opening an **existing** draft
     * (positive `draftId`: load draft from the API and bootstrap the wizard).
     * If there is no draft id (new plan, read-only / review-only entry, etc.), this is a no-op;
     * those flows rely on skeleton UI instead of this full-screen loader.
     */
    startLoader(): void;
    startBlockingShellLoader(): void;
    setConfigForExpiredDraftPopup(): void;
    wizardNextBtnClicked(currentStep: PlanCampaignMainWizardStep): void;
    saveProgress(): void;
    wizardStepChanged(step: PlanCampaignMainWizardStep): void;
    cancelClicked(): void;
    openPopup(popupToOpen: PopupToShow): void;
    onGeneralInfoUpdated(event: PlanCampaignGeneralInfoUpdateEvent): void;
    buyerContactFormUpdated(data: {
        currentValues: {
            buyers: BuyerContactDetails[];
        };
        isFormValid: boolean;
    }): void;
    primaryInfoFormChanged(data: {
        currentValues: PrimaryInfoSelectedData;
        isFormValid: boolean;
    }): void;
    marketFormChanged(value: MultiSelectIdText[]): void;
    stationSectionUpdated(data: {
        tableData: MarketWiseStationTableData[];
        isValid: boolean;
    }): void;
    subWizardStepChanged(step: PlanCampaignSubWizardStep): void;
    daypartFormUpdated(data: {
        dayparts: DaypartCategory[];
        isValid: boolean;
    }): void;
    primeTimeFormUpdated(data: {
        primeTime: PrimeTime;
        isValid: boolean;
    }): void;
    specialProgramFormUpdated(data: {
        specialProgram: SpecialProgram[];
        isValid: boolean;
    }): void;
    majorSportsProgramFormUpdated(data: {
        sportsProgram: SportsProgram[];
        isValid: boolean;
    }): void;
    specialitySportsProgramFormUpdated(data: {
        sportsProgram: SportsProgram[];
        isValid: boolean;
    }): void;
    fetchLatestAvails(): void;
    availSectionUpdated(data: {
        tableData: Avails[];
        isValid: boolean;
    }): void;
    createDataForCampaignPlanning(): void;
    emailAvails(comment?: string): void;
    moveToNextWizardStep(): void;
    budgetFormChanged(value: {
        data: SelectedMarketWiseGrpOrBudget;
        isValid: boolean;
    }): void;
    planningSubWizardStepChanged(step: PlanCampaignSubWizardStep): void;
    finalCampaignStationSectionUpdated(data: {
        tableData: MarketWiseStationTableData[];
        isValid: boolean;
    }): void;
    finalCampaignDaypartDispersionSectionUpdated(data: {
        grpByMajorDp: GrpByMajorDp;
        isValid: boolean;
    }): void;
    computeSpotDispersionWeek(dates: HiatusDate[], resetCampaign?: boolean): void;
    monthSpotDispersionUpdated(value: {
        data: HiatusDateMonthSpotDispersion;
        isValid: boolean;
    }): void;
    generalRulesUpdated(event: {
        currentValues: GeneralRulesSelectedData;
        isFormValid: boolean;
    }): void;
    aduRulesUpdated(event: {
        currentValues: AduRulesSelectedData;
        isFormValid: boolean;
    }): void;
    makegoodRulesUpdated(event: {
        currentValues: MakeGoodRulesSelectedData;
        isFormValid: boolean;
    }): void;
    minSeparationUpdated(event: string | null): void;
    updateReviewCampaignData(data: ReviewPlanContainerData): void;
    updateReviewStepButton(disableButton: boolean): void;
    saveProgressAndNavigateToListing(): void;
    navigateToCampaignListing(closeIconClicked: boolean): void;
    navigateExpiredDraftToListing(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignContainerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignContainerComponent, "afr-plan-campaign-container", never, {}, {}, never, never, true, never>;
}

declare class AfrPlanCampaignDateInputComponent implements OnInit {
    calendarMinEnabledDate: NgbDateType;
    calendarMaxEnabledDate: NgbDateType;
    selectedMinDate: NgbDateType;
    selectedMaxDate: NgbDateType;
    selectedLabel: string;
    dateChanged: EventEmitter<any>;
    closeTooltip: EventEmitter<any>;
    isFilterChanged: boolean;
    disableCalendarApplyBtn: boolean;
    calendarSelection: any;
    previousCalendarSelection: any;
    annaDateTimeFormatService: AnnaDateTimeFormatService;
    ngOnInit(): void;
    createInitialData(): void;
    applyDateFilter(): void;
    cancelInDateFilter(): void;
    calendarDateChanged(event: any): void;
    disableCalendarApplyButton(): void;
    checkIfDateTooltipIsFiltered(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignDateInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignDateInputComponent, "afr-plan-campaign-date-input", never, { "calendarMinEnabledDate": { "alias": "calendarMinEnabledDate"; "required": false; }; "calendarMaxEnabledDate": { "alias": "calendarMaxEnabledDate"; "required": false; }; "selectedMinDate": { "alias": "selectedMinDate"; "required": false; }; "selectedMaxDate": { "alias": "selectedMaxDate"; "required": false; }; "selectedLabel": { "alias": "selectedLabel"; "required": false; }; }, { "dateChanged": "dateChanged"; "closeTooltip": "closeTooltip"; }, never, never, true, never>;
}

interface DaypartUpdatedEvent {
    isValid: boolean;
    dayparts: DaypartCategory[];
}
/**
 * Edits daypart selection and dispersion in-place on mutable `DaypartCategory` models
 * owned by the parent; changes are re-emitted via `daypartUpdated`.
 */
declare class AfrPlanCampaignDaypartsComponent implements OnChanges {
    readonly dayparts: _angular_core.InputSignal<DaypartCategory[]>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly timezoneHeader: _angular_core.InputSignal<string[]>;
    readonly showGrpColumn: _angular_core.InputSignal<boolean>;
    readonly daypartUpdated: _angular_core.OutputEmitterRef<DaypartUpdatedEvent>;
    readonly daysDropdownConfig: ICustomMultiSelect;
    readonly messageBoxData: MessageBoxData;
    readonly skeletonHeaders: any[];
    readonly skeletonRows: any[];
    readonly staticSkeletonHeaders: string[];
    readonly skeletonColWidth = "var(--daypart-col-width)";
    readonly selectedDpTimezone: _angular_core.WritableSignal<TimezoneEntry>;
    private readonly daypartsRevision;
    private tooltip;
    private readonly planCampaignDaypartsService;
    private readonly daypartTotals;
    readonly totalImpressions: _angular_core.Signal<number>;
    readonly showTotalError: _angular_core.Signal<boolean>;
    private readonly daypartCounts;
    readonly totalDpCount: _angular_core.Signal<number>;
    readonly totalSelectedDpCount: _angular_core.Signal<number>;
    readonly allRowState: _angular_core.Signal<State>;
    readonly tableHeaders: _angular_core.Signal<_annalib_anna_feature_radiant.StationTableHeaders[]>;
    readonly totalMajorCount: _angular_core.Signal<number>;
    readonly allRowAriaChecked: _angular_core.Signal<"true" | "false" | "mixed">;
    ngOnChanges(changes: SimpleChanges): void;
    selectUnselectDaypartFromCategory(dpCategory: DaypartCategory): void;
    selectUnselectDaypartsFromCategory(): void;
    selectUnselectDaypart(dp: Daypart, dpCategory: DaypartCategory): void;
    daypartPercentChanged(daypart: Daypart, value: Event): void;
    categoryPercentChanged(category: DaypartCategory, value: Event): void;
    daysSelectionChanged(selectedDays: MultiSelectIdText[], dp: Daypart): void;
    bindTheValueToToolTip(timezone: TimezoneEntry, tooltip: NgbTooltip): void;
    openTooltip(tooltip: NgbTooltip, timezone: TimezoneEntry): void;
    closeTooltip(): void;
    onSavingTime(time: {
        startTime: string;
        endTime: string;
    }): void;
    private bumpDaypartsRevision;
    private deriveAllRowState;
    private syncAndEmit;
    private emitDaypartEvent;
    private checkIfDpFormIsValid;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignDaypartsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignDaypartsComponent, "afr-plan-campaign-dayparts", never, { "dayparts": { "alias": "dayparts"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "timezoneHeader": { "alias": "timezoneHeader"; "required": false; "isSignal": true; }; "showGrpColumn": { "alias": "showGrpColumn"; "required": false; "isSignal": true; }; }, { "daypartUpdated": "daypartUpdated"; }, never, never, true, never>;
}

declare class AfrPlanCampaignFinalCampaignPlanningComponent {
    wizardSteps: PlanCampaignSubWizardStep[];
    selectedStep: PlanCampaignSubWizardStep;
    data: FinalCampaignPlanningData;
    selectedData: FinalCampaignPlanningSelectedData;
    loaderForMarket: boolean;
    daypartDispersionRows: DaypartCategory[];
    daypartTimezoneHeaders: string[];
    budgetFormUpdated: EventEmitter<any>;
    stationTableUpdated: EventEmitter<any>;
    daypartTableUpdated: EventEmitter<{
        grpByMajorDp: GrpByMajorDp;
        isValid: boolean;
    }>;
    subWizardStepUpdated: EventEmitter<any>;
    hiatusDatesUpdated: EventEmitter<any>;
    spotDispersionUpdated: EventEmitter<any>;
    generalRulesUpdated: EventEmitter<any>;
    makeGoodRulesUpdated: EventEmitter<any>;
    aduRulesUpdated: EventEmitter<any>;
    minSeparationUpdated: EventEmitter<any>;
    budgetFormChanged(value: {
        data: SelectedMarketWiseGrpOrBudget;
        isValid: boolean;
    }): void;
    stationSectionUpdated(data: {
        tableData: MarketWiseStationTableData[];
        isValid: boolean;
    }): void;
    wizardStepChanged(step: PlanCampaignSubWizardStep): void;
    daypartFormUpdated(data: {
        dayparts: DaypartCategory[];
        isValid: boolean;
    }): void;
    computeSpotDispersionWeek(dates: HiatusDate[]): void;
    weekSpotDispersionUpdated(value: {
        data: HiatusDateMonthSpotDispersion;
        isValid: boolean;
    }): void;
    generalFormRulesUpdated(event: {
        currentValues: GeneralRulesSelectedData;
        isFormValid: boolean;
    }): void;
    makegoodFormRulesUpdated(event: {
        currentValues: MakeGoodRulesSelectedData;
        isFormValid: boolean;
    }): void;
    aduFormRulesUpdated(event: {
        currentValues: AduRulesSelectedData;
        isFormValid: boolean;
    }): void;
    minSeparationInputUpdated(event: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignFinalCampaignPlanningComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignFinalCampaignPlanningComponent, "afr-plan-campaign-final-campaign-planning", never, { "wizardSteps": { "alias": "wizardSteps"; "required": false; }; "selectedStep": { "alias": "selectedStep"; "required": false; }; "data": { "alias": "data"; "required": false; }; "selectedData": { "alias": "selectedData"; "required": false; }; "loaderForMarket": { "alias": "loaderForMarket"; "required": false; }; "daypartDispersionRows": { "alias": "daypartDispersionRows"; "required": false; }; "daypartTimezoneHeaders": { "alias": "daypartTimezoneHeaders"; "required": false; }; }, { "budgetFormUpdated": "budgetFormUpdated"; "stationTableUpdated": "stationTableUpdated"; "daypartTableUpdated": "daypartTableUpdated"; "subWizardStepUpdated": "subWizardStepUpdated"; "hiatusDatesUpdated": "hiatusDatesUpdated"; "spotDispersionUpdated": "spotDispersionUpdated"; "generalRulesUpdated": "generalRulesUpdated"; "makeGoodRulesUpdated": "makeGoodRulesUpdated"; "aduRulesUpdated": "aduRulesUpdated"; "minSeparationUpdated": "minSeparationUpdated"; }, never, never, true, never>;
}

declare class AfrPlanCampaignGeneralInfoComponent {
    readonly wizardSteps: _angular_core.InputSignal<PlanCampaignSubWizardStep[]>;
    readonly selectedStep: _angular_core.InputSignal<PlanCampaignSubWizardStep>;
    readonly data: _angular_core.InputSignal<GeneralInfoData>;
    readonly selectedData: _angular_core.InputSignal<GeneralInfoSelectedData>;
    readonly planningData: _angular_core.InputSignal<FinalCampaignPlanningData>;
    readonly selectedPlanningData: _angular_core.InputSignal<FinalCampaignPlanningSelectedData>;
    readonly loaders: _angular_core.InputSignal<CampaignLoaderVM>;
    readonly daypartDispersionRows: _angular_core.InputSignal<DaypartCategory[]>;
    readonly generalInfoUpdated: _angular_core.OutputEmitterRef<PlanCampaignGeneralInfoUpdateEvent>;
    readonly config: PlanCampaignConfig;
    buyerContactChanged(data: BuyerContactFormChangeEvent): void;
    primaryInfoFormChanged(data: PrimaryInfoFormChangeEvent): void;
    wizardStepChanged(step: PlanCampaignSubWizardStep): void;
    marketFormChanged(value: MultiSelectIdText[]): void;
    stationSectionUpdated(data: {
        tableData: MarketWiseStationTableData[];
        isValid: boolean;
    }): void;
    daypartFormUpdated(data: {
        dayparts: DaypartCategory[];
        isValid: boolean;
    }): void;
    primeTimeFormUpdated(data: {
        primeTime: PrimeTime;
        isValid: boolean;
    }): void;
    majorSportsProgramFormUpdated(data: {
        sportsProgram: SportsProgram[];
        isValid: boolean;
    }): void;
    specialitySportsProgramFormUpdated(data: {
        sportsProgram: SportsProgram[];
        isValid: boolean;
    }): void;
    specialProgramFormUpdated(data: {
        specialProgram: SpecialProgram[];
        isValid: boolean;
    }): void;
    budgetFormChanged(value: {
        data: SelectedMarketWiseGrpOrBudget;
        isValid: boolean;
    }): void;
    planningStationSectionUpdated(data: {
        tableData: MarketWiseStationTableData[];
        isValid: boolean;
    }): void;
    planningDaypartFormUpdated(data: {
        dayparts: DaypartCategory[];
        isValid: boolean;
    }): void;
    computeSpotDispersionWeek(dates: HiatusDate[]): void;
    weekSpotDispersionUpdated(value: {
        data: HiatusDateMonthSpotDispersion;
        isValid: boolean;
    }): void;
    generalFormRulesUpdated(event: {
        currentValues: GeneralRulesSelectedData;
        isFormValid: boolean;
    }): void;
    makegoodFormRulesUpdated(event: {
        currentValues: MakeGoodRulesSelectedData;
        isFormValid: boolean;
    }): void;
    aduFormRulesUpdated(event: {
        currentValues: AduRulesSelectedData;
        isFormValid: boolean;
    }): void;
    minSeparationInputUpdated(event: string | null): void;
    private emitUpdate;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignGeneralInfoComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignGeneralInfoComponent, "afr-plan-campaign-general-info", never, { "wizardSteps": { "alias": "wizardSteps"; "required": true; "isSignal": true; }; "selectedStep": { "alias": "selectedStep"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": true; "isSignal": true; }; "selectedData": { "alias": "selectedData"; "required": true; "isSignal": true; }; "planningData": { "alias": "planningData"; "required": true; "isSignal": true; }; "selectedPlanningData": { "alias": "selectedPlanningData"; "required": true; "isSignal": true; }; "loaders": { "alias": "loaders"; "required": true; "isSignal": true; }; "daypartDispersionRows": { "alias": "daypartDispersionRows"; "required": false; "isSignal": true; }; }, { "generalInfoUpdated": "generalInfoUpdated"; }, never, never, true, never>;
}

interface GeneralRulesFormChangeEvent {
    currentValues: GeneralRulesSelectedData;
    isFormValid: boolean;
}
type GeneralRulesFormControls = {
    maxSpotsStripPerHalfHrDaily: FormControl<number | null>;
    maxSpotsStripPerHalfHrWeekly: FormControl<number | null>;
    maxSpotsStripPerHalfHrToOneHrDaily: FormControl<number | null>;
    maxSpotsStripPerHalfHrToOneHrWeekly: FormControl<number | null>;
    maxSpotsStripPerOneHrToTwoHrDaily: FormControl<number | null>;
    maxSpotsStripPerOneHrToTwoHrWeekly: FormControl<number | null>;
    maxSpotsStripPerTwoHrPlusDaily: FormControl<number | null>;
    maxSpotsStripPerTwoHrPlusWeekly: FormControl<number | null>;
    maxSpotsOtoPerHalfHrDaily: FormControl<number | null>;
    maxSpotsOtoPerHalfHrToOneHrDaily: FormControl<number | null>;
    maxSpotsOtoPerOneHrToTwoHrDaily: FormControl<number | null>;
    maxSpotsOtoPerTwoHrPlusDaily: FormControl<number | null>;
};
declare class AfrPlanCampaignGeneralRulesComponent {
    readonly selectedData: _angular_core.InputSignal<GeneralRulesSelectedData>;
    readonly formValueChanged: _angular_core.OutputEmitterRef<GeneralRulesFormChangeEvent>;
    generalRulesForm: FormGroup<GeneralRulesFormControls>;
    readonly minValue = 1;
    readonly maxValue = 100;
    private readonly destroyRef;
    private readonly fb;
    private formSubscription?;
    private lastSelectedData?;
    constructor();
    control(name: keyof GeneralRulesFormControls | string): FormControl<number | null>;
    stripTimeContainerDecreaseGap(): boolean;
    createFormGroup(): void;
    private emitFormState;
    dailyNotGreaterThanWeeklyValidator(group: AbstractControl): ValidationErrors | null;
    onMaxSpotsAllowedPerHalfAnHourDailyInStripChanged(event: Event): void;
    onMaxSpotsAllowedPerHalfAnHourWeeklyInStripChanged(event: Event): void;
    onMaxSpotsAllowedPerHalfAnHourDailyInOtoChanged(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignGeneralRulesComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignGeneralRulesComponent, "afr-plan-campaign-general-rules", never, { "selectedData": { "alias": "selectedData"; "required": true; "isSignal": true; }; }, { "formValueChanged": "formValueChanged"; }, never, never, true, never>;
}

declare class AfrPlanCampaignMainWizardComponent implements OnChanges {
    steps: PlanCampaignMainWizardStep[];
    currentStep: PlanCampaignMainWizardStep;
    progress: number;
    markAllBtnAsDisabled: boolean;
    campaignExpiresOn: string;
    flowType: CampaignFlow;
    disableSaveProgressBtn: boolean;
    stepChanged: EventEmitter<any>;
    nextBtnClicked: EventEmitter<any>;
    navigateBackToListingPage: EventEmitter<any>;
    openPopup: EventEmitter<any>;
    saveDraft: EventEmitter<any>;
    campaignExpiresOnDate: string;
    campaignExpiresAt: string;
    ngOnChanges(changes: SimpleChanges): void;
    updateCampaignExpiresOn(): void;
    goToStep(step: PlanCampaignMainWizardStep): void;
    nextStep(): void;
    prevStep(): void;
    getStepIndexById(id: MainWizardId): number;
    cancel(): void;
    saveProgress(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignMainWizardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignMainWizardComponent, "afr-plan-campaign-main-wizard", never, { "steps": { "alias": "steps"; "required": false; }; "currentStep": { "alias": "currentStep"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; "markAllBtnAsDisabled": { "alias": "markAllBtnAsDisabled"; "required": false; }; "campaignExpiresOn": { "alias": "campaignExpiresOn"; "required": false; }; "flowType": { "alias": "flowType"; "required": false; }; "disableSaveProgressBtn": { "alias": "disableSaveProgressBtn"; "required": false; }; }, { "stepChanged": "stepChanged"; "nextBtnClicked": "nextBtnClicked"; "navigateBackToListingPage": "navigateBackToListingPage"; "openPopup": "openPopup"; "saveDraft": "saveDraft"; }, never, ["*"], true, never>;
}

interface MakeGoodRulesFormChangeEvent {
    currentValues: MakeGoodRulesSelectedData;
    isFormValid: boolean;
}
type MakeGoodRulesFormControls = {
    allowedInventory: FormControl<SingleSelectIdText | null>;
    timeWindow: FormControl<SingleSelectIdText | null>;
    allowWeekdaysOnWeekends: FormControl<boolean | null>;
    allowWeekendsOnWeekdays: FormControl<boolean | null>;
    allowSportsPermittedAlternative: FormControl<boolean | null>;
    sports: FormControl<SingleSelectIdText | null>;
    primeTime: FormControl<SingleSelectIdText | null>;
    programThresholdAllowed: FormControl<boolean | null>;
};
declare class AfrPlanCampaignMakeGoodRulesComponent implements OnChanges {
    readonly makegoodRules: _angular_core.InputSignal<MakegoodRules>;
    readonly makegoodRulesSelectedData: _angular_core.InputSignal<MakeGoodRulesSelectedData>;
    readonly formValueChanged: _angular_core.OutputEmitterRef<MakeGoodRulesFormChangeEvent>;
    makegoodRulesForm: FormGroup<MakeGoodRulesFormControls>;
    private readonly annaGlobalConfigService;
    private readonly destroyRef;
    private readonly fb;
    private formSubscription?;
    readonly timeWindowConfig: ICustomSingleSelect;
    readonly allowedInventoryConfig: ICustomSingleSelect;
    readonly makegoodForSportsConfig: ICustomSingleSelect;
    readonly makegoodForPrimeTimeConfig: ICustomSingleSelect;
    ngOnChanges(changes: SimpleChanges): void;
    createFormGroup(): void;
    private syncSportsFieldValidators;
    private createSelectConfig;
    private emitFormState;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignMakeGoodRulesComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignMakeGoodRulesComponent, "afr-plan-campaign-make-good-rules", never, { "makegoodRules": { "alias": "makegoodRules"; "required": false; "isSignal": true; }; "makegoodRulesSelectedData": { "alias": "makegoodRulesSelectedData"; "required": true; "isSignal": true; }; }, { "formValueChanged": "formValueChanged"; }, never, never, true, never>;
}

declare class AfrPlanCampaignMarketComponent implements OnInit, OnChanges, OnDestroy {
    readonly marketWithStationsResponse: _angular_core.InputSignal<MarketInfoWithStationData>;
    readonly markets: _angular_core.InputSignal<MultiSelectIdText[]>;
    readonly marketDropdownChanged: _angular_core.OutputEmitterRef<MultiSelectIdText[]>;
    readonly marketDropdownConfig: ICustomMultiSelect;
    readonly replaceDMASpecialCharacter: RegExp;
    readonly legends: MarketLegend[];
    private readonly MIN_HEIGHT;
    private readonly HEIGHT_OFFSET;
    private readonly SVG_HEIGHT_PADDING;
    private readonly SHIFT_LEFT;
    private readonly RESIZE_DEBOUNCE_MS;
    private readonly el;
    private readonly cdr;
    private readonly marketMapContainer;
    private readonly mapTooltipRef;
    private mapRendered;
    private hasEmittedInitialSelection;
    private resizeListener;
    private resizeTimeoutId;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    onDropdownClosed(items: MultiSelectIdText[]): void;
    getTooltipContent(properties: MarketListResponse["properties"]): string;
    private setupResizeListener;
    private removeResizeListener;
    private calculateDimensions;
    private createDmaData;
    private createProjection;
    private createGraticule;
    private setupSvgBackground;
    private createMapPaths;
    private applyMapRegionAccessibility;
    private getMapRegionAriaLabel;
    private showMapTooltip;
    private moveMapTooltip;
    private hideMapTooltip;
    private renderUsaMap;
    private recalculateMapSize;
    private selectEligibleDMAs;
    private syncMapColorsFromMarkets;
    private setMapRegionFill;
    private updateMapRegionAriaLabels;
    private getMapRegionId;
    private isAlaskaRegion;
    private emitSelectedMarkets;
    private getMapTooltipSelection;
    private escapeHtml;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignMarketComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignMarketComponent, "afr-plan-campaign-market", never, { "marketWithStationsResponse": { "alias": "marketWithStationsResponse"; "required": true; "isSignal": true; }; "markets": { "alias": "markets"; "required": true; "isSignal": true; }; }, { "marketDropdownChanged": "marketDropdownChanged"; }, never, never, true, never>;
}

type PrimaryInfoFormControls = {
    advertiser: FormControl<SingleSelectIdText | null>;
    agency: FormControl<SingleSelectIdText | null | undefined>;
    campaignName: FormControl<string | null>;
    buyerEstimate: FormControl<string | null>;
    startDate: FormControl<NgbDate | null>;
    endDate: FormControl<NgbDate | null>;
    postingType: FormControl<SingleSelectIdText | null>;
    demo: FormControl<SingleSelectIdText | null>;
    spotDurations: FormControl<SingleSelectIdText | null>;
    productCode: FormControl<SingleSelectIdText | null>;
    productDesc: FormControl<string | null>;
};
declare class AfrPlanCampaignPrimaryInfoComponent implements OnChanges {
    private static readonly FORM_VALUE_CHANGE_DEBOUNCE_MS;
    readonly dropdownData: _angular_core.InputSignal<PrimaryInfoDropdowns>;
    readonly selectedData: _angular_core.InputSignal<PrimaryInfoSelectedData>;
    readonly isStartDateInPast: _angular_core.InputSignal<boolean>;
    readonly loadingApiData: _angular_core.InputSignal<boolean>;
    readonly loadingAgencyList: _angular_core.InputSignal<boolean>;
    readonly formValueChanged: _angular_core.OutputEmitterRef<PrimaryInfoFormChangeEvent>;
    primaryInfoForm: FormGroup<PrimaryInfoFormControls>;
    readonly showEndDateError: _angular_core.WritableSignal<boolean>;
    private readonly startDatePastCleared;
    private readonly selectedStartDate;
    readonly minDate: NgbDate;
    readonly maxDate: NgbDate;
    readonly advertiserConfig: ICustomSingleSelect;
    readonly agencyConfig: ICustomSingleSelect;
    readonly postingTypeConfig: ICustomSingleSelect;
    readonly demoConfig: ICustomSingleSelect;
    readonly spotDurationConfig: ICustomSingleSelect;
    readonly productCodeConfig: ICustomSingleSelect;
    readonly primaryInfoConfig: _angular_core.Signal<PlanCampaignPrimaryInfoConfig>;
    readonly showSecondDropdownRow: _angular_core.Signal<boolean>;
    readonly skeletonLoaderRows: _angular_core.Signal<any[]>;
    readonly showStartDatePastError: _angular_core.Signal<boolean>;
    readonly isStationForwardPlanOrderFlow: _angular_core.Signal<boolean>;
    readonly startDateMinDate: _angular_core.Signal<NgbDate>;
    readonly startDateMaxDate: _angular_core.Signal<NgbDate>;
    readonly endDateMaxDate: _angular_core.Signal<NgbDate>;
    readonly endDateMinDate: _angular_core.Signal<NgbDate>;
    readonly isAgencyDropdownDisabled: _angular_core.Signal<boolean>;
    private readonly destroyRef;
    private readonly fb;
    private readonly annaGlobalConfigService;
    private readonly config;
    readonly planCampaignState: PlanCampaignStateService;
    private readonly startDatePastValidator;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    private syncFormWithSelectedData;
    private createPrimaryInfoForm;
    private patchPrimaryInfoForm;
    private bindFormSubscriptions;
    private syncStartDatePastState;
    private emitPrimaryInfoFormState;
    private stationForwardMaxDate;
    private createSingleSelectConfig;
    private parseFlightDate;
    private static createDateBounds;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignPrimaryInfoComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignPrimaryInfoComponent, "afr-plan-campaign-primary-info", never, { "dropdownData": { "alias": "dropdownData"; "required": false; "isSignal": true; }; "selectedData": { "alias": "selectedData"; "required": false; "isSignal": true; }; "isStartDateInPast": { "alias": "isStartDateInPast"; "required": false; "isSignal": true; }; "loadingApiData": { "alias": "loadingApiData"; "required": false; "isSignal": true; }; "loadingAgencyList": { "alias": "loadingAgencyList"; "required": false; "isSignal": true; }; }, { "formValueChanged": "formValueChanged"; }, never, never, true, never>;
}

interface PrimeTimeUpdatedEvent {
    isValid: boolean;
    primeTime: PrimeTime;
}
/**
 * Edits prime-time program selection in-place on the mutable `PrimeTime` model
 * owned by the parent; changes are re-emitted via `primeTimeUpdated`.
 */
declare class AfrPlanCampaignPrimeTimeComponent implements OnChanges {
    readonly data: _angular_core.InputSignal<PrimeTime>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly primeTimeUpdated: _angular_core.OutputEmitterRef<PrimeTimeUpdatedEvent>;
    readonly skeletonHeaders: any[];
    readonly skeletonRows: any[];
    readonly noDataWidth = "var(--prime-time-no-data-width)";
    readonly noDataMarginTop = "var(--prime-time-no-data-margin-top)";
    private readonly selectionRevision;
    private readonly planCampaignPrimeTimeService;
    readonly affiliates: _angular_core.Signal<string[]>;
    private readonly counts;
    readonly totalCount: _angular_core.Signal<number>;
    readonly selectedCount: _angular_core.Signal<number>;
    readonly allRowState: _angular_core.Signal<_annalib_anna_feature_radiant.State>;
    ngOnChanges(changes: SimpleChanges): void;
    selectUnselectAllDays(): void;
    selectUnselectDay(day: DayProgram): void;
    selectUnselectTimeSlot(time: TimeSlotGroup, day: DayProgram): void;
    selectUnselectPrimeProgramCheckbox(): void;
    selectUnselectProgram(affiliate: AffiliateProgram, time: TimeSlotGroup, day: DayProgram): void;
    private bumpSelectionRevision;
    private syncAndEmit;
    private emitEvent;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignPrimeTimeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignPrimeTimeComponent, "afr-plan-campaign-prime-time", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "primeTimeUpdated": "primeTimeUpdated"; }, never, never, true, never>;
}

interface SpecialSelectionChangedEvent {
    specialProgram: SpecialProgram[];
    isValid: boolean;
}
/**
 * Special Programming GT step: mutates row objects in place on shared clone refs;
 * emits `specialSelectionChanged` for parent validation.
 */
declare class AfrPlanCampaignSpecialProgramComponent implements OnChanges, OnInit, OnDestroy {
    readonly specialPrograms: _angular_core.InputSignal<SpecialProgram[]>;
    readonly clonedSpecialPrograms: _angular_core.InputSignal<SpecialProgram[]>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly specialSelectionChanged: _angular_core.OutputEmitterRef<SpecialSelectionChangedEvent>;
    readonly displayedPrograms: _angular_core.WritableSignal<SpecialProgram[]>;
    readonly gtDimension: {
        rowHeight: number;
        headerHeight: number;
        dataOnTopHeight: number;
        marginFromBottom: number;
    };
    private readonly annaGlobalConfig;
    private readonly annaFilterService;
    private readonly annaGtHelperService;
    private readonly annaSortService;
    private readonly specialProgramService;
    readonly tableHeaders: IGtTableHeader[];
    gtGeneralConfig: IGtGeneralConfig;
    private readonly specialRevision;
    private readonly resetButtonRevision;
    readonly selectedCount: _angular_core.Signal<number>;
    readonly totalCount: _angular_core.Signal<number>;
    private readonly totalRowBundle;
    readonly totalRowInfo: _angular_core.Signal<_annalib_anna_core.ITotalRowInfo[]>;
    readonly totalRowState: _angular_core.Signal<_annalib_anna_feature_radiant.State>;
    readonly disableResetAllBtn: _angular_core.Signal<boolean>;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    sortingAppliedToTable(tableData: SpecialProgram[]): void;
    resetAllFilter(): void;
    filterAppliedToTable(tableData: SpecialProgram[]): void;
    initResetFilterVar(): void;
    selectUnselectLine(data: {
        rowData: SpecialProgram;
        columnKeys: string;
        isCheckboxSelected: boolean;
    }): void;
    emitEvent(): void;
    totalRowIconClicked(_colName: string): void;
    ngOnDestroy(): void;
    private bumpSpecialRevision;
    private bumpResetButtonRevision;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignSpecialProgramComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignSpecialProgramComponent, "afr-plan-campaign-special-program", never, { "specialPrograms": { "alias": "specialPrograms"; "required": false; "isSignal": true; }; "clonedSpecialPrograms": { "alias": "clonedSpecialPrograms"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "specialSelectionChanged": "specialSelectionChanged"; }, never, never, true, never>;
}

interface SportsSelectionChangedEvent {
    sportsProgram: SportsProgram[];
    isValid: boolean;
}
/**
 * Sports Programming GT step: mutates row objects in place on shared clone refs;
 * emits `sportsSelectionChanged` for parent validation.
 */
declare class AfrPlanCampaignSportsProgramComponent implements OnChanges, OnInit, OnDestroy {
    readonly sportsPrograms: _angular_core.InputSignal<SportsProgram[]>;
    readonly clonedSportsPrograms: _angular_core.InputSignal<SportsProgram[]>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly sportsSelectionChanged: _angular_core.OutputEmitterRef<SportsSelectionChangedEvent>;
    readonly displayedPrograms: _angular_core.WritableSignal<SportsProgram[]>;
    readonly gtDimension: {
        rowHeight: number;
        headerHeight: number;
        dataOnTopHeight: number;
        marginFromBottom: number;
    };
    private readonly annaGlobalConfig;
    private readonly annaFilterService;
    private readonly annaGtHelperService;
    private readonly annaSortService;
    private readonly sportsProgramService;
    readonly tableHeaders: IGtTableHeader[];
    gtGeneralConfig: IGtGeneralConfig;
    private readonly sportsRevision;
    private readonly resetButtonRevision;
    readonly selectedCount: _angular_core.Signal<number>;
    readonly totalCount: _angular_core.Signal<number>;
    private readonly totalRowBundle;
    readonly totalRowInfo: _angular_core.Signal<_annalib_anna_core.ITotalRowInfo[]>;
    readonly totalRowState: _angular_core.Signal<_annalib_anna_feature_radiant.State>;
    readonly disableResetAllBtn: _angular_core.Signal<boolean>;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    sortingAppliedToTable(tableData: SportsProgram[]): void;
    resetAllFilter(): void;
    filterAppliedToTable(tableData: SportsProgram[]): void;
    initResetFilterVar(): void;
    selectUnselectLine(data: {
        rowData: SportsProgram;
        columnKeys: string;
        isCheckboxSelected: boolean;
    }): void;
    emitEvent(): void;
    totalRowIconClicked(_colName: string): void;
    ngOnDestroy(): void;
    private bumpSportsRevision;
    private bumpResetButtonRevision;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignSportsProgramComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignSportsProgramComponent, "afr-plan-campaign-sports-program", never, { "sportsPrograms": { "alias": "sportsPrograms"; "required": false; "isSignal": true; }; "clonedSportsPrograms": { "alias": "clonedSportsPrograms"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "sportsSelectionChanged": "sportsSelectionChanged"; }, never, never, true, never>;
}

type StationChangedEvent = {
    isValid: boolean;
    tableData: MarketWiseStationTableData[];
};
declare class AfrPlanCampaignStationsComponent implements OnChanges {
    readonly tableData: _angular_core.InputSignal<MarketWiseStationTableData[]>;
    readonly showMinMarketShareCol: _angular_core.InputSignal<boolean>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly stationChanged: _angular_core.OutputEmitterRef<StationChangedEvent>;
    readonly skeletonHeaders: any[];
    readonly skeletonRows: any[];
    private readonly affiliateStateVersion;
    private readonly annaGlobalConfig;
    private readonly planCampaignStationService;
    readonly measurementConfig: ICustomSingleSelect;
    readonly tableHeaders: _angular_core.Signal<_annalib_anna_feature_radiant.StationTableHeaders[]>;
    readonly affiliates: _angular_core.Signal<Affiliates[]>;
    ngOnChanges(changes: SimpleChanges): void;
    uncheckCheckAllAffliate(affiliate: Affiliates): void;
    uncheckCheckTableStation(station: StationTableData): void;
    stationShareChanged(station: StationTableData, value: Event): void;
    measurementAgencyChanged(station: StationTableData, measurementAgency: SingleSelectIdText): void;
    getShareErrorTooltip(error: StationTableData["error"]): string;
    private refreshAffiliateState;
    private buildAffiliates;
    private emitStationEvent;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignStationsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignStationsComponent, "afr-plan-campaign-stations", never, { "tableData": { "alias": "tableData"; "required": true; "isSignal": true; }; "showMinMarketShareCol": { "alias": "showMinMarketShareCol"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "stationChanged": "stationChanged"; }, never, never, true, never>;
}

declare class AfrPlanCampaignSubWizardComponent implements OnChanges {
    steps: PlanCampaignSubWizardStep[];
    currentStep: PlanCampaignSubWizardStep;
    stepChanged: EventEmitter<any>;
    ngOnChanges(changes: SimpleChanges): void;
    private applyIsAllowedToNavigateOnSteps;
    goToStep(step: PlanCampaignSubWizardStep): void;
    nextStep(): void;
    prevStep(): void;
    getStepIndexById(id: SubWizardId): number;
    tryGoToStep(step: PlanCampaignSubWizardStep): void;
    get usePlainLayoutForPrimaryInfo(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignSubWizardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignSubWizardComponent, "afr-plan-campaign-sub-wizard", never, { "steps": { "alias": "steps"; "required": false; }; "currentStep": { "alias": "currentStep"; "required": false; }; }, { "stepChanged": "stepChanged"; }, never, ["*"], true, never>;
}

declare class AfrPlanCampaignWeekSpotDispersionComponent implements OnChanges {
    readonly hiatusDateMonthWiseData: _angular_core.InputSignal<HiatusDateMonthSpotDispersion>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly calendarMinEnabledDate: _angular_core.InputSignal<NgbDateType>;
    readonly calendarMaxEnabledDate: _angular_core.InputSignal<NgbDateType>;
    readonly generalRulesSelectedData: _angular_core.InputSignal<GeneralRulesSelectedData>;
    readonly makeGoodRulesSelectedData: _angular_core.InputSignal<MakeGoodRulesSelectedData>;
    readonly makegoodRules: _angular_core.InputSignal<MakegoodRules>;
    readonly aduRulesSelectedData: _angular_core.InputSignal<AduRulesSelectedData>;
    readonly aduRules: _angular_core.InputSignal<AduRules>;
    readonly minSeparationTime: _angular_core.InputSignal<string>;
    readonly hiatusDatesUpdated: _angular_core.OutputEmitterRef<HiatusDate[]>;
    readonly spotDispersionUpdated: _angular_core.OutputEmitterRef<{
        data: HiatusDateMonthSpotDispersion;
        isValid: boolean;
    }>;
    readonly aduRulesUpdated: _angular_core.OutputEmitterRef<{
        currentValues: AduRulesSelectedData;
        isFormValid: boolean;
    }>;
    readonly generalRulesUpdated: _angular_core.OutputEmitterRef<{
        currentValues: GeneralRulesSelectedData;
        isFormValid: boolean;
    }>;
    readonly makegoodRulesUpdated: _angular_core.OutputEmitterRef<{
        currentValues: MakeGoodRulesSelectedData;
        isFormValid: boolean;
    }>;
    readonly minSeparationUpdated: _angular_core.OutputEmitterRef<string>;
    private hiatusWindowPopup;
    private timepickerRef?;
    hiatusWindowPopupReference?: NgbModalRef;
    readonly hiatusPopupOptions: NgbModalOptions;
    readonly hiatusDateInputText: _angular_core.WritableSignal<string>;
    readonly showMinSeparationError: _angular_core.WritableSignal<boolean>;
    readonly minSeparationTimeForComponent: _angular_core.WritableSignal<TimeInput>;
    readonly loaderArr: any[];
    private readonly localDispersionOverride;
    readonly activeDispersionData: _angular_core.Signal<HiatusDateMonthSpotDispersion>;
    private readonly monthDispersionSumRaw;
    readonly monthDispersionSum: _angular_core.Signal<number>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly messageBoxData: MessageBoxData;
    private readonly modalService;
    private readonly planCampaignSpotDispersionService;
    ngOnChanges(changes: SimpleChanges): void;
    convertToTimeObject(time: string): TimeInput | null;
    getFormattedHiatusDatesArr(startEndDateArr: HiatusDate[]): string[];
    openHiatusDatePopup(): void;
    closeHiatusDatePopup(): void;
    updateHiatusDateInputText(event: string): void;
    saveHiatusDates(hiatusDatePopupObj: {
        hiatusDates: HiatusDate[];
        sellerComments?: string | null;
        hiatusInputText?: string;
    }): void;
    monthValueChanged(month: MonthWiseHiatusDateData, value: Event): void;
    updateOrderMinSeparation(time: {
        hour: number;
        minute: number;
        second: number;
    } | null): void;
    getStringValueOfOrderMinSeparation(time: {
        hour: number;
        minute: number;
        second: number;
    }): string;
    addZeroToTimeValue(value: number, addColon: boolean): string;
    focusOnHourValue(): void;
    generalRulesFormUpdated(event: {
        currentValues: GeneralRulesSelectedData;
        isFormValid: boolean;
    }): void;
    makegoodRulesFormUpdated(event: {
        currentValues: MakeGoodRulesSelectedData;
        isFormValid: boolean;
    }): void;
    aduRulesFormUpdated(event: {
        currentValues: AduRulesSelectedData;
        isFormValid: boolean;
    }): void;
    private syncMinSeparationFromInput;
    private buildUpdatedDispersion;
    private getIsDispersionValid;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlanCampaignWeekSpotDispersionComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlanCampaignWeekSpotDispersionComponent, "afr-plan-campaign-week-spot-dispersion", never, { "hiatusDateMonthWiseData": { "alias": "hiatusDateMonthWiseData"; "required": true; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "calendarMinEnabledDate": { "alias": "calendarMinEnabledDate"; "required": false; "isSignal": true; }; "calendarMaxEnabledDate": { "alias": "calendarMaxEnabledDate"; "required": false; "isSignal": true; }; "generalRulesSelectedData": { "alias": "generalRulesSelectedData"; "required": false; "isSignal": true; }; "makeGoodRulesSelectedData": { "alias": "makeGoodRulesSelectedData"; "required": false; "isSignal": true; }; "makegoodRules": { "alias": "makegoodRules"; "required": false; "isSignal": true; }; "aduRulesSelectedData": { "alias": "aduRulesSelectedData"; "required": false; "isSignal": true; }; "aduRules": { "alias": "aduRules"; "required": false; "isSignal": true; }; "minSeparationTime": { "alias": "minSeparationTime"; "required": false; "isSignal": true; }; }, { "hiatusDatesUpdated": "hiatusDatesUpdated"; "spotDispersionUpdated": "spotDispersionUpdated"; "aduRulesUpdated": "aduRulesUpdated"; "generalRulesUpdated": "generalRulesUpdated"; "makegoodRulesUpdated": "makegoodRulesUpdated"; "minSeparationUpdated": "minSeparationUpdated"; }, never, never, true, never>;
}

interface LegendDaypartAllocation extends DaypartWiseSplit {
    legendColorCode: string;
}
declare class AfrPlannedCampaignDaypartAllocationComponent implements OnChanges, OnInit {
    showChart: boolean;
    daypartAllocation: DaypartWiseSplit[];
    loading: boolean;
    showNoData: boolean;
    showDesiredImps: boolean;
    showOriginalCurrentTable: boolean;
    isImpsMetric: boolean;
    bookedDemo: string;
    tableHeaders: IGtTableHeader[];
    clonedDaypartAllocation: DaypartWiseSplit[];
    gtDimension: {
        rowHeight: number;
        headerHeight: number;
        dataOnTopHeight: number;
        marginFromBottom: number;
    };
    gtGeneralConfig: IGtGeneralConfig;
    colorCodesArr: string[];
    daypartAllocationDoughnutChartData: any;
    daypartAllocationDoughnutChartOptions: any;
    legendDaypartAllocation: LegendDaypartAllocation[];
    private annaGlobalConfig;
    private tableDispersionSvc;
    private utilitySvc;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    createTableHeaders(): void;
    setGtGeneralConfig(): void;
    createDaypartAllocationDougnutChartData(): void;
    createLegendDaypartAllocation(): void;
    getImpsRtgPercentage(item: DaypartWiseSplit): number;
    getImpsRtg(item: DaypartWiseSplit): string;
    getCpmCpp(item: DaypartWiseSplit): string;
    removeTableHeaders(): IGtTableHeader[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlannedCampaignDaypartAllocationComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlannedCampaignDaypartAllocationComponent, "afr-planned-campaign-daypart-allocation", never, { "showChart": { "alias": "showChart"; "required": false; }; "daypartAllocation": { "alias": "daypartAllocation"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "showNoData": { "alias": "showNoData"; "required": false; }; "showDesiredImps": { "alias": "showDesiredImps"; "required": false; }; "showOriginalCurrentTable": { "alias": "showOriginalCurrentTable"; "required": false; }; "isImpsMetric": { "alias": "isImpsMetric"; "required": false; }; "bookedDemo": { "alias": "bookedDemo"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AfrPlannedCampaignMarketSplitComponent implements OnChanges, OnInit {
    showChart: boolean;
    marketSplit: MarketWiseSplit[];
    loading: boolean;
    showNoData: boolean;
    showOriginalCurrentTable: boolean;
    showHeadersForBudget: boolean;
    isImpsMetric: boolean;
    bookedDemo: string;
    chartType: keyof ChartTypeRegistry;
    stackChartOption: any;
    marketSplitChartData: any;
    loadingTableData: boolean;
    tableHeaders: IGtTableHeader[];
    clonedMarketSplit: MarketWiseSplit[];
    gtDimension: {
        rowHeight: number;
        headerHeight: number;
        dataOnTopHeight: number;
        marginFromBottom: number;
    };
    gtGeneralConfig: IGtGeneralConfig;
    colorCodesArr: string[];
    private annaGlobalConfig;
    private utilitySvc;
    private tableDispersionSvc;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    createTableHeaders(): void;
    removeTableHeaders(): IGtTableHeader[];
    setGtGeneralConfig(): void;
    createStationSplitStackChartData(): void;
    getImpsRtgPercentage(item: MarketWiseSplit): number;
    getImpsRtg(item: MarketWiseSplit): string;
    getCpmCpp(item: MarketWiseSplit): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlannedCampaignMarketSplitComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlannedCampaignMarketSplitComponent, "afr-planned-campaign-market-split", never, { "showChart": { "alias": "showChart"; "required": false; }; "marketSplit": { "alias": "marketSplit"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "showNoData": { "alias": "showNoData"; "required": false; }; "showOriginalCurrentTable": { "alias": "showOriginalCurrentTable"; "required": false; }; "showHeadersForBudget": { "alias": "showHeadersForBudget"; "required": false; }; "isImpsMetric": { "alias": "isImpsMetric"; "required": false; }; "bookedDemo": { "alias": "bookedDemo"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AfrPlannedCampaignPeriodAllocationComponent implements OnChanges, OnInit {
    monthWiseSplit: MonthWiseSplit[];
    showChart: boolean;
    loading: boolean;
    showNoData: boolean;
    isImpsMetric: boolean;
    showOriginalCurrentTable: boolean;
    bookedDemo: string;
    tableHeaders: IGtTableHeader[];
    clonedMonthWiseSplit: MonthWiseSplit[];
    gtDimension: {
        rowHeight: number;
        headerHeight: number;
        dataOnTopHeight: number;
        marginFromBottom: number;
    };
    gtGeneralConfig: IGtGeneralConfig;
    periodAllocationBarChartData: ChartData<"bar">;
    periodAllocationBarChartOptions: any;
    selectedType: "IMPS" | "BUDGET";
    private annaGlobalConfig;
    private tableDispersionSvc;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    createTableHeaders(): void;
    setGtGeneralConfig(): void;
    setPeriodAllocationBarChartData(): void;
    getImpsRtg(item: MonthWiseSplit): number;
    getImpsRtgAsDisplay(item: MonthWiseSplit): string;
    getCpmCpp(item: MonthWiseSplit): string;
    updateChartData(type: "IMPS" | "BUDGET"): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlannedCampaignPeriodAllocationComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlannedCampaignPeriodAllocationComponent, "afr-planned-campaign-period-allocation", never, { "monthWiseSplit": { "alias": "monthWiseSplit"; "required": false; }; "showChart": { "alias": "showChart"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "showNoData": { "alias": "showNoData"; "required": false; }; "isImpsMetric": { "alias": "isImpsMetric"; "required": false; }; "showOriginalCurrentTable": { "alias": "showOriginalCurrentTable"; "required": false; }; "bookedDemo": { "alias": "bookedDemo"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AfrPlannedCampaignStationSplitComponent implements OnInit, OnChanges {
    showChart: boolean;
    stationSplit: StationWiseSplit[];
    showOriginalCurrentTable: boolean;
    loading: boolean;
    showNoData: boolean;
    isImpsMetric: boolean;
    bookedDemo: string;
    chartType: keyof ChartTypeRegistry;
    stackChartOption: any;
    stationSplitChartData: any;
    tableHeaders: IGtTableHeader[];
    clonedStationSplit: StationWiseSplit[];
    gtDimension: {
        rowHeight: number;
        headerHeight: number;
        dataOnTopHeight: number;
        marginFromBottom: number;
    };
    gtGeneralConfig: IGtGeneralConfig;
    colorCodesArr: string[];
    private annaGlobalConfig;
    private utilitySvc;
    private tableDispersionSvc;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnInit(): void;
    createTableHeaders(): void;
    setGtGeneralConfig(): void;
    createStationSplitStackChartData(): void;
    getImpsRtgPercentage(item: StationWiseSplit): number;
    getImpsRtg(item: StationWiseSplit): string;
    getCpmCpp(item: StationWiseSplit): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlannedCampaignStationSplitComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlannedCampaignStationSplitComponent, "afr-planned-campaign-station-split", never, { "showChart": { "alias": "showChart"; "required": false; }; "stationSplit": { "alias": "stationSplit"; "required": false; }; "showOriginalCurrentTable": { "alias": "showOriginalCurrentTable"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "showNoData": { "alias": "showNoData"; "required": false; }; "isImpsMetric": { "alias": "isImpsMetric"; "required": false; }; "bookedDemo": { "alias": "bookedDemo"; "required": false; }; }, {}, never, never, true, never>;
}

declare class PlannedSummaryConstants {
    static readonly STATIONS = "Stations";
    static readonly TOTAL_BUDGET = "Total Budget";
    static readonly CPM = "CPM";
    static readonly IMPS = "IMPS('000)";
    static readonly REACH = "Reach";
    static readonly FREQUENCY = "Frequency";
    static readonly BOOKED_DEMO_WITH = "Booked Demo ";
    static readonly BOOKED_DEMO_WITH_A18 = "A18+";
    static readonly ADVERTISER = "Advertiser";
    static readonly AGENCY = "Agency";
    static readonly PLAN_NAME = "Plan Name";
    static readonly PERIOD = "Period";
    static readonly MARKET = "Market";
    static readonly POSTING_TYPE = "Posting Type";
    static readonly DEMO = "Demo";
    static readonly SPOT_DURATION = "Spot Duration";
    static readonly MEASURING_AGENCY = "Measurement Agency";
    static readonly PLAN_ID = "Plan ID";
    static readonly DRAFT_ID = "Draft ID";
    static readonly ESTIMATE_NUMBER = "Buyer Est#";
    static readonly BUDGET = "Budget";
    static readonly PRODUCT_NAME = "Product Name";
    static readonly PRODUCT_CATEGORY = "Product Category";
    static readonly CREATED_ON = "Created On";
    static readonly HIATUS = "Hiatus";
    static readonly Separation = "Separation";
    static readonly GRP = "GRP";
    static readonly CPP = "CPP";
    static readonly NO_OF_ORDER = "#Orders";
    static readonly MediaOcean_IO = "MediaOcean IO#";
}

interface SummaryWithSingleSection {
    heading: string;
    upperLabel: string;
    lowerLabel?: string;
    stationOverflowCount?: number;
    stationOverflowTooltip?: string;
}
interface SummaryWithMultipleSection {
    heading: string;
    class?: string;
    sections: Section[];
}
interface Section {
    label: string;
    value: string;
    showTooltip?: boolean;
    tooltipIconClass?: string;
    tooltipMessage?: string;
}

declare class AfrPlannedCampaignSummaryComponent implements OnChanges {
    private modalService;
    summaryDetails: SummaryDetails;
    loading: boolean;
    showNoData: boolean;
    isImpsMetric: boolean;
    useDraftId: boolean;
    summaryWithOneSection: SummaryWithSingleSection[];
    summaryWithMultipleSection: SummaryWithMultipleSection[];
    collapsedSummaryInfo: KeyValue$1[];
    expandedSummaryInfo: KeyValue$1[];
    plannedSummaryConstants: typeof PlannedSummaryConstants;
    summaryLoaderArr: any[];
    topSummaryLoaderArr: any[];
    isOpened: boolean;
    hiatusPopupHeaderMsg: string;
    private hiatusWindowPopup;
    hiatusWindowPopupReference: NgbModalRef;
    hiatusPopupOptions: NgbModalOptions;
    hiatusDates: HiatusDate[];
    constructor(modalService: NgbModal);
    ngOnChanges(changes: SimpleChanges): void;
    createSummaryWithOneSection(): void;
    createSummaryWithMultipleSection(): void;
    getTooltipMessage(): string;
    createSummaryInfoSection(): void;
    hiatusPopupModalConfig(): void;
    openClose(): void;
    openModalForHiatusWindow(): void;
    closeHiatusDatePopup(): void;
    handleClick(item: KeyValue$1): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrPlannedCampaignSummaryComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrPlannedCampaignSummaryComponent, "afr-planned-campaign-summary", never, { "summaryDetails": { "alias": "summaryDetails"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "showNoData": { "alias": "showNoData"; "required": false; }; "isImpsMetric": { "alias": "isImpsMetric"; "required": false; }; "useDraftId": { "alias": "useDraftId"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AfrReviewPlanContainerComponent implements OnInit {
    private static readonly REVIEW_PLAN_LOADER_ID;
    private approveCountdownIntervalId;
    readonly campaignId: _angular_core.InputSignal<number>;
    readonly metaData: _angular_core.InputSignal<ReviewPlanContainerMetaData>;
    readonly selectedAvails: _angular_core.InputSignal<Avails[]>;
    readonly persistedData: _angular_core.InputSignal<ReviewPlanContainerData>;
    readonly getOrderDetailsPath: _angular_core.InputSignal<(order: AvailOrderRow) => OrderDetailsNavigationResult | undefined>;
    readonly persistedDataChanged: _angular_core.OutputEmitterRef<ReviewPlanContainerData>;
    readonly disableEnableButton: _angular_core.OutputEmitterRef<boolean>;
    readonly instapitchEmailPackagePopupComponent: _angular_core.Signal<AfrInstapitchEmailPackageConfirmationPopupComponent>;
    readonly editModeConfirmationModal: _angular_core.Signal<ConfirmationPopupComponent>;
    readonly tabSwitchUnsavedChangesConfirmationModal: _angular_core.Signal<ConfirmationPopupComponent>;
    readonly isCampaignApproved: _angular_core.WritableSignal<boolean>;
    readonly loadingMarkets: _angular_core.WritableSignal<boolean>;
    readonly loadingCharts: _angular_core.WritableSignal<boolean>;
    readonly loadingTable: _angular_core.WritableSignal<boolean>;
    readonly showNoData: _angular_core.WritableSignal<boolean>;
    readonly showChart: _angular_core.WritableSignal<boolean>;
    readonly showMarketData: _angular_core.WritableSignal<boolean>;
    readonly showAddedLineTag: _angular_core.WritableSignal<boolean>;
    readonly mode: _angular_core.WritableSignal<Mode>;
    readonly activeTab: _angular_core.WritableSignal<string>;
    readonly isImpsMetric: _angular_core.WritableSignal<boolean>;
    readonly showDesiredImps: _angular_core.WritableSignal<boolean>;
    readonly showHeaderForBudget: _angular_core.WritableSignal<boolean>;
    readonly disableSaveBtn: _angular_core.WritableSignal<boolean>;
    readonly disableResetAllBtn: _angular_core.WritableSignal<boolean>;
    readonly seconds: _angular_core.WritableSignal<number>;
    readonly campaignName: _angular_core.WritableSignal<string>;
    readonly summary: _angular_core.WritableSignal<SummaryDetails>;
    readonly marketSplit: _angular_core.WritableSignal<MarketWiseSplit[]>;
    readonly stationSplit: _angular_core.WritableSignal<StationWiseSplit[]>;
    readonly daypartSplit: _angular_core.WritableSignal<DaypartWiseSplit[]>;
    readonly monthWiseSplit: _angular_core.WritableSignal<MonthWiseSplit[]>;
    readonly markets: _angular_core.WritableSignal<MultiSelectIdText[]>;
    readonly selectedMarkets: _angular_core.WritableSignal<MultiSelectIdText[]>;
    readonly tooltipText: _angular_core.WritableSignal<string>;
    readonly tabs: _angular_core.WritableSignal<ListingTab[]>;
    readonly tabToBeActive: _angular_core.WritableSignal<string>;
    readonly tableData: _angular_core.WritableSignal<EditableLineDetails[]>;
    readonly clonedTableData: _angular_core.WritableSignal<EditableLineDetails[]>;
    readonly tableHeaders: _angular_core.WritableSignal<IGtTableHeader[]>;
    readonly gtDimension: {
        rowHeight: number;
        headerHeight: number;
    };
    readonly gtGeneralConfig: _angular_core.WritableSignal<IGtGeneralConfig>;
    readonly totalRowInfo: _angular_core.WritableSignal<ITotalRowInfo[]>;
    readonly marketDropdownConfig: _angular_core.WritableSignal<ICustomMultiSelect>;
    readonly metrics: _angular_core.WritableSignal<SingleSelectIdText[]>;
    readonly selectedMetric: _angular_core.WritableSignal<SingleSelectIdText>;
    readonly metricConfig: _angular_core.WritableSignal<ICustomSingleSelect>;
    readonly weekArr: _angular_core.WritableSignal<ModifiedWeekWiseSpotCount[]>;
    readonly editModeConfirmationConfig: _angular_core.WritableSignal<IConfirmationPopupConfig>;
    readonly currentAllMarketsLineData: _angular_core.WritableSignal<EditableLineDetails[]>;
    readonly previousAllMarketsLineData: _angular_core.WritableSignal<EditableLineDetails[]>;
    readonly unsavedChangesConfirmationConfig: _angular_core.WritableSignal<IConfirmationPopupConfig>;
    readonly selectedLinesLength: _angular_core.WritableSignal<number>;
    readonly selectedClonedLineLength: _angular_core.WritableSignal<number>;
    readonly actualMarketNameAndMarketDisplayNameObj: _angular_core.WritableSignal<Record<string, string>>;
    readonly campaignsExpiresOn: _angular_core.WritableSignal<string>;
    readonly planId: _angular_core.WritableSignal<number>;
    readonly availUsage: _angular_core.WritableSignal<ReviewAvailUsage>;
    readonly syncedOrders: _angular_core.WritableSignal<AvailOrderRow[]>;
    readonly canShowViewOrdersLink: _angular_core.Signal<boolean>;
    readonly isApproved: _angular_core.WritableSignal<boolean>;
    readonly addedLines: _angular_core.WritableSignal<AddedBuyLines[]>;
    private readonly toastr;
    private readonly annaGlobalConfigService;
    private readonly modalService;
    private readonly ngxService;
    private readonly annaSortService;
    private readonly annaFilterService;
    private readonly annaGtHelperService;
    private readonly multiSelectService;
    private readonly location;
    private readonly reviewDataSvc;
    private readonly reviewSvc;
    private readonly tabService;
    private readonly commonNavSvc;
    private readonly state;
    private readonly destroyRef;
    private readonly route;
    private readonly reviewPlanDataSvc;
    private readonly buylineEditSvc;
    private readonly persistedState;
    private hydrateIfExternalChange;
    setComponentData(): void;
    setPersistedData(): void;
    emitPersistedData(): void;
    constructor();
    ngOnInit(): void;
    private initializeComponent;
    private approveCampaignClicked;
    setConfigForUnsavedPopup(): void;
    setMetricDropdownConfig(): void;
    setMarketDropdownConfig(): void;
    setConfigForEditPopup(): void;
    calculatePlaceholderTableColumns(): number;
    setGtGeneralConfig(): void;
    fetchCampaignInfo(selectedMarketNames: string[]): void;
    private handleCampaignInfoError;
    private applyCampaignInfoResponse;
    formatDataForLineDetails(res: EditableLineDetails[]): void;
    createTotalRowData(): void;
    switchView(view: "Chart" | "Table"): void;
    fetchMarketsForCampaign(): void;
    private fetchStationForwardsPackageData;
    dropdownClosed(items: MultiSelectIdText[]): void;
    approveCampaign(onlySendToBuyerFlow?: boolean): void;
    navigateToListing(planCreated?: boolean): void;
    copyToClipboard(tooltip: NgbTooltip): void;
    switchTabs(event: ListingTab): void;
    filterAppliedToTable(tableData: EditableLineDetails[]): void;
    sortingAppliedToTable(tableData: EditableLineDetails[]): void;
    enableDisableResetAllBtn(): void;
    resetAllFilter(): void;
    initResetFilterVar(): void;
    metricChanged(metric: SingleSelectIdText): void;
    openConfirmationPopupForEdit(): void;
    proceedToEdit(mode: Mode): void;
    fetchUpdatedCampaignDispersionData(): void;
    openOrdersPopup(): void;
    private resolveOrderDetailsPath;
    revertChangesForBuyLine(): void;
    filterOutTableDataForMarkets(showAllRows?: boolean): void;
    saveChangesForBuyLine(): void;
    selectUnselectLine(data: {
        rowData: EditableLineDetails;
        columnKeys: string;
        isCheckboxSelected: boolean;
    }): void;
    showUnselectedRowAtLast(): void;
    weekInputChanged(emittedData: {
        data: EditableLineDetails;
        key: string;
        valueEntered: string;
    }): void;
    stayOrSwitchTab(stay: boolean): void;
    getActualMarketName(marketNameWithRank: string): string;
    disableApproveButton(): void;
    private isCampaignExpired;
    private isStationForwardsPackageApproveFlow;
    enableDisableSaveBtn(data: AddedBuyLinesEmittedData): void;
    cancelUnsavedChanges(): void;
    goBack(): void;
    showAddedBuyerLinesLabel(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrReviewPlanContainerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrReviewPlanContainerComponent, "afr-review-plan-container", never, { "campaignId": { "alias": "campaignId"; "required": true; "isSignal": true; }; "metaData": { "alias": "metaData"; "required": false; "isSignal": true; }; "selectedAvails": { "alias": "selectedAvails"; "required": false; "isSignal": true; }; "persistedData": { "alias": "persistedData"; "required": false; "isSignal": true; }; "getOrderDetailsPath": { "alias": "getOrderDetailsPath"; "required": false; "isSignal": true; }; }, { "persistedDataChanged": "persistedDataChanged"; "disableEnableButton": "disableEnableButton"; }, never, [".station-forward-package-chrome"], true, never>;
}

declare class AfrTimeInputComponent implements OnInit {
    private annaFilterService;
    private dateTimeFormatService;
    startTime: string;
    endTime: string;
    minStartTime: string;
    maxEndTime: string;
    startFromText: string;
    endToText: string;
    showDays: boolean;
    days: ReviewDays[];
    timeChanges: EventEmitter<any>;
    closeTooltip: EventEmitter<any>;
    startTimeHourErr: boolean;
    startTimeMinErr: boolean;
    endTimeHourErr: boolean;
    endTimeMinErr: boolean;
    selectedFromTime: any[];
    selectedToTime: any[];
    clonedSelectedFromTime: any;
    clonedSelectedToTime: any;
    private lastValidFromTime;
    private lastValidToTime;
    disableTimeFilterApplyBtn: boolean;
    isFilterChanged: boolean;
    previousDays: ReviewDays[];
    constructor(annaFilterService: AnnaFilterService, dateTimeFormatService: AnnaDateTimeFormatService);
    ngOnInit(): void;
    createInitialData(): void;
    closeTimeFilter(): void;
    changeStartTimeHour(increment: boolean): void;
    changeEndTimeHour(increment: boolean): void;
    changeEndTimeMinute(increment: boolean): void;
    changeStartTimeMinute(increment: boolean): void;
    startTimeHourChange(val: string): void;
    startTimeMinChange(val: string): void;
    endTimeHourChange(val: string): void;
    endTimeMinChange(val: string): void;
    disableTimeFilterApplyButton(): void;
    private clampSelectedTimesToRange;
    checkIfTimeEnteredIsOutOfRange(): boolean;
    checkIfInvalidTimeIsEntered(): boolean;
    checkIfTimeTooltipIsFiltered(): boolean;
    getStartAndEndTimeInString(): {
        startTime: string;
        endTime: string;
    };
    applyTimeFilters(): void;
    checkIfDaysAreValidAndChanged(): boolean;
    selectUnselectDay(item: ReviewDays): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AfrTimeInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AfrTimeInputComponent, "afr-time-input", never, { "startTime": { "alias": "startTime"; "required": false; }; "endTime": { "alias": "endTime"; "required": false; }; "minStartTime": { "alias": "minStartTime"; "required": false; }; "maxEndTime": { "alias": "maxEndTime"; "required": false; }; "startFromText": { "alias": "startFromText"; "required": false; }; "endToText": { "alias": "endToText"; "required": false; }; "showDays": { "alias": "showDays"; "required": false; }; "days": { "alias": "days"; "required": false; }; }, { "timeChanges": "timeChanges"; "closeTooltip": "closeTooltip"; }, never, never, true, never>;
}

interface ListingState {
    columnSortFilter: ListingColumnSortFilterState | null;
    quarterFilter: PeriodSelectionPopUp | null;
    stationIds: string[] | null;
    popupFilter: PersistedDashboardPrimaryFilters | null;
}
declare const defaultListingState: () => ListingState;

interface ListingAdapter {
    loadEosActive(req: any): Observable<any>;
    loadEosDrafts(req: any): Observable<any>;
    loadEosAvails(req: any): Observable<any>;
    loadEosCompleted(req: any): Observable<any>;
    loadEosStationForwards?(req: any): Observable<any>;
    loadInstaPitchAvails(req: any): Observable<any>;
    loadInstaPitchPackages(req: any): Observable<any>;
    loadInstaPitchDrafts(req: any): Observable<any>;
    loadBuyerPulledAvails?(req: any): Observable<any>;
}
declare const LISTING_ADAPTER: InjectionToken<ListingAdapter>;

interface ListingRequestContext {
    userId: string;
    isCopilot: boolean;
    stationNames: string[];
    selectedPeriod?: {
        startDate: string;
        endDate: string;
        isEntireFlightPeriod?: boolean;
    };
    toQueryString: (params: Record<string, unknown>) => string;
    tabId?: string;
}
interface ListingNavCommand {
    type: "NAVIGATE";
    path: unknown[];
    queryParams?: Record<string, unknown>;
}
interface ListingNavContext {
    go: (cmd: ListingNavCommand) => void;
    ensureBreadcrumbs: () => string | null;
    buildListingPageFilterParams: () => Record<string, unknown>;
    tabId: string;
}
interface ListingTextActionContext {
    go: (cmd: ListingNavCommand) => void;
    ensureBreadcrumbs: () => string | null;
    buildListingPageFilterParams: () => Record<string, unknown>;
    tabId: string;
}
interface ListingFlowCommand {
    type: ListingFlowType;
    tabId?: string;
    queryParams?: Record<string, unknown>;
    payload?: unknown;
}
interface ListingFlowContext {
    open: (cmd: ListingFlowCommand) => void;
    buildListingPageFilterParams: () => Record<string, unknown>;
    tabId: string;
}
type ListingFlowType = "ANNA" | "EOS";
interface TabDefinition {
    id: string;
    title: string;
    route: string;
    headers: IGtTableHeader[];
    tableClass?: string;
    flowType?: ListingFlowType;
    adapterMethod?: keyof ListingAdapter;
    requestMapper: (ctx: ListingRequestContext) => unknown;
    mapRow?(row: any): any;
    rowAction(row: any, nav: ListingNavContext): void;
    textAction?(event: ListingGtTextActionEvent, nav: ListingTextActionContext): void;
    addAction(flow: ListingFlowContext): void;
    /** When false, the listing page hides the Add button. Defaults to true. */
    showAddButton?: boolean;
    expiryCard?: {
        getIds: () => Array<string | number>;
        wasTakeActionClicked: () => boolean;
        resetTakeActionClicked: () => void;
    };
}

/**
 * Lifecycle of the “initial draft load” container-loader gate (see `docs/plan-campaign-container-loader.md`).
 */
declare enum PlanCampaignDraftInitialLoadPhase {
    /** Gate off: non-draft bootstrap or teardown; loader handled outside this gate. */
    Idle = "idle",
    /** Draft payload committed; loader may only clear per gate rules (incl. nested async). */
    InProgress = "inProgress",
    /** This load cycle cleared the gate via `tryStopInitialDraftLoader`. */
    Complete = "complete"
}

declare const ROOT_BREABCRUMB: InjectionToken<BreadcrumbsService>;
declare class ListingBreadcrumbsService {
    private breadcrumbsToPersist;
    private persistingFilterService;
    private breadcrumbService;
    setPersistedBreadcrumbs(filters: string | null | undefined): void;
    applyBreadcrumbs(label: string, path: string): void;
    persistCurrentBreadcrumbs(): string | null;
    private removeRemovableBreadcrumbs;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListingBreadcrumbsService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ListingBreadcrumbsService>;
}

declare class ListingConfigService {
    registry: Map<string, TabDefinition>;
    getTab(tabId: string): TabDefinition;
    getAllTabs(): TabDefinition[];
    getAllTabsForParent(): ListingTab[];
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListingConfigService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ListingConfigService>;
}

declare class ListingDataService {
    private readonly adapter;
    private readonly config;
    load(tabId: string, req: unknown): Observable<unknown>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListingDataService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ListingDataService>;
}

declare class ListingFilterService {
    private persistingFilterService;
    private annaFilterService;
    private annaSortService;
    private annaGtHelperService;
    parsePersistedParam<T>(value: string | null | undefined): T | null;
    storeFilterValue(value: unknown): string;
    initColumnFilterAndSorting(): void;
    setNoSortingAppliedData(tableData: any[]): void;
    applyPersistedFilters(filtersFromRoute: ListingColumnSortFilterState, clonedTableData: any[]): any[];
    applyExpiryCardFilter(tableData: any[], clonedTableData: any[], expiryIds: Array<string | number>): any[];
    resetAll(tableData: any[], clonedTableData: any[]): any[];
    updateStateOfAllKeys(): void;
    isResetDisabled(): boolean;
    buildQueryParams(routeQueryParams: Record<string, unknown>): Record<string, unknown>;
    buildColumnSortFilterState(): ListingColumnSortFilterState | null;
    buildListingPageFilterParams(routeQueryParams: Record<string, unknown>): Record<string, unknown>;
    private initPersistedFilters;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListingFilterService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ListingFilterService>;
}

/**
 * Final query params for parent-level tab navigation (`router.navigate`).
 * Values are already hashed/serialized via `AnnaPersistingFilterService`
 * and can be written to the URL as-is.
 */
interface ListingParentHashedQueryParams {
    filters?: string;
    popupFilter?: string;
    quarterFilter?: string;
    stationIds?: string;
}
/**
 * Intermediate normalized context used while building parent tab query params.
 * Contains hashed values that can be merged into `ListingParentHashedQueryParams`.
 */
interface ListingParentInstaPitchContext {
    quarterFilter?: string;
    stationIds?: string;
}

declare class ListingNavigationService {
    private readonly router;
    private readonly persistingFilterService;
    goTo(path: unknown[], queryParams?: Record<string, unknown>): Promise<boolean>;
    navigateToListingTab(tab: ListingTab, state: ListingState, route: ActivatedRoute): void;
    buildListingTabQueryParams(tab: ListingTab, state: ListingState, queryParamMap: ParamMap, currentUrl: string): ListingParentHashedQueryParams;
    resolveInstaPitchPeriodAndStations(queryParamMap: ParamMap, isCurrentTabBuyerPulledAvails: boolean): ListingParentInstaPitchContext;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListingNavigationService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ListingNavigationService>;
}

interface ListingQuarterFilterResult {
    calendarTypes?: any;
    enabledPeriod?: {
        startDate: string;
        endDate: string;
    };
}
interface ListingPageConfig {
    getUserId: () => string;
    isCopilotUserLoggedIn: () => boolean;
    toQueryString: (params: Record<string, any>) => string;
    getStationDataForDropdown?: () => {
        id: number;
        text: string;
        timezoneShortForm: string;
    }[];
    loadQuarterFilters: () => Observable<any>;
    mapQuarterFilterResponse?: (response: any) => ListingQuarterFilterResult;
    periodModalTitle?: string;
    periodModalMessage?: string;
    periodOptions?: string[];
    gtDimension?: {
        rowHeight: number;
        headerHeight: number;
        dataOnTopHeight: number;
        marginFromBottom: number;
    };
    gtGeneralConfig?: Partial<IGtGeneralConfig>;
    showAllInMonthsDropdown?: boolean;
    showAllInQuartersDropdown?: boolean;
    includeBorderInTableHeight?: boolean;
    tableBorderBottomClassRequired?: boolean;
    breadcrumbLabel?: (tabId: string, tabTitle?: string) => string;
    /** When true (or when the function returns true for the current tabId), the multi-select station dropdown is shown. Typically true only for InstaPitch buyer-pulled avails tab. */
    showMultiSelectStationDropdown?: (tabId: string) => boolean;
    /** Host-filtered hard-reset stream (InstaPitch wires this from Anna). */
    primaryFiltersHardReset$?: Observable<unknown>;
}
declare const LISTING_PAGE_CONFIG: InjectionToken<ListingPageConfig>;

declare class ListingQuarterFilterService {
    private quarterFilterService;
    private pageConfig;
    loadQuarterFilters(): Observable<ListingQuarterFilterResult | null>;
    private processQuarterFilters;
    private mapQuarterFilterResponse;
    private publishQuarterData;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListingQuarterFilterService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ListingQuarterFilterService>;
}

declare class ListingStateService {
    private stateByTab;
    get(tabId: string, defaults?: Partial<ListingState>): ListingState;
    set(tabId: string, patch: Partial<ListingState>, defaults?: Partial<ListingState>): ListingState;
    reset(tabId: string, defaults?: Partial<ListingState>): ListingState;
    clear(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListingStateService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ListingStateService>;
}

interface DaypartTooltipContent {
    daypartName: string;
    daypartBudget: string;
    daypartCpmCpp: string;
    daypartImpsRtg: string;
}
interface StackTooltipContent {
    marketName?: string;
    stationName?: string;
    budget: string;
    cpmCpp: string;
    impsRtg: string;
}
interface PeriodTooltipContent {
    month: string;
    impsRtg: string;
    budget: string;
    cpmCpp: string;
    displayImpsRtg: string;
    displayBudget: string;
}
declare class PlanCampaignChartDispersionService {
    getDaypartAllocationsTableHeaders(isImpsMetric: boolean, bookedDemo?: string | null): IGtTableHeader[];
    getDaypartAllocationsCurrentTableHeaders(isImpsMetric: boolean, bookedDemo?: string | null): IGtTableHeader[];
    getMarketSplitTableHeaders(isImpsMetric: boolean, bookedDemo?: string | null): IGtTableHeader[];
    getMarketSplitCurrentTableHeaders(isImpsMetric: boolean, bookedDemo?: string | null): IGtTableHeader[];
    getMonthWisePeriodAllocationTableHeaders(isImpsMetric: boolean, bookedDemo?: string | null): IGtTableHeader[];
    getMonthWisePeriodAllocationCurrentTableHeaders(isImpsMetric: boolean, bookedDemo?: string | null): IGtTableHeader[];
    getStationSplitTableHeaders(isImpsMetric: boolean, bookedDemo?: string | null): IGtTableHeader[];
    getStationSplitCurrentTableHeaders(isImpsMetric: boolean, bookedDemo?: string | null): IGtTableHeader[];
    getEmptyHeaderForTable(headerName: string): IHeaderInfo;
    getDaypartAllocationsDoughnutChartOptions(isImpsMetric: boolean): {
        responsive: boolean;
        maintainAspectRatio: boolean;
        cutout: number;
        legend: {
            display: boolean;
        };
        plugins: {
            datalabels: {
                display: boolean;
                align: string;
                anchor: string;
                font: {
                    family: string;
                    size: number;
                };
            };
            deferred: boolean;
            tooltip: {
                displayColors: boolean;
                backgroundColor: string;
                bodyColor: string;
                bodyFont: string;
                showShadow: boolean;
                enabled: boolean;
                cornerRadius: number;
                borderColor: string;
                borderWidth: number;
                callbacks: {
                    label(context: {
                        dataset: Record<string, unknown>;
                        dataIndex: number;
                    }): DaypartTooltipContent;
                    title: () => null;
                };
                external: (context: {
                    tooltip: Record<string, unknown>;
                    chart: {
                        canvas: HTMLCanvasElement;
                    };
                }) => void;
            };
        };
    };
    getMarketSplitHorizontalStackChartOption(isImpsMetric: boolean): {
        responsive: boolean;
        maintainAspectRatio: boolean;
        cornerRadius: number;
        indexAxis: string;
        barThickness: number;
        scales: {
            x: {
                display: boolean;
                stacked: boolean;
            };
            y: {
                display: boolean;
            };
        };
        hover: {
            mode: string;
            intersect: boolean;
        };
        elements: {
            line: {
                tension: number;
            };
            point: {
                radius: number;
            };
        };
        plugins: {
            tooltip: {
                enabled: boolean;
                cornerRadius: number;
                borderColor: string;
                borderWidth: number;
                callbacks: {
                    label(context: {
                        dataset: Record<string, unknown>;
                    }): StackTooltipContent;
                    title: () => null;
                };
                external: (context: {
                    tooltip: Record<string, unknown>;
                    chart: {
                        canvas: HTMLCanvasElement;
                    };
                }) => void;
            };
        };
    };
    getPeriodAllocationBarChartOptions(isImpsMetric: boolean, selectedType: "IMPS" | "BUDGET"): {
        responsive: boolean;
        maintainAspectRatio: boolean;
        animation: boolean;
        animations: boolean;
        datasets: {
            bar: {
                barThickness: number;
            };
        };
        transitions: {
            show: {
                animations: boolean;
            };
            hide: {
                animations: boolean;
            };
        };
        scales: {
            x: {
                grid: {
                    display: boolean;
                    zeroLineColor: string;
                    color: string;
                };
                ticks: {
                    padding: number;
                };
                title: {
                    display: boolean;
                    text: string;
                    font: {
                        size: number;
                    };
                    color: string;
                };
            };
            y: {
                min: number;
                display: boolean;
                grid: {
                    display: boolean;
                    borderDash: number[];
                    color: string;
                };
                title: {
                    display: boolean;
                    text: string;
                    font: {
                        size: number;
                    };
                    color: string;
                };
                ticks: {
                    beginAtZero: boolean;
                    padding: number;
                    min: number;
                    callback(value: number): string;
                };
            };
        };
        interaction: {
            mode: string;
            intersect: boolean;
        };
        elements: {
            line: {
                tension: number;
            };
            point: {
                radius: number;
            };
        };
        plugins: {
            tooltip: {
                animation: boolean;
                enabled: boolean;
                callbacks: {
                    label(context: {
                        dataset: Record<string, unknown>;
                        dataIndex: number;
                    }): PeriodTooltipContent;
                };
                external: (context: {
                    tooltip: Record<string, unknown>;
                    chart: {
                        canvas: HTMLCanvasElement;
                    };
                }) => void;
            };
        };
    };
    getStationSplitHorizontalStackChartOption(isImpsMetric: boolean): {
        responsive: boolean;
        maintainAspectRatio: boolean;
        cornerRadius: number;
        indexAxis: string;
        barThickness: number;
        scales: {
            x: {
                display: boolean;
                stacked: boolean;
            };
            y: {
                display: boolean;
            };
        };
        hover: {
            mode: string;
            intersect: boolean;
        };
        elements: {
            line: {
                tension: number;
            };
            point: {
                radius: number;
            };
        };
        plugins: {
            tooltip: {
                enabled: boolean;
                cornerRadius: number;
                borderColor: string;
                borderWidth: number;
                callbacks: {
                    label(context: {
                        dataset: Record<string, unknown>;
                    }): StackTooltipContent;
                    title: () => null;
                };
                external: (context: {
                    tooltip: Record<string, unknown>;
                    chart: {
                        canvas: HTMLCanvasElement;
                    };
                }) => void;
            };
        };
    };
    private createDoughnutTooltipConfig;
    private createHorizontalStackChartOption;
    private renderDoughnutTooltip;
    private renderStackChartTooltip;
    private renderPeriodAllocationTooltip;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignChartDispersionService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignChartDispersionService>;
}

declare class PlanCampaignCommonNavigationService {
    private readonly state;
    private readonly route;
    private readonly router;
    private readonly persistingFilterService;
    private readonly config;
    /**
     * Returns the user to the campaign listing page, preserving filters when possible.
     * Priority: listing tab + persisted filters → returnUrl query param → tab from state → fallback route.
     */
    navigateToListing(planCreated?: boolean): Promise<boolean>;
    private getListingUrlForCurrentTab;
    private navigateToListingPath;
    private navigateWithPersistedFilters;
    private getFallbackListingUrl;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignCommonNavigationService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignCommonNavigationService>;
}

declare class PlanCampaignDaypartsService {
    /** Sum GRP % across in-play major rows. Returns [total, hasMissingGrp]. */
    calculateTotalPercentage(dayparts: DaypartCategory[]): [number, boolean];
    showErrorBasedOnPercentage(showGrpColumn: boolean, totalPercentage: number, hasMissingGrp: boolean): boolean;
    hasDpWithMissingDays(dayparts: DaypartCategory[]): boolean;
    getTotalCount(dayparts: DaypartCategory[]): [number, number];
    updateDaypartCategoryState(category: DaypartCategory): void;
    getDaypartTargetPayload(selectedData: DaypartCategory[] | null | undefined): CommonDaypartTarget[] | null;
    getDaypartDispersionPayload(grpByMajorDp: GrpByMajorDp | null | undefined): DaypartDispersionEntry[] | null;
    buildDaypartPayloadBundle(generalTable: DaypartCategory[] | null | undefined, grpByMajorDp: GrpByMajorDp | null | undefined): {
        DaypartTarget: CommonDaypartTarget[] | null;
        DaypartDispersion: DaypartDispersionEntry[] | null;
    };
    aggregateToMajorDaypartsForDispersion(categories: DaypartCategory[]): DaypartCategory[];
    getTableHeadersForDaypart(showGrpColumn: boolean, timezones: string[]): StationTableHeaders[];
    private buildDaypartTargetEntry;
    private buildTimezonePayload;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignDaypartsService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignDaypartsService>;
}

declare class PlanCampaignMarketService {
    /** Display name (with rank) → backend market name (without rank). Populated during bootstrap. */
    private displayNameToMarketName;
    /** Builds market dropdown options and USA map data for the General Info step. */
    createMarketSectionData(marketInfo: MarketFormData, markets: unknown, usaMapTopoJson: unknown, marketWiseArcInfo: unknown, marketsFromDraft: MarketTarget[] | null | undefined): void;
    /** Resolves a dropdown display name to the backend market name, or undefined when unmapped. */
    getActualMarketNameBasedOnSelectedMarket(marketDisplayName: string): string | undefined;
    /** Resolves a backend market name to its ranked display name shown in the UI. */
    getMarketNameWithRank(marketNameWithoutRank: string): string | undefined;
    /** Maps selected market dropdown items to backend market names for API payloads. */
    getMarketPayload(selectedMarkets: MultiSelectIdText[] | null | undefined): string[] | null;
    /** Combines selected markets with GRP/budget row data for save and avails payloads. */
    getMarketTargetPayload(selectedMarkets: MultiSelectIdText[], marketWiseGrpBudget: SelectedMarketWiseGrpOrBudget | null | undefined): MarketTarget[];
    /** Returns true when any market row has a missing or zero GRP/budget value. */
    checkIfMarketTargetIsInValid(marketWiseGrpOrBudget: SelectedMarketWiseGrpOrBudget): boolean;
    private normalizeMarketsApiResponse;
    private buildMarketDropdownData;
    private toMarketTarget;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignMarketService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignMarketService>;
}

declare class PlanCampaignPreviewService {
    private readonly config;
    private readonly primaryInfoSvc;
    private readonly state;
    createPreviewData(): void;
    private buildPreviewContext;
    private createEmptyCounters;
    private addProgressItem;
    private buildProgressItems;
    private buildGeneralProgressItems;
    private buildAvailsProgressItems;
    private buildPlanningProgressItems;
    private createMainWizardProgressItem;
    private createSubWizardProgressItem;
    private calculatePrimaryInfoCompletionRatio;
    private getProgressWeight;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignPreviewService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignPreviewService>;
}

interface LoadAgenciesForAdvertiserParams {
    advertiserName: string;
    draftAgencyName?: string | null;
    isStationForwardPlanOrderFlow?: boolean;
    clearSelectedAgency?: boolean;
}
interface LoadAgenciesForAdvertiserResult {
    agencies: SingleSelectIdText[];
    selected: SingleSelectIdText | null;
}
declare class PlanCampaignPrimaryInfoService {
    private readonly config;
    private readonly annaDateTimeService;
    private readonly state;
    private readonly regexPatternService;
    private readonly lookupMapper;
    private readonly lookupDataService;
    readonly emailValidators: (typeof Validators.required)[];
    readonly nameValidators: (typeof Validators.required)[];
    readonly phoneValidators: _angular_forms.ValidatorFn[];
    loadAgenciesForAdvertiser(params: LoadAgenciesForAdvertiserParams): Observable<LoadAgenciesForAdvertiserResult>;
    setDropdownDataForPrimaryInfo(primaryInfo: PrimaryInfoDropdowns, dropdownRes: PlanCampaignBootstrapRawResponse): void;
    createSelectedDataForPrimaryInfo(primaryInfo: PrimaryInfoDropdowns, selectedObj: PrimaryInfoSelectedData, draftRes: DraftPrimaryInfoFields | null | undefined): void;
    createBuyerContactSectionData(selectedData: GeneralInfoSelectedData, buyersFromDraft: BuyerContactFromDraft[] | null | undefined): void;
    setPrimaryInfoDataForPayload(payload: PlanCampaignRequestPayload, generalSelectedData: GeneralInfoSelectedData): void;
    setPrimaryInfoPayloadForEmailAvails(payload: PayloadForEmailAvails, generalSelectedData: GeneralInfoSelectedData): void;
    createPrimaryInfoPayloadForGenerateAvails(payload: GenerateAvailsPayload, selectedData: PrimaryInfoSelectedData): void;
    checkIfAvailsDependentDataChanged(currentValues: PrimaryInfoSelectedData, previousValues: PrimaryInfoSelectedData): boolean;
    checkIfValuesFromDraftAreValid(selectedObj: PrimaryInfoSelectedData | null | undefined, datesInPast: boolean): boolean;
    calculatePrimaryInfoCompletionRatio(selectedObj: GeneralInfoSelectedData | null | undefined, datesInPast: boolean): number;
    checkIfBuyerContactValidFromDraft(selectedObj: GeneralInfoSelectedData): boolean;
    isBuyerContactArrayValid(data: BuyerContactDetails[] | null | undefined): boolean;
    isPrimaryInfoEmpty(selectedObj: PrimaryInfoSelectedData | null | undefined): boolean;
    getPayloadSelectedDataForSingleSelect(value: SingleSelectIdText | null | undefined): string | null;
    getPayloadSelectedDataForInput(value: string | null | undefined): string | null;
    getPayloadSelectedDataForDate(value: NgbDate | null | undefined): string | null;
    private mapCommonPrimaryInfoPayloadFields;
    private resolveSpotDurationForPayload;
    private mapBuyersForEmailAvailsPayload;
    private buildPrimaryInfoFieldList;
    private hasPrimaryInfoValue;
    private resolveAgencySelection;
    private resolveDraftDropdownSelection;
    private resolveDraftInput;
    private resolveDraftDate;
    private isStationForwardPlanOrderFlow;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignPrimaryInfoService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignPrimaryInfoService>;
}

declare class PlanCampaignPrimeTimeService {
    /** Valid when there is no program data, or at least one program is selected / other-prime is checked. */
    isStepValid(primeTime: Pick<PrimeTime, "programsForWeek" | "showOtherPrimeProgramsCheckbox"> | undefined | null): boolean;
    getTotalCount(programs: DayProgram[]): [number, number];
    updateTimeSlotState(time: TimeSlotGroup): void;
    updateDayState(day: DayProgram): void;
    deriveAllRowState(programs: DayProgram[]): State;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignPrimeTimeService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignPrimeTimeService>;
}

interface GtSelectionTotalRowResult {
    totalRowInfo: ITotalRowInfo[];
    state: State;
}

type SpecialProgramTotalRowResult = GtSelectionTotalRowResult;
declare class PlanCampaignSpecialProgramService {
    isStepValid(programs: SpecialProgram[] | undefined | null): boolean;
    getTableHeaders(): IGtTableHeader[];
    buildTotalRowInfo(programs: SpecialProgram[]): SpecialProgramTotalRowResult;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignSpecialProgramService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignSpecialProgramService>;
}

type SportsProgramTotalRowResult = GtSelectionTotalRowResult;
declare class PlanCampaignSportsProgramService {
    isStepValid(programs: SportsProgram[] | undefined | null): boolean;
    getTableHeaders(): IGtTableHeader[];
    buildTotalRowInfo(programs: SportsProgram[]): SportsProgramTotalRowResult;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignSportsProgramService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignSportsProgramService>;
}

declare class PlanCampaignStationService {
    /**
     * Builds market-wise station rows for selected markets.
     * `selectedStations`:
     *   - `[]` — no station pre-selected
     *   - `null` — markets were not selected, stations were not created
     */
    buildMarketWiseStationTable(selectedMarkets: MultiSelectIdText[], marketDataWithStations: MarketListResponse[], selectedStations: StationTarget[] | null): MarketWiseStationTableData[];
    checkIfStationDataIsValid(marketWiseData: MarketWiseStationTableData[], requireMinShareForSelected?: boolean): boolean;
    getStationTargetPayload(selectedData: MarketWiseStationTableData[] | null | undefined, addTargetPercentage: boolean, selectedCampaignPlanningData: MarketWiseStationTableData[] | null | undefined): StationTarget[] | null;
    getTableHeadersForMarketWiseStations(showMinMarketShareCol: boolean): StationTableHeaders[];
    private getMarketSelectionState;
    private getStationLookupKey;
    private indexStationsByMarketAndName;
    private buildStationTarget;
    private resolveStationIsSelected;
    private resolveMeasurementAgencyName;
    private isApproximately100;
    private applyShareFormErrors;
    private validateMarketShareSequence;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignStationService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignStationService>;
}

declare class PlanCampaignUtilityService {
    private static readonly TENTH;
    private static readonly COLOR_CHANNEL_MIN;
    private static readonly COLOR_CHANNEL_MAX;
    /** Coerces user-entered numeric strings to a finite number, or null when empty/invalid. */
    static toFiniteNumberOrNull(value: string | number | null | undefined): number | null;
    /** Converts GRP to equivalent impressions for a market universe size. */
    static getEquivalentImpressions(grp: number, universeSize: number): number;
    /** Formats an HH:mm:ss time string as "h:mm A" with a single-letter meridiem (e.g. "2:30 P"). */
    static getDisplayTime(time: string): string;
    /** Normalizes decimal percentages to sum exactly 100 using 0.1 increments. */
    divide100IntoParts(values: number[]): number[];
    /** Converts percentage values to integers that sum to Math.round(total). */
    roundToTotal100(percentages: number[]): number[];
    /**
     * Splits `total` into integers proportional to `weights` using largest-remainder allocation.
     * Returns zeros when weights are empty or sum to zero.
     */
    distributeIntegerByWeights(total: number, weights: number[]): number[];
    /** Scales weights to integer percentages summing to 100. Returns zeros when total is 0. */
    fixFloatingPrecision(weights: number[]): number[];
    /** Generates distinct mid-tone hex colors for chart segments (excludes black and white). */
    generateUniqueHexColors(count: number): string[];
    private distributeIntegerRemainder;
    private sortByDescendingRemainder;
    private roundDecimal;
    private randomColorChannel;
    private rgbToHex;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlanCampaignUtilityService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PlanCampaignUtilityService>;
}

declare class ReviewPlanDataService {
    private readonly router;
    private readonly state;
    formatLineDetails(lineDetails: EditableLineDetails[]): EditableLineDetails[];
    buildCampaignInfoRequest(campaignId: number, marketNames: string[], options?: {
        PeriodStartDate?: string;
        PeriodEndDate?: string;
    }): CampaignInfoRequest;
    mapMarketsFromPrimaryFilter(response: CampaignPrimaryFilterResponse): ReviewPlanMarketMapping;
    mapMarketsFromCampaignInfo(response: CampaignInfoResponse): ReviewPlanMarketMapping;
    mapCampaignInfoResponse(response: CampaignInfoResponse): ReviewPlanCampaignInfoPatch;
    mapDispersionResponse(response: CampaignDispersionResponse): ReviewPlanChartDataPatch;
    mergeAddedBuylines(currentAllMarketsLineData: EditableLineDetails[], addedBuylines: CampaignAddedBuyline[] | undefined): EditableLineDetails[];
    extractSyncedOrders(response: CampaignInfoResponse): AvailOrderRow[];
    stripUiKeysFromLineDetails(lineDetails: EditableLineDetails[]): EditableLineDetails[];
    buildDispersionPayload(campaignId: number, selectedMarketNames: string[], currentAllMarketsLineData: EditableLineDetails[]): CampaignDispersionPayload;
    buildApprovePayload(campaignId: number, isStationForwardFlow: boolean, previousAllMarketsLineData: EditableLineDetails[]): ApproveCampaignPayload;
    isStationForwardsPackageApproveFlow(planOrderSource?: string | null): boolean;
    calculatePlaceholderTableColumns(): number;
    getActualMarketName(marketNameWithRank: string, actualMarketNameAndMarketDisplayNameObj: Record<string, string>): string;
    private mapChartDataFromSummary;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReviewPlanDataService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ReviewPlanDataService>;
}

declare const TAB_REGISTRY: InjectionToken<Map<string, TabDefinition>>;

interface PlanCampaignLookupsAdapter {
    getAdvertiserList(): Observable<any>;
    getAgencyList(advertiserName?: string): Observable<any>;
    getMeasurementAgencyList?(): Observable<any>;
    getPostingTypeList(): Observable<any>;
    getDemoList(): Observable<any>;
    getSpotDurationList?(): Observable<any>;
    getProductCodes?(): Observable<any>;
    getStationForwardAvailDetails?(availId: number): Observable<any>;
}
interface PlanCampaignMarketsAdapter {
    getMarketList(): Observable<any>;
    getTopoData(): Observable<any>;
    getMarketWiseArcData(): Observable<any>;
}
interface PlanCampaignDaypartsAdapter {
    getDayparts(payload: any): Observable<any>;
    getPrimeTimePrograms(payload: any): Observable<any>;
    getSportsPrograms(payload: any): Observable<any>;
    getSpecialPrograms(payload: any): Observable<any>;
}
interface StationMarketSharePayload {
    PlanningDemo: string;
    PostingType: string;
    StationNames: string[];
}
interface StationMarketShare {
    StationName: string;
    Share: number;
}
interface PlanCampaignPlanningAdapter {
    getBusinessRuleInfo(): Observable<any>;
    getMarketUniverseEstimatesForGrpBudget(payload: MarketUniverseEstimatesGrpBudgetPayload): Observable<MarketEquivalentImpressionResponse[]>;
    getStationMarketSharesForDispersion(payload: StationMarketSharePayload): Observable<StationMarketShare[]>;
}
interface PlanCampaignDraftsAdapter {
    saveOrUpdateDraft(payload: any): Observable<any>;
    getDraftInfo(draftId: number): Observable<any>;
}
interface PlanCampaignAvailsAdapter {
    generateAvails(payload: any): Observable<any>;
    emailAvails(payload: any): Observable<any>;
    getDownloadAvailsAPIURL(): string;
}
interface PlanCampaignRealtimeAdapter {
    getSignalRHubUrl?(): string;
    planCampaign(payload: any): Observable<any>;
}
interface PlanCampaignReviewAdapter {
    rejectCampaign(campaignId: number): Observable<unknown>;
    approveCampaign(payload: ApproveCampaignPayload): Observable<ApproveCampaignResponse>;
    getCampaignDispersion(payload: CampaignDispersionPayload): Observable<CampaignDispersionResponse>;
    getPrimaryFilterForCampaign(campaignId: number): Observable<CampaignPrimaryFilterResponse>;
    getCampaignInfo(payload: CampaignInfoRequest): Observable<CampaignInfoResponse>;
}
declare const PLAN_CAMPAIGN_LOOKUPS_ADAPTER: InjectionToken<PlanCampaignLookupsAdapter>;
declare const PLAN_CAMPAIGN_MARKETS_ADAPTER: InjectionToken<PlanCampaignMarketsAdapter>;
declare const PLAN_CAMPAIGN_DAYPARTS_ADAPTER: InjectionToken<PlanCampaignDaypartsAdapter>;
declare const PLAN_CAMPAIGN_PLANNING_ADAPTER: InjectionToken<PlanCampaignPlanningAdapter>;
declare const PLAN_CAMPAIGN_DRAFTS_ADAPTER: InjectionToken<PlanCampaignDraftsAdapter>;
declare const PLAN_CAMPAIGN_AVAILS_ADAPTER: InjectionToken<PlanCampaignAvailsAdapter>;
declare const PLAN_CAMPAIGN_REALTIME_ADAPTER: InjectionToken<PlanCampaignRealtimeAdapter>;
declare const PLAN_CAMPAIGN_REVIEW_ADAPTER: InjectionToken<PlanCampaignReviewAdapter>;

declare class CampaignAvailsTableHeadersConstant {
    static readonly NormalizedDemo = "A18+";
    static readonly IMPS = "IMPS";
    static readonly RTG = "RTG";
    static readonly MARKET = "MARKET";
    static readonly STATION = "STATION";
    static readonly PROGRAM = "PROGRAM";
    static readonly START_DATE = "START DATE";
    static readonly END_DATE = "END DATE";
    static readonly DAYS = "DAYS";
    static readonly TIME = "TIME";
    static readonly DAYPART = "DP";
    static readonly LEN = "LEN";
    static readonly BOOKED_IMPS_TOP_HEADER = "BOOKED IMPS";
    static readonly BOOKED_IMPS_BOTTOM_HEADER = "IMPS";
    static readonly SPOTS = "SPOTS";
    static readonly PROJECTED_GI = "PROJ. GI";
    static readonly POSTED_GI = "POSTED GI";
    static readonly RATE = "SUBMIT RATE";
    static readonly YMC_RATE = "YMC RATE";
    static readonly AMOUNT = "AMOUNT";
    static readonly HARD_BLOCK_MESSAGE = "Value is outside the allowed limit. Please correct the value to continue.";
    static readonly CPM = "CPM";
    static readonly BOOKED_RTG = "BOOKED RTG";
    static readonly CPP = "CPP";
    static readonly PROJECTED_GRP = "PROJ. GRP";
    static readonly POSTED_GRP = "POSTED GRP";
}

declare class PlanDispersionTableHeaderConstants {
    static readonly STATION = "STATION";
    static readonly PERCENT = "% (IMPS('000))";
    static readonly BUDGET = "BUDGET";
    static readonly DESIRED = "DESIRED";
    static readonly BOOKED = "BOOKED";
    static readonly PROJECTED = "PROJECTED";
    static readonly FINAL = "FINAL";
    static readonly CPM = "CPM";
    static readonly IMPS = "IMPS('000)";
    static readonly DAYPART = "DAYPART";
    static readonly WEEK = "WEEK";
    static readonly MARKET = "MARKET";
    static readonly AFFILIATE = "AFFILIATE";
    static readonly GENRE = "GENRE";
    static readonly CPP = "CPP";
    static readonly GRP = "GRP";
    static readonly GRP_PERCENT = "% GRP";
    static readonly MONTH = "MONTH";
}

declare class DaypartConstants {
    static readonly DAYPART_MAIN_CATEGORY: {
        readonly MORNING: "MORNING";
        readonly DAYTIME: "DAYTIME";
        readonly EARLY_FRINGE: "EARLY FRINGE";
        readonly EVENING_NEWS: "EVENING NEWS";
        readonly ACCESS: "ACCESS";
        readonly NETWORK_PRIME: "NETWORK PRIME";
        readonly LATE_NEWS: "LATE NEWS";
        readonly LATE_FRINGE: "LATE FRINGE";
        readonly OVERNIGHT: "OVERNIGHT";
        readonly WEEKEND: "WEEKEND";
        readonly SPORTS: "SPORTS";
        readonly SPECIAL_PROGRAMMING: "SPECIAL PROGRAMMING";
    };
    static readonly DAYPART_PROGRAMMING_STEPS: {
        readonly NETWORK_PRIME: "NETWORK PRIME";
        readonly SPORTS: "SPORTS";
        readonly SPECIAL_PROGRAMMING: "SPECIAL PROGRAMMING";
    };
    /** User-facing sub-wizard titles for dayparts and optional program steps. */
    static readonly DAYPART_WIZARD_STEP_TITLES: {
        readonly DAYPARTS: "Dayparts and Special Programming";
        readonly NETWORK_PRIME: "Network Prime Programming";
        readonly SPORTS: "Sports Programming";
        readonly MAJOR_SPORTS: "Major Sports Programming";
        readonly SPECIALITY_SPORTS: "Specialty Sports Programming";
        readonly SPECIAL_PROGRAMMING: "Holiday & Special Events";
    };
    /**
     * Sub-daypart under `SPECIAL PROGRAMMING` that opens the Holiday & Special Events step.
     * Movies alone must not open that step.
     */
    static readonly HOLIDAY_AND_SPECIAL_EVENTS_SUB_DAYPART = "Holiday & Special Events";
}
type DaypartMainCategoryCode = (typeof DaypartConstants.DAYPART_MAIN_CATEGORY)[keyof typeof DaypartConstants.DAYPART_MAIN_CATEGORY];
type DaypartProgrammingStepCode = (typeof DaypartConstants.DAYPART_PROGRAMMING_STEPS)[keyof typeof DaypartConstants.DAYPART_PROGRAMMING_STEPS];

declare class ReviewLineDetailsTableHeadersConstant {
    static readonly MARKET = "MARKET";
    static readonly STATION = "STATION";
    static readonly PROGRAM = "PROGRAM";
    static readonly START_DATE = "START DATE";
    static readonly END_DATE = "END DATE";
    static readonly DAYS = "DAYS";
    static readonly TIME = "TIME";
    static readonly DAYPART = "DP";
    static readonly LEN = "LEN";
    static readonly BOOKED_IMPS_TOP_HEADER = "BOOKED IMPS";
    static readonly BOOKED_IMPS_BOTTOM_HEADER = "IMPS";
    static readonly SPOTS = "SPOTS";
    static readonly PROJECTED_GI = "PROJ. GI";
    static readonly POSTED_GI = "POSTED GI";
    static readonly RATE = "RATE";
    static readonly AMOUNT = "AMOUNT";
    static readonly CPM = "CPM";
    static readonly BOOKED_RTG = "BOOKED RTG";
    static readonly CPP = "CPP";
    static readonly PROJECTED_GRP = "PROJ. GRP";
    static readonly POSTED_GRP = "POSTED GRP";
}
declare class MetricDropdownConstants {
    static readonly IMPS = "IMPS('000)";
    static readonly RATING = "Ratings";
}

declare class SpecialProgramTableHeadersConstant {
    static readonly SPECIAL_PROGRAM = "SPECIAL PROGRAMS";
    static readonly TIME_OF_THE_YEAR = "TIME OF THE YEAR";
    static readonly NETWORKS = "NETWORKS";
}

declare class SportsProgramTableHeadersConstant {
    static readonly LEAGUE = "LEAGUE";
    static readonly SPORT = "SPORT";
    static readonly STAGE = "STAGE";
    static readonly EVENT_TIER = "EVENT TIER";
    static readonly DATE = "DATE";
    static readonly MAJOR_EVENT = "MAJOR EVENT";
}

export { AVAIL_DETAILS_CONFIG, AVAIL_HIGHLIGHT_COMPANION_KEYS, AVAIL_NEGOTIATION_ADDED_ROW_CLASS, AVAIL_NEGOTIATION_CHANGED_CELL_CLASS, AVAIL_NEGOTIATION_REMOVED_ROW_CLASS, AduRules, AffiliateProgram, AfrAvailCommentHistoryModalComponent, AfrAvailNegotiationBarComponent, AfrAvailVersionSelectorComponent, AfrAvailsGeneratedDetailsComponent, AfrCampaignEmailAvailsPopupComponent, AfrCampaignFlowSelectionPopupComponent, AfrCampaignsListingParentComponent, AfrDaypartGroupsControlComponent, AfrInstapitchEmailAvailsConfirmationPopupComponent, AfrInstapitchEmailPackageConfirmationPopupComponent, AfrListingPageComponent, AfrPlanCampaignAddBuylinesComponent, AfrPlanCampaignAduRulesComponent, AfrPlanCampaignAvailsComponent, AfrPlanCampaignBudgetComponent, AfrPlanCampaignBuyerContactComponent, AfrPlanCampaignContainerComponent, AfrPlanCampaignDateInputComponent, AfrPlanCampaignDaypartsComponent, AfrPlanCampaignFinalCampaignPlanningComponent, AfrPlanCampaignGeneralInfoComponent, AfrPlanCampaignGeneralRulesComponent, AfrPlanCampaignMainWizardComponent, AfrPlanCampaignMakeGoodRulesComponent, AfrPlanCampaignMarketComponent, AfrPlanCampaignPrimaryInfoComponent, AfrPlanCampaignPrimeTimeComponent, AfrPlanCampaignSpecialProgramComponent, AfrPlanCampaignSportsProgramComponent, AfrPlanCampaignStationsComponent, AfrPlanCampaignSubWizardComponent, AfrPlanCampaignWeekSpotDispersionComponent, AfrPlannedCampaignDaypartAllocationComponent, AfrPlannedCampaignMarketSplitComponent, AfrPlannedCampaignPeriodAllocationComponent, AfrPlannedCampaignStationSplitComponent, AfrPlannedCampaignSummaryComponent, AfrReviewPlanContainerComponent, AfrTimeInputComponent, AvailVersionDiffService, CampaignAvailsTableHeadersConstant, DayProgram, Daypart, DaypartCategory, DaypartConstants, DaypartGroups, DaypartGroupsList, EditableLineDetailsTotalRow, GeneralRules, LISTING_ADAPTER, LISTING_PAGE_CONFIG, ListingBreadcrumbsService, ListingConfigService, ListingDataService, ListingFilterService, ListingNavigationService, ListingQuarterFilterService, ListingStateService, MakegoodRules, MarketInfoWithStationData, MarketWiseStationTableData, MaxSpots, MetricDropdownConstants, PLAN_CAMPAIGN_AVAILS_ADAPTER, PLAN_CAMPAIGN_CONFIG, PLAN_CAMPAIGN_DAYPARTS_ADAPTER, PLAN_CAMPAIGN_DRAFTS_ADAPTER, PLAN_CAMPAIGN_LOOKUPS_ADAPTER, PLAN_CAMPAIGN_MARKETS_ADAPTER, PLAN_CAMPAIGN_PLANNING_ADAPTER, PLAN_CAMPAIGN_REALTIME_ADAPTER, PLAN_CAMPAIGN_REVIEW_ADAPTER, PlanCampaignAvailsSection, PlanCampaignChartDispersionService, PlanCampaignCommonNavigationService, PlanCampaignCommonService, PlanCampaignDaypartsService, PlanCampaignDraftInitialLoadPhase, PlanCampaignDraftSection, PlanCampaignExecutionSection, PlanCampaignGeneralSection, PlanCampaignMarketService, PlanCampaignNavigationSection, PlanCampaignPlanningSection, PlanCampaignPreviewService, PlanCampaignPrimaryInfoService, PlanCampaignPrimeTimeService, PlanCampaignReviewSection, PlanCampaignSaveSection, PlanCampaignSpecialProgramService, PlanCampaignSportsProgramService, PlanCampaignSpotSection, PlanCampaignStateService, PlanCampaignStationService, PlanCampaignUtilityService, PlanCampaignWizardSection, PlanDispersionTableHeaderConstants, PlannedSummaryConstants, PrimeTime, ROOT_BREABCRUMB, ReviewLineDetailsTableHeadersConstant, ReviewPlanDataService, SUBMIT_REVISION_EDIT_KEYS, SpecialProgram, SpecialProgramTableHeadersConstant, SportsProgram, SportsProgramTableHeadersConstant, StationTableData, TAB_REGISTRY, TimeSlotGroup, TimezoneEntry, UsaMapMarketConstants, buildSubmitRevisionAvailRows, campaignStatusToCssClass, campaignStatusToDisplayLabel, composeVersionedListingDisplayId, createNegotiationRowId, defaultListingState, ensureAvailNegotiationRowIds, getAvailRowMatchKey, getLatestAvailCommentForVersion, getSelectionState, hasBackendAvailRowEditStatus, isAvailRowEditedForEasyFilter };
export type { AddedBuyLines, AddedBuyLinesEmittedData, AduBusinessRules, AduRulesFormChangeEvent, AduRulesSelectedData, Affiliates, ApproveCampaignPayload, ApproveCampaignResponse, AvailAuthorRole, AvailChangeLogEntry, AvailCommentEntry, AvailCommentFilter, AvailDetailsConfig, AvailDetailsResponse, AvailLineEditStatus, AvailOrderRow, AvailOrderTableRow, AvailUsage, AvailUsageTableRow, AvailVersionSummaryEntry, Avails, AvailsDigitOnlyInput, AvailsPropertyFromBackend, AvailsSelectionVM, AvailsVM, BusinessRulesForPayload, BuyerContactDetails, BuyerContactFromDraft, CampaignAddedBuyline, CampaignComponentStateVM, CampaignDispersionPayload, CampaignDispersionResponse, CampaignFlow, CampaignInfoRequest, CampaignInfoResponse, CampaignInfoSummary, CampaignInfoSummarySplit, CampaignLoaderVM, CampaignMarketStation, CampaignPreviousPayloadVM, CampaignPrimaryFilterResponse, CampaignStatus, CampaignSubWizardVM, CampaignViewModel, CampaignWizardVM, CommonDaypartTarget, CommonStationTarget, CommonWizardStep, DaypartDispersionEntry, DaypartFormData, DaypartGroupPayload, DaypartMainCategoryCode, DaypartPayload, DaypartProgrammingStepCode, DaypartUpdatedEvent, DaypartWiseSplit, DaypartsVM, DigitOnlyValue, DownloadButtonValue, DownloadSheetData, DraftFlowHelpers, DraftStateVM, DraftVM, EditableLineDetails, FinalCampaignPlanningData, FinalCampaignPlanningSelectedData, GeneralBusinessRules, GeneralInfoData, GeneralInfoSelectedData, GeneralInfoVM, GeneralRulesFormChangeEvent, GeneralRulesSelectedData, GenerateAvailsPayload, GrpBudgetVM, GrpByMajorDp, HiatusDate, HiatusDateMonthSpotDispersion, KeyValue, LineDetailsSetVM, LineSelection, ListingAdapter, ListingFlowCommand, ListingFlowContext, ListingFlowType, ListingNavCommand, ListingNavContext, ListingPageConfig, ListingQuarterFilterResult, ListingRequestContext, ListingState, ListingTextActionContext, LoadAgenciesForAdvertiserParams, LoadAgenciesForAdvertiserResult, MainWizardId, MakeGoodBusinessRules, MakeGoodRulesFormChangeEvent, MakeGoodRulesSelectedData, MarketEquivalentImpressionResponse, MarketFormData, MarketLegend, MarketListResponse, MarketTarget, MarketUniverseEstimatesGrpBudgetPayload, MarketWiseGrpOrBudgetChangeEvent, MarketWiseSplit, MarketWiseValue, MaxSpotsPayload, MeasurementAgencyUniverseSize, Mode, ModifiedWeekWiseSpotCount, MonthWiseHiatusDateData, MonthWiseSplit, MonthWiseTargetPercentage, OrderDetailsNavigationResult, PayloadForDownloadAvails, PayloadForEmailAvails, PlanCampaignAvailsAdapter, PlanCampaignConfig, PlanCampaignDaypartsAdapter, PlanCampaignDraftsAdapter, PlanCampaignFlowConfig, PlanCampaignHubResponse, PlanCampaignLookupsAdapter, PlanCampaignMainWizardStep, PlanCampaignMarketsAdapter, PlanCampaignPlanningAdapter, PlanCampaignPrimaryInfoConfig, PlanCampaignRealtimeAdapter, PlanCampaignRequestPayload, PlanCampaignReviewAdapter, PlanCampaignSubWizardStep, PlanningPreviousSelectionVM, PlanningVM, PopupToShow, PrimaryInfoDropdowns, PrimaryInfoFormChangeEvent, PrimaryInfoSelectedData, PrimeProgramsDayWise, PrimeProgramsTimeWise, PrimeSportsSpecialPreviousVM, PrimeTimePayload, PrimeTimeUpdatedEvent, ProjectedDataForGraph, ReviewAvailUsage, ReviewDays, ReviewPlanCampaignInfoPatch, ReviewPlanChartDataPatch, ReviewPlanContainerData, ReviewPlanContainerMetaData, ReviewPlanMarketMapping, ReviewPlanRuntimeSnapshot, ReviewVM, SaveDraftPayload, SaveProgressVM, Section, SelectedDataPreview, SelectedMarketWiseGrpOrBudget, SendNegotiationRequest, SendNegotiationResponse, SpecialProgramApiData, SpecialProgramPayload, SpecialProgramTotalRowResult, SpecialSelectionChangedEvent, SplitGraphCommonData, SportEvent, SportEventToBEResponse, SportsProgramApiResponse, SportsProgramPayload, SportsProgramTotalRowResult, SportsProgramsApiResponse, SportsSelectionChangedEvent, SpotDispersionFormData, SpotDispersionMonthRange, SpotDispersionSelectedData, SpotDispersionValidationVM, State, StationChangedEvent, StationInfoForEachMarket, StationMarketShare, StationMarketSharePayload, StationRatesTimeInfo, StationTableHeaders, StationTarget, StationWiseSplit, StationsVM, SubWizardId, SubmitAvailRevisionRequest, SubmitAvailRevisionResponse, SubmitRevisionEditKey, SummaryDetails, SummaryWithMultipleSection, SummaryWithSingleSection, TabDefinition, TimeInput, TimeInputOutput, TimezonePayload, WeekSpotDispersionPayload };