goap/nsActivitystreams.go

package goap

import (
	"time"

	"github.com/datainq/xml-date-time"
	"gitlab.com/mstarongitlab/goutils/sliceutils"
)

type ASActorData struct {
	FullIdType
}

func (actor *ASActorData) GetSelfOrBase() (BaseApChain, bool) {
	return actor.FullIdType.GetSelfOrBase()
}

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
}

func (cc *ASAlsoKnownAsData) GetSelfOrBase() (BaseApChain, bool) {
	return cc.Next, true
}

func (cc *ASAlsoKnownAsData) MarshalToMap() map[string]any {
	return appendWithKey(
		cc.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_ALSOKNOWNAS,
		sliceutils.Map(cc.Urls, func(t string) map[string]any {
			return map[string]any{KEY_ID: t}
		}),
	)
}

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)
	}
	delete(raw, KEY_ACTIVITYSTREAMS_ALSOKNOWNAS)
	return &ASAlsoKnownAsData{
		Next: next,
		Urls: urls,
	}, nil
}

type ASAttachmentsData struct {
	Next        BaseApChain
	Attachments []Attachment
}

func (attachmentsdata *ASAttachmentsData) GetSelfOrBase() (BaseApChain, bool) {
	return attachmentsdata.Next, true
}

func (attachmentsdata *ASAttachmentsData) MarshalToMap() map[string]any {
	return appendWithKey(
		attachmentsdata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_ATTACHMENTS,
		sliceutils.Map(
			attachmentsdata.Attachments,
			func(t Attachment) map[string]any { return t.Marshal() },
		),
	)
}

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)
	}
	delete(raw, KEY_ACTIVITYSTREAMS_ATTACHMENTS)
	return &ASAttachmentsData{
		Next:        next,
		Attachments: attachments,
	}, nil
}

type ASAttributedToData struct {
	FullIdType
}

func (attributedtodata *ASAttributedToData) GetSelfOrBase() (BaseApChain, bool) {
	return attributedtodata.FullIdType.Next, true
}

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
}

func (cc *ASCCData) GetSelfOrBase() (BaseApChain, bool) {
	return cc.Next, true
}

func (cc *ASCCData) MarshalToMap() map[string]any {
	return appendWithKey(
		cc.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_CC,
		sliceutils.Map(cc.Targets, func(t string) map[string]any {
			return map[string]any{KEY_ID: t}
		}),
	)
}

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)
	}
	delete(raw, KEY_ACTIVITYSTREAMS_CC)
	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]
}

func (contentdata *ASContentData) GetSelfOrBase() (BaseApChain, bool) {
	return contentdata.Next, true
}

func (contentdata *ASContentData) MarshalToMap() map[string]any {
	return appendWithKey(
		contentdata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_CONTENT,
		sliceutils.Map(contentdata.Content, func(t ValueValue[string]) map[string]any {
			return t.Marshal()
		}),
	)
}

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)
	}
	delete(raw, KEY_ACTIVITYSTREAMS_CONTENT)
	return &ASContentData{
		Next:    next,
		Content: contents,
	}, nil
}

type ASEndpointsData struct {
	Next      BaseApChain
	Endpoints map[string]string
}

func (endpointsdata *ASEndpointsData) GetSelfOrBase() (BaseApChain, bool) {
	return endpointsdata.Next, true
}

func (endpointsdata *ASEndpointsData) MarshalToMap() map[string]any {
	m := endpointsdata.Next.MarshalToMap()
	arr := []map[string]any{}
	for k, v := range endpointsdata.Endpoints {
		arr = append(arr, map[string]any{
			k: []map[string]any{{KEY_ID: v}},
		})
	}
	m[KEY_ACTIVITYSTREAMS_ENDPOINTS] = arr
	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
	}
	delete(raw, KEY_ACTIVITYSTREAMS_ENDPOINTS)
	return &ASEndpointsData{
		Next:      next,
		Endpoints: endpoints,
	}, nil
}

type ASFollowersData struct {
	FullIdType
}

