Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/TelegramCore/FlatSerialization/BUILD

@@ -0,0 +1,56 @@
+load("@build_bazel_rules_swift//swift:swift.bzl", "swift_library")
+
+models = glob([
+    "Models/*.fbs",
+])
+
+model_names = [
+    f[7:-4] for f in models
+]
+
+generated_models = [ "{}_generated.swift".format(name) for name in model_names ]
+flatc_input = " ".join([ "$(location Models/{}.fbs)".format(name) for name in model_names ])
+
+genrule(
+    name = "GenerateModels",
+    srcs = models,
+    tools = [
+        "//third-party/flatc:flatc_bin"
+    ],
+    cmd_bash = 
+    """
+    set -ex
+    FLATC="$$(pwd)/$(location //third-party/flatc:flatc_bin)"
+
+    BUILD_DIR="$(RULEDIR)/build"
+    rm -rf "$$BUILD_DIR"
+    mkdir -p "$$BUILD_DIR"
+
+    "$$FLATC" --require-explicit-ids --swift -o "$$BUILD_DIR" {flatc_input}
+    """.format(
+        flatc_input=flatc_input
+    ) + "\n" + "\n".join([
+    """
+    cp "$$BUILD_DIR/{name}_generated.swift" "$(location {name}_generated.swift)"
+    """.format(name=name) for name in model_names
+    ]),
+    outs = generated_models,
+    visibility = [
+        "//visibility:public",
+    ]
+)
+
+swift_library(
+    name = "FlatSerialization",
+    module_name = "FlatSerialization",
+    srcs = generated_models,
+    copts = [
+        "-warnings-as-errors",
+    ],
+    deps = [
+        "//submodules/TelegramCore/FlatBuffers",
+    ],
+    visibility = [
+        "//visibility:public",
+    ],
+)

submodules/TelegramCore/FlatSerialization/Models/InstantPage.fbs

@@ -0,0 +1,16 @@
+include "InstantPageBlock.fbs";
+include "MediaId.fbs";
+include "Media.fbs";
+
+namespace TelegramCore;
+
+table InstantPage {
+    blocks:[InstantPageBlock] (id: 0, required);
+    media:[Media] (id: 1, required);
+    isComplete:bool (id: 2);
+    rtl:bool (id: 3);
+    url:string (id: 4, required);
+    views:int32 (id: 5);
+}
+
+root_type InstantPage;

submodules/TelegramCore/FlatSerialization/Models/InstantPageBlock.fbs

