All parsers for the different elements done

Now to make a parser to combine all of them into one for a giant chain

commonTypes.go

@@ -45,8 +45,55 @@ func ParseIdTypeWithName(m map[string]any, b BaseApChain, name string) (*FullIdT
 	if !ok {
 		return nil, BadFieldValueError[string]{name, rawData2, ""}
 	}
+	delete(m, name)
 	return &FullIdType{
 		Next: b,
 		Id:   data2,
 	}, nil
 }
+
+type FullValueType[T any] struct {
+	Next  BaseApChain
+	Value ValueValue[T]
+}
+
+func (v *FullValueType[T]) GetSelfOrBase() (BaseApChain, bool) {
+	return v.Next, true
+}
+
+func (v *FullValueType[T]) MarshalToMapWithName(name string) map[string]any {
+	m := v.Next.MarshalToMap()
+	m[name] = []map[string]any{v.Value.Marshal()}
+	return m
+}
+
+func ParseValueTypeWithName[T any](
+	m map[string]any,
+	b BaseApChain,
+	name string,
+) (*FullValueType[T], error) {
+	rawData1, ok := m[name]
+	if !ok {
+		return nil, NoRequiredFieldError{name}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			name,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{name, 1, len(data1)}
+	}
+	tmp, err := ParseValueValue[T](data1[0])
+	if err != nil {
+		return nil, err
+	}
+	delete(m, name)
+	return &FullValueType[T]{
+		Next:  b,
+		Value: *tmp,
+	}, nil
+}

constants.go

@@ -22,7 +22,7 @@ const (
 	KEY_W3_SECURITY_OWNER        = "https://w3id.org/security#owner"         // Owner of the public key
 	KEY_W3_SECURITY_PUBLICKEY    = "https://w3id.org/security#publicKey"     // Public key of the account
 	KEY_W3_SECURITY_PUBLICKEYPEM = "https://w3id.org/security#publicKeyPem"  // Pem content of the key
-	KEY_W3_VCARD_ADRESS          = "http://www.w3.org/2006/vcard/ns#Address" // Vcard address of an account
+	KEY_W3_VCARD_ADDRESS         = "http://www.w3.org/2006/vcard/ns#Address" // Vcard address of an account
 	KEY_W3_VCARD_BIRTHDAY        = "http://www.w3.org/2006/vcard/ns#bday"    // Vcard birthday of an account
 
 	KEY_W3_SECURITY_KEY = "https://w3id.org/security#Key" // Object is a PublicKey

nsActivitystreams.go

@@ -71,6 +71,7 @@ func ParseASAlsoKnownAsData(raw map[string]any, next BaseApChain) (BaseApChain,
 		}
 		urls = append(urls, data2)
 	}
+	delete(raw, KEY_ACTIVITYSTREAMS_ALSOKNOWNAS)
 	return &ASAlsoKnownAsData{
 		Next: next,
 		Urls: urls,
@@ -119,6 +120,7 @@ func ParseASAttachmentsData(raw map[string]any, next BaseApChain) (BaseApChain,
 		}
 		attachments = append(attachments, *a)
 	}
+	delete(raw, KEY_ACTIVITYSTREAMS_ATTACHMENTS)
 	return &ASAttachmentsData{
 		Next:        next,
 		Attachments: attachments,
@@ -189,6 +191,7 @@ func ParseASCCData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
 		}
 		ccs = append(ccs, val)
 	}
+	delete(raw, KEY_ACTIVITYSTREAMS_CC)
 	return &ASCCData{
 		Next:    next,
 		Targets: ccs,
@@ -236,6 +239,7 @@ func ParseASContentData(raw map[string]any, next BaseApChain) (BaseApChain, erro
 		}
 		contents = append(contents, *parsed)
 	}
+	delete(raw, KEY_ACTIVITYSTREAMS_CONTENT)
 	return &ASContentData{
 		Next:    next,
 		Content: contents,
@@ -299,6 +303,7 @@ func ParseASEndpointsData(raw map[string]any, next BaseApChain) (BaseApChain, er
 		}
 		endpoints[k] = v2
 	}
