sync for backup

commonTypes.go

@@ -32,7 +32,7 @@ func ParseIdTypeWithName(m map[string]any, b BaseApChain, name string) (*FullIdT
 	}
 	data1, ok := rawData1.([]map[string]any)
 	if !ok {
-		return nil, BadFieldValueError{name, rawData1, []map[string]any{{}}}
+		return nil, BadFieldValueError[[]map[string]any]{name, rawData1, []map[string]any{{}}}
 	}
 	if len(data1) != 1 {
 		return nil, BadFieldArrayLengthError{name, 1, len(data1)}
@@ -43,7 +43,7 @@ func ParseIdTypeWithName(m map[string]any, b BaseApChain, name string) (*FullIdT
 	}
 	data2, ok := rawData1.(string)
 	if !ok {
-		return nil, BadFieldValueError{name, rawData2, ""}
+		return nil, BadFieldValueError[string]{name, rawData2, ""}
 	}
 	return &FullIdType{
 		Next: b,

errors.go

@@ -10,15 +10,16 @@ func (n NoRequiredFieldError) Error() string {
 	return fmt.Sprintf("no attribute named %s", n.FieldName)
 }
 
-type BadFieldValueError struct {
+// Expected is a string representation of the expected type
+type BadFieldValueError[T any] struct {
 	FieldName string
 	RawValue  any
-	Expected  any
+	Expected  T
 }
 
-func (b BadFieldValueError) Error() string {
+func (b BadFieldValueError[T]) Error() string {
 	return fmt.Sprintf(
-		"attribute %s has a bad raw value, inspect error struct for raw and expected value",
+		"attribute %s has a bad raw value, inspect error struct for raw and expected type",
 		b.FieldName,
 	)
 }
@@ -46,3 +47,17 @@ type NoRequiredSubFieldError struct {
 func (n NoRequiredSubFieldError) Error() string {
 	return fmt.Sprintf("missing subfield %s for attribute %s", n.Subfield, n.FieldName)
 }
+
+type NotImplementedError struct{}
+
+func (n NotImplementedError) Error() string {
+	return "Feature not implemented yet"
+}
+
+type UnknownTagType struct {
+	TagType string
+}
+
+func (u UnknownTagType) Error() string {
+	return fmt.Sprintf("Unknown tag type: %s", u.TagType)
+}

examples/mk_note_random.json

@@ -0,0 +1,79 @@
+[
+  {
+    "@id": "https://plasmatrap.com/notes/9wona1fblx",
+    "@type": [
+      "https://www.w3.org/ns/activitystreams#Note"
+    ],
+    "https://misskey-hub.net/ns#_misskey_content": [
+      {
+        "@value": "After having kept @lunduke@linuxrocks.online suspended locally for a few days, I have now seen the admin of linuxrocks.online be a fan of [\"unpopular opinions\" (transphobia and other bullshit)](https://linuxrocks.online/@yisraeldov/112885717416855799) and [ignoring all reports](https://linuxrocks.online/@yisraeldov/112865583454794746), warning the people that reported lunduke for being an ass. As a result, federation with linuxrocks.online will be suspended tomorrow, $[unixtime 1723197600]."
+      }
+    ],
+    "https://www.w3.org/ns/activitystreams#attachment": [],
+    "https://www.w3.org/ns/activitystreams#attributedTo": [
+      {
+        "@id": "https://plasmatrap.com/users/9fxq5dv2icicia1w"
+      }
+    ],
+    "https://www.w3.org/ns/activitystreams#cc": [
+      {
+        "@id": "https://plasmatrap.com/users/9fxq5dv2icicia1w/followers"
+      },
+      {
+        "@id": "https://linuxrocks.online/users/lunduke"
+      }
+    ],
+    "https://www.w3.org/ns/activitystreams#content": [
+      {
+        "@value": "\u003cp\u003eAfter having kept \u003ca href=\"https://linuxrocks.online/@lunduke\" class=\"u-url mention\"\u003e@lunduke@linuxrocks.online\u003c/a\u003e suspended locally for a few days, I have now seen the admin of linuxrocks.online be a fan of \u003ca href=\"https://linuxrocks.online/@yisraeldov/112885717416855799\"\u003e\"unpopular opinions\" (transphobia and other bullshit)\u003c/a\u003e and \u003ca href=\"https://linuxrocks.online/@yisraeldov/112865583454794746\"\u003eignoring all reports\u003c/a\u003e\u003cspan\u003e, warning the people that reported lunduke for being an ass.\u003cbr\u003e\u003cbr\u003eAs a result, federation with linuxrocks.online will be suspended tomorrow, \u003c/span\u003e\u003ctime datetime=\"2024-08-09T10:00:00.000Z\"\u003e2024-08-09T10:00:00.000Z\u003c/time\u003e.\u003c/p\u003e"
+      }
+    ],
+    "https://www.w3.org/ns/activitystreams#published": [
+      {
+        "@type": "http://www.w3.org/2001/XMLSchema#dateTime",
+        "@value": "2024-08-08T09:33:19.415Z"
+      }
+    ],
+    "https://www.w3.org/ns/activitystreams#sensitive": [
+      {
+        "@value": false
+      }
+    ],
+    "https://www.w3.org/ns/activitystreams#source": [
+      {
+        "https://www.w3.org/ns/activitystreams#content": [
+          {
+            "@value": "After having kept @lunduke@linuxrocks.online suspended locally for a few days, I have now seen the admin of linuxrocks.online be a fan of [\"unpopular opinions\" (transphobia and other bullshit)](https://linuxrocks.online/@yisraeldov/112885717416855799) and [ignoring all reports](https://linuxrocks.online/@yisraeldov/112865583454794746), warning the people that reported lunduke for being an ass. As a result, federation with linuxrocks.online will be suspended tomorrow, $[unixtime 1723197600]."
+          }
+        ],
+        "https://www.w3.org/ns/activitystreams#mediaType": [
+          {
+            "@value": "text/x.misskeymarkdown"
+          }
+        ]
+      }
+    ],
+    "https://www.w3.org/ns/activitystreams#tag": [
+      {
+        "@type": [
+          "https://www.w3.org/ns/activitystreams#Mention"
+        ],
+        "https://www.w3.org/ns/activitystreams#href": [
+          {
+            "@id": "https://linuxrocks.online/users/lunduke"
+          }
+        ],
+        "https://www.w3.org/ns/activitystreams#name": [
+          {
+            "@value": "@lunduke@linuxrocks.online"
+          }
+        ]
+      }
+    ],
+    "https://www.w3.org/ns/activitystreams#to": [
+      {
+        "@id": "https://www.w3.org/ns/activitystreams#Public"
+      }
+    ]
+  }
+]

examples/raw/mk_note_random.json

@@ -0,0 +1,60 @@
+{
+	"@context": [
+		"https://www.w3.org/ns/activitystreams",
+		"https://w3id.org/security/v1",
+		{
+			"Key": "sec:Key",
+			"manuallyApprovesFollowers": "as:manuallyApprovesFollowers",
+			"sensitive": "as:sensitive",
+			"Hashtag": "as:Hashtag",
+			"quoteUrl": "as:quoteUrl",
+			"fedibird": "http://fedibird.com/ns#",
+			"quoteUri": "fedibird:quoteUri",
+			"toot": "http://joinmastodon.org/ns#",
+			"Emoji": "toot:Emoji",
+			"featured": "toot:featured",
+			"discoverable": "toot:discoverable",
+			"schema": "http://schema.org#",
+			"PropertyValue": "schema:PropertyValue",
+			"value": "schema:value",
+			"misskey": "https://misskey-hub.net/ns#",
+			"_misskey_content": "misskey:_misskey_content",
+			"_misskey_quote": "misskey:_misskey_quote",
+			"_misskey_reaction": "misskey:_misskey_reaction",
+			"_misskey_votes": "misskey:_misskey_votes",
+			"_misskey_summary": "misskey:_misskey_summary",
+			"isCat": "misskey:isCat",
+			"firefish": "https://joinfirefish.org/ns#",
+			"speakAsCat": "firefish:speakAsCat",
+			"sharkey": "https://joinsharkey.org/ns#",
+			"backgroundUrl": "sharkey:backgroundUrl",
+			"listenbrainz": "sharkey:listenbrainz",
+			"vcard": "http://www.w3.org/2006/vcard/ns#"
+		}
+	],
+	"id": "https://plasmatrap.com/notes/9wona1fblx",
+	"type": "Note",
+	"attributedTo": "https://plasmatrap.com/users/9fxq5dv2icicia1w",
+	"content": "<p>After having kept <a href=\"https://linuxrocks.online/@lunduke\" class=\"u-url mention\">@lunduke@linuxrocks.online</a> suspended locally for a few days, I have now seen the admin of linuxrocks.online be a fan of <a href=\"https://linuxrocks.online/@yisraeldov/112885717416855799\">\"unpopular opinions\" (transphobia and other bullshit)</a> and <a href=\"https://linuxrocks.online/@yisraeldov/112865583454794746\">ignoring all reports</a><span>, warning the people that reported lunduke for being an ass.<br><br>As a result, federation with linuxrocks.online will be suspended tomorrow, </span><time datetime=\"2024-08-09T10:00:00.000Z\">2024-08-09T10:00:00.000Z</time>.</p>",
+	"_misskey_content": "After having kept @lunduke@linuxrocks.online suspended locally for a few days, I have now seen the admin of linuxrocks.online be a fan of [\"unpopular opinions\" (transphobia and other bullshit)](https://linuxrocks.online/@yisraeldov/112885717416855799) and [ignoring all reports](https://linuxrocks.online/@yisraeldov/112865583454794746), warning the people that reported lunduke for being an ass. As a result, federation with linuxrocks.online will be suspended tomorrow, $[unixtime 1723197600].",
+	"source": {
+		"content": "After having kept @lunduke@linuxrocks.online suspended locally for a few days, I have now seen the admin of linuxrocks.online be a fan of [\"unpopular opinions\" (transphobia and other bullshit)](https://linuxrocks.online/@yisraeldov/112885717416855799) and [ignoring all reports](https://linuxrocks.online/@yisraeldov/112865583454794746), warning the people that reported lunduke for being an ass. As a result, federation with linuxrocks.online will be suspended tomorrow, $[unixtime 1723197600].",
+		"mediaType": "text/x.misskeymarkdown"
+	},
+	"published": "2024-08-08T09:33:19.415Z",
+	"to": ["https://www.w3.org/ns/activitystreams#Public"],
+	"cc": [
+		"https://plasmatrap.com/users/9fxq5dv2icicia1w/followers",
+		"https://linuxrocks.online/users/lunduke"
+	],
+	"inReplyTo": null,
+	"attachment": [],
+	"sensitive": false,
+	"tag": [
+		{
+			"type": "Mention",
+			"href": "https://linuxrocks.online/users/lunduke",
+			"name": "@lunduke@linuxrocks.online"
+		}
+	]
+}

go.mod

@@ -4,6 +4,11 @@ go 1.22.5
 
 require github.com/piprate/json-gold v0.5.0
 
+require (
+	github.com/datainq/xml-date-time v0.0.0-20170820214645-2292f08baa38 // indirect
+	github.com/samber/go-type-to-string v1.7.0 // indirect
+)
+
 require (
 	github.com/pquerna/cachecontrol v0.0.0-20180517163645-1555304b9b35 // indirect
 	github.com/stretchr/testify v1.9.0 // indirect

go.sum

@@ -1,3 +1,5 @@
+github.com/datainq/xml-date-time v0.0.0-20170820214645-2292f08baa38 h1:cUoduvNB9/JFJYEVeKy2hX/R5qyg2uwnHVhXCIjhBeI=
+github.com/datainq/xml-date-time v0.0.0-20170820214645-2292f08baa38/go.mod h1:a0PnbhSGmzFMGx9KdEqfEdDHoEwTF9KLNbKLcWD8kAo=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/piprate/json-gold v0.5.0 h1:RmGh1PYboCFcchVFuh2pbSWAZy4XJaqTMU4KQYsApbM=
@@ -6,6 +8,8 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pquerna/cachecontrol v0.0.0-20180517163645-1555304b9b35 h1:J9b7z+QKAmPf4YLrFg6oQUotqHQeUNWwkvo7jZp1GLU=
 github.com/pquerna/cachecontrol v0.0.0-20180517163645-1555304b9b35/go.mod h1:prYjPmNq4d1NPVmpShWobRqXY3q7Vp+80DqgxxUrUIA=
+github.com/samber/go-type-to-string v1.7.0 h1:FiSstaAikHMUSLt5bhVlsvCnD7bbQzC8L0UkkGS3Bj8=
+github.com/samber/go-type-to-string v1.7.0/go.mod h1:jpU77vIDoIxkahknKDoEx9C8bQ1ADnh2sotZ8I4QqBU=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 gitlab.com/mstarongitlab/goutils v1.3.0 h1:uuxPHjIU36lyJ8/z4T2xI32zOyh53Xj0Au8K12qkaJ4=

nsActivitystreams.go

@@ -3,6 +3,7 @@ package goap
 import (
 	"time"
 
+	"github.com/datainq/xml-date-time"
 	"gitlab.com/mstarongitlab/goutils/sliceutils"
 )
 
@@ -18,6 +19,14 @@ func (actor *ASActorData) MarshalToMap() map[string]any {
 	return actor.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_ACTOR)
 }
 
+func ParseASActorData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_ACTOR)
+	if err != nil {
+		return nil, err
+	}
+	return &ASActorData{FullIdType: *id}, nil
+}
+
 type ASAlsoKnownAsData struct {
 	Next BaseApChain
 	Urls []string
@@ -37,6 +46,37 @@ func (cc *ASAlsoKnownAsData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASAlsoKnownAsData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_ALSOKNOWNAS]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_ALSOKNOWNAS}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_ALSOKNOWNAS,
+			rawData1,
+			[]map[string]any{},
+		}
+	}
+	urls := []string{}
+	for _, v := range data1 {
+		rawData2, ok := v[KEY_ID]
+		if !ok {
+			return nil, NoRequiredSubFieldError{KEY_ACTIVITYSTREAMS_ALSOKNOWNAS, KEY_ID}
+		}
+		data2, ok := rawData2.(string)
+		if !ok {
+			return nil, BadFieldValueError[string]{KEY_ACTIVITYSTREAMS_ALSOKNOWNAS, rawData2, ""}
+		}
+		urls = append(urls, data2)
+	}
+	return &ASAlsoKnownAsData{
+		Next: next,
+		Urls: urls,
+	}, nil
+}
+
 type ASAttachmentsData struct {
 	Next        BaseApChain
 	Attachments []Attachment
@@ -57,6 +97,34 @@ func (attachmentsdata *ASAttachmentsData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASAttachmentsData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData, ok := raw[KEY_ACTIVITYSTREAMS_ATTACHMENTS]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_ATTACHMENTS}
+	}
+	data, ok := rawData.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_ATTACHMENTS,
+			rawData,
+			[]map[string]any{},
+		}
+	}
+
+	attachments := []Attachment{}
+	for _, k := range data {
+		a, err := ParseAttachment(k)
+		if err != nil {
+			return nil, err
+		}
+		attachments = append(attachments, *a)
+	}
+	return &ASAttachmentsData{
+		Next:        next,
+		Attachments: attachments,
+	}, nil
+}
+
 type ASAttributedToData struct {
 	FullIdType
 }
