models_serde.go

//go:build go1.18
// +build go1.18

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// Code generated by Microsoft (R) AutoRest Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

package azopenai

import (
	"encoding/json"
	"fmt"
	"reflect"

	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
)

// MarshalJSON implements the json.Marshaller interface for type ErrorResponse.
func (e ErrorResponse) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "error", e.Error)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponse.
func (e *ErrorResponse) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", e, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "error":
			err = unpopulate(val, "Error", &e.Error)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", e, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type ErrorResponseError.
func (e ErrorResponseError) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "code", e.Code)
	populate(objectMap, "message", e.Message)
	populate(objectMap, "param", e.Param)
	populate(objectMap, "type", e.Type)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type ErrorResponseError.
func (e *ErrorResponseError) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", e, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "code":
			err = unpopulate(val, "Code", &e.Code)
			delete(rawMsg, key)
		case "message":
			err = unpopulate(val, "Message", &e.Message)
			delete(rawMsg, key)
		case "param":
			err = unpopulate(val, "Param", &e.Param)
			delete(rawMsg, key)
		case "type":
			err = unpopulate(val, "Type", &e.Type)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", e, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type EmbeddingsCreateParameters.
func (p EmbeddingsCreateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "input", p.Input)
	populate(objectMap, "input_type", p.InputType)
	populate(objectMap, "model", p.Model)
	populate(objectMap, "user", p.User)
	if p.AdditionalProperties != nil {
		for key, val := range p.AdditionalProperties {
			objectMap[key] = val
		}
	}
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type EmbeddingsCreateParameters.
func (p *EmbeddingsCreateParameters) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "input":
			err = unpopulate(val, "Input", &p.Input)
			delete(rawMsg, key)
		case "input_type":
			err = unpopulate(val, "InputType", &p.InputType)
			delete(rawMsg, key)
		case "model":
			err = unpopulate(val, "Model", &p.Model)
			delete(rawMsg, key)
		case "user":
			err = unpopulate(val, "User", &p.User)
			delete(rawMsg, key)
		default:
			if p.AdditionalProperties == nil {
				p.AdditionalProperties = map[string]any{}
			}
			if val != nil {
				var aux any
				err = json.Unmarshal(val, &aux)
				p.AdditionalProperties[key] = aux
			}
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type Embeddings.
func (p Embeddings) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "data", p.Data)
	populate(objectMap, "model", p.Model)
	populate(objectMap, "object", p.Object)
	populate(objectMap, "usage", p.Usage)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type Embeddings.
func (p *Embeddings) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "data":
			err = unpopulate(val, "Data", &p.Data)
			delete(rawMsg, key)
		case "model":
			err = unpopulate(val, "Model", &p.Model)
			delete(rawMsg, key)
		case "object":
			err = unpopulate(val, "Object", &p.Object)
			delete(rawMsg, key)
		case "usage":
			err = unpopulate(val, "Usage", &p.Usage)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type EmbeddingsUsage.
func (p EmbeddingsUsage) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "prompt_tokens", p.PromptTokens)
	populate(objectMap, "total_tokens", p.TotalTokens)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type EmbeddingsUsage.
func (p *EmbeddingsUsage) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "prompt_tokens":
			err = unpopulate(val, "PromptTokens", &p.PromptTokens)
			delete(rawMsg, key)
		case "total_tokens":
			err = unpopulate(val, "TotalTokens", &p.TotalTokens)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type ChatCompletionsChoice.
func (p ChatCompletionsChoice) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "finish_reason", p.FinishReason)
	populate(objectMap, "index", p.Index)
	populate(objectMap, "message", p.Message)
	populate(objectMap, "delta", p.Delta)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type ChatCompletionsChoice.
func (p *ChatCompletionsChoice) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "finish_reason":
			err = unpopulate(val, "FinishReason", &p.FinishReason)
			delete(rawMsg, key)
		case "index":
			err = unpopulate(val, "Index", &p.Index)
			delete(rawMsg, key)
		case "message":
			err = unpopulate(val, "Message", &p.Message)
			delete(rawMsg, key)
		case "delta":
			err = unpopulate(val, "Delta", &p.Delta)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type ChatCompletions.
