@devvit/protos 0.11.0-next-2024-07-24-e3a20f1a9.0 → 0.11.0-next-2024-07-25-e11c6b2a8.0

package/schema/.snootobuf/deps/reddit/coreplatform/api/metadata/v1/metadata.proto

@@ -0,0 +1,82 @@
+syntax = "proto3";
+
+package reddit.coreplatform.api.metadata.v1;
+
+import "google/protobuf/descriptor.proto";
+import "google/protobuf/duration.proto";
+
+option go_package = "github.snooguts.net/reddit/thing-api/go/api/metadata/v1;metadata";
+option java_multiple_files = true;
+option java_outer_classname = "MetadataProto";
+option java_package = "com.reddit.coreplatform.api.metadata.v1";
+
+extend google.protobuf.EnumValueOptions {
+  // This enum option is used to allow us to annotate newer protobuf enums
+  // with a description of what their previous value was in the older thrift
+  // API. Newer proto enums are not 1:1 mapping of their Thrift counterparts
+  // due to differences between the best practices of Thrift and protobuf.
+  ThriftEnumAlias thrift_alias = 78010000;
+}
+
+// This message represents a legacy Thrift enum const.
+message ThriftEnumAlias {
+  // The const name for the enum value
+  string name = 1;
+  // The the ordinal or index number of the enum value
+  int32 ordinal = 2;
+}
+
+extend google.protobuf.FieldOptions {
+  // Metadata describing the usage and behavior of API entity fields
+  EntityFieldMetadata entity_field_metadata = 78010001 [deprecated = true];
+
+  // Contains metadata about the thrift equivalent of a field. Used to help assert backward compatibility
+  // when mapping protobuf messages to and from their thrift counterpart.
+  ThriftFieldMetadata thrift_field_metadata = 78010002;
+}
+
+// The thing-api metadata for an entity field. This message is used to encapsulate
+// and document information about thing entities.
+//
+// EntityFieldMetadata in this file has been deprecated, use:
+//  https://github.snooguts.net/reddit/reddit-api-metadata
+message EntityFieldMetadata {
+  option deprecated = true;
+
+  // Level of sensitivity that the data stored in a field should be treated with.
+  enum SensitivityLevel {
+    option deprecated = true;
+
+    // This is a default vault used to convey the absence of a value.
+    SENSITIVITY_LEVEL_UNSPECIFIED = 0;
+
+    // Value to denote fields that should be treated as user PII
+    SENSITIVITY_LEVEL_PII = 1;
+
+    // Value to describe fields that are visible to reddit administrators but not
+    // publicly visible to users.
+    SENSITIVITY_LEVEL_ADMIN = 2;
+
+    // Value to describe fields that are visible to all users regardless of authentication status.
+    SENSITIVITY_LEVEL_PUBLIC = 3;
+  }
+
+  // The sensitivity level of the data stored in the annotated field
+  SensitivityLevel sensitivity_level = 1;
+
+  // An http url to the design doc which documents the purposed and introduction of this field to the API.
+  // New fields added by contributors must have this value populated
+  string design_doc_url = 2;
+
+  // The maximum duration the contents of this field can be cached or stored. After which, its value
+  // must be expunged. This is most commonly used to describe the retention period of fields which store PII.
+  google.protobuf.Duration max_retention = 3;
+}
+
+// Represents any metadata about the corresponding field in Thrift schema.
+message ThriftFieldMetadata {
+  // This field denotes if the legacy thrift representation of the annotated field was of type `set`. We use this field
+  // to ensure backward compatibility when mapping protobuf messages to and from their thrift counterpart since
+  // protobuf does not support the concept of `sets`.
+  bool is_set = 1;
+}

package/schema/.snootobuf/deps/reddit/coreplatform/blocking/v1/user_blocking_service.proto