@@ -69,6 +137,14 @@ func (attributedtodata *ASAttributedToData) MarshalToMap() map[string]any {
 	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_ATTRIBUTEDTO)
 }
 
+func ParseASAttributedToData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_ATTRIBUTEDTO)
+	if err != nil {
+		return nil, err
+	}
+	return &ASAttributedToData{FullIdType: *id}, nil
+}
+
 type ASCCData struct {
 	Next    BaseApChain
 	Targets []string
@@ -88,6 +164,38 @@ func (cc *ASCCData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASCCData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_CC]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_CC}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_CC,
+			rawData1,
+			[]map[string]any{},
+		}
+	}
+	ccs := []string{}
+	for _, v := range data1 {
+		rawVal, ok := v[KEY_ID]
+		if !ok {
+			return nil, NoRequiredSubFieldError{KEY_ACTIVITYSTREAMS_CC, KEY_ID}
+		}
+		val, ok := rawVal.(string)
+		if !ok {
+			return nil, BadFieldValueError[string]{KEY_ID, rawVal, ""}
+		}
+		ccs = append(ccs, val)
+	}
+	return &ASCCData{
+		Next:    next,
+		Targets: ccs,
+	}, nil
+}
+
+// Content is an array of string value types due to some servers including the content in multiple languages or with different metadata attached
 type ASContentData struct {
 	Next    BaseApChain
 	Content []ValueValue[string]
@@ -107,6 +215,33 @@ func (contentdata *ASContentData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASContentData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_CONTENT]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_CONTENT}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_CONTENT,
+			rawData1,
+			data1,
+		}
+	}
+	contents := []ValueValue[string]{}
+	for _, v := range data1 {
+		parsed, err := ParseValueValue[string](v)
+		if err != nil {
+			return nil, err
+		}
+		contents = append(contents, *parsed)
+	}
+	return &ASContentData{
+		Next:    next,
+		Content: contents,
+	}, nil
+}
+
 type ASEndpointsData struct {
 	Next      BaseApChain
 	Endpoints map[string]string
@@ -128,6 +263,48 @@ func (endpointsdata *ASEndpointsData) MarshalToMap() map[string]any {
 	return m
 }
 
+func ParseASEndpointsData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_ENDPOINTS]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_ENDPOINTS}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_ENDPOINTS,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_ENDPOINTS, 1, len(data1)}
+	}
+	data2 := data1[0]
+	endpoints := map[string]string{}
+	for k, rawV := range data2 {
+		v, ok := rawV.([]map[string]any)
+		if !ok {
+			return nil, BadFieldValueError[[]map[string]any]{k, rawV, v}
+		}
+		if len(v) != 1 {
+			return nil, BadFieldArrayLengthError{k, 1, len(v)}
+		}
+		rawV2, ok := v[0][KEY_ID]
+		if !ok {
+			return nil, NoRequiredSubFieldError{KEY_ACTIVITYSTREAMS_ENDPOINTS, KEY_ID}
+		}
+		v2, ok := rawV2.(string)
+		if !ok {
+			return nil, BadFieldValueError[string]{k, rawV2, ""}
+		}
+		endpoints[k] = v2
+	}
+	return &ASEndpointsData{
+		Next:      next,
+		Endpoints: endpoints,
+	}, nil
+}
+
 type ASFollowersData struct {
 	FullIdType
 }
