// Code generated by lexgen from lexicons/. DO NOT EDIT.

package market

import (
	"bytes"
	"encoding/json"
	"fmt"

	"github.com/bluesky-social/indigo/atproto/atdata"

	"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/b64"
)

type Record interface {
	NSID() string
}

func EncodeRecord(r Record) (map[string]any, error) {
	b, err := json.Marshal(r)
	if err != nil {
		return nil, err
	}
	return atdata.UnmarshalJSON(b)
}

func decodeRecord(value map[string]any, nsid string, out any) error {
	if got, _ := value["$type"].(string); got != nsid {
		return fmt.Errorf("%w: expected $type %s, got %q", ErrInvalidRecord, nsid, got)
	}
	b, err := json.Marshal(b64.NormalizeJSON(value))
	if err != nil {
		return fmt.Errorf("%w: %v", ErrInvalidRecord, err)
	}
	if err := json.Unmarshal(b, out); err != nil {
		return fmt.Errorf("%w: %v", ErrInvalidRecord, err)
	}
	if v, ok := out.(interface{ Validate() error }); ok {
		return v.Validate()
	}
	return nil
}

func marshalOpen(v any, extra, absent map[string]json.RawMessage) ([]byte, error) {
	b, err := json.Marshal(v)
	if err != nil || len(extra)+len(absent) == 0 {
		return b, err
	}
	fields := map[string]json.RawMessage{}
	if err := json.Unmarshal(b, &fields); err != nil {
		return nil, err
	}
	for k, raw := range absent {
		if bytes.Equal(fields[k], raw) {
			delete(fields, k)
		}
	}
	for k, raw := range extra {
		if _, ok := fields[k]; !ok {
			fields[k] = raw
		}
	}
	return json.Marshal(fields)
}

func unmarshalOpen(b []byte, v any) (extra, absent map[string]json.RawMessage, err error) {
	if err := json.Unmarshal(b, v); err != nil {
		return nil, nil, err
	}
	var in map[string]json.RawMessage
	if err := json.Unmarshal(b, &in); err != nil {
		return nil, nil, err
	}
	encoded, err := json.Marshal(v)
	if err != nil {
		return nil, nil, err
	}
	var kept map[string]json.RawMessage
	if err := json.Unmarshal(encoded, &kept); err != nil {
		return nil, nil, err
	}
	return missing(in, kept), missing(kept, in), nil
}

func missing(from, in map[string]json.RawMessage) map[string]json.RawMessage {
	var out map[string]json.RawMessage
	for k, raw := range from {
		if _, ok := in[k]; ok {
			continue
		}
		if out == nil {
			out = map[string]json.RawMessage{}
		}
		out[k] = raw
	}
	return out
}

type Accept struct {
	Type        string                     `json:"$type"`
	Bid         StrongRef                  `json:"bid"`
	CreatedAt   string                     `json:"createdAt,omitempty"`
	Ingress     []StrongRef                `json:"ingress,omitempty"`
	Payload     *StrongRef                 `json:"payload,omitempty"`
	RFP         StrongRef                  `json:"rfp"`
	Signatures  Signatures                 `json:"signatures,omitempty"`
	SubmitEvent string                     `json:"submitEvent,omitempty"`
	Extra       map[string]json.RawMessage `json:"-"`
	absent      map[string]json.RawMessage
}

func (Accept) NSID() string {
	return "com.publicdomainrelay.temp.market.accept"
}