+	delete(raw, KEY_ACTIVITYSTREAMS_ENDPOINTS)
 	return &ASEndpointsData{
 		Next:      next,
 		Endpoints: endpoints,
@@ -398,6 +403,7 @@ func ParseASIconData(raw map[string]any, next BaseApChain) (BaseApChain, error)
 	if err != nil {
 		return nil, err
 	}
+	delete(raw, KEY_ACTIVITYSTREAMS_ICON)
 	return &ASIconData{
 		Media: *m,
 		Next:  next,
@@ -441,6 +447,7 @@ func ParseASImageData(raw map[string]any, next BaseApChain) (BaseApChain, error)
 	if err != nil {
 		return nil, err
 	}
+	delete(raw, KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE)
 	return &ASImageData{
 		Media: *m,
 		Next:  next,
@@ -448,8 +455,7 @@ func ParseASImageData(raw map[string]any, next BaseApChain) (BaseApChain, error)
 }
 
 type ASMediaTypeData struct {
-	Next BaseApChain
-	Type string
+	FullValueType[string]
 }
 
 func (mediatypedata *ASMediaTypeData) GetSelfOrBase() (BaseApChain, bool) {
@@ -457,46 +463,19 @@ func (mediatypedata *ASMediaTypeData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (mediatypedata *ASMediaTypeData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		mediatypedata.Next.MarshalToMap(),
-		KEY_ACTIVITYSTREAMS_MEDIATYPE,
-		ValueValue[string]{
-			Value:       mediatypedata.Type,
-			Type:        nil,
-			OtherThings: map[string]any{},
-		}.Marshal(),
-	)
+	return mediatypedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_MEDIATYPE)
 }
 
 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])
+	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_MEDIATYPE)
 	if err != nil {
 		return nil, err
 	}
-	return &ASMediaTypeData{
-		Next: next,
-		Type: tmp.Value,
-	}, nil
+	return &ASMediaTypeData{*tmp}, nil
 }
 
 type ASNameData struct {
-	Next BaseApChain
-	Name ValueValue[string]
+	FullValueType[string]
 }
 
 func (namedata *ASNameData) GetSelfOrBase() (BaseApChain, bool) {
@@ -504,37 +483,15 @@ func (namedata *ASNameData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (namedata *ASNameData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		namedata.Next.MarshalToMap(),
-		KEY_ACTIVITYSTREAMS_NAME,
-		[]map[string]any{namedata.Name.Marshal()},
-	)
+	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_NAME)
 }
 
 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])
+	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_NAME)
 	if err != nil {
 		return nil, err
 	}
-	return &ASNameData{
-		Next: next,
-		Name: *tmp,
-	}, nil
+	return &ASNameData{*tmp}, nil
 }
 
 type ASOutboxData struct {
@@ -578,8 +535,7 @@ func ParseASObjectData(raw map[string]any, next BaseApChain) (BaseApChain, error
 }
 
 type ASPreferredNameData struct {
-	Next BaseApChain
-	Name ValueValue[string]
+	FullValueType[string]
 }
 
 func (namedata *ASPreferredNameData) GetSelfOrBase() (BaseApChain, bool) {
@@ -587,37 +543,15 @@ func (namedata *ASPreferredNameData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (namedata *ASPreferredNameData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		namedata.Next.MarshalToMap(),
-		KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME,
-		[]map[string]any{namedata.Name.Marshal()},
-	)
+	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME)
 }
 
 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])
+	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME)
 	if err != nil {
 		return nil, err
 	}
-	return &ASPreferredNameData{
-		Next: next,
-		Name: *tmp,
-	}, nil
+	return &ASPreferredNameData{*tmp}, nil
 }
 
 type ASPublishedData struct {
@@ -660,6 +594,7 @@ func ParseASPublishedData(raw map[string]any, next BaseApChain) (BaseApChain, er
 	if err != nil {
 		return nil, err
 	}
+	delete(raw, KEY_ACTIVITYSTREAMS_PUBLISHED)
 	return &ASPublishedData{
 		Next:      next,
 		Timestamp: t,
@@ -667,8 +602,7 @@ func ParseASPublishedData(raw map[string]any, next BaseApChain) (BaseApChain, er
 }
 
 type ASRestrictedFollowData struct {
-	Next  BaseApChain
-	Value ValueValue[bool]
+	FullValueType[bool]
 }
 
 func (namedata *ASRestrictedFollowData) GetSelfOrBase() (BaseApChain, bool) {
@@ -676,37 +610,15 @@ func (namedata *ASRestrictedFollowData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (namedata *ASRestrictedFollowData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		namedata.Next.MarshalToMap(),
-		KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW,
-		[]map[string]any{namedata.Value.Marshal()},
-	)
+	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW)
 }
 
 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])
+	tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW)
 	if err != nil {
 		return nil, err
 	}
