entry => {
                                countOfObserversThatHaveReported++;
                                ob.unobserve(entry.target); // don't want to keep getting them, or leak observers
                                var isBubble = !!entry.target.closest(
                                    ".bloom-textOverPicture"
                                );
                                let overflowing = entry.intersectionRatio < 1;
                                if (overflowing && isBubble) {
                                    // We want to be less aggressive about putting scroll bars on bubbles.
                                    // Most of the time, a bubble is very carefully sized to just fit the
                                    // text. But the intersection observer wants it to fit a certain amount
                                    // of white space as well. We want a scroll bar if it's overflowing
                                    // really badly for some reason, but that's much more the exception
                                    // than the rule, so better a little clipping when the bubble is badly
                                    // sized than a scroll bar that isn't needed in one that is just right.
                                    // Example: a bubble which appears to fit perfectly, 3 lines high:
                                    // its clientHeight is 72; containing bloom-editable's is 59;
                                    // lineHeight is 24px. IntersectionRatio computes to 59/72,
                                    // which makes the 'overflow' 13. A ratio of 0.5 as we originally
                                    // proposed would give us a scroll bar we don't want.
                                    let maxBubbleOverflowLineFraction = 0.6;
                                    if (
                                        entry.target !=
                                            entry.target.parentElement
                                                ?.firstElementChild ||
                                        entry.target !=
                                            entry.target.parentElement!
                                                .lastElementChild
                                    ) {
                                        // Bubbles are center-aligned vertically. If this is not the only
                                        // child,the first and last will overflow above and below by about the
                                        // same amount. So we're only really looking at half the overflow on this para,
                                        // and should reduce the threshold.
                                        maxBubbleOverflowLineFraction /= 2;
                                    }
                                    const overflow =
                                        (1 - entry.intersectionRatio) *
                                        entry.target.clientHeight;
                                    const lineHeightPx = window.getComputedStyle(
                                        entry.target
                                    ).lineHeight;
                                    const lineHeight = parseFloat(
                                        // remove the trailing "px"
                                        lineHeightPx.substring(
                                            0,
                                            lineHeightPx.length - 2
                                        )
                                    );
                                    overflowing =
                                        overflow >
                                        lineHeight *
                                            maxBubbleOverflowLineFraction;
                                }
                                if (
                                    overflowing &&
                                    scrollBlocks.indexOf(
                                        entry.target.parentElement!
                                    ) < 0
                                ) {
                                    scrollBlocks.push(
                                        entry.target.parentElement!
                                    );
                                    // remove classes incompatible with nicescroll
                                    const group = entry.target.parentElement!
                                        .parentElement!;
                                    group.classList.remove(
                                        "bloom-vertical-align-center"
                                    );
                                    group.classList.remove(
                                        "bloom-vertical-align-bottom"
                                    );
                                    if (isBubble) {
                                        // This is a way of forcing it not to be display-flex, which doesn't
                                        // work with the nice-scroll-bar library we're using.
                                        // That library messes with the element style, so it seemed safer
                                        // not to do that myself.
                                        entry.target.parentElement!.classList.add(
                                            "scrolling-bubble"
                                        );
                                    }
                                }
                                if (
                                    countOfObserversThatHaveReported ==
                                    countOfObserversExpectedToReport
                                ) {
                                    // configure nicescroll...ideally only once for all of them
                                    $(scrollBlocks).niceScroll({
                                        autohidemode: false,
                                        cursorwidth: "12px",
                                        cursorcolor: "#000000",
                                        cursoropacitymax: 0.1,
                                        cursorborderradius: "12px" // Make the corner more rounded than the 5px default.
                                    });
                                    scrollBlocks = []; // Just in case it's possible to get callbacks before we created them all.
                                }
                            }


i => {
        return "&#" + i.charCodeAt(0) + ";";
    }


// BloomPlayer takes a URL param that directs it to Bloom book.
// (See comment on sourceUrl for exactly how.)
// It displays pages from the book and allows them to be turned by dragging.
// On a wide screen, an option may be used to show the next and previous pages
// beside the current one.
interface IProps {
    // Url of the bloom book (folder). Should be a valid, well-formed URL
    // e.g. any special chars in the path or book title should be appropriately encoded
    // e.g. if title is C#, url should be http://localhost:8089/bloom/C:/PathToTemp/PlaceForStagingBook/C%23
    url: string;
    landscape: boolean; // whether viewing as landscape or portrait
    showContextPages?: boolean;
    // ``paused`` allows the parent to control pausing of audio. We expect we may supply
    // a click/touch event callback if needed to support pause-on-touch.
    paused?: boolean;
    preferredUiLanguages: string[];

    pageStylesAreNowInstalled: () => void;
    onContentClick?: (event: any) => void;

    // reportBookProperties is called when book loaded enough to determine these properties.
    // Some of this is probably obsolete, since if the player is embedded in a iframe as we currently
    // require, only the containing BloomPlayerControls can make use of it. However, it's just
    // possible we might want it if we end up with rotation-related controls. Note that the
    // same information is made available via postMessage if the control's window has a parent.
    reportBookProperties?: (properties: {
        landscape: boolean;
        canRotate: boolean;
        preferredLanguages: string[];
        pageNumbers: string[]; // one per page, from data-page-number; some empty
    }) => void;

    // 'controlsCallback' feeds information about the book's contents and other things
    /// BloomPlayerControls needs back to it.
    // So far:
    // - the book's languages for the LanguageMenu to use
    // - whether the book has image descriptions or not.
    controlsCallback?: (
        bookLanguages: LangData[],
        bookHasImageDescriptions: boolean,
        // Provides the client a way to switch page numbers. It would feel more natural and React-y to
        // just pass current page number to bloom-player-controls as a property, but I don't think regenerating the whole
        // bloom-player-core to switch page numbers is a great idea.
        setCurrentPage?: (pageNo: number) => void
    ) => void;

    // A callback the client may supply to be notified whether navigation buttons are being hidden for this page.
    hidingNavigationButtonsCallback?: (hiding: boolean) => void;

    // Allows the core to inform the controls that we have been forced to pause.
    // We use this when trying to play initially and that playback fails,
    // usually because the browser doesn't think the user has interacted with the page.
    // We set it false if we can detect that the user interacted, e.g., by clicking next.
    // Though we are no longer forced to be paused, we will stay paused unless the user
    // indicates he wants sound.
    // See BL-8864.
    setForcedPausedCallback?: (paused: boolean) => void;

    // Set by BloomPlayerControls -> ControlBar -> LanguageMenu
    // Changing this should modify bloom-visibility-code-on stuff in the DOM.
    activeLanguageCode: string;

    useOriginalPageSize?: boolean;

    reportPageProperties?: (properties: {
        hasAudio: boolean;
        hasMusic: boolean;
        hasVideo: boolean;
    }) => void;

    locationOfDistFolder: string;

    // may be "largeOutsideButtons" or "smallOutsideButtons" or empty.
    outsideButtonPageClass: string;

    extraClassNames?: string;

    shouldReadImageDescriptions: boolean;

    imageDescriptionCallback: (inImageDescription: boolean) => void;

    // A callback the client may provide in order to be notified when the current page changes.
    pageChanged?: (n: number) => void;
}


interface IState {
    pages: string[]; // of the book. First and last are empty in context mode.
    pageIdToIndexMap: {}; // map from page id to page index

    // concatenated stylesheets the book references or embeds.
    // Make sure these are only set once per book or else
    // it wreaks havoc on scoped styles. See BL-9504.
    styleRules: string;

    importedBodyAttributes: {};

    // indicates current page, though typically not corresponding to the page
    // numbers actually on the page. This is an index into pages, and in context
    // mode it's the index of the left context page, not the main page.
    currentSwiperIndex: number;
    isLoading: boolean;
    loadFailed: boolean;
    loadErrorHtml: string;

    //When in touch mode (in chrome debugger at least), a touch on a navigation button
    //causes a click to be raised after the onTouchEnd(). This would normally try and
    //toggle the app bar. So we have onTouchStart() set this to true and then set to
    // false in the onClick handler. Sigh.
    ignorePhonyClick: boolean;

    // True if finishUp has completed when isNewBook is true.
    // I couldn't find any other way to know if the change in the landscape prop
    // should trigger a load of the current slide. Without this, we were trying
    // to load the initial slide multiple times when a book was landscape when
    // it was loaded the first time.
    isFinishUpForNewBookComplete: boolean;

    // Works in tandem with props.setForcedPausedCallback. If true, we need to call the callback
    // whenever something happens that would end the forced pause.
    // True represents a state where we wanted to be playing but cannot (see setPausedCallback).
    // If the user interacts, which we detect as anything that makes us change page,
    // we're no longer in a FORCED pause, though we may still be paused.
    inPauseForced: boolean;
}


interface IPlayerPageOptions {
    hideNavigation?: boolean;
}


export enum PlaybackMode {
    NewPage, // starting a new page ready to play
    NewPageMediaPaused, // starting a new page in the "paused" state
    VideoPlaying, // video is playing
    VideoPaused, // video is paused
    AudioPlaying, // narration and/or animation are playing (or possibly finished)
    AudioPaused, // narration and/or animation are paused
    MediaFinished // video, narration, and/or animation has played (possibly no media to play)
    // Note that music can be playing when the state is either AudioPlaying or MediaFinished.
}


public componentDidMount() {
        LocalizationManager.setUp();

        window.addEventListener("focus", () => this.handleWindowFocus());
        window.addEventListener("blur", () => this.handleWindowBlur());

        // To get this to fire consistently no matter where the focus is,
        // we have to attach to the document itself. No level of react component
        // seems to work (using the OnKeyDown prop). So we use good ol'-fashioned js.
        document.addEventListener("keydown", e =>
            this.handleDocumentLevelKeyDown(e)
        );
        // March 2020 - Andrew/JohnH got confused about this line because 1) we don't actually *know* the
        // previous props & state, so it's a bit bogus (but it does work), and 2) when we remove it
        // everything still works (but there could well be some state that we didn't test). So we're leaving
        // it in.
        this.componentDidUpdate(this.props, this.state);
        const host = getQueryStringParamAndUnencode("host");
        if (host === "bloomdesktop") {
            // needed only for GeckoFx60. (We hope no one else is still running FF 60!)
            // To test this in storybook:
            // - use the "Activity that leads to FF60 split page";
            // - use Firefox 60, initially you should see the problem when advancing to second page
            // - inspect and add "&host=bloomdesktop" to the source of the storybook iframe to see the fix.
            // or, of course, you can try it actually in Bloom desktop.
            setTimeout(() => this.repairFF60Offset(), 2000);
        }
    }


private handleWindowFocus() {
        const readDuration = localStorage.getItem(kLocalStorageDurationKey);
        const savedBookUrl = localStorage.getItem(kLocalStorageBookUrlKey);

        if (readDuration && savedBookUrl == this.sourceUrl) {
            this.bookInteraction.beginReadTime =
                Date.now() - parseInt(readDuration, 10);
        }
    }


private handleWindowBlur() {
        const readDuration = Date.now() - this.bookInteraction.beginReadTime;

        localStorage.setItem(kLocalStorageDurationKey, readDuration.toString());
        localStorage.setItem(kLocalStorageBookUrlKey, this.sourceUrl);
    }


