import { RawOptionsFromRefiners, RefinedOptionsFromRefiners, Identity as Identity$1 } from '@fullcalendar/core/protected-api';
import { EventApi, ViewApi, ClassNameGenerator, CssDimValue, BusinessHoursInput, ConstraintInput, AllowFunc } from 'fullcalendar/public-api';
import { DateRange, CalendarContext, Dictionary, DateMeta, ContentGenerator, DidMountHandler, WillUnmountHandler, Action, EventStore, EventUi, Identity, parseFieldSpecs, refineClassName } from 'fullcalendar/protected-api';
import { ReactNode } from 'preact/compat';

declare const RESOURCE_REFINERS: {
    id: StringConstructor;
    parentId: StringConstructor;
    children: Identity$1<ResourceInput[]>;
    title: StringConstructor;
    businessHours: Identity$1<BusinessHoursInput>;
    extendedProps: Identity$1<Dictionary>;
    eventEditable: BooleanConstructor;
    eventStartEditable: BooleanConstructor;
    eventDurationEditable: BooleanConstructor;
    eventConstraint: Identity$1<ConstraintInput>;
    eventOverlap: BooleanConstructor;
    eventAllow: Identity$1<AllowFunc>;
    eventClass: typeof refineClassName;
    eventColor: StringConstructor;
    eventContrastColor: StringConstructor;
};
type BuiltInResourceRefiners = typeof RESOURCE_REFINERS;
interface ResourceRefiners extends BuiltInResourceRefiners {
}
type ResourceInput = RawOptionsFromRefiners<Required<ResourceRefiners>> & // Required hack
{
    [extendedProps: string]: any;
};
interface Resource {
    id: string;
    parentId: string;
    title: string;
    businessHours: EventStore | null;
    ui: EventUi;
    extendedProps: {
        [extendedProp: string]: any;
    };
}
type ResourceHash = {
    [resourceId: string]: Resource;
};

interface ResourceSource<ResourceSourceMeta> {
    _raw: any;
    sourceId: string;
    sourceDefId: number;
    meta: ResourceSourceMeta;
    publicId: string;
    isFetching: boolean;
    latestFetchId: string;
    fetchRange: DateRange | null;
}

interface ResourceFuncInfo {
    start?: Date;
    end?: Date;
    startStr?: string;
    endStr?: string;
    timeZone?: string;
}
type ResourceFunc = ((info: ResourceFuncInfo, successCallback: (resourceInputs: ResourceInput[]) => void, failureCallback: (error: Error) => void) => void) | ((info: ResourceFuncInfo) => Promise<ResourceInput[]>);

declare const RESOURCE_SOURCE_REFINERS: {
    id: StringConstructor;
    resources: Identity<ResourceInput[] | ResourceFunc>;
    url: StringConstructor;
    method: StringConstructor;
    startParam: StringConstructor;
    endParam: StringConstructor;
    timeZoneParam: StringConstructor;
    extraParams: Identity<Dictionary | (() => Dictionary)>;
};
type ResourceSourceInputObject = RawOptionsFromRefiners<typeof RESOURCE_SOURCE_REFINERS>;
type ResourceSourceInput = ResourceSourceInputObject | ResourceInput[] | ResourceFunc | string;

declare class ResourceApi {
    private _context;
    _resource: Resource;
    constructor(_context: CalendarContext, _resource: Resource);
    setProp(name: string, value: any): void;
    setExtendedProp(name: string, value: any): void;
    private sync;
    remove(): void;
    getParent(): ResourceApi | null;
    getChildren(): ResourceApi[];
    getEvents(): EventApi[];
    get id(): string;
    get title(): string;
    get eventConstraint(): any;
    get eventOverlap(): boolean;
    get eventAllow(): any;
    get eventColor(): string;
    get eventContrastColor(): string;
    get eventClass(): string;
    get extendedProps(): {
        [extendedProp: string]: any;
    };
    toPlainObject(settings?: {
        collapseExtendedProps?: boolean;
    }): Dictionary;
    toJSON(): Dictionary;
}

interface ResourceAddInfo {
    resource: ResourceApi;
    revert: () => void;
}
interface ResourceChangeInfo {
    oldResource: ResourceApi;
    resource: ResourceApi;
    revert: () => void;
}
interface ResourceRemoveInfo {
    resource: ResourceApi;
    revert: () => void;
}

interface ResourceDayHeaderInfo extends Partial<DateMeta> {
    resource: ResourceApi;
    text: string;
    level: number;
    view: ViewApi;
    isDisabled: boolean;
    isNarrow: boolean;
    isMajor: boolean;
}