-	return &ASRestrictedFollowData{
-		Next:  next,
-		Value: *tmp,
-	}, nil
+	return &ASRestrictedFollowData{*tmp}, nil
 }
 
 type ASRepliesData struct {
@@ -750,8 +662,7 @@ func ParseASSharedInboxData(raw map[string]any, next BaseApChain) (BaseApChain,
 }
 
 type ASSummaryData struct {
-	Next BaseApChain
-	Name ValueValue[string]
+	FullValueType[string]
 }
 
 func (namedata *ASSummaryData) GetSelfOrBase() (BaseApChain, bool) {
@@ -759,42 +670,19 @@ func (namedata *ASSummaryData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (namedata *ASSummaryData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		namedata.Next.MarshalToMap(),
-		KEY_ACTIVITYSTREAMS_SUMMARY,
-		[]map[string]any{namedata.Name.Marshal()},
-	)
+	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_SUMMARY)
 }
 
 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])
+	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_SUMMARY)
 	if err != nil {
 		return nil, err
 	}
-	return &ASSummaryData{
-		Next: next,
-		Name: *tmp,
-	}, nil
+	return &ASSummaryData{*tmp}, nil
 }
 
 type ASSensitiveData struct {
-	Next BaseApChain
-	Name ValueValue[bool]
+	FullValueType[bool]
 }
 
 func (namedata *ASSensitiveData) GetSelfOrBase() (BaseApChain, bool) {
@@ -802,37 +690,15 @@ func (namedata *ASSensitiveData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (namedata *ASSensitiveData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		namedata.Next.MarshalToMap(),
-		KEY_ACTIVITYSTREAMS_SENSITIVE,
-		[]map[string]any{namedata.Name.Marshal()},
-	)
+	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_SENSITIVE)
 }
 
 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])
+	tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_ACTIVITYSTREAMS_SENSITIVE)
 	if err != nil {
 		return nil, err
 	}
-	return &ASSensitiveData{
-		Next: next,
-		Name: *tmp,
-	}, nil
+	return &ASSensitiveData{*tmp}, nil
 }
 
 type ASTagData struct {
@@ -855,7 +721,27 @@ func (tagdata *ASTagData) MarshalToMap() map[string]any {
 }
 
 func ParseASTagData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
-	return nil, NotImplementedError{}
+	rawData, ok := raw[KEY_ACTIVITYSTREAMS_TAG]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_TAG}
+	}
+	data, ok := rawData.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_TAG, rawData, data}
+	}
+	tags := []Tag{}
+	for _, v := range data {
+		tag, err := ParseTag(v)
+		if err != nil {
+			return nil, err
+		}
+		tags = append(tags, tag)
+	}
+	delete(raw, KEY_ACTIVITYSTREAMS_TAG)
+	return &ASTagData{
+		Next: next,
+		Tags: tags,
+	}, nil
 }
 
 type ASToData struct {
@@ -878,7 +764,32 @@ func (cc *ASToData) MarshalToMap() map[string]any {
 }
 
 func ParseASToData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
-	return nil, NotImplementedError{}
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_TO]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_TO}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_TO, rawData1, data1}
+	}
+	targets := []string{}
+	for _, v := range data1 {
+		rawData2, ok := v[KEY_ID]
+		if !ok {
+			return nil, NoRequiredSubFieldError{KEY_ACTIVITYSTREAMS_TO, KEY_ID}
+		}
+		data2, ok := rawData2.(string)
+		if !ok {
+			return nil, BadFieldValueError[string]{KEY_ID, rawData2, data2}
+		}
+		targets = append(targets, data2)
+	}
+
+	delete(raw, KEY_ACTIVITYSTREAMS_TO)
+	return &ASToData{
+		Next:    next,
+		Targets: targets,
+	}, nil
 }
 
 type ASUrlData struct {
@@ -912,10 +823,38 @@ func (publisheddata *ASUpdatedData) GetSelfOrBase() (BaseApChain, bool) {
 
 func (publisheddata *ASUpdatedData) MarshalToMap() map[string]any {
 	m := publisheddata.Next.MarshalToMap()
-	m[KEY_ACTIVITYSTREAMS_PUBLISHED] = timeToXmlTime(publisheddata.Timestamp)
+	m[KEY_ACTIVITYSTREAMS_UPDATED] = timeToXmlTime(publisheddata.Timestamp)
 	return m
 }
 
 func ParseASUpdatedData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
-	return nil, NotImplementedError{}
+	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_UPDATED]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_UPDATED}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_ACTIVITYSTREAMS_UPDATED,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_UPDATED, 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
+	}
+	delete(raw, KEY_ACTIVITYSTREAMS_UPDATED)
+	return &ASPublishedData{
+		Next:      next,
+		Timestamp: t,
+	}, nil
 }

