Support lexicons for video (#721)

api/atproto/labeldefs.go

···
 
 // LabelDefs_LabelValueDefinition is a "labelValueDefinition" in the com.atproto.label.defs schema.
 //
-// Declares a label value and its expected interpertations and behaviors.
+// Declares a label value and its expected interpretations and behaviors.
 type LabelDefs_LabelValueDefinition struct {
 	// adultOnly: Does the user need to have adult content enabled in order to configure this label?
 	AdultOnly *bool `json:"adultOnly,omitempty" cborgen:"adultOnly,omitempty"`

api/atproto/servergetServiceAuth.go

···
 // ServerGetServiceAuth calls the XRPC method "com.atproto.server.getServiceAuth".
 //
 // aud: The DID of the service that the token will be used to authenticate with
-func ServerGetServiceAuth(ctx context.Context, c *xrpc.Client, aud string) (*ServerGetServiceAuth_Output, error) {
+// exp: The time in Unix Epoch seconds that the JWT expires. Defaults to 60 seconds in the future. The service may enforce certain time bounds on tokens depending on the requested scope.
+// lxm: Lexicon (XRPC) method to bind the requested token to
+func ServerGetServiceAuth(ctx context.Context, c *xrpc.Client, aud string, exp int64, lxm string) (*ServerGetServiceAuth_Output, error) {
 	var out ServerGetServiceAuth_Output
 
 	params := map[string]interface{}{
 		"aud": aud,
+		"exp": exp,
+		"lxm": lxm,
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.server.getServiceAuth", params, nil, &out); err != nil {
 		return nil, err

api/bsky/actordefs.go

···
 //
 // A word that the account owner has muted.
 type ActorDefs_MutedWord struct {
+	// actorTarget: Groups of users to apply the muted word to. If undefined, applies to all users.
+	ActorTarget *string `json:"actorTarget,omitempty" cborgen:"actorTarget,omitempty"`
+	// expiresAt: The date and time at which the muted word will expire and no longer be applied.
+	ExpiresAt *string `json:"expiresAt,omitempty" cborgen:"expiresAt,omitempty"`
+	Id        *string `json:"id,omitempty" cborgen:"id,omitempty"`
 	// targets: The intended targets of the muted word.
 	Targets []*string `json:"targets" cborgen:"targets"`
 	// value: The muted word itself.

api/bsky/cbor_gen.go

···
 		return err
 	}
 
-	// t.AspectRatio (bsky.EmbedImages_AspectRatio) (struct)
+	// t.AspectRatio (bsky.EmbedDefs_AspectRatio) (struct)
 	if t.AspectRatio != nil {
 
 		if len("aspectRatio") > 1000000 {
···
 				}
 
 			}
-			// t.AspectRatio (bsky.EmbedImages_AspectRatio) (struct)
+			// t.AspectRatio (bsky.EmbedDefs_AspectRatio) (struct)
 		case "aspectRatio":
 
 			{
···
 					if err := cr.UnreadByte(); err != nil {
 						return err
 					}
-					t.AspectRatio = new(EmbedImages_AspectRatio)
+					t.AspectRatio = new(EmbedDefs_AspectRatio)
 					if err := t.AspectRatio.UnmarshalCBOR(cr); err != nil {
 						return xerrors.Errorf("unmarshaling t.AspectRatio pointer: %w", err)
 					}
···
 
 	return nil
 }
-func (t *EmbedImages_AspectRatio) MarshalCBOR(w io.Writer) error {
+func (t *EmbedDefs_AspectRatio) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
···
 	return nil
 }
 
-func (t *EmbedImages_AspectRatio) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = EmbedImages_AspectRatio{}
+func (t *EmbedDefs_AspectRatio) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = EmbedDefs_AspectRatio{}
 
 	cr := cbg.NewCborReader(r)
 
···
 	}
 
 	if extra > cbg.MaxLength {
-		return fmt.Errorf("EmbedImages_AspectRatio: map struct too large (%d)", extra)
+		return fmt.Errorf("EmbedDefs_AspectRatio: map struct too large (%d)", extra)
 	}
 
 	var name string
···
 
 	return nil
 }
+func (t *EmbedVideo) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+	fieldCount := 5
+
+	if t.Alt == nil {
+		fieldCount--
+	}
+
+	if t.AspectRatio == nil {
+		fieldCount--
+	}
+
+	if t.Captions == nil {
+		fieldCount--
+	}
+
+	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
+		return err
+	}
+
+	// t.Alt (string) (string)
+	if t.Alt != nil {
+
+		if len("alt") > 1000000 {
+			return xerrors.Errorf("Value in field \"alt\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("alt"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("alt")); err != nil {
+			return err
+		}
+
+		if t.Alt == nil {
+			if _, err := cw.Write(cbg.CborNull); err != nil {
+				return err
+			}
+		} else {
+			if len(*t.Alt) > 1000000 {
+				return xerrors.Errorf("Value in field t.Alt was too long")
+			}
+
+			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Alt))); err != nil {
+				return err
+			}
+			if _, err := cw.WriteString(string(*t.Alt)); err != nil {
+				return err
+			}
+		}
+	}
+
+	// t.LexiconTypeID (string) (string)
+	if len("$type") > 1000000 {
+		return xerrors.Errorf("Value in field \"$type\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("$type")); err != nil {
+		return err
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.bsky.embed.video"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("app.bsky.embed.video")); err != nil {
+		return err
+	}
+
+	// t.Video (util.LexBlob) (struct)
+	if len("video") > 1000000 {
+		return xerrors.Errorf("Value in field \"video\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("video"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("video")); err != nil {
+		return err
+	}
+
+	if err := t.Video.MarshalCBOR(cw); err != nil {
+		return err
+	}
+
+	// t.Captions ([]*bsky.EmbedVideo_Caption) (slice)
+	if t.Captions != nil {
+
+		if len("captions") > 1000000 {
+			return xerrors.Errorf("Value in field \"captions\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("captions"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("captions")); err != nil {
+			return err
+		}
+
+		if len(t.Captions) > 8192 {
+			return xerrors.Errorf("Slice value in field t.Captions was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Captions))); err != nil {
+			return err
+		}
+		for _, v := range t.Captions {
+			if err := v.MarshalCBOR(cw); err != nil {
+				return err
+			}
+
+		}
+	}
+
+	// t.AspectRatio (bsky.EmbedDefs_AspectRatio) (struct)
+	if t.AspectRatio != nil {
+
+		if len("aspectRatio") > 1000000 {
+			return xerrors.Errorf("Value in field \"aspectRatio\" was too long")
+		}
+
+		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("aspectRatio"))); err != nil {
+			return err
+		}
+		if _, err := cw.WriteString(string("aspectRatio")); err != nil {
+			return err
+		}
+
+		if err := t.AspectRatio.MarshalCBOR(cw); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *EmbedVideo) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = EmbedVideo{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("EmbedVideo: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringWithMax(cr, 1000000)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.Alt (string) (string)
+		case "alt":
+
+			{
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+
+					sval, err := cbg.ReadStringWithMax(cr, 1000000)
+					if err != nil {
+						return err
+					}
+
+					t.Alt = (*string)(&sval)
+				}
+			}
+			// t.LexiconTypeID (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.LexiconTypeID = string(sval)
+			}
+			// t.Video (util.LexBlob) (struct)
+		case "video":
+
+			{
+
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+					t.Video = new(util.LexBlob)
+					if err := t.Video.UnmarshalCBOR(cr); err != nil {
+						return xerrors.Errorf("unmarshaling t.Video pointer: %w", err)
+					}
+				}
+
+			}
+			// t.Captions ([]*bsky.EmbedVideo_Caption) (slice)
+		case "captions":
+
+			maj, extra, err = cr.ReadHeader()
+			if err != nil {
+				return err
+			}
+
+			if extra > 8192 {
+				return fmt.Errorf("t.Captions: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.Captions = make([]*EmbedVideo_Caption, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+				{
+					var maj byte
+					var extra uint64
+					var err error
+					_ = maj
+					_ = extra
+					_ = err
+
+					{
+
+						b, err := cr.ReadByte()
+						if err != nil {
+							return err
+						}
+						if b != cbg.CborNull[0] {
+							if err := cr.UnreadByte(); err != nil {
+								return err
+							}
+							t.Captions[i] = new(EmbedVideo_Caption)
+							if err := t.Captions[i].UnmarshalCBOR(cr); err != nil {
+								return xerrors.Errorf("unmarshaling t.Captions[i] pointer: %w", err)
+							}
+						}
+
+					}
+
+				}
+			}
+			// t.AspectRatio (bsky.EmbedDefs_AspectRatio) (struct)
+		case "aspectRatio":
+
+			{
+
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+					t.AspectRatio = new(EmbedDefs_AspectRatio)
+					if err := t.AspectRatio.UnmarshalCBOR(cr); err != nil {
+						return xerrors.Errorf("unmarshaling t.AspectRatio pointer: %w", err)
+					}
+				}
+
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			cbg.ScanForLinks(r, func(cid.Cid) {})
+		}
+	}
+
+	return nil
+}
+func (t *EmbedVideo_Caption) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+
+	if _, err := cw.Write([]byte{162}); err != nil {
+		return err
+	}
+
+	// t.File (util.LexBlob) (struct)
+	if len("file") > 1000000 {
+		return xerrors.Errorf("Value in field \"file\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("file"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("file")); err != nil {
+		return err
+	}
+
+	if err := t.File.MarshalCBOR(cw); err != nil {
+		return err
+	}
+
+	// t.Lang (string) (string)
+	if len("lang") > 1000000 {
+		return xerrors.Errorf("Value in field \"lang\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("lang"))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string("lang")); err != nil {
+		return err
+	}
+
+	if len(t.Lang) > 1000000 {
+		return xerrors.Errorf("Value in field t.Lang was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Lang))); err != nil {
+		return err
+	}
+	if _, err := cw.WriteString(string(t.Lang)); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *EmbedVideo_Caption) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = EmbedVideo_Caption{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("EmbedVideo_Caption: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringWithMax(cr, 1000000)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.File (util.LexBlob) (struct)
+		case "file":
+
+			{
+
+				b, err := cr.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := cr.UnreadByte(); err != nil {
+						return err
+					}
+					t.File = new(util.LexBlob)
+					if err := t.File.UnmarshalCBOR(cr); err != nil {
+						return xerrors.Errorf("unmarshaling t.File pointer: %w", err)
+					}
+				}
+
+			}
+			// t.Lang (string) (string)
+		case "lang":
+
+			{
+				sval, err := cbg.ReadStringWithMax(cr, 1000000)
+				if err != nil {
+					return err
+				}
+
+				t.Lang = string(sval)
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			cbg.ScanForLinks(r, func(cid.Cid) {})
+		}
+	}
+
+	return nil
+}

api/bsky/embeddefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package bsky
+
+// schema: app.bsky.embed.defs
+
+// EmbedDefs_AspectRatio is a "aspectRatio" in the app.bsky.embed.defs schema.
+//
+// width:height represents an aspect ratio. It may be approximate, and may not correspond to absolute dimensions in any given unit.
+type EmbedDefs_AspectRatio struct {
+	Height int64 `json:"height" cborgen:"height"`
+	Width  int64 `json:"width" cborgen:"width"`
+}

api/bsky/embedimages.go

···
 	Images        []*EmbedImages_Image `json:"images" cborgen:"images"`
 }
 