interface ResourceColumnHeaderInfo {
    view: ViewApi;
}
interface ResourceCellInfo {
    resource?: ResourceApi;
    field: string;
    fieldValue: any;
    view: ViewApi;
}
interface ResourceGroupHeaderInfo {
    fieldValue: any;
    view: ViewApi;
}
interface ResourceGroupLaneInfo {
    fieldValue: any;
    view: ViewApi;
}
interface ResourceLaneContentArgInput {
    resource: Resource;
    context: CalendarContext;
    eventOverlap: boolean;
}
interface ResourceLaneInfo {
    resource: ResourceApi;
    options: {
        eventOverlap: boolean;
    };
}
interface ResourceExpanderInfo {
    isExpanded: boolean;
}
interface ColHeaderRenderHooks {
    headerClass?: ClassNameGenerator<ResourceColumnHeaderInfo>;
    headerInnerClass?: ClassNameGenerator<ResourceColumnHeaderInfo>;
    headerResizerClass?: ClassNameGenerator<ResourceColumnHeaderInfo>;
    headerContent?: ContentGenerator<ResourceColumnHeaderInfo>;
    headerDefault?: (renderProps: ResourceColumnHeaderInfo) => ReactNode;
    headerDidMount?: DidMountHandler<ResourceColumnHeaderInfo>;
    headerWillUnmount?: WillUnmountHandler<ResourceColumnHeaderInfo>;
}
interface ColSpec extends ColHeaderRenderHooks {
    group?: boolean;
    isMain?: boolean;
    width?: number | string;
    field?: string;
    cellClass?: ClassNameGenerator<ResourceCellInfo>;
    cellInnerClass?: ClassNameGenerator<ResourceCellInfo>;
    cellContent?: ContentGenerator<ResourceCellInfo>;
    cellDidMount?: DidMountHandler<ResourceCellInfo>;
    cellWillUnmount?: WillUnmountHandler<ResourceCellInfo>;
}
interface GroupLaneRenderHooks {
    laneClass?: ClassNameGenerator<ResourceCellInfo>;
    laneInnerClass?: ClassNameGenerator<ResourceCellInfo>;
    laneContent?: ContentGenerator<ResourceCellInfo>;
    laneDidMount?: DidMountHandler<ResourceCellInfo>;
    laneWillUnmount?: WillUnmountHandler<ResourceCellInfo>;
}
interface GroupSpec extends GroupLaneRenderHooks {
    field?: string;
    order?: number;
    labelClass?: ClassNameGenerator<ResourceCellInfo>;
    labelInnerClass?: ClassNameGenerator<ResourceCellInfo>;
    labelContent?: ContentGenerator<ResourceCellInfo>;
    labelDidMount?: DidMountHandler<ResourceCellInfo>;
    labelWillUnmount?: WillUnmountHandler<ResourceCellInfo>;
}

