import { StatelessConfig, ApiHealth } from './types';
/**
 * The `Boolean` scalar type represents `true` or `false`.
 */
export declare type GqlBoolean = boolean;
/**
 * The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](http://en.wikipedia.org/wiki/IEEE_floating_point).
 */
export declare type GqlFloat = number;
/**
 * The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as "4") or integer (such as 4) input value will be accepted as an ID.
 */
export declare type GqlID = string;
/**
 * The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
 */
export declare type GqlInt = number;
/**
 * The `String`scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.
 */
export declare type GqlString = string;
/**
 * Standard [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) timestamp in UTC
 *
 * ### Example
 *
 * ```
 * 2020-08-04T23:43:27Z
 * ```
 */
export declare type GqlTime = string;
/**
 * Color theme the user prefers
 */
export declare enum GqlColorTheme {
    /**
     * Change to match where you're watching
     */
    PER_SERVICE = "PER_SERVICE",
    ANIME_SKIP_BLUE = "ANIME_SKIP_BLUE",
    VRV_YELLOW = "VRV_YELLOW",
    FUNIMATION_PURPLE = "FUNIMATION_PURPLE",
    CRUNCHYROLL_ORANGE = "CRUNCHYROLL_ORANGE"
}
/**
 * Which of the supported services the `EpisodeUrl` was created for. This is a simple enum that allows
 * for simple checks, but this data can also be pulled from the url in the case of UNKNOWN
 */
export declare enum GqlEpisodeSource {
    /**
     * Data came from an external source
     */
    UNKNOWN = "UNKNOWN",
    /**
     * Data is from <vrv.co>
     */
    VRV = "VRV",
    /**
     * Data is from <funimation.com>
     */
    FUNIMATION = "FUNIMATION"
}
/**
 * A user's role in the system. Higher roles allow a user write access to certain data that a normal
 * user would not. Some queries and mutations are only alloed by certain roles
 */
export declare enum GqlRole {
    /**
     * Highest role. Has super user access to all queries and mutations
     */
    DEV = "DEV",
    /**
     * Administrator role. Has some elevated permissions
     */
    ADMIN = "ADMIN",
    /**
     * Basic role. Has no elevated permissions
     */
    USER = "USER"
}
/**
 * The scope that a template applies to
 */
export declare enum GqlTemplateType {
    /**
     * The template is loaded for all episodes of a given show
     */
    SHOW = "SHOW",
    /**
     * The template is loaded for episodes of a given show where their season is included in `Template.seasons`
     */
    SEASONS = "SEASONS"
}
/**
 * Where a timestamp originated from
 */
export declare enum GqlTimestampSource {
    ANIME_SKIP = "ANIME_SKIP",
    BETTER_VRV = "BETTER_VRV"
}
/**
 * Account info that should only be accessible by the authorised user
 */
export interface GqlAccount {
    id: GqlID;
    createdAt: GqlTime;
    deletedAt?: GqlTime | undefined;
    /**
     * Unique string slug that is the easy to remember identifier
     */
    username: GqlString;
    email: GqlString;
    /**
     * Url to an image that is the user's profile picture
     */
    profileUrl: GqlString;
    /**
     * The linking object that associates a user to the shows they are admins of.
     *
     * > This data is also accessible on the `User` model. It has been added here for convienience
     */
    adminOfShows: Array<GqlShowAdmin>;
    /**
     * If the user's email is verified. Emails must be verified before the user can call a mutation
     */
    emailVerified: GqlBoolean;
    /**
     * The user's administrative role. Most users are `Role.USER`
     */
    role: GqlRole;
    /**
     * The user's preferences
     */
    preferences: GqlPreferences;
}
/**
 * The base model has all the fields you would expect a fully fleshed out item in the database would
 * have. It is used to track who create, updated, and deleted items
 */