@@ -0,0 +1,235 @@
+include "RichText.fbs";
+include "MediaId.fbs";
+include "TelegramChannel.fbs";
+include "PixelDimensions.fbs";
+include "RichText.fbs";
+
+namespace TelegramCore;
+
+union InstantPageBlock_Value {
+    InstantPageBlock_Unsupported,
+    InstantPageBlock_Title,
+    InstantPageBlock_Subtitle,
+    InstantPageBlock_AuthorDate,
+    InstantPageBlock_Header,
+    InstantPageBlock_Subheader,
+    InstantPageBlock_Paragraph,
+    InstantPageBlock_Preformatted,
+    InstantPageBlock_Footer,
+    InstantPageBlock_Divider,
+    InstantPageBlock_Anchor,
+    InstantPageBlock_List,
+    InstantPageBlock_BlockQuote,
+    InstantPageBlock_PullQuote,
+    InstantPageBlock_Image,
+    InstantPageBlock_Video,
+    InstantPageBlock_Audio,
+    InstantPageBlock_Cover,
+    InstantPageBlock_WebEmbed,
+    InstantPageBlock_PostEmbed,
+    InstantPageBlock_Collage,
+    InstantPageBlock_Slideshow,
+    InstantPageBlock_ChannelBanner,
+    InstantPageBlock_Kicker,
+    InstantPageBlock_Table,
+    InstantPageBlock_Details,
+    InstantPageBlock_RelatedArticles,
+    InstantPageBlock_Map
+}
+
+table InstantPageBlock {
+    value:InstantPageBlock_Value (id: 1, required);
+}
+
+table InstantPageBlock_Unsupported {}
+
+table InstantPageBlock_Title {
+    text:RichText (id: 0, required);
+}
+
+table InstantPageBlock_Subtitle {
+    text:RichText (id: 0, required);
+}
+
+table InstantPageBlock_AuthorDate {
+    author:RichText (id: 0, required);
+    date:int32 (id: 1);
+}
+
+table InstantPageBlock_Header {
+    text:RichText (id: 0, required);
+}
+
+table InstantPageBlock_Subheader {
+    text:RichText (id: 0, required);
+}
+
+table InstantPageBlock_Paragraph {
+    text:RichText (id: 0, required);
+}
+
+table InstantPageBlock_Preformatted {
+    text:RichText (id: 0, required);
+}
+
+table InstantPageBlock_Footer {
+    text:RichText (id: 0, required);
+}
+
+table InstantPageBlock_Divider {}
+
+table InstantPageBlock_Anchor {
+    name:string (id: 0, required);
+}
+
+table InstantPageBlock_List {
+    items:[InstantPageListItem] (id: 0, required);
+    ordered:bool (id: 1);
+}
+
+table InstantPageBlock_BlockQuote {
+    text:RichText (id: 0, required);
+    caption:RichText (id: 1, required);
+}
+
+table InstantPageBlock_PullQuote {
+    text:RichText (id: 0, required);
+    caption:RichText (id: 1, required);
+}
+
+table InstantPageBlock_Image {
+    id:MediaId (id: 0, required);
+    caption:InstantPageCaption (id: 1, required);
+    url:string (id: 2);
+    webpageId:MediaId (id: 3);
+}
+
+table InstantPageBlock_Video {
+    id:MediaId (id: 0, required);
+    caption:InstantPageCaption (id: 1, required);
+    autoplay:bool (id: 2);
+    loop:bool (id: 3);
+}
+
+table InstantPageBlock_Audio {
+    id:MediaId (id: 0, required);
+    caption:InstantPageCaption (id: 1, required);
+}
+
+table InstantPageBlock_Cover {
+    block:InstantPageBlock (id: 0, required);
+}
+
+table InstantPageBlock_WebEmbed {
+    url:string (id: 0);
+    html:string (id: 1);
+    dimensions:PixelDimensions (id: 2);
+    caption:InstantPageCaption (id: 3, required);
+    stretchToWidth:bool (id: 4);
+    allowScrolling:bool (id: 5);
+    coverId:MediaId (id: 6);
+}
+
+table InstantPageBlock_PostEmbed {
+    url:string (id: 0, required);
+    webpageId:MediaId (id: 1);
+    avatarId:MediaId (id: 2);
+    author:string (id: 3, required);
+    date:int32 (id: 4);
+    blocks:[InstantPageBlock] (id: 5, required);
+    caption:InstantPageCaption (id: 6, required);
+}
+
+table InstantPageBlock_Collage {
+    items:[InstantPageBlock] (id: 0, required);
+    caption:InstantPageCaption (id: 1, required);
+}
+
+table InstantPageBlock_Slideshow {
+    items:[InstantPageBlock] (id: 0, required);
+    caption:InstantPageCaption (id: 1, required);
+}
+
+table InstantPageBlock_ChannelBanner {
+    channel:TelegramChannel (id: 0);
+}
+
+table InstantPageBlock_Kicker {
+    text:RichText (id: 0, required);
+}
+
+table InstantPageBlock_Table {
+    title:RichText (id: 0, required);
+    rows:[InstantPageTableRow] (id: 1, required);
+    bordered:bool (id: 2);
+    striped:bool (id: 3);
+}
+
+table InstantPageBlock_Details {
+    title:RichText (id: 0, required);
+    blocks:[InstantPageBlock] (id: 1, required);
+    expanded:bool (id: 2);
+}
+
+table InstantPageBlock_RelatedArticles {
+    title:RichText (id: 0, required);
+    articles:[InstantPageRelatedArticle] (id: 1, required);
+}
+
+table InstantPageBlock_Map {
+    latitude:float64 (id: 0);
+    longitude:float64 (id: 1);
+    zoom:int32 (id: 2);
+    dimensions:PixelDimensions (id: 3, required);
+    caption:InstantPageCaption (id: 4, required);
+}
+
+table InstantPageCaption {
+    text:RichText (id: 0, required);
+    credit:RichText (id: 1, required);
+}
+
+union InstantPageListItem_Value {
+    InstantPageListItem_Text,
+    InstantPageListItem_Blocks,
+    InstantPageListItem_Unknown
+}
+
+table InstantPageListItem {
+    value:InstantPageListItem_Value (id: 1, required);
+}
+
+table InstantPageListItem_Text {
+    text:RichText (id: 0, required);
+    number:string (id: 1);
+}
+
+table InstantPageListItem_Blocks {
+    blocks:[InstantPageBlock] (id: 0, required);
+    number:string (id: 1);
+}
+
+table InstantPageListItem_Unknown {}
+
+table InstantPageTableCell {
+    text:RichText (id: 0);
+    header:bool (id: 1);
+    alignment:int32 (id: 2);
+    verticalAlignment:int32 (id: 3);
+    colspan:int32 (id: 4);
+    rowspan:int32 (id: 5);
+}
+
+table InstantPageTableRow {
+    cells:[InstantPageTableCell] (id: 0, required);
+}
+
+table InstantPageRelatedArticle {
+    url:string (id: 0, required);
+    webpageId:MediaId (id: 1, required);
+    title:string (id: 2);
+    description:string (id: 3);
+    photoId:MediaId (id: 4);
+    author:string (id: 5);
+    date:int32 (id: 6);
+}

submodules/TelegramCore/FlatSerialization/Models/ItemCollectionId.fbs

@@ -0,0 +1,6 @@
+namespace TelegramCore;
+
+struct ItemCollectionId {
+    namespace: int;
+    id: int64;
+}

submodules/TelegramCore/FlatSerialization/Models/Media.fbs

@@ -0,0 +1,23 @@
+include "MediaId.fbs";
+include "TelegramMediaFile.fbs";
+include "TelegramMediaImage.fbs";
+namespace TelegramCore;
+
+union Media_Value {
+    Media_TelegramMediaFile,
+    Media_TelegramMediaImage
+}
+
+table Media {
+    value:Media_Value (id: 1, required);
+}
+
+table Media_TelegramMediaFile {
+    file:TelegramMediaFile (id: 0, required);
+}
+
+table Media_TelegramMediaImage {
+    image:TelegramMediaImage (id: 0, required);
+}
+
+root_type Media;

submodules/TelegramCore/FlatSerialization/Models/MediaId.fbs

@@ -0,0 +1,6 @@
+namespace TelegramCore;
+
+struct MediaId {
+    namespace: int;
+    id: int64;
+}

