+32

api/atproto/admindefs.go

reviewed

··· 193 193 Comment *string `json:"comment,omitempty" cborgen:"comment,omitempty"` 194 194 } 195 195 196 196 + // AdminDefs_ModEventTag is a "modEventTag" in the com.atproto.admin.defs schema. 197 197 + // 198 198 + // Add/Remove a tag on a subject 199 199 + // 200 200 + // RECORDTYPE: AdminDefs_ModEventTag 201 201 + type AdminDefs_ModEventTag struct { 202 202 + LexiconTypeID string `json:"$type,const=com.atproto.admin.defs#modEventTag" cborgen:"$type,const=com.atproto.admin.defs#modEventTag"` 203 203 + // add: Tags to be added to the subject. If already exists, won't be duplicated. 204 204 + Add []string `json:"add" cborgen:"add"` 205 205 + // comment: Additional comment about added/removed tags. 206 206 + Comment *string `json:"comment,omitempty" cborgen:"comment,omitempty"` 207 207 + // remove: Tags to be removed to the subject. Ignores a tag If it doesn't exist, won't be duplicated. 208 208 + Remove []string `json:"remove" cborgen:"remove"` 209 209 + } 210 210 + 196 211 // AdminDefs_ModEventTakedown is a "modEventTakedown" in the com.atproto.admin.defs schema. 197 212 // 198 213 // # Take down a subject permanently or temporarily ··· 247 262 AdminDefs_ModEventAcknowledge *AdminDefs_ModEventAcknowledge 248 263 AdminDefs_ModEventEscalate *AdminDefs_ModEventEscalate 249 264 AdminDefs_ModEventMute *AdminDefs_ModEventMute 265 265 + AdminDefs_ModEventEmail *AdminDefs_ModEventEmail 250 266 AdminDefs_ModEventResolveAppeal *AdminDefs_ModEventResolveAppeal 251 267 } 252 268 ··· 283 299 t.AdminDefs_ModEventMute.LexiconTypeID = "com.atproto.admin.defs#modEventMute" 284 300 return json.Marshal(t.AdminDefs_ModEventMute) 285 301 } 302 302 + if t.AdminDefs_ModEventEmail != nil { 303 303 + t.AdminDefs_ModEventEmail.LexiconTypeID = "com.atproto.admin.defs#modEventEmail" 304 304 + return json.Marshal(t.AdminDefs_ModEventEmail) 305 305 + } 286 306 if t.AdminDefs_ModEventResolveAppeal != nil { 287 307 t.AdminDefs_ModEventResolveAppeal.LexiconTypeID = "com.atproto.admin.defs#modEventResolveAppeal" 288 308 return json.Marshal(t.AdminDefs_ModEventResolveAppeal) ··· 320 340 case "com.atproto.admin.defs#modEventMute": 321 341 t.AdminDefs_ModEventMute = new(AdminDefs_ModEventMute) 322 342 return json.Unmarshal(b, t.AdminDefs_ModEventMute) 343 343 + case "com.atproto.admin.defs#modEventEmail": 344 344 + t.AdminDefs_ModEventEmail = new(AdminDefs_ModEventEmail) 345 345 + return json.Unmarshal(b, t.AdminDefs_ModEventEmail) 323 346 case "com.atproto.admin.defs#modEventResolveAppeal": 324 347 t.AdminDefs_ModEventResolveAppeal = new(AdminDefs_ModEventResolveAppeal) 325 348 return json.Unmarshal(b, t.AdminDefs_ModEventResolveAppeal) ··· 390 413 AdminDefs_ModEventEscalate *AdminDefs_ModEventEscalate 391 414 AdminDefs_ModEventMute *AdminDefs_ModEventMute 392 415 AdminDefs_ModEventEmail *AdminDefs_ModEventEmail 416 416 + AdminDefs_ModEventResolveAppeal *AdminDefs_ModEventResolveAppeal 393 417 } 394 418 395 419 func (t *AdminDefs_ModEventView_Event) MarshalJSON() ([]byte, error) { ··· 429 453 t.AdminDefs_ModEventEmail.LexiconTypeID = "com.atproto.admin.defs#modEventEmail" 430 454 return json.Marshal(t.AdminDefs_ModEventEmail) 431 455 } 456 456 + if t.AdminDefs_ModEventResolveAppeal != nil { 457 457 + t.AdminDefs_ModEventResolveAppeal.LexiconTypeID = "com.atproto.admin.defs#modEventResolveAppeal" 458 458 + return json.Marshal(t.AdminDefs_ModEventResolveAppeal) 459 459 + } 432 460 return nil, fmt.Errorf("cannot marshal empty enum") 433 461 } 434 462 func (t *AdminDefs_ModEventView_Event) UnmarshalJSON(b []byte) error { ··· 465 493 case "com.atproto.admin.defs#modEventEmail": 466 494 t.AdminDefs_ModEventEmail = new(AdminDefs_ModEventEmail) 467 495 return json.Unmarshal(b, t.AdminDefs_ModEventEmail) 496 496 + case "com.atproto.admin.defs#modEventResolveAppeal": 497 497 + t.AdminDefs_ModEventResolveAppeal = new(AdminDefs_ModEventResolveAppeal) 498 498 + return json.Unmarshal(b, t.AdminDefs_ModEventResolveAppeal) 468 499 469 500 default: 470 501 return nil ··· 744 775 SubjectBlobCids []string `json:"subjectBlobCids,omitempty" cborgen:"subjectBlobCids,omitempty"` 745 776 SubjectRepoHandle *string `json:"subjectRepoHandle,omitempty" cborgen:"subjectRepoHandle,omitempty"` 746 777 SuspendUntil *string `json:"suspendUntil,omitempty" cborgen:"suspendUntil,omitempty"` 778 778 + Tags []string `json:"tags,omitempty" cborgen:"tags,omitempty"` 747 779 Takendown *bool `json:"takendown,omitempty" cborgen:"takendown,omitempty"` 748 780 // updatedAt: Timestamp referencing when the last update was made to the moderation status of the subject 749 781 UpdatedAt string `json:"updatedAt" cborgen:"updatedAt"`

+8

api/atproto/adminemitModerationEvent.go

reviewed