func (p ChatCompletions) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "choices", p.Choices)
	populateTimeUnix(objectMap, "created", p.Created)
	populate(objectMap, "id", p.ID)
	populate(objectMap, "model", p.Model)
	populate(objectMap, "object", p.Object)
	populate(objectMap, "usage", p.Usage)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type ChatCompletions.
func (p *ChatCompletions) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "choices":
			err = unpopulate(val, "Choices", &p.Choices)
			delete(rawMsg, key)
		case "created":
			err = unpopulateTimeUnix(val, "Created", &p.Created)
			delete(rawMsg, key)
		case "id":
			err = unpopulate(val, "ID", &p.ID)
			delete(rawMsg, key)
		case "model":
			err = unpopulate(val, "Model", &p.Model)
			delete(rawMsg, key)
		case "object":
			err = unpopulate(val, "Object", &p.Object)
			delete(rawMsg, key)
		case "usage":
			err = unpopulate(val, "Usage", &p.Usage)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type ChatCompletionsCreateParameters.
func (p ChatCompletionsCreateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "frequency_penalty", p.FrequencyPenalty)
	populate(objectMap, "logit_bias", p.LogitBias)
	populate(objectMap, "max_tokens", p.MaxTokens)
	populate(objectMap, "messages", p.Messages)
	populate(objectMap, "n", p.N)
	populate(objectMap, "presence_penalty", p.PresencePenalty)
	populate(objectMap, "stop", p.Stop)
	populate(objectMap, "stream", p.Stream)
	populate(objectMap, "temperature", p.Temperature)
	populate(objectMap, "top_p", p.TopP)
	populate(objectMap, "user", p.User)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type ChatCompletionsCreateParameters.
func (p *ChatCompletionsCreateParameters) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "frequency_penalty":
			err = unpopulate(val, "FrequencyPenalty", &p.FrequencyPenalty)
			delete(rawMsg, key)
		case "logit_bias":
			err = unpopulate(val, "LogitBias", &p.LogitBias)
			delete(rawMsg, key)
		case "max_tokens":
			err = unpopulate(val, "MaxTokens", &p.MaxTokens)
			delete(rawMsg, key)
		case "messages":
			err = unpopulate(val, "Messages", &p.Messages)
			delete(rawMsg, key)
		case "n":
			err = unpopulate(val, "N", &p.N)
			delete(rawMsg, key)
		case "presence_penalty":
			err = unpopulate(val, "PresencePenalty", &p.PresencePenalty)
			delete(rawMsg, key)
		case "stop":
			err = unpopulate(val, "Stop", &p.Stop)
			delete(rawMsg, key)
		case "stream":
			err = unpopulate(val, "Stream", &p.Stream)
			delete(rawMsg, key)
		case "temperature":
			err = unpopulate(val, "Temperature", &p.Temperature)
			delete(rawMsg, key)
		case "top_p":
			err = unpopulate(val, "TopP", &p.TopP)
			delete(rawMsg, key)
		case "user":
			err = unpopulate(val, "User", &p.User)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type CompletionsUsage.
func (p CompletionsUsage) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "completion_tokens", p.CompletionTokens)
	populate(objectMap, "prompt_tokens", p.PromptTokens)
	populate(objectMap, "total_tokens", p.TotalTokens)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type CompletionsUsage.
func (p *CompletionsUsage) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "completion_tokens":
			err = unpopulate(val, "CompletionTokens", &p.CompletionTokens)
			delete(rawMsg, key)
		case "prompt_tokens":
			err = unpopulate(val, "PromptTokens", &p.PromptTokens)
			delete(rawMsg, key)
		case "total_tokens":
			err = unpopulate(val, "TotalTokens", &p.TotalTokens)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type CompletionsCreateParameters.