submodules/TelegramCore/FlatSerialization/Models/MessageId.fbs

@@ -0,0 +1,9 @@
+include "PeerId.fbs";
+
+namespace TelegramCore;
+
+struct MessageId {
+    peerId: PeerId (id: 0);
+    namespace: int32 (id: 1);
+    id: int32 (id: 2);
+}

submodules/TelegramCore/FlatSerialization/Models/Optional.fbs

@@ -0,0 +1,5 @@
+namespace TelegramCore;
+
+struct OptionalBool {
+    value:bool (id: 0);
+}

submodules/TelegramCore/FlatSerialization/Models/PartialMediaReference.fbs

@@ -0,0 +1,62 @@
+include "MessageId.fbs";
+include "PeerId.fbs";
+include "PeerReference.fbs";
+include "StickerPackReference.fbs";
+
+namespace TelegramCore;
+
+table MessageReference {
+    peer:PeerReference (id: 0, required);
+    author:PeerReference (id: 1);
+    messageId:MessageId (id: 2, required);
+    timestamp:int32 (id: 3);
+    incoming:bool (id: 4);
+    secret:bool (id: 5);
+    threadId:int64 (id: 6);
+}
+
+table WebpageReference {
+    webpageId:int64 (id: 0);
+    url:string (id: 1, required);
+}
+
+table PartialMediaReference_Message {
+    message:MessageReference (id: 0);
+}
+
+table PartialMediaReference_WebPage {
+    webPage:WebpageReference (id: 0);
+}
+
+table PartialMediaReference_StickerPack {
+    stickerPack:StickerPackReference (id: 0, required);
+}
+
+table PartialMediaReference_SavedGif {
+}
+
+table PartialMediaReference_SavedSticker {
+}
+
+table PartialMediaReference_RecentSticker {
+}
+
+table PartialMediaReference_SavedMusic {
+    peer:PeerReference (id: 0);
+}
+
+union PartialMediaReference_Value {
+    PartialMediaReference_Message,
+    PartialMediaReference_WebPage,
+    PartialMediaReference_StickerPack,
+    PartialMediaReference_SavedGif,
+    PartialMediaReference_SavedSticker,
+    PartialMediaReference_RecentSticker,
+    PartialMediaReference_SavedMusic
+}
+
+table PartialMediaReference {
+    value:PartialMediaReference_Value (id: 1, required);
+}
+
+root_type PartialMediaReference;

submodules/TelegramCore/FlatSerialization/Models/PeerAccessRestrictionInfo.fbs

@@ -0,0 +1,11 @@
+namespace TelegramCore;
+
+table RestrictionRule {
+    platform:string (id: 0, required);
+    reason:string (id: 1, required);
+    text:string (id: 2, required);
+}
+
+table PeerAccessRestrictionInfo {
+    rules:[RestrictionRule] (id: 0, required);
+}

submodules/TelegramCore/FlatSerialization/Models/PeerCollectibleColor.fbs

@@ -0,0 +1,13 @@
+namespace TelegramCore;
+
+table PeerCollectibleColor {
+  collectibleId:long (id: 0);
+  giftEmojiFileId:long (id: 1);
+  backgroundEmojiId:long (id: 2);
+  accentColor:uint (id: 3);
+  colors:[uint] (id: 4);
+  darkAccentColor:uint (id: 5);
+  darkColors:[uint] (id: 6);
+}
+
+root_type PeerCollectibleColor;

submodules/TelegramCore/FlatSerialization/Models/PeerEmojiStatus.fbs

@@ -0,0 +1,31 @@
+namespace TelegramCore;
+
+table PeerEmojiStatusContentEmoji {
+    fileId:int64 (id: 0);
+}
+
+table PeerEmojiStatusContentStarGift {
+    id:int64 (id: 0);
+    fileId:int64 (id: 1);
+    title:string (id: 2, required);
+    slug:string (id: 3, required);
+    patternFileId:int64 (id: 4);
+    innerColor:int32 (id: 5);
+    outerColor:int32 (id: 6);
+    patternColor:int32 (id: 7);
+    textColor:int32 (id: 8);
+}
+
+union PeerEmojiStatusContent_Value {
+    PeerEmojiStatusContentEmoji,
+    PeerEmojiStatusContentStarGift
+}
+
+table PeerEmojiStatusContent {
+    value:PeerEmojiStatusContent_Value (id: 1, required);
+}
+
+table PeerEmojiStatus {
+    content:PeerEmojiStatusContent (id: 0, required);
+    expirationDate:int32 (id: 1);
+}

submodules/TelegramCore/FlatSerialization/Models/PeerId.fbs

@@ -0,0 +1,6 @@
+namespace TelegramCore;
+
+struct PeerId {
+    namespace: int32 (id: 0);
+    id: int64 (id: 1);
+}

submodules/TelegramCore/FlatSerialization/Models/PeerNameColor.fbs

@@ -0,0 +1,7 @@
+namespace TelegramCore;
+
+table PeerNameColor {
+    value:int32 (id: 0);
+}
+
+root_type PeerNameColor;

submodules/TelegramCore/FlatSerialization/Models/PeerReference.fbs

@@ -0,0 +1,27 @@
+namespace TelegramCore;
+
+table PeerReference_User {
+    id:int64 (id: 0);
+    accessHash:int64 (id: 1);
+}
+
+table PeerReference_Group {
+    id:int64 (id: 0);
+}
+
+table PeerReference_Channel {
+    id:int64 (id: 0);
+    accessHash:int64 (id: 1);
+}
+
+union PeerReference_Value {
+    PeerReference_User,
+    PeerReference_Group,
+    PeerReference_Channel
+}
+
+table PeerReference {
+    value:PeerReference_Value (id: 1, required);
+}
+
+root_type PeerReference;