func (attributedtodata *ASFollowersData) GetSelfOrBase() (BaseApChain, bool) {
	return attributedtodata.FullIdType.Next, true
}

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 &ASFollowersData{FullIdType: *id}, nil
}

type ASFollowingData struct {
	FullIdType
}

func (attributedtodata *ASFollowingData) GetSelfOrBase() (BaseApChain, bool) {
	return attributedtodata.FullIdType.Next, true
}

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 &ASFollowingData{FullIdType: *id}, nil
}

type ASHrefData struct {
	FullIdType
}

func (attributedtodata *ASHrefData) GetSelfOrBase() (BaseApChain, bool) {
	return attributedtodata.FullIdType.Next, true
}

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 &ASHrefData{FullIdType: *id}, nil
}

type ASIconData struct {
	Next  BaseApChain
	Media Media
}

func (icondata *ASIconData) GetSelfOrBase() (BaseApChain, bool) {
	return icondata.Next, true
}

func (icondata *ASIconData) MarshalToMap() map[string]any {
	return appendWithKey(
		icondata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_ICON,
		[]map[string]any{icondata.Media.Marshal()},
	)
}

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
	}
	delete(raw, KEY_ACTIVITYSTREAMS_ICON)
	return &ASIconData{
		Media: *m,
		Next:  next,
	}, nil
}

type ASImageData struct {
	Next  BaseApChain
	Media Media
}

func (icondata *ASImageData) GetSelfOrBase() (BaseApChain, bool) {
	return icondata.Next, true
}

func (icondata *ASImageData) MarshalToMap() map[string]any {
	return appendWithKey(
		icondata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE,
		[]map[string]any{icondata.Media.Marshal()},
	)
}

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
	}
	delete(raw, KEY_ACTIVITYSTREAMS_IMAGE_ATTRIBUTE)
	return &ASImageData{
		Media: *m,
		Next:  next,
	}, nil
}

type ASMediaTypeData struct {
	FullValueType[string]
}

func (mediatypedata *ASMediaTypeData) GetSelfOrBase() (BaseApChain, bool) {
	return mediatypedata.Next, true
}

func (mediatypedata *ASMediaTypeData) MarshalToMap() map[string]any {
	return mediatypedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_MEDIATYPE)
}

func ParseASMediaTypeData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_MEDIATYPE)
	if err != nil {
		return nil, err
	}
	return &ASMediaTypeData{*tmp}, nil
}

type ASNameData struct {
	FullValueType[string]
}

func (namedata *ASNameData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *ASNameData) MarshalToMap() map[string]any {
	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_NAME)
}

func ParseASNameData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_NAME)
	if err != nil {
		return nil, err
	}
	return &ASNameData{*tmp}, nil
}

type ASOutboxData struct {
	FullIdType
}

func (attributedtodata *ASOutboxData) GetSelfOrBase() (BaseApChain, bool) {
	return attributedtodata.FullIdType.Next, true
}

func (attributedtodata *ASOutboxData) MarshalToMap() map[string]any {
	return attributedtodata.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_OUTBOX)
}

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 {
	Next BaseApChain
	// Unparsed objects. Please parse yourself. Go doesn't like the recursion if the parser for this attribute was calling Unmarshal
	Objects []map[string]any
}

func (object *ASObjectData) GetSelfOrBase() (BaseApChain, bool) {
	return object.Next, true
}

func (object *ASObjectData) MarshalToMap() map[string]any {
	return appendWithKey(object.Next.MarshalToMap(), KEY_ACTIVITYSTREAMS_OBJECT, object.Objects)
}

func ParseASObjectData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	rawData1, ok := raw[KEY_ACTIVITYSTREAMS_OBJECT]
	if !ok {
		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_OBJECT}
	}
	data, ok := rawData1.([]map[string]any)
	if !ok {
		return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_OBJECT, rawData1, data}
	}
	return &ASObjectData{Next: next, Objects: data}, nil
}

type ASPreferredNameData struct {
	FullValueType[string]
}

func (namedata *ASPreferredNameData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *ASPreferredNameData) MarshalToMap() map[string]any {
	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME)
}

