chromium/out/Default/gen/extensions/common/api/virtual_keyboard_private.h

// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// GENERATED FROM THE API DEFINITION IN
//   extensions/common/api/virtual_keyboard_private.json
// by tools/json_schema_compiler.
// DO NOT EDIT.

#ifndef EXTENSIONS_COMMON_API_VIRTUAL_KEYBOARD_PRIVATE_H__
#define EXTENSIONS_COMMON_API_VIRTUAL_KEYBOARD_PRIVATE_H__

#include <stdint.h>

#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>

#include "base/values.h"
#include <string_view>


namespace extensions {
namespace api {
namespace virtual_keyboard_private {

//
// Types
//

// One of keyup or keydown.
enum class VirtualKeyboardEventType {};


const char* ToString(VirtualKeyboardEventType as_enum);
VirtualKeyboardEventType ParseVirtualKeyboardEventType(std::string_view as_string);
std::u16string GetVirtualKeyboardEventTypeParseError(std::string_view as_string);

struct VirtualKeyboardEvent {};

// The value of the virtual keyboard mode to set to.
enum class KeyboardMode {};


const char* ToString(KeyboardMode as_enum);
KeyboardMode ParseKeyboardMode(std::string_view as_string);
std::u16string GetKeyboardModeParseError(std::string_view as_string);

// The value of the virtual keyboard state to change to.
enum class KeyboardState {};


const char* ToString(KeyboardState as_enum);
KeyboardState ParseKeyboardState(std::string_view as_string);
std::u16string GetKeyboardStateParseError(std::string_view as_string);

struct Bounds {};

struct KeyboardConfig {};

struct ContainerBehaviorOptions {};

// The display format associated with this item.
enum class DisplayFormat {};


const char* ToString(DisplayFormat as_enum);
DisplayFormat ParseDisplayFormat(std::string_view as_string);
std::u16string GetDisplayFormatParseError(std::string_view as_string);

struct ClipboardItem {};


//
// Functions
//

namespace InsertText {

struct Params {};

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace InsertText

namespace SendKeyEvent {

struct Params {};

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace SendKeyEvent

namespace HideKeyboard {

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace HideKeyboard

namespace SetHotrodKeyboard {

struct Params {};

}  // namespace SetHotrodKeyboard

namespace LockKeyboard {

struct Params {};

}  // namespace LockKeyboard

namespace KeyboardLoaded {

namespace Results {

base::Value::List Create();
}  // namespace Results

}  // namespace KeyboardLoaded

namespace GetKeyboardConfig {

namespace Results {

base::Value::List Create(const KeyboardConfig& config);
}  // namespace Results

}  // namespace GetKeyboardConfig

namespace OpenSettings {

}  // namespace OpenSettings

namespace OpenSuggestionSettings {

}  // namespace OpenSuggestionSettings

namespace SetContainerBehavior {

struct Params {};

namespace Results {

// Whether the container mode changed successfully
base::Value::List Create(bool success);
}  // namespace Results

}  // namespace SetContainerBehavior

namespace SetDraggableArea {

struct Params {};

}  // namespace SetDraggableArea

namespace SetKeyboardState {

struct Params {};

}  // namespace SetKeyboardState

namespace SetOccludedBounds {

struct Params {};

}  // namespace SetOccludedBounds

namespace SetHitTestBounds {

struct Params {};

}  // namespace SetHitTestBounds

namespace SetAreaToRemainOnScreen {

struct Params {};

}  // namespace SetAreaToRemainOnScreen

namespace SetWindowBoundsInScreen {

struct Params {};

}  // namespace SetWindowBoundsInScreen

namespace GetClipboardHistory {

struct Params {};

namespace Results {

// List of clipboard items corresponding to the requested items (or everything
// if 'itemIds' was not specified).
base::Value::List Create(const std::vector<ClipboardItem>& clipboard_history);
}  // namespace Results

}  // namespace GetClipboardHistory

namespace PasteClipboardItem {

struct Params {};

}  // namespace PasteClipboardItem

namespace DeleteClipboardItem {

struct Params {};

}  // namespace DeleteClipboardItem

//
// Events
//

namespace OnBoundsChanged {

extern const char kEventName[];  // "virtualKeyboardPrivate.onBoundsChanged"

// The virtual keyboard bounds
base::Value::List Create(const Bounds& bounds);
}  // namespace OnBoundsChanged

namespace OnKeyboardClosed {

extern const char kEventName[];  // "virtualKeyboardPrivate.onKeyboardClosed"

base::Value::List Create();
}  // namespace OnKeyboardClosed

namespace OnKeyboardConfigChanged {

extern const char kEventName[];  // "virtualKeyboardPrivate.onKeyboardConfigChanged"

// The virtual keyboard config
base::Value::List Create(const KeyboardConfig& config);
}  // namespace OnKeyboardConfigChanged

namespace OnClipboardHistoryChanged {

extern const char kEventName[];  // "virtualKeyboardPrivate.onClipboardHistoryChanged"

// A list of ids for all current items in the clipboard history.
base::Value::List Create(const std::vector<std::string>& item_ids);
}  // namespace OnClipboardHistoryChanged

namespace OnClipboardItemUpdated {

extern const char kEventName[];  // "virtualKeyboardPrivate.onClipboardItemUpdated"

// An existing clipboard history item with changed data
base::Value::List Create(const ClipboardItem& clipboard_history_item);
}  // namespace OnClipboardItemUpdated

namespace OnColorProviderChanged {

extern const char kEventName[];  // "virtualKeyboardPrivate.onColorProviderChanged"

base::Value::List Create();
}  // namespace OnColorProviderChanged

}  // namespace virtual_keyboard_private
}  // namespace api
}  // namespace extensions

#endif  // EXTENSIONS_COMMON_API_VIRTUAL_KEYBOARD_PRIVATE_H__