// This horrible hack attempts to fix the worst effects of BL-8900. Basically, something inside
// a widget iframe sometimes causes the wrapper that holds the whole collection of pages to scroll
// over to be out of position. It appears to be related to an unknown bug in FF60...a very nasty one
// since anything happening inside an iframe should not be able to affect its size, position, or
// anything outside it (except with the deliberate cooperation of the host page). We have not found
// any good way to stop it happening, but this basically compensates for it and puts the current page
// back where it belongs. Our theory is that the problem occurs when the activity finishes loading,
// typically sometime after the page before it becomes the 'current' page and the activity itself is
// therefore the 'next' page and no longer blocked by laziness.
// Observed cases take about 2s for the problem to appear on a fast computer
// with a good internet. To be fairly sure of catching it if it happens, but not keep using power
// doing this forever, we monitor for it for 30s.
// Note that the initial call that starts this checking process only happens if we are invoked
// from bloomdesktop. Otherwise, this function will never be called at all.
private repairFF60Offset() {
        try {
            let wrapper = document.getElementsByClassName(
                "swiper-wrapper"
            )[0] as HTMLElement;
            let current = document.getElementsByClassName(
                "swiper-slide-active"
            )[0] as HTMLElement;
            if (wrapper && current && this.msToContinueFF60RepairChecks > 0) {
                let error =
                    wrapper.parentElement!.getBoundingClientRect().left -
                    current.getBoundingClientRect().left;
                if (Math.abs(error) > 1) {
                    const scale =
                        wrapper.getBoundingClientRect().width /
                        wrapper.offsetWidth;
                    const paddingPx = wrapper.style.paddingLeft;
                    const padding =
                        paddingPx.length === 0
                            ? 0
                            : parseFloat(
                                  paddingPx.substring(0, paddingPx.length - 2)
                              );
                    wrapper.style.paddingLeft = padding + error / scale + "px";
                }
            }
        } catch (_) {
            // If something goes wrong with this...oh well, we tried, and on most
            // browsers we didn't need it anyway.
        }
        this.msToContinueFF60RepairChecks -= 100;
        setTimeout(() => this.repairFF60Offset(), 100);
    }


private collectBodyAttributes(originalBodyElement: HTMLBodyElement) {
        // When working on the ABC-BARMM branding/XMatter pack, we discovered that the classes on the
        // Desktop body element were not getting passed into bloom-player.
        // Unfortunately, just putting them on the body element doesn't work because we are using
        // scoped styles. So we put them on the div.bloomPlayer-page (and then we have to adjust the rules
        // so they'll work there).
        // Other xmatter uses other info than classes. E.g. Kyrgystan uses the data-bookshelfurlkey attribute
        // to control the background color.

        // convert from the NamedNodeMap to a simple object:
        var x = {};
        for (var i = 0; i < originalBodyElement.attributes.length; i++) {
            x[
                originalBodyElement.attributes.item(i)!.nodeName
            ] = originalBodyElement.attributes.item(i)!.nodeValue;
        }
        this.setState({
            importedBodyAttributes: x
        });
    }


private HandleLoadingError(axiosError: any) {
        const errorMessage = axiosError.message as string;
        // Note: intentionally no bothering to add this to the l10n load, at this time.
        let msg = `<p>There was a problem displaying this book: ${errorMessage}<p>`; // just show the raw thing
        // If it's a file:/// url, we're probably on an Android, and something
        // went wrong with unpacking it, or it is corrupt. This typically results in an error
        // message that is NOT a 404 but IS reported, unhelpfully, as a "Network Error" (BL-7813).
        // A file:/// url can't possibly be a network error, so the "part of the book is missing"
        // error is at least a little more helpful, maybe to the user, and certainly to a developer
        // trying to fix the problem, especially if the user reports the problem URL.
        const localFileMissing =
            axiosError.config &&
            axiosError.config.url &&
            axiosError.config.url.startsWith("file://");
        if (localFileMissing || axiosError.message.indexOf("404") >= 0) {
            msg = "
This book (or some part of it) was not found.
";
            if (axiosError.config && axiosError.config.url) {
                msg += `
${htmlEncode(
                    axiosError.config.url
                )}
`;
            }
        }
        this.setState({
            isLoading: false,
            loadFailed: true,
            loadErrorHtml: msg
        });
    }


// This function, the rest of the work we need to do, will be executed after we attempt
// to retrieve questions.json and either get it and convert it into extra pages,
// or fail to get it and make no changes.
// We also call this method when changing the language, but we only want it to update the swiper content
private async finishUp(isNewBook: boolean = true) {
        this.finishUpCalled = true;

        // assemble the page content list
        if (!this.htmlElement) {
            return;
        }
        const pages = this.htmlElement.getElementsByClassName("bloom-page");
        const swiperContent: string[] = [];
        if (this.props.showContextPages) {
            swiperContent.push(""); // blank page to fill the space left of first.
        }
        if (isNewBook) {
            this.bookInfo.totalNumberedPages = 0;
            this.bookInfo.questionCount = 0;
            this.activityManager.collectActivityContextForBook(pages);
            this.bookInteraction.clearPagesShown();
            this.music.processAllMusicForBook(pages);
        }

        const bookLanguages = this.bookInfo.getPreferredTranslationLanguages();
        const usingDefaultLang =
            bookLanguages[0] === this.props.activeLanguageCode ||
            !this.props.activeLanguageCode;

        const pageMap = {};

        for (let i = 0; i < pages.length; i++) {
            const page = pages[i] as HTMLElement;
            const pageId = page.getAttribute("id");
            if (pageId) {
                pageMap[pageId] = i;
            }
            const landscape = this.setPageSizeClass(page);
            // this used to be done for us by react-slick, but swiper does not.
            // Since it's used by at least page-api code, it's easiest to just stick it in.
            page.setAttribute("data-index", i.toString(10));
            // Now we have all the information we need to call reportBookProps if it is set.
            if (i === 0 && this.props.reportBookProperties) {
                // Informs containing react controls (in the same frame)
                this.props.reportBookProperties({
                    landscape,
                    canRotate: this.bookInfo.canRotate,
                    preferredLanguages: bookLanguages,
                    // We pass these up to the client, typically for use in the page number control.
                    // This allows the page numbers it shows as labels to reflect the actual page numbers shown on the
                    // page, which typically don't correspond to the page index, since xmatter pages are not numbered.
                    pageNumbers: Array.from(pages).map(
                        p => p.getAttribute("data-page-number") ?? ""
                    )
                });
            }
            if (isNewBook) {
                this.fixRelativeUrls(page);
                // possibly more efficient to look for attribute data-page-number,
                // but due to a bug (BL-7303) many published books may have that on back-matter pages.
                const hasPageNum = page.classList.contains("numberedPage");
                if (hasPageNum) {
                    this.indexOflastNumberedPage =
                        i + (this.props.showContextPages ? 1 : 0);
                    this.bookInfo.totalNumberedPages++;
                }
                if (
                    page.getAttribute("data-analyticscategories") ===
                    "comprehension"
                ) {
                    // Note that this will count both new-style question pages,
                    // and ones generated from old-style json.
                    this.bookInfo.questionCount++;
                }
            }
            this.showOrHideTitle2(page, usingDefaultLang);
            swiperContent.push(page.outerHTML);

            // look for activities on this page
            this.activityManager.processPage(this.urlPrefix, page);
        }
        if (this.props.showContextPages) {
            swiperContent.push(""); // blank page to fill the space right of last.
        }
        if (isNewBook) {
            const head = this.htmlElement.getElementsByTagName("head")[0];
            this.bookInfo.setSomeBookInfoFromHead(head); // prep for reportBookOpened()
            const body = this.htmlElement.getElementsByTagName("body")[0];
            if (this.metaDataObject) {
                this.bookInfo.setSomeBookInfoFromMetadata(
                    this.metaDataObject,
                    body
                );
                this.reportBookOpened(body);
            }
            if (this.props.controlsCallback) {
                const languages = LangData.createLangDataArrayFromDomAndMetadata(
                    body,
                    this.metaDataObject
                );
                this.hasImageDescriptions = doesBookHaveImageDescriptions(body);
                // Tell BloomPlayerControls which languages are available for the Language Menu
                // and whether or not to bother with the readImageDescriptions toggle.
                this.props.controlsCallback(
                    languages,
                    this.hasImageDescriptions,
                    (pageNumber: number) => {
                        this.swiperInstance?.slideTo(pageNumber);
                    }
                );
            }
        }

        // Make sure you only set state.styleRules once per book.
        // Otherwise, it wreaks havoc on scoped styles. See BL-9504.
        if (isNewBook) {
            const combinedStyle = await this.assembleStyleSheets(
                this.htmlElement
            );
            // assembleStyleSheets takes a while, fetching stylesheets. We can't render properly until
            // we get them, so we wait for the results and then make all the state changes in one go
            // to minimize renderings. (Because all this is happening asynchronously, not within the
            // original componentDidUpdate method call, each setState results in an immediate render.)
            this.setState({
                pages: swiperContent,
                pageIdToIndexMap: pageMap,
                styleRules: combinedStyle,
                isLoading: false
            });
        } else {
            this.setState({
                pages: swiperContent,
                isLoading: false
            });
        }

        this.props.pageStylesAreNowInstalled();
        // A pause hopefully allows the document to become visible before we
        // start playing any audio or movement on the first page.
        // Also gives time for the first page element and the buttons we want
        // to mess with here to actually get created in the document.
        // Note: typically in Chrome we won't actually start playing, because
        // of a rule that the user must interact with the document first.
        if (isNewBook) {
            window.setTimeout(() => {
                this.setState({ isFinishUpForNewBookComplete: true });
                this.setIndex(0);
                this.showingPage(0);
                // This allows a user to tab to the prev/next buttons, and also makes the focus() call work
                const nextButton = document.getElementsByClassName(
                    "swiper-button-next"
                )[0] as HTMLElement;
                const prevButton = document.getElementsByClassName(
                    "swiper-button-prev"
                )[0] as HTMLElement;

                prevButton?.setAttribute("tabindex", "4");
                nextButton?.setAttribute("tabindex", "5");
                // The most likely thing the user wants to do next, but also,
                // we need to focus something in the reader to make the arrow keys
                // work immediately.
                nextButton?.focus();
            }, 500);
        } else {
            if (BloomPlayerCore.currentPage) {
                // We need to replace the old currentPage with the corresponding one created from the updated content.
                window.setTimeout(() => {
                    BloomPlayerCore.currentPage = this.getPageAtSwiperIndex(
                        BloomPlayerCore.currentPageIndex
                    );
                }, 200);
            }
        }
    }


// If a book is displayed in its original language, the author may well want to also see a title
// in the corresponding national language. Typically default rules or author styles will make
// the two titles appropriate sizes.
// When the user selects a different language, showing the published national language as well is
// less appropriate. It may not be the national language of any country where the chosen language
// is spoken. Worse, the book may have been published in a monolingual collection, where the
// vernacular and national languages are the same. When a different language is chosen,
// what was originally a single, possibly very large, title in the book's only language
// suddenly becomes a (possibly smaller) title in the chosen language followed by a possibly
// larger one in the original language (previously marked both bloom-content1 and
// bloom-contentNational1, now with just the second class making it visible).
// We decided (BL-9256) that Title-On-Cover should not display in the national language
// unless we are displaying the book's default language or unless the national language IS
// the main one we're showing (that is, it has bloom-content1 as well as bloom-contentNational1).
//
// Don't be tempted to achieve this by returning conditionally created rules from assembleStyleSheets.
// That was our original implementation, but if state.styleRules gets set more than once for a book,
// it wreaks havoc on scoped styles. See BL-9504.
private showOrHideTitle2(page: Element, show: boolean) {
        if (show) {
            page.querySelectorAll(
                ".Title-On-Cover-style.bloom-contentNational1, .Title-On-Title-Page-style.bloom-contentNational1"
            ).forEach(title2Element => {
                title2Element.classList.remove("do-not-display");
            });
        } else {
            page.querySelectorAll(
                ".Title-On-Cover-style.bloom-contentNational1:not(.bloom-content1), .Title-On-Title-Page-style.bloom-contentNational1:not(.bloom-content1)"
            ).forEach(title2Element => {
                title2Element.classList.add("do-not-display");
            });
        }
    }