func ParseASPreferredNameData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_PREFFEREDUSERNAME)
	if err != nil {
		return nil, err
	}
	return &ASPreferredNameData{*tmp}, nil
}

type ASPublishedData struct {
	Next      BaseApChain
	Timestamp time.Time
}

func (publisheddata *ASPublishedData) GetSelfOrBase() (BaseApChain, bool) {
	return publisheddata.Next, true
}

func (publisheddata *ASPublishedData) MarshalToMap() map[string]any {
	m := publisheddata.Next.MarshalToMap()
	m[KEY_ACTIVITYSTREAMS_PUBLISHED] = timeToXmlTime(publisheddata.Timestamp)
	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
	}
	delete(raw, KEY_ACTIVITYSTREAMS_PUBLISHED)
	return &ASPublishedData{
		Next:      next,
		Timestamp: t,
	}, nil
}

type ASRestrictedFollowData struct {
	FullValueType[bool]
}

func (namedata *ASRestrictedFollowData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *ASRestrictedFollowData) MarshalToMap() map[string]any {
	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW)
}

func ParseASRestrictedData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_ACTIVITYSTREAMS_RESTRICTED_FOLLOW)
	if err != nil {
		return nil, err
	}
	return &ASRestrictedFollowData{*tmp}, nil
}

type ASRepliesData struct {
	FullIdType
}

func (object *ASRepliesData) GetSelfOrBase() (BaseApChain, bool) {
	return object.FullIdType.Next, true
}

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
}

func (object *ASSharedInboxData) GetSelfOrBase() (BaseApChain, bool) {
	return object.FullIdType.Next, true
}

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 {
	FullValueType[string]
}

func (namedata *ASSummaryData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *ASSummaryData) MarshalToMap() map[string]any {
	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_SUMMARY)
}

func ParseASSummaryData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_SUMMARY)
	if err != nil {
		return nil, err
	}
	return &ASSummaryData{*tmp}, nil
}

type ASSensitiveData struct {
	FullValueType[bool]
}

func (namedata *ASSensitiveData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *ASSensitiveData) MarshalToMap() map[string]any {
	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_SENSITIVE)
}

func ParseASSensitiveData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	tmp, err := ParseValueTypeWithName[bool](raw, next, KEY_ACTIVITYSTREAMS_SENSITIVE)
	if err != nil {
		return nil, err
	}
	return &ASSensitiveData{*tmp}, nil
}

type ASTagData struct {
	Next BaseApChain
	Tags []Tag
}

func (tagdata *ASTagData) GetSelfOrBase() (BaseApChain, bool) {
	return tagdata.Next, true
}

func (tagdata *ASTagData) MarshalToMap() map[string]any {
	return appendWithKey(
		tagdata.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_TAG,
		sliceutils.Map(tagdata.Tags, func(t Tag) map[string]any {
			return t.Marshal()
		}),
	)
}

func ParseASTagData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	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 {
	Next    BaseApChain
	Targets []string
}

func (cc *ASToData) GetSelfOrBase() (BaseApChain, bool) {
	return cc.Next, true
}

func (cc *ASToData) MarshalToMap() map[string]any {
	return appendWithKey(
		cc.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_TO,
		sliceutils.Map(cc.Targets, func(t string) map[string]any {
			return map[string]any{KEY_ID: t}
		}),
	)
}

func ParseASToData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	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 {
	FullIdType
}

func (object *ASUrlData) GetSelfOrBase() (BaseApChain, bool) {
	return object.FullIdType.Next, true
}

func (object *ASUrlData) MarshalToMap() map[string]any {
	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_URL)
}

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
}

func (publisheddata *ASUpdatedData) GetSelfOrBase() (BaseApChain, bool) {
	return publisheddata.Next, true
}

func (publisheddata *ASUpdatedData) MarshalToMap() map[string]any {
	m := publisheddata.Next.MarshalToMap()
	m[KEY_ACTIVITYSTREAMS_UPDATED] = timeToXmlTime(publisheddata.Timestamp)
	return m
}

func ParseASUpdatedData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	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
}