submodules/TelegramCore/FlatSerialization/Models/PixelDimensions.fbs

@@ -0,0 +1,6 @@
+namespace TelegramCore;
+
+struct PixelDimensions {
+    width: int;
+    height: int;
+}

submodules/TelegramCore/FlatSerialization/Models/RichText.fbs

@@ -0,0 +1,95 @@
+include "MediaId.fbs";
+include "PixelDimensions.fbs";
+
+namespace TelegramCore;
+
+union RichText_Value {
+    RichText_Empty,
+    RichText_Plain,
+    RichText_Bold,
+    RichText_Italic,
+    RichText_Underline,
+    RichText_Strikethrough,
+    RichText_Fixed,
+    RichText_Url,
+    RichText_Email,
+    RichText_Concat,
+    RichText_Subscript,
+    RichText_Superscript,
+    RichText_Marked,
+    RichText_Phone,
+    RichText_Image,
+    RichText_Anchor
+}
+
+table RichText {
+    value:RichText_Value (id: 1, required);
+}
+
+table RichText_Empty {}
+
+table RichText_Plain {
+    text:string (id: 0, required);
+}
+
+table RichText_Bold {
+    text:RichText (id: 0, required);
+}
+
+table RichText_Italic {
+    text:RichText (id: 0, required);
+}
+
+table RichText_Underline {
+    text:RichText (id: 0, required);
+}
+
+table RichText_Strikethrough {
+    text:RichText (id: 0, required);
+}
+
+table RichText_Fixed {
+    text:RichText (id: 0, required);
+}
+
+table RichText_Url {
+    text:RichText (id: 0, required);
+    url:string (id: 1, required);
+    webpageId:MediaId (id: 2);
+}
+
+table RichText_Email {
+    text:RichText (id: 0, required);
+    email:string (id: 1, required);
+}
+
+table RichText_Concat {
+    texts:[RichText] (id: 0, required);
+}
+
+table RichText_Subscript {
+    text:RichText (id: 0, required);
+}
+
+table RichText_Superscript {
+    text:RichText (id: 0, required);
+}
+
+table RichText_Marked {
+    text:RichText (id: 0, required);
+}
+
+table RichText_Phone {
+    text:RichText (id: 0, required);
+    phone:string (id: 1, required);
+}
+
+table RichText_Image {
+    id:MediaId (id: 0, required);
+    dimensions:PixelDimensions (id: 1, required);
+}
+
+table RichText_Anchor {
+    text:RichText (id: 0, required);
+    name:string (id: 1, required);
+}

submodules/TelegramCore/FlatSerialization/Models/StarsAmount.fbs

@@ -0,0 +1,6 @@
+namespace TelegramCore;
+
+table StarsAmount {
+    value:int64 (id: 0);
+    nanos:int32 (id: 1);
+}

submodules/TelegramCore/FlatSerialization/Models/StickerPackCollectionInfo.fbs

@@ -0,0 +1,19 @@
+include "ItemCollectionId.fbs";
+include "TelegramMediaImageRepresentation.fbs";
+
+namespace TelegramCore;
+
+table StickerPackCollectionInfo {
+    id:ItemCollectionId (id: 0, required);
+    flags:int32 (id: 1);
+    accessHash:int64 (id: 2);
+    title:string (id: 3, required);
+    shortName:string (id: 4, required);
+    thumbnail:TelegramMediaImageRepresentation (id: 5);
+    thumbnailFileId:int64 (id: 6);
+    immediateThumbnailData:[ubyte] (id: 7);
+    hash:int32 (id: 8);
+    count:int32 (id: 9);
+}
+
+root_type StickerPackCollectionInfo;

submodules/TelegramCore/FlatSerialization/Models/StickerPackReference.fbs

@@ -0,0 +1,58 @@
+namespace TelegramCore;
+
+table StickerPackReference_Id {
+    id:int64 (id: 0);
+    accessHash:int64 (id: 1);
+}
+
+table StickerPackReference_Name {
+    name:string (id: 0, required);
+}
+
+table StickerPackReference_AnimatedEmoji {
+}
+
+table StickerPackReference_Dice {
+    emoji:string (id: 0, required);
+}
+
+table StickerPackReference_AnimatedEmojiAnimations {
+}
+
+table StickerPackReference_PremiumGifts {
+}
+
+table StickerPackReference_EmojiGenericAnimations {
+}
+
+table StickerPackReference_IconStatusEmoji {
+}
+
+table StickerPackReference_IconTopicEmoji {
+}
+
+table StickerPackReference_IconChannelStatusEmoji {
+}
+
+table StickerPackReference_TonGifts {
+}
+
+union StickerPackReference_Value {
+    StickerPackReference_Id,
+    StickerPackReference_Name,
+    StickerPackReference_AnimatedEmoji,
+    StickerPackReference_Dice,
+    StickerPackReference_AnimatedEmojiAnimations,
+    StickerPackReference_PremiumGifts,
+    StickerPackReference_EmojiGenericAnimations,
+    StickerPackReference_IconStatusEmoji,
+    StickerPackReference_IconTopicEmoji,
+    StickerPackReference_IconChannelStatusEmoji,
+    StickerPackReference_TonGifts
+}
+
+table StickerPackReference {
+    value:StickerPackReference_Value (id: 1, required);
+}
+
+root_type StickerPackReference;