export interface GqlBaseModel {
    /**
     * Unique, v4 UUID. When asked for an `id` of an object, use this field
     */
    id: GqlID;
    /**
     * Time that the item was created at
     */
    createdAt: GqlTime;
    /**
     * The user's `id` that created the item
     */
    createdByUserId: GqlID;
    /**
     * The entire user that created the item
     */
    createdBy: GqlUser;
    /**
     * Time that the item was updated at
     */
    updatedAt: GqlTime;
    /**
     * The user's `id` that last updated the item
     */
    updatedByUserId: GqlID;
    /**
     * The entire user that last updated the item
     */
    updatedBy: GqlUser;
    /**
     * Time that the item was updated at. If this value is present, the item is considered deleted
     */
    deletedAt?: GqlTime | undefined;
    /**
     * The user's `id` that deleted the item
     */
    deletedByUserId?: GqlID | undefined;
    /**
     * The entire user that deleted the item
     */
    deletedBy?: GqlUser | undefined;
}
/**
 * Basic information about an episode, including season, numbers, a list of timestamps, and urls that
 * it can be watched at
 */
export interface GqlEpisode {
    id: GqlID;
    createdAt: GqlTime;
    createdByUserId: GqlID;
    createdBy: GqlUser;
    updatedAt: GqlTime;
    updatedByUserId: GqlID;
    updatedBy: GqlUser;
    deletedAt?: GqlTime | undefined;
    deletedByUserId?: GqlID | undefined;
    deletedBy?: GqlUser | undefined;
    /**
     * The season number that this episode belongs to
     *
     * ### Examples:
     *
     * - "1"
     * - "1 Directors Cut"
     * - "2"
     * - "Movies"
     */
    season?: GqlString | undefined;
    /**
     * The episode number in the current season
     *
     * ### Examples:
     *
     * - "1"
     * - "2"
     * - "5.5"
     * - "OVA 1"
     */
    number?: GqlString | undefined;
    /**
     * The absolute episode number out of all the episodes of the show. Generally only regular episodes
     * should have this field
     */
    absoluteNumber?: GqlString | undefined;
    /**
     * The duration of the episode's first url, which can be used to calculate a suggested offset for new
     * episode urls. Episodes at different URLs have different branding intros, and that difference can
     * be computed using: `EpisodeUrl.duration - Episode.baseDuration`
     * Generally, this works because each service has it's own branding at the beginning of the show, not
     * at the end of it
     */
    baseDuration?: GqlFloat | undefined;
    /**
     * The episode's name
     */
    name?: GqlString | undefined;
    /**
     * The show that the episode belongs to
     */
    show: GqlShow;
    /**
     * The id of the show that the episode blongs to
     */
    showId: GqlID;
    /**
     * The list of current timestamps.
     *
     * Timestamps are apart apart of the `Episode` instead of the `EpisodeUrl` so that they can be shared
     * between urls and not need duplicate data
     */
    timestamps: Array<GqlTimestamp>;
    /**
     * The list of urls and services that the episode can be accessed from
     */
    urls: Array<GqlEpisodeUrl>;
    /**
     * If the episode is the source episode for a `Template`, this will resolve to that template
     */
    template?: GqlTemplate | undefined;
}
/**
 * Stores information about what where an episode can be watched from
 */
export interface GqlEpisodeUrl {
    /**
     * The url that would take a user to watch the `episode`.
     *
     * This url should be stripped of all query params.
     */
    url: GqlString;
    createdAt: GqlTime;
    createdByUserId: GqlID;
    createdBy: GqlUser;
    updatedAt: GqlTime;
    updatedByUserId: GqlID;
    updatedBy: GqlUser;
    /**
     * The length of the episode at this url. For more information on why this field exists, check out
     * the `Episode.baseDuration`. If an `Episode` does not have a duration, that `Episode` and this
     * `EpisodeUrl` should be given the same value, and the `EpisodeUrl.timestampsOffset` should be set to 0
     */
    duration?: GqlFloat | undefined;
    /**
     * How much a episode's timestamps should be offset for this `EpisodeUrl`, since different services
     * have different branding animations, leading to offsets between services. This field can be edited
     * to whatever, but it should be suggested to be `EpisodeUrl.duration - Episode.baseDuration`.
     * It can be positive or negative.
     */
    timestampsOffset?: GqlFloat | undefined;
    /**
     * The `Episode.id` that this url belongs to
     */
    episodeId: GqlID;
    /**
     * The `Episode` that this url belongs to
     */
    episode: GqlEpisode;
    /**
     * What service this url points to. This is computed when the `EpisodeUrl` is created
     */
    source: GqlEpisodeSource;
}
/**
 * Data required to create a new `Episode`. See `Episode` for a description of each field
 */
