reference.go

// Code generated by Fern. DO NOT EDIT.

package generatorcli

import (
	json "encoding/json"
	fmt "fmt"
	internal "github.com/fern-api/generator-cli-go/internal"
	big "math/big"
)

var (
	endpointReferenceFieldTitle       = big.NewInt(1 << 0)
	endpointReferenceFieldDescription = big.NewInt(1 << 1)
	endpointReferenceFieldSnippet     = big.NewInt(1 << 2)
	endpointReferenceFieldParameters  = big.NewInt(1 << 3)
)

type EndpointReference struct {
	// The title is a code snippet that is shown when the endpoint's reference is collapsed.
	// For example, `client.subpackage.method({ ...params }) -> ReturnValue`.
	Title       *MethodInvocationSnippet `json:"title" url:"title"`
	Description *string                  `json:"description,omitempty" url:"description,omitempty"`
	// A "full" snippet, showing all the parameters, with a full example.
	// ```typescript
	//
	//	await client.subpackage.method({
	//	    expiresIn: 300,
	//	});
	//
	// ```
	Snippet    string                `json:"snippet" url:"snippet"`
	Parameters []*ParameterReference `json:"parameters" url:"parameters"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (e *EndpointReference) GetTitle() *MethodInvocationSnippet {
	if e == nil {
		return nil
	}
	return e.Title
}

func (e *EndpointReference) GetDescription() *string {
	if e == nil {
		return nil
	}
	return e.Description
}

func (e *EndpointReference) GetSnippet() string {
	if e == nil {
		return ""
	}
	return e.Snippet
}

func (e *EndpointReference) GetParameters() []*ParameterReference {
	if e == nil {
		return nil
	}
	return e.Parameters
}

func (e *EndpointReference) GetExtraProperties() map[string]interface{} {
	if e == nil {
		return nil
	}
	return e.extraProperties
}

func (e *EndpointReference) require(field *big.Int) {
	if e.explicitFields == nil {
		e.explicitFields = big.NewInt(0)
	}
	e.explicitFields.Or(e.explicitFields, field)
}

// SetTitle sets the Title field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (e *EndpointReference) SetTitle(title *MethodInvocationSnippet) {
	e.Title = title
	e.require(endpointReferenceFieldTitle)
}

// SetDescription sets the Description field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (e *EndpointReference) SetDescription(description *string) {
	e.Description = description
	e.require(endpointReferenceFieldDescription)
}

// SetSnippet sets the Snippet field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (e *EndpointReference) SetSnippet(snippet string) {
	e.Snippet = snippet
	e.require(endpointReferenceFieldSnippet)
}

// SetParameters sets the Parameters field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (e *EndpointReference) SetParameters(parameters []*ParameterReference) {
	e.Parameters = parameters
	e.require(endpointReferenceFieldParameters)
}

func (e *EndpointReference) UnmarshalJSON(data []byte) error {
	type unmarshaler EndpointReference
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*e = EndpointReference(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *e)
	if err != nil {
		return err
	}
	e.extraProperties = extraProperties
	e.rawJSON = json.RawMessage(data)
	return nil
}

func (e *EndpointReference) MarshalJSON() ([]byte, error) {
	type embed EndpointReference
	var marshaler = struct {
		embed
	}{
		embed: embed(*e),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, e.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (e *EndpointReference) String() string {
	if e == nil {
		return "<nil>"
	}
	if len(e.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(e.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(e); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", e)
}

type Language string

const (
	LanguageJava       Language = "JAVA"
	LanguagePython     Language = "PYTHON"
	LanguageGo         Language = "GO"
	LanguageRuby       Language = "RUBY"
	LanguageCsharp     Language = "CSHARP"
	LanguageTypescript Language = "TYPESCRIPT"
	LanguagePhp        Language = "PHP"
	LanguageRust       Language = "RUST"
	LanguageSwift      Language = "SWIFT"
)

func NewLanguageFromString(s string) (Language, error) {
	switch s {
	case "JAVA":
		return LanguageJava, nil
	case "PYTHON":
		return LanguagePython, nil
	case "GO":
		return LanguageGo, nil
	case "RUBY":
		return LanguageRuby, nil
	case "CSHARP":
		return LanguageCsharp, nil
	case "TYPESCRIPT":
		return LanguageTypescript, nil
	case "PHP":
		return LanguagePhp, nil
	case "RUST":
		return LanguageRust, nil
	case "SWIFT":
		return LanguageSwift, nil
	}
	var t Language
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (l Language) Ptr() *Language {
	return &l
}

var (
	linkedTextFieldText     = big.NewInt(1 << 0)
	linkedTextFieldLocation = big.NewInt(1 << 1)
)

type LinkedText struct {
	Text     string            `json:"text" url:"text"`
	Location *RelativeLocation `json:"location,omitempty" url:"location,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (l *LinkedText) GetText() string {
	if l == nil {
		return ""
	}
	return l.Text
}

