gotd: update to layer 218

2025-12-03 14:22:16 +02:00
parent b38c3cc935
commit 66b84a7b44
2065 changed files with 53382 additions and 684259 deletions
@@ -34,3 +34,48 @@ func (s *MessagesGetQuickReplies) computeHash(v *tg.MessagesQuickReplies) int64

 	return h.Sum()
 }
+
+func (s *PaymentsGetStarGiftCollections) computeHash(v *tg.PaymentsStarGiftCollections) int64 {
+	collections := v.Collections
+
+	sort.SliceStable(collections, func(i, j int) bool {
+		return collections[i].CollectionID < collections[j].CollectionID
+	})
+
+	h := hasher.Hasher{}
+	for _, collection := range collections {
+		h.Update(uint32(collection.CollectionID))
+	}
+
+	return h.Sum()
+}
+
+func (s *AccountGetSavedMusicIDs) computeHash(v *tg.AccountSavedMusicIDs) int64 {
+	ids := v.IDs
+
+	sort.SliceStable(ids, func(i, j int) bool {
+		return ids[i] < ids[j]
+	})
+
+	h := hasher.Hasher{}
+	for _, id := range ids {
+		h.Update(uint32(id))
+	}
+
+	return h.Sum()
+}
+
+func (s *PaymentsGetStarGiftActiveAuctions) computeHash(v *tg.PaymentsStarGiftActiveAuctions) int64 {
+	auctions := v.Auctions
+
+	sort.SliceStable(auctions, func(i, j int) bool {
+		return auctions[i].GetGift().GetID() < auctions[j].GetGift().GetID()
+	})
+
+	h := hasher.Hasher{}
+	for _, auction := range auctions {
+		h.Update(uint32(auction.GetGift().GetID()))
+	}
+
+	return h.Sum()
+}
@@ -770,6 +770,90 @@ func (s *AccountGetRecentEmojiStatuses) Fetch(ctx context.Context) (bool, error)
 	}
 }

+type innerAccountGetSavedMusicIDs struct {
+	// Last received hash.
+	hash int64
+	// Last received result.
+	value *tg.AccountSavedMusicIDs
+}
+
+type AccountGetSavedMusicIDs struct {
+	// Result state.
+	last atomic.Value
+
+	// Reference to RPC client to make requests.
+	raw *tg.Client
+}
+
+// NewAccountGetSavedMusicIDs creates new AccountGetSavedMusicIDs.
+func NewAccountGetSavedMusicIDs(raw *tg.Client) *AccountGetSavedMusicIDs {
+	q := &AccountGetSavedMusicIDs{
+		raw: raw,
+	}
+
+	return q
+}
+
+func (s *AccountGetSavedMusicIDs) store(v innerAccountGetSavedMusicIDs) {
+	s.last.Store(v)
+}
+
+func (s *AccountGetSavedMusicIDs) load() (innerAccountGetSavedMusicIDs, bool) {
+	v, ok := s.last.Load().(innerAccountGetSavedMusicIDs)
+	return v, ok
+}
+
+// Value returns last received result.
+// NB: May be nil. Returned AccountSavedMusicIDs must not be mutated.
+func (s *AccountGetSavedMusicIDs) Value() *tg.AccountSavedMusicIDs {
+	inner, _ := s.load()
+	return inner.value
+}
+
+// Hash returns last received hash.
+func (s *AccountGetSavedMusicIDs) Hash() int64 {
+	inner, _ := s.load()
+	return inner.hash
+}
+
+// Get updates data if needed and returns it.
+func (s *AccountGetSavedMusicIDs) Get(ctx context.Context) (*tg.AccountSavedMusicIDs, error) {
+	if _, err := s.Fetch(ctx); err != nil {
+		return nil, err
+	}
+
+	return s.Value(), nil
+}
+
+// Fetch updates data if needed and returns true if data was modified.
+func (s *AccountGetSavedMusicIDs) Fetch(ctx context.Context) (bool, error) {
+	lastHash := s.Hash()
+
+	req := lastHash
+	result, err := s.raw.AccountGetSavedMusicIDs(ctx, req)
+	if err != nil {
+		return false, errors.Wrap(err, "execute AccountGetSavedMusicIDs")
+	}
+
+	switch variant := result.(type) {
+	case *tg.AccountSavedMusicIDs:
+		hash := s.computeHash(variant)
+
+		s.store(innerAccountGetSavedMusicIDs{
+			hash:  hash,
+			value: variant,
+		})
+		return true, nil
+	case *tg.AccountSavedMusicIDsNotModified:
+		if lastHash == 0 {
+			return false, errors.Errorf("got unexpected %T result", result)
+		}
+		return false, nil
+	default:
+		return false, errors.Errorf("unexpected type %T", result)
+	}
+}
+
 type innerAccountGetSavedRingtones struct {
 	// Last received hash.
 	hash int64
@@ -2653,3 +2737,263 @@ func (s *MessagesSearchStickerSets) Fetch(ctx context.Context) (bool, error) {
 		return false, errors.Errorf("unexpected type %T", result)
 	}
 }