submodules/TelegramCore/FlatSerialization/Models/StoredDeviceContactData.fbs

@@ -0,0 +1,14 @@
+namespace TelegramCore;
+
+table DeviceContactPhoneNumberData {
+    label:string (id: 0, required);
+    value:string (id: 1, required);
+}
+
+table StoredDeviceContactData {
+    firstName:string (id: 0, required);
+    lastName:string (id: 1, required);
+    phoneNumbers:[DeviceContactPhoneNumberData] (id: 2);
+}
+
+root_type StoredDeviceContactData;

submodules/TelegramCore/FlatSerialization/Models/TelegramChannel.fbs

@@ -0,0 +1,62 @@
+include "PeerId.fbs";
+include "TelegramPeerAccessHash.fbs";
+include "TelegramMediaImageRepresentation.fbs";
+include "PeerAccessRestrictionInfo.fbs";
+include "TelegramChatAdminRights.fbs";
+include "TelegramChatBannedRights.fbs";
+include "TelegramPeerUsername.fbs";
+include "Optional.fbs";
+include "PeerNameColor.fbs";
+include "PeerEmojiStatus.fbs";
+include "StarsAmount.fbs";
+
+namespace TelegramCore;
+
+table TelegramChannelInfo_Broadcast {
+    flags:int32 (id: 0);
+}
+
+table TelegramChannelInfo_Group {
+    flags:int32 (id: 0);
+}
+
+union TelegramChannelInfo_Value {
+    TelegramChannelInfo_Broadcast,
+    TelegramChannelInfo_Group
+}
+
+table TelegramChannelInfo {
+    value:TelegramChannelInfo_Value (id: 1, required);
+}
+
+table TelegramChannel {
+    id:PeerId (id: 0, required);
+    accessHash:TelegramPeerAccessHash (id: 1);
+    title:string (id: 2, required);
+    username:string (id: 3);
+    photo:[TelegramMediaImageRepresentation] (id: 4);
+    creationDate:int32 (id: 5);
+    version:int32 (id: 6);
+    participationStatus:int32 (id: 7);
+    info:TelegramChannelInfo (id: 8, required);
+    flags:int32 (id: 9);
+    restrictionInfo:PeerAccessRestrictionInfo (id: 10);
+    adminRights:TelegramChatAdminRights (id: 11);
+    bannedRights:TelegramChatBannedRights (id: 12);
+    defaultBannedRights:TelegramChatBannedRights (id: 13);
+    usernames:[TelegramPeerUsername] (id: 14);
+    storiesHidden:OptionalBool (id: 15);
+    nameColor:PeerNameColor (id: 16);
+    backgroundEmojiId:int64 (id: 17);
+    profileColor:PeerNameColor (id: 18);
+    profileBackgroundEmojiId:int64 (id: 19);
+    emojiStatus:PeerEmojiStatus (id: 20);
+    approximateBoostLevel:int32 (id: 21);
+    subscriptionUntilDate:int32 (id: 22);
+    verificationIconFileId:int64 (id: 23);
+    sendPaidMessageStars:StarsAmount (id: 24);
+    linkedMonoforumId:PeerId (id: 25);
+    linkedBotId:PeerId (id: 26, deprecated);
+}
+
+root_type TelegramChannel;

submodules/TelegramCore/FlatSerialization/Models/TelegramChatAdminRights.fbs

@@ -0,0 +1,7 @@
+namespace TelegramCore;
+
+table TelegramChatAdminRights {
+    rights:int32 (id: 0);
+}
+
+root_type TelegramChatAdminRights;

submodules/TelegramCore/FlatSerialization/Models/TelegramChatBannedRights.fbs

@@ -0,0 +1,7 @@
+namespace TelegramCore;
+
+table TelegramChatBannedRights {
+    flags:int32 (id: 0);
+    untilDate:int32 (id: 1);
+}
+

submodules/TelegramCore/FlatSerialization/Models/TelegramGroup.fbs

@@ -0,0 +1,48 @@
+include "PeerId.fbs";
+include "TelegramMediaImageRepresentation.fbs";
+include "TelegramChatAdminRights.fbs";
+include "TelegramChatBannedRights.fbs";
+
+namespace TelegramCore;
+
+table TelegramGroupRole_Creator {
+    rank:string (id: 0);
+}
+
+table TelegramGroupRole_Admin {
+    rights:TelegramChatAdminRights (id: 0, required);
+    rank:string (id: 1);
+}
+
+table TelegramGroupRole_Member {}
+
+union TelegramGroupRole_Value {
+    TelegramGroupRole_Creator,
+    TelegramGroupRole_Admin,
+    TelegramGroupRole_Member
+}
+
+table TelegramGroupRole {
+    value:TelegramGroupRole_Value (id: 1, required);
+}
+
+table TelegramGroupToChannelMigrationReference {
+    peerId:int64 (id: 0);
+    accessHash:int64 (id: 1);
+}
+
+table TelegramGroup {
+    id:PeerId (id: 0, required);
+    title:string (id: 1, required);
+    photo:[TelegramMediaImageRepresentation] (id: 2, required);
+    participantCount:int32 (id: 3);
+    role:TelegramGroupRole (id: 4, required);
+    membership:int32 (id: 5);
+    flags:int32 (id: 6);
+    defaultBannedRights:TelegramChatBannedRights (id: 7);
+    migrationReference:TelegramGroupToChannelMigrationReference (id: 8);
+    creationDate:int32 (id: 9);
+    version:int32 (id: 10);
+}
+
+root_type TelegramGroup;