func (p CompletionsCreateParameters) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "best_of", p.BestOf)
	populate(objectMap, "cache_level", p.CacheLevel)
	populate(objectMap, "completion_config", p.CompletionConfig)
	populate(objectMap, "echo", p.Echo)
	populate(objectMap, "frequency_penalty", p.FrequencyPenalty)
	populate(objectMap, "logit_bias", p.LogitBias)
	populate(objectMap, "logprobs", p.Logprobs)
	populate(objectMap, "max_tokens", p.MaxTokens)
	populate(objectMap, "model", p.Model)
	populate(objectMap, "n", p.N)
	populate(objectMap, "presence_penalty", p.PresencePenalty)
	populate(objectMap, "prompt", p.Prompt)
	populate(objectMap, "stop", p.Stop)
	populate(objectMap, "stream", p.Stream)
	populate(objectMap, "suffix", p.Suffix)
	populate(objectMap, "temperature", p.Temperature)
	populate(objectMap, "top_p", p.TopP)
	populate(objectMap, "user", p.User)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type CompletionsCreateParameters.
func (p *CompletionsCreateParameters) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "best_of":
			err = unpopulate(val, "BestOf", &p.BestOf)
			delete(rawMsg, key)
		case "cache_level":
			err = unpopulate(val, "CacheLevel", &p.CacheLevel)
			delete(rawMsg, key)
		case "completion_config":
			err = unpopulate(val, "CompletionConfig", &p.CompletionConfig)
			delete(rawMsg, key)
		case "echo":
			err = unpopulate(val, "Echo", &p.Echo)
			delete(rawMsg, key)
		case "frequency_penalty":
			err = unpopulate(val, "FrequencyPenalty", &p.FrequencyPenalty)
			delete(rawMsg, key)
		case "logit_bias":
			err = unpopulate(val, "LogitBias", &p.LogitBias)
			delete(rawMsg, key)
		case "logprobs":
			err = unpopulate(val, "Logprobs", &p.Logprobs)
			delete(rawMsg, key)
		case "max_tokens":
			err = unpopulate(val, "MaxTokens", &p.MaxTokens)
			delete(rawMsg, key)
		case "model":
			err = unpopulate(val, "Model", &p.Model)
			delete(rawMsg, key)
		case "n":
			err = unpopulate(val, "N", &p.N)
			delete(rawMsg, key)
		case "presence_penalty":
			err = unpopulate(val, "PresencePenalty", &p.PresencePenalty)
			delete(rawMsg, key)
		case "prompt":
			err = unpopulate(val, "Prompt", &p.Prompt)
			delete(rawMsg, key)
		case "stop":
			err = unpopulate(val, "Stop", &p.Stop)
			delete(rawMsg, key)
		case "stream":
			err = unpopulate(val, "Stream", &p.Stream)
			delete(rawMsg, key)
		case "suffix":
			err = unpopulate(val, "Suffix", &p.Suffix)
			delete(rawMsg, key)
		case "temperature":
			err = unpopulate(val, "Temperature", &p.Temperature)
			delete(rawMsg, key)
		case "top_p":
			err = unpopulate(val, "TopP", &p.TopP)
			delete(rawMsg, key)
		case "user":
			err = unpopulate(val, "User", &p.User)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type ChatCompletionsUsage.
func (p ChatCompletionsUsage) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "completion_tokens", p.CompletionTokens)
	populate(objectMap, "prompt_tokens", p.PromptTokens)
	populate(objectMap, "total_tokens", p.TotalTokens)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type ChatCompletionsUsage.
func (p *ChatCompletionsUsage) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "completion_tokens":
			err = unpopulate(val, "CompletionTokens", &p.CompletionTokens)
			delete(rawMsg, key)
		case "prompt_tokens":
			err = unpopulate(val, "PromptTokens", &p.PromptTokens)
			delete(rawMsg, key)
		case "total_tokens":
			err = unpopulate(val, "TotalTokens", &p.TotalTokens)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type EmbeddingsData.