private localizeOnce() {
        // We want to localize once and only once after pages has been set and assembleStyleSheets has happened.
        if (
            !this.isPagesLocalized &&
            this.state.pages !== this.initialPages &&
            this.state.styleRules !== this.initialStyleRules
        ) {
            LocalizationManager.localizePages(
                document.body,
                this.bookInfo.getPreferredTranslationLanguages()
            );
            this.isPagesLocalized = true;
        }
    }


private showReplayButton(pageVideoData: IPageVideoComplete | undefined) {
        if (!pageVideoData?.video || !pageVideoData!.page) {
            return; // paranoia, and allows us to assume they are defined without ! everywhere.
        }
        const parent = pageVideoData.video.parentElement!;
        let replayButton = document.getElementById("replay-button");
        if (!replayButton) {
            replayButton = document.createElement("div");
            replayButton.setAttribute("id", "replay-button");
            replayButton.style.position = "absolute";
            replayButton.style.display = "none";
            ReactDOM.render(
                <Replay
                    style={{ backgroundColor: "rgba(255,255,255,0.5)" }}
                    onClick={args => {
                        // in storybook, I was seeing the page jump around as I clicked the button.
                        // Guessing it was somehow caused by something higher up also responding to
                        // the click, I put these in to try to stop it, but didn't succeed.
                        // If we get the behavior in production, we'll need to try some more.
                        args.preventDefault();
                        args.stopPropagation();
                        // This not only starts the video, it should put everything in the right
                        // state, including stopping any audio. If we change our minds about
                        // always playing video first, or decide to support more than one video
                        // on a page, we'll need something smarter here.
                        this.resetForNewPageAndPlay(
                            BloomPlayerCore.currentPage!
                        );
                    }}


for (let iedit = 0; iedit < editable


if (!stylesheet) {
            stylesheet = document.createElement("style");
            document.head.appendChild(stylesheet);
            stylesheet.setAttribute("id", "andikaCssStyleSheet");
        }


Array<AxiosPromise


if (this


useActualContents ? (
                                    <


if (!div) {
            return;
        }


// Expected behavior for cover: "on the cover, which is has a very dynamic layout, we just don't do scrollbars"
if (bloomPage


if (duration < 0.001


() => {
  beforeEach(() => {
    TestBed.configureTestingModule({
      providers: [UploadImageService]
    });
  });

  it('should be created', inject([UploadImageService], (service: UploadImageService) => {
    expect(service).toBeTruthy();
  }));
}


() => {
    TestBed.configureTestingModule({
      providers: [UploadImageService]
    });
  }


(service: UploadImageService) => {
    expect(service).toBeTruthy();
  }


export declare class SensorParameterV1Schema extends ObjectSchema {
    constructor();
}


// --- implementation ------------------------------------------
export class EventService extends EventEmitter implements IEventService {
	public _serviceBrand: any;
	constructor() {
		super();
	}
}


export function compileHandledom(template: string): string {
  const ast = parseHandledom(template)
  return generateTemplateFunction(ast)
}


() => {
  describe('isListenerObject', () => {
    describe('when object contains "addEventListener" and "removeEventListener"', () => {
      it('should return true', () => {
        const obj = {
          addEventListener: function() {},
          removeEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), true);
      });
    });
    describe('when object doesn\'t contain "addEventListener" and "removeEventListener"', () => {
      it('should return true', () => {
        const obj = {};
        assert.strictEqual(utils.isListenerObject(obj), false);
      });
    });
    describe('when object contains "addEventListener" only', () => {
      it('should return false', () => {
        const obj = {
          addEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), false);
      });
    });
    describe('when object contains "removeEventListener" only', () => {
      it('should return false', () => {
        const obj = {
          removeEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), false);
      });
    });
  });
}


() => {
    describe('when object contains "addEventListener" and "removeEventListener"', () => {
      it('should return true', () => {
        const obj = {
          addEventListener: function() {},
          removeEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), true);
      });
    });
    describe('when object doesn\'t contain "addEventListener" and "removeEventListener"', () => {
      it('should return true', () => {
        const obj = {};
        assert.strictEqual(utils.isListenerObject(obj), false);
      });
    });
    describe('when object contains "addEventListener" only', () => {
      it('should return false', () => {
        const obj = {
          addEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), false);
      });
    });
    describe('when object contains "removeEventListener" only', () => {
      it('should return false', () => {
        const obj = {
          removeEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), false);
      });
    });
  }


() => {
      it('should return true', () => {
        const obj = {
          addEventListener: function() {},
          removeEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), true);
      });
    }


() => {
        const obj = {
          addEventListener: function() {},
          removeEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), true);
      }


() => {
      it('should return true', () => {
        const obj = {};
        assert.strictEqual(utils.isListenerObject(obj), false);
      });
    }


() => {
        const obj = {};
        assert.strictEqual(utils.isListenerObject(obj), false);
      }


() => {
      it('should return false', () => {
        const obj = {
          addEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), false);
      });
    }


() => {
        const obj = {
          addEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), false);
      }


() => {
      it('should return false', () => {
        const obj = {
          removeEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), false);
      });
    }


() => {
        const obj = {
          removeEventListener: function() {},
        };
        assert.strictEqual(utils.isListenerObject(obj), false);
      }


rules => {
                this.setMultiState({
                    isLoading: false,
                    rules
                });
            }


(ruleType: string): void => {
        Services.getLoggerService().debug("[RulesPage] Enabling global rule:", ruleType);
        let config: string = "FULL";
        if (ruleType === "COMPATIBILITY") {
            config = "BACKWARD";
        }
        Services.getAdminService().createRule(ruleType, config).catch(error => {
            this.handleServerError(error, `Error enabling "${ ruleType }" global rule.`);
        });
        this.setSingleState("rules", [...this.rules(), {config, type: ruleType}]);
    }


error => {
            this.handleServerError(error, `Error enabling "${ ruleType }" global rule.`);
        }


(ruleType: string): void => {
        Services.getLoggerService().debug("[RulesPage] Disabling global rule:", ruleType);
        Services.getAdminService().deleteRule(ruleType).catch(error => {
            this.handleServerError(error, `Error disabling "${ ruleType }" global rule.`);
        });
        this.setSingleState("rules", this.rules().filter(r => r.type !== ruleType));
    }


error => {
            this.handleServerError(error, `Error disabling "${ ruleType }" global rule.`);
        }


r => r.type !== ruleType


(ruleType: string, config: string): void => {
        Services.getLoggerService().debug("[RulesPage] Configuring global rule:", ruleType, config);
        Services.getAdminService().updateRule(ruleType, config).catch(error => {
            this.handleServerError(error, `Error configuring "${ ruleType }" global rule.`);
        });
        this.setSingleState("rules", this.rules().map(r => {
            if (r.type === ruleType) {
                return {config, type: r.type};
            } else {
                return r;
            }
        }));
    }


error => {
            this.handleServerError(error, `Error configuring "${ ruleType }" global rule.`);
        }


r => {
            if (r.type === ruleType) {
                return {config, type: r.type};
            } else {
                return r;
            }
        }


/**
 * The global rules page.
 */
export class RulesPage extends PageComponent<RulesPageProps, RulesPageState> {

    constructor(props: Readonly<RulesPageProps>) {
        super(props);
    }