func (l *LinkedText) GetLocation() *RelativeLocation {
	if l == nil {
		return nil
	}
	return l.Location
}

func (l *LinkedText) GetExtraProperties() map[string]interface{} {
	if l == nil {
		return nil
	}
	return l.extraProperties
}

func (l *LinkedText) require(field *big.Int) {
	if l.explicitFields == nil {
		l.explicitFields = big.NewInt(0)
	}
	l.explicitFields.Or(l.explicitFields, field)
}

// SetText sets the Text field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (l *LinkedText) SetText(text string) {
	l.Text = text
	l.require(linkedTextFieldText)
}

// SetLocation sets the Location field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (l *LinkedText) SetLocation(location *RelativeLocation) {
	l.Location = location
	l.require(linkedTextFieldLocation)
}

func (l *LinkedText) UnmarshalJSON(data []byte) error {
	type unmarshaler LinkedText
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*l = LinkedText(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *l)
	if err != nil {
		return err
	}
	l.extraProperties = extraProperties
	l.rawJSON = json.RawMessage(data)
	return nil
}

func (l *LinkedText) MarshalJSON() ([]byte, error) {
	type embed LinkedText
	var marshaler = struct {
		embed
	}{
		embed: embed(*l),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, l.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (l *LinkedText) String() string {
	if l == nil {
		return "<nil>"
	}
	if len(l.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(l.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(l); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", l)
}

// The method invocation snippet is one which appears when the endpoint's reference is collapsed.
// It is meant to give a high-level overview of the endpoint -- e.g. the method name and it's return value.
// The snippet itself should be a list of concatable content, which the CLI will handle hyperlinking. Note that this
// will essentially just be a "".join(snippetParts), so you must handle making sure the right `.`, etc. are in the parts.
// Note this is a separate object to make it easier to add additional properties down the road, for example if
// we wanted to be specific about what portion of the snippet we hyperlink, etc.
var (
	methodInvocationSnippetFieldSnippetParts = big.NewInt(1 << 0)
	methodInvocationSnippetFieldReturnValue  = big.NewInt(1 << 1)
)

type MethodInvocationSnippet struct {
	SnippetParts []*LinkedText `json:"snippetParts" url:"snippetParts"`
	ReturnValue  *LinkedText   `json:"returnValue,omitempty" url:"returnValue,omitempty"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (m *MethodInvocationSnippet) GetSnippetParts() []*LinkedText {
	if m == nil {
		return nil
	}
	return m.SnippetParts
}

func (m *MethodInvocationSnippet) GetReturnValue() *LinkedText {
	if m == nil {
		return nil
	}
	return m.ReturnValue
}

func (m *MethodInvocationSnippet) GetExtraProperties() map[string]interface{} {
	if m == nil {
		return nil
	}
	return m.extraProperties
}

func (m *MethodInvocationSnippet) require(field *big.Int) {
	if m.explicitFields == nil {
		m.explicitFields = big.NewInt(0)
	}
	m.explicitFields.Or(m.explicitFields, field)
}

// SetSnippetParts sets the SnippetParts field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (m *MethodInvocationSnippet) SetSnippetParts(snippetParts []*LinkedText) {
	m.SnippetParts = snippetParts
	m.require(methodInvocationSnippetFieldSnippetParts)
}

// SetReturnValue sets the ReturnValue field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (m *MethodInvocationSnippet) SetReturnValue(returnValue *LinkedText) {
	m.ReturnValue = returnValue
	m.require(methodInvocationSnippetFieldReturnValue)
}

func (m *MethodInvocationSnippet) UnmarshalJSON(data []byte) error {
	type unmarshaler MethodInvocationSnippet
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*m = MethodInvocationSnippet(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *m)
	if err != nil {
		return err
	}
	m.extraProperties = extraProperties
	m.rawJSON = json.RawMessage(data)
	return nil
}

func (m *MethodInvocationSnippet) MarshalJSON() ([]byte, error) {
	type embed MethodInvocationSnippet
	var marshaler = struct {
		embed
	}{
		embed: embed(*m),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, m.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (m *MethodInvocationSnippet) String() string {
	if m == nil {
		return "<nil>"
	}
	if len(m.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(m.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(m); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", m)
}

var (
	parameterReferenceFieldName        = big.NewInt(1 << 0)
	parameterReferenceFieldDescription = big.NewInt(1 << 1)
	parameterReferenceFieldLocation    = big.NewInt(1 << 2)
	parameterReferenceFieldType        = big.NewInt(1 << 3)
	parameterReferenceFieldRequired    = big.NewInt(1 << 4)
)

type ParameterReference struct {
	Name        string            `json:"name" url:"name"`
	Description *string           `json:"description,omitempty" url:"description,omitempty"`
	Location    *RelativeLocation `json:"location,omitempty" url:"location,omitempty"`
	Type        string            `json:"type" url:"type"`
	Required    bool              `json:"required" url:"required"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (p *ParameterReference) GetName() string {
	if p == nil {
		return ""
	}
	return p.Name
}

func (p *ParameterReference) GetDescription() *string {
	if p == nil {
		return nil
	}
	return p.Description
}

func (p *ParameterReference) GetLocation() *RelativeLocation {
	if p == nil {
		return nil
	}
	return p.Location
}

func (p *ParameterReference) GetType() string {
	if p == nil {
		return ""
	}
	return p.Type
}

func (p *ParameterReference) GetRequired() bool {
	if p == nil {
		return false
	}
	return p.Required
}

func (p *ParameterReference) GetExtraProperties() map[string]interface{} {
	if p == nil {
		return nil
	}
	return p.extraProperties
}

func (p *ParameterReference) require(field *big.Int) {
	if p.explicitFields == nil {
		p.explicitFields = big.NewInt(0)
	}
	p.explicitFields.Or(p.explicitFields, field)
}

// SetName sets the Name field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (p *ParameterReference) SetName(name string) {
	p.Name = name
	p.require(parameterReferenceFieldName)
}

// SetDescription sets the Description field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (p *ParameterReference) SetDescription(description *string) {
	p.Description = description
	p.require(parameterReferenceFieldDescription)
}

// SetLocation sets the Location field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (p *ParameterReference) SetLocation(location *RelativeLocation) {
	p.Location = location
	p.require(parameterReferenceFieldLocation)
}

// SetType sets the Type field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (p *ParameterReference) SetType(type_ string) {
	p.Type = type_
	p.require(parameterReferenceFieldType)
}

// SetRequired sets the Required field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (p *ParameterReference) SetRequired(required bool) {
	p.Required = required
	p.require(parameterReferenceFieldRequired)
}

