// Code generated by Fern. DO NOT EDIT.

package api

import (
	json "encoding/json"
	fmt "fmt"
	big "math/big"
	internal "pentagi/pkg/observability/langfuse/api/internal"
	time "time"
)

var (
	createAnnotationQueueRequestFieldName           = big.NewInt(1 << 0)
	createAnnotationQueueRequestFieldDescription    = big.NewInt(1 << 1)
	createAnnotationQueueRequestFieldScoreConfigIDs = big.NewInt(1 << 2)
)

type CreateAnnotationQueueRequest struct {
	Name           string   `json:"name" url:"-"`
	Description    *string  `json:"description,omitempty" url:"-"`
	ScoreConfigIDs []string `json:"scoreConfigIds" url:"-"`

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

func (c *CreateAnnotationQueueRequest) require(field *big.Int) {
	if c.explicitFields == nil {
		c.explicitFields = big.NewInt(0)
	}
	c.explicitFields.Or(c.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 (c *CreateAnnotationQueueRequest) SetName(name string) {
	c.Name = name
	c.require(createAnnotationQueueRequestFieldName)
}

// 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 (c *CreateAnnotationQueueRequest) SetDescription(description *string) {
	c.Description = description
	c.require(createAnnotationQueueRequestFieldDescription)
}

// SetScoreConfigIDs sets the ScoreConfigIDs field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (c *CreateAnnotationQueueRequest) SetScoreConfigIDs(scoreConfigIDs []string) {
	c.ScoreConfigIDs = scoreConfigIDs
	c.require(createAnnotationQueueRequestFieldScoreConfigIDs)
}

func (c *CreateAnnotationQueueRequest) UnmarshalJSON(data []byte) error {
	type unmarshaler CreateAnnotationQueueRequest
	var body unmarshaler
	if err := json.Unmarshal(data, &body); err != nil {
		return err
	}
	*c = CreateAnnotationQueueRequest(body)
	return nil
}

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

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

type AnnotationQueuesCreateQueueAssignmentRequest struct {
	// The unique identifier of the annotation queue
	QueueID string                            `json:"-" url:"-"`
	Body    *AnnotationQueueAssignmentRequest `json:"-" url:"-"`

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

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

// SetQueueID sets the QueueID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesCreateQueueAssignmentRequest) SetQueueID(queueID string) {
	a.QueueID = queueID
	a.require(annotationQueuesCreateQueueAssignmentRequestFieldQueueID)
}

func (a *AnnotationQueuesCreateQueueAssignmentRequest) UnmarshalJSON(data []byte) error {
	body := new(AnnotationQueueAssignmentRequest)
	if err := json.Unmarshal(data, &body); err != nil {
		return err
	}
	a.Body = body
	return nil
}

func (a *AnnotationQueuesCreateQueueAssignmentRequest) MarshalJSON() ([]byte, error) {
	return json.Marshal(a.Body)
}

var (
	createAnnotationQueueItemRequestFieldQueueID    = big.NewInt(1 << 0)
	createAnnotationQueueItemRequestFieldObjectID   = big.NewInt(1 << 1)
	createAnnotationQueueItemRequestFieldObjectType = big.NewInt(1 << 2)
	createAnnotationQueueItemRequestFieldStatus     = big.NewInt(1 << 3)
)

type CreateAnnotationQueueItemRequest struct {
	// The unique identifier of the annotation queue
	QueueID    string                    `json:"-" url:"-"`
	ObjectID   string                    `json:"objectId" url:"-"`
	ObjectType AnnotationQueueObjectType `json:"objectType" url:"-"`
	// Defaults to PENDING for new queue items
	Status *AnnotationQueueStatus `json:"status,omitempty" url:"-"`

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

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

// SetQueueID sets the QueueID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (c *CreateAnnotationQueueItemRequest) SetQueueID(queueID string) {
	c.QueueID = queueID
	c.require(createAnnotationQueueItemRequestFieldQueueID)
}

// SetObjectID sets the ObjectID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (c *CreateAnnotationQueueItemRequest) SetObjectID(objectID string) {
	c.ObjectID = objectID
	c.require(createAnnotationQueueItemRequestFieldObjectID)
}

