export declare enum PopularityReferenceTime {
    This = "this"
}
export declare const PopularityReferenceTimes: PopularityReferenceTime.This[];
export declare enum PopularityTimeSpan {
    Year = "year",
    Month = "month",
    Week = "week"
}
export declare const PopularityTimeSpans: PopularityTimeSpan[];
export type PopularFilterProps = {
    refTime: PopularityReferenceTime;
    span: PopularityTimeSpan;
};
export type PopularFilter = true | PopularFilterProps;
export declare enum RatingSlug {
    None = "none",
    HalfStar = 0.5,
    OneStar = 1,
    OneAndAHalfStars = 1.5,
    TwoStars = 2,
    TwoAndAHalfStars = 2.5,
    ThreeStars = 3,
    ThreeAndAHalfStars = 3.5,
    FourStars = 4,
    FourAndAHalfStars = 4.5,
    FiveStars = 5
}
export type RatingFilter = RatingSlug | `${RatingSlug}`;
export declare enum DecadeSlug {
    The1870s = "1870s",
    The1880s = "1880s",
    The1890s = "1890s",
    The1900s = "1900s",
    The1910s = "1910s",
    The1920s = "1920s",
    The1930s = "1930s",
    The1940s = "1940s",
    The1950s = "1950s",
    The1960s = "1960s",
    The1970s = "1970s",
    The1980s = "1980s",
    The1990s = "1990s",
    The2000s = "2000s",
    The2010s = "2010s",
    The2020s = "2020s"
}
export type HrefTimespanFilterProps = {
    upcoming: true;
} | {
    decade: (`${number}0s` | DecadeSlug);
} | {
    year: number | `${number}`;
} | {};
export declare enum GenreSlug {
    Action = "action",
    Adventure = "adventure",
    Animation = "animation",
    Comedy = "comedy",
    Crime = "crime",
    Documentary = "documentary",
    Drama = "drama",
    Family = "family",
    Fantasy = "fantasy",
    History = "history",
    Horror = "horror",
    Music = "music",
    Mystery = "mystery",
    Romance = "romance",
    ScienceFiction = "science-fiction",
    Thriller = "thriller",
    TVMovie = "tv-movie",
    War = "war",
    Western = "western"
}
export type ExcludeGenreSlug = `-${GenreSlug}`;
export type IncludeGenreSlug = `+${GenreSlug}`;
export type AnyGenreSlug = (GenreSlug | IncludeGenreSlug | ExcludeGenreSlug);
export type GenreSlugArray = AnyGenreSlug[];
export type GenreFilter = GenreSlugArray | AnyGenreSlug;
export declare const excludeGenre: (genre: GenreSlug) => ExcludeGenreSlug;
export declare enum StreamingServiceSlug {
    AmazonUSA = "amazon-usa",
    AmazonVideoUSA = "amazon-video-us",
    AppleTVPlusUSA = "apple-tv-plus-us",
    AppleTVUSA = "apple-itunes-us"
}
export declare enum RoleSlug {
    AdditionalDirecting = "additional-directing",
    AdditionalPhotography = "additional-photography",
    ArtDirection = "art-direction",
    AssistantDirector = "assistant-director",
    CameraOperator = "camera-operator",
    Casting = "casting",
    Choreography = "choreography",
    Cinematography = "cinematography",
    CoDirector = "co-director",
    Composer = "composer",
    CostumeDesign = "costume-design",
    Director = "director",
    Editor = "editor",
    ExecutiveProducer = "executive-producer",
    Hairstyling = "hairstyling",
    Lighting = "lighting",
    Makeup = "makeup",
    OriginalWriter = "original-writer",
    Producer = "producer",
    ProductionDesign = "production-design",
    SetDecoration = "set-decoration",
    Songs = "songs",
    Sound = "sound",
    SpecialEffects = "special-effects",
    Stunts = "stunts",
    Studio = "studio",
    Story = "story",
    TitleDesign = "title-design",
    VisualEffects = "visual-effects",
    Writer = "writer"
}
export type RoleFilter = {
    roleSlug: RoleSlug;
    personSlug: string;
};
export declare enum SizeSlug {
    Large = "large"
}
export declare enum FilmFilterCookieValue {
    ShowShorts = "show-shorts",
    HideShorts = "hide-shorts",
    ShowTV = "show-tv",
    HideTV = "hide-tv",
    HideDocumentaries = "hide-docs",
    HideUnreleased = "hide-unreleased"
}
export declare enum SortByFilter {
    Name = "name",// asc
    BestMatch = "best-match",// desc
    MostPopular = "popular",// desc
    Shuffle = "shuffle",
    Activity = "activity",
    DiaryCount = "diary-count",// desc
    ReviewCount = "review-count",// desc
    NewestAdded = "added",// desc
    EarliestAdded = "added-earliest",// asc
    NewestRelease = "release",// desc
    EarliestRelease = "release-earliest",// asc
    HighestRating = "rating",// desc
    LowestRating = "rating-lowest",// asc
    ShortestLength = "shortest",// asc
    LongestLength = "longest",// desc
    NewestInOwnerDiary = "owner-diary",// desc
    EarliestInOwnerDiary = "owner-diary-earliest",// asc
    HighestOwnerRating = "owner-rating",// desc
    LowestOwnerRating = "owner-rating-lowest",// asc
    NewestDate = "date",// desc
    EarliestDate = "date-earliest",// asc
    NewestDateRated = "rated-date",// desc
    EarliestDateRated = "rated-date-earliest",// asc
    HighestEntryRating = "entry-rating",// desc
    LowestEntryRating = "entry-rating-lowest",// asc
    HighestMemberRating = "member-rating",// desc
    LowestMemberRating = "member-rating-lowest",// asc
    Newest = "newest",// desc
    Oldest = "oldest",// asc
    NewestUpdated = "updated",// desc
    OldestUpdated = "updated-oldest",// asc
    Week = "week",// desc
    Month = "month",// desc
    Year = "year",// desc
    WhenJoined = "whenJoined",// desc
    Billing = "billing",// desc
    Title = "title",// asc
    NewestPublished = "published",// desc
    OldestPublished = "published-oldest"
}
export type FilmsSortByFilter = SortByFilter.Name | SortByFilter.BestMatch | SortByFilter.NewestRelease | SortByFilter.EarliestRelease | SortByFilter.HighestRating | SortByFilter.LowestRating | SortByFilter.ShortestLength | SortByFilter.LongestLength;
export type DiarySortByFilter = FilmsSortByFilter | SortByFilter.NewestAdded | SortByFilter.EarliestAdded | SortByFilter.Activity | SortByFilter.MostPopular | SortByFilter.HighestEntryRating | SortByFilter.LowestEntryRating;
export type ReviewsSortByFilter = FilmsSortByFilter | SortByFilter.NewestAdded | SortByFilter.EarliestAdded | SortByFilter.Activity | SortByFilter.MostPopular | SortByFilter.HighestEntryRating | SortByFilter.LowestEntryRating;
export type ListsSortByFilter = SortByFilter.Name | SortByFilter.MostPopular | SortByFilter.NewestUpdated | SortByFilter.Newest | SortByFilter.Oldest;
export type HrefSortOrPopularFilterProps<TSortBy = SortByFilter> = {
    popular: PopularFilter;
} | {
    by: TSortBy;
} | {};
export type FilmsHrefArgs = HrefSortOrPopularFilterProps<FilmsSortByFilter> & {
    rated?: RatingFilter;
} & HrefTimespanFilterProps & {
    like?: string;
    in?: string;
    genre?: GenreFilter;
    nanogenre?: string;
    theme?: string;
    minitheme?: string;
    on?: StreamingServiceSlug;
    with?: RoleFilter;
    size?: SizeSlug;
    page?: number | `${number}`;
};
export declare enum FilmHrefSubroute {
    Similar = "similar",
    Themes = "themes",
    Nanogenres = "nanogenres",
    Crew = "crew",
    Details = "details",
    Genres = "genres",
    Releases = "releases",
    Members = "members",
    Fans = "fans",
    Likes = "likes",
    Reviews = "reviews",
    Lists = "lists"
}
export declare const FilmHrefSubroutes: FilmHrefSubroute[];
export declare const FilmHrefSubroutesSet: Set<FilmHrefSubroute>;
export type SimilarToFilmHrefArgs = HrefTimespanFilterProps & {
    on?: StreamingServiceSlug;
};
export type FilmThemesHrefArgs = HrefTimespanFilterProps & {
    on?: StreamingServiceSlug;
};
export type FilmNanogenresHrefArgs = HrefTimespanFilterProps & {
    on?: StreamingServiceSlug;
};
export type FilmMembersSortByFilter = SortByFilter.Name | SortByFilter.MostPopular | SortByFilter.NewestDate | SortByFilter.EarliestDate;
export type FilmMembersHrefArgs = {
    rated?: RatingFilter;
    by?: FilmMembersSortByFilter;
};
export type FilmLikesSortByFilter = SortByFilter.Name | SortByFilter.MostPopular | SortByFilter.NewestDate | SortByFilter.EarliestDate;
export type FilmLikesHrefArgs = {
    by?: FilmLikesSortByFilter;
};
export type FilmReviewsSortByFilter = SortByFilter.NewestAdded | SortByFilter.EarliestAdded | SortByFilter.Activity | SortByFilter.HighestEntryRating | SortByFilter.LowestEntryRating;
export type FilmReviewsHrefArgs = {
    rated?: RatingFilter;
    by?: FilmReviewsSortByFilter;
};
export type FilmListsSortByFilter = SortByFilter.Name | SortByFilter.MostPopular | SortByFilter.NewestUpdated | SortByFilter.Newest | SortByFilter.Oldest;
export type FilmListsHrefArgs = {
    by?: FilmListsSortByFilter;
};
export type ListsHrefArgs = {
    popular?: PopularFilter;
};
export declare enum MembersType {
    HQ = "hq"
}
export type MembersHrefArgs = {
    popular?: PopularFilter;
} | {
    popular: PopularFilter;
    page?: number | `${number}`;
};
export type HQMembersSortByFilter = SortByFilter.Name | SortByFilter.NewestDate;
export declare enum HQMembersOrganizationType {
    ClubOrSociety = "societies",
    Educator = "educators",
    Exhibitor = "exhibitors",
    Festival = "festivals",
    FilmOrFilmmaker = "films",
    GenreOrSpecialty = "genres",
    IndustryOrAssociation = "associations",
    MediaOrPublisher = "publishers",
    PlatformOrProduct = "platforms",
    Podcast = "podcasts",
    Streamer = "streamers",
    StudioOrDistributor = "studios"
}
export declare const HQMembersOrganizationTypes: HQMembersOrganizationType[];
export declare const HQMembersOrganizationTypesSet: Set<HQMembersOrganizationType>;
export type HQMembersHrefArgs = HrefSortOrPopularFilterProps<HQMembersSortByFilter> & {
    orgType?: HQMembersOrganizationType;
    page?: number | `${number}`;
};
export type ReviewersHrefArgs = {
    popular: PopularFilter;
};
export declare enum TagsType {
    Films = "films",
    Diary = "diary",
    Reviews = "reviews",
    Lists = "lists"
}
export declare const TagsTypes: TagsType[];
export declare const TagsTypesSet: Set<TagsType>;
type TagFilmsFilters = HrefTimespanFilterProps & {
    genre?: GenreFilter;
    on?: StreamingServiceSlug;
    by?: TagFilmsSortByFilter;
    page?: number | `${number}`;
};
export type TagFilmsSortByFilter = FilmsSortByFilter | SortByFilter.MostPopular | SortByFilter.Week | SortByFilter.Month | SortByFilter.Year;
export type TagFilmsHrefArgs = TagFilmsFilters;
export type TagDiarySortByFilter = DiarySortByFilter;
export type TagDiaryHrefArgs = {
    by?: TagDiarySortByFilter;
    page?: number | `${number}`;
};
export type TagReviewsSortByFilter = ReviewsSortByFilter;
export type TagReviewsHrefArgs = {
    by?: TagReviewsSortByFilter;
    page?: number | `${number}`;
};
export type TagListsSortByFilter = ListsSortByFilter;
export type TagListsHrefArgs = {
    by?: TagListsSortByFilter;
    page?: number | `${number}`;
};
export type ReviewsHrefArgs = {
    popular: PopularFilter;
};
export declare enum SearchTypeSlug {
    Films = "films",
    Reviews = "reviews",
    Lists = "lists",
    OriginalLists = "original-lists",
    Stories = "stories",
    CastOrCrewOrStudios = "cast-crew",
    MembersOrHQs = "members",
    Tags = "tags",
    Articles = "articles",
    PodcastEpisodes = "episodes",
    FullText = "full-text"
}
export declare const SearchTypeSlugs: SearchTypeSlug[];
export declare const SearchTypeSlugsSet: Set<SearchTypeSlug>;
export type SearchHrefArgs = {
    searchType: SearchTypeSlug;
    query: string;
} | {
    query?: string;
};
export type RolePersonSortByFilter = FilmsSortByFilter | SortByFilter.Billing;
export type RolePersonHrefArgs = HrefTimespanFilterProps & {
    genre?: GenreFilter;
    on?: StreamingServiceSlug;
    by?: RolePersonSortByFilter;
};
export declare const FirstYearInReview = 2012;
export declare enum OtherPageSlug {
    Showdown = "showdown",
    Journal = "journal",
    About = "about",
    GiftGuide = "gift-guide",
    Legal = "legal",
    Welcome = "welcome",
    Apps = "apps",
    Pro = "pro",
    Contact = "contact",
    APIBeta = "api-beta",
    API = "api"
}
export declare const OtherPageSlugs: OtherPageSlug[];
export declare enum UserHrefBaseSlug {
    Stories = "stories",
    Activity = "activity",
    Films = "films",
    Film = "film",
    Watchlist = "watchlist",
    Lists = "lists",
    List = "list",
    Likes = "likes",
    Tags = "tags",
    Tag = "tag",
    Following = "following",
    Followers = "followers",
    Stats = "stats"
}
export declare const UserHrefBaseSlugs: UserHrefBaseSlug[];
export declare const UserHrefBaseSlugsSet: Set<UserHrefBaseSlug>;
export declare enum UserFilmsHrefSubroute {
    Diary = "diary",
    Reviews = "reviews"
}
export declare const UserFilmsHrefSubroutes: UserFilmsHrefSubroute[];
export declare const UserFilmsHrefSubroutesSet: Set<UserFilmsHrefSubroute>;
export declare enum UserActivityType {
    Following = "following"
}
export declare const UserActivityTypes: UserActivityType.Following[];
export declare const UserActivityTypesSet: Set<UserActivityType.Following>;
export type UserFilmsSortByFilter = FilmsSortByFilter | SortByFilter.NewestDate | SortByFilter.EarliestDate | SortByFilter.NewestDateRated | SortByFilter.EarliestDateRated | SortByFilter.HighestEntryRating | SortByFilter.LowestEntryRating;
export type UserFilmsHrefArgs = {
    rated?: RatingFilter;
} & HrefTimespanFilterProps & {
    like?: string;
    in?: string;
    genre?: GenreFilter;
    nanogenre?: string;
    theme?: string;
    minitheme?: string;
    on?: StreamingServiceSlug;
    with?: RoleFilter;
    by?: UserFilmsSortByFilter;
    page?: number | `${number}`;
};
export type UserDiarySortByFilter = DiarySortByFilter | SortByFilter.DiaryCount;
export type UserDiaryHrefArgs = {
    for?: number | `${number}`;
    rated?: RatingFilter;
} & HrefTimespanFilterProps & {
    genre?: GenreFilter;
    on?: StreamingServiceSlug;
    by?: UserDiarySortByFilter;
    page?: number | `${number}`;
};
export type UserReviewsSortByFilter = ReviewsSortByFilter | SortByFilter.ReviewCount;
export type UserReviewsHrefArgs = {
    for?: number | `${number}`;
    rated?: RatingFilter;
    by?: UserReviewsSortByFilter;
    page?: number | `${number}`;
};
export declare enum UserFilmSubroute {
    Activity = "activity",
    Diary = "diary",
    Reviews = "reviews",
    Lists = "lists",
    Likes = "likes"
}
export declare const UserFilmSubroutes: UserFilmSubroute[];
export declare const UserFilmSubroutesSet: Set<UserFilmSubroute>;
export declare enum UserFilmViewingSubroute {
    Likes = "likes"
}
export declare const UserFilmViewingSubroutes: UserFilmViewingSubroute.Likes[];
export declare const UserFilmViewingSubroutesSet: Set<UserFilmViewingSubroute.Likes>;
export type UserFilmDiarySortByFilter = SortByFilter.NewestAdded | SortByFilter.EarliestAdded | SortByFilter.Activity | SortByFilter.HighestEntryRating | SortByFilter.LowestEntryRating;
export type UserFilmDiaryHrefArgs = {
    for?: number | `${number}`;
    rated?: RatingFilter;
    by?: UserFilmDiarySortByFilter;
};
export type UserFilmReviewsSortByFilter = SortByFilter.NewestAdded | SortByFilter.EarliestAdded | SortByFilter.Activity | SortByFilter.HighestEntryRating | SortByFilter.LowestEntryRating;
export type UserFilmReviewsHrefArgs = {
    rated?: RatingFilter;
    by?: UserFilmReviewsSortByFilter;
};
export type UserFilmListsSortByFilter = ListsSortByFilter;
export type UserFilmListsHrefArgs = {
    by?: UserFilmListsSortByFilter;
};
export declare enum UserFilmLikesType {
    Reviews = "reviews",
    Lists = "lists"
}
export declare const UserFilmLikesTypes: UserFilmLikesType[];
export declare const UserFilmLikesTypeSet: Set<UserFilmLikesType>;
export type UserFilmLikedReviewsSortByFilter = SortByFilter.NewestAdded | SortByFilter.EarliestAdded | SortByFilter.Activity | SortByFilter.HighestEntryRating | SortByFilter.LowestEntryRating;
export type UserFilmLikedReviewsHrefArgs = {
    rated?: RatingFilter;
    by?: UserFilmLikedReviewsSortByFilter;
};
export type UserFilmLikedListsSortByFilter = ListsSortByFilter;
export type UserFilmLikedListsHrefArgs = {
    by?: UserFilmLikedListsSortByFilter;
};
export declare enum UserFriendsFilmSubroute {
    Fans = "fans",
    Likes = "likes",
    Reviews = "reviews",
    Lists = "lists"
}
export declare const UserFriendsFilmSubroutes: UserFriendsFilmSubroute[];
export declare const UserFriendsFilmSubroutesSet: Set<UserFriendsFilmSubroute>;
export type UserFriendsFilmMembersSortByFilter = FilmMembersSortByFilter | SortByFilter.HighestEntryRating | SortByFilter.LowestEntryRating;
export type UserFriendsFilmMembersHrefArgs = {
    rated?: RatingFilter;
    by?: UserFriendsFilmMembersSortByFilter;
};
export type UserFriendsFilmLikesSortByFilter = FilmLikesSortByFilter | SortByFilter.HighestMemberRating | SortByFilter.LowestMemberRating;
export type UserFriendsFilmLikesHrefArgs = {
    by?: UserFriendsFilmLikesSortByFilter;
};
export type UserFriendsFilmReviewsSortByFilter = SortByFilter.NewestAdded | SortByFilter.EarliestAdded | SortByFilter.Activity | SortByFilter.HighestEntryRating | SortByFilter.LowestEntryRating;
export type UserFriendsFilmReviewsHrefArgs = {
    rated?: RatingFilter;
    by?: UserFriendsFilmReviewsSortByFilter;
};
export type UserFriendsFilmListsSortByFilter = ListsSortByFilter;
export type UserFriendsFilmListsHrefArgs = {
    by?: UserFriendsFilmListsSortByFilter;
};
export type UserStoriesSortByFilter = SortByFilter.Title | SortByFilter.NewestPublished | SortByFilter.OldestPublished | SortByFilter.NewestUpdated | SortByFilter.OldestUpdated;
export type UserStoriesHrefArgs = {
    by?: UserStoriesSortByFilter;
    page?: number | `${number}`;
};
export type UserWatchlistSortByFilter = FilmsSortByFilter | SortByFilter.MostPopular | SortByFilter.Shuffle | SortByFilter.NewestAdded | SortByFilter.EarliestAdded | SortByFilter.HighestMemberRating | SortByFilter.LowestMemberRating;
export type UserWatchlistHrefArgs = HrefTimespanFilterProps & {
    genre?: GenreFilter;
    on?: StreamingServiceSlug;
    by?: UserWatchlistSortByFilter;
    page?: number | `${number}`;
};
export type UserListsHrefArgs = {
    by?: ListsSortByFilter;
    page?: number | `${number}`;
};
export type ListSortByFilter = FilmsSortByFilter | SortByFilter.MostPopular | SortByFilter.Shuffle | SortByFilter.NewestAdded | SortByFilter.EarliestAdded | SortByFilter.NewestInOwnerDiary | SortByFilter.EarliestInOwnerDiary | SortByFilter.HighestOwnerRating | SortByFilter.LowestOwnerRating;
export type ListHrefArgs = {
    detail?: true;
} & HrefTimespanFilterProps & {
    genre?: GenreFilter;
    on?: StreamingServiceSlug;
    by?: ListSortByFilter;
    page?: number | `${number}`;
};
export declare enum UserLikesType {
    Films = "films",
    Reviews = "reviews",
    Lists = "lists"
}
export declare const UserLikesTypes: UserLikesType[];
export declare const UserLikesTypesSet: Set<UserLikesType>;
export type UserLikedFilmsSortByFilter = FilmsSortByFilter | SortByFilter.MostPopular | SortByFilter.Shuffle | SortByFilter.NewestDate | SortByFilter.EarliestDate | SortByFilter.HighestMemberRating | SortByFilter.LowestMemberRating;
export type UserLikedFilmsHrefArgs = {
    rated?: RatingFilter;
} & HrefTimespanFilterProps & {
    genre?: GenreFilter;
    on?: StreamingServiceSlug;
    by?: UserLikedFilmsSortByFilter;
    page?: number | `${number}`;
};
export type UserLikedReviewsSortByFilter = FilmsSortByFilter | SortByFilter.NewestAdded | SortByFilter.EarliestAdded | SortByFilter.Activity | SortByFilter.ReviewCount | SortByFilter.MostPopular | SortByFilter.HighestEntryRating | SortByFilter.LowestEntryRating | SortByFilter.HighestMemberRating | SortByFilter.LowestMemberRating;
export type UserLikedReviewsHrefArgs = {
    rated?: RatingFilter;
    by?: UserLikedReviewsSortByFilter;
    page?: number | `${number}`;
};
export type UserLikedListsSortByFilter = ListsSortByFilter;
export type UserLikedListsHrefArgs = {
    by?: UserLikedListsSortByFilter;
    page?: number | `${number}`;
};
export type UserTagsSortByFilter = SortByFilter.MostPopular | SortByFilter.Name;
export type UserTagsHrefArgs = {
    by?: UserTagsSortByFilter;
};
export type UserTagFilmsSortByFilter = TagFilmsSortByFilter | SortByFilter.NewestDate | SortByFilter.EarliestDate | SortByFilter.HighestMemberRating | SortByFilter.LowestMemberRating;
export type UserTagFilmsHrefArgs = TagFilmsFilters & {
    by?: UserTagFilmsSortByFilter;
};
export type UserTagDiarySortByFilter = UserDiarySortByFilter;
export type UserTagDiaryHrefArgs = {
    for?: number | `${number}`;
    rated?: RatingFilter;
} & HrefTimespanFilterProps & {
    genre?: GenreFilter;
    on?: StreamingServiceSlug;
    by?: UserTagDiarySortByFilter;
    page?: number | `${number}`;
};
export type UserTagReviewsSortByFilter = UserReviewsSortByFilter;
export type UserTagReviewsHrefArgs = {
    by?: UserTagReviewsSortByFilter;
    page?: number | `${number}`;
};
export type UserTagListsSortByFilter = ListsSortByFilter;
export type UserTagListsHrefArgs = {
    by?: UserTagListsSortByFilter;
    page?: number | `${number}`;
};
export type UserFriendsTagFilmsSortByFilter = TagFilmsSortByFilter;
export type UserFriendsTagFilmsHrefArgs = TagFilmsFilters & {
    by?: UserFriendsTagFilmsSortByFilter;
};
export type UserFriendsTagDiarySortByFilter = DiarySortByFilter;
export type UserFriendsTagDiaryHrefArgs = {
    by?: UserFriendsTagDiarySortByFilter;
    page?: number | `${number}`;
};
export type UserFriendsTagReviewsSortByFilter = ReviewsSortByFilter;
export type UserFriendsTagReviewsHrefArgs = {
    by?: UserFriendsTagReviewsSortByFilter;
    page?: number | `${number}`;
};
export type UserFriendsTagListsSortByFilter = ListsSortByFilter;
export type UserFriendsTagListsHrefArgs = {
    by?: ListsSortByFilter;
    page?: number | `${number}`;
};
export type UserFollowsSortByFilter = SortByFilter.Name | SortByFilter.WhenJoined | SortByFilter.MostPopular;
export declare enum UserFollowsType {
    Followers = "followers",
    Following = "following"
}
export type UserFollowsHrefArgs = {
    by?: UserFollowsSortByFilter;
};
export declare enum HrefBaseMediaPageSlug {
    Film = "film",
    Films = "films",
    Lists = "lists",
    Members = "members",
    Reviewers = "reviewers",
    Tag = "tag",
    Reviews = "reviews",
    Search = "search"
}
export type HrefBaseSlug = HrefBaseMediaPageSlug | RoleSlug | OtherPageSlug;
export type HrefParts = (({
    base: HrefBaseMediaPageSlug.Film;
    filmSlug: string;
} & ({} | ({
    subroute: (FilmHrefSubroute.Crew | FilmHrefSubroute.Details | FilmHrefSubroute.Genres | FilmHrefSubroute.Releases);
}) | ({
    subroute: FilmHrefSubroute.Similar;
} & SimilarToFilmHrefArgs) | ({
    subroute: FilmHrefSubroute.Themes;
} & FilmThemesHrefArgs) | ({
    subroute: FilmHrefSubroute.Nanogenres;
} & FilmNanogenresHrefArgs) | ({
    subroute: FilmHrefSubroute.Members;
} & FilmMembersHrefArgs) | ({
    subroute: FilmHrefSubroute.Fans;
}) | ({
    subroute: FilmHrefSubroute.Likes;
} & FilmLikesHrefArgs) | ({
    subroute: FilmHrefSubroute.Reviews;
} & FilmReviewsHrefArgs) | ({
    subroute: FilmHrefSubroute.Lists;
} & FilmListsHrefArgs))) | (({
    base: HrefBaseMediaPageSlug.Films;
} & FilmsHrefArgs)) | (({
    base: HrefBaseMediaPageSlug.Lists;
} & ListsHrefArgs)) | ({
    base: HrefBaseMediaPageSlug.Members;
} & (({
    membersType?: undefined;
} & MembersHrefArgs) | ({
    membersType: MembersType.HQ;
} & HQMembersHrefArgs))) | (({
    base: HrefBaseMediaPageSlug.Reviewers;
} & ReviewersHrefArgs)) | ({
    base: HrefBaseMediaPageSlug.Tag;
    tagSlug: string;
} & (({
    tagsType?: (TagsType.Films | undefined);
} & TagFilmsHrefArgs) | ({
    tagsType: TagsType.Diary;
} & TagDiaryHrefArgs) | ({
    tagsType: TagsType.Reviews;
} & TagReviewsHrefArgs) | ({
    tagsType: TagsType.Lists;
} & TagListsHrefArgs))) | ({
    base: HrefBaseMediaPageSlug.Reviews;
} & ReviewsHrefArgs) | (({
    base: HrefBaseMediaPageSlug.Search;
} & SearchHrefArgs)) | (({
    base: RoleSlug;
    personSlug: string;
} & RolePersonHrefArgs)) | ({
    yearInReview: number | `${number}`;
    remainingHref?: string;
}) | ({
    base: OtherPageSlug;
    remainingHref?: string;
}) | ({
    userSlug: string;
} & ({} | ({
    base: UserHrefBaseSlug.Films;
} & (({
    subroute?: undefined;
} & UserFilmsHrefArgs) | ({
    subroute: UserFilmsHrefSubroute.Diary;
} & UserDiaryHrefArgs) | ({
    subroute: UserFilmsHrefSubroute.Reviews;
} & UserReviewsHrefArgs))) | ({
    base: UserHrefBaseSlug.Film;
    filmSlug: string;
} & ({
    viewingSubroute?: UserFilmViewingSubroute;
} | ({
    subroute: UserFilmSubroute.Activity;
}) | ({
    subroute: UserFilmSubroute.Diary;
} & UserFilmDiaryHrefArgs) | ({
    subroute: UserFilmSubroute.Reviews;
} & UserFilmReviewsHrefArgs) | ({
    subroute: UserFilmSubroute.Lists;
} & UserFilmListsHrefArgs) | ({
    subroute: UserFilmSubroute.Likes;
} & (({
    likesType: UserFilmLikesType.Reviews;
} & UserFilmLikedReviewsHrefArgs) | ({
    likesType: UserFilmLikesType.Lists;
} & UserFilmLikedListsHrefArgs))) | ({
    viewingId: number | `${number}`;
    viewingSubroute?: UserFilmViewingSubroute;
}))) | ({
    friends: true;
    base: UserHrefBaseSlug.Film;
    filmSlug: string;
} & (({
    subroute?: undefined;
} & UserFriendsFilmMembersHrefArgs) | ({
    subroute: UserFriendsFilmSubroute.Fans;
}) | ({
    subroute: UserFriendsFilmSubroute.Likes;
} & UserFriendsFilmLikesHrefArgs) | ({
    subroute: UserFriendsFilmSubroute.Reviews;
} & UserFriendsFilmReviewsHrefArgs) | ({
    subroute: UserFriendsFilmSubroute.Lists;
} & UserFriendsFilmListsHrefArgs))) | ({
    base: UserHrefBaseSlug.Stories;
} & UserStoriesHrefArgs) | ({
    base: UserHrefBaseSlug.Activity;
    activityType?: UserActivityType;
}) | ({
    base: UserHrefBaseSlug.Watchlist;
} & UserWatchlistHrefArgs) | ({
    base: UserHrefBaseSlug.Lists;
} & UserListsHrefArgs) | (({
    base: UserHrefBaseSlug.List;
    listSlug: string;
} & ListHrefArgs)) | ({
    base: UserHrefBaseSlug.Likes;
} & ({
    likesType?: undefined;
} | ({
    likesType: UserLikesType.Films;
} & UserLikedFilmsHrefArgs) | ({
    likesType: UserLikesType.Reviews;
} & UserLikedReviewsHrefArgs) | ({
    likesType?: UserLikesType.Lists;
} & UserLikedListsHrefArgs))) | ({
    base: UserHrefBaseSlug.Tags;
} & (({
    tagsType?: (TagsType.Films | undefined);
} & UserTagsHrefArgs) | ({
    tagsType: TagsType.Diary;
} & UserTagsHrefArgs) | ({
    tagsType: TagsType.Reviews;
} & UserTagsHrefArgs) | ({
    tagsType: TagsType.Lists;
} & UserTagsHrefArgs))) | ({
    base: UserHrefBaseSlug.Tag;
    tagSlug: string;
} & (({
    tagsType?: TagsType.Films;
} & UserTagFilmsHrefArgs) | ({
    tagsType: TagsType.Diary;
} & UserTagDiaryHrefArgs) | ({
    tagsType: TagsType.Reviews;
} & UserTagReviewsHrefArgs) | ({
    tagsType: TagsType.Lists;
} & UserTagListsHrefArgs))) | ({
    friends: true;
    base: UserHrefBaseSlug.Tag;
    tagSlug: string;
} & (({
    tagsType?: TagsType.Films;
} & UserFriendsTagFilmsHrefArgs) | ({
    tagsType: TagsType.Diary;
} & UserFriendsTagDiaryHrefArgs) | ({
    tagsType: TagsType.Reviews;
} & UserFriendsTagReviewsHrefArgs) | ({
    tagsType: TagsType.Lists;
} & UserFriendsTagListsHrefArgs))) | ({
    base: UserHrefBaseSlug.Followers;
} & UserFollowsHrefArgs) | ({
    base: UserHrefBaseSlug.Following;
} & UserFollowsHrefArgs) | ({
    base: UserHrefBaseSlug.Stats;
})))) | {
    root: true;
};
export declare enum HrefFilterSlug {
    Popular = "popular",
    For = "for",
    Rated = "rated",
    Upcoming = "upcoming",
    Decade = "decade",
    Year = "year",
    Like = "like",
    In = "in",
    Genre = "genre",
    Nanogenre = "nanogenre",
    Theme = "theme",
    MiniTheme = "mini-theme",
    On = "on",
    With = "with",
    By = "by",
    Size = "size",
    Page = "page"
}
export declare const HrefFilterSlugs: HrefFilterSlug[];
export declare const HrefFilterSlugsSet: Set<HrefFilterSlug>;
export declare const hrefFilterSlugToKey: (slug: string) => string;
export type HrefFilterProps = HrefSortOrPopularFilterProps<SortByFilter> & {
    for?: number | `${number}`;
    rated?: RatingFilter;
} & HrefTimespanFilterProps & {
    like?: string;
    in?: string;
    genre?: GenreFilter;
    nanogenre?: string;
    theme?: string;
    minitheme?: string;
    on?: StreamingServiceSlug;
    with?: RoleFilter;
    size?: SizeSlug;
    page?: number | `${number}`;
};
export {};
//# sourceMappingURL=href.d.ts.map