export interface GqlInputEpisode {
    /**
     * See `Episode.season`
     */
    season?: GqlString | undefined;
    /**
     * See `Episode.number`
     */
    number?: GqlString | undefined;
    /**
     * See `Episode.absoluteNumber`
     */
    absoluteNumber?: GqlString | undefined;
    /**
     * See `Episode.name`
     */
    name?: GqlString | undefined;
    /**
     * See `Episode.baseDuration`
     */
    baseDuration?: GqlFloat | undefined;
}
/**
 * Data required to create a new `EpisodeUrl`. See `EpisodeUrl` for a description of each field
 */
export interface GqlInputEpisodeUrl {
    url: GqlString;
    duration?: GqlFloat | undefined;
    timestampsOffset?: GqlFloat | undefined;
}
export interface GqlInputExistingTimestamp {
    /**
     * The id of the timestamp you want to modify
     */
    id: GqlID;
    /**
     * The new values for the timestamp
     */
    timestamp: GqlInputTimestamp;
}
/**
 * Data used to update a user's `Preferences`. See `Preferences` for a description of each field. If a
 * field is not passed or passed as `null`, it will leave the value as is and skip updating it
 */
export interface GqlInputPreferences {
    enableAutoSkip?: GqlBoolean | undefined;
    enableAutoPlay?: GqlBoolean | undefined;
    minimizeToolbarWhenEditing?: GqlBoolean | undefined;
    hideTimelineWhenMinimized?: GqlBoolean | undefined;
    colorTheme?: GqlColorTheme | undefined;
    skipBranding?: GqlBoolean | undefined;
    skipIntros?: GqlBoolean | undefined;
    skipNewIntros?: GqlBoolean | undefined;
    skipMixedIntros?: GqlBoolean | undefined;
    skipRecaps?: GqlBoolean | undefined;
    skipFiller?: GqlBoolean | undefined;
    skipCanon?: GqlBoolean | undefined;
    skipTransitions?: GqlBoolean | undefined;
    skipCredits?: GqlBoolean | undefined;
    skipNewCredits?: GqlBoolean | undefined;
    skipMixedCredits?: GqlBoolean | undefined;
    skipPreview?: GqlBoolean | undefined;
    skipTitleCard?: GqlBoolean | undefined;
}
/**
 * Data required to create a new `Show`. See `Show` for a description of each field
 */
export interface GqlInputShow {
    name: GqlString;
    originalName?: GqlString | undefined;
    website?: GqlString | undefined;
    image?: GqlString | undefined;
}
/**
 * Data required to create a new `ShowAdmin`. See `ShowAdmin` for a description of each field
 */
export interface GqlInputShowAdmin {
    showId: GqlID;
    userId: GqlID;
}
/**
 * Data required to create a new template. See `Template` for a description of each field
 */
export interface GqlInputTemplate {
    showId: GqlID;
    type: GqlTemplateType;
    seasons: Array<GqlString>;
    sourceEpisodeId: GqlID;
}
/**
 * Data required to modify the timestamps on a template
 */
export interface GqlInputTemplateTimestamp {
    templateId: GqlID;
    timestampId: GqlID;
}
/**
 * Data required to create a new `Timestamp`. See `Timestamp` for a description of each field
 */