// SetObjectType sets the ObjectType field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (c *CreateAnnotationQueueItemRequest) SetObjectType(objectType AnnotationQueueObjectType) {
	c.ObjectType = objectType
	c.require(createAnnotationQueueItemRequestFieldObjectType)
}

// SetStatus sets the Status field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (c *CreateAnnotationQueueItemRequest) SetStatus(status *AnnotationQueueStatus) {
	c.Status = status
	c.require(createAnnotationQueueItemRequestFieldStatus)
}

func (c *CreateAnnotationQueueItemRequest) UnmarshalJSON(data []byte) error {
	type unmarshaler CreateAnnotationQueueItemRequest
	var body unmarshaler
	if err := json.Unmarshal(data, &body); err != nil {
		return err
	}
	*c = CreateAnnotationQueueItemRequest(body)
	return nil
}

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

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

type AnnotationQueuesDeleteQueueAssignmentRequest struct {
	// The unique identifier of the annotation queue
	QueueID string                            `json:"-" url:"-"`
	Body    *AnnotationQueueAssignmentRequest `json:"-" url:"-"`

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

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

// SetQueueID sets the QueueID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesDeleteQueueAssignmentRequest) SetQueueID(queueID string) {
	a.QueueID = queueID
	a.require(annotationQueuesDeleteQueueAssignmentRequestFieldQueueID)
}

func (a *AnnotationQueuesDeleteQueueAssignmentRequest) UnmarshalJSON(data []byte) error {
	body := new(AnnotationQueueAssignmentRequest)
	if err := json.Unmarshal(data, &body); err != nil {
		return err
	}
	a.Body = body
	return nil
}

func (a *AnnotationQueuesDeleteQueueAssignmentRequest) MarshalJSON() ([]byte, error) {
	return json.Marshal(a.Body)
}

var (
	annotationQueuesDeleteQueueItemRequestFieldQueueID = big.NewInt(1 << 0)
	annotationQueuesDeleteQueueItemRequestFieldItemID  = big.NewInt(1 << 1)
)

type AnnotationQueuesDeleteQueueItemRequest struct {
	// The unique identifier of the annotation queue
	QueueID string `json:"-" url:"-"`
	// The unique identifier of the annotation queue item
	ItemID string `json:"-" url:"-"`

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

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

// SetQueueID sets the QueueID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesDeleteQueueItemRequest) SetQueueID(queueID string) {
	a.QueueID = queueID
	a.require(annotationQueuesDeleteQueueItemRequestFieldQueueID)
}

// SetItemID sets the ItemID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesDeleteQueueItemRequest) SetItemID(itemID string) {
	a.ItemID = itemID
	a.require(annotationQueuesDeleteQueueItemRequestFieldItemID)
}

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

type AnnotationQueuesGetQueueRequest struct {
	// The unique identifier of the annotation queue
	QueueID string `json:"-" url:"-"`

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

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

// SetQueueID sets the QueueID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesGetQueueRequest) SetQueueID(queueID string) {
	a.QueueID = queueID
	a.require(annotationQueuesGetQueueRequestFieldQueueID)
}

var (
	annotationQueuesGetQueueItemRequestFieldQueueID = big.NewInt(1 << 0)
	annotationQueuesGetQueueItemRequestFieldItemID  = big.NewInt(1 << 1)
)

type AnnotationQueuesGetQueueItemRequest struct {
	// The unique identifier of the annotation queue
	QueueID string `json:"-" url:"-"`
	// The unique identifier of the annotation queue item
	ItemID string `json:"-" url:"-"`

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

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

// SetQueueID sets the QueueID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesGetQueueItemRequest) SetQueueID(queueID string) {
	a.QueueID = queueID
	a.require(annotationQueuesGetQueueItemRequestFieldQueueID)
}