+
+type innerPaymentsGetStarGiftActiveAuctions struct {
+	// Last received hash.
+	hash int64
+	// Last received result.
+	value *tg.PaymentsStarGiftActiveAuctions
+}
+
+type PaymentsGetStarGiftActiveAuctions struct {
+	// Result state.
+	last atomic.Value
+
+	// Reference to RPC client to make requests.
+	raw *tg.Client
+}
+
+// NewPaymentsGetStarGiftActiveAuctions creates new PaymentsGetStarGiftActiveAuctions.
+func NewPaymentsGetStarGiftActiveAuctions(raw *tg.Client) *PaymentsGetStarGiftActiveAuctions {
+	q := &PaymentsGetStarGiftActiveAuctions{
+		raw: raw,
+	}
+
+	return q
+}
+
+func (s *PaymentsGetStarGiftActiveAuctions) store(v innerPaymentsGetStarGiftActiveAuctions) {
+	s.last.Store(v)
+}
+
+func (s *PaymentsGetStarGiftActiveAuctions) load() (innerPaymentsGetStarGiftActiveAuctions, bool) {
+	v, ok := s.last.Load().(innerPaymentsGetStarGiftActiveAuctions)
+	return v, ok
+}
+
+// Value returns last received result.
+// NB: May be nil. Returned PaymentsStarGiftActiveAuctions must not be mutated.
+func (s *PaymentsGetStarGiftActiveAuctions) Value() *tg.PaymentsStarGiftActiveAuctions {
+	inner, _ := s.load()
+	return inner.value
+}
+
+// Hash returns last received hash.
+func (s *PaymentsGetStarGiftActiveAuctions) Hash() int64 {
+	inner, _ := s.load()
+	return inner.hash
+}
+
+// Get updates data if needed and returns it.
+func (s *PaymentsGetStarGiftActiveAuctions) Get(ctx context.Context) (*tg.PaymentsStarGiftActiveAuctions, error) {
+	if _, err := s.Fetch(ctx); err != nil {
+		return nil, err
+	}
+
+	return s.Value(), nil
+}
+
+// Fetch updates data if needed and returns true if data was modified.
+func (s *PaymentsGetStarGiftActiveAuctions) Fetch(ctx context.Context) (bool, error) {
+	lastHash := s.Hash()
+
+	req := lastHash
+	result, err := s.raw.PaymentsGetStarGiftActiveAuctions(ctx, req)
+	if err != nil {
+		return false, errors.Wrap(err, "execute PaymentsGetStarGiftActiveAuctions")
+	}
+
+	switch variant := result.(type) {
+	case *tg.PaymentsStarGiftActiveAuctions:
+		hash := s.computeHash(variant)
+
+		s.store(innerPaymentsGetStarGiftActiveAuctions{
+			hash:  hash,
+			value: variant,
+		})
+		return true, nil
+	case *tg.PaymentsStarGiftActiveAuctionsNotModified:
+		if lastHash == 0 {
+			return false, errors.Errorf("got unexpected %T result", result)
+		}
+		return false, nil
+	default:
+		return false, errors.Errorf("unexpected type %T", result)
+	}
+}
+
+type innerPaymentsGetStarGiftCollections struct {
+	// Last received hash.
+	hash int64
+	// Last received result.
+	value *tg.PaymentsStarGiftCollections
+}
+
+type PaymentsGetStarGiftCollections struct {
+	// Query to send.
+	req *tg.PaymentsGetStarGiftCollectionsRequest
+	// Result state.
+	last atomic.Value
+
+	// Reference to RPC client to make requests.
+	raw *tg.Client
+}
+
+// NewPaymentsGetStarGiftCollections creates new PaymentsGetStarGiftCollections.
+func NewPaymentsGetStarGiftCollections(raw *tg.Client, initial *tg.PaymentsGetStarGiftCollectionsRequest) *PaymentsGetStarGiftCollections {
+	q := &PaymentsGetStarGiftCollections{
+		req: initial,
+		raw: raw,
+	}
+
+	return q
+}
+
+func (s *PaymentsGetStarGiftCollections) store(v innerPaymentsGetStarGiftCollections) {
+	s.last.Store(v)
+}
+
+func (s *PaymentsGetStarGiftCollections) load() (innerPaymentsGetStarGiftCollections, bool) {
+	v, ok := s.last.Load().(innerPaymentsGetStarGiftCollections)
+	return v, ok
+}
+
+// Value returns last received result.
+// NB: May be nil. Returned PaymentsStarGiftCollections must not be mutated.
+func (s *PaymentsGetStarGiftCollections) Value() *tg.PaymentsStarGiftCollections {
+	inner, _ := s.load()
+	return inner.value
+}
+
+// Hash returns last received hash.
+func (s *PaymentsGetStarGiftCollections) Hash() int64 {
+	inner, _ := s.load()
+	return inner.hash
+}
+
+// Get updates data if needed and returns it.
+func (s *PaymentsGetStarGiftCollections) Get(ctx context.Context) (*tg.PaymentsStarGiftCollections, error) {
+	if _, err := s.Fetch(ctx); err != nil {
+		return nil, err
+	}
+
+	return s.Value(), nil
+}
+
+// Fetch updates data if needed and returns true if data was modified.
+func (s *PaymentsGetStarGiftCollections) Fetch(ctx context.Context) (bool, error) {
+	lastHash := s.Hash()
+
+	req := s.req
+	req.Hash = lastHash
+	result, err := s.raw.PaymentsGetStarGiftCollections(ctx, req)
+	if err != nil {
+		return false, errors.Wrap(err, "execute PaymentsGetStarGiftCollections")
+	}
+
+	switch variant := result.(type) {
+	case *tg.PaymentsStarGiftCollections:
+		hash := s.computeHash(variant)
+
+		s.store(innerPaymentsGetStarGiftCollections{
+			hash:  hash,
+			value: variant,
+		})
+		return true, nil
+	case *tg.PaymentsStarGiftCollectionsNotModified:
+		if lastHash == 0 {
+			return false, errors.Errorf("got unexpected %T result", result)
+		}
+		return false, nil
+	default:
+		return false, errors.Errorf("unexpected type %T", result)
+	}
+}
+
+type innerStoriesGetAlbums struct {
+	// Last received hash.
+	hash int64
+	// Last received result.
+	value *tg.StoriesAlbums
+}
+
+type StoriesGetAlbums struct {
+	// Query to send.
+	req *tg.StoriesGetAlbumsRequest
+	// Result state.
+	last atomic.Value
+
+	// Reference to RPC client to make requests.
+	raw *tg.Client
+}
+
+// NewStoriesGetAlbums creates new StoriesGetAlbums.
+func NewStoriesGetAlbums(raw *tg.Client, initial *tg.StoriesGetAlbumsRequest) *StoriesGetAlbums {
+	q := &StoriesGetAlbums{
+		req: initial,
+		raw: raw,
+	}
+
+	return q
+}
+
+func (s *StoriesGetAlbums) store(v innerStoriesGetAlbums) {
+	s.last.Store(v)
+}
+
+func (s *StoriesGetAlbums) load() (innerStoriesGetAlbums, bool) {
+	v, ok := s.last.Load().(innerStoriesGetAlbums)
+	return v, ok
+}
+
+// Value returns last received result.
+// NB: May be nil. Returned StoriesAlbums must not be mutated.
+func (s *StoriesGetAlbums) Value() *tg.StoriesAlbums {
+	inner, _ := s.load()
+	return inner.value
+}
+
+// Hash returns last received hash.
+func (s *StoriesGetAlbums) Hash() int64 {
+	inner, _ := s.load()
+	return inner.hash
+}
+
+// Get updates data if needed and returns it.
+func (s *StoriesGetAlbums) Get(ctx context.Context) (*tg.StoriesAlbums, error) {
+	if _, err := s.Fetch(ctx); err != nil {
+		return nil, err
+	}
+
+	return s.Value(), nil
+}
+
+// Fetch updates data if needed and returns true if data was modified.
+func (s *StoriesGetAlbums) Fetch(ctx context.Context) (bool, error) {
+	lastHash := s.Hash()
+
+	req := s.req
+	req.Hash = lastHash
+	result, err := s.raw.StoriesGetAlbums(ctx, req)
+	if err != nil {
+		return false, errors.Wrap(err, "execute StoriesGetAlbums")
+	}
+
+	switch variant := result.(type) {
+	case *tg.StoriesAlbums:
+		hash := variant.Hash
+
+		s.store(innerStoriesGetAlbums{
+			hash:  hash,
+			value: variant,
+		})
+		return true, nil
+	case *tg.StoriesAlbumsNotModified:
+		if lastHash == 0 {
+			return false, errors.Errorf("got unexpected %T result", result)
+		}
+		return false, nil
+	default:
+		return false, errors.Errorf("unexpected type %T", result)
+	}
+}
@@ -101,9 +101,8 @@ func (b *{{ $.Name }}QueryBuilder) {{ $mapping.Arg.OriginalName }}({{ $mapping.A
 {{- end }}{{- end }}

 {{ range $f := $.AdditionalParams }}
-// {{ $f.OriginalName }} sets {{ $f.OriginalName }} field of {{ $.Name }} query.
-func (b *{{ $.Name }}QueryBuilder) {{ $f.OriginalName }}(param{{ $f.OriginalName }} {{ $f.Type }}) *{{ $.Name }}QueryBuilder {
-    b.req.{{ $f.OriginalName }} = param{{ $f.OriginalName }}
+// {{ $f.MethodName }} sets {{ $f.OriginalName }} field of {{ $.Name }} query.
+func (b *{{ $.Name }}QueryBuilder) {{ $f.MethodName }}(param{{ $f.OriginalName }} {{ $f.Type }}) *{{ $.Name }}QueryBuilder {    b.req.{{ $f.OriginalName }} = param{{ $f.OriginalName }}
    return b
 }
 {{ end }}
@@ -16,15 +16,24 @@ type Param struct {
 	OriginalName string
 	// Go type.
 	Type string
+	// MethodName to use.
+	MethodName string
 }

 func varToParam(field *types.Var) Param {
 	fieldName := field.Name()
 	fieldName = strings.ToLower(fieldName[:1]) + fieldName[1:]
+	originalName := field.Name()
+	methodName := originalName
+	if methodName == "Query" {
+		// HACK: fix conflict.
+		methodName = "Set" + methodName
+	}
 	return Param{
 		Name:         fieldName,
-		OriginalName: field.Name(),
+		OriginalName: originalName,
 		Type:         genutil.PrintType(field.Type()),
+		MethodName:   methodName,
 	}
 }

@@ -82,19 +82,33 @@ func (b *ChannelsSearchPostsQueryBuilder) OffsetID(offsetID int) *ChannelsSearch
 	return b
 }

+// AllowPaidStars sets AllowPaidStars field of ChannelsSearchPosts query.
+func (b *ChannelsSearchPostsQueryBuilder) AllowPaidStars(paramAllowPaidStars int64) *ChannelsSearchPostsQueryBuilder {
+	b.req.AllowPaidStars = paramAllowPaidStars
+	return b
+}
+
 // Hashtag sets Hashtag field of ChannelsSearchPosts query.
 func (b *ChannelsSearchPostsQueryBuilder) Hashtag(paramHashtag string) *ChannelsSearchPostsQueryBuilder {
 	b.req.Hashtag = paramHashtag
 	return b
 }

+// SetQuery sets Query field of ChannelsSearchPosts query.
+func (b *ChannelsSearchPostsQueryBuilder) SetQuery(paramQuery string) *ChannelsSearchPostsQueryBuilder {
+	b.req.Query = paramQuery
+	return b
+}
+
 // Query implements Query interface.
 func (b *ChannelsSearchPostsQueryBuilder) Query(ctx context.Context, req Request) (tg.MessagesMessagesClass, error) {
 	r := &tg.ChannelsSearchPostsRequest{
 		Limit: req.Limit,
 	}

+	r.AllowPaidStars = b.req.AllowPaidStars
 	r.Hashtag = b.req.Hashtag
+	r.Query = b.req.Query
 	r.OffsetID = req.OffsetID
 	r.OffsetPeer = req.OffsetPeer
 	r.OffsetRate = req.OffsetRate