declare const OPTION_REFINERS: {
    schedulerLicenseKey: StringConstructor;
    virtualization: BooleanConstructor;
    initialResources: Identity<ResourceSourceInput>;
    resources: Identity<ResourceSourceInput>;
    eventResourceEditable: BooleanConstructor;
    refetchResourcesOnNavigate: BooleanConstructor;
    resourceOrder: typeof parseFieldSpecs;
    filterResourcesWithEvents: BooleanConstructor;
    resourceGroupField: StringConstructor;
    resourcesInitiallyExpanded: BooleanConstructor;
    datesAboveResources: BooleanConstructor;
    needsResourceData: BooleanConstructor;
    resourceDayHeaderClass: Identity<ClassNameGenerator<ResourceDayHeaderInfo>>;
    resourceDayHeaderInnerClass: Identity<ClassNameGenerator<ResourceDayHeaderInfo>>;
    resourceDayHeaderContent: Identity<ContentGenerator<ResourceDayHeaderInfo>>;
    resourceDayHeaderDidMount: Identity<DidMountHandler<ResourceDayHeaderInfo>>;
    resourceDayHeaderWillUnmount: Identity<WillUnmountHandler<ResourceDayHeaderInfo>>;
    resourceDayHeaderAlign: Identity<"start" | "center" | "end" | ((info: {
        level: number;
    }) => "start" | "center" | "end")>;
    _resourceDayHeaderSticky: Identity<boolean | number | string>;
    printMaxRows: NumberConstructor;
    resourceColumnsWidth: Identity<CssDimValue>;
    resourceColumns: Identity<ColSpec[]>;
    resourceColumnDividerClass: typeof refineClassName;
    resourceColumnHeaderClass: Identity<ClassNameGenerator<ResourceColumnHeaderInfo>>;
    resourceColumnHeaderInnerClass: Identity<ClassNameGenerator<ResourceColumnHeaderInfo>>;
    resourceColumnResizerClass: Identity<ClassNameGenerator<ResourceColumnHeaderInfo>>;
    resourceColumnHeaderContent: Identity<ContentGenerator<ResourceColumnHeaderInfo>>;
    resourceColumnHeaderDidMount: Identity<DidMountHandler<ResourceColumnHeaderInfo>>;
    resourceColumnHeaderWillUnmount: Identity<WillUnmountHandler<ResourceColumnHeaderInfo>>;
    resourceHeaderRowClass: typeof refineClassName;
    resourceRowClass: typeof refineClassName;
    resourceCellClass: Identity<ClassNameGenerator<ResourceCellInfo>>;
    resourceCellInnerClass: Identity<ClassNameGenerator<ResourceCellInfo>>;
    resourceCellContent: Identity<ContentGenerator<ResourceCellInfo>>;
    resourceCellDidMount: Identity<DidMountHandler<ResourceCellInfo>>;
    resourceCellWillUnmount: Identity<WillUnmountHandler<ResourceCellInfo>>;
    resourceGroupHeaderClass: Identity<ClassNameGenerator<ResourceGroupHeaderInfo>>;
    resourceGroupHeaderInnerClass: Identity<ClassNameGenerator<ResourceGroupHeaderInfo>>;
    resourceGroupHeaderContent: Identity<ContentGenerator<ResourceGroupHeaderInfo>>;
    resourceGroupHeaderDidMount: Identity<DidMountHandler<ResourceGroupHeaderInfo>>;
    resourceGroupHeaderWillUnmount: Identity<WillUnmountHandler<ResourceGroupHeaderInfo>>;
    resourceGroupLaneClass: Identity<ClassNameGenerator<ResourceGroupLaneInfo>>;
    resourceGroupLaneInnerClass: Identity<ClassNameGenerator<ResourceGroupLaneInfo>>;
    resourceGroupLaneContent: Identity<ContentGenerator<ResourceGroupLaneInfo>>;
    resourceGroupLaneDidMount: Identity<DidMountHandler<ResourceGroupLaneInfo>>;
    resourceGroupLaneWillUnmount: Identity<WillUnmountHandler<ResourceGroupLaneInfo>>;
    resourceLaneClass: Identity<ClassNameGenerator<ResourceLaneInfo>>;
    resourceLaneDidMount: Identity<DidMountHandler<ResourceLaneInfo>>;
    resourceLaneWillUnmount: Identity<WillUnmountHandler<ResourceLaneInfo>>;
    resourceLaneTopClass: Identity<ClassNameGenerator<ResourceLaneInfo>>;
    resourceLaneTopContent: Identity<ContentGenerator<ResourceLaneInfo>>;
    resourceLaneBottomClass: Identity<ClassNameGenerator<ResourceLaneInfo>>;
    resourceLaneBottomContent: Identity<ContentGenerator<ResourceLaneInfo>>;
    resourceIndentClass: typeof refineClassName;
    resourceExpanderClass: Identity<ClassNameGenerator<ResourceExpanderInfo>>;
    resourceExpanderContent: Identity<ContentGenerator<ResourceExpanderInfo>>;
    timelineTopClass: typeof refineClassName;
    timelineBottomClass: typeof refineClassName;
};
type PremiumOptions = RawOptionsFromRefiners<typeof OPTION_REFINERS>;
type PremiumOptionsRefined = RefinedOptionsFromRefiners<typeof OPTION_REFINERS>;
declare const LISTENER_REFINERS: {
    resourcesSet: Identity<(resources: ResourceApi[]) => void>;
    resourceAdd: Identity<(info: ResourceAddInfo) => void>;
    resourceChange: Identity<(info: ResourceChangeInfo) => void>;
    resourceRemove: Identity<(info: ResourceRemoveInfo) => void>;
    _resourceScrollRequest: Identity<(resourceId: string) => void>;
};
type PremiumListeners = RawOptionsFromRefiners<typeof LISTENER_REFINERS>;
type PremiumListenersRefined = RefinedOptionsFromRefiners<typeof LISTENER_REFINERS>;