@@ -140,6 +317,14 @@ func (attributedtodata *ASFollowersData) MarshalToMap() map[string]any {
 	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_FOLLOWERS)
 }
 
+func ParseASFollowersData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_FOLLOWERS)
+	if err != nil {
+		return nil, err
+	}
+	return &ASAttributedToData{FullIdType: *id}, nil
+}
+
 type ASFollowingData struct {
 	FullIdType
 }
@@ -152,6 +337,14 @@ func (attributedtodata *ASFollowingData) MarshalToMap() map[string]any {
 	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_FOLLOWING)
 }
 
+func ParseASFollowingData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_FOLLOWING)
+	if err != nil {
+		return nil, err
+	}
+	return &ASAttributedToData{FullIdType: *id}, nil
+}
+
 type ASHrefData struct {
 	FullIdType
 }
@@ -164,6 +357,14 @@ func (attributedtodata *ASHrefData) MarshalToMap() map[string]any {
 	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_HREF)
 }
 
+func ParseASHrefData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_HREF)
+	if err != nil {
+		return nil, err
+	}
+	return &ASAttributedToData{FullIdType: *id}, nil
+}
+
 type ASIconData struct {
 	Next  BaseApChain
 	Media Media
@@ -181,6 +382,28 @@ func (icondata *ASIconData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASIconData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	dataRaw, ok := raw[KEY_ACTIVITYSTREAMS_ICON]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_ICON}
+	}
+	data, ok := dataRaw.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_ICON, dataRaw, data}
+	}
+	if len(data) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_ICON, 1, len(data)}
+	}
+	m, err := ParseMedia(data[0])
+	if err != nil {
+		return nil, err
+	}
+	return &ASIconData{
+		Media: *m,
+		Next:  next,
+	}, nil
+}
+
 type ASImageData struct {
 	Next  BaseApChain
 	Media Media
@@ -198,6 +421,32 @@ func (icondata *ASImageData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASImageData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	dataRaw, ok := raw[KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE}
+	}
+	data, ok := dataRaw.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE,
+			dataRaw,
+			data,
+		}
+	}
+	if len(data) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE, 1, len(data)}
+	}
+	m, err := ParseMedia(data[0])
+	if err != nil {
+		return nil, err
+	}
+	return &ASImageData{
+		Media: *m,
+		Next:  next,
+	}, nil
+}
+
 type ASMediaTypeData struct {
 	Next BaseApChain
 	Type string
@@ -219,6 +468,32 @@ func (mediatypedata *ASMediaTypeData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASMediaTypeData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_MEDIATYPE]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_MEDIATYPE}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_MEDIATYPE,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_MEDIATYPE, 1, len(data1)}
+	}
+	tmp, err := ParseValueValue[string](data1[0])
+	if err != nil {
+		return nil, err
+	}
+	return &ASMediaTypeData{
+		Next: next,
+		Type: tmp.Value,
+	}, nil
+}
+
 type ASNameData struct {
 	Next BaseApChain
 	Name ValueValue[string]
@@ -236,6 +511,32 @@ func (namedata *ASNameData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASNameData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_NAME]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_NAME}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_NAME,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_NAME, 1, len(data1)}
+	}
+	tmp, err := ParseValueValue[string](data1[0])
+	if err != nil {
+		return nil, err
+	}
+	return &ASNameData{
+		Next: next,
+		Name: *tmp,
+	}, nil
+}
+
 type ASOutboxData struct {
 	FullIdType
 }