@@ -0,0 +1,221 @@
+syntax = "proto3";
+
+package reddit.coreplatform.blocking.v1;
+
+import "google/protobuf/descriptor.proto";
+
+option go_package = "github.snooguts.net/reddit/thing-api/go/grpc/blocking/v1;blocking";
+option java_multiple_files = true;
+option java_outer_classname = "UserBlockingServiceProto";
+option java_package = "com.reddit.coreplatform.api.blocking.v1";
+
+// The user blocking service exposes APIs for interacting with user block lists
+service UserBlockingService {
+  // Add a user to the target users block list. This performs a bidirectional write, where the
+  // blockee is added to the users "blocking" list, and the blocker is added to the blockees
+  // "blocked by" list.
+  rpc BlockUser(BlockUserRequest) returns (BlockUserResponse) {
+    option idempotency_level = IDEMPOTENT;
+  }
+
+  // Remove a user to the target users block list. This performs a bidirectional write, where the
+  // blockee is removed from the users "blocking" list, and the blocker is removed from the blockees
+  // "blocked by" list.
+  rpc UnblockUser(UnblockUserRequest) returns (UnblockUserResponse) {
+    option idempotency_level = IDEMPOTENT;
+  }
+
+  // Retrieve the list of users that are blocking the requested user.
+  rpc GetBlockedByList(GetBlockedByListRequest) returns (GetBlockedByListResponse) {
+    option idempotency_level = NO_SIDE_EFFECTS;
+  }
+
+  // Retrieve the list of users that the requested user has blocked.
+  rpc GetBlockingList(GetBlockingListRequest) returns (GetBlockingListResponse) {
+    option idempotency_level = NO_SIDE_EFFECTS;
+  }
+
+  // Check if the requested user is blocked by or blocking any of the target account ids supplied
+  // This method is more performant than concurrently calling both `IsBlockedByUsers` and `IsBlockingUsers`
+  rpc HasAnyBlockingRelation(HasAnyBlockingRelationRequest) returns (HasAnyBlockingRelationResponse) {
+    option idempotency_level = NO_SIDE_EFFECTS;
+  }
+
+  // Check if the requested user is blocked by any of the target account ids supplied
+  rpc IsBlockedByUsers(IsBlockedByUsersRequest) returns (IsBlockedByUsersResponse) {
+    option idempotency_level = NO_SIDE_EFFECTS;
+  }
+
+  // Check if the requested user is blocking any of the target account ids supplied
+  rpc IsBlockingUsers(IsBlockingUsersRequest) returns (IsBlockingUsersResponse) {
+    option idempotency_level = NO_SIDE_EFFECTS;
+  }
+}
+
+// The type of blocking relation between two users
+enum BlockRelationType {
+  // No relation specific
+  BLOCK_RELATION_TYPE_UNSPECIFIED = 0;
+
+  // The relation type used when the subject user is blocking the target user
+  BLOCK_RELATION_TYPE_BLOCKING = 1;
+
+  // The relation type used when the subject user is blocked by the target user
+  BLOCK_RELATION_TYPE_BLOCKED_BY = 2;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message BlockUserRequest {
+  //account_id
+  string account_id = 1;
+
+  //block_target
+  string block_target = 2;
+}
+
+// The response message returned by successful calls to the `BlockUser` rpc.
+message BlockUserResponse {
+  // The unique identifier of the relation entry between the blocker and blocked. This field will always be populated in responses where a block was successfully performed.
+  // Generally, this id has no special meaning outside of the context of core services and should be ignored by clients. Its purpose is mostly to help facilitate migrations in legacy systems which depend blocking implementation details.
+  // Originally added to support R2 blocking migrations due to the way R2 persists blocks in its cache.
+  int64 relation_id = 1;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message GetBlockedAccountIdsResponse {
+  //blocked_account_ids
+  repeated string blocked_account_ids = 1;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message GetBlockedByAccountIdsResponse {
+  //blocking_account_ids
+  repeated string blocking_account_ids = 1;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message GetBlockedByListRequest {
+  //account_id
+  string account_id = 1;
+
+  //cursor
+  string cursor = 2;
+
+  //limit
+  int32 limit = 3;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message GetBlockedByListResponse {
+  //blocked_by
+  repeated string blocked_by = 1;
+
+  //cursor
+  string cursor = 2;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message GetBlockedIdsForAccountIdsResponse {
+  //account_id_to_blocked_account_ids
+  map<string, BlockedAccountIdList> account_id_to_blocked_account_ids = 1;
+  /* @exclude No documentation present when converted from Thrift to Proto */
+  message BlockedAccountIdList {
+    /* @exclude No documentation present when converted from Thrift to Proto */
+    repeated string blocked_account_ids = 1;
+  }
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message GetBlockerAccountIdsResponse {
+  //account_ids
+  repeated string account_ids = 1;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message GetBlockingListRequest {
+  //account_id
+  string account_id = 1;
+
+  //cursor
+  string cursor = 2;
+
+  //limit
+  int32 limit = 3;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message GetBlockingListResponse {
+  //is_blocking
+  repeated string is_blocking = 1;
+
+  //cursor
+  string cursor = 2;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message HasAnyBlockingRelationRequest {
+  //account_id
+  string account_id = 1;
+
+  //blocker_ids
+  repeated string blocker_ids = 2;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message HasAnyBlockingRelationResponse {
+  //found_relations
+  repeated string found_relations = 1;
+
+  //relations_by_type
+  map<string, AccountIdList> relations_by_type = 2;
+
+  /* @exclude No documentation present when converted from Thrift to Proto */
+  message AccountIdList {
+    /* @exclude No documentation present when converted from Thrift to Proto */
+    repeated string account_id = 1;
+  }
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message IsBlockedByUsersRequest {
+  //account_id
+  string account_id = 1;
+
+  //blocker_ids
+  repeated string blocker_ids = 2;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message IsBlockedByUsersResponse {
+  // The is_blocked_by field contains the subset of blocker_ids supplied which are blocking the account_id supplied.
+  // This list can potentially be empty.
+  repeated string is_blocked_by = 1;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message IsBlockingUsersRequest {
+  //account_id
+  string account_id = 1;
+
+  //users
+  repeated string users = 2;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message IsBlockingUsersResponse {
+  // The is_blocking field contains the subset of account ids supplied which are blocked by the account_id supplied.
+  // This list can potentially be empty.
+  repeated string is_blocking = 1;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message UnblockUserRequest {
+  //account_id
+  string account_id = 1;
+
+  //unblock_target
+  string unblock_target = 2;
+}
+
+/* @exclude No documentation present when converted from Thrift to Proto */
+message UnblockUserResponse {}

package/schema/.snootobuf/deps/reddit/coreplatform/comments/v1/comment_tree.proto

@@ -0,0 +1,78 @@
+syntax = "proto3";
+
+package reddit.coreplatform.comments.v1;
+
+import "google/protobuf/descriptor.proto";
+import "reddit/coreplatform/comments/v1/comments.proto";
+
+option go_package = "github.snooguts.net/reddit/thing-api/go/grpc/comments/v1;comments";
+option java_multiple_files = true;
+option java_outer_classname = "CommentTreeProto";
+option java_package = "com.reddit.coreplatform.api.comments.v1";
+
+// Message representing a comment tree. This is not a traditional tree or graph.
+// A CommentTree is represented via a list of Nodes.
+// Each of which may contain a Comment Thing model, comment id, or a cursor to sub-segment of the tree.
+message CommentTree {
+  // Enum with possible max_comments/max_depth cached/precomputed comment tree sizes
+  enum PrecomputedTreeView {
+    // the default value is unspecified so usage of this enum must be explicit when supplying a value
+    PRECOMPUTED_TREE_VIEW_UNSPECIFIED = 0;
+    // logged out user - 200 max_comments / 5 max_depth
+    PRECOMPUTED_TREE_VIEW_LOGGED_OUT = 1;
+    // logged in user - 500 max_comments / 5 max_depth
+    PRECOMPUTED_TREE_VIEW_DEFAULT = 2;
+    // the user has Gold/Premium - 1500 max_comments / 7 max_depth
+    PRECOMPUTED_TREE_VIEW_GOLD = 3;
+    // user viewing on Shreddit - 10 max_comments / 2 max_depth
+    PRECOMPUTED_TREE_VIEW_SHREDDIT = 4;
+  }
+
+  // Filters comments based on conditions when generating a CommentTree
+  enum Filter {
+    // No filtering will be applied
+    FILTER_UNSPECIFIED = 0;
+
+    // Only include comments which have a response by the OP or a collaborator
+    FILTER_ANSWERED = 1;
+    // Only include comments which do not have a response by the OP or a collaborator
+    FILTER_UNANSWERED = 2;
+  }
+
+  // LoadMoreComments represents a pointer to a comment tree subset that was hidden because of size/depth limitations or content relevancy.
+  message LoadMoreComments {
+    // A reference to a subset of a CommentTree
+    string cursor = 1;
+    // The number of comments the cursor points to
+    int32 num_comments = 2;
+  }
+
+  // Node represents a comment node (hydrated or non-hydrated) or a LoadMoreComments cursor.
+  message Node {
+    // The depth of this comment node from overall tree. This is the distance between
+    // this node and the root node of the comment tree.
+    int32 depth = 1;
+
+    // The t1 Thing Comment id of the parent of this comment. If this comment
+    // has no parent, then this field will be an empty string.
+    string parent_id = 2;
+
+    // The value of this (comment) Node.
+    oneof value {
+      // A fully hydrated Comment Thing model. This field will only be populated if the
+      // client requested the tree nodes to be hydrated.
+      Comment comment = 3;
+
+      // A t1 Thing Comment id that represents a comment. This field is populated if *no* comment hydration was requested.
+      string comment_id = 4;
+
+      // A reference to a comment tree subset. This node is used to represent
+      // a tree node for comments that are part of the tree but need to be loaded
+      // separately due to response size limitations or content relevancy.
+      LoadMoreComments load_more_comments = 5;
+    }
+  }
+
+  // An ordered list of the nodes that this comment tree segment is comprised of
+  repeated Node nodes = 1;
+}

package/schema/.snootobuf/deps/reddit/coreplatform/comments/v1/comment_tree_service.proto

@@ -0,0 +1,189 @@
+syntax = "proto3";
+
+package reddit.coreplatform.comments.v1;
+
+import "reddit/coreplatform/comments/v1/comment_tree.proto";
+import "reddit/coreplatform/comments/v1/comment_tree_structure.proto";
+import "reddit/coreplatform/comments/v1/comments.proto";
+import "reddit/coreplatform/common/v1/auth.proto";
+import "validate/validate.proto";
+
+option go_package = "github.snooguts.net/reddit/thing-api/go/grpc/comments/v1;comments";
+option java_multiple_files = true;
+option java_outer_classname = "CommentTreeServiceProto";
+option java_package = "com.reddit.coreplatform.api.comments.v1";
+
+//  RPC Service for working with Comment Trees
+service CommentTreeService {
+  // Load a segment of a comment tree represented as a list of nodes. This rpc does not return a traditional tree or graph
+  // structure. The nodes on the result can be used as arguments to further iterate the entirety of the tree.
+  rpc GetCommentTree(GetCommentTreeRequest) returns (GetCommentTreeResponse) {
+    option idempotency_level = NO_SIDE_EFFECTS;
+  }
+
+  // GetBatchCommentTree returns a map of CommentTree by LinkID for a given list of Link IDs.
+  //
+  // Given its batch nature, this endpoint sets some restrictions to reduce the amount of processing needed
+  // to generate the response.
+  // Unlike the single version GetCommentTree, GetBatchCommentTree does not hydrate the comments (return ids) and only allows
+  // requesting PrecomputedTreeView sizes and cached sorts (BEST/TOP).
+  // This ensures we always retrieve the cached comment trees in order to keep the endpoint's latency as low as
+  // possible.
+  rpc GetBatchCommentTree(GetBatchCommentTreeRequest) returns (GetBatchCommentTreeResponse) {
+    option idempotency_level = NO_SIDE_EFFECTS;
+  }
+
+  // GetCommentTreeStructure returns the comment tree structures (parent-child relations) from a post.
+  rpc GetCommentTreeStructure(GetCommentTreeStructureRequest) returns (GetCommentTreeStructureResponse) {
+    option idempotency_level = NO_SIDE_EFFECTS;
+  }
+}
+
+// The request message for loading a single comment tree segment from a post (link_id).
+message GetCommentTreeRequest {
+  // The t3 Link Thing id for the link the CommentTree belongs to.
+  // This is required in all cases of fetching a CommentTree.
+  // Passing only link_id and no source.comment_id or source.cursor, will fetch a CommentTree for a post e.g. https://reddit.com/r/aww/comments/12nmp5o/
+  string link_id = 1 [(validate.rules).string = {pattern: "^t3_[a-zA-Z0-9]+$"}];
+
+  // Optional source of the comment tree to fetch if the client was to load a permalink using comment_id or comments from a cursor
+  oneof source {
+    // Permalink case - the t1 Comment Thing id that will be used as the root of the subset of the comment tree returned.
+    // Used to load post pages where a specific comment is the root e.g. https://www.reddit.com/r/aww/comments/12nmp5o/comment/jgfcg4i/
+    string comment_id = 2 [(validate.rules).string = {pattern: "^t1_[a-zA-Z0-9]+$"}];
+
+    // Cursor case - a cursor to a subset of a comment tree that will be used as the root of the subset of the comment tree returned.
+    // Its primary purpose is to allow clients to perform depth-first and breadth-first traversal
+    // of comment trees.
+    string cursor = 3;
+  }
+
+  // Comment sort to be used to generate the CommentTree
+  Comment.Sort sort = 4 [(validate.rules).enum = {
+    defined_only: true,
+    // Only allow supported comment sorts
+    in: [
+      1, // CONFIDENCE,
+      2, // TOP,
+      3, // NEW,
+      4, // CONTROVERSIAL
+      5, // OLD,
+      6, // RANDOM,
+      7 // QA,
+    ]
+  }];
+
+  // Whether or not the CommentTree.nodes are fully hydrated Comment Thing models, or just Comment ids.
+  bool hydrate_nodes = 5;
+
+  // Important note: you can pass either a PrecomputedTreeView size to receive a cached and *faster* comment tree
+  // or pass custom `max_comments` and `max_depth` arguments which may incur latency costs to compute the comment tree at request time.
+  // Trees computed in real-time are not cached for later retrieval so this latency cost is paid on each request.
+  optional CommentTree.PrecomputedTreeView precomputed_tree_view = 6 [(validate.rules).enum = {
+    defined_only: true,
+    not_in: [0]
+  }];
+
+  // Max number of comments to return in the CommentTree (exclusive of LoadMoreComments nodes)
+  optional int32 max_comments = 7 [(validate.rules).int32.lte = 1500];
+
+  // Max depth that comments can have in the CommentTree
+  optional int32 max_depth = 8 [(validate.rules).int32.lte = 10];
+
+  // Enable returning CommentTrees in a r2-compatible way
+  // r2-compatible means:
+  // - cursor string format used is list of comment_ids e.g. "abc, def, hij"
+  // - Permalink type responses have Node's depth to start at 0, regardless of the true comment's depth
+  bool legacy_r2_mode = 9;
+
+  // Optional int32 to load N parent comments before a comment_id.bool
+  // Only used for the permalink case and it does not interfere on the GetCommentTreeRequest.max_depth
+  optional int32 num_parents = 10 [(validate.rules).int32.lte = 8];
+
+  // Truncate commentTree length by the given value.
+  // Design Doc: https://docs.google.com/document/d/1jNRAuKbVGupDaM67pdvYpx55VGAB7LA8NPtymtJJCPs/edit?usp=sharing
+  int32 truncate = 11 [(validate.rules).int32 = {
+    gte: 0,
+    lte: 50
+  }];
+
+  // Filter comment trees by the given type
+  // Design Doc: https://docs.google.com/document/d/1_-m6QECGx9JjPhoqIDq7eIDJbHXfAiIBHIuZgtzIR1o/edit?usp=sharing
+  optional CommentTree.Filter filter = 12 [(validate.rules).enum = {
+    defined_only: true,
+    in: [
+      1, // ANSWERED
+      2 // UNANSWERED
+    ],
+  }];
+
+  // The authorization policy to use while executing this request. This policy dictates what permission set
+  // the caller assumes while reading comment tree data.
+  reddit.coreplatform.common.v1.AuthzPolicy authz_policy = 2000;
+}
+
+// The response message for loading a comment tree
+message GetCommentTreeResponse {
+  // The comment tree computed for the requested parameters. Comment tree segments can be further iterated by
+  // re-invoking this RPC with a source identifier from one of resulting trees nodes.
+  CommentTree comment_tree = 1;
+  // Populated by a call to the UserBlockingService. This will contain the
+  // list of comment ids where a user has blocked the comment author.
+  // Comments where the author has blocked the viewer are filtered out (mock deleted).
+  repeated string comment_ids_with_blocked_author = 2;
+}
+
+// The request message for batch loading non-hydrated comment trees by link id
+message GetBatchCommentTreeRequest {
+  // A list of link ids to fetch individual comment trees for. Must be a valid `t3_{}` link id
+  repeated string link_ids = 1 [(validate.rules).repeated = {
+    min_items: 1,
+    max_items: 100,
+    items: {
+      string: {pattern: "^t3_[a-zA-Z0-9]+$"}
+    }
+  }];
+
+  // The sort strategy of the entries in each of the comment trees returned.
+  Comment.Sort sort = 2 [(validate.rules).enum = {
+    defined_only: true,
+    // Only allow cached sorts for this batch call.
+    in: [
+      1, // CONFIDENCE,
+      2 // TOP,
+    ]
+  }];
+
+  // The limit of tree size and depth. These are precomputed well known limits of max comments + max tree depth.
+  optional CommentTree.PrecomputedTreeView precomputed_tree_view = 3 [(validate.rules).enum = {
+    defined_only: true,
+    not_in: [0]
+  }];
+}
+
+// The batch response message for non-hydrated comment trees
+message GetBatchCommentTreeResponse {
+  // A map of the requested links and their associated non-hydrated comment tree.
+  map<string, CommentTree> comment_trees_by_link_id = 1;
+}
+
+// The request message for loading a comment tree structure from a post (link_id).
+message GetCommentTreeStructureRequest {
+  // The t3 Link Thing id for the link the comment tree structure belongs to.
+  string link_id = 1 [(validate.rules).string = {pattern: "^t3_[a-zA-Z0-9]+$"}];
+
+  // Optional cursor for pagination. When absent returns the fist page.
+  optional string cursor = 2;
+
+  // Optional maximum limit for number of parent comments in the response (defaults to and capped at 2000).
+  optional int32 limit = 3 [(validate.rules).int32.lte = 2000];
+}
+
+// The response message for loading a comment tree structure from a post (link_id).
+message GetCommentTreeStructureResponse {
+  // The comment tree structure which represents the parent-child relations of the comments.
+  CommentTreeStructure comment_tree_structure = 1;
+
+  // Cursor for the next page (empty if exhausted).
+  optional string cursor = 2;
+}

package/schema/.snootobuf/deps/reddit/coreplatform/comments/v1/comment_tree_structure.proto

@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+package reddit.coreplatform.comments.v1;
+
+option go_package = "github.snooguts.net/reddit/thing-api/go/grpc/comments/v1;comments";
+option java_multiple_files = true;
+option java_outer_classname = "CommentTreeStructureProto";
+option java_package = "com.reddit.coreplatform.api.comments.v1";
+
+// Message representing a comment tree structure.
+// A CommentTreeStructure is a map of children list to parent comments,
+// with a list of stickied comments.
+message CommentTreeStructure {
+  // The mapping of parent comment to a list of child comments.
+  message ChildrenByParent {
+    // comment id for parent comment.
+    string parent_comment_id = 1;
+    // list of comment ids for child comments.
+    repeated string child_comment_id = 2;
+    // bool flag for whether the parent comment is a top level comment.
+    bool is_top_level = 3;
+  }
+
+  // The list of children_by_parent relations.
+  repeated ChildrenByParent children_by_parent = 1;
+
+  // The list of stickied comments.
+  repeated string stickied_comment_ids = 2;
+}