// SetItemID sets the ItemID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesGetQueueItemRequest) SetItemID(itemID string) {
	a.ItemID = itemID
	a.require(annotationQueuesGetQueueItemRequestFieldItemID)
}

var (
	annotationQueuesListQueueItemsRequestFieldQueueID = big.NewInt(1 << 0)
	annotationQueuesListQueueItemsRequestFieldStatus  = big.NewInt(1 << 1)
	annotationQueuesListQueueItemsRequestFieldPage    = big.NewInt(1 << 2)
	annotationQueuesListQueueItemsRequestFieldLimit   = big.NewInt(1 << 3)
)

type AnnotationQueuesListQueueItemsRequest struct {
	// The unique identifier of the annotation queue
	QueueID string `json:"-" url:"-"`
	// Filter by status
	Status *AnnotationQueueStatus `json:"-" url:"status,omitempty"`
	// page number, starts at 1
	Page *int `json:"-" url:"page,omitempty"`
	// limit of items per page
	Limit *int `json:"-" url:"limit,omitempty"`

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

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

// SetQueueID sets the QueueID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesListQueueItemsRequest) SetQueueID(queueID string) {
	a.QueueID = queueID
	a.require(annotationQueuesListQueueItemsRequestFieldQueueID)
}

// SetStatus sets the Status field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesListQueueItemsRequest) SetStatus(status *AnnotationQueueStatus) {
	a.Status = status
	a.require(annotationQueuesListQueueItemsRequestFieldStatus)
}

// SetPage sets the Page field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesListQueueItemsRequest) SetPage(page *int) {
	a.Page = page
	a.require(annotationQueuesListQueueItemsRequestFieldPage)
}

// SetLimit sets the Limit field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesListQueueItemsRequest) SetLimit(limit *int) {
	a.Limit = limit
	a.require(annotationQueuesListQueueItemsRequestFieldLimit)
}

var (
	annotationQueuesListQueuesRequestFieldPage  = big.NewInt(1 << 0)
	annotationQueuesListQueuesRequestFieldLimit = big.NewInt(1 << 1)
)

type AnnotationQueuesListQueuesRequest struct {
	// page number, starts at 1
	Page *int `json:"-" url:"page,omitempty"`
	// limit of items per page
	Limit *int `json:"-" url:"limit,omitempty"`

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

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

// SetPage sets the Page field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesListQueuesRequest) SetPage(page *int) {
	a.Page = page
	a.require(annotationQueuesListQueuesRequestFieldPage)
}

// SetLimit sets the Limit field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueuesListQueuesRequest) SetLimit(limit *int) {
	a.Limit = limit
	a.require(annotationQueuesListQueuesRequestFieldLimit)
}

var (
	annotationQueueFieldID             = big.NewInt(1 << 0)
	annotationQueueFieldName           = big.NewInt(1 << 1)
	annotationQueueFieldDescription    = big.NewInt(1 << 2)
	annotationQueueFieldScoreConfigIDs = big.NewInt(1 << 3)
	annotationQueueFieldCreatedAt      = big.NewInt(1 << 4)
	annotationQueueFieldUpdatedAt      = big.NewInt(1 << 5)
)

type AnnotationQueue struct {
	ID             string    `json:"id" url:"id"`
	Name           string    `json:"name" url:"name"`
	Description    *string   `json:"description,omitempty" url:"description,omitempty"`
	ScoreConfigIDs []string  `json:"scoreConfigIds" url:"scoreConfigIds"`
	CreatedAt      time.Time `json:"createdAt" url:"createdAt"`
	UpdatedAt      time.Time `json:"updatedAt" url:"updatedAt"`

	// 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 (a *AnnotationQueue) GetID() string {
	if a == nil {
		return ""
	}
	return a.ID
}

func (a *AnnotationQueue) GetName() string {
	if a == nil {
		return ""
	}
	return a.Name
}