nsAll.go

@@ -1 +0,0 @@
-package goap

nsLitepub.go

@@ -2,7 +2,7 @@ package goap
 
 type LitepubCapabilitiesData struct {
 	Next         BaseApChain
-	Capabilities []map[string]any
+	Capabilities []map[string]any // I have no idea what the data inside there looks like
 }
 
 func (capabilitiesdata *LitepubCapabilitiesData) GetSelfOrBase() (BaseApChain, bool) {
@@ -17,6 +17,21 @@ func (capabilitiesdata *LitepubCapabilitiesData) MarshalToMap() map[string]any {
 	)
 }
 
+func ParseLitepubCapabilitiesData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData, ok := raw[KEY_LITEPUB_CAPABILITIES]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_LITEPUB_CAPABILITIES}
+	}
+	data, ok := rawData.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{KEY_LITEPUB_CAPABILITIES, rawData, data}
+	}
+	return &LitepubCapabilitiesData{
+		Next:         next,
+		Capabilities: data,
+	}, nil
+}
+
 type LitepubOauthRegistrationEndpointData struct {
 	FullIdType
 }
@@ -30,3 +45,14 @@ func (oauthregistrationendpointdata *LitepubOauthRegistrationEndpointData) Marsh
 		KEY_ACTIVITYSTREAMS_OAUTHAUTHORIZATION,
 	)
 }
+
+func ParseLitepubOauthRegistrationEndpointData(
+	raw map[string]any,
+	next BaseApChain,
+) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_LITEPUB_OAUTHREGISTRATION)
+	if err != nil {
+		return nil, err
+	}
+	return &LitepubOauthRegistrationEndpointData{FullIdType: *id}, nil
+}

nsMasto.go

@@ -12,9 +12,16 @@ func (actor *MastoDevicesData) MarshalToMap() map[string]any {
 	return actor.FullIdType.MarshalToMapWithName(KEY_MASTO_DEVICES)
 }
 
+func ParseMastoDevicesData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_MASTO_DEVICES)
+	if err != nil {
+		return nil, err
+	}
+	return &MastoDevicesData{FullIdType: *id}, nil
+}
+
 type MastoDiscoverableData struct {
-	Next  BaseApChain
-	Value ValueValue[bool]
+	FullValueType[bool]
 }
 
 func (namedata *MastoDiscoverableData) GetSelfOrBase() (BaseApChain, bool) {
@@ -22,11 +29,15 @@ func (namedata *MastoDiscoverableData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (namedata *MastoDiscoverableData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		namedata.Next.MarshalToMap(),
-		KEY_MASTO_DISCOVERABLE,
-		[]map[string]any{namedata.Value.Marshal()},
-	)
+	return namedata.MarshalToMapWithName(KEY_MASTO_DISCOVERABLE)
+}
+
+func ParseMastoDiscoverableData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_MASTO_DISCOVERABLE)
+	if err != nil {
+		return nil, err
+	}
+	return &MastoDiscoverableData{*tmp}, nil
 }
 
 type MastoFeaturedData struct {
@@ -41,6 +52,14 @@ func (actor *MastoFeaturedData) MarshalToMap() map[string]any {
 	return actor.FullIdType.MarshalToMapWithName(KEY_MASTO_FEATURED)
 }
 
+func ParseMastoFeaturedData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_MASTO_FEATURED)
+	if err != nil {
+		return nil, err
+	}
+	return &MastoFeaturedData{FullIdType: *id}, nil
+}
+
 type MastoFeaturedTagsData struct {
 	FullIdType
 }