-// EmbedImages_AspectRatio is a "aspectRatio" in the app.bsky.embed.images schema.
-//
-// width:height represents an aspect ratio. It may be approximate, and may not correspond to absolute dimensions in any given unit.
-type EmbedImages_AspectRatio struct {
-	Height int64 `json:"height" cborgen:"height"`
-	Width  int64 `json:"width" cborgen:"width"`
-}
-
 // EmbedImages_Image is a "image" in the app.bsky.embed.images schema.
 type EmbedImages_Image struct {
 	// alt: Alt text description of the image, for accessibility.
-	Alt         string                   `json:"alt" cborgen:"alt"`
-	AspectRatio *EmbedImages_AspectRatio `json:"aspectRatio,omitempty" cborgen:"aspectRatio,omitempty"`
-	Image       *util.LexBlob            `json:"image" cborgen:"image"`
+	Alt         string                 `json:"alt" cborgen:"alt"`
+	AspectRatio *EmbedDefs_AspectRatio `json:"aspectRatio,omitempty" cborgen:"aspectRatio,omitempty"`
+	Image       *util.LexBlob          `json:"image" cborgen:"image"`
 }
 
 // EmbedImages_View is a "view" in the app.bsky.embed.images schema.
···
 // EmbedImages_ViewImage is a "viewImage" in the app.bsky.embed.images schema.
 type EmbedImages_ViewImage struct {
 	// alt: Alt text description of the image, for accessibility.
-	Alt         string                   `json:"alt" cborgen:"alt"`
-	AspectRatio *EmbedImages_AspectRatio `json:"aspectRatio,omitempty" cborgen:"aspectRatio,omitempty"`
+	Alt         string                 `json:"alt" cborgen:"alt"`
+	AspectRatio *EmbedDefs_AspectRatio `json:"aspectRatio,omitempty" cborgen:"aspectRatio,omitempty"`
 	// fullsize: Fully-qualified URL where a large version of the image can be fetched. May or may not be the exact original blob. For example, CDN location provided by the App View.
 	Fullsize string `json:"fullsize" cborgen:"fullsize"`
 	// thumb: Fully-qualified URL where a thumbnail of the image can be fetched. For example, CDN location provided by the App View.

api/bsky/embedrecord.go

···
 
 type EmbedRecord_ViewRecord_Embeds_Elem struct {
 	EmbedImages_View          *EmbedImages_View
+	EmbedVideo_View           *EmbedVideo_View
 	EmbedExternal_View        *EmbedExternal_View
 	EmbedRecord_View          *EmbedRecord_View
 	EmbedRecordWithMedia_View *EmbedRecordWithMedia_View
···
 	if t.EmbedImages_View != nil {
 		t.EmbedImages_View.LexiconTypeID = "app.bsky.embed.images#view"
 		return json.Marshal(t.EmbedImages_View)
+	}
+	if t.EmbedVideo_View != nil {
+		t.EmbedVideo_View.LexiconTypeID = "app.bsky.embed.video#view"
+		return json.Marshal(t.EmbedVideo_View)
 	}
 	if t.EmbedExternal_View != nil {
 		t.EmbedExternal_View.LexiconTypeID = "app.bsky.embed.external#view"
···
 	case "app.bsky.embed.images#view":
 		t.EmbedImages_View = new(EmbedImages_View)
 		return json.Unmarshal(b, t.EmbedImages_View)
+	case "app.bsky.embed.video#view":
+		t.EmbedVideo_View = new(EmbedVideo_View)
+		return json.Unmarshal(b, t.EmbedVideo_View)
 	case "app.bsky.embed.external#view":
 		t.EmbedExternal_View = new(EmbedExternal_View)
 		return json.Unmarshal(b, t.EmbedExternal_View)

api/bsky/embedrecordWithMedia.go

···
 
 type EmbedRecordWithMedia_Media struct {
 	EmbedImages   *EmbedImages
+	EmbedVideo    *EmbedVideo
 	EmbedExternal *EmbedExternal
 }
 
···
 	if t.EmbedImages != nil {
 		t.EmbedImages.LexiconTypeID = "app.bsky.embed.images"
 		return json.Marshal(t.EmbedImages)
+	}
+	if t.EmbedVideo != nil {
+		t.EmbedVideo.LexiconTypeID = "app.bsky.embed.video"
+		return json.Marshal(t.EmbedVideo)
 	}
 	if t.EmbedExternal != nil {
 		t.EmbedExternal.LexiconTypeID = "app.bsky.embed.external"
···
 	case "app.bsky.embed.images":
 		t.EmbedImages = new(EmbedImages)
 		return json.Unmarshal(b, t.EmbedImages)
+	case "app.bsky.embed.video":
+		t.EmbedVideo = new(EmbedVideo)
+		return json.Unmarshal(b, t.EmbedVideo)
 	case "app.bsky.embed.external":
 		t.EmbedExternal = new(EmbedExternal)
 		return json.Unmarshal(b, t.EmbedExternal)
···
 	}
 	if t.EmbedImages != nil {
 		return t.EmbedImages.MarshalCBOR(w)
+	}
+	if t.EmbedVideo != nil {
+		return t.EmbedVideo.MarshalCBOR(w)
 	}
 	if t.EmbedExternal != nil {
 		return t.EmbedExternal.MarshalCBOR(w)
···
 	case "app.bsky.embed.images":
 		t.EmbedImages = new(EmbedImages)
 		return t.EmbedImages.UnmarshalCBOR(bytes.NewReader(b))
+	case "app.bsky.embed.video":
+		t.EmbedVideo = new(EmbedVideo)
+		return t.EmbedVideo.UnmarshalCBOR(bytes.NewReader(b))
 	case "app.bsky.embed.external":
 		t.EmbedExternal = new(EmbedExternal)
 		return t.EmbedExternal.UnmarshalCBOR(bytes.NewReader(b))
···
 
 type EmbedRecordWithMedia_View_Media struct {
 	EmbedImages_View   *EmbedImages_View
+	EmbedVideo_View    *EmbedVideo_View
 	EmbedExternal_View *EmbedExternal_View
 }
 
···
 		t.EmbedImages_View.LexiconTypeID = "app.bsky.embed.images#view"
 		return json.Marshal(t.EmbedImages_View)
 	}
+	if t.EmbedVideo_View != nil {
+		t.EmbedVideo_View.LexiconTypeID = "app.bsky.embed.video#view"
+		return json.Marshal(t.EmbedVideo_View)
+	}
 	if t.EmbedExternal_View != nil {
 		t.EmbedExternal_View.LexiconTypeID = "app.bsky.embed.external#view"
 		return json.Marshal(t.EmbedExternal_View)
···
 	case "app.bsky.embed.images#view":
 		t.EmbedImages_View = new(EmbedImages_View)
 		return json.Unmarshal(b, t.EmbedImages_View)
+	case "app.bsky.embed.video#view":
+		t.EmbedVideo_View = new(EmbedVideo_View)
+		return json.Unmarshal(b, t.EmbedVideo_View)
 	case "app.bsky.embed.external#view":
 		t.EmbedExternal_View = new(EmbedExternal_View)
 		return json.Unmarshal(b, t.EmbedExternal_View)

api/bsky/embedvideo.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package bsky
+
+// schema: app.bsky.embed.video
+
+import (
+	"github.com/bluesky-social/indigo/lex/util"
+)
+
+func init() {
+	util.RegisterType("app.bsky.embed.video#main", &EmbedVideo{})
+} // EmbedVideo is a "main" in the app.bsky.embed.video schema.
+// RECORDTYPE: EmbedVideo
+type EmbedVideo struct {
+	LexiconTypeID string `json:"$type,const=app.bsky.embed.video" cborgen:"$type,const=app.bsky.embed.video"`
+	// alt: Alt text description of the video, for accessibility.
+	Alt         *string                `json:"alt,omitempty" cborgen:"alt,omitempty"`
+	AspectRatio *EmbedDefs_AspectRatio `json:"aspectRatio,omitempty" cborgen:"aspectRatio,omitempty"`
+	Captions    []*EmbedVideo_Caption  `json:"captions,omitempty" cborgen:"captions,omitempty"`
+	Video       *util.LexBlob          `json:"video" cborgen:"video"`
+}
+
+// EmbedVideo_Caption is a "caption" in the app.bsky.embed.video schema.
+type EmbedVideo_Caption struct {
+	File *util.LexBlob `json:"file" cborgen:"file"`
+	Lang string        `json:"lang" cborgen:"lang"`
+}
+
+// EmbedVideo_View is a "view" in the app.bsky.embed.video schema.
+//
+// RECORDTYPE: EmbedVideo_View
+type EmbedVideo_View struct {
+	LexiconTypeID string                 `json:"$type,const=app.bsky.embed.video#view" cborgen:"$type,const=app.bsky.embed.video#view"`
+	Alt           *string                `json:"alt,omitempty" cborgen:"alt,omitempty"`
+	AspectRatio   *EmbedDefs_AspectRatio `json:"aspectRatio,omitempty" cborgen:"aspectRatio,omitempty"`
+	Cid           string                 `json:"cid" cborgen:"cid"`
+	Playlist      string                 `json:"playlist" cborgen:"playlist"`
+	Thumbnail     *string                `json:"thumbnail,omitempty" cborgen:"thumbnail,omitempty"`
+}

api/bsky/feeddefs.go

···
 // FeedDefs_Interaction is a "interaction" in the app.bsky.feed.defs schema.
 type FeedDefs_Interaction struct {
 	Event *string `json:"event,omitempty" cborgen:"event,omitempty"`
-	// feedContext: Context on a feed item that was orginally supplied by the feed generator on getFeedSkeleton.
+	// feedContext: Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton.
 	FeedContext *string `json:"feedContext,omitempty" cborgen:"feedContext,omitempty"`
 	Item        *string `json:"item,omitempty" cborgen:"item,omitempty"`
 }
···
 
 type FeedDefs_PostView_Embed struct {
 	EmbedImages_View          *EmbedImages_View
+	EmbedVideo_View           *EmbedVideo_View
 	EmbedExternal_View        *EmbedExternal_View
 	EmbedRecord_View          *EmbedRecord_View
 	EmbedRecordWithMedia_View *EmbedRecordWithMedia_View
···
 		t.EmbedImages_View.LexiconTypeID = "app.bsky.embed.images#view"
 		return json.Marshal(t.EmbedImages_View)
 	}
+	if t.EmbedVideo_View != nil {
+		t.EmbedVideo_View.LexiconTypeID = "app.bsky.embed.video#view"
+		return json.Marshal(t.EmbedVideo_View)
+	}
 	if t.EmbedExternal_View != nil {
 		t.EmbedExternal_View.LexiconTypeID = "app.bsky.embed.external#view"
 		return json.Marshal(t.EmbedExternal_View)
···
 	case "app.bsky.embed.images#view":
 		t.EmbedImages_View = new(EmbedImages_View)
 		return json.Unmarshal(b, t.EmbedImages_View)
+	case "app.bsky.embed.video#view":
+		t.EmbedVideo_View = new(EmbedVideo_View)
+		return json.Unmarshal(b, t.EmbedVideo_View)
 	case "app.bsky.embed.external#view":
 		t.EmbedExternal_View = new(EmbedExternal_View)
 		return json.Unmarshal(b, t.EmbedExternal_View)

api/bsky/feedpost.go

···
 
 type FeedPost_Embed struct {
 	EmbedImages          *EmbedImages
+	EmbedVideo           *EmbedVideo
 	EmbedExternal        *EmbedExternal
 	EmbedRecord          *EmbedRecord
 	EmbedRecordWithMedia *EmbedRecordWithMedia
···
 	if t.EmbedImages != nil {
 		t.EmbedImages.LexiconTypeID = "app.bsky.embed.images"
 		return json.Marshal(t.EmbedImages)
+	}
+	if t.EmbedVideo != nil {
+		t.EmbedVideo.LexiconTypeID = "app.bsky.embed.video"
+		return json.Marshal(t.EmbedVideo)
 	}
 	if t.EmbedExternal != nil {
 		t.EmbedExternal.LexiconTypeID = "app.bsky.embed.external"
···
 	case "app.bsky.embed.images":
 		t.EmbedImages = new(EmbedImages)
 		return json.Unmarshal(b, t.EmbedImages)
+	case "app.bsky.embed.video":
+		t.EmbedVideo = new(EmbedVideo)
+		return json.Unmarshal(b, t.EmbedVideo)
 	case "app.bsky.embed.external":
 		t.EmbedExternal = new(EmbedExternal)
 		return json.Unmarshal(b, t.EmbedExternal)
···
 	}
 	if t.EmbedImages != nil {
 		return t.EmbedImages.MarshalCBOR(w)
+	}
+	if t.EmbedVideo != nil {
+		return t.EmbedVideo.MarshalCBOR(w)
 	}
 	if t.EmbedExternal != nil {
 		return t.EmbedExternal.MarshalCBOR(w)
···
 	case "app.bsky.embed.images":
 		t.EmbedImages = new(EmbedImages)
 		return t.EmbedImages.UnmarshalCBOR(bytes.NewReader(b))
+	case "app.bsky.embed.video":
+		t.EmbedVideo = new(EmbedVideo)
+		return t.EmbedVideo.UnmarshalCBOR(bytes.NewReader(b))
 	case "app.bsky.embed.external":
 		t.EmbedExternal = new(EmbedExternal)
 		return t.EmbedExternal.UnmarshalCBOR(bytes.NewReader(b))

api/bsky/videodefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package bsky
+
+// schema: app.bsky.video.defs
+
+import (
+	"github.com/bluesky-social/indigo/lex/util"
+)
+
+// VideoDefs_JobStatus is a "jobStatus" in the app.bsky.video.defs schema.
+type VideoDefs_JobStatus struct {
+	Blob    *util.LexBlob `json:"blob,omitempty" cborgen:"blob,omitempty"`
+	Did     string        `json:"did" cborgen:"did"`
+	Error   *string       `json:"error,omitempty" cborgen:"error,omitempty"`
+	JobId   string        `json:"jobId" cborgen:"jobId"`
+	Message *string       `json:"message,omitempty" cborgen:"message,omitempty"`
+	// progress: Progress within the current processing state.
+	Progress *int64 `json:"progress,omitempty" cborgen:"progress,omitempty"`
+	// state: The state of the video processing job. All values not listed as a known value indicate that the job is in process.
+	State string `json:"state" cborgen:"state"`
+}

api/bsky/videogetJobStatus.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package bsky
+
+// schema: app.bsky.video.getJobStatus
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// VideoGetJobStatus_Output is the output of a app.bsky.video.getJobStatus call.
+type VideoGetJobStatus_Output struct {
+	JobStatus *VideoDefs_JobStatus `json:"jobStatus" cborgen:"jobStatus"`
+}
+
+// VideoGetJobStatus calls the XRPC method "app.bsky.video.getJobStatus".
+func VideoGetJobStatus(ctx context.Context, c *xrpc.Client, jobId string) (*VideoGetJobStatus_Output, error) {
+	var out VideoGetJobStatus_Output
+
+	params := map[string]interface{}{
+		"jobId": jobId,
+	}
+	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.video.getJobStatus", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/bsky/videogetUploadLimits.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package bsky
+
+// schema: app.bsky.video.getUploadLimits
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// VideoGetUploadLimits_Output is the output of a app.bsky.video.getUploadLimits call.
+type VideoGetUploadLimits_Output struct {
+	CanUpload            bool    `json:"canUpload" cborgen:"canUpload"`
+	Error                *string `json:"error,omitempty" cborgen:"error,omitempty"`
+	Message              *string `json:"message,omitempty" cborgen:"message,omitempty"`
+	RemainingDailyBytes  *int64  `json:"remainingDailyBytes,omitempty" cborgen:"remainingDailyBytes,omitempty"`
+	RemainingDailyVideos *int64  `json:"remainingDailyVideos,omitempty" cborgen:"remainingDailyVideos,omitempty"`
+}
+
+// VideoGetUploadLimits calls the XRPC method "app.bsky.video.getUploadLimits".
+func VideoGetUploadLimits(ctx context.Context, c *xrpc.Client) (*VideoGetUploadLimits_Output, error) {
+	var out VideoGetUploadLimits_Output
+	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.video.getUploadLimits", nil, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/bsky/videouploadVideo.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package bsky
+
+// schema: app.bsky.video.uploadVideo
+
+import (
+	"context"
+	"io"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// VideoUploadVideo_Output is the output of a app.bsky.video.uploadVideo call.
+type VideoUploadVideo_Output struct {
+	JobStatus *VideoDefs_JobStatus `json:"jobStatus" cborgen:"jobStatus"`
+}
+
+// VideoUploadVideo calls the XRPC method "app.bsky.video.uploadVideo".
+func VideoUploadVideo(ctx context.Context, c *xrpc.Client, input io.Reader) (*VideoUploadVideo_Output, error) {
+	var out VideoUploadVideo_Output
+	if err := c.Do(ctx, xrpc.Procedure, "video/mp4", "app.bsky.video.uploadVideo", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

gen/main.go

···
 		bsky.GraphListitem{},
 		bsky.FeedGenerator{},
 		bsky.GraphListblock{},
-		bsky.EmbedImages_AspectRatio{},
+		bsky.EmbedDefs_AspectRatio{},
 		bsky.FeedThreadgate{},
 		bsky.FeedThreadgate_ListRule{},
 		bsky.FeedThreadgate_MentionRule{},
···
 		bsky.GraphStarterpack{},
 		bsky.LabelerService{},
 		bsky.LabelerDefs_LabelerPolicies{},
+		bsky.EmbedVideo{}, bsky.EmbedVideo_Caption{},
 		/*bsky.EmbedImages_View{},
 		bsky.EmbedRecord_View{}, bsky.EmbedRecordWithMedia_View{},
 		bsky.EmbedExternal_View{}, bsky.EmbedImages_ViewImage{},

lex/gen.go

···
 	EncodingJSON  = "application/json"
 	EncodingJSONL = "application/jsonl"
 	EncodingCAR   = "application/vnd.ipld.car"
+	EncodingMP4   = "video/mp4"
 	EncodingANY   = "*/*"
 )
 
···
 
 		if ts.Input != nil {
 			if ts.Input.Schema == nil {
-				if ts.Input.Encoding != "application/cbor" && ts.Input.Encoding != "*/*" && ts.Input.Encoding != "application/vnd.ipld.car" {
+				if ts.Input.Encoding != EncodingCBOR &&
+					ts.Input.Encoding != EncodingANY &&
+					ts.Input.Encoding != EncodingCAR &&
+					ts.Input.Encoding != EncodingMP4 {
 					panic(fmt.Sprintf("strange input type def in %s", s.ID))
 				}
 			} else {
···
 
 		if ts.Output != nil {
 			if ts.Output.Schema == nil {
-				if ts.Output.Encoding != "application/cbor" && ts.Output.Encoding != "application/vnd.ipld.car" && ts.Output.Encoding != "*/*" && ts.Output.Encoding != "application/jsonl" {
+				if ts.Output.Encoding != EncodingCBOR &&
+					ts.Output.Encoding != EncodingCAR &&
+					ts.Output.Encoding != EncodingANY &&
+					ts.Output.Encoding != EncodingJSONL &&
+					ts.Output.Encoding != EncodingMP4 {
 					panic(fmt.Sprintf("strange output type def in %s", s.ID))
 				}
 			} else {
···
 		inpvar = "input"
 		inpenc = s.Input.Encoding
 		switch s.Input.Encoding {
-		case EncodingCBOR, EncodingCAR, EncodingANY:
+		case EncodingCBOR, EncodingCAR, EncodingANY, EncodingMP4:
 			params = fmt.Sprintf("%s, input io.Reader", params)
 		case EncodingJSON:
 			params = fmt.Sprintf("%s, input *%s_Input", params, fname)
···
 	out := "error"
 	if s.Output != nil {
 		switch s.Output.Encoding {
-		case EncodingCBOR, EncodingCAR, EncodingANY, EncodingJSONL:
+		case EncodingCBOR, EncodingCAR, EncodingANY, EncodingJSONL, EncodingMP4:
 			out = "([]byte, error)"
 		case EncodingJSON:
 			outname := fname + "_Output"
···
 	outRet := "nil"
 	if s.Output != nil {
 		switch s.Output.Encoding {
-		case EncodingCBOR, EncodingCAR, EncodingANY, EncodingJSONL:
+		case EncodingCBOR, EncodingCAR, EncodingANY, EncodingJSONL, EncodingMP4:
 			pf("buf := new(bytes.Buffer)\n")
 			outvar = "buf"
 			errRet = "nil, err"
···
 				pf("contentType := c.Request().Header.Get(\"Content-Type\")\n")
 				paramtypes = append(paramtypes, "r io.Reader", "contentType string")
 				params = append(params, "body", "contentType")
-
+			case EncodingMP4:
+				pf("body := c.Request().Body\n")
+				paramtypes = append(paramtypes, "r io.Reader")
+				params = append(params, "body")
 			default:
 				return fmt.Errorf("unrecognized input encoding: %q", s.Input.Encoding)
 			}
···
 			}
 			pf("var out *%s.%s\n", impname, outname)
 			returndef = fmt.Sprintf("(*%s.%s, error)", impname, outname)
-		case EncodingCBOR, EncodingCAR, EncodingANY, EncodingJSONL:
+		case EncodingCBOR, EncodingCAR, EncodingANY, EncodingJSONL, EncodingMP4:
 			assign = "out, handleErr"
 			pf("var out io.Reader\n")
 			returndef = "(io.Reader, error)"
···
 			pf("return c.Stream(200, \"application/vnd.ipld.car\", out)\n}\n\n")
 		case EncodingJSONL:
 			pf("return c.Stream(200, \"application/jsonl\", out)\n}\n\n")
+		case EncodingMP4:
+			pf("return c.Stream(200, \"video/mp4\", out)\n}\n\n")
 		default:
 			return fmt.Errorf("unrecognized output encoding (RPC output handler return): %q", s.Output.Encoding)
 		}