feature.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"
)

// The configuration used to specify a generator's set of supported features.
// This is static data associated with a particular version of a generator, and
// is expected to be written as a static features.yml file in the generator's
// repository.
var (
	featureConfigFieldFeatures = big.NewInt(1 << 0)
)

type FeatureConfig struct {
	Features []*FeatureSpec `json:"features" url:"features"`

	// 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 (f *FeatureConfig) GetFeatures() []*FeatureSpec {
	if f == nil {
		return nil
	}
	return f.Features
}

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

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

// SetFeatures sets the Features field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (f *FeatureConfig) SetFeatures(features []*FeatureSpec) {
	f.Features = features
	f.require(featureConfigFieldFeatures)
}

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

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

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

// A unique identifier for a feature (e.g. OPTIONALS). This is typed as a freeform string
// to allow for arbitrary features, but callers are expected to use the StructuredFeatureId
// string representation whenever possible.
type FeatureId struct {
	String              string
	StructuredFeatureId StructuredFeatureId

	typ string
}

func (f *FeatureId) GetString() string {
	if f == nil {
		return ""
	}
	return f.String
}

func (f *FeatureId) GetStructuredFeatureId() StructuredFeatureId {
	if f == nil {
		return ""
	}
	return f.StructuredFeatureId
}

func (f *FeatureId) UnmarshalJSON(data []byte) error {
	var valueString string
	if err := json.Unmarshal(data, &valueString); err == nil {
		f.typ = "String"
		f.String = valueString
		return nil
	}
	var valueStructuredFeatureId StructuredFeatureId
	if err := json.Unmarshal(data, &valueStructuredFeatureId); err == nil {
		f.typ = "StructuredFeatureId"
		f.StructuredFeatureId = valueStructuredFeatureId
		return nil
	}
	return fmt.Errorf("%s cannot be deserialized as a %T", data, f)
}

func (f FeatureId) MarshalJSON() ([]byte, error) {
	if f.typ == "String" || f.String != "" {
		return json.Marshal(f.String)
	}
	if f.typ == "StructuredFeatureId" || f.StructuredFeatureId != "" {
		return json.Marshal(f.StructuredFeatureId)
	}
	return nil, fmt.Errorf("type %T does not include a non-empty union type", f)
}

type FeatureIdVisitor interface {
	VisitString(string) error
	VisitStructuredFeatureId(StructuredFeatureId) error
}

func (f *FeatureId) Accept(visitor FeatureIdVisitor) error {
	if f.typ == "String" || f.String != "" {
		return visitor.VisitString(f.String)
	}
	if f.typ == "StructuredFeatureId" || f.StructuredFeatureId != "" {
		return visitor.VisitStructuredFeatureId(f.StructuredFeatureId)
	}
	return fmt.Errorf("type %T does not include a non-empty union type", f)
}

// A specification for a feature supported by a generator. This includes the
// feature's ID, a description, and any additional information that should be
// included in the README.md.
var (
	featureSpecFieldId          = big.NewInt(1 << 0)
	featureSpecFieldDescription = big.NewInt(1 << 1)
	featureSpecFieldAddendum    = big.NewInt(1 << 2)
	featureSpecFieldAdvanced    = big.NewInt(1 << 3)
)

type FeatureSpec struct {
	Id          *FeatureId `json:"id" url:"id"`
	Description *string    `json:"description,omitempty" url:"description,omitempty"`
	Addendum    *string    `json:"addendum,omitempty" url:"addendum,omitempty"`
	Advanced    *bool      `json:"advanced,omitempty" url:"advanced,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 (f *FeatureSpec) GetId() *FeatureId {
	if f == nil {
		return nil
	}
	return f.Id
}

func (f *FeatureSpec) GetDescription() *string {
	if f == nil {
		return nil
	}
	return f.Description
}

func (f *FeatureSpec) GetAddendum() *string {
	if f == nil {
		return nil
	}
	return f.Addendum
}

func (f *FeatureSpec) GetAdvanced() *bool {
	if f == nil {
		return nil
	}
	return f.Advanced
}

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

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

// SetId sets the Id field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (f *FeatureSpec) SetId(id *FeatureId) {
	f.Id = id
	f.require(featureSpecFieldId)
}

// 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 (f *FeatureSpec) SetDescription(description *string) {
	f.Description = description
	f.require(featureSpecFieldDescription)
}

// SetAddendum sets the Addendum field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (f *FeatureSpec) SetAddendum(addendum *string) {
	f.Addendum = addendum
	f.require(featureSpecFieldAddendum)
}

// SetAdvanced sets the Advanced field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (f *FeatureSpec) SetAdvanced(advanced *bool) {
	f.Advanced = advanced
	f.require(featureSpecFieldAdvanced)
}

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

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

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

// Unique identifiers for features that can be demonstrated with snippets.
type StructuredFeatureId string

const (
	StructuredFeatureIdAuthentication StructuredFeatureId = "AUTHENTICATION"
	StructuredFeatureIdErrors         StructuredFeatureId = "ERRORS"
	StructuredFeatureIdUsage          StructuredFeatureId = "USAGE"
	StructuredFeatureIdPagination     StructuredFeatureId = "PAGINATION"
	StructuredFeatureIdRetries        StructuredFeatureId = "RETRIES"
	StructuredFeatureIdRequestOptions StructuredFeatureId = "REQUEST_OPTIONS"
	StructuredFeatureIdStreaming      StructuredFeatureId = "STREAMING"
	StructuredFeatureIdTimeouts       StructuredFeatureId = "TIMEOUTS"
	StructuredFeatureIdCustomClient   StructuredFeatureId = "CUSTOM_CLIENT"
	StructuredFeatureIdContributing   StructuredFeatureId = "CONTRIBUTING"
)

func NewStructuredFeatureIdFromString(s string) (StructuredFeatureId, error) {
	switch s {
	case "AUTHENTICATION":
		return StructuredFeatureIdAuthentication, nil
	case "ERRORS":
		return StructuredFeatureIdErrors, nil
	case "USAGE":
		return StructuredFeatureIdUsage, nil
	case "PAGINATION":
		return StructuredFeatureIdPagination, nil
	case "RETRIES":
		return StructuredFeatureIdRetries, nil
	case "REQUEST_OPTIONS":
		return StructuredFeatureIdRequestOptions, nil
	case "STREAMING":
		return StructuredFeatureIdStreaming, nil
	case "TIMEOUTS":
		return StructuredFeatureIdTimeouts, nil
	case "CUSTOM_CLIENT":
		return StructuredFeatureIdCustomClient, nil
	case "CONTRIBUTING":
		return StructuredFeatureIdContributing, nil
	}
	var t StructuredFeatureId
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (s StructuredFeatureId) Ptr() *StructuredFeatureId {
	return &s
}