@@ -248,6 +549,14 @@ func (attributedtodata *ASOutboxData) MarshalToMap() map[string]any {
 	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_HREF)
 }
 
+func ParseASOutboxData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_OUTBOX)
+	if err != nil {
+		return nil, err
+	}
+	return &ASOutboxData{FullIdType: *id}, nil
+}
+
 type ASObjectData struct {
 	FullIdType
 }
@@ -260,6 +569,14 @@ func (object *ASObjectData) MarshalToMap() map[string]any {
 	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_OBJECT)
 }
 
+func ParseASObjectData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_OBJECT)
+	if err != nil {
+		return nil, err
+	}
+	return &ASObjectData{FullIdType: *id}, nil
+}
+
 type ASPreferredNameData struct {
 	Next BaseApChain
 	Name ValueValue[string]
@@ -277,6 +594,32 @@ func (namedata *ASPreferredNameData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASPreferredNameData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME, 1, len(data1)}
+	}
+	tmp, err := ParseValueValue[string](data1[0])
+	if err != nil {
+		return nil, err
+	}
+	return &ASPreferredNameData{
+		Next: next,
+		Name: *tmp,
+	}, nil
+}
+
 type ASPublishedData struct {
 	Next      BaseApChain
 	Timestamp time.Time
@@ -292,6 +635,37 @@ func (publisheddata *ASPublishedData) MarshalToMap() map[string]any {
 	return m
 }
 
+func ParseASPublishedData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_PUBLISHED]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_PUBLISHED}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_PUBLISHED,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_PUBLISHED, 1, len(data1)}
+	}
+	tmp, err := ParseValueValue[string](data1[0])
+	if err != nil {
+		return nil, err
+	}
+
+	t, err := xmldatetime.Parse(tmp.Value)
+	if err != nil {
+		return nil, err
+	}
+	return &ASPublishedData{
+		Next:      next,
+		Timestamp: t,
+	}, nil
+}
+
 type ASRestrictedFollowData struct {
 	Next  BaseApChain
 	Value ValueValue[bool]
@@ -309,6 +683,32 @@ func (namedata *ASRestrictedFollowData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASRestrictedData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW, 1, len(data1)}
+	}
+	tmp, err := ParseValueValue[bool](data1[0])
+	if err != nil {
+		return nil, err
+	}
+	return &ASRestrictedFollowData{
+		Next:  next,
+		Value: *tmp,
+	}, nil
+}
+
 type ASRepliesData struct {
 	FullIdType
 }