export interface GqlInputTimestamp {
    at: GqlFloat;
    typeId: GqlID;
    source?: GqlTimestampSource | undefined;
}
export interface GqlInputTimestampOn {
    /**
     * The episode id the timestamp will be created on
     */
    episodeId: GqlID;
    /**
     * The new values for the timestamp
     */
    timestamp: GqlInputTimestamp;
}
/**
 * Data required to create a new `TimestampType`. See `TimestampType` for a description of each field
 */
export interface GqlInputTimestampType {
    name: GqlString;
    description: GqlString;
}
/**
 * When logging in with a password or refresh token, you can get new tokens and account info
 */
export interface GqlLoginData {
    /**
     * A JWT that should be used in the header of all requests: `Authorization: Bearer <authToken>`
     */
    authToken: GqlString;
    /**
     * A JWT used for the `loginRefresh` query to get new `LoginData`
     */
    refreshToken: GqlString;
    /**
     * The personal account information of the user that got authenticated
     */
    account: GqlAccount;
}
/**
 * Where all the user preferences are stored. This includes what timestamps the user doesn't want to
 * watch
 */
export interface GqlPreferences {
    id: GqlID;
    createdAt: GqlTime;
    updatedAt: GqlTime;
    deletedAt?: GqlTime | undefined;
    /**
     * The `User.id` that this preferences object belongs to
     */
    userId: GqlID;
    /**
     * The `User` that the preferences belong to
     */
    user: GqlUser;
    /**
     * Whether or not the user wants to automatically skip section. Default: `true`
     */
    enableAutoSkip: GqlBoolean;
    /**
     * Whether or not the user wants to auto-play the videos. Default: `true`
     */
    enableAutoPlay: GqlBoolean;
    /**
     * Whether or not the bottom toolbar with the video progress and play button is minimized after
     * inactivity while editing
     */
    minimizeToolbarWhenEditing: GqlBoolean;
    /**
     * When false, timeline is pinned to the bottom of the screen after inactivity. When true, it is
     * hidden completely
     */
    hideTimelineWhenMinimized: GqlBoolean;
    colorTheme: GqlColorTheme;
    /**
     * Whether or not the user whats to skip branding timestamps. Default: `true`
     */
    skipBranding: GqlBoolean;
    /**
     * Whether or not the user whats to skip regular intros. Default: `true`
     */
    skipIntros: GqlBoolean;
    /**
     * Whether or not the user whats to skip the first of an intro. Default: `false`
     */
    skipNewIntros: GqlBoolean;
    /**
     * Whether or not the user whats to kip intros that have plot progression rather than the standard animation. Default: `false`
     */
    skipMixedIntros: GqlBoolean;
    /**
     * Whether or not the user whats to skip recaps at the beginning of episodes. Default: `true`
     */
    skipRecaps: GqlBoolean;
    /**
     * Whether or not the user whats to skip filler content. Default: `true`
     */
    skipFiller: GqlBoolean;
    /**
     * Whether or not the user whats to skip canon content. Default: `false`
     */
    skipCanon: GqlBoolean;
    /**
     * Whether or not the user whats to skip commertial transitions. Default: `true`
     */
    skipTransitions: GqlBoolean;
    /**
     * Whether or not the user whats to skip credits/outros. Default: `true`
     */
    skipCredits: GqlBoolean;
    /**
     * Whether or not the user whats to skip the first of a credits/outro. Default: `false`
     */
    skipNewCredits: GqlBoolean;
    /**
     * Whether or not the user whats to skip credits/outros that have plot progression rather than the standard animation. Default: `false`
     */
    skipMixedCredits: GqlBoolean;
    /**
     * Whether or not to skip the next episode's preview. Default: `true`
     */
    skipPreview: GqlBoolean;
    /**
     * Whether or not to skip an episode's static title card. Default: `true`
     */
    skipTitleCard: GqlBoolean;
}
/**
 * A show containing a list of episodes and relevate links
 */