    public renderPage(): React.ReactElement {
        return (
            <React.Fragment>
                <PageSection className="ps_rules-header" variant={PageSectionVariants.light} padding={{ default : "noPadding" }


/**
 * Properties
 */
// tslint:disable-next-line:no-empty-interface
export interface RulesPageProps extends PageProps {

}


/**
 * State
 */
// tslint:disable-next-line:no-empty-interface
export interface RulesPageState extends PageState {
    rules: Rule[] | null;
}


public renderPage(): React.ReactElement {
        return (
            <React.Fragment>
                <PageSection className="ps_rules-header" variant={PageSectionVariants.light} padding={{


/**
 * 顶栏按钮下拉里的菜单按钮
 */
export default function NavButtonItems({
  items
}: IProps): JSX.Element {
  return <>
    {items.map(({
      key,
      label,
      href,
      onClick
    }: IPropsTopNavButtonDropdownItem): JSX.Element => <Button {...{
      key,
      spm: key as string,
      theme: ButtonTheme.MENU,
      label,
      href,
      onClick
    }} />)}
  </>;
}


({
      key,
      label,
      href,
      onClick
    }: IPropsTopNavButtonDropdownItem): JSX.Element => <Button {...{
      key,
      spm: key as string,
      theme: ButtonTheme.MENU,
      label,
      href,
      onClick
    }} />


interface IProps {
  items: IPropsTopNavButtonDropdownItem[];
}


function parseName(dependency: string): ID {
    let organization = "";
    let module = "";
    let dependencyArray = [];
    dependencyArray = dependency.split("/");
    for (var dependencyIndex in dependencyArray) {
        if (organization === "") {
            organization = dependencyArray[dependencyIndex];
        } else {
            if (module === "") {
                module = dependencyArray[dependencyIndex];
            } else {
                module = module + "/" + dependencyArray[dependencyIndex];
            }
        }
    }

    return { organization, module };
}


export default class VendorConfExtractor implements Extractor {
    public requires(): string[] {
        return [ fileName ];
    }

    public async extract(files: { [p: string]: ExtractorFile }): Promise<DependencyManagementFile> {
        const content = files[fileName].raw();

        const lines = content.split(/\n+/g);

        let id = {};
        id[organizationString] = null;
        id[moduleString] = null;
        let idFlag = true;
        const dependencies = [];
        for (var line of lines) {
            let trimmedLine = line.trim();
            if (trimmedLine.length === 0) {
                continue; // empty line
            }

            const parts = trimmedLine.split(/\s+/);
            const directive = parts[0];
            if (directive === '#') {
                continue;
            }
            if (idFlag) {
                id = parseName(directive);
                idFlag = false;
                continue;
            }

            const version = parts[1];
            var { organization, module } = parseName(directive);

            let scopes = [];
            if (parts[2] != null) {
                scopes.push(parts[2]);
            }

            const dependencyMap: Dependency = {
                organization: organization,
                module: module,
                versionConstraint: version,
                scopes: scopes,
            };

            dependencies.push(dependencyMap);
        }

        if (id[organizationString] === null || id[moduleString] === null) {
            throw new Error(`parse error: no module present`);
        }

        return {
            language: Languages.GO,
            system: "vendor",
            organization: id[organizationString],
            module: id[moduleString],
            version: "latest",
            dependencies,
        };
    }
}


interface ID {
    organization: string;
    module: string;
}


public requires(): string[] {
        return [ fileName ];
    }


public async extract(files: { [p: string]: ExtractorFile }): Promise<DependencyManagementFile> {
        const content = files[fileName].raw();

        const lines = content.split(/\n+/g);

        let id = {};
        id[organizationString] = null;
        id[moduleString] = null;
        let idFlag = true;
        const dependencies = [];
        for (var line of lines) {
            let trimmedLine = line.trim();
            if (trimmedLine.length === 0) {
                continue; // empty line
            }

            const parts = trimmedLine.split(/\s+/);
            const directive = parts[0];
            if (directive === '#') {
                continue;
            }
            if (idFlag) {
                id = parseName(directive);
                idFlag = false;
                continue;
            }

            const version = parts[1];
            var { organization, module } = parseName(directive);

            let scopes = [];
            if (parts[2] != null) {
                scopes.push(parts[2]);
            }

            const dependencyMap: Dependency = {
                organization: organization,
                module: module,
                versionConstraint: version,
                scopes: scopes,
            };

            dependencies.push(dependencyMap);
        }

        if (id[organizationString] === null || id[moduleString] === null) {
            throw new Error(`parse error: no module present`);
        }

        return {
            language: Languages.GO,
            system: "vendor",
            organization: id[organizationString],
            module: id[moduleString],
            version: "latest",
            dependencies,
        };
    }


function extractTitle(title: string | null) {
  if (title) {
    if ((window as any).source?.title) {
      const prefix = (window as any).source.title.base + (window as any).source.title.connector;
      if (title.startsWith(prefix)) return title.substr(prefix.length);
      else return title;
    }
  } else return title;
}


export function ArticleCard(
  this: ThemedComponentThis<CodedocTheme>,
  options: ArticleCardOptions,
  renderer: RendererLike<any, any>,
) {
  const classes = this.theme.classes(ArticleCardStyle);

  const src = new BehaviorSubject<string>(options.src);
  const img = new BehaviorSubject<string>('https://coding.blog/banner.svg');
  const title = new BehaviorSubject<string>('Some Article');
  const desc = new BehaviorSubject<string>('Some description for this article');

  this.track({
    bind() {
      let url = options.src;
      if (options.src.startsWith('/')) {
        url = `${(window as any).source?.namespace || ''}${options.src}`;
      }

      src.next(url);

      fetch(url)
      .then(response => response.text())
      .then(html => {
        const marker =
;
        marker.innerHTML = html;
        let candidate;

        if (candidate = marker.querySelector('meta[property="og:title"], meta[name="twitter:title"]'))
          title.next(extractTitle(candidate.getAttribute('content')) || title.value);
        else if (candidate = marker.querySelector('head > title'))
          title.next(extractTitle(candidate.textContent) || title.value);

        if (candidate = marker.querySelector(
          'meta[property="og:description"],' +
          'meta[name="twitter:description"],' +
          'meta[name="description"]'
        )) {
          desc.next(candidate.getAttribute('content') || '');
        } else if (candidate = marker.querySelector('#-codedoc-container > p')) {
          desc.next(candidate.textContent || '');
        }else {
          desc.next('');
        }

        if (candidate = marker.querySelector('meta[property="og:image"], meta[name="twitter:image"]'))
          img.next(candidate.getAttribute('content') || img.value);
        else if (candidate = marker.querySelector('img[data-hero]')) {
          img.next(candidate.getAttribute('src') || img.value);
        }
      });
    }
  });

  return <a {...(options.style==='box'?{'data-article-card-grid':''}:{})}
            href={src}
            class={`${classes.card} ${options.style === 'box' ? classes.cardcol: ''}`}>
    <div style={rl`background-image: url('${img}')`} class={classes.img}/>

{title}

{desc}

}


response => response.text()


html => {
        const marker = <div/>;
        marker.innerHTML = html;
        let candidate;

        if (candidate = marker.querySelector('meta[property="og:title"], meta[name="twitter:title"]'))
          title.next(extractTitle(candidate.getAttribute('content')) || title.value);
        else if (candidate = marker.querySelector('head > title'))
          title.next(extractTitle(candidate.textContent) || title.value);

        if (candidate = marker.querySelector(
          'meta[property="og:description"],' +
          'meta[name="twitter:description"],' +
          'meta[name="description"]'
        )) {
          desc.next(candidate.getAttribute('content') || '');
        } else if (candidate = marker.querySelector('#-codedoc-container > p')) {
          desc.next(candidate.textContent || '');
        }else {
          desc.next('');
        }

        if (candidate = marker.querySelector('meta[property="og:image"], meta[name="twitter:image"]'))
          img.next(candidate.getAttribute('content') || img.value);
        else if (candidate = marker.querySelector('img[data-hero]')) {
          img.next(candidate.getAttribute('src') || img.value);
        }
      }


export interface ArticleCardOptions {
  src: string;
  style: 'row' | 'box'
}


bind() {
      let url = options.src;
      if (options.src.startsWith('/')) {
        url = `${(window as any).source?.namespace || ''}${options.src}`;
      }

      src.next(url);

      fetch(url)
      .then(response => response.text())
      .then(html => {
        const marker = <div/>;
        marker.innerHTML = html;
        let candidate;

        if (candidate = marker.querySelector('meta[property="og:title"], meta[name="twitter:title"]'))
          title.next(extractTitle(candidate.getAttribute('content')) || title.value);
        else if (candidate = marker.querySelector('head > title'))
          title.next(extractTitle(candidate.textContent) || title.value);

        if (candidate = marker.querySelector(
          'meta[property="og:description"],' +
          'meta[name="twitter:description"],' +
          'meta[name="description"]'
        )) {
          desc.next(candidate.getAttribute('content') || '');
        } else if (candidate = marker.querySelector('#-codedoc-container > p')) {
          desc.next(candidate.textContent || '');
        }else {
          desc.next('');
        }

        if (candidate = marker.querySelector('meta[property="og:image"], meta[name="twitter:image"]'))
          img.next(candidate.getAttribute('content') || img.value);
        else if (candidate = marker.querySelector('img[data-hero]')) {
          img.next(candidate.getAttribute('src') || img.value);
        }
      });
    }


export enum PotraceTurnPolicy {
  TurnpolicyBlack = 'TURNPOLICY_BLACK',
  TurnpolicyWhite = 'TURNPOLICY_WHITE',
  TurnpolicyLeft = 'TURNPOLICY_LEFT',
  TurnpolicyRight = 'TURNPOLICY_RIGHT',
  TurnpolicyMinority = 'TURNPOLICY_MINORITY',
  TurnpolicyMajority = 'TURNPOLICY_MAJORITY'
}


export enum ImageFormat {
  NoChange = 'NO_CHANGE',
  Jpg = 'JPG',
  Png = 'PNG',
  Webp = 'WEBP'
}


export enum ImageCropFocus {
  Center = 'CENTER',
  North = 'NORTH',
  Northeast = 'NORTHEAST',
  East = 'EAST',
  Southeast = 'SOUTHEAST',
  South = 'SOUTH',
  Southwest = 'SOUTHWEST',
  West = 'WEST',
  Northwest = 'NORTHWEST',
  Entropy = 'ENTROPY',
  Attention = 'ATTENTION'
}


export enum ImageFit {
  Cover = 'COVER',
  Contain = 'CONTAIN',
  Fill = 'FILL',
  Inside = 'INSIDE',
  Outside = 'OUTSIDE'
}


export enum HeadingsMdx {
  H1 = 'h1',
  H2 = 'h2',
  H3 = 'h3',
  H4 = 'h4',
  H5 = 'h5',
  H6 = 'h6'
}


export enum SortOrderEnum {
  Asc = 'ASC',
  Desc = 'DESC'
}


export enum DirectoryFieldsEnum {
  SourceInstanceName = 'sourceInstanceName',
  AbsolutePath = 'absolutePath',
  RelativePath = 'relativePath',
  Extension = 'extension',
  Size = 'size',
  PrettySize = 'prettySize',
  ModifiedTime = 'modifiedTime',
  AccessTime = 'accessTime',
  ChangeTime = 'changeTime',
  BirthTime = 'birthTime',
  Root = 'root',
  Dir = 'dir',
  Base = 'base',
  Ext = 'ext',
  Name = 'name',
  RelativeDirectory = 'relativeDirectory',
  Dev = 'dev',
  Mode = 'mode',
  Nlink = 'nlink',
  Uid = 'uid',
  Gid = 'gid',
  Rdev = 'rdev',
  Ino = 'ino',
  AtimeMs = 'atimeMs',
  MtimeMs = 'mtimeMs',
  CtimeMs = 'ctimeMs',
  Atime = 'atime',
  Mtime = 'mtime',
  Ctime = 'ctime',
  Birthtime = 'birthtime',
  BirthtimeMs = 'birthtimeMs',
  Blksize = 'blksize',
  Blocks = 'blocks',
  Id = 'id',
  ParentId = 'parent___id',
  ParentParentId = 'parent___parent___id',
  ParentParentParentId = 'parent___parent___parent___id',
  ParentParentParentChildren = 'parent___parent___parent___children',
  ParentParentChildren = 'parent___parent___children',
  ParentParentChildrenId = 'parent___parent___children___id',
  ParentParentChildrenChildren = 'parent___parent___children___children',
  ParentParentInternalContent = 'parent___parent___internal___content',
  ParentParentInternalContentDigest = 'parent___parent___internal___contentDigest',
  ParentParentInternalDescription = 'parent___parent___internal___description',
  ParentParentInternalFieldOwners = 'parent___parent___internal___fieldOwners',
  ParentParentInternalIgnoreType = 'parent___parent___internal___ignoreType',
  ParentParentInternalMediaType = 'parent___parent___internal___mediaType',
  ParentParentInternalOwner = 'parent___parent___internal___owner',
  ParentParentInternalType = 'parent___parent___internal___type',
  ParentChildren = 'parent___children',
  ParentChildrenId = 'parent___children___id',
  ParentChildrenParentId = 'parent___children___parent___id',
  ParentChildrenParentChildren = 'parent___children___parent___children',
  ParentChildrenChildren = 'parent___children___children',
  ParentChildrenChildrenId = 'parent___children___children___id',
  ParentChildrenChildrenChildren = 'parent___children___children___children',
  ParentChildrenInternalContent = 'parent___children___internal___content',
  ParentChildrenInternalContentDigest = 'parent___children___internal___contentDigest',
  ParentChildrenInternalDescription = 'parent___children___internal___description',
  ParentChildrenInternalFieldOwners = 'parent___children___internal___fieldOwners',
  ParentChildrenInternalIgnoreType = 'parent___children___internal___ignoreType',
  ParentChildrenInternalMediaType = 'parent___children___internal___mediaType',
  ParentChildrenInternalOwner = 'parent___children___internal___owner',
  ParentChildrenInternalType = 'parent___children___internal___type',
  ParentInternalContent = 'parent___internal___content',
  ParentInternalContentDigest = 'parent___internal___contentDigest',
  ParentInternalDescription = 'parent___internal___description',
  ParentInternalFieldOwners = 'parent___internal___fieldOwners',
  ParentInternalIgnoreType = 'parent___internal___ignoreType',
  ParentInternalMediaType = 'parent___internal___mediaType',
  ParentInternalOwner = 'parent___internal___owner',
  ParentInternalType = 'parent___internal___type',
  Children = 'children',
  ChildrenId = 'children___id',
  ChildrenParentId = 'children___parent___id',
  ChildrenParentParentId = 'children___parent___parent___id',
  ChildrenParentParentChildren = 'children___parent___parent___children',
  ChildrenParentChildren = 'children___parent___children',
  ChildrenParentChildrenId = 'children___parent___children___id',
  ChildrenParentChildrenChildren = 'children___parent___children___children',
  ChildrenParentInternalContent = 'children___parent___internal___content',
  ChildrenParentInternalContentDigest = 'children___parent___internal___contentDigest',
  ChildrenParentInternalDescription = 'children___parent___internal___description',
  ChildrenParentInternalFieldOwners = 'children___parent___internal___fieldOwners',
  ChildrenParentInternalIgnoreType = 'children___parent___internal___ignoreType',
  ChildrenParentInternalMediaType = 'children___parent___internal___mediaType',
  ChildrenParentInternalOwner = 'children___parent___internal___owner',
  ChildrenParentInternalType = 'children___parent___internal___type',
  ChildrenChildren = 'children___children',
  ChildrenChildrenId = 'children___children___id',
  ChildrenChildrenParentId = 'children___children___parent___id',
  ChildrenChildrenParentChildren = 'children___children___parent___children',
  ChildrenChildrenChildren = 'children___children___children',
  ChildrenChildrenChildrenId = 'children___children___children___id',
  ChildrenChildrenChildrenChildren = 'children___children___children___children',
  ChildrenChildrenInternalContent = 'children___children___internal___content',
  ChildrenChildrenInternalContentDigest = 'children___children___internal___contentDigest',
  ChildrenChildrenInternalDescription = 'children___children___internal___description',
  ChildrenChildrenInternalFieldOwners = 'children___children___internal___fieldOwners',
  ChildrenChildrenInternalIgnoreType = 'children___children___internal___ignoreType',
  ChildrenChildrenInternalMediaType = 'children___children___internal___mediaType',
  ChildrenChildrenInternalOwner = 'children___children___internal___owner',
  ChildrenChildrenInternalType = 'children___children___internal___type',
  ChildrenInternalContent = 'children___internal___content',
  ChildrenInternalContentDigest = 'children___internal___contentDigest',
  ChildrenInternalDescription = 'children___internal___description',
  ChildrenInternalFieldOwners = 'children___internal___fieldOwners',
  ChildrenInternalIgnoreType = 'children___internal___ignoreType',
  ChildrenInternalMediaType = 'children___internal___mediaType',
  ChildrenInternalOwner = 'children___internal___owner',
  ChildrenInternalType = 'children___internal___type',
  InternalContent = 'internal___content',
  InternalContentDigest = 'internal___contentDigest',
  InternalDescription = 'internal___description',
  InternalFieldOwners = 'internal___fieldOwners',
  InternalIgnoreType = 'internal___ignoreType',
  InternalMediaType = 'internal___mediaType',
  InternalOwner = 'internal___owner',
  InternalType = 'internal___type'
}


export enum SiteFieldsEnum {
  BuildTime = 'buildTime',
  SiteMetadataTitle = 'siteMetadata___title',
  SiteMetadataDescription = 'siteMetadata___description',
  SiteMetadataAuthor = 'siteMetadata___author',
  Port = 'port',
  Host = 'host',
  Polyfill = 'polyfill',
  PathPrefix = 'pathPrefix',
  Id = 'id',
  ParentId = 'parent___id',
  ParentParentId = 'parent___parent___id',
  ParentParentParentId = 'parent___parent___parent___id',
  ParentParentParentChildren = 'parent___parent___parent___children',
  ParentParentChildren = 'parent___parent___children',
  ParentParentChildrenId = 'parent___parent___children___id',
  ParentParentChildrenChildren = 'parent___parent___children___children',
  ParentParentInternalContent = 'parent___parent___internal___content',
  ParentParentInternalContentDigest = 'parent___parent___internal___contentDigest',
  ParentParentInternalDescription = 'parent___parent___internal___description',
  ParentParentInternalFieldOwners = 'parent___parent___internal___fieldOwners',
  ParentParentInternalIgnoreType = 'parent___parent___internal___ignoreType',
  ParentParentInternalMediaType = 'parent___parent___internal___mediaType',
  ParentParentInternalOwner = 'parent___parent___internal___owner',
  ParentParentInternalType = 'parent___parent___internal___type',
  ParentChildren = 'parent___children',
  ParentChildrenId = 'parent___children___id',
  ParentChildrenParentId = 'parent___children___parent___id',
  ParentChildrenParentChildren = 'parent___children___parent___children',
  ParentChildrenChildren = 'parent___children___children',
  ParentChildrenChildrenId = 'parent___children___children___id',
  ParentChildrenChildrenChildren = 'parent___children___children___children',
  ParentChildrenInternalContent = 'parent___children___internal___content',
  ParentChildrenInternalContentDigest = 'parent___children___internal___contentDigest',
  ParentChildrenInternalDescription = 'parent___children___internal___description',
  ParentChildrenInternalFieldOwners = 'parent___children___internal___fieldOwners',
  ParentChildrenInternalIgnoreType = 'parent___children___internal___ignoreType',
  ParentChildrenInternalMediaType = 'parent___children___internal___mediaType',
  ParentChildrenInternalOwner = 'parent___children___internal___owner',
  ParentChildrenInternalType = 'parent___children___internal___type',
  ParentInternalContent = 'parent___internal___content',
  ParentInternalContentDigest = 'parent___internal___contentDigest',
  ParentInternalDescription = 'parent___internal___description',
  ParentInternalFieldOwners = 'parent___internal___fieldOwners',
  ParentInternalIgnoreType = 'parent___internal___ignoreType',
  ParentInternalMediaType = 'parent___internal___mediaType',
  ParentInternalOwner = 'parent___internal___owner',
  ParentInternalType = 'parent___internal___type',
  Children = 'children',
  ChildrenId = 'children___id',
  ChildrenParentId = 'children___parent___id',
  ChildrenParentParentId = 'children___parent___parent___id',
  ChildrenParentParentChildren = 'children___parent___parent___children',
  ChildrenParentChildren = 'children___parent___children',
  ChildrenParentChildrenId = 'children___parent___children___id',
  ChildrenParentChildrenChildren = 'children___parent___children___children',
  ChildrenParentInternalContent = 'children___parent___internal___content',
  ChildrenParentInternalContentDigest = 'children___parent___internal___contentDigest',
  ChildrenParentInternalDescription = 'children___parent___internal___description',
  ChildrenParentInternalFieldOwners = 'children___parent___internal___fieldOwners',
  ChildrenParentInternalIgnoreType = 'children___parent___internal___ignoreType',
  ChildrenParentInternalMediaType = 'children___parent___internal___mediaType',
  ChildrenParentInternalOwner = 'children___parent___internal___owner',
  ChildrenParentInternalType = 'children___parent___internal___type',
  ChildrenChildren = 'children___children',
  ChildrenChildrenId = 'children___children___id',
  ChildrenChildrenParentId = 'children___children___parent___id',
  ChildrenChildrenParentChildren = 'children___children___parent___children',
  ChildrenChildrenChildren = 'children___children___children',
  ChildrenChildrenChildrenId = 'children___children___children___id',
  ChildrenChildrenChildrenChildren = 'children___children___children___children',
  ChildrenChildrenInternalContent = 'children___children___internal___content',
  ChildrenChildrenInternalContentDigest = 'children___children___internal___contentDigest',
  ChildrenChildrenInternalDescription = 'children___children___internal___description',
  ChildrenChildrenInternalFieldOwners = 'children___children___internal___fieldOwners',
  ChildrenChildrenInternalIgnoreType = 'children___children___internal___ignoreType',
  ChildrenChildrenInternalMediaType = 'children___children___internal___mediaType',
  ChildrenChildrenInternalOwner = 'children___children___internal___owner',
  ChildrenChildrenInternalType = 'children___children___internal___type',
  ChildrenInternalContent = 'children___internal___content',
  ChildrenInternalContentDigest = 'children___internal___contentDigest',
  ChildrenInternalDescription = 'children___internal___description',
  ChildrenInternalFieldOwners = 'children___internal___fieldOwners',
  ChildrenInternalIgnoreType = 'children___internal___ignoreType',
  ChildrenInternalMediaType = 'children___internal___mediaType',
  ChildrenInternalOwner = 'children___internal___owner',
  ChildrenInternalType = 'children___internal___type',
  InternalContent = 'internal___content',
  InternalContentDigest = 'internal___contentDigest',
  InternalDescription = 'internal___description',
  InternalFieldOwners = 'internal___fieldOwners',
  InternalIgnoreType = 'internal___ignoreType',
  InternalMediaType = 'internal___mediaType',
  InternalOwner = 'internal___owner',
  InternalType = 'internal___type'
}


export enum MdxFieldsEnum {
  RawBody = 'rawBody',
  FileAbsolutePath = 'fileAbsolutePath',
  FrontmatterTitle = 'frontmatter___title',
  FrontmatterDate = 'frontmatter___date',
  FrontmatterDescription = 'frontmatter___description',
  FrontmatterTags = 'frontmatter___tags',
  Body = 'body',
  Excerpt = 'excerpt',
  Headings = 'headings',
  HeadingsValue = 'headings___value',
  HeadingsDepth = 'headings___depth',
  Html = 'html',
  MdxAst = 'mdxAST',
  TableOfContents = 'tableOfContents',
  TimeToRead = 'timeToRead',
  WordCountParagraphs = 'wordCount___paragraphs',
  WordCountSentences = 'wordCount___sentences',
  WordCountWords = 'wordCount___words',
  FieldsSlug = 'fields___slug',
  Id = 'id',
  ParentId = 'parent___id',
  ParentParentId = 'parent___parent___id',
  ParentParentParentId = 'parent___parent___parent___id',
  ParentParentParentChildren = 'parent___parent___parent___children',
  ParentParentChildren = 'parent___parent___children',
  ParentParentChildrenId = 'parent___parent___children___id',
  ParentParentChildrenChildren = 'parent___parent___children___children',
  ParentParentInternalContent = 'parent___parent___internal___content',
  ParentParentInternalContentDigest = 'parent___parent___internal___contentDigest',
  ParentParentInternalDescription = 'parent___parent___internal___description',
  ParentParentInternalFieldOwners = 'parent___parent___internal___fieldOwners',
  ParentParentInternalIgnoreType = 'parent___parent___internal___ignoreType',
  ParentParentInternalMediaType = 'parent___parent___internal___mediaType',
  ParentParentInternalOwner = 'parent___parent___internal___owner',
  ParentParentInternalType = 'parent___parent___internal___type',
  ParentChildren = 'parent___children',
  ParentChildrenId = 'parent___children___id',
  ParentChildrenParentId = 'parent___children___parent___id',
  ParentChildrenParentChildren = 'parent___children___parent___children',
  ParentChildrenChildren = 'parent___children___children',
  ParentChildrenChildrenId = 'parent___children___children___id',
  ParentChildrenChildrenChildren = 'parent___children___children___children',
  ParentChildrenInternalContent = 'parent___children___internal___content',
  ParentChildrenInternalContentDigest = 'parent___children___internal___contentDigest',
  ParentChildrenInternalDescription = 'parent___children___internal___description',
  ParentChildrenInternalFieldOwners = 'parent___children___internal___fieldOwners',
  ParentChildrenInternalIgnoreType = 'parent___children___internal___ignoreType',
  ParentChildrenInternalMediaType = 'parent___children___internal___mediaType',
  ParentChildrenInternalOwner = 'parent___children___internal___owner',
  ParentChildrenInternalType = 'parent___children___internal___type',
  ParentInternalContent = 'parent___internal___content',
  ParentInternalContentDigest = 'parent___internal___contentDigest',
  ParentInternalDescription = 'parent___internal___description',
  ParentInternalFieldOwners = 'parent___internal___fieldOwners',
  ParentInternalIgnoreType = 'parent___internal___ignoreType',
  ParentInternalMediaType = 'parent___internal___mediaType',
  ParentInternalOwner = 'parent___internal___owner',
  ParentInternalType = 'parent___internal___type',
  Children = 'children',
  ChildrenId = 'children___id',
  ChildrenParentId = 'children___parent___id',
  ChildrenParentParentId = 'children___parent___parent___id',
  ChildrenParentParentChildren = 'children___parent___parent___children',
  ChildrenParentChildren = 'children___parent___children',
  ChildrenParentChildrenId = 'children___parent___children___id',
  ChildrenParentChildrenChildren = 'children___parent___children___children',
  ChildrenParentInternalContent = 'children___parent___internal___content',
  ChildrenParentInternalContentDigest = 'children___parent___internal___contentDigest',
  ChildrenParentInternalDescription = 'children___parent___internal___description',
  ChildrenParentInternalFieldOwners = 'children___parent___internal___fieldOwners',
  ChildrenParentInternalIgnoreType = 'children___parent___internal___ignoreType',
  ChildrenParentInternalMediaType = 'children___parent___internal___mediaType',
  ChildrenParentInternalOwner = 'children___parent___internal___owner',
  ChildrenParentInternalType = 'children___parent___internal___type',
  ChildrenChildren = 'children___children',
  ChildrenChildrenId = 'children___children___id',
  ChildrenChildrenParentId = 'children___children___parent___id',
  ChildrenChildrenParentChildren = 'children___children___parent___children',
  ChildrenChildrenChildren = 'children___children___children',
  ChildrenChildrenChildrenId = 'children___children___children___id',
  ChildrenChildrenChildrenChildren = 'children___children___children___children',
  ChildrenChildrenInternalContent = 'children___children___internal___content',
  ChildrenChildrenInternalContentDigest = 'children___children___internal___contentDigest',
  ChildrenChildrenInternalDescription = 'children___children___internal___description',
  ChildrenChildrenInternalFieldOwners = 'children___children___internal___fieldOwners',
  ChildrenChildrenInternalIgnoreType = 'children___children___internal___ignoreType',
  ChildrenChildrenInternalMediaType = 'children___children___internal___mediaType',
  ChildrenChildrenInternalOwner = 'children___children___internal___owner',
  ChildrenChildrenInternalType = 'children___children___internal___type',
  ChildrenInternalContent = 'children___internal___content',
  ChildrenInternalContentDigest = 'children___internal___contentDigest',
  ChildrenInternalDescription = 'children___internal___description',
  ChildrenInternalFieldOwners = 'children___internal___fieldOwners',
  ChildrenInternalIgnoreType = 'children___internal___ignoreType',
  ChildrenInternalMediaType = 'children___internal___mediaType',
  ChildrenInternalOwner = 'children___internal___owner',
  ChildrenInternalType = 'children___internal___type',
  InternalContent = 'internal___content',
  InternalContentDigest = 'internal___contentDigest',
  InternalDescription = 'internal___description',
  InternalFieldOwners = 'internal___fieldOwners',
  InternalIgnoreType = 'internal___ignoreType',
  InternalMediaType = 'internal___mediaType',
  InternalOwner = 'internal___owner',
  InternalType = 'internal___type'
}


export enum SiteBuildMetadataFieldsEnum {
  Id = 'id',
  ParentId = 'parent___id',
  ParentParentId = 'parent___parent___id',
  ParentParentParentId = 'parent___parent___parent___id',
  ParentParentParentChildren = 'parent___parent___parent___children',
  ParentParentChildren = 'parent___parent___children',
  ParentParentChildrenId = 'parent___parent___children___id',
  ParentParentChildrenChildren = 'parent___parent___children___children',
  ParentParentInternalContent = 'parent___parent___internal___content',
  ParentParentInternalContentDigest = 'parent___parent___internal___contentDigest',
  ParentParentInternalDescription = 'parent___parent___internal___description',
  ParentParentInternalFieldOwners = 'parent___parent___internal___fieldOwners',
  ParentParentInternalIgnoreType = 'parent___parent___internal___ignoreType',
  ParentParentInternalMediaType = 'parent___parent___internal___mediaType',
  ParentParentInternalOwner = 'parent___parent___internal___owner',
  ParentParentInternalType = 'parent___parent___internal___type',
  ParentChildren = 'parent___children',
  ParentChildrenId = 'parent___children___id',
  ParentChildrenParentId = 'parent___children___parent___id',
  ParentChildrenParentChildren = 'parent___children___parent___children',
  ParentChildrenChildren = 'parent___children___children',
  ParentChildrenChildrenId = 'parent___children___children___id',
  ParentChildrenChildrenChildren = 'parent___children___children___children',
  ParentChildrenInternalContent = 'parent___children___internal___content',
  ParentChildrenInternalContentDigest = 'parent___children___internal___contentDigest',
  ParentChildrenInternalDescription = 'parent___children___internal___description',
  ParentChildrenInternalFieldOwners = 'parent___children___internal___fieldOwners',
  ParentChildrenInternalIgnoreType = 'parent___children___internal___ignoreType',
  ParentChildrenInternalMediaType = 'parent___children___internal___mediaType',
  ParentChildrenInternalOwner = 'parent___children___internal___owner',
  ParentChildrenInternalType = 'parent___children___internal___type',
  ParentInternalContent = 'parent___internal___content',
  ParentInternalContentDigest = 'parent___internal___contentDigest',
  ParentInternalDescription = 'parent___internal___description',
  ParentInternalFieldOwners = 'parent___internal___fieldOwners',
  ParentInternalIgnoreType = 'parent___internal___ignoreType',
  ParentInternalMediaType = 'parent___internal___mediaType',
  ParentInternalOwner = 'parent___internal___owner',
  ParentInternalType = 'parent___internal___type',
  Children = 'children',
  ChildrenId = 'children___id',
  ChildrenParentId = 'children___parent___id',
  ChildrenParentParentId = 'children___parent___parent___id',
  ChildrenParentParentChildren = 'children___parent___parent___children',
  ChildrenParentChildren = 'children___parent___children',
  ChildrenParentChildrenId = 'children___parent___children___id',
  ChildrenParentChildrenChildren = 'children___parent___children___children',
  ChildrenParentInternalContent = 'children___parent___internal___content',
  ChildrenParentInternalContentDigest = 'children___parent___internal___contentDigest',
  ChildrenParentInternalDescription = 'children___parent___internal___description',
  ChildrenParentInternalFieldOwners = 'children___parent___internal___fieldOwners',
  ChildrenParentInternalIgnoreType = 'children___parent___internal___ignoreType',
  ChildrenParentInternalMediaType = 'children___parent___internal___mediaType',
  ChildrenParentInternalOwner = 'children___parent___internal___owner',
  ChildrenParentInternalType = 'children___parent___internal___type',
  ChildrenChildren = 'children___children',
  ChildrenChildrenId = 'children___children___id',
  ChildrenChildrenParentId = 'children___children___parent___id',
  ChildrenChildrenParentChildren = 'children___children___parent___children',
  ChildrenChildrenChildren = 'children___children___children',
  ChildrenChildrenChildrenId = 'children___children___children___id',
  ChildrenChildrenChildrenChildren = 'children___children___children___children',
  ChildrenChildrenInternalContent = 'children___children___internal___content',
  ChildrenChildrenInternalContentDigest = 'children___children___internal___contentDigest',
  ChildrenChildrenInternalDescription = 'children___children___internal___description',
  ChildrenChildrenInternalFieldOwners = 'children___children___internal___fieldOwners',
  ChildrenChildrenInternalIgnoreType = 'children___children___internal___ignoreType',
  ChildrenChildrenInternalMediaType = 'children___children___internal___mediaType',
  ChildrenChildrenInternalOwner = 'children___children___internal___owner',
  ChildrenChildrenInternalType = 'children___children___internal___type',
  ChildrenInternalContent = 'children___internal___content',
  ChildrenInternalContentDigest = 'children___internal___contentDigest',
  ChildrenInternalDescription = 'children___internal___description',
  ChildrenInternalFieldOwners = 'children___internal___fieldOwners',
  ChildrenInternalIgnoreType = 'children___internal___ignoreType',
  ChildrenInternalMediaType = 'children___internal___mediaType',
  ChildrenInternalOwner = 'children___internal___owner',
  ChildrenInternalType = 'children___internal___type',
  InternalContent = 'internal___content',
  InternalContentDigest = 'internal___contentDigest',
  InternalDescription = 'internal___description',
  InternalFieldOwners = 'internal___fieldOwners',
  InternalIgnoreType = 'internal___ignoreType',
  InternalMediaType = 'internal___mediaType',
  InternalOwner = 'internal___owner',
  InternalType = 'internal___type',
  BuildTime = 'buildTime'
}


export enum SitePluginFieldsEnum {
  Id = 'id',
  ParentId = 'parent___id',
  ParentParentId = 'parent___parent___id',
  ParentParentParentId = 'parent___parent___parent___id',
  ParentParentParentChildren = 'parent___parent___parent___children',
  ParentParentChildren = 'parent___parent___children',
  ParentParentChildrenId = 'parent___parent___children___id',
  ParentParentChildrenChildren = 'parent___parent___children___children',
  ParentParentInternalContent = 'parent___parent___internal___content',
  ParentParentInternalContentDigest = 'parent___parent___internal___contentDigest',
  ParentParentInternalDescription = 'parent___parent___internal___description',
  ParentParentInternalFieldOwners = 'parent___parent___internal___fieldOwners',
  ParentParentInternalIgnoreType = 'parent___parent___internal___ignoreType',
  ParentParentInternalMediaType = 'parent___parent___internal___mediaType',
  ParentParentInternalOwner = 'parent___parent___internal___owner',
  ParentParentInternalType = 'parent___parent___internal___type',
  ParentChildren = 'parent___children',
  ParentChildrenId = 'parent___children___id',
  ParentChildrenParentId = 'parent___children___parent___id',
  ParentChildrenParentChildren = 'parent___children___parent___children',
  ParentChildrenChildren = 'parent___children___children',
  ParentChildrenChildrenId = 'parent___children___children___id',
  ParentChildrenChildrenChildren = 'parent___children___children___children',
  ParentChildrenInternalContent = 'parent___children___internal___content',
  ParentChildrenInternalContentDigest = 'parent___children___internal___contentDigest',
  ParentChildrenInternalDescription = 'parent___children___internal___description',
  ParentChildrenInternalFieldOwners = 'parent___children___internal___fieldOwners',
  ParentChildrenInternalIgnoreType = 'parent___children___internal___ignoreType',
  ParentChildrenInternalMediaType = 'parent___children___internal___mediaType',
  ParentChildrenInternalOwner = 'parent___children___internal___owner',
  ParentChildrenInternalType = 'parent___children___internal___type',
  ParentInternalContent = 'parent___internal___content',
  ParentInternalContentDigest = 'parent___internal___contentDigest',
  ParentInternalDescription = 'parent___internal___description',
  ParentInternalFieldOwners = 'parent___internal___fieldOwners',
  ParentInternalIgnoreType = 'parent___internal___ignoreType',
  ParentInternalMediaType = 'parent___internal___mediaType',
  ParentInternalOwner = 'parent___internal___owner',
  ParentInternalType = 'parent___internal___type',
  Children = 'children',
  ChildrenId = 'children___id',
  ChildrenParentId = 'children___parent___id',
  ChildrenParentParentId = 'children___parent___parent___id',
  ChildrenParentParentChildren = 'children___parent___parent___children',
  ChildrenParentChildren = 'children___parent___children',
  ChildrenParentChildrenId = 'children___parent___children___id',
  ChildrenParentChildrenChildren = 'children___parent___children___children',
  ChildrenParentInternalContent = 'children___parent___internal___content',
  ChildrenParentInternalContentDigest = 'children___parent___internal___contentDigest',
  ChildrenParentInternalDescription = 'children___parent___internal___description',
  ChildrenParentInternalFieldOwners = 'children___parent___internal___fieldOwners',
  ChildrenParentInternalIgnoreType = 'children___parent___internal___ignoreType',
  ChildrenParentInternalMediaType = 'children___parent___internal___mediaType',
  ChildrenParentInternalOwner = 'children___parent___internal___owner',
  ChildrenParentInternalType = 'children___parent___internal___type',
  ChildrenChildren = 'children___children',
  ChildrenChildrenId = 'children___children___id',
  ChildrenChildrenParentId = 'children___children___parent___id',
  ChildrenChildrenParentChildren = 'children___children___parent___children',
  ChildrenChildrenChildren = 'children___children___children',
  ChildrenChildrenChildrenId = 'children___children___children___id',
  ChildrenChildrenChildrenChildren = 'children___children___children___children',
  ChildrenChildrenInternalContent = 'children___children___internal___content',
  ChildrenChildrenInternalContentDigest = 'children___children___internal___contentDigest',
  ChildrenChildrenInternalDescription = 'children___children___internal___description',
  ChildrenChildrenInternalFieldOwners = 'children___children___internal___fieldOwners',
  ChildrenChildrenInternalIgnoreType = 'children___children___internal___ignoreType',
  ChildrenChildrenInternalMediaType = 'children___children___internal___mediaType',
  ChildrenChildrenInternalOwner = 'children___children___internal___owner',
  ChildrenChildrenInternalType = 'children___children___internal___type',
  ChildrenInternalContent = 'children___internal___content',
  ChildrenInternalContentDigest = 'children___internal___contentDigest',
  ChildrenInternalDescription = 'children___internal___description',
  ChildrenInternalFieldOwners = 'children___internal___fieldOwners',
  ChildrenInternalIgnoreType = 'children___internal___ignoreType',
  ChildrenInternalMediaType = 'children___internal___mediaType',
  ChildrenInternalOwner = 'children___internal___owner',
  ChildrenInternalType = 'children___internal___type',
  InternalContent = 'internal___content',
  InternalContentDigest = 'internal___contentDigest',
  InternalDescription = 'internal___description',
  InternalFieldOwners = 'internal___fieldOwners',
  InternalIgnoreType = 'internal___ignoreType',
  InternalMediaType = 'internal___mediaType',
  InternalOwner = 'internal___owner',
  InternalType = 'internal___type',
  Resolve = 'resolve',
  Name = 'name',
  Version = 'version',
  PluginOptionsName = 'pluginOptions___name',
  PluginOptionsPath = 'pluginOptions___path',
  PluginOptionsDefaultLayoutsDefault = 'pluginOptions___defaultLayouts___default',
  PluginOptionsExtensions = 'pluginOptions___extensions',
  PluginOptionsShortName = 'pluginOptions___short_name',
  PluginOptionsStartUrl = 'pluginOptions___start_url',
  PluginOptionsBackgroundColor = 'pluginOptions___background_color',
  PluginOptionsThemeColor = 'pluginOptions___theme_color',
  PluginOptionsDisplay = 'pluginOptions___display',
  PluginOptionsIcon = 'pluginOptions___icon',
  PluginOptionsCacheBustingMode = 'pluginOptions___cache_busting_mode',
  PluginOptionsIncludeFavicon = 'pluginOptions___include_favicon',
  PluginOptionsLegacy = 'pluginOptions___legacy',
  PluginOptionsThemeColorInHead = 'pluginOptions___theme_color_in_head',
  PluginOptionsCacheDigest = 'pluginOptions___cacheDigest',
  PluginOptionsSassLoaderOptionsSourceMap = 'pluginOptions___sassLoaderOptions___sourceMap',
  PluginOptionsPathCheck = 'pluginOptions___pathCheck',
  NodeApIs = 'nodeAPIs',
  BrowserApIs = 'browserAPIs',
  SsrApIs = 'ssrAPIs',
  PluginFilepath = 'pluginFilepath',
  PackageJsonName = 'packageJson___name',
  PackageJsonDescription = 'packageJson___description',
  PackageJsonVersion = 'packageJson___version',
  PackageJsonMain = 'packageJson___main',
  PackageJsonAuthor = 'packageJson___author',
  PackageJsonLicense = 'packageJson___license',
  PackageJsonDependencies = 'packageJson___dependencies',
  PackageJsonDependenciesName = 'packageJson___dependencies___name',
  PackageJsonDependenciesVersion = 'packageJson___dependencies___version',
  PackageJsonDevDependencies = 'packageJson___devDependencies',
  PackageJsonDevDependenciesName = 'packageJson___devDependencies___name',
  PackageJsonDevDependenciesVersion = 'packageJson___devDependencies___version',
  PackageJsonPeerDependencies = 'packageJson___peerDependencies',
  PackageJsonPeerDependenciesName = 'packageJson___peerDependencies___name',
  PackageJsonPeerDependenciesVersion = 'packageJson___peerDependencies___version',
  PackageJsonKeywords = 'packageJson___keywords'
}


/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: string;
  String: string;
  Boolean: boolean;
  Int: number;
  Float: number;
  /** A date string, such as 2007-12-03, compliant with the ISO 8601 standard for representation of dates and times using the Gregorian calendar. */
  Date: any;
  /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
  JSON: any;
};


export type Query = {
  __typename?: 'Query';
  file?: Maybe<File>;
  allFile: FileConnection;
  directory?: Maybe<Directory>;
  allDirectory: DirectoryConnection;
  sitePage?: Maybe<SitePage>;
  allSitePage: SitePageConnection;
  site?: Maybe<Site>;
  allSite: SiteConnection;
  imageSharp?: Maybe<ImageSharp>;
  allImageSharp: ImageSharpConnection;
  mdx?: Maybe<Mdx>;
  allMdx: MdxConnection;
  siteBuildMetadata?: Maybe<SiteBuildMetadata>;
  allSiteBuildMetadata: SiteBuildMetadataConnection;
  sitePlugin?: Maybe<SitePlugin>;
  allSitePlugin: SitePluginConnection;
};


export type QueryFileArgs = {
  sourceInstanceName?: Maybe<StringQueryOperatorInput>;
  absolutePath?: Maybe<StringQueryOperatorInput>;
  relativePath?: Maybe<StringQueryOperatorInput>;
  extension?: Maybe<StringQueryOperatorInput>;
  size?: Maybe<IntQueryOperatorInput>;
  prettySize?: Maybe<StringQueryOperatorInput>;
  modifiedTime?: Maybe<DateQueryOperatorInput>;
  accessTime?: Maybe<DateQueryOperatorInput>;
  changeTime?: Maybe<DateQueryOperatorInput>;
  birthTime?: Maybe<DateQueryOperatorInput>;
  root?: Maybe<StringQueryOperatorInput>;
  dir?: Maybe<StringQueryOperatorInput>;
  base?: Maybe<StringQueryOperatorInput>;
  ext?: Maybe<StringQueryOperatorInput>;
  name?: Maybe<StringQueryOperatorInput>;
  relativeDirectory?: Maybe<StringQueryOperatorInput>;
  dev?: Maybe<IntQueryOperatorInput>;
  mode?: Maybe<IntQueryOperatorInput>;
  nlink?: Maybe<IntQueryOperatorInput>;
  uid?: Maybe<IntQueryOperatorInput>;
  gid?: Maybe<IntQueryOperatorInput>;
  rdev?: Maybe<IntQueryOperatorInput>;
  ino?: Maybe<FloatQueryOperatorInput>;
  atimeMs?: Maybe<FloatQueryOperatorInput>;
  mtimeMs?: Maybe<FloatQueryOperatorInput>;
  ctimeMs?: Maybe<FloatQueryOperatorInput>;
  atime?: Maybe<DateQueryOperatorInput>;
  mtime?: Maybe<DateQueryOperatorInput>;
  ctime?: Maybe<DateQueryOperatorInput>;
  birthtime?: Maybe<DateQueryOperatorInput>;
  birthtimeMs?: Maybe<FloatQueryOperatorInput>;
  blksize?: Maybe<IntQueryOperatorInput>;
  blocks?: Maybe<IntQueryOperatorInput>;
  publicURL?: Maybe<StringQueryOperatorInput>;
  childImageSharp?: Maybe<ImageSharpFilterInput>;
  id?: Maybe<StringQueryOperatorInput>;
  parent?: Maybe<NodeFilterInput>;
  children?: Maybe<NodeFilterListInput>;
  internal?: Maybe<InternalFilterInput>;
  childMdx?: Maybe<MdxFilterInput>;
};


export type QueryAllFileArgs = {
  filter?: Maybe<FileFilterInput>;
  sort?: Maybe<FileSortInput>;
  skip?: Maybe<Scalars['Int']>;
  limit?: Maybe<Scalars['Int']>;
};


export type QueryDirectoryArgs = {
  sourceInstanceName?: Maybe<StringQueryOperatorInput>;
  absolutePath?: Maybe<StringQueryOperatorInput>;
  relativePath?: Maybe<StringQueryOperatorInput>;
  extension?: Maybe<StringQueryOperatorInput>;
  size?: Maybe<IntQueryOperatorInput>;
  prettySize?: Maybe<StringQueryOperatorInput>;
  modifiedTime?: Maybe<DateQueryOperatorInput>;
  accessTime?: Maybe<DateQueryOperatorInput>;
  changeTime?: Maybe<DateQueryOperatorInput>;
  birthTime?: Maybe<DateQueryOperatorInput>;
  root?: Maybe<StringQueryOperatorInput>;
  dir?: Maybe<StringQueryOperatorInput>;
  base?: Maybe<StringQueryOperatorInput>;
  ext?: Maybe<StringQueryOperatorInput>;
  name?: Maybe<StringQueryOperatorInput>;
  relativeDirectory?: Maybe<StringQueryOperatorInput>;
  dev?: Maybe<IntQueryOperatorInput>;
  mode?: Maybe<IntQueryOperatorInput>;
  nlink?: Maybe<IntQueryOperatorInput>;
  uid?: Maybe<IntQueryOperatorInput>;
  gid?: Maybe<IntQueryOperatorInput>;
  rdev?: Maybe<IntQueryOperatorInput>;
  ino?: Maybe<FloatQueryOperatorInput>;
  atimeMs?: Maybe<FloatQueryOperatorInput>;
  mtimeMs?: Maybe<FloatQueryOperatorInput>;
  ctimeMs?: Maybe<FloatQueryOperatorInput>;
  atime?: Maybe<DateQueryOperatorInput>;
  mtime?: Maybe<DateQueryOperatorInput>;
  ctime?: Maybe<DateQueryOperatorInput>;
  birthtime?: Maybe<DateQueryOperatorInput>;
  birthtimeMs?: Maybe<FloatQueryOperatorInput>;
  blksize?: Maybe<IntQueryOperatorInput>;
  blocks?: Maybe<IntQueryOperatorInput>;
  id?: Maybe<StringQueryOperatorInput>;
  parent?: Maybe<NodeFilterInput>;
  children?: Maybe<NodeFilterListInput>;
  internal?: Maybe<InternalFilterInput>;
};


export type QueryAllDirectoryArgs = {
  filter?: Maybe<DirectoryFilterInput>;
  sort?: Maybe<DirectorySortInput>;
  skip?: Maybe<Scalars['Int']>;
  limit?: Maybe<Scalars['Int']>;
};


export type QuerySitePageArgs = {
  path?: Maybe<StringQueryOperatorInput>;
  component?: Maybe<StringQueryOperatorInput>;
  internalComponentName?: Maybe<StringQueryOperatorInput>;
  componentChunkName?: Maybe<StringQueryOperatorInput>;
  matchPath?: Maybe<StringQueryOperatorInput>;
  id?: Maybe<StringQueryOperatorInput>;
  parent?: Maybe<NodeFilterInput>;
  children?: Maybe<NodeFilterListInput>;
  internal?: Maybe<InternalFilterInput>;
  isCreatedByStatefulCreatePages?: Maybe<BooleanQueryOperatorInput>;
  context?: Maybe<SitePageContextFilterInput>;
  pluginCreator?: Maybe<SitePluginFilterInput>;
  pluginCreatorId?: Maybe<StringQueryOperatorInput>;
  componentPath?: Maybe<StringQueryOperatorInput>;
};


export type QueryAllSitePageArgs = {
  filter?: Maybe<SitePageFilterInput>;
  sort?: Maybe<SitePageSortInput>;
  skip?: Maybe<Scalars['Int']>;
  limit?: Maybe<Scalars['Int']>;
};


export type QuerySiteArgs = {
  buildTime?: Maybe<DateQueryOperatorInput>;
  siteMetadata?: Maybe<SiteSiteMetadataFilterInput>;
  port?: Maybe<DateQueryOperatorInput>;
  host?: Maybe<StringQueryOperatorInput>;
  polyfill?: Maybe<BooleanQueryOperatorInput>;
  pathPrefix?: Maybe<StringQueryOperatorInput>;
  id?: Maybe<StringQueryOperatorInput>;
  parent?: Maybe<NodeFilterInput>;
  children?: Maybe<NodeFilterListInput>;
  internal?: Maybe<InternalFilterInput>;
};


export type QueryAllSiteArgs = {
  filter?: Maybe<SiteFilterInput>;
  sort?: Maybe<SiteSortInput>;
  skip?: Maybe<Scalars['Int']>;
  limit?: Maybe<Scalars['Int']>;
};


export type QueryImageSharpArgs = {
  fixed?: Maybe<ImageSharpFixedFilterInput>;
  resolutions?: Maybe<ImageSharpResolutionsFilterInput>;
  fluid?: Maybe<ImageSharpFluidFilterInput>;
  sizes?: Maybe<ImageSharpSizesFilterInput>;
  original?: Maybe<ImageSharpOriginalFilterInput>;
  resize?: Maybe<ImageSharpResizeFilterInput>;
  id?: Maybe<StringQueryOperatorInput>;
  parent?: Maybe<NodeFilterInput>;
  children?: Maybe<NodeFilterListInput>;
  internal?: Maybe<InternalFilterInput>;
};


export type QueryAllImageSharpArgs = {
  filter?: Maybe<ImageSharpFilterInput>;
  sort?: Maybe<ImageSharpSortInput>;
  skip?: Maybe<Scalars['Int']>;
  limit?: Maybe<Scalars['Int']>;
};


export type QueryMdxArgs = {
  rawBody?: Maybe<StringQueryOperatorInput>;
  fileAbsolutePath?: Maybe<StringQueryOperatorInput>;
  frontmatter?: Maybe<MdxFrontmatterFilterInput>;
  body?: Maybe<StringQueryOperatorInput>;
  excerpt?: Maybe<StringQueryOperatorInput>;
  headings?: Maybe<MdxHeadingMdxFilterListInput>;
  html?: Maybe<StringQueryOperatorInput>;
  mdxAST?: Maybe<JsonQueryOperatorInput>;
  tableOfContents?: Maybe<JsonQueryOperatorInput>;
  timeToRead?: Maybe<IntQueryOperatorInput>;
  wordCount?: Maybe<MdxWordCountFilterInput>;
  fields?: Maybe<MdxFieldsFilterInput>;
  id?: Maybe<StringQueryOperatorInput>;
  parent?: Maybe<NodeFilterInput>;
  children?: Maybe<NodeFilterListInput>;
  internal?: Maybe<InternalFilterInput>;
};


export type QueryAllMdxArgs = {
  filter?: Maybe<MdxFilterInput>;
  sort?: Maybe<MdxSortInput>;
  skip?: Maybe<Scalars['Int']>;
  limit?: Maybe<Scalars['Int']>;
};


export type QuerySiteBuildMetadataArgs = {
  id?: Maybe<StringQueryOperatorInput>;
  parent?: Maybe<NodeFilterInput>;
  children?: Maybe<NodeFilterListInput>;
  internal?: Maybe<InternalFilterInput>;
  buildTime?: Maybe<DateQueryOperatorInput>;
};


export type QueryAllSiteBuildMetadataArgs = {
  filter?: Maybe<SiteBuildMetadataFilterInput>;
  sort?: Maybe<SiteBuildMetadataSortInput>;
  skip?: Maybe<Scalars['Int']>;
  limit?: Maybe<Scalars['Int']>;
};


export type QuerySitePluginArgs = {
  id?: Maybe<StringQueryOperatorInput>;
  parent?: Maybe<NodeFilterInput>;
  children?: Maybe<NodeFilterListInput>;
  internal?: Maybe<InternalFilterInput>;
  resolve?: Maybe<StringQueryOperatorInput>;
  name?: Maybe<StringQueryOperatorInput>;
  version?: Maybe<StringQueryOperatorInput>;
  pluginOptions?: Maybe<SitePluginPluginOptionsFilterInput>;
  nodeAPIs?: Maybe<StringQueryOperatorInput>;
  browserAPIs?: Maybe<StringQueryOperatorInput>;
  ssrAPIs?: Maybe<StringQueryOperatorInput>;
  pluginFilepath?: Maybe<StringQueryOperatorInput>;
  packageJson?: Maybe<SitePluginPackageJsonFilterInput>;
};


export type QueryAllSitePluginArgs = {
  filter?: Maybe<SitePluginFilterInput>;
  sort?: Maybe<SitePluginSortInput>;
  skip?: Maybe<Scalars['Int']>;
  limit?: Maybe<Scalars['Int']>;
};


export type StringQueryOperatorInput = {
  eq?: Maybe<Scalars['String']>;
  ne?: Maybe<Scalars['String']>;
  in?: Maybe<Array<Maybe<Scalars['String']>>>;
  nin?: Maybe<Array<Maybe<Scalars['String']>>>;
  regex?: Maybe<Scalars['String']>;
  glob?: Maybe<Scalars['String']>;
};


export type IntQueryOperatorInput = {
  eq?: Maybe<Scalars['Int']>;
  ne?: Maybe<Scalars['Int']>;
  gt?: Maybe<Scalars['Int']>;
  gte?: Maybe<Scalars['Int']>;
  lt?: Maybe<Scalars['Int']>;
  lte?: Maybe<Scalars['Int']>;
  in?: Maybe<Array<Maybe<Scalars['Int']>>>;
  nin?: Maybe<Array<Maybe<Scalars['Int']>>>;
};


export type DateQueryOperatorInput = {
  eq?: Maybe<Scalars['Date']>;
  ne?: Maybe<Scalars['Date']>;
  gt?: Maybe<Scalars['Date']>;
  gte?: Maybe<Scalars['Date']>;
  lt?: Maybe<Scalars['Date']>;
  lte?: Maybe<Scalars['Date']>;
  in?: Maybe<Array<Maybe<Scalars['Date']>>>;
  nin?: Maybe<Array<Maybe<Scalars['Date']>>>;
};


export type FloatQueryOperatorInput = {
  eq?: Maybe<Scalars['Float']>;
  ne?: Maybe<Scalars['Float']>;
  gt?: Maybe<Scalars['Float']>;
  gte?: Maybe<Scalars['Float']>;
  lt?: Maybe<Scalars['Float']>;
  lte?: Maybe<Scalars['Float']>;
  in?: Maybe<Array<Maybe<Scalars['Float']>>>;
  nin?: Maybe<Array<Maybe<Scalars['Float']>>>;
};


export type ImageSharpFilterInput = {
  fixed?: Maybe<ImageSharpFixedFilterInput>;
  resolutions?: Maybe<ImageSharpResolutionsFilterInput>;
  fluid?: Maybe<ImageSharpFluidFilterInput>;
  sizes?: Maybe<ImageSharpSizesFilterInput>;
  original?: Maybe<ImageSharpOriginalFilterInput>;
  resize?: Maybe<ImageSharpResizeFilterInput>;
  id?: Maybe<StringQueryOperatorInput>;
  parent?: Maybe<NodeFilterInput>;
  children?: Maybe<NodeFilterListInput>;
  internal?: Maybe<InternalFilterInput>;
};


export type ImageSharpFixedFilterInput = {
  base64?: Maybe<StringQueryOperatorInput>;
  tracedSVG?: Maybe<StringQueryOperatorInput>;
  aspectRatio?: Maybe<FloatQueryOperatorInput>;
  width?: Maybe<FloatQueryOperatorInput>;
  height?: Maybe<FloatQueryOperatorInput>;
  src?: Maybe<StringQueryOperatorInput>;
  srcSet?: Maybe<StringQueryOperatorInput>;
  srcWebp?: Maybe<StringQueryOperatorInput>;
  srcSetWebp?: Maybe<StringQueryOperatorInput>;
  originalName?: Maybe<StringQueryOperatorInput>;
};


export type ImageSharpResolutionsFilterInput = {
  base64?: Maybe<StringQueryOperatorInput>;
  tracedSVG?: Maybe<StringQueryOperatorInput>;
  aspectRatio?: Maybe<FloatQueryOperatorInput>;
  width?: Maybe<FloatQueryOperatorInput>;
  height?: Maybe<FloatQueryOperatorInput>;
  src?: Maybe<StringQueryOperatorInput>;
  srcSet?: Maybe<StringQueryOperatorInput>;
  srcWebp?: Maybe<StringQueryOperatorInput>;
  srcSetWebp?: Maybe<StringQueryOperatorInput>;
  originalName?: Maybe<StringQueryOperatorInput>;
};


export type ImageSharpFluidFilterInput = {
  base64?: Maybe<StringQueryOperatorInput>;
  tracedSVG?: Maybe<StringQueryOperatorInput>;
  aspectRatio?: Maybe<FloatQueryOperatorInput>;
  src?: Maybe<StringQueryOperatorInput>;
  srcSet?: Maybe<StringQueryOperatorInput>;
  srcWebp?: Maybe<StringQueryOperatorInput>;
  srcSetWebp?: Maybe<StringQueryOperatorInput>;
  sizes?: Maybe<StringQueryOperatorInput>;
  originalImg?: Maybe<StringQueryOperatorInput>;
  originalName?: Maybe<StringQueryOperatorInput>;
  presentationWidth?: Maybe<IntQueryOperatorInput>;
  presentationHeight?: Maybe<IntQueryOperatorInput>;
};


export type ImageSharpSizesFilterInput = {
  base64?: Maybe<StringQueryOperatorInput>;
  tracedSVG?: Maybe<StringQueryOperatorInput>;
  aspectRatio?: Maybe<FloatQueryOperatorInput>;
  src?: Maybe<StringQueryOperatorInput>;
  srcSet?: Maybe<StringQueryOperatorInput>;
  srcWebp?: Maybe<StringQueryOperatorInput>;
  srcSetWebp?: Maybe<StringQueryOperatorInput>;
  sizes?: Maybe<StringQueryOperatorInput>;
  originalImg?: Maybe<StringQueryOperatorInput>;
  originalName?: Maybe<StringQueryOperatorInput>;
  presentationWidth?: Maybe<IntQueryOperatorInput>;
  presentationHeight?: Maybe<IntQueryOperatorInput>;
};


export type ImageSharpOriginalFilterInput = {
  width?: Maybe<FloatQueryOperatorInput>;
  height?: Maybe<FloatQueryOperatorInput>;
  src?: Maybe<StringQueryOperatorInput>;
};


export type ImageSharpResizeFilterInput = {
  src?: Maybe<StringQueryOperatorInput>;
  tracedSVG?: Maybe<StringQueryOperatorInput>;
  width?: Maybe<IntQueryOperatorInput>;
  height?: Maybe<IntQueryOperatorInput>;
  aspectRatio?: Maybe<FloatQueryOperatorInput>;
  originalName?: Maybe<StringQueryOperatorInput>;
};


export type NodeFilterInput = {
  id?: Maybe<StringQueryOperatorInput>;
  parent?: Maybe<NodeFilterInput>;
  children?: Maybe<NodeFilterListInput>;
  internal?: Maybe<InternalFilterInput>;
};


export type NodeFilterListInput = {
  elemMatch?: Maybe<NodeFilterInput>;
};


export type InternalFilterInput = {
  content?: Maybe<StringQueryOperatorInput>;
  contentDigest?: Maybe<StringQueryOperatorInput>;
  description?: Maybe<StringQueryOperatorInput>;
  fieldOwners?: Maybe<StringQueryOperatorInput>;
  ignoreType?: Maybe<BooleanQueryOperatorInput>;
  mediaType?: Maybe<StringQueryOperatorInput>;
  owner?: Maybe<StringQueryOperatorInput>;
  type?: Maybe<StringQueryOperatorInput>;
};


export type BooleanQueryOperatorInput = {
  eq?: Maybe<Scalars['Boolean']>;
  ne?: Maybe<Scalars['Boolean']>;
  in?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
  nin?: Maybe<Array<Maybe<Scalars['Boolean']>>>;
};