func (p EmbeddingsData) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "embedding", p.Embedding)
	populate(objectMap, "index", p.Index)
	populate(objectMap, "object", p.Object)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type EmbeddingsData.
func (p *EmbeddingsData) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "embedding":
			err = unpopulate(val, "Embedding", &p.Embedding)
			delete(rawMsg, key)
		case "index":
			err = unpopulate(val, "Index", &p.Index)
			delete(rawMsg, key)
		case "object":
			err = unpopulate(val, "Object", &p.Object)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type ChatCompletionsStop.
func (p ChatCompletionsStop) MarshalJSON() ([]byte, error) {
	return json.Marshal(oneOf(p.Text, p.Sequences))
}

// UnmarshalJSON implements the json.Unmarshaller interface for type ChatCompletionsStop.
func (p *ChatCompletionsStop) UnmarshalJSON(data []byte) error {
	return unmarshalOneOf(data, &p.Text, &p.Sequences)
}

// MarshalJSON implements the json.Marshaller interface for type Completions.
func (p Completions) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "choices", p.Choices)
	populate(objectMap, "created", p.Created)
	populate(objectMap, "id", p.ID)
	populate(objectMap, "model", p.Model)
	populate(objectMap, "object", p.Object)
	populate(objectMap, "usage", p.Usage)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type Completions.
func (p *Completions) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "choices":
			err = unpopulate(val, "Choices", &p.Choices)
			delete(rawMsg, key)
		case "created":
			err = unpopulate(val, "Created", &p.Created)
			delete(rawMsg, key)
		case "id":
			err = unpopulate(val, "ID", &p.ID)
			delete(rawMsg, key)
		case "model":
			err = unpopulate(val, "Model", &p.Model)
			delete(rawMsg, key)
		case "object":
			err = unpopulate(val, "Object", &p.Object)
			delete(rawMsg, key)
		case "usage":
			err = unpopulate(val, "Usage", &p.Usage)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type CompletionsChoice.
func (p CompletionsChoice) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "finish_reason", p.FinishReason)
	populate(objectMap, "index", p.Index)
	populate(objectMap, "logprobs", p.Logprobs)
	populate(objectMap, "text", p.Text)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type CompletionsChoice.
func (p *CompletionsChoice) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "finish_reason":
			err = unpopulate(val, "FinishReason", &p.FinishReason)
			delete(rawMsg, key)
		case "index":
			err = unpopulate(val, "Index", &p.Index)
			delete(rawMsg, key)
		case "logprobs":
			err = unpopulate(val, "Logprobs", &p.Logprobs)
			delete(rawMsg, key)
		case "text":
			err = unpopulate(val, "Text", &p.Text)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type EmbeddingsInput.
func (p EmbeddingsInput) MarshalJSON() ([]byte, error) {
	return json.Marshal(oneOf(p.Text, p.Sequences))
}

// UnmarshalJSON implements the json.Unmarshaller interface for type EmbeddingsInput.
func (p *EmbeddingsInput) UnmarshalJSON(data []byte) error {
	return unmarshalOneOf(data, &p.Text, &p.Sequences)
}

// MarshalJSON implements the json.Marshaller interface for type ChatCompletionsMessage.
func (p ChatCompletionsMessage) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "content", p.Content)
	populate(objectMap, "name", p.Name)
	populate(objectMap, "role", p.Role)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type ChatCompletionsMessage.
func (p *ChatCompletionsMessage) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "content":
			err = unpopulate(val, "Content", &p.Content)
			delete(rawMsg, key)
		case "name":
			err = unpopulate(val, "Name", &p.Name)
			delete(rawMsg, key)
		case "role":
			err = unpopulate(val, "Role", &p.Role)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type CompletionsChoiceLogprobs.