submodules/TelegramCore/FlatSerialization/Models/TelegramMediaFile.fbs

@@ -0,0 +1,25 @@
+include "MediaId.fbs";
+include "TelegramMediaResource.fbs";
+include "TelegramMediaFileAttribute.fbs";
+include "TelegramMediaImageRepresentation.fbs";
+include "VideoThumbnail.fbs";
+include "TelegramMediaImage.fbs";
+include "PartialMediaReference.fbs";
+
+namespace TelegramCore;
+
+table TelegramMediaFile {
+    fileId:MediaId (id: 0, required);
+    partialReference:PartialMediaReference (id: 1);
+    resource:TelegramMediaResource (id: 2, required);
+    previewRepresentations:[TelegramMediaImageRepresentation] (id: 3);
+    videoThumbnails:[VideoThumbnail] (id: 4);
+    videoCover:TelegramMediaImage (id: 5);
+    immediateThumbnailData:[ubyte] (id: 6);
+    mimeType:string (id: 7, required);
+    size:int64 (id: 8);
+    attributes:[TelegramMediaFileAttribute] (id: 9);
+    alternativeRepresentations:[TelegramMediaFile] (id: 10);
+}
+
+root_type TelegramMediaFile;

submodules/TelegramCore/FlatSerialization/Models/TelegramMediaFileAttribute.fbs

@@ -0,0 +1,85 @@
+include "StickerPackReference.fbs";
+
+namespace TelegramCore;
+
+table TelegramMediaFileAttribute_FileName {
+    fileName:string (id: 0, required);
+}
+
+table StickerMaskCoords {
+    n:int32 (id: 0);
+    x:float32 (id: 1); 
+    y:float32 (id: 2);
+    zoom:float32 (id: 3);
+}
+
+table TelegramMediaFileAttribute_Sticker {
+    displayText:string (id: 0, required);
+    packReference:StickerPackReference (id: 1);
+    maskData:StickerMaskCoords (id: 2);
+}
+
+table TelegramMediaFileAttribute_ImageSize {
+    width:int32 (id: 0);
+    height:int32 (id: 1);
+}
+
+table TelegramMediaFileAttribute_Animated {
+}
+
+table TelegramMediaFileAttribute_Video {
+    duration:float32 (id: 0);
+    width:int32 (id: 1);
+    height:int32 (id: 2);
+    flags:int32 (id: 3);
+    preloadSize:int32 (id: 4);
+    coverTime:float32 (id: 5);
+    videoCodec:string (id: 6);
+}
+
+table TelegramMediaFileAttribute_Audio {
+    isVoice:bool (id: 0);
+    duration:int32 (id: 1);
+    title:string (id: 2);
+    performer:string (id: 3);
+    waveform:[ubyte] (id: 4);
+}
+
+table TelegramMediaFileAttribute_HasLinkedStickers {
+}
+
+table TelegramMediaFileAttribute_HintFileIsLarge {
+}
+
+table TelegramMediaFileAttribute_HintIsValidated {
+}
+
+table TelegramMediaFileAttribute_NoPremium {
+}
+
+table TelegramMediaFileAttribute_CustomEmoji {
+    isPremium:bool (id: 0);
+    isSingleColor:bool (id: 1);
+    alt:string (id: 2, required);
+    packReference:StickerPackReference (id: 3);
+}
+
+union TelegramMediaFileAttribute_Value {
+    TelegramMediaFileAttribute_FileName,
+    TelegramMediaFileAttribute_Sticker,
+    TelegramMediaFileAttribute_ImageSize,
+    TelegramMediaFileAttribute_Animated,
+    TelegramMediaFileAttribute_Video,
+    TelegramMediaFileAttribute_Audio,
+    TelegramMediaFileAttribute_HasLinkedStickers,
+    TelegramMediaFileAttribute_HintFileIsLarge,
+    TelegramMediaFileAttribute_HintIsValidated,
+    TelegramMediaFileAttribute_NoPremium,
+    TelegramMediaFileAttribute_CustomEmoji
+}
+
+table TelegramMediaFileAttribute {
+    value:TelegramMediaFileAttribute_Value (id: 1, required);
+}
+
+root_type TelegramMediaFileAttribute;

submodules/TelegramCore/FlatSerialization/Models/TelegramMediaImage.fbs

@@ -0,0 +1,51 @@
+include "MediaId.fbs";
+include "TelegramMediaImageRepresentation.fbs";
+include "StickerPackReference.fbs";
+include "PartialMediaReference.fbs";
+
+namespace TelegramCore;
+
+table TelegramMediaImageReference {
+    imageId:int64 (id: 0);
+    accessHash:int64 (id: 1);
+    fileReference:[ubyte] (id: 2);
+}
+
+table VideoRepresentation {
+    width:int32 (id: 0);
+    height:int32 (id: 1);
+    resource:TelegramMediaResource (id: 2, required);
+    startTimestamp:float32 (id: 3);
+}
+
+table EmojiMarkup_Content_Emoji {
+    fileId:int64 (id: 0);
+}
+
+table EmojiMarkup_Content_Sticker {
+    packReference:StickerPackReference (id: 0, required);
+    fileId:int64 (id: 1);
+}
+
+union EmojiMarkup_Content {
+    EmojiMarkup_Content_Emoji,
+    EmojiMarkup_Content_Sticker
+}
+
+table EmojiMarkup {
+    content:EmojiMarkup_Content (id: 1, required);
+    backgroundColors:[int32] (id: 2);
+}
+
+table TelegramMediaImage {
+    imageId:MediaId (id: 0, required);
+    representations:[TelegramMediaImageRepresentation] (id: 1);
+    videoRepresentations:[VideoRepresentation] (id: 2);
+    immediateThumbnailData:[ubyte] (id: 3);
+    emojiMarkup:EmojiMarkup (id: 4);
+    reference:TelegramMediaImageReference (id: 5);
+    partialReference:PartialMediaReference (id: 6);
+    flags:int32 (id: 7);
+}
+
+root_type TelegramMediaImage;