@@ -53,9 +72,16 @@ func (actor *MastoFeaturedTagsData) MarshalToMap() map[string]any {
 	return actor.FullIdType.MarshalToMapWithName(KEY_MASTO_FEATURED_TAGS)
 }
 
+func ParseMastoFeaturedTagsData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	id, err := ParseIdTypeWithName(raw, next, KEY_MASTO_FEATURED_TAGS)
+	if err != nil {
+		return nil, err
+	}
+	return &MastoFeaturedTagsData{FullIdType: *id}, nil
+}
+
 type MastoIndexableData struct {
-	Next  BaseApChain
-	Value ValueValue[bool]
+	FullValueType[bool]
 }
 
 func (namedata *MastoIndexableData) GetSelfOrBase() (BaseApChain, bool) {
@@ -63,16 +89,19 @@ func (namedata *MastoIndexableData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (namedata *MastoIndexableData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		namedata.Next.MarshalToMap(),
-		KEY_MASTO_INDEXABLE,
-		[]map[string]any{namedata.Value.Marshal()},
-	)
+	return namedata.MarshalToMapWithName(KEY_MASTO_INDEXABLE)
+}
+
+func ParseMastoIndexableData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_MASTO_INDEXABLE)
+	if err != nil {
+		return nil, err
+	}
+	return &MastoIndexableData{*tmp}, nil
 }
 
 type MastoMemorialData struct {
-	Next  BaseApChain
-	Value ValueValue[bool]
+	FullValueType[bool]
 }
 
 func (namedata *MastoMemorialData) GetSelfOrBase() (BaseApChain, bool) {
@@ -80,9 +109,13 @@ func (namedata *MastoMemorialData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (namedata *MastoMemorialData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		namedata.Next.MarshalToMap(),
-		KEY_MASTO_MEMORIAL,
-		[]map[string]any{namedata.Value.Marshal()},
-	)
+	return namedata.MarshalToMapWithName(KEY_MASTO_MEMORIAL)
+}
+
+func ParseMastoMemorialData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_MASTO_MEMORIAL)
+	if err != nil {
+		return nil, err
+	}
+	return &MastoMemorialData{*tmp}, nil
 }

nsMisskey.go

@@ -3,8 +3,7 @@ package goap
 // NOTE: Different to ASSummaryData
 // Misskey summary is the raw text without formatting applied while the Activitystreams summary already contains the preformatted summary
 type MKSummaryData struct {
-	Next    BaseApChain
-	Summary string
+	FullValueType[string]
 }
 
 func (misskeysummarydata *MKSummaryData) GetSelfOrBase() (BaseApChain, bool) {
@@ -12,16 +11,19 @@ func (misskeysummarydata *MKSummaryData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (misskeysummarydata *MKSummaryData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		misskeysummarydata.Next.MarshalToMap(),
-		KEY_MISSKEY_MKSUMMARY,
-		[]map[string]any{{KEY_VALUE: misskeysummarydata.Summary}},
-	)
+	return misskeysummarydata.MarshalToMapWithName(KEY_MISSKEY_MKSUMMARY)
+}
+
+func ParseMKSummaryData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_MISSKEY_MKSUMMARY)
+	if err != nil {
+		return nil, err
+	}
+	return &MKSummaryData{*tmp}, nil
 }
 
 type MKIsCatData struct {
-	Next  BaseApChain
-	IsCat bool
+	FullValueType[bool]
 }
 
 func (iscatdata *MKIsCatData) GetSelfOrBase() (BaseApChain, bool) {
@@ -29,26 +31,33 @@ func (iscatdata *MKIsCatData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (iscatdata *MKIsCatData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		iscatdata.Next.MarshalToMap(),
-		KEY_MISSKEY_ISCAT,
-		[]map[string]any{{KEY_VALUE: iscatdata.IsCat}},
-	)
+	return iscatdata.MarshalToMapWithName(KEY_MISSKEY_ISCAT)
 }
 
-type MKSpeakAsCatData struct {
-	Next        BaseApChain
-	SpeaksAsCat bool
+func ParseMKIsCatData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_MISSKEY_ISCAT)
+	if err != nil {
+		return nil, err
+	}
+	return &MKIsCatData{*tmp}, nil
 }
 