func ParseAccept(value map[string]any) (*Accept, error) {
	var out Accept
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.accept", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v Accept) MarshalJSON() ([]byte, error) {
	type plain Accept
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.accept"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *Accept) UnmarshalJSON(b []byte) error {
	type plain Accept
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = Accept(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type AcceptsFree struct {
	Type       string                     `json:"$type"`
	Bid        StrongRef                  `json:"bid"`
	CreatedAt  string                     `json:"createdAt,omitempty"`
	Payload    *StrongRef                 `json:"payload,omitempty"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (AcceptsFree) NSID() string {
	return "com.publicdomainrelay.temp.market.accepts.free"
}

func ParseAcceptsFree(value map[string]any) (*AcceptsFree, error) {
	var out AcceptsFree
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.accepts.free", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v AcceptsFree) MarshalJSON() ([]byte, error) {
	type plain AcceptsFree
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.accepts.free"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *AcceptsFree) UnmarshalJSON(b []byte) error {
	type plain AcceptsFree
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = AcceptsFree(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type AcceptsX402 struct {
	Type       string                     `json:"$type"`
	Bid        StrongRef                  `json:"bid"`
	CreatedAt  string                     `json:"createdAt,omitempty"`
	Payload    *StrongRef                 `json:"payload,omitempty"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (AcceptsX402) NSID() string {
	return "com.publicdomainrelay.temp.market.accepts.x402"
}

func ParseAcceptsX402(value map[string]any) (*AcceptsX402, error) {
	var out AcceptsX402
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.accepts.x402", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v AcceptsX402) MarshalJSON() ([]byte, error) {
	type plain AcceptsX402
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.accepts.x402"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *AcceptsX402) UnmarshalJSON(b []byte) error {
	type plain AcceptsX402
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = AcceptsX402(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type Association struct {
	Type      string                     `json:"$type"`
	Contract  *StrongRef                 `json:"contract,omitempty"`
	CreatedAt string                     `json:"createdAt"`
	ExpiresAt string                     `json:"expiresAt,omitempty"`
	Note      string                     `json:"note,omitempty"`
	Parent    *StrongRef                 `json:"parent,omitempty"`
	Service   string                     `json:"service"`
	Subject   string                     `json:"subject"`
	Extra     map[string]json.RawMessage `json:"-"`
	absent    map[string]json.RawMessage
}

func (Association) NSID() string {
	return "com.publicdomainrelay.temp.market.association"
}

func ParseAssociation(value map[string]any) (*Association, error) {
	var out Association
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.association", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v Association) MarshalJSON() ([]byte, error) {
	type plain Association
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.association"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *Association) UnmarshalJSON(b []byte) error {
	type plain Association
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = Association(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type AssociationRequest struct {
	Type      string                     `json:"$type"`
	Authority string                     `json:"authority"`
	Contract  string                     `json:"contract"`
	CreatedAt string                     `json:"createdAt"`
	Nonce     string                     `json:"nonce"`
	Service   string                     `json:"service"`
	Extra     map[string]json.RawMessage `json:"-"`
	absent    map[string]json.RawMessage
}

func (AssociationRequest) NSID() string {
	return "com.publicdomainrelay.temp.market.associationRequest"
}

func ParseAssociationRequest(value map[string]any) (*AssociationRequest, error) {
	var out AssociationRequest
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.associationRequest", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v AssociationRequest) MarshalJSON() ([]byte, error) {
	type plain AssociationRequest
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.associationRequest"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *AssociationRequest) UnmarshalJSON(b []byte) error {
	type plain AssociationRequest
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = AssociationRequest(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type AttestedSignature struct {
	Type      string                     `json:"$type,omitempty"`
	CID       string                     `json:"cid"`
	IssuedAt  string                     `json:"issuedAt,omitempty"`
	Issuer    string                     `json:"issuer,omitempty"`
	Key       string                     `json:"key"`
	Role      string                     `json:"role,omitempty"`
	Signature atdata.Bytes               `json:"signature,omitempty"`
	Extra     map[string]json.RawMessage `json:"-"`
	absent    map[string]json.RawMessage
}

func (v AttestedSignature) MarshalJSON() ([]byte, error) {
	type plain AttestedSignature
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *AttestedSignature) UnmarshalJSON(b []byte) error {
	type plain AttestedSignature
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = AttestedSignature(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type BadgeBlueKeys struct {
	Type      string                     `json:"$type"`
	Challenge string                     `json:"challenge"`
	CreatedAt string                     `json:"createdAt"`
	KeyID     string                     `json:"keyId"`
	Name      string                     `json:"name,omitempty"`
	Nonce     string                     `json:"nonce,omitempty"`
	Proof     *StrongRef                 `json:"proof,omitempty"`
	Service   string                     `json:"service"`
	Extra     map[string]json.RawMessage `json:"-"`
	absent    map[string]json.RawMessage
}

func (BadgeBlueKeys) NSID() string {
	return "com.publicdomainrelay.temp.badgeBlueKeys"
}

func ParseBadgeBlueKeys(value map[string]any) (*BadgeBlueKeys, error) {
	var out BadgeBlueKeys
	if err := decodeRecord(value, "com.publicdomainrelay.temp.badgeBlueKeys", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v BadgeBlueKeys) MarshalJSON() ([]byte, error) {
	type plain BadgeBlueKeys
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.badgeBlueKeys"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *BadgeBlueKeys) UnmarshalJSON(b []byte) error {
	type plain BadgeBlueKeys
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = BadgeBlueKeys(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type Bid struct {
	Type         string                     `json:"$type"`
	Config       *StrongRef                 `json:"config,omitempty"`
	CreatedAt    string                     `json:"createdAt,omitempty"`
	Ingress      []StrongRef                `json:"ingress,omitempty"`
	Payload      StrongRef                  `json:"payload"`
	RFP          StrongRef                  `json:"rfp"`
	Signatures   Signatures                 `json:"signatures,omitempty"`
	SubmitAccept string                     `json:"submitAccept,omitempty"`
	Extra        map[string]json.RawMessage `json:"-"`
	absent       map[string]json.RawMessage
}

func (Bid) NSID() string {
	return "com.publicdomainrelay.temp.market.bid"
}

func ParseBid(value map[string]any) (*Bid, error) {
	var out Bid
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.bid", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v Bid) MarshalJSON() ([]byte, error) {
	type plain Bid
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.bid"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *Bid) UnmarshalJSON(b []byte) error {
	type plain Bid
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = Bid(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type BidsFree struct {
	Type       string                     `json:"$type"`
	Cost       int64                      `json:"cost,omitempty"`
	CreatedAt  string                     `json:"createdAt,omitempty"`
	Reason     string                     `json:"reason"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (BidsFree) NSID() string {
	return "com.publicdomainrelay.temp.market.bids.free"
}

func ParseBidsFree(value map[string]any) (*BidsFree, error) {
	var out BidsFree
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.bids.free", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v BidsFree) MarshalJSON() ([]byte, error) {
	type plain BidsFree
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.bids.free"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *BidsFree) UnmarshalJSON(b []byte) error {
	type plain BidsFree
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = BidsFree(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type BidsX402 struct {
	Type       string                     `json:"$type"`
	Cost       int64                      `json:"cost"`
	CreatedAt  string                     `json:"createdAt,omitempty"`
	Currency   string                     `json:"currency"`
	Frequency  string                     `json:"frequency"`
	Prepay     bool                       `json:"prepay"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	URL        string                     `json:"url"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (BidsX402) NSID() string {
	return "com.publicdomainrelay.temp.market.bids.x402"
}

func ParseBidsX402(value map[string]any) (*BidsX402, error) {
	var out BidsX402
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.bids.x402", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v BidsX402) MarshalJSON() ([]byte, error) {
	type plain BidsX402
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.bids.x402"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *BidsX402) UnmarshalJSON(b []byte) error {
	type plain BidsX402
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = BidsX402(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsGuestAgentStart struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsGuestAgentStart) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.guest.agentStart"
}

func ParseComputeEventsGuestAgentStart(value map[string]any) (*ComputeEventsGuestAgentStart, error) {
	var out ComputeEventsGuestAgentStart
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.guest.agentStart", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsGuestAgentStart) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsGuestAgentStart
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.guest.agentStart"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsGuestAgentStart) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsGuestAgentStart
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsGuestAgentStart(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsGuestPublicKey struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	Key        string                     `json:"key"`
	Kind       string                     `json:"kind"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Tag        string                     `json:"tag"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsGuestPublicKey) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.guest.publicKey"
}

func ParseComputeEventsGuestPublicKey(value map[string]any) (*ComputeEventsGuestPublicKey, error) {
	var out ComputeEventsGuestPublicKey
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.guest.publicKey", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsGuestPublicKey) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsGuestPublicKey
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.guest.publicKey"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsGuestPublicKey) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsGuestPublicKey
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsGuestPublicKey(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsGuestR2Release struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsGuestR2Release) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.guest.r2Release"
}

func ParseComputeEventsGuestR2Release(value map[string]any) (*ComputeEventsGuestR2Release, error) {
	var out ComputeEventsGuestR2Release
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.guest.r2Release", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsGuestR2Release) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsGuestR2Release
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.guest.r2Release"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsGuestR2Release) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsGuestR2Release
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsGuestR2Release(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsGuestR2Released struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	Message    string                     `json:"message,omitempty"`
	Ok         bool                       `json:"ok"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsGuestR2Released) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.guest.r2Released"
}

func ParseComputeEventsGuestR2Released(value map[string]any) (*ComputeEventsGuestR2Released, error) {
	var out ComputeEventsGuestR2Released
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.guest.r2Released", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsGuestR2Released) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsGuestR2Released
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.guest.r2Released"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsGuestR2Released) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsGuestR2Released
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsGuestR2Released(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsGuestR2Start struct {
	Type       string                     `json:"$type"`
	Agent      bool                       `json:"agent,omitempty"`
	CreatedAt  string                     `json:"createdAt"`
	Hold       bool                       `json:"hold,omitempty"`
	Name       string                     `json:"name"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsGuestR2Start) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.guest.r2Start"
}

func ParseComputeEventsGuestR2Start(value map[string]any) (*ComputeEventsGuestR2Start, error) {
	var out ComputeEventsGuestR2Start
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.guest.r2Start", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsGuestR2Start) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsGuestR2Start
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.guest.r2Start"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsGuestR2Start) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsGuestR2Start
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsGuestR2Start(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsGuestRequesterDID struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	DID        string                     `json:"did"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsGuestRequesterDID) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.guest.requesterDid"
}

func ParseComputeEventsGuestRequesterDID(value map[string]any) (*ComputeEventsGuestRequesterDID, error) {
	var out ComputeEventsGuestRequesterDID
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.guest.requesterDid", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsGuestRequesterDID) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsGuestRequesterDID
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.guest.requesterDid"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsGuestRequesterDID) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsGuestRequesterDID
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsGuestRequesterDID(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsGuestSecrets struct {
	Type       string                     `json:"$type"`
	Ciphertext string                     `json:"ciphertext"`
	CreatedAt  string                     `json:"createdAt"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsGuestSecrets) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.guest.secrets"
}

func ParseComputeEventsGuestSecrets(value map[string]any) (*ComputeEventsGuestSecrets, error) {
	var out ComputeEventsGuestSecrets
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.guest.secrets", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsGuestSecrets) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsGuestSecrets
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.guest.secrets"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsGuestSecrets) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsGuestSecrets
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsGuestSecrets(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsGuestSecretsApplied struct {
	Type       string                     `json:"$type"`
	Count      int64                      `json:"count,omitempty"`
	CreatedAt  string                     `json:"createdAt"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Via        string                     `json:"via"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsGuestSecretsApplied) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.guest.secretsApplied"
}

func ParseComputeEventsGuestSecretsApplied(value map[string]any) (*ComputeEventsGuestSecretsApplied, error) {
	var out ComputeEventsGuestSecretsApplied
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.guest.secretsApplied", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsGuestSecretsApplied) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsGuestSecretsApplied
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.guest.secretsApplied"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsGuestSecretsApplied) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsGuestSecretsApplied
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsGuestSecretsApplied(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsGuestSecretsRequested struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsGuestSecretsRequested) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.guest.secretsRequested"
}

func ParseComputeEventsGuestSecretsRequested(value map[string]any) (*ComputeEventsGuestSecretsRequested, error) {
	var out ComputeEventsGuestSecretsRequested
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.guest.secretsRequested", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsGuestSecretsRequested) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsGuestSecretsRequested
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.guest.secretsRequested"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsGuestSecretsRequested) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsGuestSecretsRequested
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsGuestSecretsRequested(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsGuestSecretsUpdated struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsGuestSecretsUpdated) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.guest.secretsUpdated"
}

func ParseComputeEventsGuestSecretsUpdated(value map[string]any) (*ComputeEventsGuestSecretsUpdated, error) {
	var out ComputeEventsGuestSecretsUpdated
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.guest.secretsUpdated", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsGuestSecretsUpdated) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsGuestSecretsUpdated
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.guest.secretsUpdated"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsGuestSecretsUpdated) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsGuestSecretsUpdated
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsGuestSecretsUpdated(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsGuestSignalWebRTC struct {
	Type       string                     `json:"$type"`
	Ciphertext string                     `json:"ciphertext"`
	CreatedAt  string                     `json:"createdAt"`
	Kind       string                     `json:"kind"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Tag        string                     `json:"tag"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsGuestSignalWebRTC) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.guest.signalWebRTC"
}

func ParseComputeEventsGuestSignalWebRTC(value map[string]any) (*ComputeEventsGuestSignalWebRTC, error) {
	var out ComputeEventsGuestSignalWebRTC
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.guest.signalWebRTC", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsGuestSignalWebRTC) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsGuestSignalWebRTC
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.guest.signalWebRTC"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsGuestSignalWebRTC) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsGuestSignalWebRTC
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsGuestSignalWebRTC(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsVMDelete struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	Reason     string                     `json:"reason"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsVMDelete) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.vm.delete"
}

func ParseComputeEventsVMDelete(value map[string]any) (*ComputeEventsVMDelete, error) {
	var out ComputeEventsVMDelete
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.vm.delete", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsVMDelete) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsVMDelete
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.vm.delete"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsVMDelete) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsVMDelete
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsVMDelete(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsVMHostKeys struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	Keys       []HostKey                  `json:"keys,omitempty"`
	ObservedAt string                     `json:"observedAt"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsVMHostKeys) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.vm.hostKeys"
}

func ParseComputeEventsVMHostKeys(value map[string]any) (*ComputeEventsVMHostKeys, error) {
	var out ComputeEventsVMHostKeys
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.vm.hostKeys", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsVMHostKeys) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsVMHostKeys
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.vm.hostKeys"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsVMHostKeys) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsVMHostKeys
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsVMHostKeys(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsVMOnNetwork struct {
	Type       string                     `json:"$type"`
	Address    string                     `json:"address,omitempty"`
	CreatedAt  string                     `json:"createdAt"`
	Kind       string                     `json:"kind,omitempty"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Tag        string                     `json:"tag,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsVMOnNetwork) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.vm.onNetwork"
}

func ParseComputeEventsVMOnNetwork(value map[string]any) (*ComputeEventsVMOnNetwork, error) {
	var out ComputeEventsVMOnNetwork
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.vm.onNetwork", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsVMOnNetwork) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsVMOnNetwork
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.vm.onNetwork"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsVMOnNetwork) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsVMOnNetwork
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsVMOnNetwork(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsVMRegisterIdentity struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsVMRegisterIdentity) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.vm.registerIdentity"
}

func ParseComputeEventsVMRegisterIdentity(value map[string]any) (*ComputeEventsVMRegisterIdentity, error) {
	var out ComputeEventsVMRegisterIdentity
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.vm.registerIdentity", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsVMRegisterIdentity) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsVMRegisterIdentity
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.vm.registerIdentity"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsVMRegisterIdentity) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsVMRegisterIdentity
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsVMRegisterIdentity(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsVMSandbox struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	ExitCode   int64                      `json:"exitCode"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Stderr     string                     `json:"stderr,omitempty"`
	Stdout     string                     `json:"stdout,omitempty"`
	TimedOut   bool                       `json:"timedOut,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsVMSandbox) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.vm.sandbox"
}

func ParseComputeEventsVMSandbox(value map[string]any) (*ComputeEventsVMSandbox, error) {
	var out ComputeEventsVMSandbox
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.vm.sandbox", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsVMSandbox) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsVMSandbox
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.vm.sandbox"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsVMSandbox) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsVMSandbox
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsVMSandbox(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsVMStarted struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	ObservedAt string                     `json:"observedAt,omitempty"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsVMStarted) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.vm.started"
}

func ParseComputeEventsVMStarted(value map[string]any) (*ComputeEventsVMStarted, error) {
	var out ComputeEventsVMStarted
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.vm.started", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsVMStarted) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsVMStarted
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.vm.started"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsVMStarted) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsVMStarted
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsVMStarted(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeEventsVMTerminated struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	ExitCode   int64                      `json:"exitCode,omitempty"`
	ObservedAt string                     `json:"observedAt"`
	Reason     string                     `json:"reason"`
	Request    *StrongRef                 `json:"request,omitempty"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ComputeEventsVMTerminated) NSID() string {
	return "com.publicdomainrelay.temp.compute.events.vm.terminated"
}

func ParseComputeEventsVMTerminated(value map[string]any) (*ComputeEventsVMTerminated, error) {
	var out ComputeEventsVMTerminated
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.events.vm.terminated", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeEventsVMTerminated) MarshalJSON() ([]byte, error) {
	type plain ComputeEventsVMTerminated
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.events.vm.terminated"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeEventsVMTerminated) UnmarshalJSON(b []byte) error {
	type plain ComputeEventsVMTerminated
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeEventsVMTerminated(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeGuestSubscribeEventsEvent struct {
	CID    string                     `json:"cid"`
	Record json.RawMessage            `json:"record,omitempty"`
	Seq    int64                      `json:"seq"`
	URI    string                     `json:"uri"`
	Extra  map[string]json.RawMessage `json:"-"`
	absent map[string]json.RawMessage
}

func (v ComputeGuestSubscribeEventsEvent) MarshalJSON() ([]byte, error) {
	type plain ComputeGuestSubscribeEventsEvent
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeGuestSubscribeEventsEvent) UnmarshalJSON(b []byte) error {
	type plain ComputeGuestSubscribeEventsEvent
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeGuestSubscribeEventsEvent(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeVM struct {
	Type      string                     `json:"$type"`
	Cpus      int64                      `json:"cpus,omitempty"`
	CreatedAt string                     `json:"createdAt,omitempty"`
	Disk      string                     `json:"disk,omitempty"`
	Kind      string                     `json:"kind,omitempty"`
	Location  *ComputeVMLocation         `json:"location,omitempty"`
	Mem       string                     `json:"mem,omitempty"`
	Network   string                     `json:"network,omitempty"`
	Role      string                     `json:"role"`
	UserData  string                     `json:"user_data,omitempty"`
	Extra     map[string]json.RawMessage `json:"-"`
	absent    map[string]json.RawMessage
}

func (ComputeVM) NSID() string {
	return "com.publicdomainrelay.temp.compute.vm"
}

func ParseComputeVM(value map[string]any) (*ComputeVM, error) {
	var out ComputeVM
	if err := decodeRecord(value, "com.publicdomainrelay.temp.compute.vm", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ComputeVM) MarshalJSON() ([]byte, error) {
	type plain ComputeVM
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.compute.vm"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeVM) UnmarshalJSON(b []byte) error {
	type plain ComputeVM
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeVM(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ComputeVMLocation struct {
	Country string                     `json:"country,omitempty"`
	Region  string                     `json:"region,omitempty"`
	Extra   map[string]json.RawMessage `json:"-"`
	absent  map[string]json.RawMessage
}

func (v ComputeVMLocation) MarshalJSON() ([]byte, error) {
	type plain ComputeVMLocation
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ComputeVMLocation) UnmarshalJSON(b []byte) error {
	type plain ComputeVMLocation
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ComputeVMLocation(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type Event struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt,omitempty"`
	Payload    StrongRef                  `json:"payload"`
	Receipt    StrongRef                  `json:"receipt"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (Event) NSID() string {
	return "com.publicdomainrelay.temp.market.event"
}

func ParseEvent(value map[string]any) (*Event, error) {
	var out Event
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.event", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v Event) MarshalJSON() ([]byte, error) {
	type plain Event
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.event"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *Event) UnmarshalJSON(b []byte) error {
	type plain Event
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = Event(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type Heartbeat struct {
	Type      string                     `json:"$type"`
	CreatedAt string                     `json:"createdAt"`
	Offering  string                     `json:"offering"`
	Extra     map[string]json.RawMessage `json:"-"`
	absent    map[string]json.RawMessage
}

func (Heartbeat) NSID() string {
	return "com.publicdomainrelay.temp.market.heartbeat"
}

func ParseHeartbeat(value map[string]any) (*Heartbeat, error) {
	var out Heartbeat
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.heartbeat", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v Heartbeat) MarshalJSON() ([]byte, error) {
	type plain Heartbeat
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.heartbeat"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *Heartbeat) UnmarshalJSON(b []byte) error {
	type plain Heartbeat
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = Heartbeat(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type HostKey struct {
	Fingerprint string                     `json:"fingerprint"`
	PublicKey   string                     `json:"publicKey"`
	Type        string                     `json:"type"`
	Extra       map[string]json.RawMessage `json:"-"`
	absent      map[string]json.RawMessage
}

func (v HostKey) MarshalJSON() ([]byte, error) {
	type plain HostKey
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *HostKey) UnmarshalJSON(b []byte) error {
	type plain HostKey
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = HostKey(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type IngressWebRTC struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt"`
	Descriptor *StrongRef                 `json:"descriptor,omitempty"`
	ID         string                     `json:"id"`
	Kind       string                     `json:"kind"`
	Mode       string                     `json:"mode"`
	Peer       string                     `json:"peer,omitempty"`
	Sdp        string                     `json:"sdp,omitempty"`
	Session    string                     `json:"session,omitempty"`
	StunUrls   []string                   `json:"stunUrls,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (IngressWebRTC) NSID() string {
	return "com.publicdomainrelay.temp.ingress.webRTC"
}

func ParseIngressWebRTC(value map[string]any) (*IngressWebRTC, error) {
	var out IngressWebRTC
	if err := decodeRecord(value, "com.publicdomainrelay.temp.ingress.webRTC", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v IngressWebRTC) MarshalJSON() ([]byte, error) {
	type plain IngressWebRTC
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.ingress.webRTC"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *IngressWebRTC) UnmarshalJSON(b []byte) error {
	type plain IngressWebRTC
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = IngressWebRTC(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type Offering struct {
	Type        string                     `json:"$type"`
	AppliesTo   []string                   `json:"appliesTo,omitempty"`
	CreatedAt   string                     `json:"createdAt"`
	EndpointURL string                     `json:"endpointUrl,omitempty"`
	Ingress     []StrongRef                `json:"ingress,omitempty"`
	RefreshedAt string                     `json:"refreshedAt,omitempty"`
	WithdrawnAt string                     `json:"withdrawnAt,omitempty"`
	Extra       map[string]json.RawMessage `json:"-"`
	absent      map[string]json.RawMessage
}

func (Offering) NSID() string {
	return "com.publicdomainrelay.temp.market.offering"
}

func ParseOffering(value map[string]any) (*Offering, error) {
	var out Offering
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.offering", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v Offering) MarshalJSON() ([]byte, error) {
	type plain Offering
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.offering"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *Offering) UnmarshalJSON(b []byte) error {
	type plain Offering
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = Offering(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type RFP struct {
	Type       string                     `json:"$type"`
	CreatedAt  string                     `json:"createdAt,omitempty"`
	Domain     string                     `json:"domain,omitempty"`
	Ingress    []StrongRef                `json:"ingress,omitempty"`
	Payload    StrongRef                  `json:"payload"`
	Policies   []StrongRef                `json:"policies,omitempty"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	SubmitBid  string                     `json:"submitBid,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (RFP) NSID() string {
	return "com.publicdomainrelay.temp.market.rfp"
}

func ParseRFP(value map[string]any) (*RFP, error) {
	var out RFP
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.rfp", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v RFP) MarshalJSON() ([]byte, error) {
	type plain RFP
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.rfp"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *RFP) UnmarshalJSON(b []byte) error {
	type plain RFP
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = RFP(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type Receipt struct {
	Type        string                     `json:"$type"`
	Accept      StrongRef                  `json:"accept"`
	Bid         StrongRef                  `json:"bid"`
	CID         string                     `json:"cid"`
	CreatedAt   string                     `json:"createdAt,omitempty"`
	Ingress     []StrongRef                `json:"ingress,omitempty"`
	Payload     *StrongRef                 `json:"payload,omitempty"`
	RFP         StrongRef                  `json:"rfp"`
	Signatures  Signatures                 `json:"signatures,omitempty"`
	SubmitEvent string                     `json:"submitEvent,omitempty"`
	Extra       map[string]json.RawMessage `json:"-"`
	absent      map[string]json.RawMessage
}

func (Receipt) NSID() string {
	return "com.publicdomainrelay.temp.market.receipt"
}

func ParseReceipt(value map[string]any) (*Receipt, error) {
	var out Receipt
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.receipt", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v Receipt) MarshalJSON() ([]byte, error) {
	type plain Receipt
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.receipt"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *Receipt) UnmarshalJSON(b []byte) error {
	type plain Receipt
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = Receipt(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ReceiptsFree struct {
	Type       string                     `json:"$type"`
	Accept     StrongRef                  `json:"accept"`
	CID        string                     `json:"cid"`
	CreatedAt  string                     `json:"createdAt,omitempty"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ReceiptsFree) NSID() string {
	return "com.publicdomainrelay.temp.market.receipts.free"
}

func ParseReceiptsFree(value map[string]any) (*ReceiptsFree, error) {
	var out ReceiptsFree
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.receipts.free", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ReceiptsFree) MarshalJSON() ([]byte, error) {
	type plain ReceiptsFree
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.receipts.free"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ReceiptsFree) UnmarshalJSON(b []byte) error {
	type plain ReceiptsFree
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ReceiptsFree(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type ReceiptsX402 struct {
	Type       string                     `json:"$type"`
	Accept     StrongRef                  `json:"accept"`
	CID        string                     `json:"cid"`
	CreatedAt  string                     `json:"createdAt,omitempty"`
	Signatures Signatures                 `json:"signatures,omitempty"`
	Extra      map[string]json.RawMessage `json:"-"`
	absent     map[string]json.RawMessage
}

func (ReceiptsX402) NSID() string {
	return "com.publicdomainrelay.temp.market.receipts.x402"
}

func ParseReceiptsX402(value map[string]any) (*ReceiptsX402, error) {
	var out ReceiptsX402
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.receipts.x402", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v ReceiptsX402) MarshalJSON() ([]byte, error) {
	type plain ReceiptsX402
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.receipts.x402"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *ReceiptsX402) UnmarshalJSON(b []byte) error {
	type plain ReceiptsX402
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = ReceiptsX402(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type Relays struct {
	Type      string                     `json:"$type"`
	CreatedAt string                     `json:"createdAt"`
	Relays    []string                   `json:"relays,omitempty"`
	Extra     map[string]json.RawMessage `json:"-"`
	absent    map[string]json.RawMessage
}

func (Relays) NSID() string {
	return "com.publicdomainrelay.temp.market.relays"
}

func ParseRelays(value map[string]any) (*Relays, error) {
	var out Relays
	if err := decodeRecord(value, "com.publicdomainrelay.temp.market.relays", &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (v Relays) MarshalJSON() ([]byte, error) {
	type plain Relays
	if v.Type == "" {
		v.Type = "com.publicdomainrelay.temp.market.relays"
	}
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *Relays) UnmarshalJSON(b []byte) error {
	type plain Relays
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = Relays(p)
	v.Extra = extra
	v.absent = absent
	return nil
}

type Signature struct {
	AttestedSignature *AttestedSignature
	StrongRef         *StrongRef
	Unknown           json.RawMessage
}

func (u Signature) MarshalJSON() ([]byte, error) {
	switch {
	case u.AttestedSignature != nil:
		v := *u.AttestedSignature
		if v.Type == "" {
			v.Type = "network.attested.signature"
		}
		return json.Marshal(v)
	case u.StrongRef != nil:
		v := *u.StrongRef
		if v.Type == "" {
			v.Type = "com.atproto.repo.strongRef"
		}
		return json.Marshal(v)
	case u.Unknown != nil:
		return u.Unknown, nil
	}
	return nil, fmt.Errorf("Signature: no variant is set")
}

func (u *Signature) UnmarshalJSON(b []byte) error {
	var head struct {
		Type string `json:"$type"`
	}
	if err := json.Unmarshal(b, &head); err != nil {
		return err
	}
	*u = Signature{}
	switch head.Type {
	case "network.attested.signature":
		u.AttestedSignature = new(AttestedSignature)
		return json.Unmarshal(b, u.AttestedSignature)
	case "com.atproto.repo.strongRef":
		u.StrongRef = new(StrongRef)
		return json.Unmarshal(b, u.StrongRef)
	default:
		u.Unknown = append(json.RawMessage(nil), b...)
		return nil
	}
}

type Signatures []Signature

type StrongRef struct {
	Type   string                     `json:"$type,omitempty"`
	CID    string                     `json:"cid"`
	URI    string                     `json:"uri"`
	Extra  map[string]json.RawMessage `json:"-"`
	absent map[string]json.RawMessage
}

func (v StrongRef) MarshalJSON() ([]byte, error) {
	type plain StrongRef
	return marshalOpen(plain(v), v.Extra, v.absent)
}

func (v *StrongRef) UnmarshalJSON(b []byte) error {
	type plain StrongRef
	var p plain
	extra, absent, err := unmarshalOpen(b, &p)
	if err != nil {
		return err
	}
	*v = StrongRef(p)
	v.Extra = extra
	v.absent = absent
	return nil
}