submodules/TelegramCore/FlatSerialization/Models/TelegramMediaImageRepresentation.fbs

@@ -0,0 +1,22 @@
+include "TelegramMediaResource.fbs";
+
+namespace TelegramCore;
+
+enum TelegramMediaImageRepresentation_TypeHint:int32 {
+    generic = 0,
+    animated = 1,
+    video = 2
+}
+
+table TelegramMediaImageRepresentation {
+    width:int32 (id: 0);
+    height:int32 (id: 1);
+    resource:TelegramMediaResource (id: 2, required);
+    progressiveSizes:[int32] (id: 3);
+    immediateThumbnailData:[ubyte] (id: 4);
+    hasVideo:bool (id: 5);
+    isPersonal:bool (id: 6);
+    typeHint:TelegramMediaImageRepresentation_TypeHint (id: 7);
+}
+
+root_type TelegramMediaImageRepresentation;

submodules/TelegramCore/FlatSerialization/Models/TelegramMediaResource.fbs

@@ -0,0 +1,78 @@
+namespace TelegramCore;
+
+table TelegramMediaResource_CloudFileMediaResource {
+    datacenterId:int32 (id: 0);
+    volumeId:int64 (id: 1);
+    localId:int32 (id: 2);
+    secret:int64 (id: 3);
+    size:int64 (id: 4);
+    fileReference:[ubyte] (id: 5);
+}
+
+table TelegramMediaResource_CloudDocumentSizeMediaResource {
+    datacenterId:int32 (id: 0);
+    documentId:int64 (id: 1);
+    accessHash:int64 (id: 2);
+    sizeSpec:string (id: 3, required);
+    fileReference:[ubyte] (id: 4);
+}
+
+table TelegramMediaResource_CloudPhotoSizeMediaResource {
+    datacenterId:int32 (id: 0);
+    photoId:int64 (id: 1);
+    accessHash:int64 (id: 2);
+    sizeSpec:string (id: 3, required);
+    size:int64 (id: 4);
+    fileReference:[ubyte] (id: 5);
+}
+
+enum CloudPeerPhotoSizeSpec:int32 {
+    small = 0,
+    fullSize = 1
+}
+
+table TelegramMediaResource_CloudPeerPhotoSizeMediaResource {
+    datacenterId:int32 (id: 0);
+    photoId:int64 (id: 1);
+    sizeSpec:CloudPeerPhotoSizeSpec (id: 2);
+    volumeId:int64 (id: 3);
+    localId:int32 (id: 4);
+}
+
+table TelegramMediaResource_CloudStickerPackThumbnailMediaResource {
+    datacenterId:int32 (id: 0);
+    thumbVersion:int32 (id: 1);
+    volumeId:int64 (id: 2);
+    localId:int32 (id: 3);
+}
+
+table TelegramMediaResource_CloudDocumentMediaResource {
+    datacenterId:int32 (id: 0);
+    fileId:int64 (id: 1);
+    accessHash:int64 (id: 2);
+    size:int64 (id: 3);
+    fileReference:[ubyte] (id: 4);
+    fileName:string (id: 5);
+}
+
+table TelegramMediaResource_LocalFileMediaResource {
+    fileId:int64 (id: 0);
+    size:int64 (id: 1);
+    isSecretRelated:bool (id: 2);
+}
+
+union TelegramMediaResource_Value {
+    TelegramMediaResource_CloudFileMediaResource,
+    TelegramMediaResource_CloudDocumentSizeMediaResource,
+    TelegramMediaResource_CloudPhotoSizeMediaResource,
+    TelegramMediaResource_CloudPeerPhotoSizeMediaResource,
+    TelegramMediaResource_CloudStickerPackThumbnailMediaResource,
+    TelegramMediaResource_CloudDocumentMediaResource,
+    TelegramMediaResource_LocalFileMediaResource
+}
+
+table TelegramMediaResource {
+    value:TelegramMediaResource_Value (id: 1, required);
+}
+
+root_type TelegramMediaResource;

submodules/TelegramCore/FlatSerialization/Models/TelegramPeerAccessHash.fbs

@@ -0,0 +1,18 @@
+namespace TelegramCore;
+
+table TelegramPeerAccessHash_Personal {
+    accessHash:int64 (id: 0);
+}
+
+table TelegramPeerAccessHash_GenericPublic {
+    accessHash:int64 (id: 0);
+}
+
+union TelegramPeerAccessHash_Value {
+    TelegramPeerAccessHash_Personal,
+    TelegramPeerAccessHash_GenericPublic
+}
+
+table TelegramPeerAccessHash {
+    value:TelegramPeerAccessHash_Value (id: 1, required);
+}