export interface GqlShow {
    id: GqlID;
    createdAt: GqlTime;
    createdByUserId: GqlID;
    createdBy: GqlUser;
    updatedAt: GqlTime;
    updatedByUserId: GqlID;
    updatedBy: GqlUser;
    deletedAt?: GqlTime | undefined;
    deletedByUserId?: GqlID | undefined;
    deletedBy?: GqlUser | undefined;
    /**
     * The show name
     *
     * ### Examples
     *
     * - "Death Note"
     * - "My Hero Academia"
     */
    name: GqlString;
    /**
     * The show's original Japanese name
     *
     * ### Examples
     *
     * - "Desu Nōto"
     * - "Boku no Hīrō Akademia"
     */
    originalName?: GqlString | undefined;
    /**
     * A link to the anime's official website
     */
    website?: GqlString | undefined;
    /**
     * A link to a show poster
     */
    image?: GqlString | undefined;
    /**
     * The list of admins for the show
     */
    admins: Array<GqlShowAdmin>;
    /**
     * All the episodes that belong to the show
     */
    episodes: Array<GqlEpisode>;
    /**
     * All the templates that belong to this show
     */
    templates: Array<GqlTemplate>;
    /**
     * How many seasons are associated with this show
     */
    seasonCount: GqlInt;
    /**
     * How many episodes are apart of this show
     */
    episodeCount: GqlInt;
}
/**
 * A list of users that have elevated permissions when making changes to a show, it's episodes, and
 * timestamps. Show admins are responsible for approving any changes that users might submit.
 *
 * If a user has the `ADMIN` or `DEV` roles, they do not need to be show admins to approve changes or
 * make changes directly. Likewise, if a show doesn't have an admin, the user that create the
 * show/episode will have temporary access to editing the data until someone becomes that shows admin.
 *
 * Admins can be created using the API and will soon come to the Anime Skip player/website.
 */
export interface GqlShowAdmin {
    id: GqlID;
    createdAt: GqlTime;
    createdByUserId: GqlID;
    createdBy: GqlUser;
    updatedAt: GqlTime;
    updatedByUserId: GqlID;
    updatedBy: GqlUser;
    deletedAt?: GqlTime | undefined;
    deletedByUserId?: GqlID | undefined;
    deletedBy?: GqlUser | undefined;
    /**
     * The `Show.id` that the admin has elevated privileges for
     */
    showId: GqlID;
    /**
     * The `Show` that the admin has elevated privileges for
     */
    show: GqlShow;
    /**
     * The `User.id` that the admin privileges belong to
     */
    userId: GqlID;
    /**
     * The `User` that the admin privileges belong to
     */
    user: GqlUser;
}
/**
 * When no timestamps exist for a specific episode, templates are setup to provide fallback timestamps
 */
export interface GqlTemplate {
    id: GqlID;
    createdAt: GqlTime;
    createdByUserId: GqlID;
    createdBy: GqlUser;
    updatedAt: GqlTime;
    updatedByUserId: GqlID;
    updatedBy: GqlUser;
    deletedAt?: GqlTime | undefined;
    deletedByUserId?: GqlID | undefined;
    deletedBy?: GqlUser | undefined;
    /**
     * The id of the show that this template is for
     */
    showId: GqlID;
    /**
     * The show that this template is for
     */
    show: GqlShow;
    /**
     * Specify the scope of the template, if it's for the entire show, or just for a set of seasons
     */
    type: GqlTemplateType;
    /**
     * When the template is for a set of seasons, this is the set of seasons it is applied to
     */
    seasons: Array<GqlString>;
    /**
     * The id of the episode used to create the template. All the timestamps are from this episode
     */
    sourceEpisodeId: GqlID;
    /**
     * The episode used to create the template. All the timestamps are from this episode
     */
    sourceEpisode: GqlEpisode;
    /**
     * The list of timestamps that are apart of this template
     */
    timestamps: Array<GqlTimestamp>;
    /**
     * The list of timestamp ids that are apart of this template. Since this is a many-to-many
     * relationship, this field will resolve quicker than `timestamps` since it doesn't have to do an
     * extra join
     *
     * This is useful when you already got the episode and timestamps, and you just need to know what
     * timestamps are apart of the template
     */
    timestampIds: Array<GqlID>;
}
/**
 * The many to many object that links a timestamp to a template
 */