-func (iscatdata *MKSpeakAsCatData) GetSelfOrBase() (BaseApChain, bool) {
+type FFSpeakAsCatData struct {
+	FullValueType[bool]
+}
+
+func (iscatdata *FFSpeakAsCatData) GetSelfOrBase() (BaseApChain, bool) {
 	return iscatdata.Next, true
 }
 
-func (iscatdata *MKSpeakAsCatData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		iscatdata.Next.MarshalToMap(),
-		KEY_FIREFISH_SPEAKASCAT,
-		[]map[string]any{{KEY_VALUE: iscatdata.SpeaksAsCat}},
-	)
+func (iscatdata *FFSpeakAsCatData) MarshalToMap() map[string]any {
+	return iscatdata.MarshalToMapWithName(KEY_FIREFISH_SPEAKASCAT)
+}
+
+func ParseFFSpeakAsCatData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_FIREFISH_SPEAKASCAT)
+	if err != nil {
+		return nil, err
+	}
+	return &FFSpeakAsCatData{*tmp}, nil
 }

nsOstatus.go

@@ -2,7 +2,7 @@ package goap
 
 type OstatusAtomUriData struct {
 	Next BaseApChain
-	Uri  string
+	Uri  ValueValue[string]
 }
 
 func (atomurivalue *OstatusAtomUriData) GetSelfOrBase() (BaseApChain, bool) {
@@ -13,13 +13,40 @@ func (atomurivalue *OstatusAtomUriData) MarshalToMap() map[string]any {
 	return appendWithKey(
 		atomurivalue.Next.MarshalToMap(),
 		KEY_OSTATUS_ATOMURI,
-		[]map[string]any{{KEY_VALUE: atomurivalue.Uri}},
+		[]map[string]any{atomurivalue.Uri.Marshal()},
 	)
 }
 
+func ParseOstatusAtomUriData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_OSTATUS_ATOMURI]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_OSTATUS_ATOMURI}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_OSTATUS_ATOMURI,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_OSTATUS_ATOMURI, 1, len(data1)}
+	}
+	tmp, err := ParseValueValue[string](data1[0])
+	if err != nil {
+		return nil, err
+	}
+	delete(raw, KEY_OSTATUS_ATOMURI)
+	return &OstatusAtomUriData{
+		Next: next,
+		Uri:  *tmp,
+	}, nil
+}
+
 type OstatusConversationData struct {
 	Next BaseApChain
-	Uri  string
+	Uri  ValueValue[string]
 }
 
 func (atomurivalue *OstatusConversationData) GetSelfOrBase() (BaseApChain, bool) {
@@ -30,6 +57,33 @@ func (atomurivalue *OstatusConversationData) MarshalToMap() map[string]any {
 	return appendWithKey(
 		atomurivalue.Next.MarshalToMap(),
 		KEY_OSTATUS_CONVERSATION,
-		[]map[string]any{{KEY_VALUE: atomurivalue.Uri}},
+		[]map[string]any{atomurivalue.Uri.Marshal()},
 	)
 }
+
+func ParseOstatusConversationData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_OSTATUS_CONVERSATION]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_OSTATUS_CONVERSATION}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{
+			KEY_OSTATUS_CONVERSATION,
+			rawData1,
+			data1,
+		}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_OSTATUS_CONVERSATION, 1, len(data1)}
+	}
+	tmp, err := ParseValueValue[string](data1[0])
+	if err != nil {
+		return nil, err
+	}
+	delete(raw, KEY_OSTATUS_CONVERSATION)
+	return &OstatusConversationData{
+		Next: next,
+		Uri:  *tmp,
+	}, nil
+}

nsSchema.go