@@ -321,6 +721,14 @@ func (object *ASRepliesData) MarshalToMap() map[string]any {
 	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_REPLIES)
 }
 
+func ParseASRepliesData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_REPLIES)
+	if err != nil {
+		return nil, err
+	}
+	return &ASRepliesData{FullIdType: *id}, nil
+}
+
 type ASSharedInboxData struct {
 	FullIdType
 }
@@ -333,6 +741,14 @@ func (object *ASSharedInboxData) MarshalToMap() map[string]any {
 	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_SHAREDINBOX)
 }
 
+func ParseASSharedInboxData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_SHAREDINBOX)
+	if err != nil {
+		return nil, err
+	}
+	return &ASSharedInboxData{FullIdType: *id}, nil
+}
+
 type ASSummaryData struct {
 	Next BaseApChain
 	Name ValueValue[string]
@@ -350,6 +766,32 @@ func (namedata *ASSummaryData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASSummaryData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_SUMMARY]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_SUMMARY}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_SUMMARY,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_SUMMARY, 1, len(data1)}
+	}
+	tmp, err := ParseValueValue[string](data1[0])
+	if err != nil {
+		return nil, err
+	}
+	return &ASSummaryData{
+		Next: next,
+		Name: *tmp,
+	}, nil
+}
+
 type ASSensitiveData struct {
 	Next BaseApChain
 	Name ValueValue[bool]
@@ -367,9 +809,35 @@ func (namedata *ASSensitiveData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASSensitiveData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_SENSITIVE]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_SENSITIVE}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_SENSITIVE,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_SENSITIVE, 1, len(data1)}
+	}
+	tmp, err := ParseValueValue[bool](data1[0])
+	if err != nil {
+		return nil, err
+	}
+	return &ASSensitiveData{
+		Next: next,
+		Name: *tmp,
+	}, nil
+}
+
 type ASTagData struct {
 	Next BaseApChain
-	Tags []string
+	Tags []Tag
 }
 
 func (tagdata *ASTagData) GetSelfOrBase() (BaseApChain, bool) {
@@ -380,12 +848,16 @@ func (tagdata *ASTagData) MarshalToMap() map[string]any {
 	return appendWithKey(
 		tagdata.Next.MarshalToMap(),
 		KEY_ACTIVITYSTREAMS_TAG,
-		sliceutils.Map(tagdata.Tags, func(t string) map[string]any {
+		sliceutils.Map(tagdata.Tags, func(t Tag) map[string]any {
-			return map[string]any{KEY_ID: t}
+			return t.Marshal()
 		}),
 	)
 }
 
+func ParseASTagData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	return nil, NotImplementedError{}
+}
+
 type ASToData struct {
 	Next    BaseApChain
 	Targets []string
@@ -405,6 +877,10 @@ func (cc *ASToData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseASToData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	return nil, NotImplementedError{}
+}
+
 type ASUrlData struct {
 	FullIdType
 }
@@ -417,6 +893,14 @@ func (object *ASUrlData) MarshalToMap() map[string]any {
 	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_SHAREDINBOX)
 }
 
+func ParseASUrlData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_URL)
+	if err != nil {
+		return nil, err
+	}
+	return &ASUrlData{FullIdType: *id}, nil
+}
+
 type ASUpdatedData struct {
 	Next      BaseApChain
 	Timestamp time.Time
@@ -431,3 +915,7 @@ func (publisheddata *ASUpdatedData) MarshalToMap() map[string]any {
 	m[KEY_ACTIVITYSTREAMS_PUBLISHED] = timeToXmlTime(publisheddata.Timestamp)
 	return m
 }
+
+func ParseASUpdatedData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	return nil, NotImplementedError{}
+}