func (a *AnnotationQueue) GetDescription() *string {
	if a == nil {
		return nil
	}
	return a.Description
}

func (a *AnnotationQueue) GetScoreConfigIDs() []string {
	if a == nil {
		return nil
	}
	return a.ScoreConfigIDs
}

func (a *AnnotationQueue) GetCreatedAt() time.Time {
	if a == nil {
		return time.Time{}
	}
	return a.CreatedAt
}

func (a *AnnotationQueue) GetUpdatedAt() time.Time {
	if a == nil {
		return time.Time{}
	}
	return a.UpdatedAt
}

func (a *AnnotationQueue) GetExtraProperties() map[string]interface{} {
	return a.extraProperties
}

func (a *AnnotationQueue) require(field *big.Int) {
	if a.explicitFields == nil {
		a.explicitFields = big.NewInt(0)
	}
	a.explicitFields.Or(a.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 (a *AnnotationQueue) SetID(id string) {
	a.ID = id
	a.require(annotationQueueFieldID)
}

// 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 (a *AnnotationQueue) SetName(name string) {
	a.Name = name
	a.require(annotationQueueFieldName)
}

// 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 (a *AnnotationQueue) SetDescription(description *string) {
	a.Description = description
	a.require(annotationQueueFieldDescription)
}

// SetScoreConfigIDs sets the ScoreConfigIDs field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueue) SetScoreConfigIDs(scoreConfigIDs []string) {
	a.ScoreConfigIDs = scoreConfigIDs
	a.require(annotationQueueFieldScoreConfigIDs)
}

// SetCreatedAt sets the CreatedAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueue) SetCreatedAt(createdAt time.Time) {
	a.CreatedAt = createdAt
	a.require(annotationQueueFieldCreatedAt)
}

// SetUpdatedAt sets the UpdatedAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueue) SetUpdatedAt(updatedAt time.Time) {
	a.UpdatedAt = updatedAt
	a.require(annotationQueueFieldUpdatedAt)
}