@@ -1,8 +1,7 @@
 package goap
 
 type SchemaValueData struct {
-	Next  BaseApChain
-	Value ValueValue[string]
+	FullValueType[string]
 }
 
 func (namedata *SchemaValueData) GetSelfOrBase() (BaseApChain, bool) {
@@ -10,9 +9,13 @@ func (namedata *SchemaValueData) GetSelfOrBase() (BaseApChain, bool) {
 }
 
 func (namedata *SchemaValueData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		namedata.Next.MarshalToMap(),
-		KEY_SCHEMA_VALUE,
-		[]map[string]any{namedata.Value.Marshal()},
-	)
+	return namedata.MarshalToMapWithName(KEY_SCHEMA_VALUE)
+}
+
+func ParseSchemaValueData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_SCHEMA_VALUE)
+	if err != nil {
+		return nil, err
+	}
+	return &SchemaValueData{*tmp}, nil
 }

nsW3.go

@@ -11,3 +11,11 @@ func (actor *W3InboxData) GetSelfOrBase() (BaseApChain, bool) {
 func (actor *W3InboxData) MarshalToMap() map[string]any {
 	return actor.FullIdType.MarshalToMapWithName(KEY_W3_INBOX)
 }
+
+func ParseW3InboxData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseIdTypeWithName(raw, next, KEY_W3_INBOX)
+	if err != nil {
+		return nil, err
+	}
+	return &W3InboxData{*tmp}, nil
+}

nsW3Security.go

@@ -12,6 +12,15 @@ func (actor *W3SecurityOwnerData) MarshalToMap() map[string]any {
 	return actor.FullIdType.MarshalToMapWithName(KEY_W3_SECURITY_OWNER)
 }
 
+func ParseW3SecurityOwnerData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseIdTypeWithName(raw, next, KEY_W3_SECURITY_OWNER)
+	if err != nil {
+		return nil, err
+	}
+	return &W3SecurityOwnerData{*tmp}, nil
+}
+
+// TODO: Handle case with multiple public keys (if allowed, idk if it is)
 type W3SecurityPublicKeyData struct {
 	Next  BaseApChain
 	Id    string
@@ -33,9 +42,43 @@ func (publickeydata *W3SecurityPublicKeyData) MarshalToMap() map[string]any {
 	return m
 }
 
+func ParseW3SecurityPublicKeyData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	rawData1, ok := raw[KEY_W3_SECURITY_PUBLICKEY]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_W3_SECURITY_PUBLICKEY}
+	}
+	data1, ok := rawData1.([]map[string]any)
+	if !ok {
+		return nil, BadFieldValueError[[]map[string]any]{KEY_W3_SECURITY_PUBLICKEY, rawData1, data1}
+	}
+	if len(data1) != 1 {
+		return nil, BadFieldArrayLengthError{KEY_W3_SECURITY_PUBLICKEY, 1, len(data1)}
+	}
+	Id, err := ParseIdValue(data1[0])
+	if err != nil {
+		return nil, err
+	}
+	rawPem, err := ParseW3SecurityPublicKeyPemData(data1[0], nil)
+	if err != nil {
+		return nil, err
+	}
+	rawOwner, err := ParseW3SecurityOwnerData(data1[0], nil)
+	if err != nil {
+		return nil, err
+	}
+	owner := rawOwner.(*W3SecurityOwnerData)
+
+	pem := rawPem.(*W3SecurityPublicKeyPemData)
+	return &W3SecurityPublicKeyData{
+		Next:  next,
+		Id:    Id.Id,
+		Key:   pem.Value.Value,
+		Owner: owner.Id,
+	}, nil
+}
+
 type W3SecurityPublicKeyPemData struct {
-	Next  BaseApChain
-	Value ValueValue[bool]
+	FullValueType[string]
 }
 
 func (namedata *W3SecurityPublicKeyPemData) GetSelfOrBase() (BaseApChain, bool) {
@@ -43,9 +86,13 @@ func (namedata *W3SecurityPublicKeyPemData) GetSelfOrBase() (BaseApChain, bool)
 }
 
 func (namedata *W3SecurityPublicKeyPemData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		namedata.Next.MarshalToMap(),
-		KEY_W3_SECURITY_PUBLICKEYPEM,
-		[]map[string]any{namedata.Value.Marshal()},
-	)
+	return namedata.MarshalToMapWithName(KEY_W3_SECURITY_PUBLICKEYPEM)
+}
+
+func ParseW3SecurityPublicKeyPemData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_W3_SECURITY_PUBLICKEYPEM)
+	if err != nil {
+		return nil, err
+	}
+	return &W3SecurityPublicKeyPemData{*tmp}, nil
 }

nsW3Vcard.go