func (p CompletionsChoiceLogprobs) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "text_offset", p.TextOffset)
	populate(objectMap, "token_logprobs", p.TokenLogprobs)
	populate(objectMap, "tokens", p.Tokens)
	populate(objectMap, "top_logprobs", p.TopLogprobs)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type CompletionsChoiceLogprobs.
func (p *CompletionsChoiceLogprobs) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "text_offset":
			err = unpopulate(val, "TextOffset", &p.TextOffset)
			delete(rawMsg, key)
		case "token_logprobs":
			err = unpopulate(val, "TokenLogprobs", &p.TokenLogprobs)
			delete(rawMsg, key)
		case "tokens":
			err = unpopulate(val, "Tokens", &p.Tokens)
			delete(rawMsg, key)
		case "top_logprobs":
			err = unpopulate(val, "TopLogprobs", &p.TopLogprobs)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type ChatCompletionsChoiceMessage.
func (p ChatCompletionsChoiceMessage) MarshalJSON() ([]byte, error) {
	objectMap := make(map[string]any)
	populate(objectMap, "content", p.Content)
	populate(objectMap, "role", p.Role)
	return json.Marshal(objectMap)
}

// UnmarshalJSON implements the json.Unmarshaller interface for type ChatCompletionsChoiceMessage.
func (p *ChatCompletionsChoiceMessage) UnmarshalJSON(data []byte) error {
	var rawMsg map[string]json.RawMessage
	if err := json.Unmarshal(data, &rawMsg); err != nil {
		return fmt.Errorf("unmarshalling type %T: %v", p, err)
	}
	for key, val := range rawMsg {
		var err error
		switch key {
		case "content":
			err = unpopulate(val, "Content", &p.Content)
			delete(rawMsg, key)
		case "role":
			err = unpopulate(val, "Role", &p.Role)
			delete(rawMsg, key)
		}
		if err != nil {
			return fmt.Errorf("unmarshalling type %T: %v", p, err)
		}
	}
	return nil
}

// MarshalJSON implements the json.Marshaller interface for type CompletionsPrompt.
func (p CompletionsPrompt) MarshalJSON() ([]byte, error) {
	return json.Marshal(oneOf(p.Text, p.Sequences))
}

// UnmarshalJSON implements the json.Unmarshaller interface for type CompletionsPrompt.
func (p *CompletionsPrompt) UnmarshalJSON(data []byte) error {
	return unmarshalOneOf(data, &p.Text, &p.Sequences)
}

// MarshalJSON implements the json.Marshaller interface for type CompletionsStop.
func (p CompletionsStop) MarshalJSON() ([]byte, error) {
	return json.Marshal(oneOf(p.Text, p.Sequences))
}

// UnmarshalJSON implements the json.Unmarshaller interface for type CompletionsStop.
func (p *CompletionsStop) UnmarshalJSON(data []byte) error {
	return unmarshalOneOf(data, &p.Text, &p.Sequences)
}

func populate(m map[string]any, k string, v any) {
	if v == nil {
		return
	} else if azcore.IsNullValue(v) {
		m[k] = nil
	} else if !reflect.ValueOf(v).IsNil() {
		m[k] = v
	}
}

func unpopulate(data json.RawMessage, fn string, v any) error {
	if data == nil {
		return nil
	}
	if err := json.Unmarshal(data, v); err != nil {
		return fmt.Errorf("struct field %s: %v", fn, err)
	}
	return nil
}

func oneOf[T, M any](single T, multiple []M) any {
	if len(multiple) == 0 {
		return single
	}
	return multiple
}

func unmarshalOneOf[T, M any](data json.RawMessage, single *T, multiple *[]M) error {
	errSingle := json.Unmarshal(data, single)
	if errSingle == nil {
		return nil
	}
	errMultiple := json.Unmarshal(data, multiple)
	if errMultiple == nil {
		return nil
	}
	return fmt.Errorf(
		"unmarshalling type %T: %v and unmarshalling type %T: %v",
		single, errSingle,
		multiple, errMultiple,
	)
}