func (a *AnnotationQueue) UnmarshalJSON(data []byte) error {
	type embed AnnotationQueue
	var unmarshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"createdAt"`
		UpdatedAt *internal.DateTime `json:"updatedAt"`
	}{
		embed: embed(*a),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*a = AnnotationQueue(unmarshaler.embed)
	a.CreatedAt = unmarshaler.CreatedAt.Time()
	a.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *a)
	if err != nil {
		return err
	}
	a.extraProperties = extraProperties
	a.rawJSON = json.RawMessage(data)
	return nil
}

func (a *AnnotationQueue) MarshalJSON() ([]byte, error) {
	type embed AnnotationQueue
	var marshaler = struct {
		embed
		CreatedAt *internal.DateTime `json:"createdAt"`
		UpdatedAt *internal.DateTime `json:"updatedAt"`
	}{
		embed:     embed(*a),
		CreatedAt: internal.NewDateTime(a.CreatedAt),
		UpdatedAt: internal.NewDateTime(a.UpdatedAt),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, a.explicitFields)
	return json.Marshal(explicitMarshaler)
}

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

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

type AnnotationQueueAssignmentRequest struct {
	UserID string `json:"userId" url:"userId"`

	// 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 (a *AnnotationQueueAssignmentRequest) GetUserID() string {
	if a == nil {
		return ""
	}
	return a.UserID
}

func (a *AnnotationQueueAssignmentRequest) GetExtraProperties() map[string]interface{} {
	return a.extraProperties
}

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

// SetUserID sets the UserID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueueAssignmentRequest) SetUserID(userID string) {
	a.UserID = userID
	a.require(annotationQueueAssignmentRequestFieldUserID)
}

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

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

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

var (
	annotationQueueItemFieldID          = big.NewInt(1 << 0)
	annotationQueueItemFieldQueueID     = big.NewInt(1 << 1)
	annotationQueueItemFieldObjectID    = big.NewInt(1 << 2)
	annotationQueueItemFieldObjectType  = big.NewInt(1 << 3)
	annotationQueueItemFieldStatus      = big.NewInt(1 << 4)
	annotationQueueItemFieldCompletedAt = big.NewInt(1 << 5)
	annotationQueueItemFieldCreatedAt   = big.NewInt(1 << 6)
	annotationQueueItemFieldUpdatedAt   = big.NewInt(1 << 7)
)

type AnnotationQueueItem struct {
	ID          string                    `json:"id" url:"id"`
	QueueID     string                    `json:"queueId" url:"queueId"`
	ObjectID    string                    `json:"objectId" url:"objectId"`
	ObjectType  AnnotationQueueObjectType `json:"objectType" url:"objectType"`
	Status      AnnotationQueueStatus     `json:"status" url:"status"`
	CompletedAt *time.Time                `json:"completedAt,omitempty" url:"completedAt,omitempty"`
	CreatedAt   time.Time                 `json:"createdAt" url:"createdAt"`
	UpdatedAt   time.Time                 `json:"updatedAt" url:"updatedAt"`

	// 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 (a *AnnotationQueueItem) GetID() string {
	if a == nil {
		return ""
	}
	return a.ID
}

func (a *AnnotationQueueItem) GetQueueID() string {
	if a == nil {
		return ""
	}
	return a.QueueID
}

func (a *AnnotationQueueItem) GetObjectID() string {
	if a == nil {
		return ""
	}
	return a.ObjectID
}

func (a *AnnotationQueueItem) GetObjectType() AnnotationQueueObjectType {
	if a == nil {
		return ""
	}
	return a.ObjectType
}

func (a *AnnotationQueueItem) GetStatus() AnnotationQueueStatus {
	if a == nil {
		return ""
	}
	return a.Status
}

func (a *AnnotationQueueItem) GetCompletedAt() *time.Time {
	if a == nil {
		return nil
	}
	return a.CompletedAt
}

func (a *AnnotationQueueItem) GetCreatedAt() time.Time {
	if a == nil {
		return time.Time{}
	}
	return a.CreatedAt
}

func (a *AnnotationQueueItem) GetUpdatedAt() time.Time {
	if a == nil {
		return time.Time{}
	}
	return a.UpdatedAt
}

func (a *AnnotationQueueItem) GetExtraProperties() map[string]interface{} {
	return a.extraProperties
}

func (a *AnnotationQueueItem) require(field *big.Int) {
	if a.explicitFields == nil {
		a.explicitFields = big.NewInt(0)
	}
	a.explicitFields.Or(a.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 (a *AnnotationQueueItem) SetID(id string) {
	a.ID = id
	a.require(annotationQueueItemFieldID)
}

// SetQueueID sets the QueueID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueueItem) SetQueueID(queueID string) {
	a.QueueID = queueID
	a.require(annotationQueueItemFieldQueueID)
}

// SetObjectID sets the ObjectID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueueItem) SetObjectID(objectID string) {
	a.ObjectID = objectID
	a.require(annotationQueueItemFieldObjectID)
}

// SetObjectType sets the ObjectType field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueueItem) SetObjectType(objectType AnnotationQueueObjectType) {
	a.ObjectType = objectType
	a.require(annotationQueueItemFieldObjectType)
}

// SetStatus sets the Status field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueueItem) SetStatus(status AnnotationQueueStatus) {
	a.Status = status
	a.require(annotationQueueItemFieldStatus)
}

// SetCompletedAt sets the CompletedAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueueItem) SetCompletedAt(completedAt *time.Time) {
	a.CompletedAt = completedAt
	a.require(annotationQueueItemFieldCompletedAt)
}

// SetCreatedAt sets the CreatedAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueueItem) SetCreatedAt(createdAt time.Time) {
	a.CreatedAt = createdAt
	a.require(annotationQueueItemFieldCreatedAt)
}

// SetUpdatedAt sets the UpdatedAt field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (a *AnnotationQueueItem) SetUpdatedAt(updatedAt time.Time) {
	a.UpdatedAt = updatedAt
	a.require(annotationQueueItemFieldUpdatedAt)
}

func (a *AnnotationQueueItem) UnmarshalJSON(data []byte) error {
	type embed AnnotationQueueItem
	var unmarshaler = struct {
		embed
		CompletedAt *internal.DateTime `json:"completedAt,omitempty"`
		CreatedAt   *internal.DateTime `json:"createdAt"`
		UpdatedAt   *internal.DateTime `json:"updatedAt"`
	}{
		embed: embed(*a),
	}
	if err := json.Unmarshal(data, &unmarshaler); err != nil {
		return err
	}
	*a = AnnotationQueueItem(unmarshaler.embed)
	a.CompletedAt = unmarshaler.CompletedAt.TimePtr()
	a.CreatedAt = unmarshaler.CreatedAt.Time()
	a.UpdatedAt = unmarshaler.UpdatedAt.Time()
	extraProperties, err := internal.ExtractExtraProperties(data, *a)
	if err != nil {
		return err
	}
	a.extraProperties = extraProperties
	a.rawJSON = json.RawMessage(data)
	return nil
}

func (a *AnnotationQueueItem) MarshalJSON() ([]byte, error) {
	type embed AnnotationQueueItem
	var marshaler = struct {
		embed
		CompletedAt *internal.DateTime `json:"completedAt,omitempty"`
		CreatedAt   *internal.DateTime `json:"createdAt"`
		UpdatedAt   *internal.DateTime `json:"updatedAt"`
	}{
		embed:       embed(*a),
		CompletedAt: internal.NewOptionalDateTime(a.CompletedAt),
		CreatedAt:   internal.NewDateTime(a.CreatedAt),
		UpdatedAt:   internal.NewDateTime(a.UpdatedAt),
	}
	explicitMarshaler := internal.HandleExplicitFields(marshaler, a.explicitFields)
	return json.Marshal(explicitMarshaler)
}

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

type AnnotationQueueObjectType string

const (
	AnnotationQueueObjectTypeTrace       AnnotationQueueObjectType = "TRACE"
	AnnotationQueueObjectTypeObservation AnnotationQueueObjectType = "OBSERVATION"
	AnnotationQueueObjectTypeSession     AnnotationQueueObjectType = "SESSION"
)

func NewAnnotationQueueObjectTypeFromString(s string) (AnnotationQueueObjectType, error) {
	switch s {
	case "TRACE":
		return AnnotationQueueObjectTypeTrace, nil
	case "OBSERVATION":
		return AnnotationQueueObjectTypeObservation, nil
	case "SESSION":
		return AnnotationQueueObjectTypeSession, nil
	}
	var t AnnotationQueueObjectType
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AnnotationQueueObjectType) Ptr() *AnnotationQueueObjectType {
	return &a
}

type AnnotationQueueStatus string

const (
	AnnotationQueueStatusPending   AnnotationQueueStatus = "PENDING"
	AnnotationQueueStatusCompleted AnnotationQueueStatus = "COMPLETED"
)

func NewAnnotationQueueStatusFromString(s string) (AnnotationQueueStatus, error) {
	switch s {
	case "PENDING":
		return AnnotationQueueStatusPending, nil
	case "COMPLETED":
		return AnnotationQueueStatusCompleted, nil
	}
	var t AnnotationQueueStatus
	return "", fmt.Errorf("%s is not a valid %T", s, t)
}

func (a AnnotationQueueStatus) Ptr() *AnnotationQueueStatus {
	return &a
}

var (
	createAnnotationQueueAssignmentResponseFieldUserID    = big.NewInt(1 << 0)
	createAnnotationQueueAssignmentResponseFieldQueueID   = big.NewInt(1 << 1)
	createAnnotationQueueAssignmentResponseFieldProjectID = big.NewInt(1 << 2)
)

type CreateAnnotationQueueAssignmentResponse struct {
	UserID    string `json:"userId" url:"userId"`
	QueueID   string `json:"queueId" url:"queueId"`
	ProjectID string `json:"projectId" url:"projectId"`

	// 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 (c *CreateAnnotationQueueAssignmentResponse) GetUserID() string {
	if c == nil {
		return ""
	}
	return c.UserID
}

func (c *CreateAnnotationQueueAssignmentResponse) GetQueueID() string {
	if c == nil {
		return ""
	}
	return c.QueueID
}

func (c *CreateAnnotationQueueAssignmentResponse) GetProjectID() string {
	if c == nil {
		return ""
	}
	return c.ProjectID
}

func (c *CreateAnnotationQueueAssignmentResponse) GetExtraProperties() map[string]interface{} {
	return c.extraProperties
}

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

// SetUserID sets the UserID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (c *CreateAnnotationQueueAssignmentResponse) SetUserID(userID string) {
	c.UserID = userID
	c.require(createAnnotationQueueAssignmentResponseFieldUserID)
}

// SetQueueID sets the QueueID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (c *CreateAnnotationQueueAssignmentResponse) SetQueueID(queueID string) {
	c.QueueID = queueID
	c.require(createAnnotationQueueAssignmentResponseFieldQueueID)
}

// SetProjectID sets the ProjectID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (c *CreateAnnotationQueueAssignmentResponse) SetProjectID(projectID string) {
	c.ProjectID = projectID
	c.require(createAnnotationQueueAssignmentResponseFieldProjectID)
}

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

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

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

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

type DeleteAnnotationQueueAssignmentResponse struct {
	Success bool `json:"success" url:"success"`

	// 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 (d *DeleteAnnotationQueueAssignmentResponse) GetSuccess() bool {
	if d == nil {
		return false
	}
	return d.Success
}

func (d *DeleteAnnotationQueueAssignmentResponse) GetExtraProperties() map[string]interface{} {
	return d.extraProperties
}

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

// SetSuccess sets the Success field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DeleteAnnotationQueueAssignmentResponse) SetSuccess(success bool) {
	d.Success = success
	d.require(deleteAnnotationQueueAssignmentResponseFieldSuccess)
}

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

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

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

var (
	deleteAnnotationQueueItemResponseFieldSuccess = big.NewInt(1 << 0)
	deleteAnnotationQueueItemResponseFieldMessage = big.NewInt(1 << 1)
)

type DeleteAnnotationQueueItemResponse struct {
	Success bool   `json:"success" url:"success"`
	Message string `json:"message" url:"message"`

	// 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 (d *DeleteAnnotationQueueItemResponse) GetSuccess() bool {
	if d == nil {
		return false
	}
	return d.Success
}

func (d *DeleteAnnotationQueueItemResponse) GetMessage() string {
	if d == nil {
		return ""
	}
	return d.Message
}

func (d *DeleteAnnotationQueueItemResponse) GetExtraProperties() map[string]interface{} {
	return d.extraProperties
}

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

// SetSuccess sets the Success field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DeleteAnnotationQueueItemResponse) SetSuccess(success bool) {
	d.Success = success
	d.require(deleteAnnotationQueueItemResponseFieldSuccess)
}

// SetMessage sets the Message field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (d *DeleteAnnotationQueueItemResponse) SetMessage(message string) {
	d.Message = message
	d.require(deleteAnnotationQueueItemResponseFieldMessage)
}

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

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

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

var (
	paginatedAnnotationQueueItemsFieldData = big.NewInt(1 << 0)
	paginatedAnnotationQueueItemsFieldMeta = big.NewInt(1 << 1)
)

type PaginatedAnnotationQueueItems struct {
	Data []*AnnotationQueueItem `json:"data" url:"data"`
	Meta *UtilsMetaResponse     `json:"meta" url:"meta"`

	// 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 *PaginatedAnnotationQueueItems) GetData() []*AnnotationQueueItem {
	if p == nil {
		return nil
	}
	return p.Data
}

func (p *PaginatedAnnotationQueueItems) GetMeta() *UtilsMetaResponse {
	if p == nil {
		return nil
	}
	return p.Meta
}

func (p *PaginatedAnnotationQueueItems) GetExtraProperties() map[string]interface{} {
	return p.extraProperties
}

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

// SetData sets the Data field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (p *PaginatedAnnotationQueueItems) SetData(data []*AnnotationQueueItem) {
	p.Data = data
	p.require(paginatedAnnotationQueueItemsFieldData)
}

// SetMeta sets the Meta field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (p *PaginatedAnnotationQueueItems) SetMeta(meta *UtilsMetaResponse) {
	p.Meta = meta
	p.require(paginatedAnnotationQueueItemsFieldMeta)
}

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

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

func (p *PaginatedAnnotationQueueItems) String() string {
	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)
}

var (
	paginatedAnnotationQueuesFieldData = big.NewInt(1 << 0)
	paginatedAnnotationQueuesFieldMeta = big.NewInt(1 << 1)
)

type PaginatedAnnotationQueues struct {
	Data []*AnnotationQueue `json:"data" url:"data"`
	Meta *UtilsMetaResponse `json:"meta" url:"meta"`

	// 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 *PaginatedAnnotationQueues) GetData() []*AnnotationQueue {
	if p == nil {
		return nil
	}
	return p.Data
}

func (p *PaginatedAnnotationQueues) GetMeta() *UtilsMetaResponse {
	if p == nil {
		return nil
	}
	return p.Meta
}

func (p *PaginatedAnnotationQueues) GetExtraProperties() map[string]interface{} {
	return p.extraProperties
}

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

// SetData sets the Data field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (p *PaginatedAnnotationQueues) SetData(data []*AnnotationQueue) {
	p.Data = data
	p.require(paginatedAnnotationQueuesFieldData)
}

// SetMeta sets the Meta field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (p *PaginatedAnnotationQueues) SetMeta(meta *UtilsMetaResponse) {
	p.Meta = meta
	p.require(paginatedAnnotationQueuesFieldMeta)
}

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

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

func (p *PaginatedAnnotationQueues) String() string {
	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)
}

var (
	updateAnnotationQueueItemRequestFieldQueueID = big.NewInt(1 << 0)
	updateAnnotationQueueItemRequestFieldItemID  = big.NewInt(1 << 1)
	updateAnnotationQueueItemRequestFieldStatus  = big.NewInt(1 << 2)
)

type UpdateAnnotationQueueItemRequest struct {
	// The unique identifier of the annotation queue
	QueueID string `json:"-" url:"-"`
	// The unique identifier of the annotation queue item
	ItemID string                 `json:"-" url:"-"`
	Status *AnnotationQueueStatus `json:"status,omitempty" url:"-"`

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

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

// SetQueueID sets the QueueID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (u *UpdateAnnotationQueueItemRequest) SetQueueID(queueID string) {
	u.QueueID = queueID
	u.require(updateAnnotationQueueItemRequestFieldQueueID)
}

// SetItemID sets the ItemID field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (u *UpdateAnnotationQueueItemRequest) SetItemID(itemID string) {
	u.ItemID = itemID
	u.require(updateAnnotationQueueItemRequestFieldItemID)
}

// SetStatus sets the Status field and marks it as non-optional;
// this prevents an empty or null value for this field from being omitted during serialization.
func (u *UpdateAnnotationQueueItemRequest) SetStatus(status *AnnotationQueueStatus) {
	u.Status = status
	u.require(updateAnnotationQueueItemRequestFieldStatus)
}

func (u *UpdateAnnotationQueueItemRequest) UnmarshalJSON(data []byte) error {
	type unmarshaler UpdateAnnotationQueueItemRequest
	var body unmarshaler
	if err := json.Unmarshal(data, &body); err != nil {
		return err
	}
	*u = UpdateAnnotationQueueItemRequest(body)
	return nil
}

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