type ResourceAction = Action | {
    type: 'FETCH_RESOURCE';
} | {
    type: 'RECEIVE_RESOURCES';
    rawResources: ResourceInput[];
    fetchId: string;
    fetchRange: DateRange | null;
} | {
    type: 'RECEIVE_RESOURCE_ERROR';
    error: Error;
    fetchId: string;
    fetchRange: DateRange | null;
} | {
    type: 'ADD_RESOURCE';
    resourceHash: ResourceHash;
} | // use a hash because needs to accept children
{
    type: 'REMOVE_RESOURCE';
    resourceId: string;
} | {
    type: 'SET_RESOURCE_PROP';
    resourceId: string;
    propName: string;
    propValue: any;
} | {
    type: 'SET_RESOURCE_EXTENDED_PROP';
    resourceId: string;
    propName: string;
    propValue: any;
} | {
    type: 'SET_RESOURCE_ENTITY_EXPANDED';
    id: string;
    isExpanded: boolean;
} | {
    type: 'RESET_RESOURCE_SOURCE';
    resourceSourceInput: any;
} | {
    type: 'REFETCH_RESOURCES';
};

type ResourceEntityExpansions = {
    [id: string]: boolean;
};

declare const EVENT_REFINERS: {
    resourceId: StringConstructor;
    resourceIds: Identity<string[]>;
    resourceEditable: BooleanConstructor;
};

type ExtraEventRefiners = typeof EVENT_REFINERS;
declare module '@fullcalendar/core/protected-api' {
    interface BaseOptions extends PremiumOptions {
    }
    interface BaseOptionsRefined extends PremiumOptionsRefined {
    }
    interface EventRefiners extends ExtraEventRefiners {
    }
}
declare module 'fullcalendar/public-api' {
    interface DatePointApi {
        resource?: ResourceApi;
    }
    interface DateSpanApi {
        resource?: ResourceApi;
    }
    interface EventDropInfo {
        oldResource?: ResourceApi;
        newResource?: ResourceApi;
    }
}
//# sourceMappingURL=ambient.d.ts.map

declare module 'fullcalendar/public-api' {
    interface EventApi {
        getResources: () => ResourceApi[];
        setResources: (resources: (string | ResourceApi)[]) => void;
    }
}
//# sourceMappingURL=EventApi.d.ts.map

declare module 'fullcalendar/public-api' {
    interface CalendarApi {
        addResource(input: ResourceInput, scrollTo?: boolean): ResourceApi;
        getResourceById(id: string): ResourceApi | null;
        getResources(): ResourceApi[];
        getTopLevelResources(): ResourceApi[];
        refetchResources(): void;
    }
}
declare module 'fullcalendar/protected-api' {
    interface CalendarListeners extends PremiumListeners {
    }
    interface CalendarListenersRefined extends PremiumListenersRefined {
    }
    interface CalendarContext {
        dispatch(action: ResourceAction): void;
    }
    interface CalendarData {
        resourceSource?: ResourceSource<any>;
        resourceStore?: ResourceHash;
        resourceEntityExpansions?: ResourceEntityExpansions;
    }
    interface EventMutation {
        resourceMutation?: {
            matchResourceId: string;
            setResourceId: string;
        };
    }
    interface EventDef {
        resourceIds?: string[];
        resourceEditable?: boolean;
    }
}
declare module 'fullcalendar/protected-api' {
    interface EventImpl {
        getResources: () => ResourceApi[];
        setResources: (resources: (string | ResourceApi)[]) => void;
    }
}
declare module 'fullcalendar/protected-api' {
    interface CalendarApiImpl {
        dispatch(action: ResourceAction): any;
        addResource(input: ResourceInput, scrollTo?: boolean): ResourceApi;
        getResourceById(id: string): ResourceApi | null;
        getResources(): ResourceApi[];
        getTopLevelResources(): ResourceApi[];
        refetchResources(): void;
    }
}

export { ColHeaderRenderHooks as C, GroupLaneRenderHooks as G, ResourceAddInfo as R, ColSpec as a, GroupSpec as b, ResourceApi as c, ResourceCellInfo as d, ResourceChangeInfo as e, ResourceColumnHeaderInfo as f, ResourceDayHeaderInfo as g, ResourceExpanderInfo as h, ResourceFunc as i, ResourceFuncInfo as j, ResourceGroupHeaderInfo as k, ResourceGroupLaneInfo as l, ResourceInput as m, ResourceLaneContentArgInput as n, ResourceLaneInfo as o, ResourceRemoveInfo as p, ResourceSourceInput as q, ResourceSourceInputObject as r };