func (p *ParameterReference) UnmarshalJSON(data []byte) error {
	type unmarshaler ParameterReference
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*p = ParameterReference(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *p)
	if err != nil {
		return err
	}
	p.extraProperties = extraProperties
	p.rawJSON = json.RawMessage(data)
	return nil
}

func (p *ParameterReference) MarshalJSON() ([]byte, error) {
	type embed ParameterReference
	var marshaler = struct {
		embed
	}{
		embed: embed(*p),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, p.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (p *ParameterReference) String() string {
	if p == nil {
		return "<nil>"
	}
	if len(p.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(p.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(p); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", p)
}

// The information to include within the `reference.md` file generated by the CLI.
// The information here should really be all defined by the generator, and not user provided.
// We intentionally keep this a bit flexible in the event SDKs structure their package/module
// references in a unique way for the same API.
var (
	referenceConfigFieldRootSection = big.NewInt(1 << 0)
	referenceConfigFieldSections    = big.NewInt(1 << 1)
	referenceConfigFieldLanguage    = big.NewInt(1 << 2)
)

type ReferenceConfig struct {
	RootSection *RootPackageReferenceSection `json:"rootSection,omitempty" url:"rootSection,omitempty"`
	Sections    []*ReferenceSection          `json:"sections" url:"sections"`
	// Similar to in README generation, the language property is used to determine the language to use when generating code blocks in markdown.
	Language Language `json:"language" url:"language"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (r *ReferenceConfig) GetRootSection() *RootPackageReferenceSection {
	if r == nil {
		return nil
	}
	return r.RootSection
}

func (r *ReferenceConfig) GetSections() []*ReferenceSection {
	if r == nil {
		return nil
	}
	return r.Sections
}

func (r *ReferenceConfig) GetLanguage() Language {
	if r == nil {
		return ""
	}
	return r.Language
}

func (r *ReferenceConfig) GetExtraProperties() map[string]interface{} {
	if r == nil {
		return nil
	}
	return r.extraProperties
}

func (r *ReferenceConfig) require(field *big.Int) {
	if r.explicitFields == nil {
		r.explicitFields = big.NewInt(0)
	}
	r.explicitFields.Or(r.explicitFields, field)
}

// SetRootSection sets the RootSection field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ReferenceConfig) SetRootSection(rootSection *RootPackageReferenceSection) {
	r.RootSection = rootSection
	r.require(referenceConfigFieldRootSection)
}

// SetSections sets the Sections field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ReferenceConfig) SetSections(sections []*ReferenceSection) {
	r.Sections = sections
	r.require(referenceConfigFieldSections)
}

// SetLanguage sets the Language field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ReferenceConfig) SetLanguage(language Language) {
	r.Language = language
	r.require(referenceConfigFieldLanguage)
}

func (r *ReferenceConfig) UnmarshalJSON(data []byte) error {
	type unmarshaler ReferenceConfig
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*r = ReferenceConfig(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *ReferenceConfig) MarshalJSON() ([]byte, error) {
	type embed ReferenceConfig
	var marshaler = struct {
		embed
	}{
		embed: embed(*r),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, r.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (r *ReferenceConfig) String() string {
	if r == nil {
		return "<nil>"
	}
	if len(r.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(r.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(r); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", r)
}

var (
	referenceSectionFieldTitle       = big.NewInt(1 << 0)
	referenceSectionFieldDescription = big.NewInt(1 << 1)
	referenceSectionFieldEndpoints   = big.NewInt(1 << 2)
)

type ReferenceSection struct {
	Title       string               `json:"title" url:"title"`
	Description *string              `json:"description,omitempty" url:"description,omitempty"`
	Endpoints   []*EndpointReference `json:"endpoints" url:"endpoints"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (r *ReferenceSection) GetTitle() string {
	if r == nil {
		return ""
	}
	return r.Title
}

func (r *ReferenceSection) GetDescription() *string {
	if r == nil {
		return nil
	}
	return r.Description
}

func (r *ReferenceSection) GetEndpoints() []*EndpointReference {
	if r == nil {
		return nil
	}
	return r.Endpoints
}

func (r *ReferenceSection) GetExtraProperties() map[string]interface{} {
	if r == nil {
		return nil
	}
	return r.extraProperties
}

func (r *ReferenceSection) require(field *big.Int) {
	if r.explicitFields == nil {
		r.explicitFields = big.NewInt(0)
	}
	r.explicitFields.Or(r.explicitFields, field)
}

// SetTitle sets the Title field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ReferenceSection) SetTitle(title string) {
	r.Title = title
	r.require(referenceSectionFieldTitle)
}

// SetDescription sets the Description field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ReferenceSection) SetDescription(description *string) {
	r.Description = description
	r.require(referenceSectionFieldDescription)
}

// SetEndpoints sets the Endpoints field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *ReferenceSection) SetEndpoints(endpoints []*EndpointReference) {
	r.Endpoints = endpoints
	r.require(referenceSectionFieldEndpoints)
}

func (r *ReferenceSection) UnmarshalJSON(data []byte) error {
	type unmarshaler ReferenceSection
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*r = ReferenceSection(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *ReferenceSection) MarshalJSON() ([]byte, error) {
	type embed ReferenceSection
	var marshaler = struct {
		embed
	}{
		embed: embed(*r),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, r.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (r *ReferenceSection) String() string {
	if r == nil {
		return "<nil>"
	}
	if len(r.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(r.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(r); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", r)
}

var (
	relativeLocationFieldPath = big.NewInt(1 << 0)
)

type RelativeLocation struct {
	// A relative location is a path to a file or directory relative to the root of the repository.
	// This is used to specify a link for a type or a function that the `reference.md` can point users to.
	Path string `json:"path" url:"path"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (r *RelativeLocation) GetPath() string {
	if r == nil {
		return ""
	}
	return r.Path
}

func (r *RelativeLocation) GetExtraProperties() map[string]interface{} {
	if r == nil {
		return nil
	}
	return r.extraProperties
}

func (r *RelativeLocation) require(field *big.Int) {
	if r.explicitFields == nil {
		r.explicitFields = big.NewInt(0)
	}
	r.explicitFields.Or(r.explicitFields, field)
}

// SetPath sets the Path field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *RelativeLocation) SetPath(path string) {
	r.Path = path
	r.require(relativeLocationFieldPath)
}

func (r *RelativeLocation) UnmarshalJSON(data []byte) error {
	type unmarshaler RelativeLocation
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*r = RelativeLocation(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *RelativeLocation) MarshalJSON() ([]byte, error) {
	type embed RelativeLocation
	var marshaler = struct {
		embed
	}{
		embed: embed(*r),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, r.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (r *RelativeLocation) String() string {
	if r == nil {
		return "<nil>"
	}
	if len(r.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(r.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(r); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", r)
}

var (
	rootPackageReferenceSectionFieldDescription = big.NewInt(1 << 0)
	rootPackageReferenceSectionFieldEndpoints   = big.NewInt(1 << 1)
)

type RootPackageReferenceSection struct {
	Description *string              `json:"description,omitempty" url:"description,omitempty"`
	Endpoints   []*EndpointReference `json:"endpoints" url:"endpoints"`

	// Private bitmask of fields set to an explicit value and therefore not to be omitted
	explicitFields *big.Int `json:"-" url:"-"`

	extraProperties map[string]interface{}
	rawJSON         json.RawMessage
}

func (r *RootPackageReferenceSection) GetDescription() *string {
	if r == nil {
		return nil
	}
	return r.Description
}

func (r *RootPackageReferenceSection) GetEndpoints() []*EndpointReference {
	if r == nil {
		return nil
	}
	return r.Endpoints
}

func (r *RootPackageReferenceSection) GetExtraProperties() map[string]interface{} {
	if r == nil {
		return nil
	}
	return r.extraProperties
}

func (r *RootPackageReferenceSection) require(field *big.Int) {
	if r.explicitFields == nil {
		r.explicitFields = big.NewInt(0)
	}
	r.explicitFields.Or(r.explicitFields, field)
}

// SetDescription sets the Description field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *RootPackageReferenceSection) SetDescription(description *string) {
	r.Description = description
	r.require(rootPackageReferenceSectionFieldDescription)
}

// SetEndpoints sets the Endpoints field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (r *RootPackageReferenceSection) SetEndpoints(endpoints []*EndpointReference) {
	r.Endpoints = endpoints
	r.require(rootPackageReferenceSectionFieldEndpoints)
}

func (r *RootPackageReferenceSection) UnmarshalJSON(data []byte) error {
	type unmarshaler RootPackageReferenceSection
	var value unmarshaler
	if err := json.Unmarshal(data, &value); err != nil {
		return err
	}
	*r = RootPackageReferenceSection(value)
	extraProperties, err := internal.ExtractExtraProperties(data, *r)
	if err != nil {
		return err
	}
	r.extraProperties = extraProperties
	r.rawJSON = json.RawMessage(data)
	return nil
}

func (r *RootPackageReferenceSection) MarshalJSON() ([]byte, error) {
	type embed RootPackageReferenceSection
	var marshaler = struct {
		embed
	}{
		embed: embed(*r),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, r.explicitFields)
	return json.Marshal(explicitMarshaler)
}

func (r *RootPackageReferenceSection) String() string {
	if r == nil {
		return "<nil>"
	}
	if len(r.rawJSON) > 0 {
		if value, err := internal.StringifyJSON(r.rawJSON); err == nil {
			return value
		}
	}
	if value, err := internal.StringifyJSON(r); err == nil {
		return value
	}
	return fmt.Sprintf("%#v", r)
}