# Copyright (C) 2010-2021 Apple Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1.  Redistributions of source code must retain the above copyright
#     notice, this list of conditions and the following disclaimer.
# 2.  Redistributions in binary form must reproduce the above copyright
#     notice, this list of conditions and the following disclaimer in the
#     documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR
# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

messages -> WebPage LegacyReceiver {
    SetInitialFocus(bool forward, bool isKeyboardEventValid, WebKit::WebKeyboardEvent event) -> () Async
    SetActivityState(OptionSet<WebCore::ActivityState::Flag> activityState, WebKit::ActivityStateChangeID activityStateChangeID) -> () Async
    SetLayerHostingMode(enum:uint8_t WebKit::LayerHostingMode layerHostingMode)

    SetBackgroundColor(std::optional<WebCore::Color> color)

    AddConsoleMessage(WebCore::FrameIdentifier frameID, enum:uint8_t JSC::MessageSource messageSource, enum:uint8_t JSC::MessageLevel messageLevel, String message, std::optional<WebCore::ResourceLoaderIdentifier> requestID)
    SendCSPViolationReport(WebCore::FrameIdentifier frameID, URL reportURL, IPC::FormDataReference reportData)
    EnqueueSecurityPolicyViolationEvent(WebCore::FrameIdentifier frameID, struct WebCore::SecurityPolicyViolationEventInit eventInit)

    TestProcessIncomingSyncMessagesWhenWaitingForSyncReply() -> (bool handled) Synchronous

#if PLATFORM(COCOA)
    SetTopContentInsetFenced(float contentInset, MachSendRight machSendRight)
#endif
    SetTopContentInset(float contentInset)

    SetUnderlayColor(WebCore::Color color)
    SetUnderPageBackgroundColorOverride(WebCore::Color underPageBackgroundColorOverride)

    ViewWillStartLiveResize()
    ViewWillEndLiveResize()

    ExecuteEditCommandWithCallback(String name, String argument) -> () Async
    KeyEvent(WebKit::WebKeyboardEvent event)
    MouseEvent(WebKit::WebMouseEvent event, std::optional<Vector<WebKit::SandboxExtension::Handle>> sandboxExtensions)
#if PLATFORM(IOS_FAMILY)
    SetViewportConfigurationViewLayoutSize(WebCore::FloatSize size, double scaleFactor, double minimumEffectiveDeviceWidth)
    SetMinimumUnobscuredSize(WebCore::FloatSize size)
    SetMaximumUnobscuredSize(WebCore::FloatSize size)
    SetDeviceOrientation(int32_t deviceOrientation)
    SetOverrideViewportArguments(std::optional<WebCore::ViewportArguments> arguments)
    DynamicViewportSizeUpdate(WebCore::FloatSize viewLayoutSize, WebCore::FloatSize minimumUnobscuredSize, WebCore::FloatSize maximumUnobscuredSize, WebCore::FloatRect targetExposedContentRect, WebCore::FloatRect targetUnobscuredRect, WebCore::FloatRect targetUnobscuredRectInScrollViewCoordinates, WebCore::RectEdges<float> targetUnobscuredSafeAreaInsets, double scale, int32_t deviceOrientation, double minimumEffectiveDeviceWidth, uint64_t dynamicViewportSizeUpdateID)
    
    SetScreenIsBeingCaptured(bool captured)

    AttemptSyntheticClick(WebCore::IntPoint point, OptionSet<WebKit::WebEvent::Modifier> modifiers, WebKit::TransactionID lastLayerTreeTransactionId)
    PotentialTapAtPosition(WebKit::TapIdentifier requestID, WebCore::FloatPoint point, bool shouldRequestMagnificationInformation)
    CommitPotentialTap(OptionSet<WebKit::WebEvent::Modifier> modifiers, WebKit::TransactionID lastLayerTreeTransactionId, WebCore::PointerID pointerId)
    CancelPotentialTap()
    TapHighlightAtPosition(WebKit::TapIdentifier requestID, WebCore::FloatPoint point)
    DidRecognizeLongPress()
    HandleDoubleTapForDoubleClickAtPoint(WebCore::IntPoint point, OptionSet<WebKit::WebEvent::Modifier> modifiers, WebKit::TransactionID lastLayerTreeTransactionId)
    InspectorNodeSearchMovedToPosition(WebCore::FloatPoint point)
    InspectorNodeSearchEndedAtPosition(WebCore::FloatPoint point)
    BlurFocusedElement()
    SelectWithGesture(WebCore::IntPoint point, enum:uint8_t WebKit::GestureType gestureType, enum:uint8_t WebKit::GestureRecognizerState gestureState, bool isInteractingWithFocusedElement) -> (WebCore::IntPoint point, enum:uint8_t WebKit::GestureType gestureType, enum:uint8_t WebKit::GestureRecognizerState gestureState, OptionSet<WebKit::SelectionFlags> flags) Async
    UpdateSelectionWithTouches(WebCore::IntPoint point, enum:uint8_t WebKit::SelectionTouch touches, bool baseIsStart) -> (WebCore::IntPoint point, enum:uint8_t WebKit::SelectionTouch touch, OptionSet<WebKit::SelectionFlags> selectionFlags) Async
    SelectWithTwoTouches(WebCore::IntPoint from, WebCore::IntPoint to, enum:uint8_t WebKit::GestureType gestureType, enum:uint8_t WebKit::GestureRecognizerState gestureState) -> (WebCore::IntPoint point, enum:uint8_t WebKit::GestureType gestureType, enum:uint8_t WebKit::GestureRecognizerState gestureState, OptionSet<WebKit::SelectionFlags> selectionFlags) Async
    ExtendSelection(enum:uint8_t WebCore::TextGranularity granularity) -> () Async
    SelectWordBackward()
    MoveSelectionByOffset(int32_t offset) -> () Async
    SelectTextWithGranularityAtPoint(WebCore::IntPoint point, enum:uint8_t WebCore::TextGranularity granularity, bool isInteractingWithFocusedElement) -> () Async
    SelectPositionAtBoundaryWithDirection(WebCore::IntPoint point, enum:uint8_t WebCore::TextGranularity granularity, enum:uint8_t WebCore::SelectionDirection direction, bool isInteractingWithFocusedElement) -> () Async
    MoveSelectionAtBoundaryWithDirection(enum:uint8_t WebCore::TextGranularity granularity, enum:uint8_t WebCore::SelectionDirection direction) -> () Async
    SelectPositionAtPoint(WebCore::IntPoint point, bool isInteractingWithFocusedElement) -> () Async
    BeginSelectionInDirection(enum:uint8_t WebCore::SelectionDirection direction) -> (bool endIsMoving) Async
    UpdateSelectionWithExtentPoint(WebCore::IntPoint point, bool isInteractingWithFocusedElement, enum:bool WebKit::RespectSelectionAnchor respectSelectionAnchor) -> (bool endIsMoving) Async
    UpdateSelectionWithExtentPointAndBoundary(WebCore::IntPoint point, enum:uint8_t WebCore::TextGranularity granularity, bool isInteractingWithFocusedElement) -> (bool endIsMoving) Async
    RequestDictationContext() -> (String selectedText, String textBefore, String textAfter) Async
#if ENABLE(REVEAL)
    RequestRVItemInCurrentSelectedRange() -> (WebKit::RevealItem item) Async
    PrepareSelectionForContextMenuWithLocationInView(WebCore::IntPoint point) -> (bool shouldShowMenu, WebKit::RevealItem item) Async
#endif
    ReplaceDictatedText(String oldText, String newText)
    ReplaceSelectedText(String oldText, String newText)
    RequestAutocorrectionData(String textForAutocorrection) -> (struct WebKit::WebAutocorrectionData data) Async
    ApplyAutocorrection(String correction, String originalText) -> (String string) Async
    SyncApplyAutocorrection(String correction, String originalText) -> (bool autocorrectionApplied) Synchronous
    HandleAutocorrectionContextRequest()
    RequestEvasionRectsAboveSelection() -> (Vector<WebCore::FloatRect> rects) Async
    GetPositionInformation(struct WebKit::InteractionInformationRequest request) -> (struct WebKit::InteractionInformationAtPosition information) Synchronous
    RequestPositionInformation(struct WebKit::InteractionInformationRequest request)
    StartInteractionWithElementContextOrPosition(std::optional<WebCore::ElementContext> elementContext, WebCore::IntPoint point)
    StopInteraction()
    PerformActionOnElement(uint32_t action)
    FocusNextFocusedElement(bool isForward) -> () Async
    AutofillLoginCredentials(String username, String password)
    SetFocusedElementValue(struct WebCore::ElementContext context, String value)
    SetFocusedElementSelectedIndex(struct WebCore::ElementContext context, uint32_t index, bool allowMultipleSelection)
    ApplicationWillResignActive()
    ApplicationDidEnterBackground(bool isSuspendedUnderLock)
    ApplicationDidFinishSnapshottingAfterEnteringBackground()
    ApplicationWillEnterForeground(bool isSuspendedUnderLock)
    ApplicationDidBecomeActive()
    ApplicationDidEnterBackgroundForMedia(bool isSuspendedUnderLock)
    ApplicationWillEnterForegroundForMedia(bool isSuspendedUnderLock)
    ContentSizeCategoryDidChange(String contentSizeCategory)
    GetSelectionContext() -> (String selectedText, String textBefore, String textAfter) Async
    SetAllowsMediaDocumentInlinePlayback(bool allows)
    HandleTwoFingerTapAtPoint(WebCore::IntPoint point, OptionSet<WebKit::WebEvent::Modifier> modifiers, WebKit::TapIdentifier requestID)
    SetForceAlwaysUserScalable(bool userScalable)
    GetRectsForGranularityWithSelectionOffset(enum:uint8_t WebCore::TextGranularity granularity, int32_t offset) -> (Vector<WebCore::SelectionGeometry> rect) Async
    GetRectsAtSelectionOffsetWithText(int32_t offset, String text) -> (Vector<WebCore::SelectionGeometry> rect) Async
    StoreSelectionForAccessibility(bool shouldStore)
    StartAutoscrollAtPosition(WebCore::FloatPoint positionInWindow)
    CancelAutoscroll()
    RequestFocusedElementInformation() -> (std::optional<WebKit::FocusedElementInformation> info) Async
    HardwareKeyboardAvailabilityChanged(bool keyboardIsAttached)
    SetIsShowingInputViewForFocusedElement(bool showingInputView)
    UpdateSelectionWithDelta(int64_t locationDelta, int64_t lengthDelta) -> () Async
    RequestDocumentEditingContext(struct WebKit::DocumentEditingContextRequest request) -> (struct WebKit::DocumentEditingContext response) Async
GenerateSyntheticEditingCommand(enum:uint8_t WebKit::SyntheticEditingCommandType command)
    SetShouldRevealCurrentSelectionAfterInsertion(bool shouldRevealCurrentSelectionAfterInsertion)
    InsertTextPlaceholder(WebCore::IntSize size) -> (std::optional<WebCore::ElementContext> placeholder) Async
    RemoveTextPlaceholder(struct WebCore::ElementContext placeholder) -> () Async
    TextInputContextsInRect(WebCore::FloatRect rect) -> (Vector<struct WebCore::ElementContext> contexts) Async
    FocusTextInputContextAndPlaceCaret(struct WebCore::ElementContext context, WebCore::IntPoint point) -> (bool success) Async
    ClearServiceWorkerEntitlementOverride() -> () Async
#endif

    RequestImageBitmap(struct WebCore::ElementContext elementContext) -> (WebKit::ShareableBitmap::Handle image, String sourceMIMEType) Async

#if ENABLE(IMAGE_ANALYSIS_ENHANCEMENTS)
    InstallCroppedImageOverlay(struct WebCore::ElementContext elementContext, WebKit::SharedMemory::IPCHandle imageData, String mimeType, WebCore::FloatRect normalizedCropRect)
    SetCroppedImageOverlayVisibility(bool visible)
#endif

    SetControlledByAutomation(bool controlled)

    ConnectInspector(String targetId, Inspector::FrontendChannel::ConnectionType connectionType)
    DisconnectInspector(String targetId)
    SendMessageToTargetBackend(String targetId, String message)

#if ENABLE(REMOTE_INSPECTOR)
    SetIndicating(bool indicating);
#endif

#if ENABLE(IOS_TOUCH_EVENTS)
    ResetPotentialTapSecurityOrigin()
    TouchEventSync(WebKit::WebTouchEvent event) -> (bool handled) Synchronous
#endif
#if !ENABLE(IOS_TOUCH_EVENTS) && ENABLE(TOUCH_EVENTS)
    TouchEvent(WebKit::WebTouchEvent event)
#endif

    CancelPointer(WebCore::PointerID pointerId, WebCore::IntPoint documentPoint)
    TouchWithIdentifierWasRemoved(WebCore::PointerID pointerId)

#if ENABLE(INPUT_TYPE_COLOR)
    DidEndColorPicker()
    DidChooseColor(WebCore::Color color)
#endif

#if ENABLE(DATALIST_ELEMENT)
    DidSelectDataListOption(String selectedOption);
    DidCloseSuggestions();
#endif

#if ENABLE(DATE_AND_TIME_INPUT_TYPES)
    DidChooseDate(String date);
    DidEndDateTimePicker();
#endif

    ScrollBy(uint32_t scrollDirection, enum:uint8_t WebCore::ScrollGranularity scrollGranularity)
    CenterSelectionInVisibleArea()

    GoToBackForwardItem(uint64_t navigationID, struct WebCore::BackForwardItemIdentifier backForwardItemID, enum:uint8_t WebCore::FrameLoadType backForwardType, enum:uint8_t WebCore::ShouldTreatAsContinuingLoad shouldTreatAsContinuingLoad, std::optional<WebKit::WebsitePoliciesData> websitePolicies, bool lastNavigationWasAppInitiated, std::optional<WebKit::NetworkResourceLoadIdentifier> existingNetworkResourceLoadIdentifierToResume)
    TryRestoreScrollPosition()

    LoadURLInFrame(URL url, String referrer, WebCore::FrameIdentifier frameID)
    LoadDataInFrame(IPC::DataReference data, String MIMEType, String encodingName, URL baseURL, WebCore::FrameIdentifier frameID)
    LoadRequest(struct WebKit::LoadParameters loadParameters)
    LoadRequestWaitingForProcessLaunch(struct WebKit::LoadParameters loadParameters, URL resourceDirectoryURL, WebKit::WebPageProxyIdentifier pageID, bool checkAssumedReadAccessToResourceURL)
    LoadData(struct WebKit::LoadParameters loadParameters)
    LoadSimulatedRequestAndResponse(struct WebKit::LoadParameters loadParameters, WebCore::ResourceResponse simulatedResponse)
    LoadAlternateHTML(struct WebKit::LoadParameters loadParameters)

    NavigateToPDFLinkWithSimulatedClick(String url, WebCore::IntPoint documentPoint, WebCore::IntPoint screenPoint)
    GetPDFFirstPageSize(WebCore::FrameIdentifier frameID) -> (WebCore::FloatSize size) Async

    Reload(uint64_t navigationID, uint32_t reloadOptions, WebKit::SandboxExtension::Handle sandboxExtensionHandle)
    StopLoading()

    StopLoadingFrame(WebCore::FrameIdentifier frameID)
    
    RestoreSession(Vector<WebKit::BackForwardListItemState> itemStates)
    UpdateBackForwardListForReattach(Vector<WebKit::BackForwardListItemState> itemStates)
    SetCurrentHistoryItemForReattach(struct WebKit::BackForwardListItemState itemState)

    DidRemoveBackForwardItem(struct WebCore::BackForwardItemIdentifier backForwardItemID)

    UpdateWebsitePolicies(struct WebKit::WebsitePoliciesData websitePolicies)
    NotifyUserScripts()
    DidReceivePolicyDecision(WebCore::FrameIdentifier frameID, uint64_t listenerID, struct WebKit::PolicyDecision policyDecision, Vector<WebKit::SandboxExtension::Handle> networkExtensionsSandboxExtensions)

    ContinueWillSubmitForm(WebCore::FrameIdentifier frameID, WebKit::FormSubmitListenerIdentifier listenerID)

    ClearSelection()
    RestoreSelectionInFocusedEditableElement()

    # Callbacks.
    GetContentsAsString(enum:bool WebKit::ContentAsStringIncludesChildFrames inChildFrames) -> (String string) Async
    GetAllFrames() -> (struct WebKit::FrameTreeNodeData mainFrame) Async
#if PLATFORM(COCOA)
    GetContentsAsAttributedString() -> (struct WebCore::AttributedString result) Async
#endif
#if ENABLE(MHTML)
    GetContentsAsMHTMLData() -> (IPC::SharedBufferCopy data) Async
#endif
    GetMainResourceDataOfFrame(WebCore::FrameIdentifier frameID) -> (std::optional<IPC::SharedBufferCopy> buffer) Async
    GetResourceDataFromFrame(WebCore::FrameIdentifier frameID, String resourceURL) -> (std::optional<IPC::SharedBufferCopy> buffer) Async
    GetRenderTreeExternalRepresentation() -> (String string) Async
    GetSelectionOrContentsAsString() -> (String string) Async
    GetSelectionAsWebArchiveData() -> (std::optional<IPC::SharedBufferCopy> data) Async
    GetSourceForFrame(WebCore::FrameIdentifier frameID) -> (String string) Async
    GetWebArchiveOfFrame(WebCore::FrameIdentifier frameID) -> (std::optional<IPC::SharedBufferCopy> dataReference) Async

    RunJavaScriptInFrameInScriptWorld(struct WebCore::RunJavaScriptParameters parameters, std::optional<WebCore::FrameIdentifier> frameID, std::pair<WebKit::ContentWorldIdentifier, String> world) -> (IPC::DataReference resultData, std::optional<WebCore::ExceptionDetails> details) Async

    ForceRepaint() -> () Async
    SelectAll()
    ScheduleFullEditorStateUpdate()

#if PLATFORM(COCOA)
    # Dictionary support.
    PerformDictionaryLookupOfCurrentSelection()
    PerformDictionaryLookupAtLocation(WebCore::FloatPoint point)
#endif

#if ENABLE(DATA_DETECTION)
    DetectDataInAllFrames(OptionSet<WebCore::DataDetectorType> types) -> (struct WebKit::DataDetectionResult result) Async
    RemoveDataDetectedLinks() -> (struct WebKit::DataDetectionResult result) Async
#endif

    ChangeFont(WebCore::FontChanges changes)
    ChangeFontAttributes(WebCore::FontAttributeChanges changes)

    PreferencesDidChange(struct WebKit::WebPreferencesStore store)

    SetUserAgent(String userAgent)
    SetCustomTextEncodingName(String encodingName)

    SuspendActiveDOMObjectsAndAnimations()
    ResumeActiveDOMObjectsAndAnimations()

    Suspend() -> (bool success) Async
    Resume() -> (bool success) Async

    Close()
    TryClose() -> (bool shouldClose) Async

    SetEditable(bool editable)
    ValidateCommand(String name) -> (bool isEnabled, int32_t state) Async
    ExecuteEditCommand(String name, String argument)

    IncreaseListLevel()
    DecreaseListLevel()
    ChangeListType()

    SetBaseWritingDirection(enum:uint8_t WebCore::WritingDirection direction)

    SetNeedsFontAttributes(bool needsFontAttributes)

    RequestFontAttributesAtSelectionStart() -> (struct WebCore::FontAttributes attributes) Async

    DidRemoveEditCommand(uint64_t commandID)
    ReapplyEditCommand(uint64_t commandID)
    UnapplyEditCommand(uint64_t commandID)

    SetPageAndTextZoomFactors(double pageZoomFactor, double textZoomFactor)
    SetPageZoomFactor(double zoomFactor)
    SetTextZoomFactor(double zoomFactor)
    WindowScreenDidChange(uint32_t displayID, std::optional<unsigned> nominalFramesPerSecond)

    AccessibilitySettingsDidChange()

    ScalePage(double scale, WebCore::IntPoint origin)
    ScalePageInViewCoordinates(double scale, WebCore::IntPoint centerInViewCoordinates)
    ScaleView(double scale)

    SetUseFixedLayout(bool fixed)
    SetFixedLayoutSize(WebCore::IntSize size)
    ListenForLayoutMilestones(OptionSet<WebCore::LayoutMilestone> layoutMilestones)
    SetSuppressScrollbarAnimations(bool suppressAnimations)

    SetEnableVerticalRubberBanding(bool enableVerticalRubberBanding)
    SetEnableHorizontalRubberBanding(bool enableHorizontalRubberBanding)

    SetBackgroundExtendsBeyondPage(bool backgroundExtendsBeyondPage)

    SetPaginationMode(uint32_t mode)
    SetPaginationBehavesLikeColumns(bool behavesLikeColumns)
    SetPageLength(double pageLength)
    SetGapBetweenPages(double gap)
    SetPaginationLineGridEnabled(bool lineGridEnabled)

    PostInjectedBundleMessage(String messageName, WebKit::UserData messageBody)

    # Find.
    FindString(String string, OptionSet<WebKit::FindOptions> findOptions, unsigned maxMatchCount) -> (bool found) Async
    FindStringMatches(String string, OptionSet<WebKit::FindOptions> findOptions, unsigned maxMatchCount)
    GetImageForFindMatch(uint32_t matchIndex)
    SelectFindMatch(uint32_t matchIndex)
    IndicateFindMatch(uint32_t matchIndex)
    HideFindUI()
    CountStringMatches(String string, OptionSet<WebKit::FindOptions> findOptions, unsigned maxMatchCount)
    ReplaceMatches(Vector<uint32_t> matchIndices, String replacementText, bool selectionOnly) -> (uint64_t numberOfReplacements) Async

    FindRectsForStringMatches(String string, OptionSet<WebKit::FindOptions> findOptions, unsigned maxMatchCount) -> (Vector<WebCore::FloatRect> matches) Async
    HideFindIndicator()

    FindTextRangesForStringMatches(String string, OptionSet<WebKit::FindOptions> findOptions, unsigned maxMatchCount) -> (Vector<WebKit::WebFoundTextRange> ranges) Async
    DecorateTextRangeWithStyle(struct WebKit::WebFoundTextRange range, enum:uint8_t WebKit::FindDecorationStyle style)
    ScrollTextRangeToVisible(struct WebKit::WebFoundTextRange range)
    ClearAllDecoratedFoundText();
    DidBeginTextSearchOperation();
    DidEndTextSearchOperation();

    RequestRectForFoundTextRange(struct WebKit::WebFoundTextRange range) -> (WebCore::FloatRect rect) Async
    
    AddMIMETypeWithCustomContentProvider(String mimeType)

    # Drag and drop.
#if PLATFORM(GTK) && ENABLE(DRAG_SUPPORT)
    PerformDragControllerAction(enum:uint8_t WebKit::DragControllerAction action, WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, OptionSet<WebCore::DragOperation> draggingSourceOperationMask, WebCore::SelectionData selection, OptionSet<WebCore::DragApplicationFlags> flags)
#endif
#if !PLATFORM(GTK) && ENABLE(DRAG_SUPPORT)
    PerformDragControllerAction(enum:uint8_t WebKit::DragControllerAction action, WebCore::DragData dragData, WebKit::SandboxExtension::Handle sandboxExtensionHandle, Vector<WebKit::SandboxExtension::Handle> sandboxExtensionsForUpload)
#endif
#if ENABLE(DRAG_SUPPORT)
    DidStartDrag()
    DragEnded(WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, OptionSet<WebCore::DragOperation> dragOperationMask)
    DragCancelled()
#endif

#if PLATFORM(IOS_FAMILY) && ENABLE(DRAG_SUPPORT)
    RequestDragStart(WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, OptionSet<WebCore::DragSourceAction> allowedActionsMask)
    RequestAdditionalItemsForDragSession(WebCore::IntPoint clientPosition, WebCore::IntPoint globalPosition, OptionSet<WebCore::DragSourceAction> allowedActionsMask)
    InsertDroppedImagePlaceholders(Vector<WebCore::IntSize> imageSize) -> (Vector<WebCore::IntRect> dropPreviewRects, std::optional<WebCore::TextIndicatorData> textIndicator) Async
    DidConcludeDrop()
#endif

    # Popup menu.
    DidChangeSelectedIndexForActivePopupMenu(int32_t newIndex)
    SetTextForActivePopupMenu(int32_t index)
#if PLATFORM(GTK)
    FailedToShowPopupMenu()
#endif

#if ENABLE(CONTEXT_MENUS)
    # Context menu.
    DidShowContextMenu()
    DidDismissContextMenu()
    DidSelectItemFromActiveContextMenu(WebKit::WebContextMenuItemData menuItem)
    ContextMenuForKeyEvent()
#endif

    # Open panel.
#if PLATFORM(IOS_FAMILY)
    DidChooseFilesForOpenPanelWithDisplayStringAndIcon(Vector<String> fileURLs, String displayString, IPC::DataReference iconData, WebKit::SandboxExtension::Handle frontboardServicesSandboxExtension, WebKit::SandboxExtension::Handle iconServicesSandboxExtension)
#endif
    DidChooseFilesForOpenPanel(Vector<String> fileURLs, Vector<String> replacementURLs)
    DidCancelForOpenPanel()
#if ENABLE(SANDBOX_EXTENSIONS)
    ExtendSandboxForFilesFromOpenPanel(Vector<WebKit::SandboxExtension::Handle> sandboxExtensions)
#endif

    # Spelling and grammar.
    AdvanceToNextMisspelling(bool startBeforeSelection)
    ChangeSpellingToWord(String word)
    DidFinishCheckingText(WebKit::TextCheckerRequestID requestID, Vector<WebCore::TextCheckingResult> result)
    DidCancelCheckingText(WebKit::TextCheckerRequestID requestID)
#if USE(APPKIT)
    UppercaseWord()
    LowercaseWord()
    CapitalizeWord()
#endif
#if PLATFORM(COCOA)
    SetSmartInsertDeleteEnabled(bool isSmartInsertDeleteEnabled)
#endif

#if ENABLE(GEOLOCATION)
    # Geolocation
    DidReceiveGeolocationPermissionDecision(WebKit::GeolocationIdentifier geolocationID, String authorizationToken)
#endif

#if ENABLE(MEDIA_STREAM)
    # MediaSteam
    UserMediaAccessWasGranted(WebCore::UserMediaRequestIdentifier userMediaID, WebCore::CaptureDevice audioDevice, WebCore::CaptureDevice videoDevice, String mediaDeviceIdentifierHashSalt, WebKit::SandboxExtension::Handle sandboxExtensionHandle) -> () Async
    UserMediaAccessWasDenied(WebCore::UserMediaRequestIdentifier userMediaID, uint64_t reason, String invalidConstraint)
    CaptureDevicesChanged()
#if USE(GSTREAMER)
    SetOrientationForMediaCapture(int rotation)
    SetMockCaptureDevicesInterrupted(bool isCameraInterrupted, bool isMicrophoneInterrupted)
#endif
#endif

#if ENABLE(ENCRYPTED_MEDIA)
    MediaKeySystemWasGranted(WebCore::MediaKeySystemRequestIdentifier mediaKeySystemID) -> () Async
    MediaKeySystemWasDenied(WebCore::MediaKeySystemRequestIdentifier mediaKeySystemID, String message)
#endif

    RequestMediaPlaybackState() -> (enum:uint8_t WebKit::MediaPlaybackState state) Async
    PauseAllMediaPlayback() -> () Async
    SuspendAllMediaPlayback() -> () Async
    ResumeAllMediaPlayback() -> () Async

    FreezeLayerTreeDueToSwipeAnimation()
    UnfreezeLayerTreeDueToSwipeAnimation()
    IsLayerTreeFrozen() -> (bool isFrozen) Async

    # Printing.
    BeginPrinting(WebCore::FrameIdentifier frameID, struct WebKit::PrintInfo printInfo)
    EndPrinting()
    ComputePagesForPrinting(WebCore::FrameIdentifier frameID, struct WebKit::PrintInfo printInfo) -> (Vector<WebCore::IntRect> pageRects, double totalScaleFactorForPrinting, WebCore::RectEdges<float> computedPageMargin) Async
#if PLATFORM(COCOA)
    DrawRectToImage(WebCore::FrameIdentifier frameID, struct WebKit::PrintInfo printInfo, WebCore::IntRect rect, WebCore::IntSize imageSize) -> (WebKit::ShareableBitmap::Handle image) Async
    DrawPagesToPDF(WebCore::FrameIdentifier frameID, struct WebKit::PrintInfo printInfo, uint32_t first, uint32_t count) -> (IPC::SharedBufferCopy data) Async
#if PLATFORM(IOS_FAMILY)
#if !HAVE(UIKIT_BACKGROUND_THREAD_PRINTING)
    ComputePagesForPrintingiOS(WebCore::FrameIdentifier frameID, struct WebKit::PrintInfo printInfo) -> (size_t pageCount) Synchronous
#endif
    DrawToPDFiOS(WebCore::FrameIdentifier frameID, struct WebKit::PrintInfo printInfo, size_t pageCount) -> (IPC::SharedBufferCopy data) Async
#endif
    DrawToPDF(WebCore::FrameIdentifier frameID, std::optional<WebCore::FloatRect> rect) -> (IPC::SharedBufferCopy data) Async
#endif
#if PLATFORM(GTK)
    DrawPagesForPrinting(WebCore::FrameIdentifier frameID, struct WebKit::PrintInfo printInfo) -> (WebCore::ResourceError error) Async
#endif

    # Media
    SetMediaVolume(float volume)
    SetMuted(OptionSet<WebCore::MediaProducerMutedState> muted) -> () Async
    SetMayStartMediaWhenInWindow(bool mayStartMedia)
    StopMediaCapture(enum:uint8_t WebCore::MediaProducerMediaCaptureKind kind) -> () Async

    SetCanRunBeforeUnloadConfirmPanel(bool canRunBeforeUnloadConfirmPanel)
    SetCanRunModal(bool canRunModal)

#if PLATFORM(GTK) || PLATFORM(WPE)
    CancelComposition(String text)
    DeleteSurrounding(int64_t offset, unsigned characterCount)
#endif

#if PLATFORM(GTK)
    CollapseSelectionInFrame(WebCore::FrameIdentifier frameID)
#endif

#if PLATFORM(COCOA)
    WindowAndViewFramesChanged(WebCore::FloatRect windowFrameInScreenCoordinates, WebCore::FloatRect windowFrameInUnflippedScreenCoordinates, WebCore::FloatRect viewFrameInWindowCoordinates, WebCore::FloatPoint accessibilityViewCoordinates)
    SetMainFrameIsScrollable(bool isScrollable)
    RegisterUIProcessAccessibilityTokens(IPC::DataReference elemenToken, IPC::DataReference windowToken)
    GetStringSelectionForPasteboard() -> (String stringValue) Synchronous
    GetDataSelectionForPasteboard(String pasteboardType) -> (WebKit::SharedMemory::IPCHandle ipcHandle) Synchronous
    ReadSelectionFromPasteboard(String pasteboardName) -> (bool result) Synchronous
    ReplaceWithPasteboardData(struct WebCore::ElementContext context, Vector<String> types, IPC::DataReference data)
    ReplaceSelectionWithPasteboardData(Vector<String> types, IPC::DataReference data)

    ShouldDelayWindowOrderingEvent(WebKit::WebMouseEvent event) -> (bool result) Synchronous

    SetTextAsync(String text)

    InsertTextAsync(String text, struct WebKit::EditingRange replacementRange, struct WebKit::InsertTextOptions options)
    InsertDictatedTextAsync(String text, struct WebKit::EditingRange replacementRange, Vector<WebCore::DictationAlternative> dictationAlternatives, struct WebKit::InsertTextOptions options)

    HasMarkedText() -> (bool hasMarkedText) Async
    GetMarkedRangeAsync() -> (struct WebKit::EditingRange range) Async
    GetSelectedRangeAsync() -> (struct WebKit::EditingRange range) Async
    CharacterIndexForPointAsync(WebCore::IntPoint point) -> (uint64_t location) Async
    FirstRectForCharacterRangeAsync(struct WebKit::EditingRange range) -> (WebCore::IntRect rect, struct WebKit::EditingRange actualRange) Async
    SetCompositionAsync(String text, Vector<WebCore::CompositionUnderline> underlines, Vector<WebCore::CompositionHighlight> highlights, struct WebKit::EditingRange selectionRange, struct WebKit::EditingRange replacementRange)
    ConfirmCompositionAsync()
#endif
#if PLATFORM(MAC)
    AttributedSubstringForCharacterRangeAsync(struct WebKit::EditingRange range) -> (struct WebCore::AttributedString string, struct WebKit::EditingRange range) Async
    RequestAcceptsFirstMouse(int eventNumber, WebKit::WebMouseEvent event)
#endif

    SetAlwaysShowsHorizontalScroller(bool alwaysShowsHorizontalScroller)
    SetAlwaysShowsVerticalScroller(bool alwaysShowsVerticalScroller)

    SetMinimumSizeForAutoLayout(WebCore::IntSize size)
    SetSizeToContentAutoSizeMaximumSize(WebCore::IntSize size)
    SetAutoSizingShouldExpandToViewHeight(bool shouldExpand)

    SetViewportSizeForCSSViewportUnits(std::optional<WebCore::FloatSize> viewportSize)

#if PLATFORM(COCOA)
    HandleAlternativeTextUIResult(String result)
#endif

#if PLATFORM(IOS_FAMILY)
    WillStartUserTriggeredZooming();
#endif

    SetScrollPinningBehavior(uint32_t pinning)
    SetScrollbarOverlayStyle(std::optional<uint32_t> scrollbarStyle)

    GetBytecodeProfile() -> (String string) Async

    GetSamplingProfilerOutput() -> (String string) Async
    
    TakeSnapshot(WebCore::IntRect snapshotRect, WebCore::IntSize bitmapSize, uint32_t options) -> (WebKit::ShareableBitmap::Handle image) Async
#if PLATFORM(MAC)
    PerformImmediateActionHitTestAtLocation(WebCore::FloatPoint location)
    ImmediateActionDidUpdate()
    ImmediateActionDidCancel()
    ImmediateActionDidComplete()

    DataDetectorsDidPresentUI(WebCore::PageOverlay::PageOverlayID pageOverlay)
    DataDetectorsDidChangeUI(WebCore::PageOverlay::PageOverlayID pageOverlay)
    DataDetectorsDidHideUI(WebCore::PageOverlay::PageOverlayID pageOverlay)

    HandleAcceptedCandidate(struct WebCore::TextCheckingResult acceptedCandidate)

    SetUseSystemAppearance(bool useSystemAppearance)

    SetHeaderBannerHeightForTesting(int height)
    SetFooterBannerHeightForTesting(int height)

    DidEndMagnificationGesture()
#endif

    EffectiveAppearanceDidChange(bool useDarkAppearance, bool useElevatedUserInterfaceLevel)

#if HAVE(APP_ACCENT_COLORS)
    SetAccentColor(WebCore::Color color)
#endif

#if PLATFORM(COCOA)
    RequestActiveNowPlayingSessionInfo() -> (bool active, bool registeredAsNowPlayingApplication, String title, double duration, double elapsedTime, uint64_t uniqueIdentifier) Async
#endif

    SetShouldDispatchFakeMouseMoveEvents(bool shouldDispatchFakeMouseMoveEvents)

#if ENABLE(WIRELESS_PLAYBACK_TARGET) && !PLATFORM(IOS_FAMILY)
    PlaybackTargetSelected(WebCore::PlaybackTargetClientContextIdentifier contextId, WebCore::MediaPlaybackTargetContext target)
    PlaybackTargetAvailabilityDidChange(WebCore::PlaybackTargetClientContextIdentifier contextId, bool available)
    SetShouldPlayToPlaybackTarget(WebCore::PlaybackTargetClientContextIdentifier contextId, bool shouldPlay)
    PlaybackTargetPickerWasDismissed(WebCore::PlaybackTargetClientContextIdentifier contextId);
#endif

#if ENABLE(POINTER_LOCK)
    DidAcquirePointerLock()
    DidNotAcquirePointerLock()
    DidLosePointerLock()
#endif

    ClearWheelEventTestMonitor()
    SetShouldScaleViewToFitDocument(bool shouldScaleViewToFitDocument)

#if ENABLE(VIDEO) && USE(GSTREAMER)
    DidEndRequestInstallMissingMediaPlugins(uint32_t result)
#endif

    SetUserInterfaceLayoutDirection(uint32_t direction)

    DidGetLoadDecisionForIcon(bool decision, WebKit::CallbackID loadIdentifier) -> (IPC::SharedBufferCopy iconData) Async
    SetUseIconLoadingClient(bool useIconLoadingClient)

#if ENABLE(GAMEPAD)
    GamepadActivity(Vector<WebKit::GamepadData> gamepadDatas, enum:bool WebCore::EventMakesGamepadsVisible eventVisibility)
#endif

    FrameBecameRemote(WebCore::FrameIdentifier frameID, struct WebCore::GlobalFrameIdentifier remoteFrameIdentifier, struct WebCore::GlobalWindowIdentifier remoteWindowIdentifier)

    RegisterURLSchemeHandler(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, String scheme)

    URLSchemeTaskWillPerformRedirection(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceResponse response, WebCore::ResourceRequest proposedRequest) -> (WebCore::ResourceRequest actualRequest) Async
    URLSchemeTaskDidPerformRedirection(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceResponse response, WebCore::ResourceRequest proposedRequest)
    URLSchemeTaskDidReceiveResponse(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceResponse response)
    URLSchemeTaskDidReceiveData(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, IPC::SharedBufferCopy data)
    URLSchemeTaskDidComplete(WebKit::WebURLSchemeHandlerIdentifier handlerIdentifier, WebCore::ResourceLoaderIdentifier taskIdentifier, WebCore::ResourceError error)

    SetIsSuspended(bool suspended)

#if ENABLE(ATTACHMENT_ELEMENT)
    InsertAttachment(String identifier, std::optional<uint64_t> fileSize, String fileName, String contentType) -> () Async
    UpdateAttachmentAttributes(String identifier, std::optional<uint64_t> fileSize, String contentType, String fileName, IPC::SharedBufferCopy enclosingImageData) -> () Async
    UpdateAttachmentThumbnail(String identifier, WebKit::ShareableBitmap::Handle qlThumbnailHandle)
    UpdateAttachmentIcon(String identifier, WebKit::ShareableBitmap::Handle icon, WebCore::FloatSize size)
#endif

#if ENABLE(APPLICATION_MANIFEST)
    GetApplicationManifest() -> (std::optional<WebCore::ApplicationManifest> manifest) Async
#endif

    SetDefersLoading(bool defersLoading)

#if ENABLE(UI_PROCESS_PDF_HUD)
    ZoomPDFIn(WebKit::PDFPluginIdentifier identifier)
    ZoomPDFOut(WebKit::PDFPluginIdentifier identifier)
    SavePDF(WebKit::PDFPluginIdentifier identifier) -> (String filename, URL url, IPC::DataReference data) Async
    OpenPDFWithPreview(WebKit::PDFPluginIdentifier identifier) -> (String filename, struct WebKit::FrameInfoData frameInfo, IPC::DataReference data, String uuid) Async
#endif

    UpdateCurrentModifierState(OptionSet<WebCore::PlatformEvent::Modifier> modifiers)
    SimulateDeviceOrientationChange(double alpha, double beta, double gamma)

#if ENABLE(SPEECH_SYNTHESIS)
    SpeakingErrorOccurred()
    BoundaryEventOccurred(bool wordBoundary, unsigned charIndex)
    VoicesDidChange()
#endif

    SetCanShowPlaceholder(struct WebCore::ElementContext context, bool canShowPlaceholder)

#if ENABLE(INTELLIGENT_TRACKING_PREVENTION)
    WasLoadedWithDataTransferFromPrevalentResource()
    ClearLoadedSubresourceDomains()
    GetLoadedSubresourceDomains() -> (Vector<WebCore::RegistrableDomain> domains) Async
#endif

#if USE(SYSTEM_PREVIEW)
    SystemPreviewActionTriggered(struct WebCore::SystemPreviewInfo previewInfo, String message)
#endif

#if PLATFORM(GTK) || PLATFORM(WPE)
    SendMessageToWebExtension(struct WebKit::UserMessage userMessage)
    SendMessageToWebExtensionWithReply(struct WebKit::UserMessage userMessage) -> (struct WebKit::UserMessage replyMessage) Async
#endif

    StartTextManipulations(Vector<WebCore::TextManipulationController::ExclusionRule> exclusionRules) -> () Async
    CompleteTextManipulation(Vector<WebCore::TextManipulationController::ManipulationItem> items) -> (bool allFailed, Vector<WebCore::TextManipulationController::ManipulationFailure> failures) Async

    SetOverriddenMediaType(String mediaType)
    GetProcessDisplayName() -> (String displayName) Async

    UpdateCORSDisablingPatterns(Vector<String> patterns)

    SetIsTakingSnapshotsForApplicationSuspension(bool isTakingSnapshotsForApplicationSuspension)
    SetNeedsDOMWindowResizeEvent()

    SetHasResourceLoadClient(bool has)
    SetCanUseCredentialStorage(bool canUse)

#if ENABLE(APP_HIGHLIGHTS)
    CreateAppHighlightInSelectedRange(enum:bool WebCore::CreateNewGroupForHighlight createNewGroup, enum:bool WebCore::HighlightRequestOriginatedInApp requestOrigin)
    RestoreAppHighlightsAndScrollToIndex(Vector<WebKit::SharedMemory::IPCHandle> memoryHandles, std::optional<unsigned> index)
    SetAppHighlightsVisibility(enum:bool WebCore::HighlightVisibility highlightVisibility)
#endif

    DispatchWheelEventWithoutScrolling(WebKit::WebWheelEvent event) -> (bool handled) Async

    LastNavigationWasAppInitiated() -> (bool wasAppBound) Async

#if ENABLE(MEDIA_SESSION_COORDINATOR)
    CreateMediaSessionCoordinator(String identifier) -> (bool success) Async
    InvalidateMediaSessionCoordinator()
#endif

#if ENABLE(IMAGE_ANALYSIS)
    UpdateWithTextRecognitionResult(struct WebCore::TextRecognitionResult result, struct WebCore::ElementContext element, WebCore::FloatPoint location) -> (enum:uint8_t WebKit::TextRecognitionUpdateResult result) Async
    StartImageAnalysis(String identifier)
#endif

    ScrollToRect(WebCore::FloatRect targetRect, WebCore::FloatPoint origin)

    InteractableRegionsInRootViewCoordinates(WebCore::FloatRect rect) -> (Vector<WebCore::FloatRect> rects) Async
}