submodules/TelegramCore/FlatSerialization/Models/TelegramPeerUsername.fbs

@@ -0,0 +1,8 @@
+namespace TelegramCore;
+
+table TelegramPeerUsername {
+    flags:int32 (id: 0);
+    username:string (id: 1, required);
+}
+
+root_type TelegramPeerUsername;

submodules/TelegramCore/FlatSerialization/Models/TelegramUser.fbs

@@ -0,0 +1,42 @@
+include "PeerId.fbs";
+include "TelegramPeerAccessHash.fbs";
+include "TelegramMediaImageRepresentation.fbs";
+include "PeerAccessRestrictionInfo.fbs";
+include "PeerEmojiStatus.fbs";
+include "TelegramPeerUsername.fbs";
+include "PeerNameColor.fbs";
+include "PeerCollectibleColor.fbs";
+include "Optional.fbs";
+include "StarsAmount.fbs";
+
+namespace TelegramCore;
+
+table BotUserInfo {
+    flags:int32 (id: 0);
+    inlinePlaceholder:string (id: 1);
+}
+
+table TelegramUser {
+    id:PeerId (id: 0, required);
+    accessHash:TelegramPeerAccessHash (id: 1);
+    firstName:string (id: 2);
+    lastName:string (id: 3);
+    username:string (id: 4);
+    phone:string (id: 5);
+    photo:[TelegramMediaImageRepresentation] (id: 6, required);
+    botInfo:BotUserInfo (id: 7);
+    restrictionInfo:PeerAccessRestrictionInfo (id: 8);
+    flags:int32 (id: 9);
+    emojiStatus:PeerEmojiStatus (id: 10);
+    usernames:[TelegramPeerUsername] (id: 11);
+    storiesHidden:OptionalBool (id: 12);
+    nameColor:PeerNameColor (id: 13);
+    backgroundEmojiId:int64 (id: 14);
+    profileColor:PeerNameColor (id: 15);
+    profileBackgroundEmojiId:int64 (id: 16);
+    subscriberCount:int32 (id: 17);
+    verificationIconFileId:int64 (id: 18);
+    collectibleColor:PeerCollectibleColor (id: 19);
+}
+
+root_type TelegramUser;

submodules/TelegramCore/FlatSerialization/Models/VideoThumbnail.fbs

@@ -0,0 +1,11 @@
+include "TelegramMediaResource.fbs";
+
+namespace TelegramCore;
+
+table VideoThumbnail {
+    width:int32 (id: 0);
+    height:int32 (id: 1);
+    resource:TelegramMediaResource (id: 2, required);
+}
+
+root_type VideoThumbnail;

submodules/TelegramCore/FlatSerialization/Package.swift

@@ -0,0 +1,30 @@
+// swift-tools-version:5.5
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "FlatSerialization",
+    platforms: [.macOS(.v10_13)],
+    products: [
+        // Products define the executables and libraries a package produces, and make them visible to other packages.
+        .library(
+            name: "FlatSerialization",
+            targets: ["FlatSerialization"]),
+    ],
+    dependencies: [
+        // Dependencies declare other packages that this package depends on.
+        // .package(url: /* package url */, from: "1.0.0"),
+        .package(name: "FlatBuffers", path: "../FlatBuffers")
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+        // Targets can depend on other targets in this package, and on products in packages this package depends on.
+        .target(
+            name: "FlatSerialization",
+            dependencies: [
+                .product(name: "FlatBuffers", package: "FlatBuffers", condition: nil),
+            ],
+            path: "Sources"),
+    ]
+)

submodules/TelegramCore/FlatSerialization/macOS/generate.sh

@@ -0,0 +1,72 @@
+#!/bin/sh
+
+# Default directories
+OUTPUT_DIR=""
+INPUT_DIR=""
+BINARY_PATH=""
+
+# Parse command line arguments
+while [ "$#" -gt 0 ]; do
+    case "$1" in
+        --binary)
+            BINARY_PATH="$2"
+            shift 2
+            ;;
+        --output)
+            OUTPUT_DIR="$2"
+            shift 2
+            ;;
+        --input)
+            INPUT_DIR="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown parameter: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Validate output directory
+if [ -z "$OUTPUT_DIR" ]; then
+    echo "Error: --output argument is required"
+    exit 1
+fi
+
+# Validate output directory
+if [ -z "$BINARY_PATH" ]; then
+    echo "Error: --binary argument is required"
+    exit 1
+fi
+
+if [ ! -d "$OUTPUT_DIR" ]; then
+    echo "Error: Output directory does not exist: $OUTPUT_DIR"
+    exit 1
+fi
+
+# Validate input directory
+if [ -z "$INPUT_DIR" ]; then
+    echo "Error: --input argument is required"
+    exit 1
+fi
+
+if [ ! -d "$INPUT_DIR" ]; then
+    echo "Error: Input directory does not exist: $INPUT_DIR"
+    exit 1
+fi
+
+# Remove existing Swift files from output directory
+rm -f "$OUTPUT_DIR"/*.swift
+
+# Get all .fbs files in Models directory
+models=$(ls "$INPUT_DIR"/*.fbs)
+
+# Initialize empty flatc_input
+flatc_input=""
+
+# Build space-separated list of model paths
+for model in $models; do
+    flatc_input="$flatc_input $model"
+done
+
+$BINARY_PATH --require-explicit-ids --swift -o "$OUTPUT_DIR" ${flatc_input}