tags.go

@@ -0,0 +1,130 @@
+package goap
+
+import "time"
+
+// go-sumtype:decl TagSum
+type Tag interface {
+	// TagEmoji | TagMention | TagHashtag
+
+	Marshal() map[string]any
+	sealed()
+}
+
+type TagEmoji struct {
+	Id          string
+	Icon        Media
+	Name        string
+	LastUpdated time.Time
+}
+
+func (t TagEmoji) sealed() {}
+func (t TagEmoji) Marshal() map[string]any {
+	m := map[string]any{
+		KEY_ID:                   t.Id,
+		KEY_TYPE:                 []string{KEY_MASTO_EMOJI},
+		KEY_ACTIVITYSTREAMS_ICON: []map[string]any{t.Icon.Marshal()},
+		KEY_ACTIVITYSTREAMS_NAME: []map[string]any{{KEY_VALUE: t.Name}},
+	}
+	return m
+}
+
+type TagMention struct {
+	TargetId   string
+	TargetName string
+}
+
+func (t TagMention) sealed() {}
+func (t TagMention) Marshal() map[string]any {
+	return map[string]any{
+		KEY_TYPE:                 []string{KEY_ACTIVITYSTREAMS_MENTION},
+		KEY_ACTIVITYSTREAMS_HREF: []map[string]any{{KEY_ID: t.TargetId}},
+		KEY_ACTIVITYSTREAMS_NAME: []map[string]any{{KEY_VALUE: t.TargetName}},
+	}
+}
+
+type TagHashtag struct {
+	Url  string
+	Name string
+}
+
+func (t TagHashtag) sealed() {}
+func (t TagHashtag) Marshal() map[string]any {
+	return map[string]any{
+		KEY_TYPE:                 []string{KEY_ACTIVITYSTREAMS_HASHTAG},
+		KEY_ACTIVITYSTREAMS_HREF: []map[string]any{{KEY_ID: t.Url}},
+		KEY_ACTIVITYSTREAMS_NAME: []map[string]any{{KEY_VALUE: t.Name}},
+	}
+}
+
+func ParseTag(raw map[string]any) (Tag, error) {
+	rawTypeArr, ok := raw[KEY_TYPE]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_TYPE}
+	}
+	typeArr, ok := rawTypeArr.([]string)
+	if !ok {
+		return nil, BadFieldValueError[[]string]{KEY_TYPE, rawTypeArr, typeArr}
+	}
+	if len(typeArr) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_TYPE, 1, len(typeArr)}
+	}
+	tagType := typeArr[0]
+	switch tagType {
+	case KEY_MASTO_EMOJI:
+		return parseEmojiTag(raw)
+	case KEY_ACTIVITYSTREAMS_MENTION:
+		return parseMentionTag(raw)
+	case KEY_ACTIVITYSTREAMS_HASHTAG:
+		return parseHashtagTag(raw)
+	default:
+		return nil, UnknownTagType{TagType: tagType}
+	}
+}
+
+func parseEmojiTag(raw map[string]any) (*TagEmoji, error) {
+	rawId, ok := raw[KEY_ID]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ID}
+	}
+	id, ok := rawId.(string)
+	if !ok {
+		return nil, BadFieldValueError[string]{KEY_ID, rawId, id}
+	}
+	media, err := ParseASIconData(raw, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	rawName1, ok := raw[KEY_ACTIVITYSTREAMS_NAME]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_NAME}
+	}
+	name1, ok := rawName1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_NAME, rawName1, name1}
+	}
+	if len(name1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_NAME, 1, len(name1)}
+	}
+	rawName2, ok := name1[0][KEY_VALUE]
+	if !ok {
+		return nil, NoRequiredSubFieldError{KEY_ACTIVITYSTREAMS_NAME, KEY_VALUE}
+	}
+	name2, ok := rawName2.(string)
+	if !ok {
+		return nil, BadFieldValueError[string]{KEY_VALUE, rawName2, name2}
+	}
+
+	// Casting media to ASIconData without check is ok here
+	// Reason: ParseASIconData returns an BaseAPChain, an interface.
+	// However, the function guarantees that, if it doesn't error out, you get an ASIconData struct back
+	return &TagEmoji{Id: id, Icon: media.(*ASIconData).Media, Name: name2}, nil
+}
+
+func parseMentionTag(raw map[string]any) (*TagMention, error) {
+	return nil, NotImplementedError{}
+}
+
+func parseHashtagTag(raw map[string]any) (*TagHashtag, error) {
+	return nil, NotImplementedError{}
+}