type ASFirstData struct {
	Next BaseApChain
	// Technically the object is decodable into BaseApChain as well
	// but Go doesn't like the potential recursive call
	// So uhh, you have to do it yourself
	Objects map[string]any
}

func (a *ASFirstData) GetSelfOrBase() (BaseApChain, bool) {
	return a.Next, true
}

func (a *ASFirstData) MarshalToMap() map[string]any {
	return appendWithKey(
		a.Next.MarshalToMap(),
		KEY_ACTIVITYSTREAMS_FIRST,
		[]map[string]any{a.Objects},
	)
}

func ParseASFirstData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	rawData, ok := raw[KEY_ACTIVITYSTREAMS_FIRST]
	if !ok {
		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_FIRST}
	}
	data, ok := rawData.([]map[string]any)
	if !ok {
		return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_FIRST, rawData, data}
	}
	if len(data) != 1 {
		return nil, BadFieldArrayLengthError{KEY_ACTIVITYSTREAMS_FIRST, 1, len(data)}
	}
	delete(raw, KEY_ACTIVITYSTREAMS_FIRST)
	return &ASFirstData{
		Next:    next,
		Objects: data[0],
	}, nil
}

type ASItemsData struct {
	Next BaseApChain
	// Items are all AP objects, but can't preparse since Go doesn't like the potential recursion
	Items []map[string]any
}

func (a *ASItemsData) GetSelfOrBase() (BaseApChain, bool) {
	return a.Next, true
}

func (a *ASItemsData) MarshalToMap() map[string]any {
	return appendWithKey(a.Next.MarshalToMap(), KEY_ACTIVITYSTREAMS_ITEMS, a.Items)
}

func ParseASItemsData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	rawData, ok := raw[KEY_ACTIVITYSTREAMS_ITEMS]
	if !ok {
		return nil, NoRequiredFieldError{KEY_ACTIVITYSTREAMS_ITEMS}
	}
	data, ok := rawData.([]map[string]any)
	if !ok {
		return nil, BadFieldValueError[[]map[string]any]{KEY_ACTIVITYSTREAMS_ITEMS, rawData, data}
	}
	return &ASItemsData{Next: next, Items: data}, nil
}

type ASNextData struct {
	FullIdType
}

func (object *ASNextData) GetSelfOrBase() (BaseApChain, bool) {
	return object.FullIdType.Next, true
}

func (object *ASNextData) MarshalToMap() map[string]any {
	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_NEXT)
}

func ParseASNextData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_NEXT)
	if err != nil {
		return nil, err
	}
	return &ASNextData{FullIdType: *id}, nil
}

type ASPartOfData struct {
	FullIdType
}

func (object *ASPartOfData) GetSelfOrBase() (BaseApChain, bool) {
	return object.FullIdType.Next, true
}

func (object *ASPartOfData) MarshalToMap() map[string]any {
	return object.FullIdType.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_PARTOF)
}

func ParseASPartOfData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_PARTOF)
	if err != nil {
		return nil, err
	}
	return &ASPartOfData{FullIdType: *id}, nil
}

type ASInReplyTo struct {
	FullIdType
}

func (a *ASInReplyTo) GetSelfOrBase() (BaseApChain, bool) {
	return a.Next, true
}

func (a *ASInReplyTo) MarshalToMap() map[string]any {
	return a.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_INREPLYTO)
}

func ParseASInReplyToData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	id, err := ParseIdTypeWithName(raw, next, KEY_ACTIVITYSTREAMS_INREPLYTO)
	if err != nil {
		return nil, err
	}
	return &ASInReplyTo{*id}, nil
}

type ASQuoteUrlData struct {
	FullValueType[string]
}

func (namedata *ASQuoteUrlData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *ASQuoteUrlData) MarshalToMap() map[string]any {
	return namedata.MarshalToMapWithName(KEY_ACTIVITYSTREAMS_QUOTEURL)
}

func ParseASQuoteUrlData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_ACTIVITYSTREAMS_QUOTEURL)
	if err != nil {
		return nil, err
	}
	return &ASQuoteUrlData{*tmp}, nil
}