··· 32 32 AdminDefs_ModEventReverseTakedown *AdminDefs_ModEventReverseTakedown 33 33 AdminDefs_ModEventUnmute *AdminDefs_ModEventUnmute 34 34 AdminDefs_ModEventEmail *AdminDefs_ModEventEmail 35 35 + AdminDefs_ModEventTag *AdminDefs_ModEventTag 35 36 } 36 37 37 38 func (t *AdminEmitModerationEvent_Input_Event) MarshalJSON() ([]byte, error) { ··· 75 76 t.AdminDefs_ModEventEmail.LexiconTypeID = "com.atproto.admin.defs#modEventEmail" 76 77 return json.Marshal(t.AdminDefs_ModEventEmail) 77 78 } 79 79 + if t.AdminDefs_ModEventTag != nil { 80 80 + t.AdminDefs_ModEventTag.LexiconTypeID = "com.atproto.admin.defs#modEventTag" 81 81 + return json.Marshal(t.AdminDefs_ModEventTag) 82 82 + } 78 83 return nil, fmt.Errorf("cannot marshal empty enum") 79 84 } 80 85 func (t *AdminEmitModerationEvent_Input_Event) UnmarshalJSON(b []byte) error { ··· 114 119 case "com.atproto.admin.defs#modEventEmail": 115 120 t.AdminDefs_ModEventEmail = new(AdminDefs_ModEventEmail) 116 121 return json.Unmarshal(b, t.AdminDefs_ModEventEmail) 122 122 + case "com.atproto.admin.defs#modEventTag": 123 123 + t.AdminDefs_ModEventTag = new(AdminDefs_ModEventTag) 124 124 + return json.Unmarshal(b, t.AdminDefs_ModEventTag) 117 125 118 126 default: 119 127 return nil

+18 -1

api/atproto/adminqueryModerationEvents.go

reviewed

··· 18 18 19 19 // AdminQueryModerationEvents calls the XRPC method "com.atproto.admin.queryModerationEvents". 20 20 // 21 21 + // addedLabels: If specified, only events where all of these labels were added are returned 22 22 + // addedTags: If specified, only events where all of these tags were added are returned 23 23 + // comment: If specified, only events with comments containing the keyword are returned 24 24 + // createdAfter: Retrieve events created after a given timestamp 25 25 + // createdBefore: Retrieve events created before a given timestamp 26 26 + // hasComment: If true, only events with comments are returned 21 27 // includeAllUserRecords: If true, events on all record types (posts, lists, profile etc.) owned by the did are returned 28 28 + // removedLabels: If specified, only events where all of these labels were removed are returned 29 29 + // removedTags: If specified, only events where all of these tags were removed are returned 22 30 // sortDirection: Sort direction for the events. Defaults to descending order of created at timestamp. 23 31 // types: The types of events (fully qualified string in the format of com.atproto.admin#modEvent<name>) to filter by. If not specified, all events are returned. 24 24 - func AdminQueryModerationEvents(ctx context.Context, c *xrpc.Client, createdBy string, cursor string, includeAllUserRecords bool, limit int64, sortDirection string, subject string, types []string) (*AdminQueryModerationEvents_Output, error) { 32 32 + func AdminQueryModerationEvents(ctx context.Context, c *xrpc.Client, addedLabels []string, addedTags []string, comment string, createdAfter string, createdBefore string, createdBy string, cursor string, hasComment bool, includeAllUserRecords bool, limit int64, removedLabels []string, removedTags []string, reportTypes []string, sortDirection string, subject string, types []string) (*AdminQueryModerationEvents_Output, error) { 25 33 var out AdminQueryModerationEvents_Output 26 34 27 35 params := map[string]interface{}{ 36 36 + "addedLabels": addedLabels, 37 37 + "addedTags": addedTags, 38 38 + "comment": comment, 39 39 + "createdAfter": createdAfter, 40 40 + "createdBefore": createdBefore, 28 41 "createdBy": createdBy, 29 42 "cursor": cursor, 43 43 + "hasComment": hasComment, 30 44 "includeAllUserRecords": includeAllUserRecords, 31 45 "limit": limit, 46 46 + "removedLabels": removedLabels, 47 47 + "removedTags": removedTags, 48 48 + "reportTypes": reportTypes, 32 49 "sortDirection": sortDirection, 33 50 "subject": subject, 34 51 "types": types,

+3 -1

api/atproto/adminqueryModerationStatuses.go

reviewed

··· 28 28 // reviewedAfter: Search subjects reviewed after a given timestamp 29 29 // reviewedBefore: Search subjects reviewed before a given timestamp 30 30 // takendown: Get subjects that were taken down 31 31 - func AdminQueryModerationStatuses(ctx context.Context, c *xrpc.Client, appealed bool, comment string, cursor string, ignoreSubjects []string, includeMuted bool, lastReviewedBy string, limit int64, reportedAfter string, reportedBefore string, reviewState string, reviewedAfter string, reviewedBefore string, sortDirection string, sortField string, subject string, takendown bool) (*AdminQueryModerationStatuses_Output, error) { 31 31 + func AdminQueryModerationStatuses(ctx context.Context, c *xrpc.Client, appealed bool, comment string, cursor string, excludeTags []string, ignoreSubjects []string, includeMuted bool, lastReviewedBy string, limit int64, reportedAfter string, reportedBefore string, reviewState string, reviewedAfter string, reviewedBefore string, sortDirection string, sortField string, subject string, tags []string, takendown bool) (*AdminQueryModerationStatuses_Output, error) { 32 32 var out AdminQueryModerationStatuses_Output 33 33 34 34 params := map[string]interface{}{ 35 35 "appealed": appealed, 36 36 "comment": comment, 37 37 "cursor": cursor, 38 38 + "excludeTags": excludeTags, 38 39 "ignoreSubjects": ignoreSubjects, 39 40 "includeMuted": includeMuted, 40 41 "lastReviewedBy": lastReviewedBy, ··· 47 48 "sortDirection": sortDirection, 48 49 "sortField": sortField, 49 50 "subject": subject, 51 51 + "tags": tags, 50 52 "takendown": takendown, 51 53 } 52 54 if err := c.Do(ctx, xrpc.Query, "", "com.atproto.admin.queryModerationStatuses", params, nil, &out); err != nil {

+26

api/atproto/adminupdateAccountPassword.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package atproto 4 4 + 5 5 + // schema: com.atproto.admin.updateAccountPassword 6 6 + 7 7 + import ( 8 8 + "context" 9 9 + 10 10 + "github.com/bluesky-social/indigo/xrpc" 11 11 + ) 12 12 + 13 13 + // AdminUpdateAccountPassword_Input is the input argument to a com.atproto.admin.updateAccountPassword call. 14 14 + type AdminUpdateAccountPassword_Input struct { 15 15 + Did string `json:"did" cborgen:"did"` 16 16 + Password string `json:"password" cborgen:"password"` 17 17 + } 18 18 + 19 19 + // AdminUpdateAccountPassword calls the XRPC method "com.atproto.admin.updateAccountPassword". 20 20 + func AdminUpdateAccountPassword(ctx context.Context, c *xrpc.Client, input *AdminUpdateAccountPassword_Input) error { 21 21 + if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.admin.updateAccountPassword", nil, input, nil); err != nil { 22 22 + return err 23 23 + } 24 24 + 25 25 + return nil 26 26 + }

+401

api/atproto/cbor_gen.go

reviewed

··· 2818 2818 2819 2819 return nil 2820 2820 } 2821 2821 + func (t *LabelDefs_LabelValueDefinition) MarshalCBOR(w io.Writer) error { 2822 2822 + if t == nil { 2823 2823 + _, err := w.Write(cbg.CborNull) 2824 2824 + return err 2825 2825 + } 2826 2826 + 2827 2827 + cw := cbg.NewCborWriter(w) 2828 2828 + 2829 2829 + if _, err := cw.Write([]byte{164}); err != nil { 2830 2830 + return err 2831 2831 + } 2832 2832 + 2833 2833 + // t.Blurs (string) (string) 2834 2834 + if uint64(len("blurs")) > cbg.MaxLength { 2835 2835 + return xerrors.Errorf("Value in field \"blurs\" was too long") 2836 2836 + } 2837 2837 + 2838 2838 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("blurs"))); err != nil { 2839 2839 + return err 2840 2840 + } 2841 2841 + if _, err := cw.WriteString(string("blurs")); err != nil { 2842 2842 + return err 2843 2843 + } 2844 2844 + 2845 2845 + if uint64(len(t.Blurs)) > cbg.MaxLength { 2846 2846 + return xerrors.Errorf("Value in field t.Blurs was too long") 2847 2847 + } 2848 2848 + 2849 2849 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Blurs))); err != nil { 2850 2850 + return err 2851 2851 + } 2852 2852 + if _, err := cw.WriteString(string(t.Blurs)); err != nil { 2853 2853 + return err 2854 2854 + } 2855 2855 + 2856 2856 + // t.Locales ([]*atproto.LabelDefs_LabelValueDefinitionStrings) (slice) 2857 2857 + if uint64(len("locales")) > cbg.MaxLength { 2858 2858 + return xerrors.Errorf("Value in field \"locales\" was too long") 2859 2859 + } 2860 2860 + 2861 2861 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("locales"))); err != nil { 2862 2862 + return err 2863 2863 + } 2864 2864 + if _, err := cw.WriteString(string("locales")); err != nil { 2865 2865 + return err 2866 2866 + } 2867 2867 + 2868 2868 + if uint64(len(t.Locales)) > cbg.MaxLength { 2869 2869 + return xerrors.Errorf("Slice value in field t.Locales was too long") 2870 2870 + } 2871 2871 + 2872 2872 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Locales))); err != nil { 2873 2873 + return err 2874 2874 + } 2875 2875 + for _, v := range t.Locales { 2876 2876 + if err := v.MarshalCBOR(cw); err != nil { 2877 2877 + return err 2878 2878 + } 2879 2879 + 2880 2880 + } 2881 2881 + 2882 2882 + // t.Severity (string) (string) 2883 2883 + if uint64(len("severity")) > cbg.MaxLength { 2884 2884 + return xerrors.Errorf("Value in field \"severity\" was too long") 2885 2885 + } 2886 2886 + 2887 2887 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("severity"))); err != nil { 2888 2888 + return err 2889 2889 + } 2890 2890 + if _, err := cw.WriteString(string("severity")); err != nil { 2891 2891 + return err 2892 2892 + } 2893 2893 + 2894 2894 + if uint64(len(t.Severity)) > cbg.MaxLength { 2895 2895 + return xerrors.Errorf("Value in field t.Severity was too long") 2896 2896 + } 2897 2897 + 2898 2898 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Severity))); err != nil { 2899 2899 + return err 2900 2900 + } 2901 2901 + if _, err := cw.WriteString(string(t.Severity)); err != nil { 2902 2902 + return err 2903 2903 + } 2904 2904 + 2905 2905 + // t.Identifier (string) (string) 2906 2906 + if uint64(len("identifier")) > cbg.MaxLength { 2907 2907 + return xerrors.Errorf("Value in field \"identifier\" was too long") 2908 2908 + } 2909 2909 + 2910 2910 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("identifier"))); err != nil { 2911 2911 + return err 2912 2912 + } 2913 2913 + if _, err := cw.WriteString(string("identifier")); err != nil { 2914 2914 + return err 2915 2915 + } 2916 2916 + 2917 2917 + if uint64(len(t.Identifier)) > cbg.MaxLength { 2918 2918 + return xerrors.Errorf("Value in field t.Identifier was too long") 2919 2919 + } 2920 2920 + 2921 2921 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Identifier))); err != nil { 2922 2922 + return err 2923 2923 + } 2924 2924 + if _, err := cw.WriteString(string(t.Identifier)); err != nil { 2925 2925 + return err 2926 2926 + } 2927 2927 + return nil 2928 2928 + } 2929 2929 + 2930 2930 + func (t *LabelDefs_LabelValueDefinition) UnmarshalCBOR(r io.Reader) (err error) { 2931 2931 + *t = LabelDefs_LabelValueDefinition{} 2932 2932 + 2933 2933 + cr := cbg.NewCborReader(r) 2934 2934 + 2935 2935 + maj, extra, err := cr.ReadHeader() 2936 2936 + if err != nil { 2937 2937 + return err 2938 2938 + } 2939 2939 + defer func() { 2940 2940 + if err == io.EOF { 2941 2941 + err = io.ErrUnexpectedEOF 2942 2942 + } 2943 2943 + }() 2944 2944 + 2945 2945 + if maj != cbg.MajMap { 2946 2946 + return fmt.Errorf("cbor input should be of type map") 2947 2947 + } 2948 2948 + 2949 2949 + if extra > cbg.MaxLength { 2950 2950 + return fmt.Errorf("LabelDefs_LabelValueDefinition: map struct too large (%d)", extra) 2951 2951 + } 2952 2952 + 2953 2953 + var name string 2954 2954 + n := extra 2955 2955 + 2956 2956 + for i := uint64(0); i < n; i++ { 2957 2957 + 2958 2958 + { 2959 2959 + sval, err := cbg.ReadString(cr) 2960 2960 + if err != nil { 2961 2961 + return err 2962 2962 + } 2963 2963 + 2964 2964 + name = string(sval) 2965 2965 + } 2966 2966 + 2967 2967 + switch name { 2968 2968 + // t.Blurs (string) (string) 2969 2969 + case "blurs": 2970 2970 + 2971 2971 + { 2972 2972 + sval, err := cbg.ReadString(cr) 2973 2973 + if err != nil { 2974 2974 + return err 2975 2975 + } 2976 2976 + 2977 2977 + t.Blurs = string(sval) 2978 2978 + } 2979 2979 + // t.Locales ([]*atproto.LabelDefs_LabelValueDefinitionStrings) (slice) 2980 2980 + case "locales": 2981 2981 + 2982 2982 + maj, extra, err = cr.ReadHeader() 2983 2983 + if err != nil { 2984 2984 + return err 2985 2985 + } 2986 2986 + 2987 2987 + if extra > cbg.MaxLength { 2988 2988 + return fmt.Errorf("t.Locales: array too large (%d)", extra) 2989 2989 + } 2990 2990 + 2991 2991 + if maj != cbg.MajArray { 2992 2992 + return fmt.Errorf("expected cbor array") 2993 2993 + } 2994 2994 + 2995 2995 + if extra > 0 { 2996 2996 + t.Locales = make([]*LabelDefs_LabelValueDefinitionStrings, extra) 2997 2997 + } 2998 2998 + 2999 2999 + for i := 0; i < int(extra); i++ { 3000 3000 + { 3001 3001 + var maj byte 3002 3002 + var extra uint64 3003 3003 + var err error 3004 3004 + _ = maj 3005 3005 + _ = extra 3006 3006 + _ = err 3007 3007 + 3008 3008 + { 3009 3009 + 3010 3010 + b, err := cr.ReadByte() 3011 3011 + if err != nil { 3012 3012 + return err 3013 3013 + } 3014 3014 + if b != cbg.CborNull[0] { 3015 3015 + if err := cr.UnreadByte(); err != nil { 3016 3016 + return err 3017 3017 + } 3018 3018 + t.Locales[i] = new(LabelDefs_LabelValueDefinitionStrings) 3019 3019 + if err := t.Locales[i].UnmarshalCBOR(cr); err != nil { 3020 3020 + return xerrors.Errorf("unmarshaling t.Locales[i] pointer: %w", err) 3021 3021 + } 3022 3022 + } 3023 3023 + 3024 3024 + } 3025 3025 + 3026 3026 + } 3027 3027 + } 3028 3028 + // t.Severity (string) (string) 3029 3029 + case "severity": 3030 3030 + 3031 3031 + { 3032 3032 + sval, err := cbg.ReadString(cr) 3033 3033 + if err != nil { 3034 3034 + return err 3035 3035 + } 3036 3036 + 3037 3037 + t.Severity = string(sval) 3038 3038 + } 3039 3039 + // t.Identifier (string) (string) 3040 3040 + case "identifier": 3041 3041 + 3042 3042 + { 3043 3043 + sval, err := cbg.ReadString(cr) 3044 3044 + if err != nil { 3045 3045 + return err 3046 3046 + } 3047 3047 + 3048 3048 + t.Identifier = string(sval) 3049 3049 + } 3050 3050 + 3051 3051 + default: 3052 3052 + // Field doesn't exist on this type, so ignore it 3053 3053 + cbg.ScanForLinks(r, func(cid.Cid) {}) 3054 3054 + } 3055 3055 + } 3056 3056 + 3057 3057 + return nil 3058 3058 + } 3059 3059 + func (t *LabelDefs_LabelValueDefinitionStrings) MarshalCBOR(w io.Writer) error { 3060 3060 + if t == nil { 3061 3061 + _, err := w.Write(cbg.CborNull) 3062 3062 + return err 3063 3063 + } 3064 3064 + 3065 3065 + cw := cbg.NewCborWriter(w) 3066 3066 + 3067 3067 + if _, err := cw.Write([]byte{163}); err != nil { 3068 3068 + return err 3069 3069 + } 3070 3070 + 3071 3071 + // t.Lang (string) (string) 3072 3072 + if uint64(len("lang")) > cbg.MaxLength { 3073 3073 + return xerrors.Errorf("Value in field \"lang\" was too long") 3074 3074 + } 3075 3075 + 3076 3076 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil { 3077 3077 + return err 3078 3078 + } 3079 3079 + if _, err := cw.WriteString(string("lang")); err != nil { 3080 3080 + return err 3081 3081 + } 3082 3082 + 3083 3083 + if uint64(len(t.Lang)) > cbg.MaxLength { 3084 3084 + return xerrors.Errorf("Value in field t.Lang was too long") 3085 3085 + } 3086 3086 + 3087 3087 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil { 3088 3088 + return err 3089 3089 + } 3090 3090 + if _, err := cw.WriteString(string(t.Lang)); err != nil { 3091 3091 + return err 3092 3092 + } 3093 3093 + 3094 3094 + // t.Name (string) (string) 3095 3095 + if uint64(len("name")) > cbg.MaxLength { 3096 3096 + return xerrors.Errorf("Value in field \"name\" was too long") 3097 3097 + } 3098 3098 + 3099 3099 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 3100 3100 + return err 3101 3101 + } 3102 3102 + if _, err := cw.WriteString(string("name")); err != nil { 3103 3103 + return err 3104 3104 + } 3105 3105 + 3106 3106 + if uint64(len(t.Name)) > cbg.MaxLength { 3107 3107 + return xerrors.Errorf("Value in field t.Name was too long") 3108 3108 + } 3109 3109 + 3110 3110 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 3111 3111 + return err 3112 3112 + } 3113 3113 + if _, err := cw.WriteString(string(t.Name)); err != nil { 3114 3114 + return err 3115 3115 + } 3116 3116 + 3117 3117 + // t.Description (string) (string) 3118 3118 + if uint64(len("description")) > cbg.MaxLength { 3119 3119 + return xerrors.Errorf("Value in field \"description\" was too long") 3120 3120 + } 3121 3121 + 3122 3122 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 3123 3123 + return err 3124 3124 + } 3125 3125 + if _, err := cw.WriteString(string("description")); err != nil { 3126 3126 + return err 3127 3127 + } 3128 3128 + 3129 3129 + if uint64(len(t.Description)) > cbg.MaxLength { 3130 3130 + return xerrors.Errorf("Value in field t.Description was too long") 3131 3131 + } 3132 3132 + 3133 3133 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil { 3134 3134 + return err 3135 3135 + } 3136 3136 + if _, err := cw.WriteString(string(t.Description)); err != nil { 3137 3137 + return err 3138 3138 + } 3139 3139 + return nil 3140 3140 + } 3141 3141 + 3142 3142 + func (t *LabelDefs_LabelValueDefinitionStrings) UnmarshalCBOR(r io.Reader) (err error) { 3143 3143 + *t = LabelDefs_LabelValueDefinitionStrings{} 3144 3144 + 3145 3145 + cr := cbg.NewCborReader(r) 3146 3146 + 3147 3147 + maj, extra, err := cr.ReadHeader() 3148 3148 + if err != nil { 3149 3149 + return err 3150 3150 + } 3151 3151 + defer func() { 3152 3152 + if err == io.EOF { 3153 3153 + err = io.ErrUnexpectedEOF 3154 3154 + } 3155 3155 + }() 3156 3156 + 3157 3157 + if maj != cbg.MajMap { 3158 3158 + return fmt.Errorf("cbor input should be of type map") 3159 3159 + } 3160 3160 + 3161 3161 + if extra > cbg.MaxLength { 3162 3162 + return fmt.Errorf("LabelDefs_LabelValueDefinitionStrings: map struct too large (%d)", extra) 3163 3163 + } 3164 3164 + 3165 3165 + var name string 3166 3166 + n := extra 3167 3167 + 3168 3168 + for i := uint64(0); i < n; i++ { 3169 3169 + 3170 3170 + { 3171 3171 + sval, err := cbg.ReadString(cr) 3172 3172 + if err != nil { 3173 3173 + return err 3174 3174 + } 3175 3175 + 3176 3176 + name = string(sval) 3177 3177 + } 3178 3178 + 3179 3179 + switch name { 3180 3180 + // t.Lang (string) (string) 3181 3181 + case "lang": 3182 3182 + 3183 3183 + { 3184 3184 + sval, err := cbg.ReadString(cr) 3185 3185 + if err != nil { 3186 3186 + return err 3187 3187 + } 3188 3188 + 3189 3189 + t.Lang = string(sval) 3190 3190 + } 3191 3191 + // t.Name (string) (string) 3192 3192 + case "name": 3193 3193 + 3194 3194 + { 3195 3195 + sval, err := cbg.ReadString(cr) 3196 3196 + if err != nil { 3197 3197 + return err 3198 3198 + } 3199 3199 + 3200 3200 + t.Name = string(sval) 3201 3201 + } 3202 3202 + // t.Description (string) (string) 3203 3203 + case "description": 3204 3204 + 3205 3205 + { 3206 3206 + sval, err := cbg.ReadString(cr) 3207 3207 + if err != nil { 3208 3208 + return err 3209 3209 + } 3210 3210 + 3211 3211 + t.Description = string(sval) 3212 3212 + } 3213 3213 + 3214 3214 + default: 3215 3215 + // Field doesn't exist on this type, so ignore it 3216 3216 + cbg.ScanForLinks(r, func(cid.Cid) {}) 3217 3217 + } 3218 3218 + } 3219 3219 + 3220 3220 + return nil 3221 3221 + }

+25

api/atproto/labeldefs.go

reviewed

··· 22 22 Val string `json:"val" cborgen:"val"` 23 23 } 24 24 25 25 + // LabelDefs_LabelValueDefinition is a "labelValueDefinition" in the com.atproto.label.defs schema. 26 26 + // 27 27 + // Declares a label value and its expected interpertations and behaviors. 28 28 + type LabelDefs_LabelValueDefinition struct { 29 29 + // blurs: What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing. 30 30 + Blurs string `json:"blurs" cborgen:"blurs"` 31 31 + // identifier: The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+). 32 32 + Identifier string `json:"identifier" cborgen:"identifier"` 33 33 + Locales []*LabelDefs_LabelValueDefinitionStrings `json:"locales" cborgen:"locales"` 34 34 + // severity: How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing. 35 35 + Severity string `json:"severity" cborgen:"severity"` 36 36 + } 37 37 + 38 38 + // LabelDefs_LabelValueDefinitionStrings is a "labelValueDefinitionStrings" in the com.atproto.label.defs schema. 39 39 + // 40 40 + // Strings which describe the label in the UI, localized into a specific language. 41 41 + type LabelDefs_LabelValueDefinitionStrings struct { 42 42 + // description: A longer description of what the label means and why it might be applied. 43 43 + Description string `json:"description" cborgen:"description"` 44 44 + // lang: The code of the language these strings are written in. 45 45 + Lang string `json:"lang" cborgen:"lang"` 46 46 + // name: A short human-readable name for the label. 47 47 + Name string `json:"name" cborgen:"name"` 48 48 + } 49 49 + 25 50 // LabelDefs_SelfLabel is a "selfLabel" in the com.atproto.label.defs schema. 26 51 // 27 52 // Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel.