export interface GqlTemplateTimestamp {
    templateId: GqlID;
    template: GqlTemplate;
    timestampId: GqlID;
    timestamp: GqlTimestamp;
}
/**
 * Episode info provided by a third party. See `Episode` for a description of each field.
 *
 * When creating data based on this type, fill out and post an episode, then timestamps based on the
 * data here. All fields will map 1 to 1 with the exception of `source`. Since a source belongs to a
 * episode for third party data, but belongs to timestamps in Anime Skip, the source should be
 * propogated down to each of the timestamps. This way when more timestamps are added, a episode can
 * have muliple timestamp sources.
 *
 * > Make sure to fill out the `source` field so that original owner of the timestamp is maintained
 */
export interface GqlThirdPartyEpisode {
    /**
     * The Anime Skip `Episode.id` when the `source` is `ANIME_SKIP`, otherwise this is null
     */
    id?: GqlID | undefined;
    season?: GqlString | undefined;
    number?: GqlString | undefined;
    absoluteNumber?: GqlString | undefined;
    baseDuration?: GqlFloat | undefined;
    name?: GqlString | undefined;
    source?: GqlTimestampSource | undefined;
    timestamps: Array<GqlThirdPartyTimestamp>;
    /**
     * The id of the show from the third party
     */
    showId: GqlString;
    show: GqlThirdPartyShow;
}
export interface GqlThirdPartyShow {
    name: GqlString;
    createdAt?: GqlTime | undefined;
    updatedAt?: GqlTime | undefined;
}
export interface GqlThirdPartyTimestamp {
    /**
     * The Anime Skip `Timestamp.id` when the `Episode.source` is `ANIME_SKIP`, otherwise this is null
     */
    id?: GqlID | undefined;
    /**
     * The actual time the timestamp is at
     */
    at: GqlFloat;
    /**
     * The id specifying the type the timestamp is
     */
    typeId: GqlID;
    type: GqlTimestampType;
}
export interface GqlTimestamp {
    id: GqlID;
    createdAt: GqlTime;
    createdByUserId: GqlID;
    createdBy: GqlUser;
    updatedAt: GqlTime;
    updatedByUserId: GqlID;
    updatedBy: GqlUser;
    deletedAt?: GqlTime | undefined;
    deletedByUserId?: GqlID | undefined;
    deletedBy?: GqlUser | undefined;
    /**
     * The actual time the timestamp is at
     */
    at: GqlFloat;
    source: GqlTimestampSource;
    /**
     * The id specifying the type the timestamp is
     */
    typeId: GqlID;
    /**
     * The type the timestamp is. Thid field is a constant string so including it has no effect on
     * performance or query complexity.
     */
    type: GqlTimestampType;
    /**
     * The `Episode.id` that the timestamp belongs to
     */
    episodeId: GqlID;
    /**
     * The `Episode` that the timestamp belongs to
     */
    episode: GqlEpisode;
}
/**
 * The type a timestamp can be. This table rarely changes so the values fetched can either be hard
 * coded or fetch occasionaly. Anime Skip website and web extension use hardcoded maps to store this
 * data, but a third party might want to fetch and cache this instead since you won't know when Anime
 * Skip adds timestamps
 */
export interface GqlTimestampType {
    id: GqlID;
    createdAt: GqlTime;
    createdByUserId: GqlID;
    createdBy: GqlUser;
    updatedAt: GqlTime;
    updatedByUserId: GqlID;
    updatedBy: GqlUser;
    deletedAt?: GqlTime | undefined;
    deletedByUserId?: GqlID | undefined;
    deletedBy?: GqlUser | undefined;
    /**
     * The name of the timestamp type
     */
    name: GqlString;
    /**
     * The description for what this type represents
     */
    description: GqlString;
}
export interface GqlUpdatedTimestamps {
    created: Array<GqlTimestamp>;
    updated: Array<GqlTimestamp>;
    deleted: Array<GqlTimestamp>;
}
/**
 * Information about a user that is public. See `Account` for a description of each field
 */