variousTypes.go

@@ -1,6 +1,8 @@
 package goap
 
-import "maps"
+import (
+	"maps"
+)
 
 type PublicKey struct {
 	Id    string
@@ -16,8 +18,8 @@ type Attachment struct {
 
 type Media struct {
 	Type      string
-	MediaType *string
 	Url       string
+	MediaType *string
 	Sensitive *bool
 }
 
@@ -75,3 +77,156 @@ func (m Media) Marshal() map[string]any {
 
 	return t
 }
+
+func ParsePublicKey(_ map[string]any) (PublicKey, error) {
+	return PublicKey{}, NotImplementedError{}
+}
+
+func ParseAttachment(raw map[string]any) (*Attachment, error) {
+	attachment := Attachment{}
+	rawType, ok := raw[KEY_VALUE]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_VALUE}
+	}
+	types, ok := rawType.([]string)
+	if !ok {
+		return nil, BadFieldValueError[[]string]{KEY_VALUE, rawType, []string{}}
+	}
+	if len(types) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_VALUE, 1, len(types)}
+	}
+	attachment.Type = types[0]
+
+	rawValueWrapper, ok := raw[KEY_SCHEMA_VALUE]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_SCHEMA_VALUE}
+	}
+	valueWrapper, ok := rawValueWrapper.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_SCHEMA_VALUE,
+			rawValueWrapper,
+			[]map[string]any{},
+		}
+	}
+	if len(valueWrapper) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_SCHEMA_VALUE, 1, len(types)}
+	}
+	rawValue, ok := valueWrapper[0][KEY_VALUE]
+	if !ok {
+		return nil, NoRequiredSubFieldError{KEY_SCHEMA_VALUE, KEY_VALUE}
+	}
+	value, ok := rawValue.(string)
+	if !ok {
+		return nil, BadFieldValueError[string]{KEY_VALUE, rawValue, ""}
+	}
+	attachment.Value = value
+
+	rawNameWrapper, ok := raw[KEY_ACTIVITYSTREAMS_NAME]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_NAME}
+	}
+	nameWrapper, ok := rawNameWrapper.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_NAME,
+			rawNameWrapper,
+			[]map[string]any{},
+		}
+	}
+	if len(nameWrapper) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_NAME, 1, len(nameWrapper)}
+	}
+	rawName, ok := valueWrapper[0][KEY_VALUE]
+	if !ok {
+		return nil, NoRequiredSubFieldError{KEY_ACTIVITYSTREAMS_NAME, KEY_VALUE}
+	}
+	name, ok := rawName.(string)
+	if !ok {
+		return nil, BadFieldValueError[string]{KEY_VALUE, rawValue, ""}
+	}
+	attachment.Name = name
+
+	return &attachment, nil
+}
+
+func ParseMedia(raw map[string]any) (*Media, error) {
+	rawType, ok := raw[KEY_TYPE]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_TYPE}
+	}
+	typeValues, ok := rawType.([]string)
+	if !ok {
+		return nil, BadFieldValueError[[]string]{KEY_TYPE, rawType, typeValues}
+	}
+	if len(typeValues) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_TYPE, 1, len(typeValues)}
+	}
+	typeValue := typeValues[0]
+	urlId, err := ParseIdTypeWithName(raw, nil, KEY_ACTIVITYSTREAMS_URL)
+	if err != nil {
+		return nil, err
+	}
+	media := Media{
+		Type: typeValue,
+		Url:  urlId.Id,
+	}
+
+	if rawSensitiveData1, ok := raw[KEY_ACTIVITYSTREAMS_SENSITIVE]; ok {
+		if sensitiveData1, ok := rawSensitiveData1.([]map[string]any); ok &&
+			len(sensitiveData1) == 1 {
+			if v, err := ParseValueValue[bool](sensitiveData1[0]); err == nil {
+				media.Sensitive = &v.Value
+			}
+		}
+	}
+	if rawMediatypeData1, ok := raw[KEY_ACTIVITYSTREAMS_MEDIATYPE]; ok {
+		if mediatypeData1, ok := rawMediatypeData1.([]map[string]any); ok &&
+			len(mediatypeData1) == 1 {
+			if v, err := ParseValueValue[string](mediatypeData1[0]); err == nil {
+				media.MediaType = &v.Value
+			}
+		}
+	}
+
+	return &media, nil
+}
+
+func ParseIdValue(_ map[string]any) (IdValue, error) {
+	return IdValue{}, NotImplementedError{}
+}
+
+func ParseValueValue[T any](raw map[string]any) (*ValueValue[T], error) {
+	otherData := map[string]any{}
+	var typeString *string = nil
+	var rawValue any = nil
+	valSet := false
+	for k, v := range raw {
+		switch k {
+		case KEY_VALUE:
+			valSet = true
+			rawValue = v
+		case KEY_TYPE:
+			parsed, ok := v.(string)
+			if !ok {
+				return nil, BadFieldValueError[string]{KEY_TYPE, v, ""}
+			}
+			typeString = &parsed
+		default:
+			otherData[k] = v
+		}
+	}
+	if !valSet {
+		return nil, NoRequiredFieldError{KEY_VALUE}
+	}
+	val, ok := rawValue.(T)
+	if !ok {
+		return nil, BadFieldValueError[T]{KEY_VALUE, rawValue, val}
+	}
+
+	return &ValueValue[T]{
+		Value:       val,
+		Type:        typeString,
+		OtherThings: otherData,
+	}, nil
+}