+65 -1

api/bsky/actordefs.go

reviewed

··· 26 26 type ActorDefs_ContentLabelPref struct { 27 27 LexiconTypeID string `json:"$type,const=app.bsky.actor.defs#contentLabelPref" cborgen:"$type,const=app.bsky.actor.defs#contentLabelPref"` 28 28 Label string `json:"label" cborgen:"label"` 29 29 - Visibility string `json:"visibility" cborgen:"visibility"` 29 29 + // labelerDid: Which labeler does this preference apply to? If undefined, applies globally. 30 30 + LabelerDid *string `json:"labelerDid,omitempty" cborgen:"labelerDid,omitempty"` 31 31 + Visibility string `json:"visibility" cborgen:"visibility"` 30 32 } 31 33 32 34 // ActorDefs_FeedViewPref is a "feedViewPref" in the app.bsky.actor.defs schema. ··· 48 50 HideReposts *bool `json:"hideReposts,omitempty" cborgen:"hideReposts,omitempty"` 49 51 } 50 52 53 53 + // ActorDefs_HiddenPostsPref is a "hiddenPostsPref" in the app.bsky.actor.defs schema. 54 54 + // 55 55 + // RECORDTYPE: ActorDefs_HiddenPostsPref 56 56 + type ActorDefs_HiddenPostsPref struct { 57 57 + LexiconTypeID string `json:"$type,const=app.bsky.actor.defs#hiddenPostsPref" cborgen:"$type,const=app.bsky.actor.defs#hiddenPostsPref"` 58 58 + // items: A list of URIs of posts the account owner has hidden. 59 59 + Items []string `json:"items" cborgen:"items"` 60 60 + } 61 61 + 51 62 // ActorDefs_InterestsPref is a "interestsPref" in the app.bsky.actor.defs schema. 52 63 // 53 64 // RECORDTYPE: ActorDefs_InterestsPref ··· 57 68 Tags []string `json:"tags" cborgen:"tags"` 58 69 } 59 70 71 71 + // ActorDefs_ModPrefItem is a "modPrefItem" in the app.bsky.actor.defs schema. 72 72 + type ActorDefs_ModPrefItem struct { 73 73 + Did string `json:"did" cborgen:"did"` 74 74 + } 75 75 + 76 76 + // ActorDefs_ModsPref is a "modsPref" in the app.bsky.actor.defs schema. 77 77 + type ActorDefs_ModsPref struct { 78 78 + Mods []*ActorDefs_ModPrefItem `json:"mods" cborgen:"mods"` 79 79 + } 80 80 + 81 81 + // ActorDefs_MutedWord is a "mutedWord" in the app.bsky.actor.defs schema. 82 82 + // 83 83 + // A word that the account owner has muted. 84 84 + type ActorDefs_MutedWord struct { 85 85 + // targets: The intended targets of the muted word. 86 86 + Targets []*string `json:"targets" cborgen:"targets"` 87 87 + // value: The muted word itself. 88 88 + Value string `json:"value" cborgen:"value"` 89 89 + } 90 90 + 91 91 + // ActorDefs_MutedWordsPref is a "mutedWordsPref" in the app.bsky.actor.defs schema. 92 92 + // 93 93 + // RECORDTYPE: ActorDefs_MutedWordsPref 94 94 + type ActorDefs_MutedWordsPref struct { 95 95 + LexiconTypeID string `json:"$type,const=app.bsky.actor.defs#mutedWordsPref" cborgen:"$type,const=app.bsky.actor.defs#mutedWordsPref"` 96 96 + // items: A list of words the account owner has muted. 97 97 + Items []*ActorDefs_MutedWord `json:"items" cborgen:"items"` 98 98 + } 99 99 + 60 100 // ActorDefs_PersonalDetailsPref is a "personalDetailsPref" in the app.bsky.actor.defs schema. 61 101 // 62 102 // RECORDTYPE: ActorDefs_PersonalDetailsPref ··· 74 114 ActorDefs_FeedViewPref *ActorDefs_FeedViewPref 75 115 ActorDefs_ThreadViewPref *ActorDefs_ThreadViewPref 76 116 ActorDefs_InterestsPref *ActorDefs_InterestsPref 117 117 + ActorDefs_MutedWordsPref *ActorDefs_MutedWordsPref 118 118 + ActorDefs_HiddenPostsPref *ActorDefs_HiddenPostsPref 77 119 } 78 120 79 121 func (t *ActorDefs_Preferences_Elem) MarshalJSON() ([]byte, error) { ··· 105 147 t.ActorDefs_InterestsPref.LexiconTypeID = "app.bsky.actor.defs#interestsPref" 106 148 return json.Marshal(t.ActorDefs_InterestsPref) 107 149 } 150 150 + if t.ActorDefs_MutedWordsPref != nil { 151 151 + t.ActorDefs_MutedWordsPref.LexiconTypeID = "app.bsky.actor.defs#mutedWordsPref" 152 152 + return json.Marshal(t.ActorDefs_MutedWordsPref) 153 153 + } 154 154 + if t.ActorDefs_HiddenPostsPref != nil { 155 155 + t.ActorDefs_HiddenPostsPref.LexiconTypeID = "app.bsky.actor.defs#hiddenPostsPref" 156 156 + return json.Marshal(t.ActorDefs_HiddenPostsPref) 157 157 + } 108 158 return nil, fmt.Errorf("cannot marshal empty enum") 109 159 } 110 160 func (t *ActorDefs_Preferences_Elem) UnmarshalJSON(b []byte) error { ··· 135 185 case "app.bsky.actor.defs#interestsPref": 136 186 t.ActorDefs_InterestsPref = new(ActorDefs_InterestsPref) 137 187 return json.Unmarshal(b, t.ActorDefs_InterestsPref) 188 188 + case "app.bsky.actor.defs#mutedWordsPref": 189 189 + t.ActorDefs_MutedWordsPref = new(ActorDefs_MutedWordsPref) 190 190 + return json.Unmarshal(b, t.ActorDefs_MutedWordsPref) 191 191 + case "app.bsky.actor.defs#hiddenPostsPref": 192 192 + t.ActorDefs_HiddenPostsPref = new(ActorDefs_HiddenPostsPref) 193 193 + return json.Unmarshal(b, t.ActorDefs_HiddenPostsPref) 138 194 139 195 default: 140 196 return nil 141 197 } 142 198 } 143 199 200 200 + // ActorDefs_ProfileAssociated is a "profileAssociated" in the app.bsky.actor.defs schema. 201 201 + type ActorDefs_ProfileAssociated struct { 202 202 + Feedgens *int64 `json:"feedgens,omitempty" cborgen:"feedgens,omitempty"` 203 203 + Labeler *bool `json:"labeler,omitempty" cborgen:"labeler,omitempty"` 204 204 + Lists *int64 `json:"lists,omitempty" cborgen:"lists,omitempty"` 205 205 + } 206 206 + 144 207 // ActorDefs_ProfileView is a "profileView" in the app.bsky.actor.defs schema. 145 208 type ActorDefs_ProfileView struct { 146 209 Avatar *string `json:"avatar,omitempty" cborgen:"avatar,omitempty"` ··· 165 228 166 229 // ActorDefs_ProfileViewDetailed is a "profileViewDetailed" in the app.bsky.actor.defs schema. 167 230 type ActorDefs_ProfileViewDetailed struct { 231 231 + Associated *ActorDefs_ProfileAssociated `json:"associated,omitempty" cborgen:"associated,omitempty"` 168 232 Avatar *string `json:"avatar,omitempty" cborgen:"avatar,omitempty"` 169 233 Banner *string `json:"banner,omitempty" cborgen:"banner,omitempty"` 170 234 Description *string `json:"description,omitempty" cborgen:"description,omitempty"`

+428

api/bsky/cbor_gen.go

reviewed

··· 5803 5803 5804 5804 return nil 5805 5805 } 5806 5806 + func (t *LabelerService) MarshalCBOR(w io.Writer) error { 5807 5807 + if t == nil { 5808 5808 + _, err := w.Write(cbg.CborNull) 5809 5809 + return err 5810 5810 + } 5811 5811 + 5812 5812 + cw := cbg.NewCborWriter(w) 5813 5813 + fieldCount := 4 5814 5814 + 5815 5815 + if t.Labels == nil { 5816 5816 + fieldCount-- 5817 5817 + } 5818 5818 + 5819 5819 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 5820 5820 + return err 5821 5821 + } 5822 5822 + 5823 5823 + // t.LexiconTypeID (string) (string) 5824 5824 + if uint64(len("$type")) > cbg.MaxLength { 5825 5825 + return xerrors.Errorf("Value in field \"$type\" was too long") 5826 5826 + } 5827 5827 + 5828 5828 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 5829 5829 + return err 5830 5830 + } 5831 5831 + if _, err := cw.WriteString(string("$type")); err != nil { 5832 5832 + return err 5833 5833 + } 5834 5834 + 5835 5835 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.bsky.labeler.service"))); err != nil { 5836 5836 + return err 5837 5837 + } 5838 5838 + if _, err := cw.WriteString(string("app.bsky.labeler.service")); err != nil { 5839 5839 + return err 5840 5840 + } 5841 5841 + 5842 5842 + // t.Labels (bsky.LabelerService_Labels) (struct) 5843 5843 + if t.Labels != nil { 5844 5844 + 5845 5845 + if uint64(len("labels")) > cbg.MaxLength { 5846 5846 + return xerrors.Errorf("Value in field \"labels\" was too long") 5847 5847 + } 5848 5848 + 5849 5849 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labels"))); err != nil { 5850 5850 + return err 5851 5851 + } 5852 5852 + if _, err := cw.WriteString(string("labels")); err != nil { 5853 5853 + return err 5854 5854 + } 5855 5855 + 5856 5856 + if err := t.Labels.MarshalCBOR(cw); err != nil { 5857 5857 + return err 5858 5858 + } 5859 5859 + } 5860 5860 + 5861 5861 + // t.Policies (bsky.LabelerDefs_LabelerPolicies) (struct) 5862 5862 + if uint64(len("policies")) > cbg.MaxLength { 5863 5863 + return xerrors.Errorf("Value in field \"policies\" was too long") 5864 5864 + } 5865 5865 + 5866 5866 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("policies"))); err != nil { 5867 5867 + return err 5868 5868 + } 5869 5869 + if _, err := cw.WriteString(string("policies")); err != nil { 5870 5870 + return err 5871 5871 + } 5872 5872 + 5873 5873 + if err := t.Policies.MarshalCBOR(cw); err != nil { 5874 5874 + return err 5875 5875 + } 5876 5876 + 5877 5877 + // t.CreatedAt (string) (string) 5878 5878 + if uint64(len("createdAt")) > cbg.MaxLength { 5879 5879 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 5880 5880 + } 5881 5881 + 5882 5882 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 5883 5883 + return err 5884 5884 + } 5885 5885 + if _, err := cw.WriteString(string("createdAt")); err != nil { 5886 5886 + return err 5887 5887 + } 5888 5888 + 5889 5889 + if uint64(len(t.CreatedAt)) > cbg.MaxLength { 5890 5890 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 5891 5891 + } 5892 5892 + 5893 5893 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 5894 5894 + return err 5895 5895 + } 5896 5896 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 5897 5897 + return err 5898 5898 + } 5899 5899 + return nil 5900 5900 + } 5901 5901 + 5902 5902 + func (t *LabelerService) UnmarshalCBOR(r io.Reader) (err error) { 5903 5903 + *t = LabelerService{} 5904 5904 + 5905 5905 + cr := cbg.NewCborReader(r) 5906 5906 + 5907 5907 + maj, extra, err := cr.ReadHeader() 5908 5908 + if err != nil { 5909 5909 + return err 5910 5910 + } 5911 5911 + defer func() { 5912 5912 + if err == io.EOF { 5913 5913 + err = io.ErrUnexpectedEOF 5914 5914 + } 5915 5915 + }() 5916 5916 + 5917 5917 + if maj != cbg.MajMap { 5918 5918 + return fmt.Errorf("cbor input should be of type map") 5919 5919 + } 5920 5920 + 5921 5921 + if extra > cbg.MaxLength { 5922 5922 + return fmt.Errorf("LabelerService: map struct too large (%d)", extra) 5923 5923 + } 5924 5924 + 5925 5925 + var name string 5926 5926 + n := extra 5927 5927 + 5928 5928 + for i := uint64(0); i < n; i++ { 5929 5929 + 5930 5930 + { 5931 5931 + sval, err := cbg.ReadString(cr) 5932 5932 + if err != nil { 5933 5933 + return err 5934 5934 + } 5935 5935 + 5936 5936 + name = string(sval) 5937 5937 + } 5938 5938 + 5939 5939 + switch name { 5940 5940 + // t.LexiconTypeID (string) (string) 5941 5941 + case "$type": 5942 5942 + 5943 5943 + { 5944 5944 + sval, err := cbg.ReadString(cr) 5945 5945 + if err != nil { 5946 5946 + return err 5947 5947 + } 5948 5948 + 5949 5949 + t.LexiconTypeID = string(sval) 5950 5950 + } 5951 5951 + // t.Labels (bsky.LabelerService_Labels) (struct) 5952 5952 + case "labels": 5953 5953 + 5954 5954 + { 5955 5955 + 5956 5956 + b, err := cr.ReadByte() 5957 5957 + if err != nil { 5958 5958 + return err 5959 5959 + } 5960 5960 + if b != cbg.CborNull[0] { 5961 5961 + if err := cr.UnreadByte(); err != nil { 5962 5962 + return err 5963 5963 + } 5964 5964 + t.Labels = new(LabelerService_Labels) 5965 5965 + if err := t.Labels.UnmarshalCBOR(cr); err != nil { 5966 5966 + return xerrors.Errorf("unmarshaling t.Labels pointer: %w", err) 5967 5967 + } 5968 5968 + } 5969 5969 + 5970 5970 + } 5971 5971 + // t.Policies (bsky.LabelerDefs_LabelerPolicies) (struct) 5972 5972 + case "policies": 5973 5973 + 5974 5974 + { 5975 5975 + 5976 5976 + b, err := cr.ReadByte() 5977 5977 + if err != nil { 5978 5978 + return err 5979 5979 + } 5980 5980 + if b != cbg.CborNull[0] { 5981 5981 + if err := cr.UnreadByte(); err != nil { 5982 5982 + return err 5983 5983 + } 5984 5984 + t.Policies = new(LabelerDefs_LabelerPolicies) 5985 5985 + if err := t.Policies.UnmarshalCBOR(cr); err != nil { 5986 5986 + return xerrors.Errorf("unmarshaling t.Policies pointer: %w", err) 5987 5987 + } 5988 5988 + } 5989 5989 + 5990 5990 + } 5991 5991 + // t.CreatedAt (string) (string) 5992 5992 + case "createdAt": 5993 5993 + 5994 5994 + { 5995 5995 + sval, err := cbg.ReadString(cr) 5996 5996 + if err != nil { 5997 5997 + return err 5998 5998 + } 5999 5999 + 6000 6000 + t.CreatedAt = string(sval) 6001 6001 + } 6002 6002 + 6003 6003 + default: 6004 6004 + // Field doesn't exist on this type, so ignore it 6005 6005 + cbg.ScanForLinks(r, func(cid.Cid) {}) 6006 6006 + } 6007 6007 + } 6008 6008 + 6009 6009 + return nil 6010 6010 + } 6011 6011 + func (t *LabelerDefs_LabelerPolicies) MarshalCBOR(w io.Writer) error { 6012 6012 + if t == nil { 6013 6013 + _, err := w.Write(cbg.CborNull) 6014 6014 + return err 6015 6015 + } 6016 6016 + 6017 6017 + cw := cbg.NewCborWriter(w) 6018 6018 + fieldCount := 2 6019 6019 + 6020 6020 + if t.LabelValueDefinitions == nil { 6021 6021 + fieldCount-- 6022 6022 + } 6023 6023 + 6024 6024 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 6025 6025 + return err 6026 6026 + } 6027 6027 + 6028 6028 + // t.LabelValues ([]*string) (slice) 6029 6029 + if uint64(len("labelValues")) > cbg.MaxLength { 6030 6030 + return xerrors.Errorf("Value in field \"labelValues\" was too long") 6031 6031 + } 6032 6032 + 6033 6033 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labelValues"))); err != nil { 6034 6034 + return err 6035 6035 + } 6036 6036 + if _, err := cw.WriteString(string("labelValues")); err != nil { 6037 6037 + return err 6038 6038 + } 6039 6039 + 6040 6040 + if uint64(len(t.LabelValues)) > cbg.MaxLength { 6041 6041 + return xerrors.Errorf("Slice value in field t.LabelValues was too long") 6042 6042 + } 6043 6043 + 6044 6044 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.LabelValues))); err != nil { 6045 6045 + return err 6046 6046 + } 6047 6047 + for _, v := range t.LabelValues { 6048 6048 + if v == nil { 6049 6049 + if _, err := cw.Write(cbg.CborNull); err != nil { 6050 6050 + return err 6051 6051 + } 6052 6052 + } else { 6053 6053 + if uint64(len(*v)) > cbg.MaxLength { 6054 6054 + return xerrors.Errorf("Value in field v was too long") 6055 6055 + } 6056 6056 + 6057 6057 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*v))); err != nil { 6058 6058 + return err 6059 6059 + } 6060 6060 + if _, err := cw.WriteString(string(*v)); err != nil { 6061 6061 + return err 6062 6062 + } 6063 6063 + } 6064 6064 + 6065 6065 + } 6066 6066 + 6067 6067 + // t.LabelValueDefinitions ([]*atproto.LabelDefs_LabelValueDefinition) (slice) 6068 6068 + if t.LabelValueDefinitions != nil { 6069 6069 + 6070 6070 + if uint64(len("labelValueDefinitions")) > cbg.MaxLength { 6071 6071 + return xerrors.Errorf("Value in field \"labelValueDefinitions\" was too long") 6072 6072 + } 6073 6073 + 6074 6074 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("labelValueDefinitions"))); err != nil { 6075 6075 + return err 6076 6076 + } 6077 6077 + if _, err := cw.WriteString(string("labelValueDefinitions")); err != nil { 6078 6078 + return err 6079 6079 + } 6080 6080 + 6081 6081 + if uint64(len(t.LabelValueDefinitions)) > cbg.MaxLength { 6082 6082 + return xerrors.Errorf("Slice value in field t.LabelValueDefinitions was too long") 6083 6083 + } 6084 6084 + 6085 6085 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.LabelValueDefinitions))); err != nil { 6086 6086 + return err 6087 6087 + } 6088 6088 + for _, v := range t.LabelValueDefinitions { 6089 6089 + if err := v.MarshalCBOR(cw); err != nil { 6090 6090 + return err 6091 6091 + } 6092 6092 + 6093 6093 + } 6094 6094 + } 6095 6095 + return nil 6096 6096 + } 6097 6097 + 6098 6098 + func (t *LabelerDefs_LabelerPolicies) UnmarshalCBOR(r io.Reader) (err error) { 6099 6099 + *t = LabelerDefs_LabelerPolicies{} 6100 6100 + 6101 6101 + cr := cbg.NewCborReader(r) 6102 6102 + 6103 6103 + maj, extra, err := cr.ReadHeader() 6104 6104 + if err != nil { 6105 6105 + return err 6106 6106 + } 6107 6107 + defer func() { 6108 6108 + if err == io.EOF { 6109 6109 + err = io.ErrUnexpectedEOF 6110 6110 + } 6111 6111 + }() 6112 6112 + 6113 6113 + if maj != cbg.MajMap { 6114 6114 + return fmt.Errorf("cbor input should be of type map") 6115 6115 + } 6116 6116 + 6117 6117 + if extra > cbg.MaxLength { 6118 6118 + return fmt.Errorf("LabelerDefs_LabelerPolicies: map struct too large (%d)", extra) 6119 6119 + } 6120 6120 + 6121 6121 + var name string 6122 6122 + n := extra 6123 6123 + 6124 6124 + for i := uint64(0); i < n; i++ { 6125 6125 + 6126 6126 + { 6127 6127 + sval, err := cbg.ReadString(cr) 6128 6128 + if err != nil { 6129 6129 + return err 6130 6130 + } 6131 6131 + 6132 6132 + name = string(sval) 6133 6133 + } 6134 6134 + 6135 6135 + switch name { 6136 6136 + // t.LabelValues ([]*string) (slice) 6137 6137 + case "labelValues": 6138 6138 + 6139 6139 + maj, extra, err = cr.ReadHeader() 6140 6140 + if err != nil { 6141 6141 + return err 6142 6142 + } 6143 6143 + 6144 6144 + if extra > cbg.MaxLength { 6145 6145 + return fmt.Errorf("t.LabelValues: array too large (%d)", extra) 6146 6146 + } 6147 6147 + 6148 6148 + if maj != cbg.MajArray { 6149 6149 + return fmt.Errorf("expected cbor array") 6150 6150 + } 6151 6151 + 6152 6152 + if extra > 0 { 6153 6153 + t.LabelValues = make([]*string, extra) 6154 6154 + } 6155 6155 + 6156 6156 + for i := 0; i < int(extra); i++ { 6157 6157 + { 6158 6158 + var maj byte 6159 6159 + var extra uint64 6160 6160 + var err error 6161 6161 + _ = maj 6162 6162 + _ = extra 6163 6163 + _ = err 6164 6164 + 6165 6165 + { 6166 6166 + sval, err := cbg.ReadString(cr) 6167 6167 + if err != nil { 6168 6168 + return err 6169 6169 + } 6170 6170 + 6171 6171 + t.LabelValues[i] = &sval 6172 6172 + } 6173 6173 + 6174 6174 + } 6175 6175 + } 6176 6176 + // t.LabelValueDefinitions ([]*atproto.LabelDefs_LabelValueDefinition) (slice) 6177 6177 + case "labelValueDefinitions": 6178 6178 + 6179 6179 + maj, extra, err = cr.ReadHeader() 6180 6180 + if err != nil { 6181 6181 + return err 6182 6182 + } 6183 6183 + 6184 6184 + if extra > cbg.MaxLength { 6185 6185 + return fmt.Errorf("t.LabelValueDefinitions: array too large (%d)", extra) 6186 6186 + } 6187 6187 + 6188 6188 + if maj != cbg.MajArray { 6189 6189 + return fmt.Errorf("expected cbor array") 6190 6190 + } 6191 6191 + 6192 6192 + if extra > 0 { 6193 6193 + t.LabelValueDefinitions = make([]*atproto.LabelDefs_LabelValueDefinition, extra) 6194 6194 + } 6195 6195 + 6196 6196 + for i := 0; i < int(extra); i++ { 6197 6197 + { 6198 6198 + var maj byte 6199 6199 + var extra uint64 6200 6200 + var err error 6201 6201 + _ = maj 6202 6202 + _ = extra 6203 6203 + _ = err 6204 6204 + 6205 6205 + { 6206 6206 + 6207 6207 + b, err := cr.ReadByte() 6208 6208 + if err != nil { 6209 6209 + return err 6210 6210 + } 6211 6211 + if b != cbg.CborNull[0] { 6212 6212 + if err := cr.UnreadByte(); err != nil { 6213 6213 + return err 6214 6214 + } 6215 6215 + t.LabelValueDefinitions[i] = new(atproto.LabelDefs_LabelValueDefinition) 6216 6216 + if err := t.LabelValueDefinitions[i].UnmarshalCBOR(cr); err != nil { 6217 6217 + return xerrors.Errorf("unmarshaling t.LabelValueDefinitions[i] pointer: %w", err) 6218 6218 + } 6219 6219 + } 6220 6220 + 6221 6221 + } 6222 6222 + 6223 6223 + } 6224 6224 + } 6225 6225 + 6226 6226 + default: 6227 6227 + // Field doesn't exist on this type, so ignore it 6228 6228 + cbg.ScanForLinks(r, func(cid.Cid) {}) 6229 6229 + } 6230 6230 + } 6231 6231 + 6232 6232 + return nil 6233 6233 + }