export interface GqlUser {
    id: GqlID;
    createdAt: GqlTime;
    deletedAt?: GqlTime | undefined;
    username: GqlString;
    profileUrl: GqlString;
    adminOfShows: Array<GqlShowAdmin>;
}
export declare type StatelessClient = ReturnType<typeof createStatelessClient>;
export declare function createStatelessClient({ baseUrl, clientId, fetch, }: StatelessConfig): {
    account: (query: string, config?: RequestInit | undefined) => Promise<GqlAccount>;
    login: (query: string, variables?: {
        usernameEmail: GqlString;
        passwordHash: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlLoginData>;
    loginRefresh: (query: string, variables?: {
        refreshToken: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlLoginData>;
    findUser: (query: string, variables?: {
        userId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlUser>;
    findUserByUsername: (query: string, variables?: {
        username: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlUser>;
    findShow: (query: string, variables?: {
        showId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlShow>;
    searchShows: (query: string, variables?: {
        search?: GqlString | undefined;
        offset?: GqlInt | undefined;
        limit?: GqlInt | undefined;
        sort?: GqlString | undefined;
    } | undefined, config?: RequestInit | undefined) => Promise<Array<GqlShow>>;
    findShowAdmin: (query: string, variables?: {
        showAdminId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlShowAdmin>;
    findShowAdminsByShowId: (query: string, variables?: {
        showId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<Array<GqlShowAdmin>>;
    findShowAdminsByUserId: (query: string, variables?: {
        userId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<Array<GqlShowAdmin>>;
    recentlyAddedEpisodes: (query: string, variables?: {
        limit?: GqlInt | undefined;
        offset?: GqlInt | undefined;
    } | undefined, config?: RequestInit | undefined) => Promise<Array<GqlEpisode>>;
    findEpisode: (query: string, variables?: {
        episodeId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlEpisode>;
    findEpisodesByShowId: (query: string, variables?: {
        showId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<Array<GqlEpisode>>;
    searchEpisodes: (query: string, variables?: {
        search?: GqlString | undefined;
        showId?: GqlID | undefined;
        offset?: GqlInt | undefined;
        limit?: GqlInt | undefined;
        sort?: GqlString | undefined;
    } | undefined, config?: RequestInit | undefined) => Promise<Array<GqlEpisode>>;
    findEpisodeByName: (query: string, variables?: {
        name: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<Array<GqlThirdPartyEpisode>>;
    findEpisodeUrl: (query: string, variables?: {
        episodeUrl: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlEpisodeUrl>;
    findEpisodeUrlsByEpisodeId: (query: string, variables?: {
        episodeId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<Array<GqlEpisodeUrl>>;
    findTimestamp: (query: string, variables?: {
        timestampId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTimestamp>;
    findTimestampsByEpisodeId: (query: string, variables?: {
        episodeId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<Array<GqlTimestamp>>;
    findTimestampType: (query: string, variables?: {
        timestampTypeId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTimestampType>;
    allTimestampTypes: (query: string, config?: RequestInit | undefined) => Promise<Array<GqlTimestampType>>;
    findTemplate: (query: string, variables?: {
        templateId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTemplate>;
    findTemplatesByShowId: (query: string, variables?: {
        showId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<Array<GqlTemplate>>;
    findTemplateByDetails: (query: string, variables?: {
        episodeId?: GqlID | undefined;
        showName?: GqlString | undefined;
        season?: GqlString | undefined;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTemplate>;
    createAccount: (query: string, variables?: {
        username: GqlString;
        email: GqlString;
        passwordHash: GqlString;
        recaptchaResponse: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlLoginData>;
    changePassword: (query: string, variables?: {
        oldPassword: GqlString;
        newPassword: GqlString;
        confirmNewPassword: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlLoginData>;
    resendVerificationEmail: (query: string, variables?: {
        recaptchaResponse: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlBoolean | undefined>;
    verifyEmailAddress: (query: string, variables?: {
        validationToken: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlAccount>;
    requestPasswordReset: (query: string, variables?: {
        recaptchaResponse: GqlString;
        email: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlBoolean>;
    resetPassword: (query: string, variables?: {
        passwordResetToken: GqlString;
        newPassword: GqlString;
        confirmNewPassword: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlLoginData>;
    deleteAccountRequest: (query: string, variables?: {
        passwordHash: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlAccount>;
    deleteAccount: (query: string, variables?: {
        deleteToken: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlAccount>;
    savePreferences: (query: string, variables?: {
        preferences: GqlInputPreferences;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlPreferences>;
    createShow: (query: string, variables?: {
        showInput: GqlInputShow;
        becomeAdmin: GqlBoolean;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlShow>;
    updateShow: (query: string, variables?: {
        showId: GqlID;
        newShow: GqlInputShow;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlShow>;
    deleteShow: (query: string, variables?: {
        showId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlShow>;
    createShowAdmin: (query: string, variables?: {
        showAdminInput: GqlInputShowAdmin;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlShowAdmin>;
    deleteShowAdmin: (query: string, variables?: {
        showAdminId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlShowAdmin>;
    createEpisode: (query: string, variables?: {
        showId: GqlID;
        episodeInput: GqlInputEpisode;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlEpisode>;
    updateEpisode: (query: string, variables?: {
        episodeId: GqlID;
        newEpisode: GqlInputEpisode;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlEpisode>;
    deleteEpisode: (query: string, variables?: {
        episodeId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlEpisode>;
    createEpisodeUrl: (query: string, variables?: {
        episodeId: GqlID;
        episodeUrlInput: GqlInputEpisodeUrl;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlEpisodeUrl>;
    deleteEpisodeUrl: (query: string, variables?: {
        episodeUrl: GqlString;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlEpisodeUrl>;
    updateEpisodeUrl: (query: string, variables?: {
        episodeUrl: GqlString;
        newEpisodeUrl: GqlInputEpisodeUrl;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlEpisodeUrl>;
    createTimestamp: (query: string, variables?: {
        episodeId: GqlID;
        timestampInput: GqlInputTimestamp;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTimestamp>;
    updateTimestamp: (query: string, variables?: {
        timestampId: GqlID;
        newTimestamp: GqlInputTimestamp;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTimestamp>;
    deleteTimestamp: (query: string, variables?: {
        timestampId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTimestamp>;
    updateTimestamps: (query: string, variables?: {
        create: Array<GqlInputTimestampOn>;
        update: Array<GqlInputExistingTimestamp>;
        delete_: Array<GqlID>;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlUpdatedTimestamps>;
    createTimestampType: (query: string, variables?: {
        timestampTypeInput: GqlInputTimestampType;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTimestampType>;
    updateTimestampType: (query: string, variables?: {
        timestampTypeId: GqlID;
        newTimestampType: GqlInputTimestampType;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTimestampType>;
    deleteTimestampType: (query: string, variables?: {
        timestampTypeId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTimestampType>;
    createTemplate: (query: string, variables?: {
        newTemplate: GqlInputTemplate;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTemplate>;
    updateTemplate: (query: string, variables?: {
        templateId: GqlID;
        newTemplate: GqlInputTemplate;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTemplate>;
    deleteTemplate: (query: string, variables?: {
        templateId: GqlID;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTemplate>;
    addTimestampToTemplate: (query: string, variables?: {
        templateTimestamp: GqlInputTemplateTimestamp;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTemplateTimestamp>;
    removeTimestampFromTemplate: (query: string, variables?: {
        templateTimestamp: GqlInputTemplateTimestamp;
    } | undefined, config?: RequestInit | undefined) => Promise<GqlTemplateTimestamp>;
    healthCheck: () => Promise<ApiHealth>;
};