@@ -1,8 +1,7 @@
 package goap
 
 type W3VcardAddressData struct {
-	Next    BaseApChain
-	Address string
+	FullValueType[string]
 }
 
 func (misskeysummarydata *W3VcardAddressData) GetSelfOrBase() (BaseApChain, bool) {
@@ -10,16 +9,19 @@ func (misskeysummarydata *W3VcardAddressData) GetSelfOrBase() (BaseApChain, bool
 }
 
 func (misskeysummarydata *W3VcardAddressData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		misskeysummarydata.Next.MarshalToMap(),
-		KEY_W3_VCARD_ADRESS,
-		[]map[string]any{{KEY_VALUE: misskeysummarydata.Address}},
-	)
+	return misskeysummarydata.MarshalToMapWithName(KEY_W3_VCARD_ADDRESS)
+}
+
+func ParseW3VcardAddressData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_W3_VCARD_ADDRESS)
+	if err != nil {
+		return nil, err
+	}
+	return &W3VcardAddressData{*tmp}, nil
 }
 
 type W3VcardBirthdayData struct {
-	Next     BaseApChain
-	Birthday string
+	FullValueType[string]
 }
 
 func (misskeysummarydata *W3VcardBirthdayData) GetSelfOrBase() (BaseApChain, bool) {
@@ -27,9 +29,13 @@ func (misskeysummarydata *W3VcardBirthdayData) GetSelfOrBase() (BaseApChain, boo
 }
 
 func (misskeysummarydata *W3VcardBirthdayData) MarshalToMap() map[string]any {
-	return appendWithKey(
-		misskeysummarydata.Next.MarshalToMap(),
-		KEY_W3_VCARD_BIRTHDAY,
-		[]map[string]any{{KEY_VALUE: misskeysummarydata.Birthday}},
-	)
+	return misskeysummarydata.MarshalToMapWithName(KEY_W3_VCARD_BIRTHDAY)
+}
+
+func ParseW3VcardBirthdayData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
+	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_W3_VCARD_BIRTHDAY)
+	if err != nil {
+		return nil, err
+	}
+	return &W3VcardBirthdayData{*tmp}, nil
 }

nsXmlschema.go

@@ -1 +0,0 @@
-package goap

tags.go

@@ -122,9 +122,35 @@ func parseEmojiTag(raw map[string]any) (*TagEmoji, error) {
 }
 
 func parseMentionTag(raw map[string]any) (*TagMention, error) {
-	return nil, NotImplementedError{}
+	rawHref, err := ParseASHrefData(raw, nil)
+	if err != nil {
+		return nil, err
+	}
+	href := rawHref.(*ASHrefData)
+	rawName, err := ParseASNameData(raw, nil)
+	if err != nil {
+		return nil, err
+	}
+	name := rawName.(*ASNameData)
+	return &TagMention{
+		TargetId:   href.Id,
+		TargetName: name.Name.Value,
+	}, nil
 }
 
 func parseHashtagTag(raw map[string]any) (*TagHashtag, error) {
-	return nil, NotImplementedError{}
+	rawHref, err := ParseASHrefData(raw, nil)
+	if err != nil {
+		return nil, err
+	}
+	href := rawHref.(*ASHrefData)
+	rawName, err := ParseASNameData(raw, nil)
+	if err != nil {
+		return nil, err
+	}
+	name := rawName.(*ASNameData)
+	return &TagHashtag{
+		Url:  href.Id,
+		Name: name.Name.Value,
+	}, nil
 }

variousTypes.go

@@ -192,8 +192,16 @@ func ParseMedia(raw map[string]any) (*Media, error) {
 	return &media, nil
 }
 
-func ParseIdValue(_ map[string]any) (IdValue, error) {
-	return IdValue{}, NotImplementedError{}
+func ParseIdValue(r map[string]any) (*IdValue, error) {
+	rawId, ok := r[KEY_ID]
+	if !ok {
+		return nil, NoRequiredFieldError{KEY_ID}
+	}
+	id, ok := rawId.(string)
+	if !ok {
+		return nil, BadFieldValueError[string]{KEY_ID, rawId, id}
+	}
+	return &IdValue{Id: id}, nil
 }
 
 func ParseValueValue[T any](raw map[string]any) (*ValueValue[T], error) {