+8

api/bsky/embedrecord.go

reviewed

··· 120 120 EmbedRecord_ViewBlocked *EmbedRecord_ViewBlocked 121 121 FeedDefs_GeneratorView *FeedDefs_GeneratorView 122 122 GraphDefs_ListView *GraphDefs_ListView 123 123 + LabelerDefs_LabelerView *LabelerDefs_LabelerView 123 124 } 124 125 125 126 func (t *EmbedRecord_View_Record) MarshalJSON() ([]byte, error) { ··· 143 144 t.GraphDefs_ListView.LexiconTypeID = "app.bsky.graph.defs#listView" 144 145 return json.Marshal(t.GraphDefs_ListView) 145 146 } 147 147 + if t.LabelerDefs_LabelerView != nil { 148 148 + t.LabelerDefs_LabelerView.LexiconTypeID = "app.bsky.labeler.defs#labelerView" 149 149 + return json.Marshal(t.LabelerDefs_LabelerView) 150 150 + } 146 151 return nil, fmt.Errorf("cannot marshal empty enum") 147 152 } 148 153 func (t *EmbedRecord_View_Record) UnmarshalJSON(b []byte) error { ··· 167 172 case "app.bsky.graph.defs#listView": 168 173 t.GraphDefs_ListView = new(GraphDefs_ListView) 169 174 return json.Unmarshal(b, t.GraphDefs_ListView) 175 175 + case "app.bsky.labeler.defs#labelerView": 176 176 + t.LabelerDefs_LabelerView = new(LabelerDefs_LabelerView) 177 177 + return json.Unmarshal(b, t.LabelerDefs_LabelerView) 170 178 171 179 default: 172 180 return nil

+51

api/bsky/labelerdefs.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package bsky 4 4 + 5 5 + // schema: app.bsky.labeler.defs 6 6 + 7 7 + import ( 8 8 + comatprototypes "github.com/bluesky-social/indigo/api/atproto" 9 9 + ) 10 10 + 11 11 + // LabelerDefs_LabelerPolicies is a "labelerPolicies" in the app.bsky.labeler.defs schema. 12 12 + type LabelerDefs_LabelerPolicies struct { 13 13 + // labelValueDefinitions: Label values created by this labeler and scoped exclusively to it. Labels defined here will override global label definitions for this labeler. 14 14 + LabelValueDefinitions []*comatprototypes.LabelDefs_LabelValueDefinition `json:"labelValueDefinitions,omitempty" cborgen:"labelValueDefinitions,omitempty"` 15 15 + // labelValues: The label values which this labeler publishes. May include global or custom labels. 16 16 + LabelValues []*string `json:"labelValues" cborgen:"labelValues"` 17 17 + } 18 18 + 19 19 + // LabelerDefs_LabelerView is a "labelerView" in the app.bsky.labeler.defs schema. 20 20 + // 21 21 + // RECORDTYPE: LabelerDefs_LabelerView 22 22 + type LabelerDefs_LabelerView struct { 23 23 + LexiconTypeID string `json:"$type,const=app.bsky.labeler.defs#labelerView" cborgen:"$type,const=app.bsky.labeler.defs#labelerView"` 24 24 + Cid string `json:"cid" cborgen:"cid"` 25 25 + Creator *ActorDefs_ProfileView `json:"creator" cborgen:"creator"` 26 26 + IndexedAt string `json:"indexedAt" cborgen:"indexedAt"` 27 27 + Labels []*comatprototypes.LabelDefs_Label `json:"labels,omitempty" cborgen:"labels,omitempty"` 28 28 + LikeCount *int64 `json:"likeCount,omitempty" cborgen:"likeCount,omitempty"` 29 29 + Uri string `json:"uri" cborgen:"uri"` 30 30 + Viewer *LabelerDefs_LabelerViewerState `json:"viewer,omitempty" cborgen:"viewer,omitempty"` 31 31 + } 32 32 + 33 33 + // LabelerDefs_LabelerViewDetailed is a "labelerViewDetailed" in the app.bsky.labeler.defs schema. 34 34 + // 35 35 + // RECORDTYPE: LabelerDefs_LabelerViewDetailed 36 36 + type LabelerDefs_LabelerViewDetailed struct { 37 37 + LexiconTypeID string `json:"$type,const=app.bsky.labeler.defs#labelerViewDetailed" cborgen:"$type,const=app.bsky.labeler.defs#labelerViewDetailed"` 38 38 + Cid string `json:"cid" cborgen:"cid"` 39 39 + Creator *ActorDefs_ProfileView `json:"creator" cborgen:"creator"` 40 40 + IndexedAt string `json:"indexedAt" cborgen:"indexedAt"` 41 41 + Labels []*comatprototypes.LabelDefs_Label `json:"labels,omitempty" cborgen:"labels,omitempty"` 42 42 + LikeCount *int64 `json:"likeCount,omitempty" cborgen:"likeCount,omitempty"` 43 43 + Policies *LabelerDefs_LabelerPolicies `json:"policies" cborgen:"policies"` 44 44 + Uri string `json:"uri" cborgen:"uri"` 45 45 + Viewer *LabelerDefs_LabelerViewerState `json:"viewer,omitempty" cborgen:"viewer,omitempty"` 46 46 + } 47 47 + 48 48 + // LabelerDefs_LabelerViewerState is a "labelerViewerState" in the app.bsky.labeler.defs schema. 49 49 + type LabelerDefs_LabelerViewerState struct { 50 50 + Like *string `json:"like,omitempty" cborgen:"like,omitempty"` 51 51 + }

+69

api/bsky/labelergetServices.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package bsky 4 4 + 5 5 + // schema: app.bsky.labeler.getServices 6 6 + 7 7 + import ( 8 8 + "context" 9 9 + "encoding/json" 10 10 + "fmt" 11 11 + 12 12 + "github.com/bluesky-social/indigo/lex/util" 13 13 + "github.com/bluesky-social/indigo/xrpc" 14 14 + ) 15 15 + 16 16 + // LabelerGetServices_Output is the output of a app.bsky.labeler.getServices call. 17 17 + type LabelerGetServices_Output struct { 18 18 + Views []*LabelerGetServices_Output_Views_Elem `json:"views" cborgen:"views"` 19 19 + } 20 20 + 21 21 + type LabelerGetServices_Output_Views_Elem struct { 22 22 + LabelerDefs_LabelerView *LabelerDefs_LabelerView 23 23 + LabelerDefs_LabelerViewDetailed *LabelerDefs_LabelerViewDetailed 24 24 + } 25 25 + 26 26 + func (t *LabelerGetServices_Output_Views_Elem) MarshalJSON() ([]byte, error) { 27 27 + if t.LabelerDefs_LabelerView != nil { 28 28 + t.LabelerDefs_LabelerView.LexiconTypeID = "app.bsky.labeler.defs#labelerView" 29 29 + return json.Marshal(t.LabelerDefs_LabelerView) 30 30 + } 31 31 + if t.LabelerDefs_LabelerViewDetailed != nil { 32 32 + t.LabelerDefs_LabelerViewDetailed.LexiconTypeID = "app.bsky.labeler.defs#labelerViewDetailed" 33 33 + return json.Marshal(t.LabelerDefs_LabelerViewDetailed) 34 34 + } 35 35 + return nil, fmt.Errorf("cannot marshal empty enum") 36 36 + } 37 37 + func (t *LabelerGetServices_Output_Views_Elem) UnmarshalJSON(b []byte) error { 38 38 + typ, err := util.TypeExtract(b) 39 39 + if err != nil { 40 40 + return err 41 41 + } 42 42 + 43 43 + switch typ { 44 44 + case "app.bsky.labeler.defs#labelerView": 45 45 + t.LabelerDefs_LabelerView = new(LabelerDefs_LabelerView) 46 46 + return json.Unmarshal(b, t.LabelerDefs_LabelerView) 47 47 + case "app.bsky.labeler.defs#labelerViewDetailed": 48 48 + t.LabelerDefs_LabelerViewDetailed = new(LabelerDefs_LabelerViewDetailed) 49 49 + return json.Unmarshal(b, t.LabelerDefs_LabelerViewDetailed) 50 50 + 51 51 + default: 52 52 + return nil 53 53 + } 54 54 + } 55 55 + 56 56 + // LabelerGetServices calls the XRPC method "app.bsky.labeler.getServices". 57 57 + func LabelerGetServices(ctx context.Context, c *xrpc.Client, detailed bool, dids []string) (*LabelerGetServices_Output, error) { 58 58 + var out LabelerGetServices_Output 59 59 + 60 60 + params := map[string]interface{}{ 61 61 + "detailed": detailed, 62 62 + "dids": dids, 63 63 + } 64 64 + if err := c.Do(ctx, xrpc.Query, "", "app.bsky.labeler.getServices", params, nil, &out); err != nil { 65 65 + return nil, err 66 66 + } 67 67 + 68 68 + return &out, nil 69 69 + }

+81

api/bsky/labelerservice.go

reviewed

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package bsky 4 4 + 5 5 + // schema: app.bsky.labeler.service 6 6 + 7 7 + import ( 8 8 + "bytes" 9 9 + "encoding/json" 10 10 + "fmt" 11 11 + "io" 12 12 + 13 13 + comatprototypes "github.com/bluesky-social/indigo/api/atproto" 14 14 + "github.com/bluesky-social/indigo/lex/util" 15 15 + cbg "github.com/whyrusleeping/cbor-gen" 16 16 + ) 17 17 + 18 18 + func init() { 19 19 + util.RegisterType("app.bsky.labeler.service", &LabelerService{}) 20 20 + } // 21 21 + // RECORDTYPE: LabelerService 22 22 + type LabelerService struct { 23 23 + LexiconTypeID string `json:"$type,const=app.bsky.labeler.service" cborgen:"$type,const=app.bsky.labeler.service"` 24 24 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 25 25 + Labels *LabelerService_Labels `json:"labels,omitempty" cborgen:"labels,omitempty"` 26 26 + Policies *LabelerDefs_LabelerPolicies `json:"policies" cborgen:"policies"` 27 27 + } 28 28 + 29 29 + type LabelerService_Labels struct { 30 30 + LabelDefs_SelfLabels *comatprototypes.LabelDefs_SelfLabels 31 31 + } 32 32 + 33 33 + func (t *LabelerService_Labels) MarshalJSON() ([]byte, error) { 34 34 + if t.LabelDefs_SelfLabels != nil { 35 35 + t.LabelDefs_SelfLabels.LexiconTypeID = "com.atproto.label.defs#selfLabels" 36 36 + return json.Marshal(t.LabelDefs_SelfLabels) 37 37 + } 38 38 + return nil, fmt.Errorf("cannot marshal empty enum") 39 39 + } 40 40 + func (t *LabelerService_Labels) UnmarshalJSON(b []byte) error { 41 41 + typ, err := util.TypeExtract(b) 42 42 + if err != nil { 43 43 + return err 44 44 + } 45 45 + 46 46 + switch typ { 47 47 + case "com.atproto.label.defs#selfLabels": 48 48 + t.LabelDefs_SelfLabels = new(comatprototypes.LabelDefs_SelfLabels) 49 49 + return json.Unmarshal(b, t.LabelDefs_SelfLabels) 50 50 + 51 51 + default: 52 52 + return nil 53 53 + } 54 54 + } 55 55 + 56 56 + func (t *LabelerService_Labels) MarshalCBOR(w io.Writer) error { 57 57 + 58 58 + if t == nil { 59 59 + _, err := w.Write(cbg.CborNull) 60 60 + return err 61 61 + } 62 62 + if t.LabelDefs_SelfLabels != nil { 63 63 + return t.LabelDefs_SelfLabels.MarshalCBOR(w) 64 64 + } 65 65 + return fmt.Errorf("cannot cbor marshal empty enum") 66 66 + } 67 67 + func (t *LabelerService_Labels) UnmarshalCBOR(r io.Reader) error { 68 68 + typ, b, err := util.CborTypeExtractReader(r) 69 69 + if err != nil { 70 70 + return err 71 71 + } 72 72 + 73 73 + switch typ { 74 74 + case "com.atproto.label.defs#selfLabels": 75 75 + t.LabelDefs_SelfLabels = new(comatprototypes.LabelDefs_SelfLabels) 76 76 + return t.LabelDefs_SelfLabels.UnmarshalCBOR(bytes.NewReader(b)) 77 77 + 78 78 + default: 79 79 + return nil 80 80 + } 81 81 + }

+4

gen/main.go

reviewed

··· 52 52 bsky.FeedThreadgate_ListRule{}, 53 53 bsky.FeedThreadgate_MentionRule{}, 54 54 bsky.FeedThreadgate_FollowingRule{}, 55 55 + bsky.LabelerService{}, 56 56 + bsky.LabelerDefs_LabelerPolicies{}, 55 57 /*bsky.EmbedImages_View{}, 56 58 bsky.EmbedRecord_View{}, bsky.EmbedRecordWithMedia_View{}, 57 59 bsky.EmbedExternal_View{}, bsky.EmbedImages_ViewImage{}, ··· 77 79 atproto.LabelDefs_Label{}, 78 80 atproto.LabelSubscribeLabels_Labels{}, 79 81 atproto.LabelSubscribeLabels_Info{}, 82 82 + atproto.LabelDefs_LabelValueDefinition{}, 83 83 + atproto.LabelDefs_LabelValueDefinitionStrings{}, 80 84 ); err != nil { 81 85 panic(err) 82 86 }